Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

Code cleanup after successful dashboard to api v2 migration (#6466)

RobertJoonas5e2f1036dab9
diff --git a/assets/js/dashboard/components/sort-button.tsx b/assets/js/dashboard/components/sort-button.tsx
index d184cd9ce1..33c3637c4b 100644
--- a/assets/js/dashboard/components/sort-button.tsx
+++ b/assets/js/dashboard/components/sort-button.tsx
@@ -1,5 +1,5 @@
import React, { ReactNode } from 'react'
-import { cycleSortDirection } from '../hooks/use-order-by-legacy'
+import { cycleSortDirection } from '../hooks/use-metric-order-by'
import { SortDirection } from '../../types/query-api'
import classNames from 'classnames'
diff --git a/assets/js/dashboard/hooks/use-order-by-legacy.test.ts b/assets/js/dashboard/hooks/use-order-by-legacy.test.ts
deleted file mode 100644
index 9b663b5392..0000000000
--- a/assets/js/dashboard/hooks/use-order-by-legacy.test.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-import { Metric } from '../stats/reports/metrics'
-import {
- OrderBy,
- cycleSortDirection,
- findOrderIndex,
- getOrderByStorageKey,
- getStoredOrderBy,
- maybeStoreOrderBy,
- rearrangeOrderBy,
- validateOrderBy
-} from './use-order-by-legacy'
-
-describe(`${findOrderIndex.name}`, () => {
- /* prettier-ignore */
- const cases: [OrderBy, Pick<Metric, 'key'>, number][] = [
- [[], { key: 'anything' }, -1],
- [[['visitors', 'asc']], { key: 'anything' }, -1],
- [[['bounce_rate', 'desc'], ['visitors', 'asc']], {key: 'bounce_rate'}, 0],
- [[['bounce_rate', 'desc'], ['visitors', 'asc']], {key: 'visitors'}, 1]
- ]
-
- test.each(cases)(
- `[%#] in order by %p, the index of metric %p is %p`,
- (orderBy, metric, expectedIndex) => {
- expect(findOrderIndex(orderBy, metric)).toEqual(expectedIndex)
- }
- )
-})
-
-describe(`${cycleSortDirection.name}`, () => {
- test.each([
- [
- null,
- {
- direction: 'desc',
- hint: 'Press to sort column in descending order'
- }
- ],
- [
- 'desc',
- {
- direction: 'asc',
- hint: 'Press to sort column in ascending order'
- }
- ],
- [
- 'asc',
- {
- direction: 'desc',
- hint: 'Press to sort column in descending order'
- }
- ]
- ] as const)(
- 'for current direction %p returns %p',
- (currentDirection, expectedOutput) => {
- expect(cycleSortDirection(currentDirection)).toEqual(expectedOutput)
- }
- )
-})
-
-describe(`${rearrangeOrderBy.name}`, () => {
- const cases: [Pick<Metric, 'key'>, OrderBy, OrderBy][] = [
- [{ key: 'visitors' }, [['visitors', 'asc']], [['visitors', 'desc']]],
- [{ key: 'visitors' }, [['visitors', 'desc']], [['visitors', 'asc']]],
- [
- { key: 'visit_duration' },
- [['visitors', 'asc']],
- [['visit_duration', 'desc']]
- ]
- ]
- it.each(cases)(
- `[%#] clicking on %p yields expected order`,
- (metric, currentOrderBy, expectedOrderBy) => {
- expect(rearrangeOrderBy(currentOrderBy, metric)).toEqual(expectedOrderBy)
- }
- )
-})
-
-describe(`${validateOrderBy.name}`, () => {
- test.each([
- [false, '', []],
- [false, [], []],
- [false, [['a']], [{ key: 'a' }]],
- [false, [['a', 'b']], [{ key: 'a' }]],
- [
- false,
- [
- ['a', 'desc'],
- ['a', 'asc']
- ],
- [{ key: 'a' }]
- ],
- [true, [['a', 'desc']], [{ key: 'a' }]]
- ])(
- '[%#] returns %p given input %p and sortable metrics %p',
- (expected, input, sortableMetrics) => {
- expect(validateOrderBy(input, sortableMetrics)).toBe(expected)
- }
- )
-})
-
-describe(`storing detailed report preferred order`, () => {
- const domain = 'any-domain'
- const reportInfo = { dimensionLabel: 'Goal' }
-
- it('does not store invalid value', () => {
- maybeStoreOrderBy({
- orderBy: [['foo', 'desc']],
- domain,
- reportInfo,
- metrics: [{ key: 'foo', sortable: false }]
- })
- expect(localStorage.getItem(getOrderByStorageKey(domain, reportInfo))).toBe(
- null
- )
- })
-
- it('falls back to fallbackValue if metric has become unsortable between storing and retrieving', () => {
- maybeStoreOrderBy({
- orderBy: [['c', 'desc']],
- domain,
- reportInfo,
- metrics: [{ key: 'c', sortable: true }]
- })
- const inStorage = localStorage.getItem(
- getOrderByStorageKey(domain, reportInfo)
- )
- expect(inStorage).toBe('[["c","desc"]]')
- expect(
- getStoredOrderBy({
- domain,
- reportInfo,
- metrics: [{ key: 'c', sortable: false }],
- fallbackValue: [['visitors', 'desc']]
- })
- ).toEqual([['visitors', 'desc']])
- })
-
- it('retrieves stored value correctly', () => {
- const input = [['any-column', 'asc']]
- localStorage.setItem(
- getOrderByStorageKey(domain, reportInfo),
- JSON.stringify(input)
- )
- expect(
- getStoredOrderBy({
- domain,
- reportInfo,
- metrics: [{ key: 'any-column', sortable: true }],
- fallbackValue: [['visitors', 'desc']]
- })
- ).toEqual(input)
- })
-})
diff --git a/assets/js/dashboard/hooks/use-order-by-legacy.ts b/assets/js/dashboard/hooks/use-order-by-legacy.ts
deleted file mode 100644
index f5d22365a1..0000000000
--- a/assets/js/dashboard/hooks/use-order-by-legacy.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { Metric } from '../stats/reports/metrics'
-import { getDomainScopedStorageKey, getItem, setItem } from '../util/storage'
-import { useSiteContext } from '../site-context'
-import { ReportInfo } from '../stats/modals/breakdown-modal-legacy'
-import { SortDirection } from '../../types/query-api'
-
-export type Order = [Metric['key'], SortDirection]
-
-export type OrderBy = Order[]
-
-export const getSortDirectionLabel = (sortDirection: SortDirection): string =>
- ({
- asc: 'Sorted in ascending order',
- desc: 'Sorted in descending order'
- })[sortDirection]
-
-export function useOrderBy({
- metrics,
- defaultOrderBy
-}: {
- metrics: Pick<Metric, 'key'>[]
- defaultOrderBy: OrderBy
-}) {
- const [orderBy, setOrderBy] = useState<OrderBy>([])
- const orderByDictionary: Record<Metric['key'], SortDirection> = useMemo(
- () =>
- orderBy.length
- ? Object.fromEntries(orderBy)
- : Object.fromEntries(defaultOrderBy),
- [orderBy, defaultOrderBy]
- )
-
- const toggleSortByMetric = useCallback(
- (metric: Pick<Metric, 'key'>) => {
- if (!metrics.find(({ key }) => key === metric.key)) {
- return
- }
- setOrderBy((currentOrderBy) =>
- rearrangeOrderBy(
- currentOrderBy.length ? currentOrderBy : defaultOrderBy,
- metric
- )
- )
- },
- [metrics, defaultOrderBy]
- )
-
- return {
- orderBy: orderBy.length ? orderBy : defaultOrderBy,
- orderByDictionary,
- toggleSortByMetric
- }
-}
-
-export function cycleSortDirection(
- currentSortDirection: SortDirection | null
-): { direction: SortDirection; hint: string } {
- if (currentSortDirection === 'desc') {
- return {
- direction: 'asc',
- hint: 'Press to sort column in ascending order'
- }
- }
-
- return {
- direction: 'desc',
- hint: 'Press to sort column in descending order'
- }
-}
-
-export function findOrderIndex(orderBy: OrderBy, metric: Pick<Metric, 'key'>) {
- return orderBy.findIndex(([metricKey]) => metricKey === metric.key)
-}
-
-export function rearrangeOrderBy(
- currentOrderBy: OrderBy,
- metric: Pick<Metric, 'key'>
-): OrderBy {
- const orderIndex = findOrderIndex(currentOrderBy, metric)
- if (orderIndex < 0) {
- const sortDirection = cycleSortDirection(null).direction
- return [[metric.key, sortDirection]]
- }
- const previousOrder = currentOrderBy[orderIndex]
- const sortDirection = cycleSortDirection(previousOrder[1]).direction
- if (sortDirection === null) {
- return []
- }
- return [[metric.key, sortDirection]]
-}
-
-export function getOrderByStorageKey(
- domain: string,
- reportInfo: Pick<ReportInfo, 'dimensionLabel'>
-) {
- const storageKey = getDomainScopedStorageKey(
- `order_${reportInfo.dimensionLabel}_by`,
- domain
- )
- return storageKey
-}
-
-export function validateOrderBy(
- orderBy: unknown,
- metrics: Pick<Metric, 'key'>[]
-): orderBy is OrderBy {
- if (!Array.isArray(orderBy)) {
- return false
- }
- if (orderBy.length !== 1) {
- return false
- }
- if (!Array.isArray(orderBy[0])) {
- return false
- }
- if (
- orderBy[0].length === 2 &&
- metrics.findIndex((m) => m.key === orderBy[0][0]) > -1 &&
- ['asc', 'desc'].includes(orderBy[0][1])
- ) {
- return true
- }
- return false
-}
-
-export function getStoredOrderBy({
- domain,
- reportInfo,
- metrics,
- fallbackValue
-}: {
- domain: string
- reportInfo: Pick<ReportInfo, 'dimensionLabel'>
- metrics: Pick<Metric, 'key' | 'sortable'>[]
- fallbackValue: OrderBy
-}): OrderBy {
- try {
- const storedItem = getItem(getOrderByStorageKey(domain, reportInfo))
- const parsed = JSON.parse(storedItem)
- if (
- validateOrderBy(
- parsed,
- metrics.filter((m) => m.sortable)
- )
- ) {
- return parsed
- } else {
- throw new Error('Invalid stored order_by value')
- }
- } catch (_e) {
- return fallbackValue
- }
-}
-
-export function maybeStoreOrderBy({
- domain,
- reportInfo,
- metrics,
- orderBy
-}: {
- domain: string
- reportInfo: Pick<ReportInfo, 'dimensionLabel'>
- metrics: Pick<Metric, 'key' | 'sortable'>[]
- orderBy: OrderBy
-}) {
- if (
- validateOrderBy(
- orderBy,
- metrics.filter((m) => m.sortable)
- )
- ) {
- setItem(getOrderByStorageKey(domain, reportInfo), JSON.stringify(orderBy))
- }
-}
-
-export function useRememberOrderBy({
- effectiveOrderBy,
- metrics,
- reportInfo
-}: {
- effectiveOrderBy: OrderBy
- metrics: Pick<Metric, 'key' | 'sortable'>[]
- reportInfo: Pick<ReportInfo, 'dimensionLabel'>
-}) {
- const site = useSiteContext()
-
- useEffect(() => {
- maybeStoreOrderBy({
- domain: site.domain,
- metrics,
- reportInfo,
- orderBy: effectiveOrderBy
- })
- }, [site, reportInfo, effectiveOrderBy, metrics])
-}
diff --git a/assets/js/dashboard/index.tsx b/assets/js/dashboard/index.tsx
index 9b3dc4e9ef..1736f963d2 100644
--- a/assets/js/dashboard/index.tsx
+++ b/assets/js/dashboard/index.tsx
@@ -2,7 +2,7 @@ import React, { useMemo, useState } from 'react'
import VisitorGraph from './stats/graph/visitor-graph'
import Sources from './stats/sources'
import Pages from './stats/pages'
-import Locations from './stats/locations'
+import { Locations } from './stats/locations'
import { Devices } from './stats/devices'
import { TopBar } from './nav-menu/top-bar'
import Behaviours from './stats/behaviours'
diff --git a/assets/js/dashboard/nav-menu/dashboard-options-menu.tsx b/assets/js/dashboard/nav-menu/dashboard-options-menu.tsx
index 8c640da218..8c57eb5fb7 100644
--- a/assets/js/dashboard/nav-menu/dashboard-options-menu.tsx
+++ b/assets/js/dashboard/nav-menu/dashboard-options-menu.tsx
@@ -1,11 +1,7 @@
import React, { useEffect, useRef, useState } from 'react'
import { Popover, Transition } from '@headlessui/react'
-import {
- EllipsisVerticalIcon,
- ArrowDownTrayIcon
-} from '@heroicons/react/24/outline'
+import { EllipsisVerticalIcon } from '@heroicons/react/24/outline'
import { Toggle } from '../components/toggle'
-import { Spinner } from '../components/icons'
import classNames from 'classnames'
import { popover, BlurMenuButtonOnEscape } from '../components/popover'
import { useGraphIntervalContext } from '../stats/graph/graph-interval-context'
@@ -14,57 +10,11 @@ import { useDashboardStateContext } from '../dashboard-state-context'
import { DashboardPeriod } from '../dashboard-time-periods'
import { IntervalPicker } from '../stats/graph/interval-picker'
import { AppNavigationLink } from '../navigation/use-app-navigate'
-import { useSiteContext } from '../site-context'
-import * as api from '../api'
import { Notice } from '../components/notice'
import { isModifierPressed, isTyping, Keybind } from '../keybinding'
import { useMatch } from 'react-router-dom'
import { rootRoute } from '../router'
-import { CsvExportV2, ExportStatus } from '../stats/csv-export/csv-export'
-
-function ExportItem({ selectedInterval }: { selectedInterval: string }) {
- const site = useSiteContext()
- const { dashboardState } = useDashboardStateContext()
- const [exporting, setExporting] = useState(false)
-
- function pollExportReady() {
- if (document.cookie.includes('exporting')) {
- setTimeout(pollExportReady, 1000)
- } else {
- setExporting(false)
- }
- }
-
- function startExport() {
- setExporting(true)
- document.cookie = 'exporting='
- pollExportReady()
- }
-
- const params = api.dashboardStateToSearchParams(dashboardState, [
- { interval: selectedInterval, comparison: undefined }
- ])
- const endpoint = `/${encodeURIComponent(site.domain)}/export?${params}`
-
- return (
- <a
- href={endpoint}
- download
- onClick={startExport}
- className={classNames(
- popover.items.classNames.navigationLink,
- popover.items.classNames.hoverLink
- )}
- >
- <span className="text-sm">Export stats</span>
- {exporting ? (
- <Spinner className="animate-spin size-4 text-indigo-500" />
- ) : (
- <ArrowDownTrayIcon className="size-4 stroke-2" />
- )}
- </a>
- )
-}
+import { CsvExport, ExportStatus } from '../stats/csv-export/csv-export'
function ImportedSwitchItem({ disabled }: { disabled: boolean }) {
const { dashboardState } = useDashboardStateContext()
@@ -92,7 +42,6 @@ function ImportedSwitchItem({ disabled }: { disabled: boolean }) {
}
function DashboardOptionsMenuItems() {
- const site = useSiteContext()
const { dashboardState } = useDashboardStateContext()
const { selectedInterval, onIntervalClick, availableIntervals } =
useGraphIntervalContext()
@@ -158,14 +107,10 @@ function DashboardOptionsMenuItems() {
options={availableIntervals}
/>
)}
- {site.flags.dashboard_csv_export_v2 ? (
- <CsvExportV2
- exportStatus={exportStatus}
- setExportStatus={setExportStatus}
- />
- ) : (
- <ExportItem selectedInterval={selectedInterval} />
- )}
+ <CsvExport
+ exportStatus={exportStatus}
+ setExportStatus={setExportStatus}
+ />
{imports.status === 'visible' && (
<>
<ImportedSwitchItem disabled={imports.disabled} />
diff --git a/assets/js/dashboard/site-context.test.tsx b/assets/js/dashboard/site-context.test.tsx
index 5822549247..13ddfea577 100644
--- a/assets/js/dashboard/site-context.test.tsx
+++ b/assets/js/dashboard/site-context.test.tsx
@@ -32,7 +32,7 @@ describe('parseSiteFromDataset', () => {
data-is-dbip="false"
data-current-user-role="owner"
data-current-user-id="1"
- data-flags='{"dashboard_csv_export_v2": false}'
+ data-flags="{}"
data-valid-intervals-by-period='{"12mo":["day","week","month"],"7d":["hour","day"],"28d":["day","week"],"30d":["day","week"],"91d":["day","week","month"],"6mo":["day","week","month"],"all":["week","month"],"custom":["day","week","month"],"day":["minute","hour"],"month":["day","week"],"realtime":["minute"],"year":["day","week","month"]}'
{...attrs}
/>
@@ -58,7 +58,7 @@ describe('parseSiteFromDataset', () => {
embedded: false,
background: undefined,
isDbip: false,
- flags: { dashboard_csv_export_v2: false },
+ flags: {},
shared: false,
isConsolidatedView: false
}
diff --git a/assets/js/dashboard/site-context.tsx b/assets/js/dashboard/site-context.tsx
index 2e61d5e9be..a7ea4d3fc8 100644
--- a/assets/js/dashboard/site-context.tsx
+++ b/assets/js/dashboard/site-context.tsx
@@ -32,7 +32,7 @@ export function parseSiteFromDataset(dataset: DOMStringMap): PlausibleSite {
}
// Update this object when new feature flags are added to the frontend.
-type FeatureFlags = Record<'dashboard_csv_export_v2', boolean>
+type FeatureFlags = Record<never, boolean>
export const siteContextDefaultValue = {
domain: '',
diff --git a/assets/js/dashboard/stats/csv-export/csv-export.test.tsx b/assets/js/dashboard/stats/csv-export/csv-export.test.tsx
index 5f601a0c6b..abd36300e4 100644
--- a/assets/js/dashboard/stats/csv-export/csv-export.test.tsx
+++ b/assets/js/dashboard/stats/csv-export/csv-export.test.tsx
@@ -2,7 +2,7 @@ import React from 'react'
import { render, screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { TestContextProviders } from '../../../../test-utils/app-context-providers'
-import { CsvExportV2, ExportStatus } from './csv-export'
+import { CsvExport, ExportStatus } from './csv-export'
const exportButton = () => screen.getByRole('button', { name: /export stats/i })
@@ -14,17 +14,9 @@ function renderCsvExport({
setExportStatus: () => void
}) {
render(
- <CsvExportV2
- exportStatus={exportStatus}
- setExportStatus={setExportStatus}
- />,
+ <CsvExport exportStatus={exportStatus} setExportStatus={setExportStatus} />,
{
- wrapper: (props) => (
- <TestContextProviders
- {...props}
- siteOptions={{ flags: { dashboard_csv_export_v2: true } }}
- />
- )
+ wrapper: (props) => <TestContextProviders {...props} />
}
)
}
diff --git a/assets/js/dashboard/stats/csv-export/csv-export.tsx b/assets/js/dashboard/stats/csv-export/csv-export.tsx
index 05f52534f0..f0d1853615 100644
--- a/assets/js/dashboard/stats/csv-export/csv-export.tsx
+++ b/assets/js/dashboard/stats/csv-export/csv-export.tsx
@@ -21,7 +21,7 @@ export enum ExportStatus {
error = 'error'
}
-export function CsvExportV2({
+export function CsvExport({
exportStatus,
setExportStatus
}: {
diff --git a/assets/js/dashboard/stats/locations/map.tsx b/assets/js/dashboard/stats/locations/map.tsx
index f773bfbd78..2f52fff787 100644
--- a/assets/js/dashboard/stats/locations/map.tsx
+++ b/assets/js/dashboard/stats/locations/map.tsx
@@ -12,7 +12,7 @@ import { numberShortFormatter } from '../../util/number-formatter'
import { useSiteContext } from '../../site-context'
import { useDashboardStateContext } from '../../dashboard-state-context'
import { UIMode, useTheme } from '../../theme-context'
-import { MIN_HEIGHT } from '../reports/list-legacy'
+import { MIN_HEIGHT } from '../reports/index-breakdown'
import { MapTooltip } from './map-tooltip'
import { GeolocationNotice } from './geolocation-notice'
import { DashboardState } from '../../dashboard-state'
diff --git a/assets/js/dashboard/stats/modals/breakdown-modal-legacy.test.tsx b/assets/js/dashboard/stats/modals/breakdown-modal-legacy.test.tsx
deleted file mode 100644
index c91d055dad..0000000000
--- a/assets/js/dashboard/stats/modals/breakdown-modal-legacy.test.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import React, { useState, Dispatch, SetStateAction } from 'react'
-import { act, render, screen } from '@testing-library/react'
-import { TestContextProviders } from '../../../../test-utils/app-context-providers'
-import BreakdownModal from './breakdown-modal-legacy'
-import Modal from './modal'
-import { createVisitors } from '../reports/metrics'
-import { MockAPI } from '../../../../test-utils/mock-api'
-
-const domain = 'dummy.site'
-const endpoint = `/api/stats/${domain}/test-dimension/`
-
-const reportInfo = {
- title: 'Test breakdown',
- endpoint,
- dimensionLabel: 'Test',
- defaultOrder: ['visitors', 'desc'] as ['visitors', 'desc']
-}
-
-const metrics = [createVisitors({ renderLabel: () => 'Visitors' })]
-
-let mockAPI: MockAPI
-
-beforeAll(() => {
- mockAPI = new MockAPI().start()
-})
-
-afterAll(() => {
- mockAPI.stop()
-})
-
-beforeEach(() => {
- mockAPI.clear()
-})
-
-beforeEach(() => {
- const modalRoot = document.createElement('div')
- modalRoot.setAttribute('id', 'modal_root')
- document.body.appendChild(modalRoot)
-})
-
-afterEach(() => {
- document.getElementById('modal_root')?.remove()
-})
-
-describe('BreakdownModal', () => {
- test('opening the modal for a second time with the same dashboardState gets response from cache', async () => {
- const response = {
- results: [],
- meta: { date_range_label: 'Last 30 days', metric_warnings: undefined }
- }
-
- const handler = mockAPI.get(endpoint, response)
-
- let setOpen: Dispatch<SetStateAction<boolean>>
-
- function ToggleableModal() {
- const [open, s] = useState(false)
- setOpen = s
- return open ? (
- <Modal>
- <BreakdownModal
- reportInfo={reportInfo}
- metrics={metrics}
- getFilterInfo={() => null}
- />
- </Modal>
- ) : null
- }
-
- render(
- <TestContextProviders siteOptions={{ domain }}>
- <ToggleableModal />
- </TestContextProviders>
- )
-
- expect(handler).toHaveBeenCalledTimes(0)
- act(() => setOpen(true))
- expect(screen.getByText('Test breakdown')).toBeVisible()
- expect(handler).toHaveBeenCalledTimes(1)
- expect(handler).toHaveBeenNthCalledWith(
- 1,
- expect.stringContaining(
- 'order_by=%5B%5B%22visitors%22%2C%22desc%22%5D%5D&limit=100&page=1'
- ),
- expect.anything()
- )
-
- act(() => setOpen(false))
- expect(screen.queryByText('Test breakdown')).not.toBeInTheDocument()
- act(() => setOpen(true))
- expect(screen.getByText('Test breakdown')).toBeVisible()
-
- expect(handler).toHaveBeenCalledTimes(1)
- })
-})
diff --git a/assets/js/dashboard/stats/modals/breakdown-modal-legacy.tsx b/assets/js/dashboard/stats/modals/breakdown-modal-legacy.tsx
deleted file mode 100644
index 30a71007e2..0000000000
--- a/assets/js/dashboard/stats/modals/breakdown-modal-legacy.tsx
+++ /dev/null
@@ -1,273 +0,0 @@
-import React, { useState, ReactNode, useMemo } from 'react'
-
-import { useDashboardStateContext } from '../../dashboard-state-context'
-import { usePaginatedGetAPI } from '../../hooks/api-client'
-import { rootRoute } from '../../router'
-import {
- getStoredOrderBy,
- Order,
- OrderBy,
- useOrderBy,
- useRememberOrderBy
-} from '../../hooks/use-order-by-legacy'
-import { Metric } from '../reports/metrics'
-import * as metricsModule from '../reports/metrics'
-import { BreakdownResultMeta, DashboardState } from '../../dashboard-state'
-import { ColumnConfiguraton } from '../../components/table-legacy'
-import { BreakdownTable } from './breakdown-table-legacy'
-import { useSiteContext } from '../../site-context'
-import { DrilldownLink, FilterInfo } from '../../components/drilldown-link'
-import { SharedReportProps } from '../reports/list-legacy'
-import { hasConversionGoalFilter } from '../../util/filters'
-
-export type ReportInfo = {
- /** Title of the report to render on the top left. */
- title: string
- /** Full pathname of the API endpoint to query. @example `/api/stats/plausible.io/sources` */
- endpoint: string
- /** Used as the leftmost column header. */
- dimensionLabel: string
- /** What this report will be initially sorted by. @example ["visitors", "desc"] */
- defaultOrder?: Order
-}
-
-type BreakdownModalProps = {
- /** Dimension and title of the breakdown. */
- reportInfo: ReportInfo
- /** Function that must return a new dashboardState that contains appropriate search filter for searchValue param. */
- addSearchFilter?: (q: DashboardState, searchValue: string) => DashboardState
- searchEnabled?: boolean
- /** When true, keep the percentage metric as a permanently visible, sortable column. */
- showPercentageColumn?: boolean
-}
-
-/**
- BreakdownModal is for rendering the "Details" reports on the dashboard,
- i.e. a breakdown by a single (non-time) dimension, with a given set of metrics.
-
- BreakdownModal is expected to be rendered inside a `<Modal>`, which has it's own
- specific URL pathname (e.g. /plausible.io/sources). During the lifecycle of a
- BreakdownModal, the `dashboardState` object is not expected to change.
-
- ### Search As You Type
- @see BreakdownTable
-
- ### Filter Links
- @see NameCell
-
- ### Pagination
- @see usePaginatedGetAPI
-
-*/
-
-export default function BreakdownModal<TListItem extends { name: string }>({
- reportInfo,
- metrics,
- renderIcon,
- getExternalLinkUrl,
- searchEnabled = true,
- showPercentageColumn = false,
- afterFetchData,
- afterFetchNextPage,
- addSearchFilter,
- getFilterInfo
-}: Omit<SharedReportProps<TListItem>, 'fetchData'> & BreakdownModalProps) {
- const site = useSiteContext()
- const { dashboardState } = useDashboardStateContext()
- const [meta, setMeta] = useState<BreakdownResultMeta | null>(null)
-
- const breakdownMetrics = useMemo(() => {
- const hasPercentage = metrics.some((m) => m.key === 'percentage')
- if (!hasPercentage && !hasConversionGoalFilter(dashboardState)) {
- return [...metrics, metricsModule.createPercentage()]
- }
- return metrics
- }, [metrics, dashboardState])
-
- const [search, setSearch] = useState('')
- const defaultOrderBy = getStoredOrderBy({
- domain: site.domain,
- reportInfo,
- metrics: breakdownMetrics,
- fallbackValue: reportInfo.defaultOrder ? [reportInfo.defaultOrder] : []
- })
- const { orderBy, orderByDictionary, toggleSortByMetric } = useOrderBy({
- metrics: breakdownMetrics,
- defaultOrderBy
- })
- useRememberOrderBy({
- effectiveOrderBy: orderBy,
- metrics: breakdownMetrics,
- reportInfo
- })
- const apiState = usePaginatedGetAPI<
- { results: Array<TListItem>; meta: BreakdownResultMeta },
- [
- string,
- { dashboardState: DashboardState; search: string; orderBy: OrderBy }
- ]
- >({
- siteTimezoneOffset: site.offset,
- siteStatsBegin: site.statsBegin,
- key: [reportInfo.endpoint, { dashboardState, search, orderBy }],
- getRequestParams: (key) => {
- const [_endpoint, { dashboardState, search }] = key
-
- let dashboardStateWithSearchFilter = { ...dashboardState }
-
- if (
- searchEnabled &&
- typeof addSearchFilter === 'function' &&
- search !== ''
- ) {
- dashboardStateWithSearchFilter = addSearchFilter(dashboardState, search)
- }
-
- return [
- dashboardStateWithSearchFilter,
- {
- detailed: true,
- order_by: JSON.stringify(orderBy)
- }
- ]
- },
- afterFetchData: (response) => {
- setMeta(response.meta)
- afterFetchData?.(response)
- },
- afterFetchNextPage
- })
-
- const columns: ColumnConfiguraton<TListItem>[] = useMemo(
- () => [
- {
- label: reportInfo.dimensionLabel,
- key: 'name',
- width: 'w-40 md:w-48',
- align: 'left',
- renderItem: (item) => (
- <NameCell
- item={item}
- getFilterInfo={getFilterInfo}
- getExternalLinkUrl={getExternalLinkUrl}
- renderIcon={renderIcon}
- />
- )
- },
- ...breakdownMetrics
- .filter((m) => showPercentageColumn || m.key !== 'percentage')
- .map(
- (m): ColumnConfiguraton<TListItem> => ({
- label: m.renderLabel(dashboardState),
- key: m.key,
- width: m.width,
- align: 'right',
- metricWarning: getMetricWarning(m, meta),
- renderValue: (item, isRowHovered) =>
- m.renderValue(
- showPercentageColumn && m.key === 'visitors'
- ? { ...item, percentage: null }
- : item,
- meta,
- { detailedView: true, isRowHovered }
- ),
- onSort: m.sortable ? () => toggleSortByMetric(m) : undefined,
- sortDirection: orderByDictionary[m.key]
- })
- )
- ],
- [
- reportInfo.dimensionLabel,
- breakdownMetrics,
- getFilterInfo,
- dashboardState,
- orderByDictionary,
- toggleSortByMetric,
- renderIcon,
- getExternalLinkUrl,
- meta,
- showPercentageColumn
- ]
- )
-
- return (
- <BreakdownTable<TListItem>
- title={reportInfo.title}
- {...apiState}
- onSearch={searchEnabled ? setSearch : undefined}
- columns={columns}
- />
- )
-}
-
-/**
- * Most interactive cell in the breakdown table.
- * May have an icon.
- * If `getFilterInfo(item)` does not return null,
- * drills down the dashboard to that particular item.
- * May have a tiny icon button to navigate to the actual resource.
- * */
-const NameCell = <TListItem extends { name: string }>({
- item,
- getFilterInfo,
- renderIcon,
- getExternalLinkUrl
-}: {
- item: TListItem
- getFilterInfo: (item: TListItem) => FilterInfo | null
- renderIcon?: (item: TListItem) => ReactNode
- getExternalLinkUrl?: (listItem: TListItem) => string
-}) => (
- <div className="max-w-full break-all flex items-center">
- {typeof renderIcon === 'function' && renderIcon(item)}
- <DrilldownLink
- path={rootRoute.path}
- filterInfo={getFilterInfo(item)}
- onClick={undefined}
- className={undefined}
- >
- {item.name}
- </DrilldownLink>
- {typeof getExternalLinkUrl === 'function' && (
- <ExternalLinkIcon url={getExternalLinkUrl(item)} />
- )}
- </div>
-)
-
-const ExternalLinkIcon = ({ url }: { url?: string }) =>
- url ? (
- <a
- target="_blank"
- href={url}
- rel="noreferrer"
- className="hidden group-hover:block"
- >
- <svg
- className="inline h-4 w-4 ml-1 -mt-1 text-gray-600 dark:text-gray-400"
- fill="currentColor"
- viewBox="0 0 20 20"
- >
- <path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z"></path>
- <path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z"></path>
- </svg>
- </a>
- ) : null
-
-const getMetricWarning = (metric: Metric, meta: BreakdownResultMeta | null) => {
- const warnings = meta?.metric_warnings
-
- if (warnings && warnings[metric.key]) {
- const { code, message } = warnings[metric.key]
-
- if (metric.key == 'bounce_rate' && code == 'no_imported_bounce_rate') {
- return 'Does not include imported data'
- }
- if (metric.key == 'scroll_depth' && code == 'no_imported_scroll_depth') {
- return 'Does not include imported data'
- }
-
- if (metric.key == 'time_on_page' && code) {
- return message
- }
- }
-}
diff --git a/assets/js/dashboard/stats/modals/breakdown-table-legacy.tsx b/assets/js/dashboard/stats/modals/breakdown-table-legacy.tsx
deleted file mode 100644
index 18ca9cde25..0000000000
--- a/assets/js/dashboard/stats/modals/breakdown-table-legacy.tsx
+++ /dev/null
@@ -1,134 +0,0 @@
-import React, { ReactNode, useRef } from 'react'
-import { XMarkIcon } from '@heroicons/react/20/solid'
-
-import { SearchInput } from '../../components/search-input'
-import { ColumnConfiguraton, Table } from '../../components/table-legacy'
-import RocketIcon from './rocket-icon'
-import { QueryStatus } from '@tanstack/react-query'
-import { useAppNavigate } from '../../navigation/use-app-navigate'
-import { rootRoute } from '../../router'
-
-export const BreakdownTable = <TListItem extends { name: string }>({
- title,
- isPending,
- isFetching,
- onSearch,
- hasNextPage,
- isFetchingNextPage,
- fetchNextPage,
- columns,
- data,
- status,
- error,
- displayError,
- onClose
-}: {
- title: ReactNode
- onSearch?: (input: string) => void
- isPending: boolean
- isFetching: boolean
- hasNextPage: boolean
- isFetchingNextPage: boolean
- fetchNextPage: () => void
- columns: ColumnConfiguraton<TListItem>[]
- data?: { pages: TListItem[][] }
- status?: QueryStatus
- error?: Error | null
- /** Controls whether the component displays API request errors or ignores them. */
- displayError?: boolean
- onClose?: () => void
-}) => {
- const searchRef = useRef<HTMLInputElement>(null)
- const navigate = useAppNavigate()
- const handleClose =
- onClose ?? (() => navigate({ path: rootRoute.path, search: (s) => s }))
-
- return (
- <div className="min-h-[66vh] md:min-h-120 flex flex-col flex-1">
- <div className="flex justify-between items-center gap-4">
- <div className="flex items-center gap-4 w-full">
- <h1 className="shrink-0 mb-0.5 text-base md:text-lg font-bold dark:text-gray-100">
- {title}
- </h1>
- {!!onSearch && (
- <SearchInput
- searchRef={searchRef}
- onSearch={onSearch}
- className={
- displayError && status === 'error'
- ? '[&_input]:pointer-events-none'
- : ''
- }
- />
- )}
- {!isPending && isFetching && <SmallLoadingSpinner />}
- </div>
- <button
- type="button"
- onClick={handleClose}
- aria-label="Close modal"
- className="text-gray-400 hover:text-gray-600 dark:text-gray-500 dark:hover:text-gray-300"
- >
- <XMarkIcon className="size-5" />
- </button>
- </div>
- <div className="my-3 md:my-4 border-b border-gray-250 dark:border-gray-750"></div>
- <div className="flex-1 overflow-auto pr-4 -mr-4">
- {displayError && status === 'error' && <ErrorMessage error={error} />}
- {isPending && <InitialLoadingSpinner />}
- {data && <Table<TListItem> data={data} columns={columns} />}
- {!isPending && !isFetching && hasNextPage && (
- <LoadMore
- onClick={() => fetchNextPage()}
- isFetchingNextPage={isFetchingNextPage}
- />
- )}
- </div>
- </div>
- )
-}
-
-const InitialLoadingSpinner = () => (
- <div className="w-full h-full flex flex-col justify-center">
- <div className="mx-auto loading">
- <div />
- </div>
- </div>
-)
-
-const SmallLoadingSpinner = () => (
- <div className="loading sm">
- <div />
- </div>
-)
-
-const ErrorMessage = ({ error }: { error?: unknown }) => (
- <div className="grid grid-rows-2 text-gray-700 dark:text-gray-300">
- <div className="text-center self-end">
- <RocketIcon />
- </div>
- <div className="text-lg text-center">
- {error
- ? (error as { message: string }).message
- : 'Error loading data. Refresh the page to try again'}
- </div>
- </div>
-)
-
-const LoadMore = ({
- onClick,
- isFetchingNextPage
-}: {
- onClick: () => void
- isFetchingNextPage: boolean
-}) => (
- <div className="flex flex-col w-full my-4 items-center justify-center h-10">
- {isFetchingNextPage ? (
- <SmallLoadingSpinner />
- ) : (
- <button onClick={onClick} type="button" className="button">
- Load more
- </button>
- )}
- </div>
-)
diff --git a/assets/js/dashboard/stats/reports/list-legacy.tsx b/assets/js/dashboard/stats/reports/list-legacy.tsx
deleted file mode 100644
index 3b913d84bc..0000000000
--- a/assets/js/dashboard/stats/reports/list-legacy.tsx
+++ /dev/null
@@ -1,409 +0,0 @@
-import React, { useState, useEffect, useCallback, ReactNode } from 'react'
-import FlipMove from 'react-flip-move'
-
-import FadeIn from '../../fade-in'
-import Bar from '../bar'
-import LazyLoader from '../../components/lazy-loader'
-import { trimURL } from '../../util/url'
-import {
- isRealTimeDashboard,
- hasConversionGoalFilter
-} from '../../util/filters'
-import { useDashboardStateContext } from '../../dashboard-state-context'
-import { Metric } from './metrics'
-import { DrilldownLink, FilterInfo } from '../../components/drilldown-link'
-import { BreakdownResultMeta } from '../../dashboard-state'
-
-const MAX_ITEMS = 9
-export const MIN_HEIGHT = 356
-const ROW_HEIGHT = 32
-const ROW_GAP_HEIGHT = 4
-const DATA_CONTAINER_HEIGHT =
- (ROW_HEIGHT + ROW_GAP_HEIGHT) * (MAX_ITEMS - 1) + ROW_HEIGHT
-const COL_MIN_WIDTH = 70
-
-function ExternalLink<T>({
- item,
- getExternalLinkUrl,
- isTapped
-}: {
- item: T
- getExternalLinkUrl?: (item: T) => string
- isTapped?: boolean
-}) {
- const dest = getExternalLinkUrl && getExternalLinkUrl(item)
- if (dest) {
- const className = isTapped
- ? 'visible md:invisible md:group-hover/row:visible'
- : 'invisible md:group-hover/row:visible'
-
- return (
- <a target="_blank" rel="noreferrer" href={dest} className={className}>
- <svg
- xmlns="http://www.w3.org/2000/svg"
- fill="none"
- viewBox="0 0 24 24"
- className="inline size-3.5 mb-0.5 text-gray-600 dark:text-gray-400 hover:text-gray-800 dark:hover:text-gray-200"
- >
- <path
- stroke="currentColor"
- strokeLinecap="round"
- strokeLinejoin="round"
- strokeWidth="2"
- d="M9 5H5a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-4M12 12l9-9-.303.303M14 3h7v7"
- />
- </svg>
- </a>
- )
- }
-
- return null
-}
-
-export interface SharedReportProps<
- TListItem extends Record<string, unknown> = Record<string, unknown>,
- TResponse = { results: TListItem[]; meta: BreakdownResultMeta }
-> {
- metrics: Metric[]
- /** A function that takes a list item and returns the filter
- * that should be applied when the list item is clicked. All existing filters matching prefix
- * are removed. If a list item is not supposed to be clickable, this function should
- * return `null` for that list item. */
- getFilterInfo: (item: TListItem) => FilterInfo | null
- /** A function that takes a list item and returns the HTML of an icon */
- renderIcon?: (item: TListItem) => ReactNode
- /** A function that takes a list item and returns an external URL
- * to navigate to. If this prop is given, an additional icon is rendered upon hovering
- * the entry. */
- getExternalLinkUrl?: (item: TListItem) => string
- /** A function that defines the data
- * to be rendered, and should return a list of objects under a `results` key. Think of
- * these objects as rows. The number of columns that are **actually rendered** is also
- * configurable through the `metrics` prop, which also defines the keys under which
- * column values are read, and how they're rendered. */
- fetchData: () => Promise<TResponse>
- afterFetchData?: (response: TResponse) => void
- afterFetchNextPage?: (response: TResponse) => void
-}
-
-type ListReportProps = {
- /** What each entry in the list represents (for UI only). */
- keyLabel: string
- metrics: Metric[]
- colMinWidth?: number
- /** Function with additional action to be taken when a list entry is clicked. */
- onClick?: () => void
- /** Color of the comparison bars in light-mode. */
- color?: string
-}
-
-/**
- * @returns {HTMLElement} Table of metrics, in the following format:
- * | keyLabel | METRIC_1.renderLabel(dashboardState) | METRIC_2.renderLabel(dashboardState) | ...
- * |--------------------|--------------------------------------|--------------------------------------| ---
- * | LISTITEM_1.name | LISTITEM_1[METRIC_1.key] | LISTITEM_1[METRIC_2.key] | ...
- * | LISTITEM_2.name | LISTITEM_2[METRIC_1.key] | LISTITEM_2[METRIC_2.key] | ...
- */
-export default function ListReport<
- TListItem extends Record<string, unknown> & { name: string }
->({
- keyLabel,
- metrics,
- colMinWidth = COL_MIN_WIDTH,
- afterFetchData,
- onClick,
- color,
- getFilterInfo,
- renderIcon,
- getExternalLinkUrl,
- fetchData
-}: Omit<SharedReportProps<TListItem>, 'afterFetchNextPage'> & ListReportProps) {
- const { dashboardState } = useDashboardStateContext()
- const [state, setState] = useState<{
- loading: boolean
- list: TListItem[] | null
- meta: BreakdownResultMeta | null
- }>({ loading: true, list: null, meta: null })
- const [visible, setVisible] = useState(false)
- const [tappedRow, setTappedRow] = useState<string | null>(null)
-
- const isRealtime = isRealTimeDashboard(dashboardState)
- const goalFilterApplied = hasConversionGoalFilter(dashboardState)
-
- const getData = useCallback(() => {
- if (!isRealtime) {
- setState({ loading: true, list: null, meta: null })
- }
- fetchData().then((response) => {
- if (afterFetchData) {
- afterFetchData(response)
- }
-
- setState({ loading: false, list: response.results, meta: response.meta })
- })
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [keyLabel, dashboardState])
-
- const onVisible = () => {
- setVisible(true)
- }
-
- useEffect(() => {
- if (isRealtime) {
- // When a goal filter is applied or removed, we always want the component to go into a
- // loading state, even in realtime mode, because the metrics list will change. We can
- // only read the new metrics once the new list is loaded.
- setState({ loading: true, list: null, meta: null })
- }
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [goalFilterApplied])
-
- useEffect(() => {
- if (visible) {
- if (isRealtime) {
- document.addEventListener('tick', getData)
- }
- getData()
- }
-
- return () => {
- document.removeEventListener('tick', getData)
- }
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [keyLabel, dashboardState, visible])
-
- // returns a filtered `metrics` list. Since currently, the backend can return different
- // metrics based on filters and existing data, this function validates that the metrics
- // we want to display are actually there in the API response.
- function getAvailableMetrics() {
- return metrics.filter((metric) =>
- state.list
- ? state.list.some((listItem) => listItem[metric.key] != null)
- : false
- )
- }
-
- function hiddenOnMobileClass(metric: Metric) {
- if (metric.meta.hiddenOnMobile) {
- return 'hidden md:block'
- } else {
- return ''
- }
- }
-
- function showOnHoverClass(metric: Metric, listItemName: string) {
- if (!metric.meta.showOnHover) {
- return ''
- }
-
- // On mobile: show if row is tapped, hide otherwise
- // On desktop: slide in from right when hovering
- if (tappedRow === listItemName) {
- return 'translate-x-0 opacity-100 transition-all duration-150'
- } else {
- return 'translate-x-[100%] opacity-0 transition-all duration-150 md:group-hover/report:translate-x-0 md:group-hover/report:opacity-100'
- }
- }
-
- function slideLeftClass(
- metricIndex: number,
- showOnHoverIndex: number,
- hasShowOnHoverMetric: boolean,
- listItemName: string
- ) {
- // Columns before the showOnHover column should slide left when it appears
- if (!hasShowOnHoverMetric || metricIndex >= showOnHoverIndex) {
- return ''
- }
-
- if (tappedRow === listItemName) {
- return 'transition-transform duration-150 translate-x-0'
- } else {
- return 'transition-transform duration-150 translate-x-[100%] md:group-hover/report:translate-x-0'
- }
- }
-
- function renderReport() {
- if (state.list && state.list.length > 0) {
- return (
- <div className="h-full flex flex-col">
- <div style={{ height: ROW_HEIGHT }}>{renderReportHeader()}</div>
-
- <div
- className="group/report"
- style={{ minHeight: DATA_CONTAINER_HEIGHT }}
- >
- <FlipMove className="grow">
- {state.list.slice(0, MAX_ITEMS).map(renderRow)}
- </FlipMove>
- </div>
- </div>
- )
- }
- return renderNoDataYet()
- }
-
- function renderReportHeader() {
- const metricLabels = getAvailableMetrics()
- .filter((metric) => !metric.meta.showOnHover)
- .map((metric) => {
- return (
- <div
- data-testid="report-header"
- key={metric.key}
- className={`${metric.key} text-right ${hiddenOnMobileClass(metric)}`}
- style={{ minWidth: colMinWidth }}
- >
- {metric.renderLabel(dashboardState)}
- </div>
- )
- })
-
- return (
- <div className="pt-3 w-full text-xs font-medium text-gray-500 flex items-center dark:text-gray-400">
- <span data-testid="report-header" className="grow truncate">
- {keyLabel}
- </span>
- {metricLabels}
- </div>
- )
- }
-
- function renderRow(listItem: TListItem) {
- const handleRowClick = (e: React.MouseEvent) => {
- if (window.innerWidth < 768 && !(e.target as HTMLElement).closest('a')) {
- if (tappedRow === listItem.name) {
- setTappedRow(null)
- } else {
- setTappedRow(listItem.name)
- }
- }
- }
-
- return (
- <div key={listItem.name} style={{ minHeight: ROW_HEIGHT }}>
- <div
- data-testid="report-row"
- className="group/row flex w-full items-center hover:bg-gray-100/60 dark:hover:bg-gray-850 rounded-sm md:cursor-default cursor-pointer"
- style={{ marginTop: ROW_GAP_HEIGHT }}
- onClick={handleRowClick}
- >
- {renderBarFor(listItem)}
- {renderMetricValuesFor(listItem)}
- </div>
- </div>
- )
- }
-
- function renderBarFor(listItem: TListItem) {
- const lightBackground = color || 'bg-green-50 group-hover/row:bg-green-100'
- const metricToPlot = metrics.find((metric) => metric.meta.plot)?.key
-
- return (
- <div className="grow w-full overflow-hidden">
- <Bar
- maxWidthDeduction={undefined}
- count={listItem[metricToPlot]}
- all={state.list}
- bg={`${lightBackground} dark:bg-gray-500/15 dark:group-hover/row:bg-gray-500/30`}
- plot={metricToPlot}
- >
- <div className="flex justify-start items-center gap-x-1.5 px-2 py-1.5 text-sm dark:text-gray-300 relative z-9 break-all w-full">
- <DrilldownLink
- filterInfo={getFilterInfo(listItem)}
- onClick={onClick}
- className="max-w-max w-full flex items-center md:overflow-hidden"
- icon={maybeRenderIconFor(listItem)}
- textClassName="w-full md:truncate"
- >
- {trimURL(listItem.name, colMinWidth)}
- </DrilldownLink>
- <ExternalLink
- item={listItem}
- getExternalLinkUrl={getExternalLinkUrl}
- isTapped={tappedRow === listItem.name}
- />
- </div>
- </Bar>
- </div>
- )
- }
-
- function maybeRenderIconFor(listItem: TListItem) {
- if (renderIcon) {
- return renderIcon(listItem)
- }
- }
-
- function renderMetricValuesFor(listItem: TListItem) {
- const availableMetrics = getAvailableMetrics()
- const showOnHoverIndex = availableMetrics.findIndex(
- (m) => m.meta.showOnHover
- )
- const hasShowOnHoverMetric = showOnHoverIndex !== -1
-
- return (
- <>
- {availableMetrics.map((metric, index) => {
- const isShowOnHover = metric.meta.showOnHover
-
- return (
- <div
- key={`${listItem.name}__${metric.key}`}
- className={`text-right ${hiddenOnMobileClass(metric)} ${showOnHoverClass(metric, listItem.name)} ${slideLeftClass(index, showOnHoverIndex, hasShowOnHoverMetric, listItem.name)}`}
- style={{ width: colMinWidth, minWidth: colMinWidth }}
- >
- <span
- className={`font-medium text-sm text-right ${isShowOnHover ? 'text-gray-500 group-hover/row:text-gray-800 dark:group-hover/row:text-gray-200' : 'text-gray-800 dark:text-gray-200'}`}
- >
- {metric.renderValue(listItem, state.meta, {
- detailedView: false,
- isRowHovered: false
- })}
- </span>
- </div>
- )
- })}
- </>
- )
- }
-
- function renderLoading() {
- return (
- <div
- className="w-full flex flex-col justify-center"
- style={{ minHeight: `${MIN_HEIGHT}px` }}
- >
- <div className="mx-auto loading">
- <div></div>
- </div>
- </div>
- )
- }
-
- function renderNoDataYet() {
- return (
- <div
- className="w-full h-full flex flex-col justify-center"
- style={{ minHeight: `${MIN_HEIGHT}px` }}
- >
- <div className="mx-auto font-medium text-gray-500 dark:text-gray-400">
- No data yet
- </div>
- </div>
- )
- }
-
- return (
- <LazyLoader onVisible={onVisible}>
- <div className="w-full" style={{ minHeight: `${MIN_HEIGHT}px` }}>
- {state.loading && renderLoading()}
- {!state.loading && (
- <FadeIn show={!state.loading} className="h-full">
- {renderReport()}
- </FadeIn>
- )}
- </div>
- </LazyLoader>
- )
-}
diff --git a/assets/js/dashboard/stats/reports/metric-value.test.tsx b/assets/js/dashboard/stats/reports/metric-value.test.tsx
deleted file mode 100644
index e18b91e907..0000000000
--- a/assets/js/dashboard/stats/reports/metric-value.test.tsx
+++ /dev/null
@@ -1,238 +0,0 @@
-import React from 'react'
-import { render, screen, fireEvent, waitFor } from '@testing-library/react'
-import MetricValue from './metric-value'
-
-jest.mock('@heroicons/react/24/solid', () => ({
- ArrowUpRightIcon: () => <>↑</>,
- ArrowDownRightIcon: () => <>↓</>
-}))
-
-const REVENUE = { long: '$1,659.50', short: '$1.7K' }
-
-describe('single value', () => {
- it('renders small value', async () => {
- render(<MetricValue {...valueProps('visitors', 10)} />)
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('10')
- })
-
- it('renders large value', async () => {
- await renderWithTooltip(<MetricValue {...valueProps('visitors', 12345)} />)
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('12.3k')
- expect(screen.getByRole('tooltip')).toHaveTextContent('12,345')
- })
-
- it('renders percentages', async () => {
- render(<MetricValue {...valueProps('bounce_rate', 5.3)} />)
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('5.3%')
- })
-
- it('renders durations', async () => {
- render(<MetricValue {...valueProps('visit_duration', 60)} />)
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('1m 00s')
- })
-
- it('renders with custom formatter', async () => {
- render(
- <MetricValue
- {...valueProps('test_money', 5.3)}
- formatter={(value) => `${value}$`}
- />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('5.3$')
- })
-
- it('renders revenue properly', async () => {
- await renderWithTooltip(
- <MetricValue {...valueProps('average_revenue', REVENUE)} />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('$1.7K')
- expect(screen.getByRole('tooltip')).toHaveTextContent('$1,659.50')
- })
-
- it('renders null revenue without tooltip', async () => {
- render(<MetricValue {...valueProps('average_revenue', null)} />)
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('-')
-
- await expect(waitForTooltip).rejects.toThrow()
- })
-})
-
-describe('comparisons', () => {
- it('renders increased metric', async () => {
- await renderWithTooltip(
- <MetricValue {...valueProps('visitors', 10, { value: 5, change: 100 })} />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('10↑')
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '10 visitors',
- '01 Aug - 31 Aug',
- '↑ 100%',
- '5 visitors',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('renders decreased metric', async () => {
- await renderWithTooltip(
- <MetricValue {...valueProps('visitors', 5, { value: 10, change: -50 })} />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('5↓')
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '5 visitors',
- '01 Aug - 31 Aug',
- '↓ 50%',
- '10 visitors',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('renders unchanged metric', async () => {
- await renderWithTooltip(
- <MetricValue {...valueProps('visitors', 10, { value: 10, change: 0 })} />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('10')
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '10 visitors',
- '01 Aug - 31 Aug',
- '0%',
- '10 visitors',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('renders metric with custom label', async () => {
- await renderWithTooltip(
- <MetricValue
- {...valueProps('visitors', 10, { value: 10, change: 0 })}
- renderLabel={() => 'Conversions'}
- />
- )
-
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '10 conversions',
- '01 Aug - 31 Aug',
- '0%',
- '10 conversions',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('does not render very short labels', async () => {
- await renderWithTooltip(
- <MetricValue
- {...valueProps('percentage', 10, { value: 10, change: 0 })}
- renderLabel={() => '%'}
- />
- )
-
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- ['10% ', '01 Aug - 31 Aug', '0%', '10% ', '01 July - 31 July'].join('')
- )
- })
-
- it('renders with custom formatter', async () => {
- await renderWithTooltip(
- <MetricValue
- {...valueProps('test', 10, { value: 5, change: 100 })}
- formatter={(value) => `${value}$`}
- />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('10$↑')
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '10$ test',
- '01 Aug - 31 Aug',
- '↑ 100%',
- '5$ test',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('renders revenue change', async () => {
- await renderWithTooltip(
- <MetricValue
- {...valueProps('average_revenue', REVENUE, {
- value: REVENUE,
- change: 0
- })}
- />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('$1.7K')
- expect(screen.getByRole('tooltip')).toHaveTextContent(
- [
- '$1,659.50 average_revenue',
- '01 Aug - 31 Aug',
- '0%',
- '$1,659.50 average_revenue',
- '01 July - 31 July'
- ].join('')
- )
- })
-
- it('renders without tooltip when revenue null', async () => {
- render(
- <MetricValue
- {...valueProps('average_revenue', null, { value: null, change: 0 })}
- />
- )
-
- expect(screen.getByTestId('metric-value')).toHaveTextContent('-')
-
- await expect(waitForTooltip).rejects.toThrow()
- })
-})
-
-function valueProps<T>(
- metric: string,
- value: T,
- comparison?: { value: T; change: number }
-) {
- return {
- metric: metric,
- listItem: {
- [metric]: value,
- comparison: comparison && {
- [metric]: comparison.value,
- change: {
- [metric]: comparison.change
- }
- }
- },
- meta: {
- date_range_label: '01 Aug - 31 Aug',
- comparison_date_range_label: '01 July - 31 July'
- },
- renderLabel: (_dashboardState: unknown) => metric.toUpperCase()
- } as any /* eslint-disable-line @typescript-eslint/no-explicit-any */
-}
-
-async function renderWithTooltip(ui: React.ReactNode) {
- render(ui)
- await waitForTooltip()
-}
-
-async function waitForTooltip() {
- fireEvent.mouseOver(screen.getByTestId('metric-value'))
- await waitFor(() => screen.getByRole('tooltip'))
-}
diff --git a/assets/js/dashboard/stats/reports/metric-value.tsx b/assets/js/dashboard/stats/reports/metric-value.tsx
deleted file mode 100644
index 820005bd70..0000000000
--- a/assets/js/dashboard/stats/reports/metric-value.tsx
+++ /dev/null
@@ -1,193 +0,0 @@
-import React, { useMemo, useRef, useEffect } from 'react'
-import { Metric } from '../../../types/query-api'
-import { Tooltip } from '../../util/tooltip'
-import { ChangeArrow } from './change-arrow'
-import {
- MetricFormatterLong,
- MetricFormatterShort,
- ValueType
-} from './metric-formatter'
-import { BreakdownResultMeta, DashboardState } from '../../dashboard-state'
-import { useDashboardStateContext } from '../../dashboard-state-context'
-
-type MetricValues = Record<Metric, ValueType>
-
-type ListItem = MetricValues & {
- comparison: MetricValues & { change: Record<Metric, number> }
-}
-
-function valueRenderProps(listItem: ListItem, metric: Metric) {
- const value = listItem[metric]
-
- let comparison = null
- if (listItem.comparison) {
- comparison = {
- value: listItem.comparison[metric],
- change: listItem.comparison.change[metric]
- }
- }
-
- return { value, comparison }
-}
-
-export default function MetricValue(props: {
- listItem: ListItem
- metric: Metric
- renderLabel: (dashboardState: DashboardState) => string
- formatter?: (value: ValueType) => string
- meta: BreakdownResultMeta | null
- detailedView?: boolean
- isRowHovered?: boolean
-}) {
- const { dashboardState } = useDashboardStateContext()
- const portalRef = useRef<HTMLElement | null>(null)
-
- useEffect(() => {
- if (typeof document !== 'undefined') {
- portalRef.current = document.body
- }
- }, [])
-
- const { metric, listItem, detailedView = false, isRowHovered = false } = props
- const { value, comparison } = useMemo(
- () => valueRenderProps(listItem, metric),
- [listItem, metric]
- )
- const metricLabel = useMemo(
- () => props.renderLabel(dashboardState),
- [dashboardState, props]
- )
- const shortFormatter = props.formatter ?? MetricFormatterShort[metric]
- const longFormatter = props.formatter ?? MetricFormatterLong[metric]
-
- const isAbbreviated = useMemo(() => {
- if (value === null) return false
- return shortFormatter(value) !== longFormatter(value)
- }, [value, shortFormatter, longFormatter])
-
- const showTooltip = detailedView
- ? !!comparison
- : !!comparison || isAbbreviated
-
- const shouldShowLongFormat =
- detailedView && !comparison && isRowHovered && isAbbreviated
- const displayFormatter = shouldShowLongFormat ? longFormatter : shortFormatter
-
- const percentageValue = listItem['percentage' as Metric]
- const shouldShowPercentage =
- detailedView &&
- metric === 'visitors' &&
- isRowHovered &&
- percentageValue != null
- const percentageFormatter = MetricFormatterShort['percentage']
- const percentageDisplay = shouldShowPercentage
- ? percentageFormatter(percentageValue)
- : null
-
- if (value === null && (!comparison || comparison.value === null)) {
- return <span data-testid="metric-value">{displayFormatter(value)}</span>
- }
-
- const valueContent = (
- <span
- className={showTooltip ? 'cursor-default' : ''}
- data-testid="metric-value"
- >
- {percentageDisplay && (
- <span className="mr-3 text-gray-500 dark:text-gray-400">
- {percentageDisplay}
- </span>
- )}
- {displayFormatter(value)}
- {comparison ? (
- <ChangeArrow
- change={comparison.change}
- metric={metric}
- className="inline-block pl-1 w-4"
- hideNumber
- />
- ) : null}
- </span>
- )
-
- if (!showTooltip) {
- return valueContent
- }
-
- return (
- <Tooltip
- containerRef={portalRef as React.RefObject<HTMLElement>}
- info={
- <ComparisonTooltipContent
- value={value}
- comparison={comparison}
- metricLabel={metricLabel}
- {...props}
- />
- }
- >
- {valueContent}
- </Tooltip>
- )
-}
-
-function ComparisonTooltipContent({
- value,
- comparison,
- metric,
- metricLabel,
- formatter,
- meta
-}: {
- value: ValueType
- comparison: { value: ValueType; change: number } | null
- metric: Metric
- metricLabel: string
- formatter?: (value: ValueType) => string
- meta: BreakdownResultMeta | null
-}) {
- const longFormatter = formatter ?? MetricFormatterLong[metric]
-
- const label = useMemo(() => {
- if (metricLabel.length < 3) {
- return ''
- }
-
- return ` ${metricLabel.toLowerCase()}`
- }, [metricLabel])
-
- if (comparison && meta) {
- return (
- <div className="text-left whitespace-nowrap py-1 space-y-2">
- <div>
- <div className="flex gap-x-4">
- <div className="flex flex-col">
- <span className="font-medium text-sm/6 text-white">
- {longFormatter(value)} {label}
- </span>
- <div className="font-normal text-xs text-white">
- {meta.date_range_label}
- </div>
- </div>
- <ChangeArrow
- metric={metric}
- change={comparison.change}
- className="text-xs/6 font-medium text-white"
- />
- </div>
- </div>
- <div className="w-full border-t border-gray-600"></div>
- <div>
- <div className="font-medium text-sm/6 text-gray-300/80">
- {longFormatter(comparison.value)} {label}
- </div>
- <div className="font-normal text-xs text-gray-300/80">
- {meta.comparison_date_range_label}
- </div>
- </div>
- </div>
- )
- } else {
- return <div className="whitespace-nowrap">{longFormatter(value)}</div>
- }
-}
diff --git a/assets/js/dashboard/stats/reports/metrics.js b/assets/js/dashboard/stats/reports/metrics.js
deleted file mode 100644
index dc6fba1562..0000000000
--- a/assets/js/dashboard/stats/reports/metrics.js
+++ /dev/null
@@ -1,226 +0,0 @@
-import React from 'react'
-import MetricValue from './metric-value'
-import { hasConversionGoalFilter } from '../../util/filters'
-
-// Class representation of a metric.
-
-// Metric instances can be created directly via the Metric constructor,
-// or using special creator functions like `createVisitors`, which just
-// fill out the known fields for that metric.
-
-// ### Required props
-
-// * `key` - the key under which to read values under in an API
-
-// * `formatter` - a function that takes a value of this metric, and
-// and returns the "rendered" version of it. Can be JSX or a string.
-
-// * `renderLabel` - a function rendering a label for this metric given a
-// dashboardState argument. Returns string.
-
-// ### Optional props
-
-// * `meta` - a map with extra context for this metric. E.g. `plot`, or
-// `hiddenOnMobile` define some special behaviours in the context where
-// it's used.
-export class Metric {
- constructor(props) {
- if (!props.key) {
- throw Error('Required field `key` is missing')
- }
- if (typeof props.renderLabel !== 'function') {
- throw Error('Required field `renderLabel` should be a function')
- }
-
- this.key = props.key
- this.meta = props.meta || {}
- this.sortable = props.sortable
- this.width = props.width ?? 'w-24'
-
- this.formatter = props.formatter
- this.renderLabel = props.renderLabel
-
- this.renderValue = this.renderValue.bind(this)
- }
-
- renderValue(listItem, meta, options = {}) {
- const { detailedView = false, isRowHovered = false } = options
- return (
- <MetricValue
- listItem={listItem}
- metric={this.key}
- renderLabel={this.renderLabel}
- meta={meta}
- formatter={this.formatter}
- detailedView={detailedView}
- isRowHovered={isRowHovered}
- />
- )
- }
-}
-
-// Creates a Metric class representing the `visitors` metric.
-
-// Optional props for conveniently generating the `renderLabel` function:
-
-// * `defaultLabel` - label when not realtime, and no goal filter applied
-// * `realtimeLabel` - label when realtime period
-// * `goalFilterLabel` - label when goal filter is applied
-export const createVisitors = (props) => {
- let renderLabel
-
- if (typeof props.renderLabel === 'function') {
- renderLabel = props.renderLabel
- } else {
- renderLabel = (dashboardState) => {
- const defaultLabel = props.defaultLabel || 'Visitors'
- const realtimeLabel = props.realtimeLabel || 'Current visitors'
- const goalFilterLabel = props.goalFilterLabel || 'Conversions'
-
- if (dashboardState && hasConversionGoalFilter(dashboardState)) {
- return goalFilterLabel
- }
- if (dashboardState.period === 'realtime') {
- return realtimeLabel
- }
- return defaultLabel
- }
- }
-
- return new Metric({
- width: 'w-36',
- sortable: true,
- ...props,
- key: 'visitors',
- renderLabel
- })
-}
-
-export const createConversionRate = (props) => {
- const renderLabel = (_dashboardState) => 'CR'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'conversion_rate',
- renderLabel,
- sortable: true
- })
-}
-
-export const createPercentage = (props) => {
- const renderLabel = (_dashboardState) => '%'
- return new Metric({
- width: 'w-24',
- ...props,
- key: 'percentage',
- renderLabel,
- sortable: true
- })
-}
-
-export const createEvents = (props) => {
- return new Metric({ width: 'w-28', ...props, key: 'events', sortable: true })
-}
-
-export const createTotalRevenue = (props) => {
- const renderLabel = (_dashboardState) => 'Revenue'
- return new Metric({
- width: 'w-32',
- ...props,
- key: 'total_revenue',
- renderLabel,
- sortable: true
- })
-}
-
-export const createAverageRevenue = (props) => {
- const renderLabel = (_dashboardState) => 'Average'
- return new Metric({
- width: 'w-28',
- ...props,
- key: 'average_revenue',
- renderLabel,
- sortable: true
- })
-}
-
-export const createTotalVisitors = (props) => {
- const renderLabel = (_dashboardState) => 'Total visitors'
- return new Metric({
- width: 'w-32',
- ...props,
- key: 'total_visitors',
- renderLabel,
- sortable: false
- })
-}
-
-export const createVisits = (props) => {
- return new Metric({ width: 'w-24', sortable: true, ...props, key: 'visits' })
-}
-
-export const createVisitDuration = (props) => {
- const renderLabel = (_dashboardState) => 'Visit duration'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'visit_duration',
- renderLabel,
- sortable: true
- })
-}
-
-export const createBounceRate = (props) => {
- const renderLabel = (_dashboardState) => 'Bounce rate'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'bounce_rate',
- renderLabel,
- sortable: true
- })
-}
-
-export const createPageviews = (props) => {
- const renderLabel = (_dashboardState) => 'Pageviews'
- return new Metric({
- width: 'w-28',
- ...props,
- key: 'pageviews',
- renderLabel,
- sortable: true
- })
-}
-
-export const createTimeOnPage = (props) => {
- const renderLabel = (_dashboardState) => 'Time on page'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'time_on_page',
- renderLabel,
- sortable: true
- })
-}
-
-export const createExitRate = (props) => {
- const renderLabel = (_dashboardState) => 'Exit rate'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'exit_rate',
- renderLabel,
- sortable: true
- })
-}
-
-export const createScrollDepth = (props) => {
- const renderLabel = (_dashboardState) => 'Scroll depth'
- return new Metric({
- width: 'w-28 md:w-24',
- ...props,
- key: 'scroll_depth',
- renderLabel,
- sortable: true
- })
-}
diff --git a/assets/js/dashboard/util/url-search-params.test.ts b/assets/js/dashboard/util/url-search-params.test.ts
index 7de042aee1..a52efaeeea 100644
--- a/assets/js/dashboard/util/url-search-params.test.ts
+++ b/assets/js/dashboard/util/url-search-params.test.ts
@@ -264,6 +264,14 @@ describe(`${getSearchWithEnforcedSegment.name}`, () => {
describe(`${maybeReloadForApiVersion.name}`, () => {
const dashboardPathname = '/example.com'
+ beforeEach(() => {
+ jest.spyOn(console, 'warn').mockImplementation(() => {})
+ })
+
+ afterEach(() => {
+ jest.restoreAllMocks()
+ })
+
type MockWindowLocation = Location & { replace: jest.Mock }
function makeLocation(search: string): MockWindowLocation {
diff --git a/assets/test-utils/app-context-providers.tsx b/assets/test-utils/app-context-providers.tsx
index f0b2f59270..e0fcd5588b 100644
--- a/assets/test-utils/app-context-providers.tsx
+++ b/assets/test-utils/app-context-providers.tsx
@@ -47,7 +47,7 @@ export const DEFAULT_SITE: PlausibleSite = {
embedded: false,
background: '',
isDbip: false,
- flags: { dashboard_csv_export_v2: false },
+ flags: {},
shared: false,
isConsolidatedView: false
}
diff --git a/e2e/tests/dashboard/csv-export.spec.ts b/e2e/tests/dashboard/csv-export.spec.ts
index a7d742acdc..b6bf9d5702 100644
--- a/e2e/tests/dashboard/csv-export.spec.ts
+++ b/e2e/tests/dashboard/csv-export.spec.ts
@@ -5,7 +5,6 @@ import * as fs from 'fs'
import {
setupSite,
populateStats,
- enableDashboardCsvExportV2,
addGoal,
addCustomProp,
StatsEntry
@@ -127,7 +126,6 @@ test('csv export column headers match expected metrics for each report', async (
request
}) => {
const { domain } = await setupSite({ page, request })
- await enableDashboardCsvExportV2({ request, domain })
await addCustomProp({ page, domain, name: 'author' })
await populateStats({
@@ -325,7 +323,6 @@ test('filters out empty visit:* dimension values', async ({
request
}) => {
const { domain } = await setupSite({ page, request })
- await enableDashboardCsvExportV2({ request, domain })
const base: StatsEntry = {
name: 'pageview',
diff --git a/e2e/tests/fixtures.ts b/e2e/tests/fixtures.ts
index 062c7a6c8e..be00032dec 100644
--- a/e2e/tests/fixtures.ts
+++ b/e2e/tests/fixtures.ts
@@ -477,31 +477,6 @@ export async function addAllCustomProps({
)
}
-export async function enableDashboardCsvExportV2({
- request,
- domain
-}: {
- request: APIRequestContext
- domain: string
-}) {
- const response = await request.post(
- '/e2e-tests/enable-dashboard-csv-export-v2',
- {
- headers: {
- 'Content-Type': 'application/json',
- Accept: 'application/json'
- },
- data: { domain }
- }
- )
- if (!response.ok()) {
- const body = await response.text()
- throw new Error(
- `enableDashboardCsvExportV2 failed (${response.status()}): ${body}`
- )
- }
-}
-
export async function addFunnel({
request,
domain,
diff --git a/lib/plausible/internal_stats_api_version.ex b/lib/plausible/internal_stats_api_version.ex
index 98b1fcf535..ded0ce3a52 100644
--- a/lib/plausible/internal_stats_api_version.ex
+++ b/lib/plausible/internal_stats_api_version.ex
@@ -14,7 +14,7 @@ defmodule Plausible.InternalStatsApiVersion do
"""
use GenServer
- @api_version 0
+ @api_version 1
@refresh_interval :timer.seconds(30)
diff --git a/lib/plausible_web/controllers/api/stats_controller.ex b/lib/plausible_web/controllers/api/stats_controller.ex
index 30e205525c..51b5ebcfcf 100644
--- a/lib/plausible_web/controllers/api/stats_controller.ex
+++ b/lib/plausible_web/controllers/api/stats_controller.ex
@@ -6,25 +6,13 @@ defmodule PlausibleWeb.Api.StatsController do
alias Plausible.Stats
- alias Plausible.Stats.{
- Query,
- Comparisons,
- Filters,
- TableDecider,
- Dashboard,
- ParsedQueryParams,
- QueryBuilder,
- QueryError
- }
+ alias Plausible.Stats.{Query, Dashboard, ParsedQueryParams, QueryBuilder, QueryError}
alias Plausible.Stats.Dashboard.CsvExport
alias PlausibleWeb.Api.Helpers, as: H
require Logger
- @revenue_metrics on_ee(do: Plausible.Stats.Goal.Revenue.revenue_metrics(), else: [])
- @not_set "(not set)"
-
plug(:date_validation_plug when action not in [:query, :csv_export_v2])
plug(:validate_required_filters_plug when action not in [:current_visitors])
@@ -47,7 +35,7 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
- def csv_export_v2(conn, params) do
+ def csv_export(conn, params) do
site = conn.assigns.site
case CsvExport.get_csvs(site, params, debug_metadata(conn)) do
@@ -67,86 +55,6 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
- def sources(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:source")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"],
- do: [:percentage, :bounce_rate, :visit_duration],
- else: [:percentage]
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics,
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{source: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def channels(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:channel")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"],
- do: [:percentage, :bounce_rate, :visit_duration],
- else: [:percentage]
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics,
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{channel: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
on_ee do
alias Plausible.Stats.Exploration
@@ -323,7 +231,7 @@ defmodule PlausibleWeb.Api.StatsController do
toplevel_goal_filter?(query) ->
{:error, {:invalid_funnel_query, "goals"}}
- Filters.filtering_on_dimension?(query, "event:page") ->
+ Plausible.Stats.Filters.filtering_on_dimension?(query, "event:page") ->
{:error, {:invalid_funnel_query, "pages"}}
query.input_date_range == :realtime ->
@@ -335,216 +243,6 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
- def utm_mediums(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:utm_medium")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{utm_medium: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def utm_campaigns(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:utm_campaign")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{utm_campaign: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def utm_contents(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:utm_content")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{utm_content: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def utm_terms(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:utm_term")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{utm_term: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def utm_sources(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:utm_source")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{utm_source: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def referrers(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:referrer")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :bounce_rate, :visit_duration],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- res =
- results
- |> transform_keys(%{referrer: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- res
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- res |> to_csv([:name, :visitors, :bounce_rate, :visit_duration])
- end
- else
- json(conn, %{
- results: res,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
def google_search_terms(conn, params) do
site = conn.assigns[:site]
@@ -599,664 +297,6 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
- def referrer_drilldown(conn, %{"referrer" => referrer} = params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:referrer")
-
- query =
- Query.from(site, params, debug_metadata: debug_metadata(conn))
- |> Query.add_filter([:is, "visit:source", [referrer]])
-
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"],
- do: [:percentage, :bounce_rate, :visit_duration],
- else: [:percentage]
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics,
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- referrers =
- results
- |> transform_keys(%{referrer: :name})
-
- json(conn, %{
- results: referrers,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
-
- def pages(conn, params) do
- site = conn.assigns[:site]
-
- params = Map.put(params, "property", "event:page")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
-
- extra_metrics =
- if params["detailed"] do
- [:percentage, :pageviews, :bounce_rate, :time_on_page, :scroll_depth]
- else
- [:percentage]
- end
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics,
- include_revenue?: !!params["detailed"]
- )
-
- pagination = parse_pagination(params)
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- pages =
- results
- |> transform_keys(%{page: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- pages
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- cols = [:name, :visitors, :pageviews, :bounce_rate, :time_on_page, :scroll_depth]
- pages |> to_csv(cols)
- end
- else
- json(conn, %{
- results: pages,
- meta: Map.new(meta.values) |> Map.merge(Stats.Breakdown.formatted_date_ranges(query)),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def entry_pages(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:entry_page")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage, :visits, :visit_duration, :bounce_rate],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- entry_pages =
- results
- |> transform_keys(%{entry_page: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- to_csv(entry_pages, [:name, :visitors, :conversion_rate], [
- :name,
- :conversions,
- :conversion_rate
- ])
- else
- to_csv(entry_pages, [:name, :visitors, :visits, :bounce_rate, :visit_duration], [
- :name,
- :unique_entrances,
- :total_entrances,
- :bounce_rate,
- :visit_duration
- ])
- end
- else
- json(conn, %{
- results: entry_pages,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def exit_pages(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:exit_page")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- {limit, page} = parse_pagination(params)
-
- extra_metrics =
- if TableDecider.sessions_join_events?(query) do
- [:percentage, :visits]
- else
- [:percentage, :visits, :exit_rate]
- end
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics,
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, {limit, page})
-
- exit_pages =
- results
- |> transform_keys(%{exit_page: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- to_csv(exit_pages, [:name, :visitors, :conversion_rate], [
- :name,
- :conversions,
- :conversion_rate
- ])
- else
- to_csv(exit_pages, [:name, :visitors, :visits, :exit_rate], [
- :name,
- :unique_exits,
- :total_exits,
- :exit_rate
- ])
- end
- else
- json(conn, %{
- results: exit_pages,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def countries(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:country")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- countries =
- results
- |> transform_keys(%{country: :code})
-
- countries_response(conn, query, meta, countries, !!params["csv"])
- end
-
- defp countries_response(_conn, query, _meta, countries, true = _csv?) do
- countries =
- countries
- |> Enum.map(fn country ->
- country_info = get_country(country[:code])
- Map.put(country, :name, country_info.name)
- end)
-
- if toplevel_goal_filter?(query) do
- countries
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- countries |> to_csv([:name, :visitors])
- end
- end
-
- defp countries_response(conn, query, meta, countries, _csv?) do
- countries =
- Enum.map(countries, fn row ->
- country = get_country(row[:code])
-
- if country do
- Map.merge(row, %{
- name: country.name,
- flag: country.flag,
- alpha_3: country.alpha_3,
- code: country.alpha_2
- })
- else
- Map.merge(row, %{
- name: row[:code],
- flag: "",
- alpha_3: "",
- code: ""
- })
- end
- end)
-
- json(conn, %{
- results: countries,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
-
- def regions(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:region")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- regions =
- results
- |> transform_keys(%{region: :code})
- |> Enum.map(fn region ->
- region_entry = Location.get_subdivision(region[:code])
-
- if region_entry do
- country_entry = get_country(region_entry.country_code)
- Map.merge(region, %{name: region_entry.name, country_flag: country_entry.flag})
- else
- Logger.warning("Could not find region info - code: #{inspect(region[:code])}")
- Map.merge(region, %{name: region[:code]})
- end
- end)
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- regions
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- regions |> to_csv([:name, :visitors])
- end
- else
- json(conn, %{
- results: regions,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def cities(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:city")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- cities =
- results
- |> transform_keys(%{city: :code})
- |> Enum.map(fn city ->
- city_info = Location.get_city(city[:code])
-
- if city_info do
- country_info = get_country(city_info.country_code)
-
- Map.merge(city, %{
- name: city_info.name,
- country_flag: country_info.flag
- })
- else
- Logger.warning("Could not find city info - code: #{inspect(city[:code])}")
-
- Map.merge(city, %{name: "N/A"})
- end
- end)
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- cities
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- cities |> to_csv([:name, :visitors])
- end
- else
- json(conn, %{
- results: cities,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def browsers(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:browser")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"], do: [:bounce_rate, :visit_duration], else: []
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics ++ [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- browsers =
- results
- |> transform_keys(%{browser: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- browsers
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- browsers |> to_csv([:name, :visitors])
- end
- else
- json(conn, %{
- results: browsers,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def browser_versions(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:browser_version")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"], do: [:bounce_rate, :visit_duration], else: []
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics ++ [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- results =
- results
- |> transform_keys(%{browser_version: :version})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- results
- |> transform_keys(%{browser: :name, visitors: :conversions})
- |> to_csv([:name, :version, :conversions, :conversion_rate])
- else
- results
- |> transform_keys(%{browser: :name})
- |> to_csv([:name, :version, :visitors])
- end
- else
- results =
- if params["detailed"] do
- transform_keys(results, %{version: :name})
- else
- Enum.map(results, &put_combined_name_with_version(&1, :browser))
- end
-
- json(conn, %{
- results: results,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def operating_systems(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:os")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"], do: [:bounce_rate, :visit_duration], else: []
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics ++ [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- systems =
- results
- |> transform_keys(%{os: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- systems
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- systems |> to_csv([:name, :visitors])
- end
- else
- json(conn, %{
- results: systems,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def operating_system_versions(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:os_version")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"], do: [:bounce_rate, :visit_duration], else: []
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics ++ [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- results =
- results
- |> transform_keys(%{os_version: :version})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- results
- |> transform_keys(%{os: :name, visitors: :conversions})
- |> to_csv([:name, :version, :conversions, :conversion_rate])
- else
- results
- |> transform_keys(%{os: :name})
- |> to_csv([:name, :version, :visitors])
- end
- else
- results =
- if params["detailed"] do
- transform_keys(results, %{version: :name})
- else
- Enum.map(results, &put_combined_name_with_version(&1, :os))
- end
-
- json(conn, %{
- results: results,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def screen_sizes(conn, params) do
- site = conn.assigns[:site]
- params = Map.put(params, "property", "visit:device")
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
- pagination = parse_pagination(params)
-
- extra_metrics =
- if params["detailed"], do: [:bounce_rate, :visit_duration], else: []
-
- metrics =
- breakdown_metrics(query,
- extra_metrics: extra_metrics ++ [:percentage],
- include_revenue?: !!params["detailed"]
- )
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- sizes =
- results
- |> transform_keys(%{device: :name})
-
- if params["csv"] do
- if toplevel_goal_filter?(query) do
- sizes
- |> transform_keys(%{visitors: :conversions})
- |> to_csv([:name, :conversions, :conversion_rate])
- else
- sizes |> to_csv([:name, :visitors])
- end
- else
- json(conn, %{
- results: sizes,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def conversions(conn, params) do
- pagination = parse_pagination(params)
-
- site =
- Plausible.Repo.preload(conn.assigns.site,
- goals: Plausible.Goals.for_site_query()
- )
-
- params =
- params
- |> realtime_period_to_30m()
- |> Map.put("property", "event:goal")
-
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
-
- metrics = [:visitors, :events, :conversion_rate] ++ @revenue_metrics
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- conversions =
- results
- |> transform_keys(%{goal: :name})
-
- if params["csv"] do
- to_csv(conversions, [:name, :visitors, :events], [
- :name,
- :unique_conversions,
- :total_conversions
- ])
- else
- json(conn, %{
- results: conversions,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- })
- end
- end
-
- def custom_prop_values(conn, params) do
- site = Plausible.Repo.preload(conn.assigns.site, :team)
- prop_key = Map.fetch!(params, "prop_key")
-
- case Plausible.Props.ensure_prop_key_accessible(prop_key, site.team) do
- :ok ->
- json(conn, breakdown_custom_prop_values(conn, site, params))
-
- {:error, :upgrade_required} ->
- H.payment_required(
- conn,
- "#{Plausible.Billing.Feature.Props.display_name()} is part of the Plausible Business plan. To get access to this feature, please upgrade your account."
- )
- end
- end
-
- def all_custom_prop_values(conn, params) do
- site = conn.assigns.site
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
-
- prop_names = Plausible.Stats.CustomProps.fetch_prop_names(site, query)
-
- prop_names =
- if Plausible.Billing.Feature.Props.enabled?(site) do
- prop_names
- else
- prop_names |> Enum.filter(&(&1 in Plausible.Props.internal_keys()))
- end
-
- if not Enum.empty?(prop_names) do
- values =
- prop_names
- |> Enum.map(fn prop_key ->
- breakdown_custom_prop_values(conn, site, Map.put(params, "prop_key", prop_key))
- |> Map.get(:results)
- |> Enum.map(&Map.put(&1, :property, prop_key))
- |> transform_keys(%{:name => :value})
- end)
- |> Enum.concat()
-
- percent_or_cr =
- if toplevel_goal_filter?(query),
- do: :conversion_rate,
- else: :percentage
-
- to_csv(values, [:property, :value, :visitors, :events, percent_or_cr])
- end
- end
-
- defp breakdown_custom_prop_values(conn, site, %{"prop_key" => prop_key} = params) do
- pagination = parse_pagination(params)
- prefixed_prop = "event:props:" <> prop_key
-
- params = Map.put(params, "property", prefixed_prop)
-
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
-
- metrics =
- if toplevel_goal_filter?(query) do
- [:visitors, :events, :conversion_rate] ++ @revenue_metrics
- else
- [:visitors, :events, :percentage] ++ @revenue_metrics
- end
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, pagination)
-
- props =
- results
- |> transform_keys(%{prop_key => :name})
-
- %{
- results: props,
- meta: Stats.Breakdown.formatted_date_ranges(query),
- skip_imported_reason: meta[:imports_skip_reason]
- }
- end
-
def current_visitors(conn, _) do
site = conn.assigns[:site]
json(conn, Stats.current_visitors(site))
@@ -1293,20 +333,6 @@ defmodule PlausibleWeb.Api.StatsController do
)
end
- defp transform_keys(result, keys_to_replace) when is_map(result) do
- for {key, val} <- result, do: {Map.get(keys_to_replace, key, key), val}, into: %{}
- end
-
- defp transform_keys(results, keys_to_replace) when is_list(results) do
- Enum.map(results, &transform_keys(&1, keys_to_replace))
- end
-
- defp parse_pagination(params) do
- limit = to_int(params["limit"], 9)
- page = to_int(params["page"], 1)
- {limit, page}
- end
-
defp to_int(string, default) when is_binary(string) do
case Integer.parse(string) do
{i, ""} when is_integer(i) ->
@@ -1319,32 +345,6 @@ defmodule PlausibleWeb.Api.StatsController do
defp to_int(_, default), do: default
- defp to_csv(list, columns), do: to_csv(list, columns, columns)
-
- defp to_csv(list, columns, column_names) do
- list
- |> Enum.map(fn row -> Enum.map(columns, &row[&1]) end)
- |> (fn res -> [column_names | res] end).()
- |> NimbleCSV.RFC4180.dump_to_iodata()
- end
-
- defp get_country(code) do
- case Location.get_country(code) do
- nil ->
- Logger.warning("Could not find country info - code: #{inspect(code)}")
-
- %Location.Country{
- alpha_2: code,
- alpha_3: "N/A",
- name: code,
- flag: nil
- }
-
- country ->
- country
- end
- end
-
defp date_validation_plug(conn, _opts) do
case parse_date_params(conn.params) do
{:ok, _dates} -> conn
@@ -1420,51 +420,12 @@ defmodule PlausibleWeb.Api.StatsController do
end)
end
- def comparison_query(query) do
- if query.include.compare do
- Comparisons.get_comparison_query(query)
- end
- end
-
- defp breakdown_metrics(query, opts) do
- extra_metrics = Keyword.get(opts, :extra_metrics, [])
- include_revenue? = Keyword.get(opts, :include_revenue?, false)
-
- if toplevel_goal_filter?(query) do
- metrics = [:visitors, :conversion_rate, :total_visitors]
-
- if ee?() and include_revenue? do
- metrics ++ [:average_revenue, :total_revenue]
- else
- metrics
- end
- else
- [:visitors] ++ extra_metrics
+ on_ee do
+ defp toplevel_goal_filter?(query) do
+ Plausible.Stats.Filters.filtering_on_dimension?(query, "event:goal",
+ max_depth: 0,
+ behavioral_filters: :ignore
+ )
end
end
-
- def put_combined_name_with_version(row, name_key) do
- name =
- case {row[name_key], row.version} do
- {@not_set, @not_set} -> @not_set
- {browser_or_os, version} -> "#{browser_or_os} #{version}"
- end
-
- Map.put(row, :name, name)
- end
-
- defp realtime_period_to_30m(%{"period" => _} = params) do
- Map.update!(params, "period", fn period ->
- if period == "realtime", do: "30m", else: period
- end)
- end
-
- defp realtime_period_to_30m(params), do: params
-
- defp toplevel_goal_filter?(query) do
- Filters.filtering_on_dimension?(query, "event:goal",
- max_depth: 0,
- behavioral_filters: :ignore
- )
- end
end
diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex
index 8607be6a68..adf2a2eab1 100644
--- a/lib/plausible_web/controllers/site/membership_controller.ex
+++ b/lib/plausible_web/controllers/site/membership_controller.ex
@@ -141,7 +141,7 @@ defmodule PlausibleWeb.Site.MembershipController do
redirect_target =
if user_id == conn.assigns[:current_user].id do
- Routes.stats_path(conn, :index, site.domain, [])
+ Routes.site_path(conn, :index)
else
Routes.site_path(conn, :settings_people, site.domain)
end
diff --git a/lib/plausible_web/controllers/stats_controller.ex b/lib/plausible_web/controllers/stats_controller.ex
index 7e563d44df..38e9169f66 100644
--- a/lib/plausible_web/controllers/stats_controller.ex
+++ b/lib/plausible_web/controllers/stats_controller.ex
@@ -41,12 +41,10 @@ defmodule PlausibleWeb.StatsController do
use Plausible.Repo
alias Plausible.Sites
- alias Plausible.Stats.{Filters, Query}
alias Plausible.Teams
- alias PlausibleWeb.Api
alias Plausible.Billing.Feature.SharedLinks
- plug(PlausibleWeb.Plugs.AuthorizeSiteAccess when action in [:stats, :csv_export])
+ plug(PlausibleWeb.Plugs.AuthorizeSiteAccess when action in [:stats])
def stats(%{assigns: %{site: site}} = conn, _params) do
site = Plausible.Repo.preload(site, :owners)
@@ -133,120 +131,6 @@ defmodule PlausibleWeb.StatsController do
defp list_revenue_goals(_site), do: []
end
- @doc """
- The export is limited to 300 entries for other reports and 100 entries for pages because bigger result sets
- start causing failures. Since we request data like time on page or bounce_rate for pages in a separate query
- using the IN filter, it causes the requests to balloon in payload size.
- """
- def csv_export(conn, params) do
- if is_nil(params["interval"]) or Plausible.Stats.Interval.valid?(params["interval"]) do
- site = Plausible.Repo.preload(conn.assigns.site, :owners)
- query = Query.from(site, params, debug_metadata: debug_metadata(conn))
-
- date_range = Query.date_range(query)
-
- filename =
- ~c"Plausible export #{params["domain"]} #{Date.to_iso8601(date_range.first)} to #{Date.to_iso8601(date_range.last)} .zip"
-
- params = Map.merge(params, %{"limit" => "300", "csv" => "True", "detailed" => "True"})
- limited_params = Map.merge(params, %{"limit" => "100"})
-
- csvs = %{
- ~c"visitors.csv" => fn -> main_graph_csv(site, query) end,
- ~c"sources.csv" => fn -> Api.StatsController.sources(conn, params) end,
- ~c"channels.csv" => fn -> Api.StatsController.channels(conn, params) end,
- ~c"utm_mediums.csv" => fn -> Api.StatsController.utm_mediums(conn, params) end,
- ~c"utm_sources.csv" => fn -> Api.StatsController.utm_sources(conn, params) end,
- ~c"utm_campaigns.csv" => fn -> Api.StatsController.utm_campaigns(conn, params) end,
- ~c"utm_contents.csv" => fn -> Api.StatsController.utm_contents(conn, params) end,
- ~c"utm_terms.csv" => fn -> Api.StatsController.utm_terms(conn, params) end,
- ~c"pages.csv" => fn -> Api.StatsController.pages(conn, limited_params) end,
- ~c"entry_pages.csv" => fn -> Api.StatsController.entry_pages(conn, params) end,
- ~c"exit_pages.csv" => fn -> Api.StatsController.exit_pages(conn, limited_params) end,
- ~c"countries.csv" => fn -> Api.StatsController.countries(conn, params) end,
- ~c"regions.csv" => fn -> Api.StatsController.regions(conn, params) end,
- ~c"cities.csv" => fn -> Api.StatsController.cities(conn, params) end,
- ~c"browsers.csv" => fn -> Api.StatsController.browsers(conn, params) end,
- ~c"browser_versions.csv" => fn -> Api.StatsController.browser_versions(conn, params) end,
- ~c"operating_systems.csv" => fn -> Api.StatsController.operating_systems(conn, params) end,
- ~c"operating_system_versions.csv" => fn ->
- Api.StatsController.operating_system_versions(conn, params)
- end,
- ~c"devices.csv" => fn -> Api.StatsController.screen_sizes(conn, params) end,
- ~c"conversions.csv" => fn -> Api.StatsController.conversions(conn, params) end,
- ~c"referrers.csv" => fn -> Api.StatsController.referrers(conn, params) end,
- ~c"custom_props.csv" => fn -> Api.StatsController.all_custom_prop_values(conn, params) end
- }
-
- csv_values =
- Map.values(csvs)
- |> Plausible.ClickhouseRepo.parallel_tasks()
-
- csvs =
- Map.keys(csvs)
- |> Enum.zip(csv_values)
- |> Enum.reject(fn {_k, v} -> is_nil(v) end)
- |> Enum.map(fn {k, v} -> {k, IO.iodata_to_binary(v)} end)
-
- {:ok, {_, zip_content}} = :zip.create(filename, csvs, [:memory])
-
- conn
- |> put_resp_content_type("application/zip")
- |> put_resp_header("content-disposition", "attachment; filename=\"#{filename}\"")
- |> delete_resp_cookie("exporting")
- |> send_resp(200, zip_content)
- else
- conn
- |> send_resp(400, "")
- |> halt()
- end
- end
-
- defp main_graph_csv(site, query) do
- {metrics, column_headers} = csv_graph_metrics(query)
-
- map_bucket_to_row = fn bucket -> Enum.map([:date | metrics], &bucket[&1]) end
- prepend_column_headers = fn data -> [column_headers | data] end
-
- Plausible.Stats.timeseries(site, query, metrics)
- |> elem(0)
- |> Enum.map(map_bucket_to_row)
- |> prepend_column_headers.()
- |> NimbleCSV.RFC4180.dump_to_iodata()
- end
-
- defp csv_graph_metrics(query) do
- include_scroll_depth? =
- !query.include_imported &&
- Filters.filtering_on_dimension?(query, "event:page", behavioral_filters: :ignore)
-
- {metrics, column_headers} =
- if Filters.filtering_on_dimension?(query, "event:goal", max_depth: 0) do
- {
- [:visitors, :events, :conversion_rate],
- [:date, :unique_conversions, :total_conversions, :conversion_rate]
- }
- else
- metrics = [
- :visitors,
- :pageviews,
- :visits,
- :views_per_visit,
- :bounce_rate,
- :visit_duration
- ]
-
- metrics = if include_scroll_depth?, do: metrics ++ [:scroll_depth], else: metrics
-
- {
- metrics,
- [:date | metrics]
- }
- end
-
- {metrics, column_headers}
- end
-
@doc """
Authorizes and renders a shared link:
1. Shared link with no password protection: needs to just make sure the shared link entry is still
@@ -550,7 +434,7 @@ defmodule PlausibleWeb.StatsController do
defp get_flags(user, site),
do:
- [:dashboard_csv_export_v2]
+ []
|> Enum.map(fn flag ->
{flag, FunWithFlags.enabled?(flag, for: user) || FunWithFlags.enabled?(flag, for: site)}
end)
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index a76743397b..d91ed83205 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -176,7 +176,6 @@ defmodule PlausibleWeb.Router do
post "/stats", E2EController, :populate_stats
post "/funnel", E2EController, :create_funnel
post "/goal", E2EController, :create_goal
- post "/enable-dashboard-csv-export-v2", E2EController, :enable_dashboard_csv_export_v2
end
end
end
@@ -286,30 +285,9 @@ defmodule PlausibleWeb.Router do
scope private: %{allow_consolidated_views: true} do
post "/:domain/query", StatsController, :query
- post "/:domain/export", StatsController, :csv_export_v2
+ post "/:domain/export", StatsController, :csv_export
get "/:domain/google-search-terms", StatsController, :google_search_terms
get "/:domain/current-visitors", StatsController, :current_visitors
- get "/:domain/sources", StatsController, :sources
- get "/:domain/channels", StatsController, :channels
- get "/:domain/utm_mediums", StatsController, :utm_mediums
- get "/:domain/utm_sources", StatsController, :utm_sources
- get "/:domain/utm_campaigns", StatsController, :utm_campaigns
- get "/:domain/utm_contents", StatsController, :utm_contents
- get "/:domain/utm_terms", StatsController, :utm_terms
- get "/:domain/referrers/:referrer", StatsController, :referrer_drilldown
- get "/:domain/pages", StatsController, :pages
- get "/:domain/entry-pages", StatsController, :entry_pages
- get "/:domain/exit-pages", StatsController, :exit_pages
- get "/:domain/countries", StatsController, :countries
- get "/:domain/regions", StatsController, :regions
- get "/:domain/cities", StatsController, :cities
- get "/:domain/browsers", StatsController, :browsers
- get "/:domain/browser-versions", StatsController, :browser_versions
- get "/:domain/operating-systems", StatsController, :operating_systems
- get "/:domain/operating-system-versions", StatsController, :operating_system_versions
- get "/:domain/screen-sizes", StatsController, :screen_sizes
- get "/:domain/conversions", StatsController, :conversions
- get "/:domain/custom-prop-values/:prop_key", StatsController, :custom_prop_values
get "/:domain/suggestions/:filter_name", StatsController, :filter_suggestions
get "/:domain/suggestions/custom-prop-values/:prop_key",
@@ -718,7 +696,6 @@ defmodule PlausibleWeb.Router do
put "/:domain/settings", SiteController, :update_settings
- get "/:domain/export", StatsController, :csv_export
get "/:domain", StatsController, :stats
get "/:domain/*path", StatsController, :stats
end
diff --git a/test/plausible_web/controllers/CSVs/30d-filter-path/exit_pages_legacy.csv b/test/plausible_web/controllers/CSVs/30d-filter-path/exit_pages_legacy.csv
deleted file mode 100644
index 736ba6d58f..0000000000
--- a/test/plausible_web/controllers/CSVs/30d-filter-path/exit_pages_legacy.csv
+++ /dev/null
@@ -1,2 +0,0 @@
-name,unique_exits,total_exits,exit_rate
-/some-other-page,1,1,
diff --git a/test/plausible_web/controllers/CSVs/30d-filter-path/visitors_legacy.csv b/test/plausible_web/controllers/CSVs/30d-filter-path/visitors_legacy.csv
deleted file mode 100644
index c1e30fab06..0000000000
--- a/test/plausible_web/controllers/CSVs/30d-filter-path/visitors_legacy.csv
+++ /dev/null
@@ -1,32 +0,0 @@
-date,visitors,pageviews,visits,views_per_visit,bounce_rate,visit_duration,scroll_depth
-2021-09-20,0,0,0,0.0,0.0,,
-2021-09-21,0,0,0,0.0,0.0,,
-2021-09-22,0,0,0,0.0,0.0,,
-2021-09-23,0,0,0,0.0,0.0,,
-2021-09-24,0,0,0,0.0,0.0,,
-2021-09-25,0,0,0,0.0,0.0,,
-2021-09-26,0,0,0,0.0,0.0,,
-2021-09-27,0,0,0,0.0,0.0,,
-2021-09-28,0,0,0,0.0,0.0,,
-2021-09-29,0,0,0,0.0,0.0,,
-2021-09-30,0,0,0,0.0,0.0,,
-2021-10-01,0,0,0,0.0,0.0,,
-2021-10-02,0,0,0,0.0,0.0,,
-2021-10-03,0,0,0,0.0,0.0,,
-2021-10-04,0,0,0,0.0,0.0,,
-2021-10-05,0,0,0,0.0,0.0,,
-2021-10-06,0,0,0,0.0,0.0,,
-2021-10-07,0,0,0,0.0,0.0,,
-2021-10-08,0,0,0,0.0,0.0,,
-2021-10-09,0,0,0,0.0,0.0,,
-2021-10-10,0,0,0,0.0,0.0,,
-2021-10-11,0,0,0,0.0,0.0,,
-2021-10-12,0,0,0,0.0,0.0,,
-2021-10-13,0,0,0,0.0,0.0,,
-2021-10-14,0,0,0,0.0,0.0,,
-2021-10-15,0,0,0,0.0,0.0,,
-2021-10-16,0,0,0,0.0,0.0,,
-2021-10-17,0,0,0,0.0,0.0,,
-2021-10-18,0,0,0,0.0,0.0,,
-2021-10-19,0,0,0,0.0,0.0,,
-2021-10-20,1,1,1,2.0,0,60,30
diff --git a/test/plausible_web/controllers/api/stats_controller/browsers_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/browsers_legacy_test.exs
deleted file mode 100644
index 13c8825c50..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/browsers_legacy_test.exs
+++ /dev/null
@@ -1,588 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.BrowsersLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/browsers" do
- setup [:create_user, :log_in, :create_site, :create_site_import]
-
- test "returns top browsers by unique visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, browser: "Chrome"),
- build(:pageview, browser: "Chrome"),
- build(:pageview, browser: "Firefox")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Chrome", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Firefox", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns top browsers with :is filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- browser: "Chrome"
- ),
- build(:pageview,
- user_id: 123,
- browser: "Chrome",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- browser: "Firefox",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- browser: "Safari"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Chrome", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "returns top browsers with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- browser: "Chrome",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- user_id: 123,
- browser: "Chrome",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- browser: "Firefox",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- browser: "Safari"
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Firefox", "visitors" => 1, "percentage" => 50},
- %{"name" => "Safari", "visitors" => 1, "percentage" => 50}
- ]
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- insert(:goal, site: site, event_name: "Signup")
-
- populate_stats(site, [
- build(:pageview, user_id: 1, browser: "Chrome"),
- build(:pageview, user_id: 2, browser: "Chrome"),
- build(:event, user_id: 1, name: "Signup")
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Chrome",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns top browsers including imported data", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, site_import.id, [
- build(:pageview, browser: "Chrome"),
- build(:imported_browsers, browser: "Chrome"),
- build(:imported_browsers, browser: "Firefox"),
- build(:imported_visitors, visitors: 2)
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/browsers?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "Chrome", "visitors" => 1, "percentage" => 100}
- ]
-
- conn2 = get(conn, "/api/stats/#{site.domain}/browsers?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "Chrome", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Firefox", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "skips breakdown when visitors=0 (possibly due to 'Enable Users Metric' in GA)", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, site_import.id, [
- build(:imported_browsers, browser: "Chrome", visitors: 0, visits: 14),
- build(:imported_browsers, browser: "Firefox", visitors: 0, visits: 14),
- build(:imported_browsers,
- browser: "''",
- visitors: 0,
- visits: 14,
- visit_duration: 0,
- bounces: 14
- )
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == []
- end
-
- test "returns (not set) when appropriate", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- browser: ""
- )
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 100.0}
- ]
- end
-
- test "select empty imported_browsers as (not set), merging with the native (not set)", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, site_import.id, [
- build(:pageview, user_id: 123),
- build(:imported_browsers, visitors: 1),
- build(:imported_visitors, visitors: 1)
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 2, "percentage" => 100.0}
- ]
- end
-
- test "returns comparisons", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Safari", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Chrome", timestamp: ~N[2021-01-07 00:00:00]),
- build(:pageview, browser: "Chrome", timestamp: ~N[2021-01-07 00:00:00]),
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-07 00:00:00])
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browsers?period=7d&date=2021-01-14&comparison=previous_period"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Chrome",
- "visitors" => 2,
- "percentage" => 66.67,
- "comparison" => %{
- "visitors" => 0,
- "percentage" => 0.0,
- "change" => %{"percentage" => 100, "visitors" => 100}
- }
- },
- %{
- "name" => "Firefox",
- "visitors" => 1,
- "percentage" => 33.33,
- "comparison" => %{
- "visitors" => 1,
- "percentage" => 50.0,
- "change" => %{"percentage" => -33, "visitors" => 0}
- }
- }
- ]
-
- assert json_response(conn, 200)["meta"] == %{
- "date_range_label" => "7 Jan - 13 Jan 2021",
- "comparison_date_range_label" => "31 Dec 2020 - 6 Jan 2021"
- }
- end
-
- test "returns comparisons with limit", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Chrome", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, browser: "Chrome", timestamp: ~N[2021-01-07 00:00:00]),
- build(:pageview, browser: "Chrome", timestamp: ~N[2021-01-07 00:00:00]),
- build(:pageview, browser: "Firefox", timestamp: ~N[2021-01-07 00:00:00])
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browsers?period=7d&date=2021-01-13&comparison=previous_period&limit=1"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Chrome",
- "visitors" => 2,
- "percentage" => 66.67,
- "comparison" => %{
- "visitors" => 1,
- "percentage" => 25.0,
- "change" => %{"percentage" => 167, "visitors" => 100}
- }
- }
- ]
-
- assert json_response(conn, 200)["meta"] == %{
- "date_range_label" => "6 Jan - 12 Jan 2021",
- "comparison_date_range_label" => "30 Dec 2020 - 5 Jan 2021"
- }
- end
-
- @tag :ee_only
- test "return revenue metrics for browsers breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, browser: "Firefox"),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, browser: "Firefox"),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, browser: "Firefox"),
- build(:pageview, user_id: 4, browser: "Safari"),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 5, browser: "Safari"),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/browsers#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "conversion_rate" => 100.0,
- "name" => "(not set)",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "Firefox",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "Safari",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/browser-versions" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns correct conversion_rate when browser_version clashes across browsers", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event, browser: "Chrome", browser_version: "110", name: "Signup"),
- build(:event, browser: "Chrome", browser_version: "110", name: "Signup"),
- build(:pageview, browser: "Chrome", browser_version: "110"),
- build(:pageview, browser: "Chrome", browser_version: "121"),
- build(:pageview, browser: "Chrome", browser_version: "121"),
- build(:event, browser: "Firefox", browser_version: "121", name: "Signup"),
- build(:pageview, browser: "Firefox", browser_version: "110"),
- build(:pageview, browser: "Firefox", browser_version: "110"),
- build(:pageview, browser: "Firefox", browser_version: "110"),
- build(:pageview, browser: "Firefox", browser_version: "110")
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- json_response =
- get(
- conn,
- "/api/stats/#{site.domain}/browser-versions?period=day&filters=#{filters}"
- )
- |> json_response(200)
- |> Map.get("results")
-
- assert %{
- "name" => "Chrome 110",
- "browser" => "Chrome",
- "conversion_rate" => 66.67,
- "version" => "110",
- "total_visitors" => 3,
- "visitors" => 2
- } == List.first(json_response)
-
- assert %{
- "name" => "Firefox 121",
- "browser" => "Firefox",
- "conversion_rate" => 100.0,
- "version" => "121",
- "total_visitors" => 1,
- "visitors" => 1
- } == List.last(json_response)
- end
-
- test "returns top browser versions by unique visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, browser: "Chrome", browser_version: "78.0"),
- build(:pageview, browser: "Chrome", browser_version: "78.0"),
- build(:pageview, browser: "Chrome", browser_version: "77.0"),
- build(:pageview, browser: "Firefox", browser_version: "88.0")
- ])
-
- filters = Jason.encode!([[:is, "visit:browser", ["Chrome"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browser-versions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Chrome 78.0",
- "version" => "78.0",
- "visitors" => 2,
- "percentage" => 66.67,
- "browser" => "Chrome"
- },
- %{
- "name" => "Chrome 77.0",
- "version" => "77.0",
- "visitors" => 1,
- "percentage" => 33.33,
- "browser" => "Chrome"
- }
- ]
- end
-
- test "returns only version under the name key (+ additional metrics) when 'detailed' is true in params",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [build(:pageview, browser: "Chrome", browser_version: "78.0")])
-
- filters = Jason.encode!([[:is, "visit:browser", ["Chrome"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browser-versions?filters=#{filters}&detailed=true&period=day"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "78.0",
- "browser" => "Chrome",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "returns results for (not set)", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, browser: "", browser_version: "")
- ])
-
- filters = Jason.encode!([[:is, "visit:browser", ["(not set)"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browser-versions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "(not set)",
- "visitors" => 1,
- "percentage" => 100,
- "browser" => "(not set)",
- "version" => "(not set)"
- }
- ]
- end
-
- test "with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- browser: "Chrome",
- browser_version: "121",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- browser: "Chrome",
- browser_version: "110",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:imported_browsers,
- date: ~D[2021-01-01],
- browser: "Chrome",
- browser_version: "121",
- visitors: 5
- ),
- build(:imported_browsers,
- date: ~D[2021-01-01],
- browser: "Firefox",
- browser_version: "121",
- visitors: 3
- ),
- build(:imported_browsers, date: ~D[2021-01-01], visitors: 10),
- build(:imported_visitors, date: ~D[2021-01-01], visitors: 18)
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browser-versions?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "browser" => "(not set)",
- "version" => "(not set)",
- "name" => "(not set)",
- "visitors" => 10,
- "percentage" => 50.0
- },
- %{
- "browser" => "Chrome",
- "version" => "121",
- "name" => "Chrome 121",
- "visitors" => 6,
- "percentage" => 30.0
- },
- %{
- "browser" => "Firefox",
- "version" => "121",
- "name" => "Firefox 121",
- "visitors" => 3,
- "percentage" => 15.0
- },
- %{
- "browser" => "Chrome",
- "version" => "110",
- "name" => "Chrome 110",
- "visitors" => 1,
- "percentage" => 5.0
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/cities_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/cities_legacy_test.exs
deleted file mode 100644
index d45a4d2e0e..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/cities_legacy_test.exs
+++ /dev/null
@@ -1,222 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.CitiesLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/cities" do
- defp seed(%{site: site}) do
- populate_stats(site, [
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- )
- ])
- end
-
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import, :seed]
-
- test "returns top cities by new visitors", %{conn: conn, site: site} do
- conn = get(conn, "/api/stats/#{site.domain}/cities?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => 588_409,
- "country_flag" => "🇪🇪",
- "name" => "Tallinn",
- "visitors" => 3,
- "percentage" => 60.0
- },
- %{
- "code" => 591_632,
- "country_flag" => "🇪🇪",
- "name" => "Kärdla",
- "visitors" => 2,
- "percentage" => 40.0
- }
- ]
- end
-
- test "when list is filtered returns one city only", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "visit:city", ["591632"]]])
- conn = get(conn, "/api/stats/#{site.domain}/cities?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => 591_632,
- "country_flag" => "🇪🇪",
- "name" => "Kärdla",
- "visitors" => 2,
- "percentage" => 100.0
- }
- ]
- end
-
- test "does not return missing cities from imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:imported_locations, country: "EE", region: "EE-37", city: 588_409),
- build(:imported_locations, country: nil, region: nil, city: 0),
- build(:imported_locations, country: nil, region: nil, city: nil)
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/cities?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => 588_409,
- "country_flag" => "🇪🇪",
- "name" => "Tallinn",
- "visitors" => 4,
- "percentage" => 66.67
- },
- %{
- "code" => 591_632,
- "country_flag" => "🇪🇪",
- "name" => "Kärdla",
- "visitors" => 2,
- "percentage" => 33.33
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for cities breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- user_id: 4,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/cities#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 33.33,
- "name" => "Tallinn",
- "code" => 588_409,
- "country_flag" => "🇪🇪",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 6,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 25.0,
- "name" => "Kärdla",
- "code" => 591_632,
- "country_flag" => "🇪🇪",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 4,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/conversions_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/conversions_legacy_test.exs
deleted file mode 100644
index 74cef7192c..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/conversions_legacy_test.exs
+++ /dev/null
@@ -1,1462 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.ConversionsLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- @user_id Enum.random(1000..9999)
-
- describe "GET /api/stats/:domain/conversions" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns mixed pageview and custom event goal conversions ordered by count", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/register"),
- build(:pageview, pathname: "/register"),
- build(:event, name: "Signup", "meta.key": ["variant"], "meta.value": ["A"]),
- build(:event,
- user_id: @user_id,
- name: "Signup",
- "meta.key": ["variant"],
- "meta.value": ["A"]
- ),
- build(:event,
- user_id: @user_id,
- name: "Signup",
- "meta.key": ["variant"],
- "meta.value": ["B"]
- ),
- build(:event, name: "Signup")
- ])
-
- insert(:goal, %{site: site, page_path: "/register"})
- insert(:goal, %{site: site, event_name: "Signup"})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Signup",
- "visitors" => 3,
- "events" => 4,
- "conversion_rate" => 42.86
- },
- %{
- "name" => "Visit /register",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 28.57
- }
- ]
- end
-
- test "returns page scroll goals ordered by count", %{conn: conn, site: site} do
- populate_stats(site, [
- # user 1: /blog -> /another -> blog/posts/1
- build(:pageview, user_id: 1, pathname: "/blog", timestamp: ~N[2020-01-01 00:00:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/blog",
- timestamp: ~N[2020-01-01 00:01:00],
- scroll_depth: 20
- ),
- build(:pageview, user_id: 1, pathname: "/another", timestamp: ~N[2020-01-01 00:01:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/another",
- timestamp: ~N[2020-01-01 00:02:00],
- scroll_depth: 100
- ),
- build(:pageview,
- user_id: 1,
- pathname: "/blog/posts/1",
- timestamp: ~N[2020-01-01 00:02:00]
- ),
- build(:engagement,
- user_id: 1,
- pathname: "/blog/posts/1",
- timestamp: ~N[2020-01-01 00:03:00],
- scroll_depth: 55
- ),
- # user 2: /blog -> /blog/posts/1 -> /blog/posts/2
- build(:pageview, user_id: 2, pathname: "/blog", timestamp: ~N[2020-01-01 00:00:00]),
- build(:engagement,
- user_id: 2,
- pathname: "/blog",
- timestamp: ~N[2020-01-01 00:01:00],
- scroll_depth: 60
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/blog/posts/1",
- timestamp: ~N[2020-01-01 00:02:00]
- ),
- build(:engagement,
- user_id: 2,
- pathname: "/blog/posts/1",
- timestamp: ~N[2020-01-01 00:03:00],
- scroll_depth: 100
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/blog/posts/2",
- timestamp: ~N[2020-01-01 00:02:00]
- ),
- build(:engagement,
- user_id: 2,
- pathname: "/blog/posts/2",
- timestamp: ~N[2020-01-01 00:03:00],
- scroll_depth: 100
- )
- ])
-
- insert(:goal, %{
- site: site,
- page_path: "/blog/**",
- scroll_threshold: 50,
- display_name: "Scroll 50 /blog/**"
- })
-
- insert(:goal, %{
- site: site,
- page_path: "/blog/posts/1",
- scroll_threshold: 75,
- display_name: "Scroll 75 /blog/posts/1"
- })
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&date=2020-01-01")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Scroll 50 /blog/**",
- "visitors" => 2,
- "events" => nil,
- "conversion_rate" => 100.0
- },
- %{
- "name" => "Scroll 75 /blog/posts/1",
- "visitors" => 1,
- "events" => nil,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns conversions when a direct :is filter on event prop", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "true"]
- ),
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["500", "true"]
- ),
- build(:event,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "false"]
- ),
- build(:event,
- name: "Payment",
- "meta.key": ["amount"],
- "meta.value": ["200"]
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment"})
-
- filters = Jason.encode!([[:is, "event:props:logged_in", ["true"]]])
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 1,
- "events" => 2,
- "conversion_rate" => 33.33
- }
- ]
- end
-
- test "returns conversions when a direct :is_not filter on event prop", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "true"]
- ),
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["500", "true"]
- ),
- build(:event,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "false"]
- ),
- build(:event, name: "Payment")
- ])
-
- insert(:goal, %{site: site, event_name: "Payment"})
-
- filters = Jason.encode!([[:is_not, "event:props:logged_in", ["true"]]])
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 66.67
- }
- ]
- end
-
- test "returns conversions when a direct :is (none) filter on event prop", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event,
- user_id: @user_id,
- name: "Payment"
- ),
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount"],
- "meta.value": ["500"]
- ),
- build(:event,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "false"]
- ),
- build(:event, name: "Payment")
- ])
-
- insert(:goal, %{site: site, event_name: "Payment"})
-
- filters = Jason.encode!([[:is, "event:props:logged_in", ["(none)"]]])
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 2,
- "events" => 3,
- "conversion_rate" => 66.67
- }
- ]
- end
-
- test "returns conversions when a direct :is_not (none) filter on event prop", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["500", "false"]
- ),
- build(:event,
- user_id: @user_id,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["500", "true"]
- ),
- build(:event,
- name: "Payment",
- "meta.key": ["amount", "logged_in"],
- "meta.value": ["100", "false"]
- ),
- build(:event, name: "Payment")
- ])
-
- insert(:goal, %{site: site, event_name: "Payment"})
-
- filters = Jason.encode!([[:is_not, "event:props:logged_in", ["(none)"]]])
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 2,
- "events" => 3,
- "conversion_rate" => 66.67
- }
- ]
- end
-
- @tag capture_log: true
- test "garbage filters don't crash the call", %{conn: conn, site: site} do
- filters =
- "{\"source\":\"Direct / None\",\"screen\":\"Desktop\",\"browser\":\"Chrome\",\"os\":\"Mac\",\"os_version\":\"10.15\",\"country\":\"DE\",\"city\":\"2950159\"}%' AND 2*3*8=6*8 AND 'L9sv'!='L9sv%"
-
- resp =
- conn
- |> get("/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
- |> json_response(200)
- |> Map.get("results")
-
- assert resp == []
- end
-
- test "filtering by session attribute and multiple goals", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event,
- user_id: @user_id,
- name: "Payment",
- browser: "Firefox"
- ),
- build(:event,
- user_id: @user_id,
- name: "Payment",
- browser: "Firefox"
- ),
- build(:event,
- name: "Payment",
- browser: "Chrome"
- ),
- build(:event, name: "Payment"),
- build(:pageview, browser: "Firefox", pathname: "/"),
- build(:pageview, browser: "Firefox", pathname: "/register")
- ])
-
- insert(:goal, %{site: site, event_name: "Payment"})
- insert(:goal, %{site: site, page_path: "/register"})
-
- filters = Jason.encode!([[:is, "visit:browser", ["Firefox"]]])
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 1,
- "events" => 2,
- "conversion_rate" => 33.33
- },
- %{
- "name" => "Visit /register",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 33.33
- }
- ]
- end
-
- @tag :ee_only
- test "returns formatted average and total values for a conversion with revenue value", %{
- conn: conn,
- site: site
- } do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("200100300.123"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("300100400.123"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("0"),
- revenue_reporting_currency: "USD"
- ),
- build(:event, name: "Payment", revenue_reporting_amount: nil),
- build(:event, name: "Payment", revenue_reporting_amount: nil)
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :EUR})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 5,
- "events" => 5,
- "conversion_rate" => 100.0,
- "average_revenue" => %{
- "short" => "€166.7M",
- "long" => "€166,733,566.75",
- "value" => 166_733_566.748,
- "currency" => "EUR"
- },
- "total_revenue" => %{
- "short" => "€500.2M",
- "long" => "€500,200,700.25",
- "value" => 500_200_700.246,
- "currency" => "EUR"
- }
- }
- ]
- end
-
- @tag :ee_only
- test "returns revenue goals as custom events if the plan doesn't cover the feature", %{
- conn: conn,
- site: site,
- user: user
- } do
- user
- |> team_of()
- |> Plausible.Teams.Team.end_trial()
- |> Plausible.Repo.update!()
-
- populate_stats(site, [
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("200100300.123"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("300100400.123"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("0"),
- revenue_reporting_currency: "USD"
- ),
- build(:event, name: "Payment", revenue_reporting_amount: nil),
- build(:event, name: "Payment", revenue_reporting_amount: nil)
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :EUR})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Payment",
- "visitors" => 5,
- "events" => 5,
- "conversion_rate" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "excludes goals with custom props when Props feature is unavailable", %{
- conn: conn,
- site: site,
- user: user
- } do
- user
- |> team_of()
- |> Plausible.Teams.Team.end_trial()
- |> Plausible.Repo.update!()
-
- populate_stats(site, [
- build(:event, name: "Signup"),
- build(:event, name: "Signup"),
- build(:event, name: "Signup")
- ])
-
- {:ok, _goal_with_props} =
- Plausible.Goals.create(site, %{
- "event_name" => "Purchase",
- "custom_props" => %{"product" => "Shirt"}
- })
-
- insert(:goal, %{site: site, event_name: "Signup"})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Signup",
- "visitors" => 3,
- "events" => 3,
- "conversion_rate" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "includes goals with custom props when Props feature is available", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event, name: "Purchase", "meta.key": ["product"], "meta.value": ["Shirt"]),
- build(:event, name: "Purchase", "meta.key": ["product"], "meta.value": ["Shirt"])
- ])
-
- {:ok, _goal_with_props} =
- Plausible.Goals.create(site, %{
- "event_name" => "Purchase",
- "custom_props" => %{"product" => "Shirt"}
- })
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
-
- results = json_response(conn, 200)["results"]
-
- assert length(results) == 1
- assert hd(results)["name"] == "Purchase"
- assert hd(results)["visitors"] == 2
- end
-
- @tag :ee_only
- test "returns correct conversion stats for goals with and without custom properties", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event, name: "Purchase", "meta.key": ["product"], "meta.value": ["Shirt"]),
- build(:event, name: "Purchase", "meta.key": ["product"], "meta.value": ["Jacket"])
- ])
-
- {:ok, _} =
- Plausible.Goals.create(
- site,
- %{
- "event_name" => "Purchase",
- "display_name" => "Purchase - Shirt",
- "custom_props" => %{"product" => "Shirt"}
- }
- )
-
- {:ok, _} =
- Plausible.Goals.create(
- site,
- %{
- "event_name" => "Purchase",
- "display_name" => "Purchase - Jacket",
- "custom_props" => %{"product" => "Jacket"}
- }
- )
-
- {:ok, _} =
- Plausible.Goals.create(
- site,
- %{
- "event_name" => "Purchase",
- "display_name" => "Purchase - All"
- }
- )
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
- response = json_response(conn, 200)
- results = response["results"]
-
- assert [
- %{
- "conversion_rate" => 100.0,
- "events" => 2,
- "name" => "Purchase - All",
- "visitors" => 2
- },
- %{
- "conversion_rate" => 50.0,
- "events" => 1,
- "name" => "Purchase - Shirt",
- "visitors" => 1
- },
- %{
- "conversion_rate" => 50.0,
- "events" => 1,
- "name" => "Purchase - Jacket",
- "visitors" => 1
- }
- ] =
- results
- end
-
- @tag :ee_only
- test "handles mixed goals with and without custom props (2)", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event, name: "Signup"),
- build(:event, name: "Purchase", "meta.key": ["product"], "meta.value": ["Shirt"])
- ])
-
- {:ok, _goal_with_props} =
- Plausible.Goals.create(
- site,
- %{
- "event_name" => "Purchase",
- "custom_props" => %{"product" => "Shirt"}
- }
- )
-
- insert(:goal, %{site: site, event_name: "Signup"})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
- response = json_response(conn, 200)
- results = response["results"]
-
- assert [
- %{"conversion_rate" => 50.0, "events" => 1, "name" => "Purchase", "visitors" => 1},
- %{"conversion_rate" => 50.0, "events" => 1, "name" => "Signup", "visitors" => 1}
- ] =
- results
- end
-
- @tag :ee_only
- test "returns revenue metrics as nil for non-revenue goals", %{
- conn: conn,
- site: site
- } do
- [
- build(:event,
- name: "Payment",
- pathname: "/checkout",
- revenue_reporting_amount: Decimal.new("10.00"),
- revenue_reporting_currency: "EUR"
- )
- ]
- |> Enum.concat(build_list(2, :event, name: "Signup"))
- |> Enum.concat(build_list(3, :pageview, pathname: "/checkout"))
- |> then(fn events -> populate_stats(site, events) end)
-
- insert(:goal, %{site: site, event_name: "Signup"})
- insert(:goal, %{site: site, page_path: "/checkout"})
- insert(:goal, %{site: site, event_name: "Payment", currency: :EUR})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
- response = json_response(conn, 200)["results"]
-
- assert [
- %{
- "average_revenue" => %{
- "long" => "€10.00",
- "short" => "€10.0",
- "value" => 10.0,
- "currency" => "EUR"
- },
- "conversion_rate" => 16.67,
- "name" => "Payment",
- "events" => 1,
- "total_revenue" => %{
- "long" => "€10.00",
- "short" => "€10.0",
- "value" => 10.0,
- "currency" => "EUR"
- },
- "visitors" => 1
- },
- %{
- "average_revenue" => nil,
- "conversion_rate" => 33.33,
- "name" => "Signup",
- "events" => 2,
- "total_revenue" => nil,
- "visitors" => 2
- },
- %{
- "average_revenue" => nil,
- "conversion_rate" => 50.0,
- "name" => "Visit /checkout",
- "events" => 3,
- "total_revenue" => nil,
- "visitors" => 3
- }
- ] == Enum.sort_by(response, & &1["name"])
- end
-
- test "does not return revenue metrics if no revenue goals are returned", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event, name: "Signup")
- ])
-
- insert(:goal, %{site: site, event_name: "Signup"})
-
- conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Signup",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 100.0
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/conversions - with goal filter" do
- setup [:create_user, :log_in, :create_site]
-
- test "does not consider custom event pathname as a pageview goal completion", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/register"),
- build(:event, pathname: "/register", name: "Signup")
- ])
-
- insert(:goal, %{site: site, page_path: "/register"})
- insert(:goal, %{site: site, event_name: "Signup"})
-
- get_with_filter = fn filters ->
- path = "/api/stats/#{site.domain}/conversions"
- query = "?period=day&filters=#{Jason.encode!(filters)}"
-
- get(conn, path <> query)
- |> json_response(200)
- |> Map.get("results")
- end
-
- expected = [
- %{
- "name" => "Signup",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 33.33
- }
- ]
-
- # {:is, {:event, event}} filter type
- assert get_with_filter.([[:is, "event:goal", ["Signup"]]]) == expected
-
- # {:member, clauses} filter type
- assert get_with_filter.([[:is, "event:goal", ["Signup", "Whatever"]]]) == expected
-
- # {:matches_member, clauses} filter type
- assert get_with_filter.([[:is, "event:goal", ["Signup", "Visit /whatever*"]]]) == expected
- end
-
- test "does not return custom events with the filtered pageview goal pathname", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/register"),
- build(:event, pathname: "/register", name: "Signup")
- ])
-
- insert(:goal, %{site: site, page_path: "/register"})
- insert(:goal, %{site: site, event_name: "Signup"})
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /register"]]])
-
- results =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}"
- )
- |> json_response(200)
- |> Map.get("results")
-
- assert results == [
- %{
- "name" => "Visit /register",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 33.33
- }
- ]
- end
-
- test "can filter by multiple mixed goals", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/another"),
- build(:pageview, pathname: "/register"),
- build(:event, name: "Signup"),
- build(:event, name: "Signup")
- ])
-
- insert(:goal, %{site: site, page_path: "/register"})
- insert(:goal, %{site: site, event_name: "Signup"})
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup", "Visit /register"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Signup",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 33.33
- },
- %{
- "name" => "Visit /register",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 16.67
- }
- ]
- end
-
- test "can combine wildcard and no wildcard in matches_member", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/blog/post-1"),
- build(:pageview, pathname: "/blog/post-2"),
- build(:pageview, pathname: "/billing/upgrade")
- ])
-
- insert(:goal, %{site: site, page_path: "/blog/**"})
- insert(:goal, %{site: site, page_path: "/billing/upgrade"})
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /blog/**", "Visit /billing/upgrade"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Visit /blog/**",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 66.67
- },
- %{
- "name" => "Visit /billing/upgrade",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 33.33
- }
- ]
- end
-
- test "can filter by matches_member filter type on goals", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/another"),
- build(:pageview, pathname: "/blog/post-1"),
- build(:pageview, pathname: "/blog/post-2"),
- build(:event, name: "CTA"),
- build(:event, name: "Signup")
- ])
-
- insert(:goal, %{site: site, page_path: "/blog**"})
- insert(:goal, %{site: site, event_name: "CTA"})
- insert(:goal, %{site: site, event_name: "Signup"})
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup", "Visit /blog**"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Visit /blog**",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 33.33
- },
- %{
- "name" => "Signup",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 16.67
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/conversions - with goal and prop=(none) filter" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns only the conversion that is filtered for", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/", user_id: 1),
- build(:pageview, pathname: "/", user_id: 2),
- build(:event, name: "Signup", user_id: 1, "meta.key": ["variant"], "meta.value": ["A"]),
- build(:event, name: "Signup", user_id: 2)
- ])
-
- insert(:goal, %{site: site, event_name: "Signup"})
-
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Signup"]],
- [:is, "event:props:variant", ["(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Signup",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/conversions - with glob goals" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns correct and sorted glob goal counts", %{conn: conn, site: site} do
- insert(:goal, %{site: site, page_path: "/register"})
- insert(:goal, %{site: site, page_path: "/reg*"})
- insert(:goal, %{site: site, page_path: "/*/register"})
- insert(:goal, %{site: site, page_path: "/billing*/success"})
- insert(:goal, %{site: site, page_path: "/signup"})
- insert(:goal, %{site: site, page_path: "/signup/*"})
- insert(:goal, %{site: site, page_path: "/*"})
-
- populate_stats(site, [
- build(:pageview,
- pathname: "/hum",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/register",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/reg",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/billing/success",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/billing/upgrade/success",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/signup/new",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/signup/new/2",
- timestamp: ~N[2019-07-01 23:00:00]
- ),
- build(:pageview,
- pathname: "/signup/new/3",
- timestamp: ~N[2019-07-01 23:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&date=2019-07-01"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "conversion_rate" => 100.0,
- "visitors" => 8,
- "name" => "Visit /*",
- "events" => 8
- },
- %{
- "conversion_rate" => 37.5,
- "visitors" => 3,
- "name" => "Visit /signup/*",
- "events" => 3
- },
- %{
- "conversion_rate" => 25.0,
- "visitors" => 2,
- "name" => "Visit /billing*/success",
- "events" => 2
- },
- %{
- "conversion_rate" => 25.0,
- "visitors" => 2,
- "name" => "Visit /reg*",
- "events" => 2
- },
- %{
- "conversion_rate" => 12.5,
- "visitors" => 1,
- "name" => "Visit /register",
- "events" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/conversions - with imported data" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns custom event goals and pageview goals", %{conn: conn, site: site} do
- insert(:goal, site: site, event_name: "Purchase")
- insert(:goal, site: site, page_path: "/test")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/test"
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:imported_custom_events,
- name: "Purchase",
- visitors: 3,
- events: 5,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/test",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 5, date: ~D[2021-01-01])
- ])
-
- url_query_params = "?period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{url_query_params}")
-
- assert [
- %{
- "name" => "Purchase",
- "visitors" => 5,
- "events" => 7,
- "conversion_rate" => 62.5
- },
- %{
- "name" => "Visit /test",
- "visitors" => 3,
- "events" => 3,
- "conversion_rate" => 37.5
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "returns only custom event goals with a custom event goal filter", %{
- conn: conn,
- site: site
- } do
- insert(:goal, site: site, event_name: "Purchase")
- insert(:goal, site: site, event_name: "Activation")
- insert(:goal, site: site, page_path: "/test")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/test"
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:imported_custom_events,
- name: "Purchase",
- visitors: 3,
- events: 5,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/test",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 5, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Purchase"]]])
- url_query_params = "?filters=#{filters}&period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{url_query_params}")
-
- assert [
- %{
- "name" => "Purchase",
- "visitors" => 5,
- "events" => 7,
- "conversion_rate" => 62.5
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "returns custom event goals with more than one option in goal filter", %{
- conn: conn,
- site: site
- } do
- insert(:goal, site: site, event_name: "Purchase")
- insert(:goal, site: site, event_name: "Activation")
- insert(:goal, site: site, page_path: "/test")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/test"
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Activation",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:imported_custom_events,
- name: "Purchase",
- visitors: 3,
- events: 5,
- date: ~D[2021-01-01]
- ),
- build(:imported_custom_events,
- name: "Activation",
- visitors: 2,
- events: 4,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/test",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 5, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Purchase", "Activation"]]])
- url_query_params = "?filters=#{filters}&period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{url_query_params}")
-
- assert [
- %{
- "name" => "Purchase",
- "visitors" => 5,
- "events" => 7,
- "conversion_rate" => 55.56
- },
- %{
- "name" => "Activation",
- "visitors" => 3,
- "events" => 5,
- "conversion_rate" => 33.33
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "returns only pageview goals with a pageview goal filter", %{
- conn: conn,
- site: site
- } do
- insert(:goal, site: site, event_name: "Purchase")
- insert(:goal, site: site, event_name: "Activation")
- insert(:goal, site: site, page_path: "/test")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/test"
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:imported_custom_events,
- name: "Purchase",
- visitors: 3,
- events: 5,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/test",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 5, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /test"]]])
- url_query_params = "?filters=#{filters}&period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{url_query_params}")
-
- assert [
- %{
- "name" => "Visit /test",
- "visitors" => 3,
- "events" => 3,
- "conversion_rate" => 37.5
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "returns pageview goals with more than one option in pageview goal filter", %{
- conn: conn,
- site: site
- } do
- insert(:goal, site: site, event_name: "Purchase")
- insert(:goal, site: site, event_name: "Activation")
- insert(:goal, site: site, page_path: "/test")
- insert(:goal, site: site, page_path: "/blog")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/test"
- ),
- build(:pageview,
- timestamp: ~N[2021-01-01 00:00:01],
- pathname: "/blog"
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:event,
- name: "Purchase",
- timestamp: ~N[2021-01-01 00:00:03]
- ),
- build(:imported_custom_events,
- name: "Purchase",
- visitors: 3,
- events: 5,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/test",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/blog",
- visitors: 1,
- pageviews: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 5, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /test", "Visit /blog"]]])
- url_query_params = "?filters=#{filters}&period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{url_query_params}")
-
- assert [
- %{
- "name" => "Visit /test",
- "visitors" => 3,
- "events" => 3,
- "conversion_rate" => 33.33
- },
- %{
- "name" => "Visit /blog",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 22.22
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "returns pageview goals with a page filter", %{
- conn: conn,
- site: site
- } do
- insert(:goal, site: site, page_path: "/blog/two")
- insert(:goal, site: site, page_path: "/blog/thr**")
- insert(:goal, site: site, page_path: "/blog/*")
-
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:imported_pages, page: "/", visitors: 1, pageviews: 1, date: ~D[2021-01-01]),
- build(:imported_pages,
- page: "/blog/one",
- visitors: 2,
- pageviews: 2,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/blog/two",
- visitors: 3,
- pageviews: 3,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/blog/three",
- visitors: 4,
- pageviews: 4,
- date: ~D[2021-01-01]
- ),
- build(:imported_visitors, visitors: 10, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/blog/one", "/blog/two"]]])
- q = "?filters=#{filters}&period=day&date=2021-01-01&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/conversions#{q}")
-
- assert [
- %{
- "name" => "Visit /blog/*",
- "visitors" => 5,
- "events" => 5,
- "conversion_rate" => 100.0
- },
- %{
- "name" => "Visit /blog/two",
- "visitors" => 3,
- "events" => 3,
- "conversion_rate" => 60.0
- }
- ] = json_response(conn, 200)["results"]
- end
-
- test "calculates conversion_rate for goals with glob pattern with imported data", %{
- conn: conn,
- site: site
- } do
- site_import =
- insert(:site_import,
- start_date: ~D[2005-01-01],
- end_date: Date.utc_today(),
- source: :universal_analytics
- )
-
- populate_stats(site, site_import.id, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/another"),
- build(:pageview, pathname: "/blog/post-1"),
- build(:pageview, pathname: "/blog/post-2"),
- build(:imported_pages, page: "/blog/post-1"),
- build(:imported_visitors)
- ])
-
- insert(:goal, %{site: site, page_path: "/blog**"})
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Visit /blog**",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 50
- }
- ]
- end
-
- test "filtering with goal contains filter", %{
- conn: conn,
- site: site
- } do
- site_import =
- insert(:site_import,
- site: site,
- start_date: ~D[2005-01-01],
- end_date: Date.utc_today(),
- source: :universal_analytics
- )
-
- insert(:goal, site: site, event_name: "Onboarding: Step 1")
- insert(:goal, site: site, event_name: "Onboarding: Step 2")
- insert(:goal, site: site, event_name: "Unrelated")
-
- populate_stats(site, site_import.id, [
- build(:event, name: "Onboarding: Step 1"),
- build(:event, name: "Onboarding: Step 1"),
- build(:event, name: "Onboarding: Step 2"),
- build(:event, name: "Unrelated"),
- build(:imported_custom_events, name: "Onboarding: Step 1", visitors: 2, events: 2),
- build(:imported_custom_events, name: "Onboarding: Step 2"),
- build(:imported_custom_events, name: "Unrelated"),
- build(:imported_visitors, visitors: 4)
- ])
-
- filters = Jason.encode!([[:contains, "event:goal", ["Onboarding"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/conversions?period=day&filters=#{filters}&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Onboarding: Step 1",
- "visitors" => 4,
- "events" => 4,
- "conversion_rate" => 50
- },
- %{
- "name" => "Onboarding: Step 2",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 25
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/countries_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/countries_legacy_test.exs
deleted file mode 100644
index 2b1d9765e6..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/countries_legacy_test.exs
+++ /dev/null
@@ -1,559 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.CountriesLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/countries" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top countries by new visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, country_code: "EE"),
- build(:pageview, country_code: "EE"),
- build(:pageview, country_code: "GB"),
- build(:imported_locations, country: "EE"),
- build(:imported_locations, country: "GB"),
- build(:imported_visitors, visitors: 2)
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/countries?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 2,
- "percentage" => 66.67
- },
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 1,
- "percentage" => 33.33
- }
- ]
-
- conn2 = get(conn, "/api/stats/#{site.domain}/countries?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 3,
- "percentage" => 60
- },
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 2,
- "percentage" => 40
- }
- ]
- end
-
- test "ignores unknown country code ZZ", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, country_code: "ZZ"),
- build(:imported_locations, country: "ZZ")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == []
- end
-
- test "includes anonymous VPN country code A1", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, country_code: "A1"),
- build(:pageview, country_code: "A1"),
- build(:pageview, country_code: "EE")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "A1",
- "alpha_3" => nil,
- "name" => "Anonymous VPN Service",
- "flag" => "🏳️",
- "visitors" => 2,
- "percentage" => 66.67
- },
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 1,
- "percentage" => 33.33
- }
- ]
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- country_code: "EE"
- ),
- build(:event, user_id: 1, name: "Signup"),
- build(:pageview,
- user_id: 2,
- country_code: "EE"
- ),
- build(:pageview,
- user_id: 3,
- country_code: "GB"
- ),
- build(:event, user_id: 3, name: "Signup")
- ])
-
- insert(:goal, site: site, event_name: "Signup")
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- },
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "total_visitors" => 1,
- "visitors" => 1,
- "conversion_rate" => 100.0
- }
- ]
- end
-
- test "handles conversion_rate sort directive", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- country_code: "EE"
- ),
- build(:event, user_id: 1, name: "Signup"),
- build(:pageview,
- user_id: 2,
- country_code: "EE"
- ),
- build(:pageview,
- user_id: 3,
- country_code: "GB"
- ),
- build(:event, user_id: 3, name: "Signup")
- ])
-
- insert(:goal, site: site, event_name: "Signup")
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}&order_by=#{Jason.encode!([["conversion_rate", "desc"]])}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "total_visitors" => 1,
- "visitors" => 1,
- "conversion_rate" => 100.0
- },
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns top countries with :is filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- country_code: "EE"
- ),
- build(:pageview,
- user_id: 123,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- country_code: "GB",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- country_code: "US"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 1,
- "percentage" => 100
- }
- ]
- end
-
- test "returns top countries with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- user_id: 123,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- country_code: "GB",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- country_code: "GB"
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 2,
- "percentage" => 100
- }
- ]
- end
-
- test "returns top countries with :is (none) filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- country_code: "GB",
- "meta.key": ["logged_in"],
- "meta.value": ["true"]
- ),
- build(:pageview,
- country_code: "GB"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["(none)"]]])
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 2,
- "percentage" => 100
- }
- ]
- end
-
- test "returns top countries with :is_not (none) filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- country_code: "EE",
- "meta.key": ["author"],
- "meta.value": [""]
- ),
- build(:pageview,
- country_code: "GB",
- "meta.key": ["logged_in"],
- "meta.value": ["true"]
- ),
- build(:pageview,
- country_code: "GB"
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["(none)"]]])
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 2,
- "percentage" => 100
- }
- ]
- end
-
- test "when list is filtered by country returns one country only", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, country_code: "EE"),
- build(:pageview, country_code: "EE"),
- build(:pageview, country_code: "GB")
- ])
-
- filters = Jason.encode!([[:is, "visit:country", ["GB"]]])
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 1,
- "percentage" => 100
- }
- ]
- end
-
- test "handles multiple segment filters", %{conn: conn, site: site, user: user} do
- %{id: segment_alfa} =
- insert(:segment,
- site_id: site.id,
- owner_id: user.id,
- name: "Ireland and Britain (excl London)",
- type: :site,
- segment_data: %{
- "filters" => [
- ["is", "visit:country", ["IE", "GB"]],
- ["is_not", "visit:city", [2_643_743]]
- ]
- }
- )
-
- %{id: segment_beta} =
- insert(:segment,
- site_id: site.id,
- owner_id: user.id,
- name: "Entered on root or blog",
- type: :personal,
- segment_data: %{
- "filters" => [
- ["is", "visit:entry_page", ["/", "/blog"]]
- ]
- }
- )
-
- populate_stats(site, [
- build(:pageview, country_code: "EE"),
- build(:pageview,
- country_code: "GB",
- # London
- city_geoname_id: 2_643_743
- ),
- build(:pageview,
- country_code: "GB",
- # London
- city_geoname_id: 2_643_743
- ),
- build(:pageview, country_code: "GB"),
- build(:pageview, country_code: "IE", pathname: "/other"),
- build(:pageview, country_code: "IE")
- ])
-
- filters =
- Jason.encode!([["is", "segment", [segment_alfa]], ["is", "segment", [segment_beta]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/countries?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 1,
- "percentage" => 50
- },
- %{
- "code" => "IE",
- "alpha_3" => "IRL",
- "name" => "Ireland",
- "flag" => "🇮🇪",
- "visitors" => 1,
- "percentage" => 50
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for countries breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- country_code: "EE"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- country_code: "EE"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- country_code: "EE"
- ),
- build(:pageview,
- user_id: 4,
- country_code: "GB"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- country_code: "GB"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/countries#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "Estonia",
- "alpha_3" => "EST",
- "code" => "EE",
- "flag" => "🇪🇪",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "United Kingdom",
- "alpha_3" => "GBR",
- "code" => "GB",
- "flag" => "🇬🇧",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/custom_prop_breakdown_test.exs b/test/plausible_web/controllers/api/stats_controller/custom_prop_breakdown_test.exs
index d41cfbb605..b806e3750b 100644
--- a/test/plausible_web/controllers/api/stats_controller/custom_prop_breakdown_test.exs
+++ b/test/plausible_web/controllers/api/stats_controller/custom_prop_breakdown_test.exs
@@ -1,6 +1,22 @@
defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
use PlausibleWeb.ConnCase
+ defp query_props(conn, site, prop_key, opts \\ []) do
+ params = %{
+ "dimensions" => ["event:props:#{prop_key}"],
+ "date_range" => Keyword.get(opts, :date_range, "day"),
+ "filters" => Keyword.get(opts, :filters, []),
+ "metrics" => Keyword.get(opts, :metrics, ["visitors", "events", "percentage"]),
+ "include" => Keyword.get(opts, :include, nil),
+ "pagination" => Keyword.get(opts, :pagination, nil),
+ "order_by" => Keyword.get(opts, :order_by, nil)
+ }
+
+ conn
+ |> post("/api/stats/#{site.domain}/query", params)
+ |> json_response(200)
+ end
+
describe "GET /api/stats/:domain/custom-prop-values/:prop_key" do
setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
@@ -15,31 +31,15 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview, "meta.key": [prop_key], "meta.value": ["Sipsik"])
])
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day"
+ response =
+ query_props(conn, site, prop_key,
+ order_by: [["visitors", "desc"], ["event:props:#{prop_key}", "asc"]]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "K2sna Kalle",
- "events" => 2,
- "percentage" => 50.0
- },
- %{
- "visitors" => 1,
- "name" => "Lotte",
- "events" => 2,
- "percentage" => 25.0
- },
- %{
- "visitors" => 1,
- "name" => "Sipsik",
- "events" => 1,
- "percentage" => 25.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["K2sna Kalle"], "metrics" => [2, 2, 50.0]},
+ %{"dimensions" => ["Lotte"], "metrics" => [1, 2, 25.0]},
+ %{"dimensions" => ["Sipsik"], "metrics" => [1, 1, 25.0]}
]
end
@@ -51,22 +51,11 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:imported_visitors, visitors: 2)
])
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&with_imported=true"
- )
+ response = query_props(conn, site, prop_key, include: %{"imports" => true})
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "K2sna Kalle",
- "events" => 1,
- "percentage" => 100.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["K2sna Kalle"], "metrics" => [1, 1, 100.0]}
]
-
- refute json_response(conn, 200)["warning"]
end
test "returns (none) values in the breakdown", %{conn: conn, site: site} do
@@ -78,25 +67,11 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview)
])
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day"
- )
+ response = query_props(conn, site, prop_key)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "K2sna Kalle",
- "events" => 2,
- "percentage" => 66.67
- },
- %{
- "visitors" => 1,
- "name" => "(none)",
- "events" => 1,
- "percentage" => 33.33
- }
+ assert response["results"] == [
+ %{"dimensions" => ["K2sna Kalle"], "metrics" => [2, 2, 66.67]},
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 33.33]}
]
end
@@ -112,40 +87,16 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview)
])
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&limit=2&page=1"
- )
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&limit=2&page=2"
- )
+ response1 = query_props(conn, site, prop_key, pagination: %{"limit" => 2, "offset" => 0})
+ response2 = query_props(conn, site, prop_key, pagination: %{"limit" => 2, "offset" => 2})
- assert json_response(conn1, 200)["results"] == [
- %{
- "visitors" => 3,
- "name" => "Tiit",
- "events" => 3,
- "percentage" => 50.0
- },
- %{
- "visitors" => 2,
- "name" => "Teet",
- "events" => 2,
- "percentage" => 33.33
- }
+ assert response1["results"] == [
+ %{"dimensions" => ["Tiit"], "metrics" => [3, 3, 50.0]},
+ %{"dimensions" => ["Teet"], "metrics" => [2, 2, 33.33]}
]
- assert json_response(conn2, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "(none)",
- "events" => 1,
- "percentage" => 16.67
- }
+ assert response2["results"] == [
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 16.67]}
]
end
end
@@ -164,28 +115,16 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
])
insert(:goal, %{site: site, event_name: "Signup"})
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
- prop_key = "variant"
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [["is", "event:goal", ["Signup"]]],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "B",
- "events" => 2,
- "conversion_rate" => 33.33
- },
- %{
- "visitors" => 1,
- "name" => "A",
- "events" => 1,
- "conversion_rate" => 16.67
- }
+ assert response["results"] == [
+ %{"dimensions" => ["B"], "metrics" => [2, 2, 33.33]},
+ %{"dimensions" => ["A"], "metrics" => [1, 1, 16.67]}
]
end
@@ -200,28 +139,16 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
])
insert(:goal, %{site: site, event_name: "Signup"})
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
- prop_key = "variant"
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [["is", "event:goal", ["Signup"]]],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "(none)",
- "events" => 2,
- "conversion_rate" => 33.33
- },
- %{
- "visitors" => 1,
- "name" => "A",
- "events" => 1,
- "conversion_rate" => 16.67
- }
+ assert response["results"] == [
+ %{"dimensions" => ["(none)"], "metrics" => [2, 2, 33.33]},
+ %{"dimensions" => ["A"], "metrics" => [1, 1, 16.67]}
]
end
@@ -240,25 +167,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is, "event:props:cost", ["0"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is", "event:props:cost", ["0"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "0",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["0"], "metrics" => [1, 1, 50.0]}
]
end
@@ -277,25 +196,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is, "event:props:cost", ["(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is", "event:props:cost", ["(none)"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "(none)",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 50.0]}
]
end
@@ -324,31 +235,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is_not, "event:props:cost", ["0"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is_not", "event:props:cost", ["0"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "20",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 50.0
- },
- %{
- "name" => "(none)",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 25.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["20"], "metrics" => [2, 2, 50.0]},
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 25.0]}
]
end
@@ -367,25 +265,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is_not, "event:props:cost", ["(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is_not", "event:props:cost", ["(none)"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "0",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["0"], "metrics" => [1, 1, 50.0]}
]
end
@@ -414,31 +304,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is, "event:props:cost", ["0", "1"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is", "event:props:cost", ["0", "1"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "1",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 50.0
- },
- %{
- "name" => "0",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 25.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["1"], "metrics" => [2, 2, 50.0]},
+ %{"dimensions" => ["0"], "metrics" => [1, 1, 25.0]}
]
end
@@ -465,31 +342,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is, "event:props:cost", ["1", "(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is", "event:props:cost", ["1", "(none)"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "1",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 50.0
- },
- %{
- "name" => "(none)",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 25.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["1"], "metrics" => [2, 2, 50.0]},
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 25.0]}
]
end
@@ -523,31 +387,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is_not, "event:props:cost", ["0", "0.01"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is_not", "event:props:cost", ["0", "0.01"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "20",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 40.0
- },
- %{
- "name" => "(none)",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 20.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["20"], "metrics" => [2, 2, 40.0]},
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 20.0]}
]
end
@@ -574,25 +425,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Purchase"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Purchase"]],
- [:is_not, "event:props:cost", ["0", "(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/cost?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "cost",
+ filters: [
+ ["is", "event:goal", ["Purchase"]],
+ ["is_not", "event:props:cost", ["0", "(none)"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "20",
- "visitors" => 2,
- "events" => 2,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["20"], "metrics" => [2, 2, 50.0]}
]
end
@@ -606,30 +449,15 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, page_path: "/register"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Visit /register"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/variant?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [["is", "event:goal", ["Visit /register"]]],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "A",
- "events" => 2,
- "conversion_rate" => 50.0
- },
- %{
- "visitors" => 1,
- "name" => "(none)",
- "events" => 1,
- "conversion_rate" => 25.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["A"], "metrics" => [2, 2, 50.0]},
+ %{"dimensions" => ["(none)"], "metrics" => [1, 1, 25.0]}
]
end
@@ -643,27 +471,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "Signup"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Signup"]],
- [:is, "event:props:variant", ["B"]]
- ])
-
- prop_key = "variant"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [
+ ["is", "event:goal", ["Signup"]],
+ ["is", "event:props:variant", ["B"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "B",
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["B"], "metrics" => [1, 1, 50.0]}
]
end
@@ -687,28 +505,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "ButtonClick"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["ButtonClick"]],
- [:is, "visit:utm_campaign", ["campaignA"]],
- [:is, "event:props:variant", ["A"]]
- ])
-
- prop_key = "variant"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [
+ ["is", "event:goal", ["ButtonClick"]],
+ ["is", "visit:utm_campaign", ["campaignA"]],
+ ["is", "event:props:variant", ["A"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "A",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["A"], "metrics" => [1, 1, 50.0]}
]
end
@@ -733,27 +541,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
insert(:goal, %{site: site, event_name: "ButtonClick"})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["ButtonClick"]],
- [:is, "visit:source", ["Google"]]
- ])
-
- prop_key = "variant"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "variant",
+ filters: [
+ ["is", "event:goal", ["ButtonClick"]],
+ ["is", "visit:source", ["Google"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "A",
- "visitors" => 1,
- "events" => 1,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["A"], "metrics" => [1, 1, 50.0]}
]
end
@@ -792,53 +590,48 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
display_name: "PaymentEUR"
})
- filters =
- Jason.encode!([
- [:is, "event:goal", ["PaymentEUR"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, prop_key,
+ filters: [["is", "event:goal", ["PaymentEUR"]]],
+ metrics: [
+ "visitors",
+ "events",
+ "conversion_rate",
+ "average_revenue",
+ "total_revenue"
+ ]
)
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "visitors" => 2,
- "name" => "true",
- "events" => 2,
- "conversion_rate" => 66.67,
- "total_revenue" => %{
- "long" => "€112.00",
- "short" => "€112.0",
- "value" => 112.00,
- "currency" => "EUR"
- },
- "average_revenue" => %{
- "long" => "€56.00",
- "short" => "€56.0",
- "value" => 56.00,
- "currency" => "EUR"
- }
+ "dimensions" => ["true"],
+ "metrics" => [
+ 2,
+ 2,
+ 66.67,
+ %{
+ "long" => "€56.00",
+ "short" => "€56.0",
+ "value" => 56.0,
+ "currency" => "EUR"
+ },
+ %{
+ "long" => "€112.00",
+ "short" => "€112.0",
+ "value" => 112.0,
+ "currency" => "EUR"
+ }
+ ]
},
%{
- "visitors" => 1,
- "name" => "false",
- "events" => 1,
- "conversion_rate" => 33.33,
- "total_revenue" => %{
- "long" => "€8.00",
- "short" => "€8.0",
- "value" => 8.00,
- "currency" => "EUR"
- },
- "average_revenue" => %{
- "long" => "€8.00",
- "short" => "€8.0",
- "value" => 8.00,
- "currency" => "EUR"
- }
+ "dimensions" => ["false"],
+ "metrics" => [
+ 1,
+ 1,
+ 33.33,
+ %{"long" => "€8.00", "short" => "€8.0", "value" => 8.0, "currency" => "EUR"},
+ %{"long" => "€8.00", "short" => "€8.0", "value" => 8.0, "currency" => "EUR"}
+ ]
}
]
end
@@ -876,57 +669,53 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Payment", "Payment2"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, prop_key,
+ filters: [["is", "event:goal", ["Payment", "Payment2"]]],
+ metrics: [
+ "visitors",
+ "events",
+ "conversion_rate",
+ "average_revenue",
+ "total_revenue"
+ ]
)
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "visitors" => 2,
- "name" => "true",
- "events" => 2,
- "conversion_rate" => 66.67,
- "total_revenue" => %{
- "long" => "€80.00",
- "short" => "€80.0",
- "value" => 80.0,
- "currency" => "EUR"
- },
- "average_revenue" => %{
- "long" => "€40.00",
- "short" => "€40.0",
- "value" => 40.0,
- "currency" => "EUR"
- }
+ "dimensions" => ["true"],
+ "metrics" => [
+ 2,
+ 2,
+ 66.67,
+ %{
+ "long" => "€40.00",
+ "short" => "€40.0",
+ "value" => 40.0,
+ "currency" => "EUR"
+ },
+ %{"long" => "€80.00", "short" => "€80.0", "value" => 80.0, "currency" => "EUR"}
+ ]
},
%{
- "visitors" => 1,
- "name" => "false",
- "events" => 1,
- "conversion_rate" => 33.33,
- "total_revenue" => %{
- "long" => "€10.00",
- "short" => "€10.0",
- "value" => 10.0,
- "currency" => "EUR"
- },
- "average_revenue" => %{
- "long" => "€10.00",
- "short" => "€10.0",
- "value" => 10.0,
- "currency" => "EUR"
- }
+ "dimensions" => ["false"],
+ "metrics" => [
+ 1,
+ 1,
+ 33.33,
+ %{
+ "long" => "€10.00",
+ "short" => "€10.0",
+ "value" => 10.0,
+ "currency" => "EUR"
+ },
+ %{"long" => "€10.00", "short" => "€10.0", "value" => 10.0, "currency" => "EUR"}
+ ]
}
]
end
+ @tag :ee_only
test "does not return revenue metrics when filtering by many revenue goals with different currencies",
%{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Payment", currency: "USD")
@@ -942,25 +731,20 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Payment", "AddToCart"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/whatever-prop?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "whatever-prop",
+ filters: [["is", "event:goal", ["Payment", "AddToCart"]]],
+ metrics: [
+ "visitors",
+ "events",
+ "conversion_rate",
+ "average_revenue",
+ "total_revenue"
+ ]
)
- returned_metrics =
- json_response(conn, 200)
- |> Map.get("results")
- |> List.first()
- |> Map.keys()
-
- refute "Average revenue" in returned_metrics
- refute "Total revenue" in returned_metrics
+ refute "average_revenue" in response["query"]["metrics"]
+ refute "total_revenue" in response["query"]["metrics"]
end
end
@@ -975,21 +759,11 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview, pathname: "/sipsik", "meta.key": [prop_key], "meta.value": ["Sipsik"])
])
- filters = Jason.encode!([[:is, "event:page", ["/sipsik"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
- )
+ response =
+ query_props(conn, site, prop_key, filters: [["is", "event:page", ["/sipsik"]]])
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "Sipsik",
- "events" => 1,
- "percentage" => 100.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["Sipsik"], "metrics" => [1, 1, 100.0]}
]
end
@@ -1005,21 +779,11 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
)
])
- filters = Jason.encode!([[:is, "visit:browser", ["Chrome"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
- )
+ response =
+ query_props(conn, site, prop_key, filters: [["is", "visit:browser", ["Chrome"]]])
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "Sipsik",
- "events" => 1,
- "percentage" => 100.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["Sipsik"], "metrics" => [1, 1, 100.0]}
]
end
@@ -1032,24 +796,13 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview, "meta.key": [prop_key], "meta.value": ["Sipsik"])
])
- filters =
- Jason.encode!([
- [:is, "event:props:parim_s6ber", ["Sipsik"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, prop_key,
+ filters: [["is", "event:props:parim_s6ber", ["Sipsik"]]]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "Sipsik",
- "events" => 1,
- "percentage" => 100.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["Sipsik"], "metrics" => [1, 1, 100.0]}
]
end
@@ -1066,30 +819,14 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview)
])
- filters =
- Jason.encode!([
- [:is_not, "event:props:parim_s6ber", ["(none)"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/#{prop_key}?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, prop_key,
+ filters: [["is_not", "event:props:parim_s6ber", ["(none)"]]]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "K2sna Kalle",
- "events" => 2,
- "percentage" => 66.67
- },
- %{
- "visitors" => 1,
- "name" => "Sipsik",
- "events" => 1,
- "percentage" => 33.33
- }
+ assert response["results"] == [
+ %{"dimensions" => ["K2sna Kalle"], "metrics" => [2, 2, 66.67]},
+ %{"dimensions" => ["Sipsik"], "metrics" => [1, 1, 33.33]}
]
end
@@ -1105,30 +842,12 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview)
])
- filters =
- Jason.encode!([
- [:contains, "event:props:key", ["bar"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/key?period=day&filters=#{filters}"
- )
+ response =
+ query_props(conn, site, "key", filters: [["contains", "event:props:key", ["bar"]]])
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "bar",
- "events" => 2,
- "percentage" => 66.67
- },
- %{
- "visitors" => 1,
- "name" => "foobar",
- "events" => 1,
- "percentage" => 33.33
- }
+ assert response["results"] == [
+ %{"dimensions" => ["bar"], "metrics" => [2, 2, 66.67]},
+ %{"dimensions" => ["foobar"], "metrics" => [1, 1, 33.33]}
]
end
@@ -1146,31 +865,17 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:pageview)
])
- filters =
- Jason.encode!([
- [:contains, "event:props:key", ["bar"]],
- [:is, "event:props:other", ["1"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/key?period=day&filters=#{filters}"
+ response =
+ query_props(conn, site, "key",
+ filters: [
+ ["contains", "event:props:key", ["bar"]],
+ ["is", "event:props:other", ["1"]]
+ ]
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "bar",
- "events" => 1,
- "percentage" => 50.0
- },
- %{
- "visitors" => 1,
- "name" => "foobar",
- "events" => 1,
- "percentage" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["bar"], "metrics" => [1, 1, 50.0]},
+ %{"dimensions" => ["foobar"], "metrics" => [1, 1, 50.0]}
]
end
end
@@ -1195,22 +900,36 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
)
])
- assert [%{"visitors" => 1, "name" => "some_value"}] =
- conn
- |> get(
- "/api/stats/#{site.domain}/custom-prop-values/#{unquote(special_prop)}?period=day"
- )
- |> json_response(200)
- |> Map.get("results")
+ response = query_props(conn, site, unquote(special_prop))
+
+ assert [
+ %{
+ "dimensions" => ["some_value"],
+ "metrics" => [1, 1, 100.0]
+ }
+ ] = response["results"]
end
end
- test "returns 402 'upgrade required' for any other prop key", %{conn: conn, site: site} do
- conn = get(conn, "/api/stats/#{site.domain}/custom-prop-values/prop?period=day")
+ test "returns 400 for a non-internal prop key when on a Growth plan", %{
+ conn: conn,
+ site: site
+ } do
+ conn =
+ conn
+ |> put_req_header("content-type", "application/json")
+ |> post(
+ "/api/stats/#{site.domain}/query",
+ Jason.encode!(%{
+ "dimensions" => ["event:props:prop"],
+ "date_range" => "day",
+ "metrics" => ["visitors", "events", "percentage"]
+ })
+ )
- assert json_response(conn, 402) == %{
+ assert json_response(conn, 400) == %{
"error" =>
- "Custom Properties is part of the Plausible Business plan. To get access to this feature, please upgrade your account."
+ "The owner of this site does not have access to the custom properties feature."
}
end
end
@@ -1239,24 +958,15 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:imported_visitors, visitors: 9)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", ["WP Search Queries"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/search_query?period=day&with_imported=true&filters=#{filters}"
+ response =
+ query_props(conn, site, "search_query",
+ filters: [["is", "event:goal", ["WP Search Queries"]]],
+ metrics: ["visitors", "events", "conversion_rate"],
+ include: %{"imports" => true}
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "name" => "some phrase",
- "events" => 1,
- "conversion_rate" => 100.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["some phrase"], "metrics" => [1, 1, 100.0]}
]
end
@@ -1291,30 +1001,16 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:imported_visitors, visitors: 9)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", [unquote(event_name)]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/path?period=day&with_imported=true&filters=#{filters}"
+ response =
+ query_props(conn, site, "path",
+ filters: [["is", "event:goal", [unquote(event_name)]]],
+ metrics: ["visitors", "events", "conversion_rate"],
+ include: %{"imports" => true}
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 5,
- "name" => "/some/path/second.bin",
- "events" => 10,
- "conversion_rate" => 50.0
- },
- %{
- "visitors" => 3,
- "name" => "/some/path/first.bin",
- "events" => 6,
- "conversion_rate" => 30.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["/some/path/second.bin"], "metrics" => [5, 10, 50.0]},
+ %{"dimensions" => ["/some/path/first.bin"], "metrics" => [3, 6, 30.0]}
]
end
end
@@ -1350,30 +1046,16 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:imported_visitors, visitors: 9)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", [unquote(event_name)]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/url?period=day&with_imported=true&filters=#{filters}"
+ response =
+ query_props(conn, site, "url",
+ filters: [["is", "event:goal", [unquote(event_name)]]],
+ metrics: ["visitors", "events", "conversion_rate"],
+ include: %{"imports" => true}
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 5,
- "name" => "https://two.com",
- "events" => 10,
- "conversion_rate" => 50.0
- },
- %{
- "visitors" => 3,
- "name" => "https://one.com",
- "events" => 6,
- "conversion_rate" => 30.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["https://two.com"], "metrics" => [5, 10, 50.0]},
+ %{"dimensions" => ["https://one.com"], "metrics" => [3, 6, 30.0]}
]
end
end
@@ -1412,25 +1094,18 @@ defmodule PlausibleWeb.Api.StatsController.CustomPropBreakdownTest do
build(:imported_visitors, visitors: 9)
])
- filters =
- Jason.encode!([
- [:is, "event:goal", [unquote(event_name)]],
- [:is, "event:props:url", ["https://two.com"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/custom-prop-values/url?period=day&with_imported=true&filters=#{filters}"
+ response =
+ query_props(conn, site, "url",
+ filters: [
+ ["is", "event:goal", [unquote(event_name)]],
+ ["is", "event:props:url", ["https://two.com"]]
+ ],
+ metrics: ["visitors", "events", "conversion_rate"],
+ include: %{"imports" => true}
)
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 5,
- "name" => "https://two.com",
- "events" => 10,
- "conversion_rate" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["https://two.com"], "metrics" => [5, 10, 50.0]}
]
end
end
diff --git a/test/plausible_web/controllers/api/stats_controller/debug_metadata_test.exs b/test/plausible_web/controllers/api/stats_controller/debug_metadata_test.exs
index 282d7b42ae..982d31285d 100644
--- a/test/plausible_web/controllers/api/stats_controller/debug_metadata_test.exs
+++ b/test/plausible_web/controllers/api/stats_controller/debug_metadata_test.exs
@@ -69,13 +69,23 @@ defmodule PlausibleWeb.Api.StatsController.DebugMetadataTest do
setup [:create_user, :log_in]
for type <- ["public", "shared"] do
- test "for /pages request (#{type})", %{
+ test "for /query request (#{type})", %{
conn: conn,
user: user
} do
domain = :rand.bytes(20) |> Base.url_encode64()
{site, query_string, expected_params} = setup_dashboard_case(domain, unquote(type))
- conn = get(conn, "/api/stats/#{site.domain}/pages#{query_string}")
+
+ query_params = %{
+ "date_range" => "day",
+ "dimensions" => ["event:page"],
+ "metrics" => ["visitors"]
+ }
+
+ expected_params = Map.merge(expected_params, query_params)
+
+ conn =
+ post(conn, "/api/stats/#{site.domain}/query#{query_string}", query_params)
assert json_response(conn, 200)
@@ -93,10 +103,10 @@ defmodule PlausibleWeb.Api.StatsController.DebugMetadataTest do
assert_matches ^strict_map(%{
# params are asserted below
"params" => %{},
- "phoenix_action" => "pages",
+ "phoenix_action" => "query",
"phoenix_controller" => "Elixir.PlausibleWeb.Api.StatsController",
- "request_method" => "GET",
- "request_path" => ^"/api/stats/#{site.domain}/pages",
+ "request_method" => "POST",
+ "request_path" => ^"/api/stats/#{site.domain}/query",
"site_domain" => ^site.domain,
"site_id" => ^site.id,
# nil team_id because viewing a public/shared dashboard
diff --git a/test/plausible_web/controllers/api/stats_controller/imported_test.exs b/test/plausible_web/controllers/api/stats_controller/imported_test.exs
index 87adb949cb..b93fa68a3a 100644
--- a/test/plausible_web/controllers/api/stats_controller/imported_test.exs
+++ b/test/plausible_web/controllers/api/stats_controller/imported_test.exs
@@ -3,6 +3,12 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
@user_id Enum.random(1000..9999)
+ defp do_query(conn, site, params) do
+ conn
+ |> post("/api/stats/#{site.domain}/query", params)
+ |> json_response(200)
+ end
+
defp import_data(ga_data, site_id, import_id, table_name) do
ga_data
|> Plausible.Imported.GoogleAnalytics4.from_report(site_id, import_id, table_name)
@@ -81,9 +87,7 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"include" => %{"imports" => true, "time_labels" => true}
}
- conn = post(conn, "/api/stats/#{site.domain}/query", params)
-
- response = json_response(conn, 200)
+ response = do_query(conn, site, params)
assert length(response["meta"]["time_labels"]) == 31
@@ -135,9 +139,7 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"include" => %{"imports" => true, "time_labels" => true}
}
- conn = post(conn, "/api/stats/#{site.domain}/query", params)
-
- response = json_response(conn, 200)
+ response = do_query(conn, site, params)
assert length(response["meta"]["time_labels"]) == 5
@@ -291,21 +293,21 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- results =
- conn
- |> get(
- "/api/stats/#{site.domain}/sources?period=month&date=2021-01-01&with_imported=true"
- )
- |> json_response(200)
- |> Map.get("results")
- |> Enum.sort()
-
- assert results == [
- %{"name" => "A Nice Newsletter", "visitors" => 1, "percentage" => 11.11},
- %{"name" => "Direct / None", "visitors" => 1, "percentage" => 11.11},
- %{"name" => "DuckDuckGo", "visitors" => 2, "percentage" => 22.22},
- %{"name" => "Google", "visitors" => 4, "percentage" => 44.44},
- %{"name" => "X (Twitter)", "visitors" => 1, "percentage" => 11.11}
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-31"],
+ "dimensions" => ["visit:source"],
+ "metrics" => ["visitors", "percentage"],
+ "order_by" => [["visit:source", "asc"]],
+ "include" => %{"imports" => true}
+ })
+
+ assert response["results"] == [
+ %{"dimensions" => ["A Nice Newsletter"], "metrics" => [1, 11.11]},
+ %{"dimensions" => ["Direct / None"], "metrics" => [1, 11.11]},
+ %{"dimensions" => ["DuckDuckGo"], "metrics" => [2, 22.22]},
+ %{"dimensions" => ["Google"], "metrics" => [4, 44.44]},
+ %{"dimensions" => ["X (Twitter)"], "metrics" => [1, 11.11]}
]
end
@@ -426,20 +428,20 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- results =
- conn
- |> get(
- "/api/stats/#{site.domain}/channels?period=month&date=2021-01-01&with_imported=true"
- )
- |> json_response(200)
- |> Map.get("results")
- |> Enum.sort()
-
- assert results == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 33.33},
- %{"name" => "Direct", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Organic Search", "visitors" => 3, "percentage" => 100.0},
- %{"name" => "Paid Search", "visitors" => 2, "percentage" => 66.67}
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-31"],
+ "dimensions" => ["visit:channel"],
+ "metrics" => ["visitors", "percentage"],
+ "order_by" => [["visit:channel", "asc"]],
+ "include" => %{"imports" => true}
+ })
+
+ assert response["results"] == [
+ %{"dimensions" => ["(not set)"], "metrics" => [1, 33.33]},
+ %{"dimensions" => ["Direct"], "metrics" => [2, 66.67]},
+ %{"dimensions" => ["Organic Search"], "metrics" => [3, 100.0]},
+ %{"dimensions" => ["Paid Search"], "metrics" => [2, 66.67]}
]
end
@@ -503,19 +505,19 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_mediums?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:utm_medium"],
+ "filters" => [["is_not", "visit:utm_medium", [""]]],
+ "metrics" => ["visitors", "bounce_rate", "visit_duration", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "bounce_rate" => 100.0,
- "name" => "social",
- "visit_duration" => 20.0,
- "visitors" => 3,
- "percentage" => 100.0
+ "dimensions" => ["social"],
+ "metrics" => [3, 100, 20, 100.0]
}
]
end
@@ -592,26 +594,24 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_campaigns?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:utm_campaign"],
+ "filters" => [["is_not", "visit:utm_campaign", [""]]],
+ "order_by" => [["visit:utm_campaign", "asc"]],
+ "metrics" => ["visitors", "bounce_rate", "visit_duration", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "name" => "august",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 50.0,
- "percentage" => 50.0
+ "dimensions" => ["august"],
+ "metrics" => [2, 50, 50, 50.0]
},
%{
- "name" => "profile",
- "visitors" => 2,
- "bounce_rate" => 100.0,
- "visit_duration" => 50.0,
- "percentage" => 50.0
+ "dimensions" => ["profile"],
+ "metrics" => [2, 100, 50, 50.0]
}
]
end
@@ -689,26 +689,23 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_terms?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:utm_term"],
+ "filters" => [["is_not", "visit:utm_term", [""]]],
+ "metrics" => ["visitors", "bounce_rate", "visit_duration", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "name" => "Sweden",
- "visitors" => 3,
- "bounce_rate" => 67.0,
- "visit_duration" => 33.0,
- "percentage" => 60.0
+ "dimensions" => ["Sweden"],
+ "metrics" => [3, 67, 33, 60.0]
},
%{
- "name" => "oat milk",
- "visitors" => 2,
- "bounce_rate" => 100.0,
- "visit_duration" => 50.0,
- "percentage" => 40.0
+ "dimensions" => ["oat milk"],
+ "metrics" => [2, 100, 50, 40.0]
}
]
end
@@ -785,26 +782,24 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_sources"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_contents?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:utm_content"],
+ "filters" => [["is_not", "visit:utm_content", [""]]],
+ "order_by" => [["bounce_rate", "desc"]],
+ "metrics" => ["visitors", "bounce_rate", "visit_duration", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "name" => "ad",
- "visitors" => 2,
- "bounce_rate" => 100.0,
- "visit_duration" => 50.0,
- "percentage" => 50.0
+ "dimensions" => ["ad"],
+ "metrics" => [2, 100, 50, 50.0]
},
%{
- "name" => "blog",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 50.0,
- "percentage" => 50.0
+ "dimensions" => ["blog"],
+ "metrics" => [2, 50, 50, 50.0]
}
]
end
@@ -904,30 +899,29 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_entry_pages"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&detailed=true&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["event:page"],
+ "metrics" => [
+ "visitors",
+ "pageviews",
+ "bounce_rate",
+ "time_on_page",
+ "scroll_depth",
+ "percentage"
+ ],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
+ assert response["results"] == [
%{
- "bounce_rate" => 0.0,
- "time_on_page" => 60,
- "visitors" => 3,
- "pageviews" => 4,
- "scroll_depth" => nil,
- "name" => "/some-other-page",
- "percentage" => 60.0
+ "dimensions" => ["/some-other-page"],
+ "metrics" => [3, 4, 0, 60, nil, 60.0]
},
%{
- "bounce_rate" => 25.0,
- "time_on_page" => 700,
- "visitors" => 2,
- "pageviews" => 2,
- "scroll_depth" => nil,
- "name" => "/",
- "percentage" => 40.0
+ "dimensions" => ["/"],
+ "metrics" => [2, 2, 25, 700, nil, 40.0]
}
]
end
@@ -990,27 +984,19 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_locations"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/cities?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:city_name", "visit:city", "visit:country"],
+ "metrics" => ["visitors", "percentage"],
+ "filters" => [["is_not", "visit:city", [0]]],
+ "order_by" => [["visit:city_name", "desc"]],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => 588_335,
- "name" => "Tartu",
- "visitors" => 1,
- "country_flag" => "🇪🇪",
- "percentage" => 50.0
- },
- %{
- "code" => 2_650_225,
- "name" => "Edinburgh",
- "visitors" => 1,
- "country_flag" => "🇬🇧",
- "percentage" => 50.0
- }
+ assert response["results"] == [
+ %{"dimensions" => ["Tartu", 588_335, "EE"], "metrics" => [1, 50.0]},
+ %{"dimensions" => ["Edinburgh", 2_650_225, "GB"], "metrics" => [1, 50.0]}
]
end
@@ -1073,29 +1059,17 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_locations"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/countries?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:country_name", "visit:country"],
+ "metrics" => ["visitors", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE",
- "alpha_3" => "EST",
- "name" => "Estonia",
- "flag" => "🇪🇪",
- "visitors" => 3,
- "percentage" => 60
- },
- %{
- "code" => "GB",
- "alpha_3" => "GBR",
- "name" => "United Kingdom",
- "flag" => "🇬🇧",
- "visitors" => 2,
- "percentage" => 40
- }
+ assert response["results"] == [
+ %{"dimensions" => ["Estonia", "EE"], "metrics" => [3, 60.0]},
+ %{"dimensions" => ["United Kingdom", "GB"], "metrics" => [2, 40.0]}
]
end
@@ -1139,16 +1113,19 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_devices"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/screen-sizes?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:device"],
+ "order_by" => [["visitors", "desc"], ["visit:device", "asc"]],
+ "metrics" => ["visitors", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 40},
- %{"name" => "Laptop", "visitors" => 2, "percentage" => 40},
- %{"name" => "Mobile", "visitors" => 1, "percentage" => 20}
+ assert response["results"] == [
+ %{"dimensions" => ["Desktop"], "metrics" => [2, 40.0]},
+ %{"dimensions" => ["Laptop"], "metrics" => [2, 40.0]},
+ %{"dimensions" => ["Mobile"], "metrics" => [1, 20.0]}
]
end
@@ -1194,17 +1171,20 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_browsers"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/browsers?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:browser"],
+ "order_by" => [["visitors", "desc"], ["visit:browser", "asc"]],
+ "metrics" => ["visitors", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert stats = json_response(conn, 200)["results"]
- assert length(stats) == 3
- assert %{"name" => "Firefox", "visitors" => 2, "percentage" => 50.0} in stats
- assert %{"name" => "Mobile App", "visitors" => 1, "percentage" => 25.0} in stats
- assert %{"name" => "Chrome", "visitors" => 1, "percentage" => 25.0} in stats
+ assert response["results"] == [
+ %{"dimensions" => ["Firefox"], "metrics" => [2, 50.0]},
+ %{"dimensions" => ["Chrome"], "metrics" => [1, 25.0]},
+ %{"dimensions" => ["Mobile App"], "metrics" => [1, 25.0]}
+ ]
end
test "OS data imported from Google Analytics", %{
@@ -1258,15 +1238,17 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"imported_operating_systems"
)
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/operating-systems?period=day&date=2021-01-01&with_imported=true"
- )
+ response =
+ do_query(conn, site, %{
+ "date_range" => ["2021-01-01", "2021-01-01"],
+ "dimensions" => ["visit:os"],
+ "metrics" => ["visitors", "percentage"],
+ "include" => %{"imports" => true}
+ })
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Mac", "visitors" => 3, "percentage" => 60},
- %{"name" => "GNU/Linux", "visitors" => 2, "percentage" => 40}
+ assert response["results"] == [
+ %{"dimensions" => ["Mac"], "metrics" => [3, 60.0]},
+ %{"dimensions" => ["GNU/Linux"], "metrics" => [2, 40.0]}
]
end
@@ -1315,8 +1297,7 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"filters" => []
}
- conn = post(conn, "/api/stats/#{site.domain}/query", params)
- response = json_response(conn, 200)
+ response = do_query(conn, site, params)
assert response["results"] == [
%{"dimensions" => [], "metrics" => [3_479_032]}
@@ -1366,8 +1347,7 @@ defmodule PlausibleWeb.Api.StatsController.ImportedTest do
"filters" => []
}
- conn = post(conn, "/api/stats/#{site.domain}/query", params)
- response = json_response(conn, 200)
+ response = do_query(conn, site, params)
assert response["results"] == [
%{"dimensions" => [], "metrics" => [1, 1, 1, 1, 0, 60]}
diff --git a/test/plausible_web/controllers/api/stats_controller/operating_systems_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/operating_systems_legacy_test.exs
deleted file mode 100644
index d2b3fa43e9..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/operating_systems_legacy_test.exs
+++ /dev/null
@@ -1,472 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.OperatingSystemsLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/operating-systems" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns operating systems by unique visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, operating_system: "Mac"),
- build(:pageview, operating_system: "Mac"),
- build(:pageview, operating_system: "Android")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/operating-systems?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Mac", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Android", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns (not set) when appropriate", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- operating_system: ""
- ),
- build(:pageview,
- operating_system: "Linux"
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/operating-systems?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 50},
- %{"name" => "Linux", "visitors" => 1, "percentage" => 50}
- ]
-
- filters = Jason.encode!([[:is, "visit:os", ["(not set)"]]])
-
- conn2 =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&filters=#{filters}")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "select empty imported_operating_systems as (not set), merging with the native (not set)",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 123),
- build(:imported_operating_systems, visitors: 1),
- build(:imported_visitors, visitors: 1)
- ])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 2, "percentage" => 100.0}
- ]
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- insert(:goal, site: site, event_name: "Signup")
-
- populate_stats(site, [
- build(:pageview, user_id: 1, operating_system: "Mac"),
- build(:pageview, user_id: 2, operating_system: "Mac"),
- build(:event, user_id: 1, name: "Signup")
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Mac",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns operating systems with :is filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- operating_system: "Mac"
- ),
- build(:pageview,
- user_id: 123,
- operating_system: "Mac",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- operating_system: "Windows",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- operating_system: "Android"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Mac", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "returns screen sizes with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- operating_system: "Windows",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- user_id: 123,
- operating_system: "Windows",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- operating_system: "Mac",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- operating_system: "Android"
- )
- ])
-
- filters = Jason.encode!([["is_not", "event:props:author", ["John Doe"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Android", "visitors" => 1, "percentage" => 50},
- %{"name" => "Mac", "visitors" => 1, "percentage" => 50}
- ]
- end
-
- test "returns operating systems by unique visitors with imported data", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, operating_system: "Mac"),
- build(:pageview, operating_system: "Mac"),
- build(:pageview, operating_system: "Android"),
- build(:imported_operating_systems, operating_system: "Mac"),
- build(:imported_operating_systems, operating_system: "Android"),
- build(:imported_visitors, visitors: 2)
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/operating-systems?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "Mac", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Android", "visitors" => 1, "percentage" => 33.33}
- ]
-
- conn2 =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "Mac", "visitors" => 3, "percentage" => 60},
- %{"name" => "Android", "visitors" => 2, "percentage" => 40}
- ]
- end
-
- test "imported data is ignored when filtering for goal", %{conn: conn, site: site} do
- insert(:goal, site: site, event_name: "Signup")
-
- populate_stats(site, [
- build(:pageview, user_id: 1, operating_system: "Mac"),
- build(:pageview, user_id: 2, operating_system: "Mac"),
- build(:imported_operating_systems, operating_system: "Mac"),
- build(:event, user_id: 1, name: "Signup")
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/operating-systems?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Mac",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for operating systems breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, operating_system: "Mac"),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, operating_system: "Mac"),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, operating_system: "Mac"),
- build(:pageview, user_id: 4, operating_system: "Android"),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 5, operating_system: "Android"),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/operating-systems#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "conversion_rate" => 100.0,
- "name" => "(not set)",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "Mac",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "Android",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/operating-system-versions" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top OS versions by unique visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- operating_system: "Mac",
- operating_system_version: "10.15"
- ),
- build(:pageview,
- operating_system: "Mac",
- operating_system_version: "10.16"
- ),
- build(:pageview,
- operating_system: "Mac",
- operating_system_version: "10.16"
- ),
- build(:pageview,
- operating_system: "Android",
- operating_system_version: "4"
- )
- ])
-
- filters = Jason.encode!([[:is, "visit:os", ["Mac"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/operating-system-versions?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Mac 10.16",
- "visitors" => 2,
- "percentage" => 66.67,
- "os" => "Mac",
- "version" => "10.16"
- },
- %{
- "name" => "Mac 10.15",
- "visitors" => 1,
- "percentage" => 33.33,
- "os" => "Mac",
- "version" => "10.15"
- }
- ]
- end
-
- test "returns only version under the name key (+ additional metrics) when 'detailed' is true in params",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, operating_system: "Mac", operating_system_version: "14")
- ])
-
- filters = Jason.encode!([[:is, "visit:os", ["Mac"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/operating-system-versions?filters=#{filters}&detailed=true&period=day"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "14",
- "os" => "Mac",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- operating_system: "Mac",
- operating_system_version: "11",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- operating_system: "Mac",
- operating_system_version: "12",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:imported_operating_systems,
- date: ~D[2021-01-01],
- operating_system: "Mac",
- operating_system_version: "11",
- visitors: 5
- ),
- build(:imported_operating_systems,
- date: ~D[2021-01-01],
- operating_system: "Windows",
- operating_system_version: "11",
- visitors: 3
- ),
- build(:imported_operating_systems, date: ~D[2021-01-01], visitors: 10),
- build(:imported_visitors, date: ~D[2021-01-01], visitors: 18)
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/operating-system-versions?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "os" => "(not set)",
- "name" => "(not set)",
- "version" => "(not set)",
- "visitors" => 10,
- "percentage" => 50.0
- },
- %{
- "os" => "Mac",
- "name" => "Mac 11",
- "version" => "11",
- "visitors" => 6,
- "percentage" => 30.0
- },
- %{
- "os" => "Windows",
- "name" => "Windows 11",
- "version" => "11",
- "visitors" => 3,
- "percentage" => 15.0
- },
- %{
- "os" => "Mac",
- "name" => "Mac 12",
- "version" => "12",
- "visitors" => 1,
- "percentage" => 5.0
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/pages_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/pages_legacy_test.exs
deleted file mode 100644
index db3117b15e..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/pages_legacy_test.exs
+++ /dev/null
@@ -1,3521 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.PagesLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- @user_id Enum.random(1000..9999)
-
- describe "GET /api/stats/:domain/pages" do
- setup [
- :create_user,
- :log_in,
- :create_site,
- :create_legacy_site_import
- ]
-
- test "returns top pages by visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/register"),
- build(:pageview, pathname: "/register"),
- build(:pageview, pathname: "/contact")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 3, "name" => "/", "percentage" => 50.0},
- %{"visitors" => 2, "name" => "/register", "percentage" => 33.33},
- %{"visitors" => 1, "name" => "/contact", "percentage" => 16.67}
- ]
- end
-
- test "returns top pages by visitors by hostname", %{conn: conn1, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/", hostname: "a.example.com"),
- build(:pageview, pathname: "/", hostname: "b.example.com"),
- build(:pageview, pathname: "/", hostname: "d.example.com"),
- build(:pageview, pathname: "/landing", hostname: "x.example.com", user_id: 123),
- build(:pageview, pathname: "/register", hostname: "d.example.com", user_id: 123),
- build(:pageview, pathname: "/register", hostname: "d.example.com", user_id: 123),
- build(:pageview, pathname: "/register", hostname: "d.example.com"),
- build(:pageview, pathname: "/contact", hostname: "e.example.com")
- ])
-
- filters = Jason.encode!([[:contains, "event:hostname", [".example.com"]]])
- conn = get(conn1, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 3, "name" => "/", "percentage" => 50.0},
- %{"visitors" => 2, "name" => "/register", "percentage" => 33.33},
- %{"visitors" => 1, "name" => "/contact", "percentage" => 16.67},
- %{"visitors" => 1, "name" => "/landing", "percentage" => 16.67}
- ]
-
- filters = Jason.encode!([[:is, "event:hostname", ["d.example.com"]]])
- conn = get(conn1, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 2, "name" => "/register", "percentage" => 66.67},
- %{"visitors" => 1, "name" => "/", "percentage" => 33.33}
- ]
- end
-
- test "returns top pages with :is filter on custom pageview props", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview, user_id: 123, pathname: "/")
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 1, "name" => "/blog/john-1", "percentage" => 100.0}
- ]
- end
-
- test "returns top pages with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview, pathname: "/")
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 1, "name" => "/", "percentage" => 50.0},
- %{"visitors" => 1, "name" => "/blog/other-post", "percentage" => 50.0}
- ]
- end
-
- test "returns top pages with :matches_wildcard filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/1",
- "meta.key": ["prop"],
- "meta.value": ["bar"]
- ),
- build(:pageview,
- pathname: "/2",
- "meta.key": ["prop"],
- "meta.value": ["foobar"]
- ),
- build(:pageview,
- pathname: "/3",
- "meta.key": ["prop"],
- "meta.value": ["baar"]
- ),
- build(:pageview,
- pathname: "/4",
- "meta.key": ["another"],
- "meta.value": ["bar"]
- ),
- build(:pageview, pathname: "/5")
- ])
-
- filters = Jason.encode!([[:contains, "event:props:prop", ["bar"]]])
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 1, "name" => "/1", "percentage" => 50.0},
- %{"visitors" => 1, "name" => "/2", "percentage" => 50.0}
- ]
- end
-
- test "returns top pages with :matches_member filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/1",
- "meta.key": ["prop"],
- "meta.value": ["bar"]
- ),
- build(:pageview,
- pathname: "/2",
- "meta.key": ["prop"],
- "meta.value": ["foobar"]
- ),
- build(:pageview,
- pathname: "/3",
- "meta.key": ["prop"],
- "meta.value": ["baar"]
- ),
- build(:pageview,
- pathname: "/4",
- "meta.key": ["another"],
- "meta.value": ["bar"]
- ),
- build(:pageview, pathname: "/5"),
- build(:pageview,
- pathname: "/6",
- "meta.key": ["prop"],
- "meta.value": ["near"]
- )
- ])
-
- filters = Jason.encode!([[:contains, "event:props:prop", ["bar", "nea"]]])
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 1, "name" => "/1", "percentage" => 33.33},
- %{"visitors" => 1, "name" => "/2", "percentage" => 33.33},
- %{"visitors" => 1, "name" => "/6", "percentage" => 33.33}
- ]
- end
-
- test "returns top pages with multiple filters on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/1",
- "meta.key": ["prop", "number"],
- "meta.value": ["bar", "1"]
- ),
- build(:pageview,
- pathname: "/2",
- "meta.key": ["prop", "number"],
- "meta.value": ["bar", "2"]
- ),
- build(:pageview,
- pathname: "/3",
- "meta.key": ["prop"],
- "meta.value": ["bar"]
- ),
- build(:pageview,
- pathname: "/4",
- "meta.key": ["number"],
- "meta.value": ["bar"]
- ),
- build(:pageview, pathname: "/5")
- ])
-
- filters =
- Jason.encode!([
- [:is, "event:props:prop", ["bar"]],
- [:is, "event:props:number", ["1"]]
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 1, "name" => "/1", "percentage" => 100.0}
- ]
- end
-
- test "calculates bounce_rate and time_on_page with :is filter on custom pageview props",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/john-2",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/blog/john-2",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/blog/john-2",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/john-2",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:00],
- engagement_time: 600_000
- ),
- build(:pageview,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog/john-2",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 0,
- "time_on_page" => 315,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/blog/john-1",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "calculates bounce_rate and time_on_page with :is_not filter on custom pageview props",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/blog/other-post",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:03:00],
- engagement_time: 180_000
- ),
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:03:00]
- ),
- build(:engagement,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:03:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 0,
- "time_on_page" => 120,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/blog/other-post",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "calculates bounce_rate and time_on_page with :is (none) filter on custom pageview props",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/blog/other-post",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["(none)"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 50,
- "time_on_page" => 45,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/blog/other-post",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "calculates bounce_rate and time_on_page with :is_not (none) filter on custom pageview props",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/john-1",
- user_id: @user_id,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"],
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": [""],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": [""],
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["(none)"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog/other-post",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 100,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/blog/john-1",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "returns top pages with :not_member filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/chrome",
- "meta.key": ["browser"],
- "meta.value": ["Chrome"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/chrome",
- "meta.key": ["browser"],
- "meta.value": ["Chrome"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/safari",
- "meta.key": ["browser"],
- "meta.value": ["Safari"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/firefox",
- "meta.key": ["browser"],
- "meta.value": ["Firefox"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/firefox",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:browser", ["Chrome", "Safari"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/firefox",
- "visitors" => 2,
- "percentage" => 100.0
- }
- ]
-
- assert json_response(conn, 200)["meta"] == %{"date_range_label" => "1 Jan 2021"}
- end
-
- test "returns top pages with :not_member filter on custom pageview props including (none) value",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/chrome",
- "meta.key": ["browser"],
- "meta.value": ["Chrome"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/chrome",
- "meta.key": ["browser"],
- "meta.value": ["Chrome"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/safari",
- "meta.key": ["browser"],
- "meta.value": ["Safari"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/no-browser-prop",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:browser", ["Chrome", "(none)"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/safari",
- "visitors" => 1,
- "percentage" => 100.0
- }
- ]
- end
-
- test "calculates bounce_rate and time_on_page for pages filtered by page path",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/about",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/about",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/",
- "visitors" => 2,
- "pageviews" => 3,
- "bounce_rate" => 50,
- "time_on_page" => 90,
- "scroll_depth" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "calculates scroll_depth", %{conn: conn, site: site} do
- t0 = ~N[2020-01-01 00:00:00]
- [t1, t2, t3] = for i <- 1..3, do: NaiveDateTime.add(t0, i, :minute)
-
- populate_stats(site, [
- build(:pageview, user_id: 12, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 12,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 20,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 12, pathname: "/another", timestamp: t1),
- build(:engagement,
- user_id: 12,
- pathname: "/another",
- timestamp: t2,
- scroll_depth: 24,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 34,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 17,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/another", timestamp: t1),
- build(:engagement,
- user_id: 34,
- pathname: "/another",
- timestamp: t2,
- scroll_depth: 26,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/blog", timestamp: t2),
- build(:engagement,
- user_id: 34,
- pathname: "/blog",
- timestamp: t3,
- scroll_depth: 60,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 56, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 56,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 100,
- engagement_time: 60_000
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2020-01-01&detailed=true&order_by=#{Jason.encode!([["scroll_depth", "asc"]])}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/another",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 25,
- "percentage" => 66.67
- },
- %{
- "name" => "/blog",
- "visitors" => 3,
- "pageviews" => 4,
- "bounce_rate" => 33,
- "time_on_page" => 80,
- "scroll_depth" => 60,
- "percentage" => 100.0
- }
- ]
- end
-
- test "calculates scroll_depth from native and imported data combined", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: @user_id,
- pathname: "/blog",
- timestamp: ~N[2020-01-01 00:00:00]
- ),
- build(:engagement,
- user_id: @user_id,
- pathname: "/blog",
- timestamp: ~N[2020-01-01 00:00:00],
- scroll_depth: 80,
- engagement_time: 20_000
- ),
- build(:imported_pages,
- date: ~D[2020-01-01],
- visitors: 3,
- pageviews: 3,
- total_time_on_page: 90,
- total_time_on_page_visits: 3,
- page: "/blog",
- total_scroll_depth: 120,
- total_scroll_depth_visits: 3
- )
- ])
-
- populate_stats(site, site_import.id, [
- build(:imported_visitors, date: ~D[2020-01-01]),
- build(:imported_visitors, date: ~D[2020-01-01]),
- build(:imported_visitors, date: ~D[2020-01-01])
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2020-01-01&detailed=true&with_imported=true&order_by=#{Jason.encode!([["scroll_depth", "desc"]])}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog",
- "visitors" => 4,
- "pageviews" => 4,
- "bounce_rate" => 100,
- "time_on_page" => 28,
- "scroll_depth" => 50,
- "percentage" => 100.0
- }
- ]
- end
-
- test "handles missing scroll_depth data from native and imported sources", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: @user_id,
- pathname: "/native-and-imported",
- timestamp: ~N[2020-01-01 00:00:00]
- ),
- build(:engagement,
- user_id: @user_id,
- pathname: "/native-and-imported",
- timestamp: ~N[2020-01-01 00:01:00],
- scroll_depth: 80,
- engagement_time: 60_000
- ),
- build(:pageview,
- user_id: @user_id,
- pathname: "/native-only",
- timestamp: ~N[2020-01-01 00:01:00]
- ),
- build(:engagement,
- user_id: @user_id,
- pathname: "/native-only",
- timestamp: ~N[2020-01-01 00:02:00],
- scroll_depth: 40,
- engagement_time: 60_000
- ),
- build(:imported_pages,
- date: ~D[2020-01-01],
- visitors: 4,
- pageviews: 4,
- total_time_on_page: 180,
- total_time_on_page_visits: 4,
- page: "/native-and-imported",
- total_scroll_depth: 120,
- total_scroll_depth_visits: 3
- ),
- build(:imported_pages,
- date: ~D[2020-01-01],
- visitors: 20,
- pageviews: 30,
- total_time_on_page: 300,
- total_time_on_page_visits: 10,
- page: "/imported-only",
- total_scroll_depth: 100,
- total_scroll_depth_visits: 10
- )
- ])
-
- populate_stats(
- site,
- site_import.id,
- for(_ <- 1..24, do: build(:imported_visitors, date: ~D[2020-01-01]))
- )
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2020-01-01&detailed=true&with_imported=true&order_by=#{Jason.encode!([["scroll_depth", "desc"]])}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/native-and-imported",
- "visitors" => 5,
- "pageviews" => 5,
- "bounce_rate" => 0,
- "time_on_page" => 48,
- "scroll_depth" => 50,
- "percentage" => 20.0
- },
- %{
- "name" => "/native-only",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 40,
- "percentage" => 4.0
- },
- %{
- "name" => "/imported-only",
- "visitors" => 20,
- "pageviews" => 30,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 10,
- "percentage" => 80.0
- }
- ]
- end
-
- test "can query scroll depth and time-on-page only from imported data, ignoring rows where scroll depth doesn't exist",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:imported_pages,
- date: ~D[2020-01-01],
- visitors: 10,
- pageviews: 10,
- page: "/blog",
- total_scroll_depth: 100,
- total_scroll_depth_visits: 10,
- total_time_on_page: 300,
- total_time_on_page_visits: 5
- ),
- build(:imported_pages,
- date: ~D[2020-01-01],
- visitors: 100,
- pageviews: 150,
- page: "/blog",
- total_scroll_depth: 0,
- total_scroll_depth_visits: 0,
- total_time_on_page: 0,
- total_time_on_page_visits: 0
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=7d&date=2020-01-02&detailed=true&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog",
- "visitors" => 110,
- "pageviews" => 160,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 10,
- "percentage" => nil
- }
- ]
- end
-
- test "can filter using the | (OR) filter",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/irrelevant",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/irrelevant",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/", "/about"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/",
- "visitors" => 2,
- "pageviews" => 3,
- "bounce_rate" => 50,
- "time_on_page" => 75,
- "scroll_depth" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "/about",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 100,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 33.33
- }
- ]
- end
-
- test "can filter using the not_member filter type",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/irrelevant",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/irrelevant",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:02:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/about",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:page", ["/irrelevant", "/about"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/",
- "visitors" => 2,
- "pageviews" => 3,
- "bounce_rate" => 50,
- "time_on_page" => 75,
- "scroll_depth" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "can filter using the matches_member filter type",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/post-1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/post-1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/post-2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog/post-2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 100,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 100,
- timestamp: ~N[2021-01-01 00:00:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/articles/post-1",
- user_id: 200,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/articles/post-1",
- user_id: 200,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/articles/post-1",
- user_id: 300,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/articles/post-1",
- user_id: 300,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:contains, "event:page", ["/blog/", "/articles/"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/articles/post-1",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 100,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "/blog/post-1",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 0,
- "percentage" => 33.33
- },
- %{
- "name" => "/blog/post-2",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 33.33
- }
- ]
- end
-
- test "page filter escapes brackets",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/(/post-1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/(/post-1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00],
- engagement_time: 60_000
- ),
- build(:pageview,
- pathname: "/blog/(/post-2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/blog/(/post-2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 456,
- timestamp: ~N[2021-01-01 00:00:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:contains, "event:page", ["/blog/(/", "/blog/)/"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/blog/(/post-1",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 60,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/blog/(/post-2",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "can filter using the not_matches_member filter type",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/post-1",
- user_id: 100,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/blog/post-1",
- user_id: 100,
- timestamp: ~N[2021-01-01 00:00:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:10:00],
- engagement_time: 600_000
- ),
- build(:pageview,
- pathname: "/about",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/about",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 200,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 200,
- timestamp: ~N[2021-01-01 00:10:00],
- engagement_time: 600_000
- ),
- build(:pageview,
- pathname: "/articles/post-1",
- user_id: 300,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/articles/post-1",
- user_id: 300,
- timestamp: ~N[2021-01-01 00:10:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:contains_not, "event:page", ["/blog/", "/articles/"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&filters=#{filters}&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/",
- "visitors" => 2,
- "pageviews" => 2,
- "bounce_rate" => 50,
- "time_on_page" => 600,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "name" => "/about",
- "visitors" => 1,
- "pageviews" => 1,
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "returns top pages by visitors with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:pageview, pathname: "/"),
- build(:imported_pages, page: "/"),
- build(:pageview, pathname: "/register"),
- build(:pageview, pathname: "/register"),
- build(:imported_pages, page: "/register"),
- build(:pageview, pathname: "/contact")
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/pages?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"visitors" => 3, "name" => "/", "percentage" => 50.0},
- %{"visitors" => 2, "name" => "/register", "percentage" => 33.33},
- %{"visitors" => 1, "name" => "/contact", "percentage" => 16.67}
- ]
-
- conn2 = get(conn, "/api/stats/#{site.domain}/pages?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{"visitors" => 4, "name" => "/", "percentage" => 66.67},
- %{"visitors" => 3, "name" => "/register", "percentage" => 50.0},
- %{"visitors" => 1, "name" => "/contact", "percentage" => 16.67}
- ]
- end
-
- test "returns scroll depth warning code", %{conn: conn, site: site} do
- conn =
- get(conn, "/api/stats/#{site.domain}/pages?period=day&detailed=true&with_imported=true")
-
- response = json_response(conn, 200)
-
- assert response["meta"]["metric_warnings"]["scroll_depth"]["code"] ==
- "no_imported_scroll_depth"
- end
-
- test "returns imported pages with a pageview goal filter", %{conn: conn, site: site} do
- insert(:goal, site: site, page_path: "/blog**")
-
- populate_stats(site, [
- build(:imported_pages, page: "/blog"),
- build(:imported_pages, page: "/not-this"),
- build(:imported_pages, page: "/blog/post-1", visitors: 2),
- build(:imported_visitors, visitors: 4)
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /blog**"]]])
- q = "?period=day&filters=#{filters}&with_imported=true"
- conn = get(conn, "/api/stats/#{site.domain}/pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "name" => "/blog/post-1",
- "conversion_rate" => 100.0,
- "total_visitors" => 2
- },
- %{
- "visitors" => 1,
- "name" => "/blog",
- "conversion_rate" => 100.0,
- "total_visitors" => 1
- }
- ]
- end
-
- test "calculates bounce rate and time on page for pages", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00],
- engagement_time: 900_000
- ),
- build(:pageview,
- pathname: "/some-other-page",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:engagement,
- pathname: "/some-other-page",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:15:30],
- engagement_time: 30_000
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50.0,
- "time_on_page" => 465.0,
- "visitors" => 2,
- "pageviews" => 2,
- "name" => "/",
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "bounce_rate" => 0,
- "time_on_page" => 30,
- "visitors" => 1,
- "pageviews" => 1,
- "name" => "/some-other-page",
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "filtering by hostname, excludes a page on different hostname", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- timestamp: ~N[2021-01-01 05:01:00],
- pathname: "/about",
- hostname: "blog.example.com",
- user_id: @user_id
- ),
- build(:pageview,
- timestamp: ~N[2021-01-01 05:01:02],
- pathname: "/hello",
- hostname: "example.com",
- user_id: @user_id
- ),
- build(:pageview,
- timestamp: ~N[2021-01-01 05:01:02],
- pathname: "/about",
- hostname: "blog.example.com"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["blog.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&detailed=true&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50,
- "name" => "/about",
- "pageviews" => 2,
- "time_on_page" => nil,
- "visitors" => 2,
- "scroll_depth" => nil,
- "percentage" => 100.0
- }
- ]
- end
-
- test "calculates bounce rate and time on page for pages when filtered by hostname", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- # session 1
- build(:pageview,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id + 1,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id + 1,
- timestamp: ~N[2021-01-01 00:01:30],
- engagement_time: 30_000
- ),
-
- # session 2
- build(:pageview,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:10:00],
- engagement_time: 540_000
- ),
- build(:pageview,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:10:00]
- ),
- build(:engagement,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00],
- engagement_time: 300_000
- ),
- build(:pageview,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:engagement,
- pathname: "/about-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:20:00],
- engagement_time: 300_000
- ),
- build(:pageview,
- pathname: "/exit-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:20:00]
- ),
- build(:engagement,
- pathname: "/exit-blog",
- hostname: "blog.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:22:00],
- engagement_time: 120_000
- ),
- build(:pageview,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:22:00]
- ),
- build(:engagement,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:25:00],
- engagement_time: 180_000
- ),
- build(:pageview,
- pathname: "/exit",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:25:00]
- ),
- build(:engagement,
- pathname: "/exit",
- hostname: "example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:25:30],
- engagement_time: 30_000
- ),
-
- # session 3
- build(:pageview,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id + 2,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:engagement,
- pathname: "/about",
- hostname: "example.com",
- user_id: @user_id + 2,
- timestamp: ~N[2021-01-01 00:01:30],
- engagement_time: 30_000
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["blog.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&detailed=true&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50,
- "name" => "/about-blog",
- "pageviews" => 3,
- "time_on_page" => 435,
- "visitors" => 2,
- "scroll_depth" => 0,
- "percentage" => 100.0
- },
- %{
- "bounce_rate" => 0,
- "name" => "/exit-blog",
- "pageviews" => 1,
- "time_on_page" => 120,
- "visitors" => 1,
- "scroll_depth" => 0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "calculates bounce rate and time on page for pages with imported data", %{
- conn: conn,
- site: site,
- site_import: site_import
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00],
- engagement_time: 900_000
- ),
- build(:pageview,
- pathname: "/some-other-page",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:engagement,
- pathname: "/some-other-page",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:30],
- engagement_time: 30_000
- ),
- build(:pageview,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:engagement,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:30:00],
- engagement_time: 900_000
- ),
- build(:imported_pages,
- page: "/",
- date: ~D[2021-01-01],
- total_time_on_page: 700,
- total_time_on_page_visits: 3
- ),
- build(:imported_entry_pages,
- entry_page: "/",
- date: ~D[2021-01-01],
- entrances: 3,
- bounces: 1
- ),
- build(:imported_pages,
- page: "/some-other-page",
- date: ~D[2021-01-01],
- total_time_on_page: 60,
- total_time_on_page_visits: 1
- )
- ])
-
- populate_stats(site, site_import.id, [
- build(:imported_visitors, date: ~D[2021-01-01]),
- build(:imported_visitors, date: ~D[2021-01-01]),
- build(:imported_visitors, date: ~D[2021-01-01])
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-01&detailed=true&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 40.0,
- "time_on_page" => 500,
- "visitors" => 3,
- "pageviews" => 3,
- "scroll_depth" => 0,
- "name" => "/",
- "percentage" => 60.0
- },
- %{
- "bounce_rate" => 0,
- "time_on_page" => 45,
- "visitors" => 2,
- "pageviews" => 2,
- "scroll_depth" => 0,
- "name" => "/some-other-page",
- "percentage" => 40.0
- }
- ]
- end
-
- test "returns top pages in realtime report", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/page1"),
- build(:pageview, pathname: "/page2"),
- build(:pageview, pathname: "/page1")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=realtime")
-
- assert json_response(conn, 200)["results"] == [
- %{"visitors" => 2, "name" => "/page1", "percentage" => 66.67},
- %{"visitors" => 1, "name" => "/page2", "percentage" => 33.33}
- ]
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, pathname: "/"),
- build(:pageview, user_id: 2, pathname: "/"),
- build(:pageview, user_id: 3, pathname: "/"),
- build(:event, user_id: 3, name: "Signup")
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/pages?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "total_visitors" => 3,
- "visitors" => 1,
- "name" => "/",
- "conversion_rate" => 33.33
- }
- ]
- end
-
- test "filter by :is page with imported data", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview, user_id: 1, pathname: "/", timestamp: ~N[2021-01-01 12:00:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/",
- timestamp: ~N[2021-01-01 12:01:00],
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 1, pathname: "/ignored", timestamp: ~N[2021-01-01 12:01:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/ignored",
- timestamp: ~N[2021-01-01 12:02:00],
- engagement_time: 60_000
- ),
- build(:imported_entry_pages,
- entry_page: "/",
- visitors: 1,
- bounces: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/",
- visitors: 3,
- pageviews: 3,
- total_time_on_page: 300,
- total_time_on_page_visits: 3,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages, page: "/ignored", visitors: 10, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/"]]])
- q = "?period=day&date=2021-01-01&filters=#{filters}&detailed=true&with_imported=true"
-
- conn = get(conn, "/api/stats/#{site.domain}/pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50,
- "name" => "/",
- "pageviews" => 4,
- "time_on_page" => 90.0,
- "visitors" => 4,
- "scroll_depth" => 0,
- "percentage" => 100.0
- }
- ]
- end
-
- test "filter by :member page with imported data", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview, user_id: 1, pathname: "/", timestamp: ~N[2021-01-01 12:00:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/",
- timestamp: ~N[2021-01-01 12:01:00],
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 1, pathname: "/ignored", timestamp: ~N[2021-01-01 12:01:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/ignored",
- timestamp: ~N[2021-01-01 12:02:00],
- engagement_time: 60_000
- ),
- build(:imported_entry_pages,
- entry_page: "/",
- visitors: 1,
- bounces: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_entry_pages,
- entry_page: "/a",
- visitors: 1,
- bounces: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/",
- visitors: 3,
- pageviews: 3,
- total_time_on_page: 300,
- total_time_on_page_visits: 3,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/a",
- visitors: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages, page: "/ignored", visitors: 10, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/", "/a"]]])
- q = "?period=day&date=2021-01-01&filters=#{filters}&detailed=true&with_imported=true"
-
- conn = get(conn, "/api/stats/#{site.domain}/pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50,
- "name" => "/",
- "pageviews" => 4,
- "time_on_page" => 90.0,
- "visitors" => 4,
- "scroll_depth" => 0,
- "percentage" => 80.0
- },
- %{
- "bounce_rate" => 100,
- "name" => "/a",
- "pageviews" => 1,
- "time_on_page" => 10.0,
- "visitors" => 1,
- "scroll_depth" => nil,
- "percentage" => 20.0
- }
- ]
- end
-
- test "filter by :matches_wildcard page with imported data", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview, user_id: 1, pathname: "/aaa", timestamp: ~N[2021-01-01 12:00:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/aaa",
- timestamp: ~N[2021-01-01 12:01:00],
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 1, pathname: "/ignored", timestamp: ~N[2021-01-01 12:01:00]),
- build(:engagement,
- user_id: 1,
- pathname: "/ignored",
- timestamp: ~N[2021-01-01 12:02:00],
- engagement_time: 60_000
- ),
- build(:imported_entry_pages,
- entry_page: "/aaa",
- visitors: 1,
- bounces: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_entry_pages,
- entry_page: "/a",
- visitors: 1,
- bounces: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/aaa",
- visitors: 3,
- pageviews: 3,
- total_time_on_page: 300,
- total_time_on_page_visits: 3,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages,
- page: "/a",
- visitors: 1,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages, page: "/ignored", visitors: 10, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:contains, "event:page", ["/a"]]])
- q = "?period=day&date=2021-01-01&filters=#{filters}&detailed=true&with_imported=true"
-
- conn = get(conn, "/api/stats/#{site.domain}/pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 50.0,
- "name" => "/aaa",
- "pageviews" => 4,
- "time_on_page" => 90,
- "visitors" => 4,
- "scroll_depth" => 0,
- "percentage" => 80.0
- },
- %{
- "bounce_rate" => 100.0,
- "name" => "/a",
- "pageviews" => 1,
- "time_on_page" => 10,
- "visitors" => 1,
- "scroll_depth" => nil,
- "percentage" => 20.0
- }
- ]
- end
-
- test "can compare with previous period", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-02 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- timestamp: ~N[2021-01-02 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- timestamp: ~N[2021-01-02 00:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages?period=day&date=2021-01-02&comparison=previous_period&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 100,
- "comparison" => %{
- "bounce_rate" => 0.0,
- "pageviews" => 0,
- "time_on_page" => nil,
- "visitors" => 0,
- "scroll_depth" => nil,
- "percentage" => 0.0,
- "change" => %{
- "bounce_rate" => nil,
- "pageviews" => 100,
- "time_on_page" => nil,
- "visitors" => 100,
- "scroll_depth" => nil,
- "percentage" => 100
- }
- },
- "name" => "/page2",
- "pageviews" => 2,
- "time_on_page" => nil,
- "visitors" => 2,
- "scroll_depth" => nil,
- "percentage" => 66.67
- },
- %{
- "bounce_rate" => 100,
- "name" => "/page1",
- "pageviews" => 1,
- "time_on_page" => nil,
- "visitors" => 1,
- "scroll_depth" => nil,
- "percentage" => 33.33,
- "comparison" => %{
- "bounce_rate" => 100,
- "pageviews" => 1,
- "time_on_page" => nil,
- "visitors" => 1,
- "scroll_depth" => nil,
- "percentage" => 100.0,
- "change" => %{
- "bounce_rate" => 0,
- "pageviews" => 0,
- "time_on_page" => nil,
- "visitors" => 0,
- "scroll_depth" => nil,
- "percentage" => -67
- }
- }
- }
- ]
-
- assert json_response(conn, 200)["meta"] == %{
- "date_range_label" => "2 Jan 2021",
- "comparison_date_range_label" => "1 Jan 2021"
- }
- end
-
- on_ee do
- test "returns pages across all sites on a consolidated view", %{conn: conn, site: site} do
- another_site = new_site(team: site.team)
- cv = new_consolidated_view(site.team)
-
- populate_stats(site, [
- build(:pageview, pathname: "/a1", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, pathname: "/a2", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, pathname: "/a2", timestamp: ~N[2021-01-01 00:00:00])
- ])
-
- populate_stats(another_site, [
- build(:pageview, pathname: "/b1", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, pathname: "/b1", timestamp: ~N[2021-01-01 00:00:00]),
- build(:pageview, pathname: "/b1", timestamp: ~N[2021-01-01 00:00:00])
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{cv.domain}/pages?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "bounce_rate" => 100,
- "name" => "/b1",
- "pageviews" => 3,
- "time_on_page" => nil,
- "visitors" => 3,
- "scroll_depth" => nil,
- "percentage" => 50.0
- },
- %{
- "bounce_rate" => 100,
- "name" => "/a2",
- "pageviews" => 2,
- "time_on_page" => nil,
- "visitors" => 2,
- "scroll_depth" => nil,
- "percentage" => 33.33
- },
- %{
- "bounce_rate" => 100,
- "name" => "/a1",
- "pageviews" => 1,
- "time_on_page" => nil,
- "visitors" => 1,
- "scroll_depth" => nil,
- "percentage" => 16.67
- }
- ]
- end
- end
- end
-
- describe "GET /api/stats/:domain/entry-pages" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top entry pages by visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- )
- ])
-
- populate_stats(site, [
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 23:15:00]
- )
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 2,
- "visits" => 2,
- "name" => "/page1",
- "visit_duration" => 0,
- "bounce_rate" => 100,
- "percentage" => 66.67
- },
- %{
- "visitors" => 1,
- "visits" => 2,
- "name" => "/page2",
- "visit_duration" => 450,
- "bounce_rate" => 50,
- "percentage" => 33.33
- }
- ]
- end
-
- test "returns top entry pages filtered by custom pageview props", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- pathname: "/blog/john-2",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/blog",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "visitors" => 1,
- "visits" => 1,
- "name" => "/blog",
- "visit_duration" => 60,
- "bounce_rate" => 0,
- "percentage" => 50.0
- },
- %{
- "visitors" => 1,
- "visits" => 1,
- "name" => "/blog/john-2",
- "visit_duration" => 0,
- "bounce_rate" => 100,
- "percentage" => 50.0
- }
- ]
- end
-
- test "returns top entry pages by visitors with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 23:15:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_entry_pages,
- entry_page: "/page2",
- date: ~D[2021-01-01],
- entrances: 3,
- visitors: 2,
- visit_duration: 300
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01")
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "visitors" => 2,
- "visits" => 2,
- "name" => "/page1",
- "visit_duration" => 0,
- "bounce_rate" => 100,
- "percentage" => 66.67
- },
- %{
- "visitors" => 1,
- "visits" => 2,
- "name" => "/page2",
- "visit_duration" => 450,
- "bounce_rate" => 50,
- "percentage" => 33.33
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "visitors" => 3,
- "visits" => 5,
- "name" => "/page2",
- "visit_duration" => 240.0,
- "bounce_rate" => 20.0,
- "percentage" => 60.0
- },
- %{
- "visitors" => 2,
- "visits" => 2,
- "name" => "/page1",
- "visit_duration" => 0.0,
- "bounce_rate" => 100.0,
- "percentage" => 40.0
- }
- ]
- end
-
- test "returns top entry pages by visitors filtered by hostname",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- hostname: "en.example.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- hostname: "es.example.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- hostname: "en.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- hostname: "es.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- pathname: "/exit",
- hostname: "es.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:16:00]
- ),
- build(:pageview,
- pathname: "/page2",
- hostname: "es.example.com",
- timestamp: ~N[2021-01-01 23:15:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["es.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- # We're going to only join sessions where the exit hostname matches the filter
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/page1",
- "visit_duration" => 0,
- "visitors" => 1,
- "visits" => 1,
- "bounce_rate" => 100,
- "percentage" => 50.0
- },
- %{
- "name" => "/page2",
- "visit_duration" => 0,
- "visitors" => 1,
- "visits" => 1,
- "bounce_rate" => 100,
- "percentage" => 50.0
- }
- ]
- end
-
- test "bugfix: pagination on /pages filtered by goal", %{conn: conn, site: site} do
- populate_stats(
- site,
- for i <- 1..30 do
- build(:event,
- user_id: i,
- name: "Signup",
- pathname: "/signup/#{String.pad_leading(to_string(i), 2, "0")}",
- timestamp: ~N[2021-01-01 00:01:00]
- )
- end
- )
-
- insert(:goal, site: site, event_name: "Signup")
-
- request = fn conn, opts ->
- page = Keyword.fetch!(opts, :page)
- limit = Keyword.fetch!(opts, :limit)
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn
- |> get(
- "/api/stats/#{site.domain}/pages?date=2021-01-01&period=day&filters=#{filters}&limit=#{limit}&page=#{page}"
- )
- |> json_response(200)
- |> Map.get("results")
- |> Enum.map(fn %{"name" => "/signup/" <> seq} ->
- seq
- end)
- end
-
- assert List.first(request.(conn, page: 1, limit: 100)) == "01"
- assert List.last(request.(conn, page: 1, limit: 100)) == "30"
- assert List.last(request.(conn, page: 1, limit: 29)) == "29"
- assert ["01", "02"] = request.(conn, page: 1, limit: 2)
- assert ["03", "04"] = request.(conn, page: 2, limit: 2)
- assert ["01", "02", "03", "04", "05"] = request.(conn, page: 1, limit: 5)
- assert ["06", "07", "08", "09", "10"] = request.(conn, page: 2, limit: 5)
- assert ["11", "12", "13", "14", "15"] = request.(conn, page: 3, limit: 5)
- assert ["20"] = request.(conn, page: 20, limit: 1)
- assert [] = request.(conn, page: 31, limit: 1)
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- user_id: 1,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- user_id: 2,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- name: "Signup",
- user_id: 1,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: 3,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: 3,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:event,
- name: "Signup",
- user_id: 3,
- timestamp: ~N[2021-01-01 00:15:00]
- )
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "total_visitors" => 2,
- "visitors" => 1,
- "name" => "/page1",
- "conversion_rate" => 50.0
- },
- %{
- "total_visitors" => 1,
- "visitors" => 1,
- "name" => "/page2",
- "conversion_rate" => 100.0
- }
- ]
- end
-
- test "ignores entry pages from sessions with only custom events", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:event,
- name: "Signup",
- timestamp: ~N[2021-01-01 00:15:00],
- pathname: "/"
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages?period=day&date=2021-01-01"
- )
-
- assert json_response(conn, 200)["results"] == []
- end
-
- test "filter by :matches_member entry_page with imported data", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview, pathname: "/aaa", timestamp: ~N[2021-01-01 12:00:00]),
- build(:pageview, pathname: "/a", timestamp: ~N[2021-01-01 12:00:00]),
- build(:pageview, pathname: "/ignored", timestamp: ~N[2021-01-01 12:01:00]),
- build(:imported_entry_pages,
- entry_page: "/a",
- visitors: 5,
- entrances: 9,
- visit_duration: 1000,
- date: ~D[2021-01-01]
- ),
- build(:imported_entry_pages,
- entry_page: "/bbb",
- visitors: 2,
- entrances: 2,
- visit_duration: 100,
- date: ~D[2021-01-01]
- )
- ])
-
- filters = Jason.encode!([[:contains, "visit:entry_page", ["/a", "/b"]]])
- q = "?period=day&date=2021-01-01&filters=#{filters}&detailed=true&with_imported=true"
-
- conn = get(conn, "/api/stats/#{site.domain}/entry-pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "visit_duration" => 100.0,
- "name" => "/a",
- "visits" => 10,
- "visitors" => 6,
- "bounce_rate" => 10.0,
- "percentage" => 66.67
- },
- %{
- "visit_duration" => 50.0,
- "name" => "/bbb",
- "visits" => 2,
- "visitors" => 2,
- "bounce_rate" => 0.0,
- "percentage" => 22.22
- },
- %{
- "visit_duration" => 0,
- "name" => "/aaa",
- "visits" => 1,
- "visitors" => 1,
- "bounce_rate" => 100.0,
- "percentage" => 11.11
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/exit-pages" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top exit pages by visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- )
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/page1",
- "visitors" => 2,
- "visits" => 2,
- "exit_rate" => 66.7,
- "percentage" => 66.67
- },
- %{
- "name" => "/page2",
- "visitors" => 1,
- "visits" => 1,
- "exit_rate" => 100,
- "percentage" => 33.33
- }
- ]
- end
-
- test "returns top exit pages by ascending visits", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&order_by=#{Jason.encode!([["visits", "asc"]])}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/page2",
- "visitors" => 1,
- "visits" => 1,
- "exit_rate" => 100.0,
- "percentage" => 33.33
- },
- %{
- "name" => "/page1",
- "visitors" => 2,
- "visits" => 2,
- "exit_rate" => 66.7,
- "percentage" => 66.67
- }
- ]
- end
-
- test "returns top exit pages by visitors filtered by hostname",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- hostname: "en.example.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- hostname: "es.example.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- hostname: "en.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- hostname: "es.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- pathname: "/exit",
- hostname: "en.example.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:16:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["es.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- # We're going to only join sessions where the entry hostname matches the filter
- assert json_response(conn, 200)["results"] ==
- [%{"name" => "/page1", "visitors" => 1, "visits" => 1, "percentage" => 100.0}]
- end
-
- test "returns top exit pages filtered by custom pageview props", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/blog/john-1",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- pathname: "/blog/other-post",
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "/", "visitors" => 1, "visits" => 1, "percentage" => 100.0}
- ]
- end
-
- test "returns top exit pages by visitors with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page1",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- pathname: "/page2",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_pages,
- page: "/page2",
- date: ~D[2021-01-01],
- pageviews: 4,
- visitors: 2
- ),
- build(:imported_exit_pages,
- exit_page: "/page2",
- date: ~D[2021-01-01],
- exits: 3,
- visitors: 2
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01")
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "/page1",
- "visitors" => 2,
- "visits" => 2,
- "exit_rate" => 66.7,
- "percentage" => 66.67
- },
- %{
- "name" => "/page2",
- "visitors" => 1,
- "visits" => 1,
- "exit_rate" => 100.0,
- "percentage" => 33.33
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "/page2",
- "visitors" => 3,
- "visits" => 4,
- "exit_rate" => 80.0,
- "percentage" => 60.0
- },
- %{
- "name" => "/page1",
- "visitors" => 2,
- "visits" => 2,
- "exit_rate" => 66.7,
- "percentage" => 40.0
- }
- ]
- end
-
- test "calculates correct exit rate and conversion_rate when filtering for goal", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:event,
- name: "Signup",
- user_id: 1,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 1,
- pathname: "/exit1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- name: "Signup",
- user_id: 2,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/exit1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/exit2",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "/exit1",
- "visitors" => 1,
- "total_visitors" => 1,
- "conversion_rate" => 100.0
- },
- %{
- "name" => "/exit2",
- "visitors" => 1,
- "total_visitors" => 1,
- "conversion_rate" => 100.0
- }
- ]
- end
-
- test "calculates correct exit rate when filtering for page", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- pathname: "/exit1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/exit1",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 2,
- pathname: "/exit2",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 3,
- pathname: "/exit2",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 3,
- pathname: "/should-not-appear",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/exit1"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "/exit1", "visitors" => 1, "visits" => 1, "percentage" => 50.0},
- %{"name" => "/exit2", "visitors" => 1, "visits" => 1, "percentage" => 50.0}
- ]
- end
-
- test "ignores exit pages from sessions with only custom events", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:event,
- name: "Signup",
- timestamp: ~N[2021-01-01 00:15:00],
- pathname: "/"
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages?period=day&date=2021-01-01"
- )
-
- assert json_response(conn, 200)["results"] == []
- end
-
- test "filter by :is_not exit_page with imported data", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- populate_stats(site, site_import.id, [
- build(:pageview, pathname: "/aaa", timestamp: ~N[2021-01-01 12:00:00]),
- build(:pageview, pathname: "/a", timestamp: ~N[2021-01-01 12:00:00]),
- build(:pageview, pathname: "/ignored", timestamp: ~N[2021-01-01 12:01:00]),
- build(:imported_exit_pages,
- exit_page: "/a",
- visitors: 5,
- exits: 9,
- visit_duration: 1000,
- date: ~D[2021-01-01]
- ),
- build(:imported_exit_pages,
- exit_page: "/bbb",
- visitors: 2,
- exits: 2,
- visit_duration: 100,
- date: ~D[2021-01-01]
- ),
- build(:imported_pages, page: "/a", pageviews: 19, date: ~D[2021-01-01]),
- build(:imported_pages, page: "/bbb", pageviews: 2, date: ~D[2021-01-01])
- ])
-
- filters = Jason.encode!([[:is_not, "visit:exit_page", ["/ignored"]]])
- q = "?period=day&date=2021-01-01&filters=#{filters}&detailed=true&with_imported=true"
-
- conn = get(conn, "/api/stats/#{site.domain}/exit-pages#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "exit_rate" => 50.0,
- "name" => "/a",
- "visits" => 10,
- "visitors" => 6,
- "percentage" => 66.67
- },
- %{
- "exit_rate" => 100.0,
- "name" => "/bbb",
- "visits" => 2,
- "visitors" => 2,
- "percentage" => 22.22
- },
- %{
- "exit_rate" => 100.0,
- "name" => "/aaa",
- "visits" => 1,
- "visitors" => 1,
- "percentage" => 11.11
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for entry pages breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, pathname: "/first"),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, pathname: "/second"),
- build(:event,
- user_id: 2,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("3000"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("4000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, pathname: "/first"),
- build(:event,
- name: "Payment",
- user_id: 3,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 4, pathname: "/third"),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("2500"),
- revenue_reporting_currency: "USD"
- ),
- build(:event, name: "Payment", revenue_reporting_amount: nil),
- build(:event, name: "Payment", revenue_reporting_amount: nil)
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/entry-pages#{q}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/first",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$3,500.00",
- "short" => "$3.5K",
- "value" => 3500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/second",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$7,000.00",
- "short" => "$7.0K",
- "value" => 7000.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/third",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for exit pages breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, pathname: "/first"),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 1, pathname: "/exit_first"),
- build(:pageview, user_id: 2, pathname: "/second"),
- build(:event,
- user_id: 2,
- name: "Payment",
- revenue_reporting_amount: Decimal.new("3000"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("4000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, pathname: "/exit_second"),
- build(:pageview, user_id: 3, pathname: "/first"),
- build(:event,
- name: "Payment",
- user_id: 3,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, pathname: "/exit_first"),
- build(:pageview, user_id: 4, pathname: "/third"),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("2500"),
- revenue_reporting_currency: "USD"
- ),
- build(:event, name: "Payment", revenue_reporting_amount: nil),
- build(:event, name: "Payment", revenue_reporting_amount: nil)
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/exit-pages#{q}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/exit_first",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$3,500.00",
- "short" => "$3.5K",
- "value" => 3500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/exit_second",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$7,000.00",
- "short" => "$7.0K",
- "value" => 7000.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/third",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for pages breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, pathname: "/first"),
- build(:event,
- name: "Payment",
- pathname: "/purchase/first",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 1, pathname: "/exit_first"),
- build(:pageview, user_id: 2, pathname: "/second"),
- build(:event,
- user_id: 2,
- name: "Payment",
- pathname: "/purchase/second",
- revenue_reporting_amount: Decimal.new("3000"),
- revenue_reporting_currency: "USD"
- ),
- build(:event,
- name: "Payment",
- pathname: "/purchase/second",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("4000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, pathname: "/exit_second"),
- build(:pageview, user_id: 3, pathname: "/first"),
- build(:event,
- name: "Payment",
- pathname: "/purchase/first",
- user_id: 3,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, pathname: "/exit_first"),
- build(:pageview, user_id: 4, pathname: "/third"),
- build(:event,
- name: "Payment",
- pathname: "/purchase/third",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("2500"),
- revenue_reporting_currency: "USD"
- ),
- build(:event, name: "Payment", pathname: "/nopay", revenue_reporting_amount: nil),
- build(:event, name: "Payment", pathname: "/nopay", revenue_reporting_amount: nil),
- build(:event, name: "Payment", pathname: "/nopay", revenue_reporting_amount: nil)
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/pages#{q}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$0.00",
- "short" => "$0.0",
- "value" => 0.0
- },
- "conversion_rate" => 100.0,
- "name" => "/nopay",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$0.00",
- "short" => "$0.0",
- "value" => 0.0
- },
- "total_visitors" => 3,
- "visitors" => 3
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/purchase/first",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$3,500.00",
- "short" => "$3.5K",
- "value" => 3500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/purchase/second",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$7,000.00",
- "short" => "$7.0K",
- "value" => 7000.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "conversion_rate" => 100.0,
- "name" => "/purchase/third",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$2,500.00",
- "short" => "$2.5K",
- "value" => 2500.0
- },
- "total_visitors" => 1,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/regions_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/regions_legacy_test.exs
deleted file mode 100644
index da441171df..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/regions_legacy_test.exs
+++ /dev/null
@@ -1,237 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.RegionsLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/regions" do
- defp seed(%{site: site}) do
- populate_stats(site, [
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:pageview,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- )
- ])
- end
-
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import, :seed]
-
- test "returns top cities by new visitors", %{conn: conn, site: site} do
- conn = get(conn, "/api/stats/#{site.domain}/regions?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE-37",
- "country_flag" => "🇪🇪",
- "name" => "Harjumaa",
- "visitors" => 3,
- "percentage" => 60.0
- },
- %{
- "code" => "EE-39",
- "country_flag" => "🇪🇪",
- "name" => "Hiiumaa",
- "visitors" => 2,
- "percentage" => 40.0
- }
- ]
- end
-
- test "when list is filtered returns one city only", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "visit:region", ["EE-39"]]])
- conn = get(conn, "/api/stats/#{site.domain}/regions?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "code" => "EE-39",
- "country_flag" => "🇪🇪",
- "name" => "Hiiumaa",
- "visitors" => 2,
- "percentage" => 100.0
- }
- ]
- end
-
- test "malicious input - date", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "visit:region", ["EE-39"]]])
- garbage = "2020-07-30'||DBMS_PIPE.RECEIVE_MESSAGE(CHR(98)||CHR(98)||CHR(98),15)||'"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/regions?period=custom&filters=#{filters}&date=#{garbage}"
- )
-
- assert resp = response(conn, 400)
- assert resp =~ "Failed to parse 'date' argument."
- end
-
- test "malicious input - from", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "visit:region", ["EE-39"]]])
- garbage = "2020-07-30'||DBMS_PIPE.RECEIVE_MESSAGE(CHR(98)||CHR(98)||CHR(98),15)||'"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/regions?period=custom&filters=#{filters}&from=#{garbage}"
- )
-
- assert resp = response(conn, 400)
- assert resp =~ "Failed to parse 'from' argument."
- end
-
- test "malicious input - to", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "visit:region", ["EE-39"]]])
- garbage = "2020-07-30'||DBMS_PIPE.RECEIVE_MESSAGE(CHR(98)||CHR(98)||CHR(98),15)||'"
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/regions?period=custom&filters=#{filters}&from=2020-04-01&to=#{garbage}"
- )
-
- assert resp = response(conn, 400)
- assert resp =~ "Failed to parse 'to' argument."
- end
-
- @tag :ee_only
- test "return revenue metrics for regions breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409
- ),
- build(:pageview,
- user_id: 4,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- country_code: "EE",
- subdivision1_code: "EE-39",
- city_geoname_id: 591_632
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/regions#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 33.33,
- "name" => "Harjumaa",
- "code" => "EE-37",
- "country_flag" => "🇪🇪",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 6,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 25.0,
- "name" => "Hiiumaa",
- "code" => "EE-39",
- "country_flag" => "🇪🇪",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 4,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/screen_sizes_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/screen_sizes_legacy_test.exs
deleted file mode 100644
index 64100328b4..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/screen_sizes_legacy_test.exs
+++ /dev/null
@@ -1,439 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.ScreenSizesLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- describe "GET /api/stats/:domain/screen-sizes" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns screen sizes by new visitors", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, screen_size: "Desktop"),
- build(:pageview, screen_size: "Desktop"),
- build(:pageview, screen_size: "Laptop")
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Laptop", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns bounce_rate and visit_duration when detailed=true", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- timestamp: ~N[2021-01-01 12:00:00],
- screen_size: "Desktop"
- ),
- build(:pageview,
- user_id: 123,
- timestamp: ~N[2021-01-01 12:10:00],
- screen_size: "Desktop"
- ),
- build(:pageview, timestamp: ~N[2021-01-01 12:00:00], screen_size: "Desktop"),
- build(:pageview, timestamp: ~N[2021-01-01 12:00:00], screen_size: "Laptop")
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/screen-sizes?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Desktop",
- "visitors" => 2,
- "bounce_rate" => 50,
- "visit_duration" => 300,
- "percentage" => 66.67
- },
- %{
- "name" => "Laptop",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 33.33
- }
- ]
- end
-
- test "returns screen sizes for user making multiple sessions", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- screen_size: "Desktop",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 1,
- screen_size: "Laptop",
- timestamp: ~N[2021-01-01 05:00:00]
- )
- ])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/screen-sizes", %{
- "period" => "day",
- "date" => "2021-01-01"
- })
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 1, "percentage" => 100},
- %{"name" => "Laptop", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "returns (not set) when appropriate", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- screen_size: ""
- ),
- build(:pageview,
- screen_size: "Desktop"
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 50},
- %{"name" => "Desktop", "visitors" => 1, "percentage" => 50}
- ]
-
- filters = Jason.encode!([[:is, "visit:screen", ["(not set)"]]])
- conn2 = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&filters=#{filters}")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "select empty imported_devices as (not set), merging with the native (not set)", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, user_id: 123),
- build(:imported_devices, visitors: 1),
- build(:imported_visitors, visitors: 1)
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&with_imported=true")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "(not set)", "visitors" => 2, "percentage" => 100.0}
- ]
- end
-
- test "returns screen sizes with :is filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- screen_size: "Desktop"
- ),
- build(:pageview,
- user_id: 123,
- screen_size: "Desktop",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- screen_size: "Mobile",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- screen_size: "Tablet"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 1, "percentage" => 100}
- ]
- end
-
- test "returns screen sizes with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- screen_size: "Desktop",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- user_id: 123,
- screen_size: "Desktop",
- "meta.key": ["author"],
- "meta.value": ["John Doe"]
- ),
- build(:pageview,
- screen_size: "Mobile",
- "meta.key": ["author"],
- "meta.value": ["other"]
- ),
- build(:pageview,
- screen_size: "Tablet"
- )
- ])
-
- filters = Jason.encode!([["is_not", "event:props:author", ["John Doe"]]])
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Mobile", "visitors" => 1, "percentage" => 50},
- %{"name" => "Tablet", "visitors" => 1, "percentage" => 50}
- ]
- end
-
- test "returns screen sizes by new visitors with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, screen_size: "Desktop"),
- build(:pageview, screen_size: "Desktop"),
- build(:pageview, screen_size: "Laptop")
- ])
-
- populate_stats(site, [
- build(:imported_devices, device: "Mobile"),
- build(:imported_devices, device: "Laptop"),
- build(:imported_visitors, visitors: 2)
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Laptop", "visitors" => 1, "percentage" => 33.33}
- ]
-
- conn2 = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 40},
- %{"name" => "Laptop", "visitors" => 2, "percentage" => 40},
- %{"name" => "Mobile", "visitors" => 1, "percentage" => 20}
- ]
- end
-
- test "returns screen sizes when filtering by imported screen size", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, screen_size: "Desktop"),
- build(:imported_devices, device: "Desktop"),
- build(:imported_devices, device: "Laptop"),
- build(:imported_visitors, visitors: 2)
- ])
-
- filters = Jason.encode!([[:is, "visit:screen", ["Desktop"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/screen-sizes?filters=#{filters}&period=day&with_imported=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 100.0}
- ]
- end
-
- test "returns screen sizes for user making multiple sessions by no of visitors with imported data",
- %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- screen_size: "Desktop",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 1,
- screen_size: "Laptop",
- timestamp: ~N[2021-01-01 05:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_devices, device: "Desktop", date: ~D[2021-01-01]),
- build(:imported_devices, device: "Laptop", date: ~D[2021-01-01]),
- build(:imported_visitors, visitors: 1, date: ~D[2021-01-01])
- ])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/screen-sizes", %{
- "period" => "day",
- "date" => "2021-01-01",
- "with_imported" => "true"
- })
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 100},
- %{"name" => "Laptop", "visitors" => 2, "percentage" => 100}
- ]
- end
-
- test "calculates conversion_rate when filtering for goal", %{conn: conn, site: site} do
- insert(:goal, site: site, event_name: "Signup")
-
- populate_stats(site, [
- build(:pageview, user_id: 1, screen_size: "Desktop"),
- build(:pageview, user_id: 2, screen_size: "Desktop"),
- build(:event, user_id: 1, name: "Signup")
- ])
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Desktop",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns screen sizes with not_member filter type", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, referrer_source: "Google", screen_size: "Desktop"),
- build(:pageview, referrer_source: "Bad source", screen_size: "Desktop"),
- build(:pageview, referrer_source: "Google", screen_size: "Desktop"),
- build(:pageview, referrer_source: "Twitter", screen_size: "Mobile"),
- build(:pageview,
- referrer_source: "Second bad source",
- screen_size: "Mobile"
- )
- ])
-
- filters = Jason.encode!([["is_not", "visit:source", ["Bad source", "Second bad source"]]])
-
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Desktop", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "Mobile", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for screen sizes breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 1, screen_size: "Mobile"),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 2, screen_size: "Mobile"),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 3, screen_size: "Mobile"),
- build(:pageview, user_id: 4, screen_size: "Desktop"),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 5, screen_size: "Desktop"),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/screen-sizes#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "conversion_rate" => 100.0,
- "name" => "(not set)",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "total_visitors" => 2,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "Mobile",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "Desktop",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/api/stats_controller/sources_legacy_test.exs b/test/plausible_web/controllers/api/stats_controller/sources_legacy_test.exs
deleted file mode 100644
index c8487c8719..0000000000
--- a/test/plausible_web/controllers/api/stats_controller/sources_legacy_test.exs
+++ /dev/null
@@ -1,2935 +0,0 @@
-defmodule PlausibleWeb.Api.StatsController.SourcesLegacyTest do
- @moduledoc """
- [DEPRECATED] Still used for CSV export but to be removed.
- """
- use PlausibleWeb.ConnCase
-
- @user_id Enum.random(1000..9999)
-
- describe "GET /api/stats/:domain/sources" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top sources by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- ),
- build(:pageview)
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/sources?period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 3, "percentage" => 50.0},
- %{"name" => "DuckDuckGo", "visitors" => 2, "percentage" => 33.33},
- %{"name" => "Direct / None", "visitors" => 1, "percentage" => 16.67}
- ]
- end
-
- test "returns top sources with :is filter on custom pageview props", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
-
- assert json_response(conn, 200)["meta"] == %{
- "date_range_label" => "1 Jan 2021"
- }
- end
-
- test "returns top sources with :is_not filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- "meta.key": ["author"],
- "meta.value": ["other"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["John Doe"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns top sources with :is (none) filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- "meta.key": ["author"],
- "meta.value": ["John Doe"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["(none)"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Facebook", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns top sources with :is_not (none) filter on custom pageview props", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- "meta.key": ["logged_in"],
- "meta.value": ["true"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- "meta.key": ["author"],
- "meta.value": ["other"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["other"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["author"],
- "meta.value": ["another"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- filters = Jason.encode!([[:is_not, "event:props:author", ["(none)"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns top sources with imported data", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, referrer_source: "Google", referrer: "google.com"),
- build(:pageview, referrer_source: "Google", referrer: "google.com"),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- )
- ])
-
- populate_stats(site, [
- build(:imported_visitors),
- build(:imported_visitors),
- build(:imported_visitors),
- build(:imported_sources,
- source: "Google",
- visitors: 2
- ),
- build(:imported_sources,
- source: "DuckDuckGo",
- visitors: 1
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/sources?period=day")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
-
- conn2 = get(conn, "/api/stats/#{site.domain}/sources?period=day&with_imported=true")
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "Google", "visitors" => 4, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 2, "percentage" => 33.33}
- ]
- end
-
- test "calculates bounce rate and visit duration for sources", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 50.0
- },
- %{
- "name" => "Google",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 50.0
- }
- ]
- end
-
- test "calculates bounce rate and visit duration for sources with imported data", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_visitors, date: ~D[2021-01-01]),
- build(:imported_visitors, date: ~D[2021-01-01]),
- build(:imported_visitors, date: ~D[2021-01-01]),
- build(:imported_sources,
- source: "Google",
- date: ~D[2021-01-01],
- visitors: 2,
- visits: 3,
- bounces: 1,
- visit_duration: 900
- ),
- build(:imported_sources,
- source: "DuckDuckGo",
- date: ~D[2021-01-01],
- visitors: 1,
- visits: 1,
- visit_duration: 100,
- bounces: 0
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 50.0
- },
- %{
- "name" => "Google",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 50.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&detailed=true&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "Google",
- "visitors" => 3,
- "bounce_rate" => 25.0,
- "visit_duration" => 450.0,
- "percentage" => 60.0
- },
- %{
- "name" => "DuckDuckGo",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 50.0,
- "percentage" => 40.0
- }
- ]
- end
-
- test "returns top sources in realtime report", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- timestamp: relative_time(minute: -3)
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- timestamp: relative_time(minute: -2)
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- timestamp: relative_time(minute: -1)
- )
- ])
-
- conn = get(conn, "/api/stats/#{site.domain}/sources?period=realtime")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "can paginate the results", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- ),
- build(:imported_sources,
- source: "DuckDuckGo"
- ),
- build(:imported_sources,
- source: "DuckDuckGo"
- )
- ])
-
- conn1 = get(conn, "/api/stats/#{site.domain}/sources?period=day&limit=1&page=2")
-
- assert json_response(conn1, 200)["results"] == [
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&limit=1&page=2&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67}
- ]
- end
-
- test "shows sources for a page (using old page filter)", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/page1", referrer_source: "Google"),
- build(:pageview, pathname: "/page1", referrer_source: "Google"),
- build(:pageview,
- user_id: 1,
- pathname: "/page2",
- referrer_source: "DuckDuckGo"
- ),
- build(:pageview,
- user_id: 1,
- pathname: "/page1",
- referrer_source: "DuckDuckGo"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/page1"]]])
- conn = get(conn, "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "shows sources for a page (using new filters)", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, pathname: "/page1", referrer_source: "Google"),
- build(:pageview, pathname: "/page1", referrer_source: "Google"),
- build(:pageview,
- user_id: 1,
- pathname: "/page2",
- referrer_source: "DuckDuckGo"
- ),
- build(:pageview,
- user_id: 1,
- pathname: "/page1",
- referrer_source: "DuckDuckGo"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/page1"]]])
- conn = get(conn, "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "Google", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "DuckDuckGo", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "order_by [[visit:source, desc]] is respected", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, referrer_source: "C"),
- build(:pageview, referrer_source: "A"),
- build(:pageview, referrer_source: "B")
- ])
-
- order_by = Jason.encode!([["visit:source", "desc"]])
- conn = get(conn, "/api/stats/#{site.domain}/sources?order_by=#{order_by}&period=day")
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "C", "visitors" => 1, "percentage" => 33.33},
- %{"name" => "B", "visitors" => 1, "percentage" => 33.33},
- %{"name" => "A", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "order_by [[visit_duration, asc], [visit:source, desc]]] is respected and flipping the sort orders works",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- pathname: "/in",
- user_id: @user_id,
- referrer_source: "B",
- timestamp: ~N[2024-08-10 09:00:00]
- ),
- build(:pageview,
- pathname: "/out",
- user_id: @user_id,
- referrer_source: "B",
- timestamp: ~N[2024-08-10 09:00:45]
- ),
- build(:pageview,
- pathname: "/in",
- user_id: @user_id,
- referrer_source: "C",
- timestamp: ~N[2024-08-10 10:00:00]
- ),
- build(:pageview,
- pathname: "/out",
- user_id: @user_id,
- referrer_source: "C",
- timestamp: ~N[2024-08-10 10:00:30]
- ),
- build(:pageview, referrer_source: "A", timestamp: ~N[2024-08-10 10:00:30]),
- build(:pageview, referrer_source: "A", timestamp: ~N[2024-08-10 10:00:30]),
- build(:pageview, referrer_source: "Z", timestamp: ~N[2024-08-10 10:00:30])
- ])
-
- order_by_asc = Jason.encode!([["visit_duration", "asc"], ["visit:source", "desc"]])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2024-08-10&detailed=true&order_by=#{order_by_asc}"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "Z",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 25.0
- },
- %{
- "name" => "A",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 50.0
- },
- %{
- "name" => "C",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 30,
- "percentage" => 25.0
- },
- %{
- "name" => "B",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 45,
- "percentage" => 25.0
- }
- ]
-
- order_by_flipped = Jason.encode!([["visit_duration", "desc"], ["visit:source", "asc"]])
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2024-08-10&detailed=true&order_by=#{order_by_flipped}"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "B",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 45,
- "percentage" => 25.0
- },
- %{
- "name" => "C",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 30,
- "percentage" => 25.0
- },
- %{
- "name" => "A",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 50.0
- },
- %{
- "name" => "Z",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 25.0
- }
- ]
- end
-
- test "can compare with previous period", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- timestamp: ~N[2021-01-02 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- timestamp: ~N[2021-01-02 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Google",
- referrer: "google.com",
- timestamp: ~N[2021-01-02 00:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-02&comparison=previous_period&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Google",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67,
- "comparison" => %{
- "visitors" => 0,
- "bounce_rate" => 0,
- "visit_duration" => nil,
- "percentage" => 0.0,
- "change" => %{
- "visitors" => 100,
- "bounce_rate" => nil,
- "visit_duration" => nil,
- "percentage" => 100
- }
- }
- },
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 33.33,
- "comparison" => %{
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 100.0,
- "change" => %{
- "visitors" => 0,
- "bounce_rate" => 0,
- "visit_duration" => 0,
- "percentage" => -67
- }
- }
- }
- ]
-
- assert json_response(conn, 200)["meta"] == %{
- "date_range_label" => "2 Jan 2021",
- "comparison_date_range_label" => "1 Jan 2021"
- }
- end
-
- @tag :ee_only
- test "return revenue metrics for sources breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- user_id: 4,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- ),
- build(:pageview,
- user_id: 8,
- referrer_source: "Bing",
- referrer: "bing.com"
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/sources#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Direct / None",
- "visitors" => 2,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "conversion_rate" => 100.0,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "total_visitors" => 2
- },
- %{
- "name" => "Google",
- "visitors" => 2,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3
- },
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2
- }
- ]
- end
- end
-
- describe "UTM parameters with hostname filter" do
- setup [:create_user, :log_in, :create_site]
-
- for {resource, attr} <- [
- utm_campaigns: :utm_campaign,
- utm_sources: :utm_source,
- utm_terms: :utm_term,
- utm_contents: :utm_content
- ] do
- test "returns #{resource} when filtered by hostname", %{conn: conn, site: site} do
- populate_stats(site, [
- # session starts at two.example.com with utm_param=ad
- build(
- :pageview,
- [
- {unquote(attr), "ad"},
- {:user_id, @user_id},
- {:hostname, "two.example.com"},
- {:timestamp, ~N[2021-01-01 00:00:00]}
- ]
- ),
- # session continues on one.example.com without any utm_params
- build(
- :pageview,
- [
- {:user_id, @user_id},
- {:hostname, "one.example.com"},
- {:timestamp, ~N[2021-01-01 00:15:00]}
- ]
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["one.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/#{unquote(resource)}?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- # nobody landed on one.example.com from utm_param=ad
- assert json_response(conn, 200)["results"] == []
- end
- end
- end
-
- describe "GET /api/stats/:domain/channels" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns top channels by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Bing",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Bing",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- utm_source: "fb-ads",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "Facebook",
- utm_source: "fb-ads",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/channels?period=day&&detailed=true&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "Paid Social",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "Organic Search",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 33.33
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for channels breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- referrer_source: "Google",
- referrer: "google.com"
- ),
- build(:pageview,
- user_id: 4,
- referrer_source: "Facebook",
- utm_source: "fb-ads"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- referrer_source: "Facebook",
- utm_source: "fb-ads"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/channels#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Direct",
- "visitors" => 2,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "conversion_rate" => 100.0,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$600.00",
- "short" => "$600.0",
- "value" => 600.0
- },
- "total_visitors" => 2
- },
- %{
- "name" => "Organic Search",
- "visitors" => 2,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3
- },
- %{
- "name" => "Paid Social",
- "visitors" => 1,
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/utm_mediums" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top utm_mediums by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_medium: "social",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_medium: "social",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_medium: "email",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_medium: "social",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_medium: "email",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 100
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_mediums?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "email",
- "visitors" => 1,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 50.0
- },
- %{
- "name" => "social",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 50.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_mediums?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "email",
- "visitors" => 2,
- "bounce_rate" => 50,
- "visit_duration" => 50,
- "percentage" => 50.0
- },
- %{
- "name" => "social",
- "visitors" => 2,
- "bounce_rate" => 50,
- "visit_duration" => 800.0,
- "percentage" => 50.0
- }
- ]
- end
-
- test "filters out entries without utm_medium present", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_medium: "social",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_medium: "social",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_medium: "",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_medium: "social",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_medium: "",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 100
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_mediums?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "social",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 100.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_mediums?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "social",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for UTM mediums breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- utm_medium: "social"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- utm_medium: "social"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- utm_medium: "social"
- ),
- build(:pageview,
- user_id: 4,
- utm_medium: "email"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- utm_medium: "email"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/utm_mediums#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "social",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "email",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/utm_campaigns" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top utm_campaigns by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_campaign: "profile",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_campaign: "profile",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_campaign: "august",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_campaign: "august",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_campaign: "profile",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_campaign: "august",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_campaigns?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "august",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "profile",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 33.33
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_campaigns?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "august",
- "visitors" => 3,
- "bounce_rate" => 67,
- "visit_duration" => 300,
- "percentage" => 60.0
- },
- %{
- "name" => "profile",
- "visitors" => 2,
- "bounce_rate" => 50,
- "visit_duration" => 800.0,
- "percentage" => 40.0
- }
- ]
- end
-
- test "filters out entries without utm_campaign present", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_campaign: "profile",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_campaign: "profile",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_campaign: "",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_campaign: "",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_campaign: "profile",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_campaign: "",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_campaigns?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "profile",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 100.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_campaigns?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "profile",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for UTM campaigns breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- utm_campaign: "profile"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- utm_campaign: "profile"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- utm_campaign: "profile"
- ),
- build(:pageview,
- user_id: 4,
- utm_campaign: "august"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- utm_campaign: "august"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/utm_campaigns#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "profile",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "august",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/utm_sources" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top utm_sources by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_source: "Twitter",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_source: "Twitter",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_source: "newsletter",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_source: "newsletter",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_sources?period=day&date=2021-01-01"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "newsletter",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "Twitter",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 33.33
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for UTM sources breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- utm_source: "Twitter"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- utm_source: "Twitter"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- utm_source: "Twitter"
- ),
- build(:pageview,
- user_id: 4,
- utm_source: "newsletter"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- utm_source: "newsletter"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/utm_sources#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "Twitter",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "newsletter",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/utm_terms" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top utm_terms by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_term: "oat milk",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_term: "oat milk",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_term: "Sweden",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_term: "Sweden",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_term: "oat milk",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_term: "Sweden",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_terms?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "Sweden",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "oat milk",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 33.33
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_terms?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "Sweden",
- "visitors" => 3,
- "bounce_rate" => 67.0,
- "visit_duration" => 300.0,
- "percentage" => 60.0
- },
- %{
- "name" => "oat milk",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 40.0
- }
- ]
- end
-
- test "filters out entries without utm_term present", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_term: "oat milk",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_term: "oat milk",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_term: "",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_term: "",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_term: "oat milk",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_term: "",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_terms?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "oat milk",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 100.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_terms?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "oat milk",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for UTM terms breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- utm_term: "oat milk"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- utm_term: "oat milk"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- utm_term: "oat milk"
- ),
- build(:pageview,
- user_id: 4,
- utm_term: "Sweden"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- utm_term: "Sweden"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/utm_terms#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "oat milk",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "Sweden",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/utm_contents" do
- setup [:create_user, :log_in, :create_site, :create_legacy_site_import]
-
- test "returns top utm_contents by unique user ids", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_content: "ad",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_content: "ad",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_content: "blog",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_content: "blog",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_content: "ad",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_content: "blog",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_contents?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "blog",
- "visitors" => 2,
- "bounce_rate" => 100,
- "visit_duration" => 0,
- "percentage" => 66.67
- },
- %{
- "name" => "ad",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 33.33
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_contents?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "blog",
- "visitors" => 3,
- "bounce_rate" => 67.0,
- "visit_duration" => 300.0,
- "percentage" => 60.0
- },
- %{
- "name" => "ad",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 40.0
- }
- ]
- end
-
- test "filters out entries without utm_content present", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- utm_content: "ad",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_content: "ad",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- utm_content: "",
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- utm_content: "",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- populate_stats(site, [
- build(:imported_sources,
- utm_content: "ad",
- date: ~D[2021-01-01],
- visit_duration: 700,
- bounces: 1,
- visits: 1,
- visitors: 1
- ),
- build(:imported_sources,
- utm_content: "",
- date: ~D[2021-01-01],
- bounces: 0,
- visits: 1,
- visitors: 1,
- visit_duration: 900
- )
- ])
-
- conn1 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_contents?period=day&date=2021-01-01"
- )
-
- assert json_response(conn1, 200)["results"] == [
- %{
- "name" => "ad",
- "visitors" => 1,
- "bounce_rate" => 0,
- "visit_duration" => 900,
- "percentage" => 100.0
- }
- ]
-
- conn2 =
- get(
- conn,
- "/api/stats/#{site.domain}/utm_contents?period=day&date=2021-01-01&with_imported=true"
- )
-
- assert json_response(conn2, 200)["results"] == [
- %{
- "name" => "ad",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 800.0,
- "percentage" => 100.0
- }
- ]
- end
-
- @tag :ee_only
- test "return revenue metrics for UTM contents breakdown", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- user_id: 1,
- utm_content: "ad"
- ),
- build(:event,
- name: "Payment",
- user_id: 1,
- revenue_reporting_amount: Decimal.new("1000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 2,
- utm_content: "ad"
- ),
- build(:event,
- name: "Payment",
- user_id: 2,
- revenue_reporting_amount: Decimal.new("2000"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 3,
- utm_content: "ad"
- ),
- build(:pageview,
- user_id: 4,
- utm_content: "blog"
- ),
- build(:event,
- name: "Payment",
- user_id: 4,
- revenue_reporting_amount: Decimal.new("500"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview,
- user_id: 5,
- utm_content: "blog"
- ),
- build(:pageview, user_id: 6),
- build(:event,
- name: "Payment",
- user_id: 6,
- revenue_reporting_amount: Decimal.new("600"),
- revenue_reporting_currency: "USD"
- ),
- build(:pageview, user_id: 7),
- build(:event,
- name: "Payment",
- user_id: 7,
- revenue_reporting_amount: nil
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Payment", currency: :USD})
-
- filters = Jason.encode!([[:is, "event:goal", ["Payment"]]])
- order_by = Jason.encode!([["visitors", "desc"]])
-
- q = "?filters=#{filters}&order_by=#{order_by}&detailed=true&period=day&page=1&limit=100"
-
- conn = get(conn, "/api/stats/#{site.domain}/utm_contents#{q}")
-
- assert json_response(conn, 200)["results"] == [
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$1,500.00",
- "short" => "$1.5K",
- "value" => 1500.0
- },
- "conversion_rate" => 66.67,
- "name" => "ad",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$3,000.00",
- "short" => "$3.0K",
- "value" => 3000.0
- },
- "total_visitors" => 3,
- "visitors" => 2
- },
- %{
- "average_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "conversion_rate" => 50.0,
- "name" => "blog",
- "total_revenue" => %{
- "currency" => "USD",
- "long" => "$500.00",
- "short" => "$500.0",
- "value" => 500.0
- },
- "total_visitors" => 2,
- "visitors" => 1
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/sources - with goal filter" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns top referrers for a custom goal including conversion_rate", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Twitter",
- user_id: @user_id
- ),
- build(:event,
- name: "Signup",
- user_id: @user_id
- ),
- build(:pageview,
- referrer_source: "Twitter"
- )
- ])
-
- # Imported data is ignored when filtering
- populate_stats(site, [
- build(:imported_sources, source: "Twitter")
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Twitter",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
-
- test "returns no top referrers for a custom goal and filtered by hostname",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- hostname: "blog.example.com",
- referrer_source: "Facebook",
- user_id: @user_id
- ),
- build(:pageview,
- hostname: "app.example.com",
- pathname: "/register",
- user_id: @user_id
- ),
- build(:event,
- name: "Signup",
- hostname: "app.example.com",
- pathname: "/register",
- user_id: @user_id
- )
- ])
-
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Signup"]],
- [:is, "event:hostname", ["app.example.com"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == []
- end
-
- test "returns top referrers for a custom goal and filtered by hostname (2)",
- %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- hostname: "app.example.com",
- referrer_source: "Facebook",
- pathname: "/register",
- user_id: @user_id
- ),
- build(:event,
- name: "Signup",
- hostname: "app.example.com",
- pathname: "/register",
- user_id: @user_id
- )
- ])
-
- insert(:goal, site: site, event_name: "Signup")
-
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Signup"]],
- [:is, "event:hostname", ["app.example.com"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "conversion_rate" => 100.0,
- "name" => "Facebook",
- "total_visitors" => 1,
- "visitors" => 1
- }
- ]
- end
-
- test "returns top referrers with goal filter + :is prop filter", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- name: "Download",
- "meta.key": ["method", "logged_in"],
- "meta.value": ["HTTP", "true"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- "meta.key": ["logged_in"],
- "meta.value": ["true"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- referrer_source: "Facebook",
- referrer: "facebook.com",
- name: "Download",
- "meta.key": ["method", "logged_in"],
- "meta.value": ["HTTP", "false"],
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- insert(:goal, site: site, event_name: "Download")
-
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Download"]],
- [:is, "event:props:logged_in", ["true"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "conversion_rate" => 50.0,
- "total_visitors" => 2
- }
- ]
- end
-
- test "returns top referrers with goal filter + prop :is_not filter", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "DuckDuckGo",
- referrer: "duckduckgo.com",
- user_id: 123,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- name: "Download",
- "meta.key": ["method"],
- "meta.value": ["HTTP"],
- user_id: 123,
- timestamp: ~N[2021-01-01 00:01:00]
- ),
- build(:event,
- name: "Download",
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["method", "logged_in"],
- "meta.value": ["HTTP", "true"],
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:event,
- name: "Download",
- referrer_source: "Google",
- referrer: "google.com",
- "meta.key": ["method", "logged_in"],
- "meta.value": ["HTTP", "false"],
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- insert(:goal, site: site, event_name: "Download")
-
- filters =
- Jason.encode!([
- [:is, "event:goal", ["Download"]],
- [:is_not, "event:props:logged_in", ["true"]]
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&date=2021-01-01&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "DuckDuckGo",
- "visitors" => 1,
- "conversion_rate" => 100.0,
- "total_visitors" => 1
- },
- %{
- "name" => "Google",
- "visitors" => 1,
- "conversion_rate" => 50.0,
- "total_visitors" => 2
- }
- ]
- end
-
- test "returns top referrers for a pageview goal including conversion_rate", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "Twitter",
- user_id: @user_id
- ),
- build(:pageview,
- pathname: "/register",
- user_id: @user_id
- ),
- build(:pageview,
- referrer_source: "Twitter"
- )
- ])
-
- insert(:goal, site: site, page_path: "/register")
- filters = Jason.encode!([[:is, "event:goal", ["Visit /register"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/sources?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "Twitter",
- "total_visitors" => 2,
- "visitors" => 1,
- "conversion_rate" => 50.0
- }
- ]
- end
- end
-
- describe "GET /api/stats/:domain/referrer-drilldown (Google Search Terms)" do
- setup [:create_user, :log_in, :create_site]
-
- test "gets keywords from Google", %{conn: conn, site: site} do
- conn = get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day")
-
- assert %{
- "results" => [
- %{
- "name" => "simple web analytics",
- "visitors" => 25,
- "impressions" => 50,
- "position" => 2.0,
- "ctr" => 37.0
- },
- %{
- "name" => "open-source analytics",
- "visitors" => 15,
- "impressions" => 25,
- "position" => 4.0,
- "ctr" => 50.0
- }
- ]
- } = json_response(conn, 200)
- end
-
- test "returns 200 with empty keywords list when no data returned from last 30d", %{
- conn: conn,
- site: site
- } do
- filters = Jason.encode!([[:is, "event:page", ["/empty"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=30d&filters=#{filters}")
-
- assert json_response(conn, 200) == %{"results" => []}
- end
-
- test "returns 422 with error when no data returned and queried range is too recent", %{
- conn: conn,
- site: site
- } do
- filters = Jason.encode!([[:is, "event:page", ["/empty"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day&filters=#{filters}")
-
- assert json_response(conn, 422) == %{"error_code" => "period_too_recent"}
- end
-
- test "returns 422 with error when Google account not connected (admin)", %{
- conn: conn,
- site: site
- } do
- filters = Jason.encode!([[:is, "event:page", ["/not-configured"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day&filters=#{filters}")
-
- assert %{"error_code" => "not_configured", "is_admin" => true} = json_response(conn, 422)
- end
-
- test "returns 422 with error when Google account not connected (non-admin)", %{conn: conn} do
- site = new_site(public: true)
-
- filters = Jason.encode!([[:is, "event:page", ["/not-configured"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day&filters=#{filters}")
-
- %{
- "error_code" => "not_configured",
- "is_admin" => false
- } = json_response(conn, 422)
- end
-
- test "returns 422 with error when unsupported filters used", %{conn: conn, site: site} do
- filters = Jason.encode!([[:is, "event:page", ["/unsupported-filters"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day&filters=#{filters}")
-
- assert %{"error_code" => "unsupported_filters"} = json_response(conn, 422)
- end
-
- @tag :capture_log
- test "returns 502 when Google API responds with an unexpected error", %{
- conn: conn,
- site: site
- } do
- filters = Jason.encode!([[:is, "event:page", ["/unexpected-error"]]])
-
- conn =
- get(conn, "/api/stats/#{site.domain}/google-search-terms?period=day&filters=#{filters}")
-
- assert %{"error_code" => "not_configured"} = json_response(conn, 502)
- end
- end
-
- describe "GET /api/stats/:domain/referrer-drilldown" do
- setup [:create_user, :log_in, :create_site]
-
- test "returns top referrers for a particular source", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com"
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com"
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com/page1"
- ),
- build(:pageview,
- referrer_source: "ignored",
- referrer: "ignored"
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/referrers/10words?period=day"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "10words.com", "visitors" => 2, "percentage" => 66.67},
- %{"name" => "10words.com/page1", "visitors" => 1, "percentage" => 33.33}
- ]
- end
-
- test "returns top referrers for a particular source filtered by hostname", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "example",
- referrer: "example.com",
- hostname: "two.example.com"
- ),
- build(:pageview,
- referrer_source: "example",
- referrer: "example.com",
- hostname: "two.example.com",
- user_id: @user_id
- ),
- build(:pageview,
- hostname: "one.example.com",
- user_id: @user_id
- ),
- build(:pageview,
- referrer_source: "example",
- referrer: "example.com/page1",
- hostname: "one.example.com"
- ),
- build(:pageview,
- referrer_source: "ignored",
- referrer: "ignored",
- hostname: "two.example.com"
- )
- ])
-
- filters = Jason.encode!([[:is, "event:hostname", ["one.example.com"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/referrers/example?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{"name" => "example.com/page1", "visitors" => 1, "percentage" => 100.0}
- ]
- end
-
- test "calculates bounce rate and visit duration for referrer urls", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:00:00]
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com",
- user_id: @user_id,
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com",
- timestamp: ~N[2021-01-01 00:15:00]
- ),
- build(:pageview,
- referrer_source: "ignored",
- referrer: "ignored",
- timestamp: ~N[2021-01-01 00:00:00]
- )
- ])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/referrers/10words?period=day&date=2021-01-01&detailed=true"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "10words.com",
- "visitors" => 2,
- "bounce_rate" => 50.0,
- "visit_duration" => 450,
- "percentage" => 100.0
- }
- ]
- end
-
- test "returns top referring urls for a custom goal", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com"
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com",
- user_id: @user_id
- ),
- build(:event,
- name: "Signup",
- user_id: @user_id
- ),
- build(:event,
- name: "Signup"
- )
- ])
-
- insert(:goal, site: site, event_name: "Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/referrers/10words?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "10words.com",
- "total_visitors" => 2,
- "conversion_rate" => 50.0,
- "visitors" => 1
- }
- ]
- end
-
- test "returns top referring urls for a pageview goal", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com"
- ),
- build(:pageview,
- referrer_source: "10words",
- referrer: "10words.com",
- user_id: @user_id
- ),
- build(:pageview,
- pathname: "/register",
- user_id: @user_id
- ),
- build(:pageview,
- pathname: "/register"
- )
- ])
-
- insert(:goal, site: site, page_path: "/register")
-
- filters = Jason.encode!([[:is, "event:goal", ["Visit /register"]]])
-
- conn =
- get(
- conn,
- "/api/stats/#{site.domain}/referrers/10words?period=day&filters=#{filters}"
- )
-
- assert json_response(conn, 200)["results"] == [
- %{
- "name" => "10words.com",
- "total_visitors" => 2,
- "conversion_rate" => 50.0,
- "visitors" => 1
- }
- ]
- end
- end
-end
diff --git a/test/plausible_web/controllers/stats_controller_test.exs b/test/plausible_web/controllers/stats_controller_test.exs
index ea882a6b46..38155954a9 100644
--- a/test/plausible_web/controllers/stats_controller_test.exs
+++ b/test/plausible_web/controllers/stats_controller_test.exs
@@ -439,952 +439,6 @@ defmodule PlausibleWeb.StatsControllerTest do
Application.put_env(:plausible, :super_admin_user_ids, [user.id])
end
- describe "[LEGACY] GET /:domain/export" do
- setup [:create_user, :create_site, :log_in]
-
- test "exports all the necessary CSV files", %{conn: conn, site: site} do
- conn = get(conn, "/" <> site.domain <> "/export")
-
- assert {"content-type", "application/zip; charset=utf-8"} =
- List.keyfind(conn.resp_headers, "content-type", 0)
-
- {:ok, zip} = :zip.unzip(response(conn, 200), [:memory])
-
- zip = Enum.map(zip, fn {filename, _} -> filename end)
-
- assert ~c"visitors.csv" in zip
- assert ~c"browsers.csv" in zip
- assert ~c"browser_versions.csv" in zip
- assert ~c"cities.csv" in zip
- assert ~c"conversions.csv" in zip
- assert ~c"countries.csv" in zip
- assert ~c"devices.csv" in zip
- assert ~c"entry_pages.csv" in zip
- assert ~c"exit_pages.csv" in zip
- assert ~c"operating_systems.csv" in zip
- assert ~c"operating_system_versions.csv" in zip
- assert ~c"pages.csv" in zip
- assert ~c"regions.csv" in zip
- assert ~c"sources.csv" in zip
- assert ~c"channels.csv" in zip
- assert ~c"utm_campaigns.csv" in zip
- assert ~c"utm_contents.csv" in zip
- assert ~c"utm_mediums.csv" in zip
- assert ~c"utm_sources.csv" in zip
- assert ~c"utm_terms.csv" in zip
- end
-
- test "exports scroll depth metric in pages.csv", %{conn: conn, site: site} do
- t0 = ~N[2020-01-01 00:00:00]
- [t1, t2, t3] = for i <- 1..3, do: NaiveDateTime.add(t0, i, :minute)
-
- populate_stats(site, [
- build(:pageview, user_id: 12, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 12,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 20,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 12, pathname: "/another", timestamp: t1),
- build(:engagement,
- user_id: 12,
- pathname: "/another",
- timestamp: t2,
- scroll_depth: 24,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 34,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 17,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/another", timestamp: t1),
- build(:engagement,
- user_id: 34,
- pathname: "/another",
- timestamp: t2,
- scroll_depth: 26,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 34, pathname: "/blog", timestamp: t2),
- build(:engagement,
- user_id: 34,
- pathname: "/blog",
- timestamp: t3,
- scroll_depth: 60,
- engagement_time: 60_000
- ),
- build(:pageview, user_id: 56, pathname: "/blog", timestamp: t0),
- build(:engagement,
- user_id: 56,
- pathname: "/blog",
- timestamp: t1,
- scroll_depth: 100,
- engagement_time: 60_000
- )
- ])
-
- pages =
- conn
- |> get("/#{site.domain}/export?period=day&date=2020-01-01")
- |> response(200)
- |> unzip_and_parse_csv(~c"pages.csv")
-
- assert pages == [
- ["name", "visitors", "pageviews", "bounce_rate", "time_on_page", "scroll_depth"],
- ["/blog", "3", "4", "33", "80", "60"],
- ["/another", "2", "2", "0", "60", "25"],
- [""]
- ]
- end
-
- test "exports only internally used props in custom_props.csv for a growth plan", %{
- conn: conn,
- site: site
- } do
- {:ok, site} = Plausible.Props.allow(site, ["author"])
-
- [owner | _] = Repo.preload(site, :owners).owners
- subscribe_to_growth_plan(owner)
-
- populate_stats(site, [
- build(:pageview, "meta.key": ["author"], "meta.value": ["a"]),
- build(:event, name: "File Download", "meta.key": ["url"], "meta.value": ["b"])
- ])
-
- result =
- conn
- |> get("/" <> site.domain <> "/export?period=day")
- |> response(200)
- |> unzip_and_parse_csv(~c"custom_props.csv")
-
- assert result == [
- ["property", "value", "visitors", "events", "percentage"],
- ["url", "(none)", "1", "1", "50.0"],
- ["url", "b", "1", "1", "50.0"],
- [""]
- ]
- end
-
- test "does not include custom_props.csv for a growth plan if no internal props used", %{
- conn: conn,
- site: site
- } do
- {:ok, site} = Plausible.Props.allow(site, ["author"])
-
- [owner | _] = Repo.preload(site, :owners).owners
- subscribe_to_growth_plan(owner)
-
- populate_stats(site, [
- build(:pageview, "meta.key": ["author"], "meta.value": ["a"])
- ])
-
- {:ok, zip} =
- conn
- |> get("/#{site.domain}/export?period=day")
- |> response(200)
- |> :zip.unzip([:memory])
-
- files = Map.new(zip)
-
- refute Map.has_key?(files, ~c"custom_props.csv")
- end
-
- test "exports data in zipped csvs", %{conn: conn, site: site} do
- populate_exported_stats(site)
-
- conn =
- get(conn, "/" <> site.domain <> "/export?period=custom&from=2021-09-20&to=2021-10-20")
-
- assert_zip(conn, "30d")
- end
-
- test "fails to export with interval=undefined, looking at you, spiders", %{
- conn: conn,
- site: site
- } do
- assert conn
- |> get("/" <> site.domain <> "/export?date=2021-10-20&interval=undefined")
- |> response(400)
- end
-
- test "exports allowed event props for a trial account", %{conn: conn, site: site} do
- {:ok, site} = Plausible.Props.allow(site, ["author", "logged_in"])
-
- populate_stats(site, [
- build(:pageview, "meta.key": ["author"], "meta.value": ["uku"]),
- build(:pageview, "meta.key": ["author"], "meta.value": ["uku"]),
- build(:event, "meta.key": ["author"], "meta.value": ["marko"], name: "Newsletter Signup"),
- build(:pageview, user_id: 999, "meta.key": ["logged_in"], "meta.value": ["true"]),
- build(:pageview, user_id: 999, "meta.key": ["logged_in"], "meta.value": ["true"]),
- build(:pageview, "meta.key": ["disallowed"], "meta.value": ["whatever"]),
- build(:pageview)
- ])
-
- result =
- conn
- |> get("/" <> site.domain <> "/export?period=day")
- |> response(200)
- |> unzip_and_parse_csv(~c"custom_props.csv")
-
- assert result == [
- ["property", "value", "visitors", "events", "percentage"],
- ["author", "(none)", "3", "4", "50.0"],
- ["author", "uku", "2", "2", "33.33"],
- ["author", "marko", "1", "1", "16.67"],
- ["logged_in", "(none)", "5", "5", "83.33"],
- ["logged_in", "true", "1", "2", "16.67"],
- [""]
- ]
- end
-
- test "exports data grouped by interval", %{conn: conn, site: site} do
- populate_exported_stats(site)
-
- visitors =
- conn
- |> get(
- "/" <>
- site.domain <> "/export?period=custom&from=2021-09-20&to=2021-10-20&interval=week"
- )
- |> response(200)
- |> unzip_and_parse_csv(~c"visitors.csv")
-
- assert visitors == [
- [
- "date",
- "visitors",
- "pageviews",
- "visits",
- "views_per_visit",
- "bounce_rate",
- "visit_duration"
- ],
- ["2021-09-20", "1", "1", "1", "1.0", "100", "0"],
- ["2021-09-27", "0", "0", "0", "0.0", "0.0", ""],
- ["2021-10-04", "0", "0", "0", "0.0", "0.0", ""],
- ["2021-10-11", "0", "0", "0", "0.0", "0.0", ""],
- ["2021-10-18", "3", "4", "3", "1.33", "33", "40"],
- [""]
- ]
- end
-
- test "exports operating system versions", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, operating_system: "Mac", operating_system_version: "14"),
- build(:pageview, operating_system: "Mac", operating_system_version: "14"),
- build(:pageview, operating_system: "Mac", operating_system_version: "14"),
- build(:pageview,
- operating_system: "Ubuntu",
- operating_system_version: "20.04"
- ),
- build(:pageview,
- operating_system: "Ubuntu",
- operating_system_version: "20.04"
- ),
- build(:pageview, operating_system: "Mac", operating_system_version: "13")
- ])
-
- os_versions =
- conn
- |> get("/#{site.domain}/export?period=day")
- |> response(200)
- |> unzip_and_parse_csv(~c"operating_system_versions.csv")
-
- assert os_versions == [
- ["name", "version", "visitors"],
- ["Mac", "14", "3"],
- ["Ubuntu", "20.04", "2"],
- ["Mac", "13", "1"],
- [""]
- ]
- end
-
- test "exports imported data when requested", %{conn: conn, site: site} do
- site_import = insert(:site_import, site: site)
-
- insert(:goal, site: site, event_name: "Outbound Link: Click")
-
- populate_stats(site, site_import.id, [
- build(:imported_visitors, visitors: 9),
- build(:imported_browsers, browser: "Chrome", pageviews: 1),
- build(:imported_devices, device: "Desktop", pageviews: 1),
- build(:imported_entry_pages, entry_page: "/test", pageviews: 1),
- build(:imported_exit_pages, exit_page: "/test", pageviews: 1),
- build(:imported_locations,
- country: "PL",
- region: "PL-22",
- city: 3_099_434,
- pageviews: 1
- ),
- build(:imported_operating_systems, operating_system: "Mac", pageviews: 1),
- build(:imported_pages, page: "/test", pageviews: 1),
- build(:imported_sources,
- source: "Google",
- channel: "Paid Search",
- utm_medium: "search",
- utm_campaign: "ads",
- utm_source: "google",
- utm_content: "content",
- utm_term: "term",
- pageviews: 1
- ),
- build(:imported_custom_events,
- name: "Outbound Link: Click",
- link_url: "https://example.com",
- visitors: 5,
- events: 10
- )
- ])
-
- tomorrow = Date.utc_today() |> Date.add(1) |> Date.to_iso8601()
-
- conn = get(conn, "/#{site.domain}/export?date=#{tomorrow}&with_imported=true")
-
- assert response = response(conn, 200)
- {:ok, zip} = :zip.unzip(response, [:memory])
-
- filenames = zip |> Enum.map(fn {filename, _} -> to_string(filename) end)
-
- # NOTE: currently, custom_props.csv is not populated from imported data
- expected_filenames = [
- "visitors.csv",
- "sources.csv",
- "channels.csv",
- "utm_mediums.csv",
- "utm_sources.csv",
- "utm_campaigns.csv",
- "utm_contents.csv",
- "utm_terms.csv",
- "pages.csv",
- "entry_pages.csv",
- "exit_pages.csv",
- "countries.csv",
- "regions.csv",
- "cities.csv",
- "browsers.csv",
- "browser_versions.csv",
- "operating_systems.csv",
- "operating_system_versions.csv",
- "devices.csv",
- "conversions.csv",
- "referrers.csv"
- ]
-
- Enum.each(expected_filenames, fn expected ->
- assert expected in filenames
- end)
-
- Enum.each(zip, fn
- {~c"visitors.csv", data} ->
- csv = parse_csv(data)
-
- assert List.first(csv) == [
- "date",
- "visitors",
- "pageviews",
- "visits",
- "views_per_visit",
- "bounce_rate",
- "visit_duration"
- ]
-
- assert Enum.at(csv, -2) ==
- [Date.to_iso8601(Date.utc_today()), "9", "1", "1", "1.0", "0.0", "10.0"]
-
- {~c"sources.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["Google", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"channels.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["Paid Search", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"utm_mediums.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["search", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"utm_sources.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["google", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"utm_campaigns.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["ads", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"utm_contents.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["content", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"utm_terms.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["term", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"pages.csv", data} ->
- assert parse_csv(data) == [
- [
- "name",
- "visitors",
- "pageviews",
- "bounce_rate",
- "time_on_page",
- "scroll_depth"
- ],
- ["/test", "1", "1", "0.0", "10", ""],
- [""]
- ]
-
- {~c"entry_pages.csv", data} ->
- assert parse_csv(data) == [
- [
- "name",
- "unique_entrances",
- "total_entrances",
- "bounce_rate",
- "visit_duration"
- ],
- ["/test", "1", "1", "0.0", "10.0"],
- [""]
- ]
-
- {~c"exit_pages.csv", data} ->
- assert parse_csv(data) == [
- ["name", "unique_exits", "total_exits", "exit_rate"],
- ["/test", "1", "1", "100.0"],
- [""]
- ]
-
- {~c"countries.csv", data} ->
- assert parse_csv(data) == [["name", "visitors"], ["Poland", "1"], [""]]
-
- {~c"regions.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors"],
- ["Pomerania", "1"],
- [""]
- ]
-
- {~c"cities.csv", data} ->
- assert parse_csv(data) == [["name", "visitors"], ["Gdańsk", "1"], [""]]
-
- {~c"browsers.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors"],
- ["Chrome", "1"],
- [""]
- ]
-
- {~c"browser_versions.csv", data} ->
- assert parse_csv(data) == [
- ["name", "version", "visitors"],
- ["Chrome", "(not set)", "1"],
- [""]
- ]
-
- {~c"operating_systems.csv", data} ->
- assert parse_csv(data) == [["name", "visitors"], ["Mac", "1"], [""]]
-
- {~c"operating_system_versions.csv", data} ->
- assert parse_csv(data) == [
- ["name", "version", "visitors"],
- ["Mac", "(not set)", "1"],
- [""]
- ]
-
- {~c"devices.csv", data} ->
- assert parse_csv(data) == [["name", "visitors"], ["Desktop", "1"], [""]]
-
- {~c"conversions.csv", data} ->
- assert parse_csv(data) == [
- ["name", "unique_conversions", "total_conversions"],
- ["Outbound Link: Click", "5", "10"],
- [""]
- ]
-
- {~c"referrers.csv", data} ->
- assert parse_csv(data) == [
- ["name", "visitors", "bounce_rate", "visit_duration"],
- ["Direct / None", "1", "0.0", "10.0"],
- [""]
- ]
- end)
- end
- end
-
- defp parse_csv(file_content) when is_binary(file_content) do
- file_content
- |> String.split("\r\n")
- |> Enum.map(&String.split(&1, ","))
- end
-
- describe "[LEGACY] GET /:domain/export - via shared link" do
- setup [:create_user, :create_site]
-
- test "exports data in zipped csvs", %{conn: conn, site: site} do
- link = insert(:shared_link, site: site)
-
- populate_exported_stats(site)
-
- conn =
- get(
- conn,
- "/" <>
- site.domain <> "/export?auth=#{link.slug}&period=custom&from=2021-09-20&to=2021-10-20"
- )
-
- assert_zip(conn, "30d")
- end
- end
-
- describe "[LEGACY] GET /:domain/export - for past 6 months" do
- setup [:create_user, :create_site, :log_in]
-
- test "exports 6 months of data in zipped csvs", %{conn: conn, site: site} do
- populate_exported_stats(site)
- conn = get(conn, "/" <> site.domain <> "/export?period=6mo&date=2021-11-20")
- assert_zip(conn, "6m")
- end
- end
-
- describe "[LEGACY] GET /:domain/export - with path filter" do
- setup [:create_user, :create_site, :log_in]
-
- test "exports filtered data in zipped csvs", %{conn: conn, site: site} do
- populate_exported_stats(site)
-
- filters = Jason.encode!([[:is, "event:page", ["/some-other-page"]]])
-
- conn =
- get(
- conn,
- "/#{site.domain}/export?period=custom&from=2021-09-20&to=2021-10-20&filters=#{filters}"
- )
-
- assert_zip(conn, "30d-filter-path")
- end
-
- test "exports scroll depth in visitors.csv", %{conn: conn, site: site} do
- populate_stats(site, [
- build(:pageview, user_id: 12, pathname: "/blog", timestamp: ~N[2020-01-05 00:00:00]),
- build(:engagement,
- user_id: 12,
- pathname: "/blog",
- timestamp: ~N[2020-01-05 00:01:00],
- scroll_depth: 40
- ),
- build(:pageview, user_id: 12, pathname: "/blog", timestamp: ~N[2020-01-05 10:00:00]),
- build(:engagement,
- user_id: 12,
- pathname: "/blog",
- timestamp: ~N[2020-01-05 10:01:00],
- scroll_depth: 17
- ),
- build(:pageview, user_id: 34, pathname: "/blog", timestamp: ~N[2020-01-07 00:00:00]),
- build(:engagement,
- user_id: 34,
- pathname: "/blog",
- timestamp: ~N[2020-01-07 00:01:00],
- scroll_depth: 90
- )
- ])
-
- filters = Jason.encode!([[:is, "event:page", ["/blog"]]])
-
- pages =
- conn
- |> get("/#{site.domain}/export?date=2020-01-08&period=7d&filters=#{filters}")
- |> response(200)
- |> unzip_and_parse_csv(~c"visitors.csv")
-
- assert pages == [
- [
- "date",
- "visitors",
- "pageviews",
- "visits",
- "views_per_visit",
- "bounce_rate",
- "visit_duration",
- "scroll_depth"
- ],
- ["2020-01-01", "0", "0", "0", "0.0", "0.0", "", ""],
- ["2020-01-02", "0", "0", "0", "0.0", "0.0", "", ""],
- ["2020-01-03", "0", "0", "0", "0.0", "0.0", "", ""],
- ["2020-01-04", "0", "0", "0", "0.0", "0.0", "", ""],
- ["2020-01-05", "1", "2", "2", "1.0", "100", "0", "28"],
- ["2020-01-06", "0", "0", "0", "0.0", "0.0", "", ""],
- ["2020-01-07", "1", "1", "1", "1.0", "100", "0", "90"],
- [""]
- ]
- end
- end
-
- describe "[LEGACY] GET /:domain/export - with a custom prop filter" do
- setup [:create_user, :create_site, :log_in]
-
- test "custom-props.csv only returns the prop and its value in filter", %{
- conn: conn,
- site: site
- } do
- {:ok, site} = Plausible.Props.allow(site, ["author", "logged_in"])
-
- populate_stats(site, [
- build(:pageview, "meta.key": ["author"], "meta.value": ["uku"]),
- build(:pageview, "meta.key": ["author"], "meta.value": ["marko"]),
- build(:pageview, "meta.key": ["logged_in"], "meta.value": ["true"])
- ])
-
- filters = Jason.encode!([[:is, "event:props:author", ["marko"]]])
-
- result =
- conn
- |> get("/" <> site.domain <> "/export?period=day&filters=#{filters}")
- |> response(200)
- |> unzip_and_parse_csv(~c"custom_props.csv")
-
- assert result == [
- ["property", "value", "visitors", "events", "percentage"],
- ["author", "marko", "1", "1", "100.0"],
- [""]
- ]
- end
- end
-
- defp unzip_and_parse_csv(archive, filename) do
- {:ok, zip} = :zip.unzip(archive, [:memory])
- {_filename, data} = Enum.find(zip, &(elem(&1, 0) == filename))
- parse_csv(data)
- end
-
- defp assert_zip(conn, folder) do
- assert conn.status == 200
-
- assert {"content-type", "application/zip; charset=utf-8"} =
- List.keyfind(conn.resp_headers, "content-type", 0)
-
- {:ok, zip} = :zip.unzip(response(conn, 200), [:memory])
-
- folder = Path.expand(folder, "test/plausible_web/controllers/CSVs")
-
- Enum.map(zip, &assert_csv_by_fixture(&1, folder))
- end
-
- defp assert_csv_by_fixture({file, downloaded}, folder) do
- file =
- file
- |> maybe_get_legacy_variant(folder)
- |> Path.expand(folder)
-
- {:ok, content} = File.read(file)
- msg = "CSV file comparison failed (#{file})"
- assert downloaded == content, message: msg, left: downloaded, right: content
- end
-
- # Remember to clean up the legacy fixture files too once the
- # legacy CSV export disappears.
- defp maybe_get_legacy_variant(filename, folder) do
- path_filter? = String.contains?(folder, "filter-path")
-
- case {filename, path_filter?} do
- {~c"exit_pages.csv", true} -> ~c"exit_pages_legacy.csv"
- {~c"visitors.csv", true} -> ~c"visitors_legacy.csv"
- {filename, _} -> filename
- end
- end
-
- defp populate_exported_stats(site) do
- populate_stats(site, [
- build(:pageview,
- user_id: 123,
- pathname: "/",
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], minute: -1)
- |> NaiveDateTime.truncate(:second),
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409,
- referrer_source: "Google"
- ),
- build(:engagement,
- user_id: 123,
- pathname: "/",
- timestamp: ~N[2021-10-20 12:00:00] |> NaiveDateTime.truncate(:second),
- engagement_time: 30_000,
- scroll_depth: 30,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409,
- referrer_source: "Google"
- ),
- build(:pageview,
- user_id: 123,
- pathname: "/some-other-page",
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], minute: -2)
- |> NaiveDateTime.truncate(:second),
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409,
- referrer_source: "Google"
- ),
- build(:engagement,
- user_id: 123,
- pathname: "/some-other-page",
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], minute: -1)
- |> NaiveDateTime.truncate(:second),
- engagement_time: 60_000,
- scroll_depth: 30,
- country_code: "EE",
- subdivision1_code: "EE-37",
- city_geoname_id: 588_409,
- referrer_source: "Google"
- ),
- build(:pageview,
- user_id: 100,
- pathname: "/",
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], day: -1) |> NaiveDateTime.truncate(:second),
- utm_medium: "search",
- utm_campaign: "ads",
- utm_source: "google",
- utm_content: "content",
- utm_term: "term",
- browser: "Firefox",
- browser_version: "120",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:engagement,
- user_id: 100,
- pathname: "/",
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], day: -1, minute: 1)
- |> NaiveDateTime.truncate(:second),
- engagement_time: 30_000,
- scroll_depth: 30,
- utm_medium: "search",
- utm_campaign: "ads",
- utm_source: "google",
- utm_content: "content",
- utm_term: "term",
- browser: "Firefox",
- browser_version: "120",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:pageview,
- user_id: 200,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], month: -1)
- |> NaiveDateTime.truncate(:second),
- country_code: "EE",
- browser: "Firefox",
- browser_version: "120",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:engagement,
- user_id: 200,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], month: -1, minute: 1)
- |> NaiveDateTime.truncate(:second),
- engagement_time: 30_000,
- scroll_depth: 20,
- country_code: "EE",
- browser: "Firefox",
- browser_version: "120",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:pageview,
- user_id: 300,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], month: -5)
- |> NaiveDateTime.truncate(:second),
- utm_campaign: "ads",
- country_code: "EE",
- referrer_source: "Google",
- click_id_param: "gclid",
- browser: "FirefoxNoVersion",
- operating_system: "MacNoVersion"
- ),
- build(:engagement,
- user_id: 300,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], month: -5, minute: 1)
- |> NaiveDateTime.truncate(:second),
- engagement_time: 30_000,
- scroll_depth: 20,
- utm_campaign: "ads",
- country_code: "EE",
- referrer_source: "Google",
- click_id_param: "gclid",
- browser: "FirefoxNoVersion",
- operating_system: "MacNoVersion"
- ),
- build(:pageview,
- user_id: 456,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], day: -1, minute: -1)
- |> NaiveDateTime.truncate(:second),
- pathname: "/signup",
- "meta.key": ["variant"],
- "meta.value": ["A"]
- ),
- build(:engagement,
- user_id: 456,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], day: -1) |> NaiveDateTime.truncate(:second),
- pathname: "/signup",
- engagement_time: 60_000,
- scroll_depth: 20,
- "meta.key": ["variant"],
- "meta.value": ["A"]
- ),
- build(:event,
- user_id: 456,
- timestamp:
- NaiveDateTime.shift(~N[2021-10-20 12:00:00], day: -1) |> NaiveDateTime.truncate(:second),
- name: "Signup",
- "meta.key": ["variant"],
- "meta.value": ["A"]
- )
- ])
-
- insert(:goal, %{site: site, event_name: "Signup"})
- end
-
- describe "[LEGACY] GET /:domain/export - with goal filter" do
- setup [:create_user, :create_site, :log_in]
-
- test "exports goal-filtered data in zipped csvs", %{conn: conn, site: site} do
- populate_exported_stats(site)
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- conn =
- get(
- conn,
- "/#{site.domain}/export?period=custom&from=2021-09-20&to=2021-10-20&filters=#{filters}"
- )
-
- assert_zip(conn, "30d-filter-goal")
- end
-
- test "custom-props.csv only returns the prop names for the goal in filter", %{
- conn: conn,
- site: site
- } do
- {:ok, site} = Plausible.Props.allow(site, ["author", "logged_in"])
-
- populate_stats(site, [
- build(:event, name: "Newsletter Signup", "meta.key": ["author"], "meta.value": ["uku"]),
- build(:event, name: "Newsletter Signup", "meta.key": ["author"], "meta.value": ["marko"]),
- build(:event, name: "Newsletter Signup", "meta.key": ["author"], "meta.value": ["marko"]),
- build(:pageview, "meta.key": ["logged_in"], "meta.value": ["true"])
- ])
-
- insert(:goal, site: site, event_name: "Newsletter Signup")
- filters = Jason.encode!([[:is, "event:goal", ["Newsletter Signup"]]])
-
- result =
- conn
- |> get("/" <> site.domain <> "/export?period=day&filters=#{filters}")
- |> response(200)
- |> unzip_and_parse_csv(~c"custom_props.csv")
-
- assert result == [
- ["property", "value", "visitors", "events", "conversion_rate"],
- ["author", "marko", "2", "2", "50.0"],
- ["author", "uku", "1", "1", "25.0"],
- [""]
- ]
- end
-
- test "exports conversions and conversion rate for operating system versions", %{
- conn: conn,
- site: site
- } do
- populate_stats(site, [
- build(:pageview, operating_system: "Mac", operating_system_version: "14"),
- build(:event,
- name: "Signup",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:event,
- name: "Signup",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:event,
- name: "Signup",
- operating_system: "Mac",
- operating_system_version: "14"
- ),
- build(:event,
- name: "Signup",
- operating_system: "Ubuntu",
- operating_system_version: "20.04"
- ),
- build(:event,
- name: "Signup",
- operating_system: "Ubuntu",
- operating_system_version: "20.04"
- ),
- build(:event,
- name: "Signup",
- operating_system: "Lubuntu",
- operating_system_version: "20.04"
- )
- ])
-
- insert(:goal, site: site, event_name: "Signup")
-
- filters = Jason.encode!([[:is, "event:goal", ["Signup"]]])
-
- os_versions =
- conn
- |> get("/#{site.domain}/export?period=day&filters=#{filters}")
- |> response(200)
- |> unzip_and_parse_csv(~c"operating_system_versions.csv")
-
- assert os_versions == [
- ["name", "version", "conversions", "conversion_rate"],
- ["Mac", "14", "3", "75.0"],
- ["Ubuntu", "20.04", "2", "100.0"],
- ["Lubuntu", "20.04", "1", "100.0"],
- [""]
- ]
- end
- end
-
describe "GET /share/:domain?auth=:auth" do
test "prompts a password for a password-protected link", %{conn: conn} do
site = new_site()
diff --git a/test/support/dev/controllers/e2e_controller.ex b/test/support/dev/controllers/e2e_controller.ex
index 90972b1194..bd61fdfbf2 100644
--- a/test/support/dev/controllers/e2e_controller.ex
+++ b/test/support/dev/controllers/e2e_controller.ex
@@ -96,11 +96,6 @@ defmodule PlausibleWeb.E2EController do
send_resp(conn, 200, Jason.encode!(%{"ok" => true}))
end
- def enable_dashboard_csv_export_v2(conn, %{"domain" => domain}) do
- FunWithFlags.enable(:dashboard_csv_export_v2, for_actor: "site:#{domain}")
- send_resp(conn, 200, Jason.encode!(%{"ok" => true}))
- end
-
defp get_goal(site, name) do
Plausible.Repo.get_by!(Plausible.Goal, site_id: site.id, display_name: name)
end