:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import { DateTime } from 'luxon'
import { closeHub, createHub } from '~/common/utils/db/hub'
import { createTestTeamFixture, insertRow } from '../../../tests/helpers/sql'
import {
Action,
ActionStep,
Element,
Hub,
ISOTimestamp,
PostIngestionEvent,
PropertyOperator,
RawAction,
StringMatching,
} from '../../types'
import { ActionManager } from './action-manager'
import { ActionMatcher, castingCompare } from './action-matcher'
jest.mock('~/common/utils/logger')
/** Return a test event created on a common base using provided property overrides. */
function createTestEvent(overrides: Partial<PostIngestionEvent> = {}): PostIngestionEvent {
const url: string = overrides.properties?.$current_url ?? 'http://example.com/foo/'
// @ts-expect-error TODO: Fix underlying types
return {
eventUuid: 'uuid1',
distinctId: 'my_id',
teamId: testTeamId,
timestamp: new Date().toISOString() as ISOTimestamp,
event: '$pageview',
properties: { $current_url: url },
elementsList: [],
person_id: 'F99FA0A1-E0C2-4CFE-A09A-4C3C4327A4C8',
person_created_at: DateTime.fromSeconds(18000000).toISO() as ISOTimestamp,
person_properties: {},
...overrides,
}
}
let testTeamId: number
describe('ActionMatcher', () => {
let hub: Hub
let actionManager: ActionManager
let actionMatcher: ActionMatcher
let actionCounter: number
let teamId: number
beforeEach(async () => {
hub = await createHub()
teamId = (await createTestTeamFixture(hub.postgres)).team.id
testTeamId = teamId
actionManager = new ActionManager(hub.postgres, hub.pubSub)
await actionManager.start()
actionMatcher = new ActionMatcher(actionManager)
actionCounter = teamId
})
afterEach(async () => {
await closeHub(hub)
})
/** Return a test action created on a common base using provided steps. */
async function createTestAction(partialSteps: Partial<ActionStep>[] | null): Promise<Action> {
const action: RawAction = {
id: actionCounter++,
team_id: teamId,
name: 'Test',
description: '',
created_at: new Date().toISOString(),
created_by_id: null,
deleted: false,
post_to_slack: true,
slack_message_format: '',
is_calculating: false,
updated_at: new Date().toISOString(),
last_calculated_at: new Date().toISOString(),
steps_json: partialSteps
? partialSteps.map(
(partialStep): ActionStep => ({
tag_name: null,
text: null,
text_matching: null,
href: null,
href_matching: null,
selector: null,
url: null,
url_matching: null,
event: null,
properties: null,
...partialStep,
})
)
: null,
}
await insertRow(hub.postgres, 'posthog_action', action)
await actionManager.reloadAction(action.team_id, action.id)
return {
...action,
steps: action.steps_json ?? [],
hooks: [],
}
}
describe('#match()', () => {
it('returns no match if action has no steps', async () => {
await createTestAction(null)
const event = createTestEvent()
expect(actionMatcher.match(event)).toEqual([])
})
it('returns a match in case of event property operator exact', async () => {
const actionDefinitionOpExact: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: 'bar', operator: 'exact' as PropertyOperator }],
},
])
const actionDefinitionOpUndefined: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: 'bar' }], // undefined operator should mean "exact"
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpExact, actionDefinitionOpUndefined])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([
actionDefinitionOpExact,
actionDefinitionOpUndefined,
])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumber)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of event property operator is not', async () => {
const actionDefinitionOpIsNot: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: 'bar', operator: 'is_not' as PropertyOperator }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooBaz)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooBarabara)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooNumber)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventNoNothing)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFigNumber)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooTrue)).toEqual([actionDefinitionOpIsNot])
expect(actionMatcher.match(eventFooNull)).toEqual([actionDefinitionOpIsNot])
})
it('returns a match in case of event property operator contains', async () => {
const actionDefinitionOpContains: Action = await createTestAction([
{
properties: [
{ type: 'event', key: 'foo', value: 'bar', operator: 'icontains' as PropertyOperator },
],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpContains])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([actionDefinitionOpContains])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpContains])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([actionDefinitionOpContains])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpContains])
expect(actionMatcher.match(eventFooNumber)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of event property operator does not contain', async () => {
const actionDefinitionOpNotContains: Action = await createTestAction([
{
properties: [
{ type: 'event', key: 'foo', value: 'bar', operator: 'not_icontains' as PropertyOperator },
],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([actionDefinitionOpNotContains])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumber)).toEqual([actionDefinitionOpNotContains])
expect(actionMatcher.match(eventNoNothing)).toEqual([actionDefinitionOpNotContains])
expect(actionMatcher.match(eventFigNumber)).toEqual([actionDefinitionOpNotContains])
expect(actionMatcher.match(eventFooTrue)).toEqual([actionDefinitionOpNotContains])
expect(actionMatcher.match(eventFooNull)).toEqual([actionDefinitionOpNotContains])
})
it('returns a match in case of event property operator regex', async () => {
const actionDefinitionOpRegex1: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: '^bar', operator: 'regex' as PropertyOperator }],
},
])
const actionDefinitionOpRegex2: Action = await createTestAction([
{
properties: [
{ type: 'event', key: 'foo', value: '(?:.+bar|[A-Z])', operator: 'regex' as PropertyOperator },
],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpRegex1])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([actionDefinitionOpRegex1])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpRegex2])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([actionDefinitionOpRegex1, actionDefinitionOpRegex2])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpRegex2])
expect(actionMatcher.match(eventFooNumber)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of event property operator not regex', async () => {
const actionDefinitionOpNotRegex1: Action = await createTestAction([
{
properties: [
{ type: 'event', key: 'foo', value: '^bar', operator: 'not_regex' as PropertyOperator },
],
},
])
const actionDefinitionOpNotRegex2: Action = await createTestAction([
{
properties: [
{
type: 'event',
key: 'foo',
value: '(?:.+bar|[A-Z])',
operator: 'not_regex' as PropertyOperator,
},
],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpNotRegex2])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([actionDefinitionOpNotRegex2])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpNotRegex1])
expect(actionMatcher.match(eventFooBaz)).toEqual([actionDefinitionOpNotRegex1, actionDefinitionOpNotRegex2])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpNotRegex1])
expect(actionMatcher.match(eventFooNumber)).toEqual([
actionDefinitionOpNotRegex1,
actionDefinitionOpNotRegex2,
])
expect(actionMatcher.match(eventNoNothing)).toEqual([
actionDefinitionOpNotRegex1,
actionDefinitionOpNotRegex2,
])
expect(actionMatcher.match(eventFigNumber)).toEqual([
actionDefinitionOpNotRegex1,
actionDefinitionOpNotRegex2,
])
expect(actionMatcher.match(eventFooTrue)).toEqual([
actionDefinitionOpNotRegex1,
actionDefinitionOpNotRegex2,
])
expect(actionMatcher.match(eventFooNull)).toEqual([
actionDefinitionOpNotRegex1,
actionDefinitionOpNotRegex2,
])
})
it('returns a match in case of event property operator is set', async () => {
const actionDefinitionOpIsSet: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', operator: 'is_set' as PropertyOperator }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBaz)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBarabara)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooNumber)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooNull)).toEqual([actionDefinitionOpIsSet])
})
it('returns a match in case of event property operator is not set', async () => {
const actionDefinitionOpIsNotSet: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', operator: 'is_not_set' as PropertyOperator }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumber)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([actionDefinitionOpIsNotSet])
expect(actionMatcher.match(eventFigNumber)).toEqual([actionDefinitionOpIsNotSet])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of event property operator greater than', async () => {
const actionDefinitionOpGreaterThan: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: 5, operator: 'gt' as PropertyOperator }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumberMinusOne = createTestEvent({ properties: { foo: -1 } })
const eventFooNumberFive = createTestEvent({ properties: { foo: 5 } })
const eventFooNumberSevenNines = createTestEvent({ properties: { foo: 9999999 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumberMinusOne)).toEqual([])
expect(actionMatcher.match(eventFooNumberFive)).toEqual([])
expect(actionMatcher.match(eventFooNumberSevenNines)).toEqual([actionDefinitionOpGreaterThan])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of event property operator less than', async () => {
const actionDefinitionOpLessThan: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: 5, operator: 'lt' as PropertyOperator }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: 'bar', pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooBarabara = createTestEvent({ properties: { foo: 'barabara' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumberMinusOne = createTestEvent({ properties: { foo: -1 } })
const eventFooNumberFive = createTestEvent({ properties: { foo: 5 } })
const eventFooNumberSevenNines = createTestEvent({ properties: { foo: 9999999 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooBarabara)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumberMinusOne)).toEqual([actionDefinitionOpLessThan])
expect(actionMatcher.match(eventFooNumberFive)).toEqual([])
expect(actionMatcher.match(eventFooNumberSevenNines)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([actionDefinitionOpLessThan]) // true is a 1
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('returns a match in case of URL contains page view', async () => {
const actionDefinition: Action = await createTestAction([
{
url: 'example.com',
url_matching: StringMatching.Contains,
event: '$pageview',
},
])
const actionDefinitionEmptyMatching: Action = await createTestAction([
{
url: 'example.com',
url_matching: '' as StringMatching, // Empty url_matching should mean "contains"
event: '$pageview',
},
])
const eventPosthog = createTestEvent({
properties: { $current_url: 'http://posthog.com/pricing' },
})
const eventExample = createTestEvent({
properties: { $current_url: 'https://example.com/' },
})
expect(actionMatcher.match(eventPosthog)).toEqual([])
expect(actionMatcher.match(eventExample)).toEqual([actionDefinition, actionDefinitionEmptyMatching])
})
it('returns a match in case of URL contains page views with % and _', async () => {
const actionDefinition: Action = await createTestAction([
{
url: 'exampl_.com/%.html',
url_matching: StringMatching.Contains,
event: '$pageview',
},
])
const actionDefinitionEmptyMatching: Action = await createTestAction([
{
url: 'exampl_.com/%.html',
url_matching: '' as StringMatching, // Empty url_matching should mean "contains"
event: '$pageview',
},
])
const eventExample = createTestEvent({
properties: { $current_url: 'https://example.com/' },
})
const eventExampleHtml = createTestEvent({
properties: { $current_url: 'https://example.com/index.html' },
})
expect(actionMatcher.match(eventExample)).toEqual([])
expect(actionMatcher.match(eventExampleHtml)).toEqual([actionDefinition, actionDefinitionEmptyMatching])
})
it('returns a match in case of URL matches regex page views', async () => {
const actionDefinition: Action = await createTestAction([
{
url: String.raw`^https?:\/\/example\.com\/\d+(\/[a-r]*\/?)?$`,
url_matching: StringMatching.Regex,
event: '$pageview',
},
])
const eventExampleOk1 = createTestEvent({
properties: { $current_url: 'https://example.com/23/hello' },
})
const eventExampleOk2 = createTestEvent({
properties: { $current_url: 'https://example.com/3/abc/' },
})
const eventExampleBad1 = createTestEvent({
properties: { $current_url: 'https://example.com/3/xyz/' },
})
const eventExampleBad2 = createTestEvent({
properties: { $current_url: 'https://example.com/' },
})
const eventExampleBad3 = createTestEvent({
properties: { $current_url: 'https://example.com/uno/dos/' },
})
const eventExampleBad4 = createTestEvent({
properties: { $current_url: 'https://example.com/1foo/' },
})
expect(actionMatcher.match(eventExampleOk1)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleOk2)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleBad1)).toEqual([])
expect(actionMatcher.match(eventExampleBad2)).toEqual([])
expect(actionMatcher.match(eventExampleBad3)).toEqual([])
expect(actionMatcher.match(eventExampleBad4)).toEqual([])
})
it('returns a match in case of URL matches exactly page views', async () => {
const actionDefinition: Action = await createTestAction([
{
url: 'https://www.mozilla.org/de/',
url_matching: StringMatching.Exact,
event: '$pageview',
},
])
const eventExampleOk = createTestEvent({
properties: { $current_url: 'https://www.mozilla.org/de/' },
})
const eventExampleBad1 = createTestEvent({
properties: { $current_url: 'https://www.mozilla.org/de' },
})
const eventExampleBad2 = createTestEvent({
properties: { $current_url: 'https://www.mozilla.org/de/firefox/' },
})
expect(actionMatcher.match(eventExampleOk)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleBad1)).toEqual([])
expect(actionMatcher.match(eventExampleBad2)).toEqual([])
})
it('returns a match in case of exact event name', async () => {
const actionDefinition: Action = await createTestAction([
{
event: 'meow',
},
])
const eventExampleOk = createTestEvent({
event: 'meow',
})
const eventExampleBad1 = createTestEvent({
event: '$meow',
})
const eventExampleBad2 = createTestEvent({
event: 'WOOF',
})
expect(actionMatcher.match(eventExampleOk)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleBad1)).toEqual([])
expect(actionMatcher.match(eventExampleBad2)).toEqual([])
})
it('returns a match in case of exact event name AND URL contains', async () => {
const actionDefinition: Action = await createTestAction([
{
event: 'meow',
url_matching: StringMatching.Contains,
url: 'pets.com/',
},
])
const eventExampleOk1 = createTestEvent({
event: 'meow',
properties: { $current_url: 'http://www.pets.com/' },
})
const eventExampleOk2 = createTestEvent({
event: 'meow',
properties: { $current_url: 'https://pets.com/food' },
})
const eventExampleBad1 = createTestEvent({
event: '$meow',
properties: { $current_url: 'https://xyz.pets.com/' },
})
const eventExampleBad2 = createTestEvent({
event: 'meow',
properties: { $current_url: 'https://www.pets.com.de/' },
})
const eventExampleBad3 = createTestEvent({
event: 'meow',
properties: { $current_url: 'https://www.pets.co' },
})
expect(actionMatcher.match(eventExampleOk1)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleOk2)).toEqual([actionDefinition])
expect(actionMatcher.match(eventExampleBad1)).toEqual([])
expect(actionMatcher.match(eventExampleBad2)).toEqual([])
expect(actionMatcher.match(eventExampleBad3)).toEqual([])
})
it('returns a match in case of person property operator exact', async () => {
const actionDefinitionOpExact: Action = await createTestAction([
{
properties: [{ type: 'person', key: 'foo', value: 'bar', operator: 'exact' as PropertyOperator }],
},
])
const actionDefinitionOpUndefined: Action = await createTestAction([
{
properties: [{ type: 'person', key: 'foo', value: 'bar' }], // undefined operator should mean "exact"
},
])
const event = createTestEvent()
expect(actionMatcher.match({ ...event, person_properties: { foo: 'bar' } })).toEqual([
actionDefinitionOpExact,
actionDefinitionOpUndefined,
])
expect(actionMatcher.match({ ...event, person_properties: { foo: 'bar', pol: 'pot' } })).toEqual([
actionDefinitionOpExact,
actionDefinitionOpUndefined,
])
expect(actionMatcher.match({ ...event, person_properties: { foo: 'baR' } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: 'baz' } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: 'barabara' } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: 'rabarbar' } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: 7 } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: {} })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { something_else: 999 } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: true } })).toEqual([])
expect(actionMatcher.match({ ...event, person_properties: { foo: null } })).toEqual([])
})
it('returns a match in case of element href equals', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
href: 'https://example.com/',
},
])
const event = createTestEvent()
const elementsHrefOuter: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefInner: Element[] = [
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsNoHref: Element[] = [
{ tag_name: 'span' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsHrefOuter })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefInner })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsNoHref })).toEqual([])
})
it('returns a match in case of element href contains', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
href: 'https://example.com/',
href_matching: StringMatching.Contains,
},
])
const event = createTestEvent()
const elementsExactHrefOuter: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsExactHrefInner: Element[] = [
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsExtendedHref: Element[] = [
{ tag_name: 'a', href: 'https://example.com/foobar' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsBadHref: Element[] = [
{ tag_name: 'a', href: 'https://example.io/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsNoHref: Element[] = [
{ tag_name: 'span' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefOuter })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefInner })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsExtendedHref })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsBadHref })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsNoHref })).toEqual([])
})
it('returns a match in case of element href contains, with wildcard', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
href: 'https://example.com/%bar',
href_matching: StringMatching.Contains,
},
])
const event = createTestEvent()
const elementsExactHrefOuter: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsExactHrefInner: Element[] = [
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsExtendedHref: Element[] = [
{ tag_name: 'a', href: 'https://example.com/foobar' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsBadHref: Element[] = [
{ tag_name: 'a', href: 'https://example.io/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsNoHref: Element[] = [
{ tag_name: 'span' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefOuter })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefInner })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsExtendedHref })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsBadHref })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsNoHref })).toEqual([])
})
it('returns a match in case of element href matches regex', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
href: 'https://example.com/.*(?:bar|baz)',
href_matching: StringMatching.Regex,
},
])
const event = createTestEvent()
const elementsExactHrefOuter: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsExactHrefInner: Element[] = [
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsExtendedHref: Element[] = [
{ tag_name: 'a', href: 'https://example.com/foobar' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsBadHref: Element[] = [
{ tag_name: 'a', href: 'https://example.io/' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
const elementsNoHref: Element[] = [
{ tag_name: 'span' },
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefOuter })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsExactHrefInner })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsExtendedHref })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsBadHref })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsNoHref })).toEqual([])
})
it('returns a match in case of element text and tag name equals', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
tag_name: 'h1',
text: 'Hallo!',
},
])
const event = createTestEvent()
const elementsHrefProper: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'], text: 'Hallo!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefWrongTag: Element[] = [
{ tag_name: 'h3', attr_class: ['headline'], text: 'Hallo!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefWrongText: Element[] = [
{ tag_name: 'h3', attr_class: ['headline'], text: 'Auf Wiedersehen!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefWrongLevel: Element[] = [
{ tag_name: 'i', attr_class: ['headline'], text: 'Auf Wiedersehen!' },
{ tag_name: 'h1' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsHrefProper })).toEqual([
actionDefinitionLinkHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefWrongTag })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefWrongText })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefWrongLevel })).toEqual([])
})
it('returns a match in case of element text contains', async () => {
const actionDefinitionLinkHref: Action = await createTestAction([
{
text: 'Wieder',
text_matching: StringMatching.Contains,
},
])
const event = createTestEvent()
const elementsHrefBadText: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'], text: 'Hallo!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefGoodText: Element[] = [
{ tag_name: 'h3', attr_class: ['headline'], text: 'Auf Wiedersehen!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsHrefBadText })).toEqual([])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefGoodText })).toEqual([
actionDefinitionLinkHref,
])
})
it('returns a match in case of element selector', async () => {
const actionDefinitionAnyDescendant: Action = await createTestAction([
{
selector: 'main h1.headline',
},
])
const actionDefinitionDirectDescendant: Action = await createTestAction([
{
selector: 'main > h1.headline',
},
])
const actionDefinitionDirectHref: Action = await createTestAction([
{
selector: 'main > a[href="https://example.com/"]',
},
])
const actionDefinitionArraySelectorProp: Action = await createTestAction([
{
properties: [{ type: 'element', key: 'selector', value: ['main h1.headline'] }],
},
])
const event = createTestEvent()
const elementsHrefProperNondirect: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'], text: 'Hallo!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefWrongClassNondirect: Element[] = [
{ tag_name: 'h1', attr_class: ['oof'], text: 'Hallo!' },
{ tag_name: 'a', href: 'https://example.com/' },
{ tag_name: 'main' },
]
const elementsHrefProperDirect: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'], text: 'Hallo!' },
{ tag_name: 'main' },
]
expect(actionMatcher.match({ ...event, elementsList: elementsHrefProperNondirect })).toEqual([
actionDefinitionAnyDescendant,
actionDefinitionDirectHref,
actionDefinitionArraySelectorProp,
])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefWrongClassNondirect })).toEqual([
actionDefinitionDirectHref,
])
expect(actionMatcher.match({ ...event, elementsList: elementsHrefProperDirect })).toEqual([
actionDefinitionAnyDescendant,
actionDefinitionDirectDescendant,
actionDefinitionArraySelectorProp,
])
})
it('returns a match using filter value casting, with multiple match groups', async () => {
const actionDefinition: Action = await createTestAction([
{ event: 'tenet' },
{
properties: [
{ key: 'insight', type: 'event', value: ['STICKINESS'], operator: PropertyOperator.Exact },
{
key: 'total_event_action_filters_count',
type: 'event',
value: '0',
operator: PropertyOperator.Exact,
},
{
key: 'total_event_actions_count',
type: 'event',
value: '0',
operator: PropertyOperator.GreaterThan,
},
],
},
])
const eventExampleOk1 = createTestEvent({
event: 'meow',
properties: {
insight: 'STICKINESS',
total_event_action_filters_count: 0,
total_event_actions_count: 4,
},
})
expect(actionMatcher.match(eventExampleOk1)).toEqual([actionDefinition])
})
it('properly handles is_not null string coercion', async () => {
const actionDefinitionOpIsSet: Action = await createTestAction([
{
properties: [
{ type: 'event', key: 'foo', operator: 'is_set' as PropertyOperator },
{ type: 'event', key: 'foo', value: ['null'], operator: 'is_not' as PropertyOperator },
],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: null, pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([])
expect(actionMatcher.match(eventFooBaR)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBaz)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooNumber)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooNull)).toEqual([])
})
it('properly handles exact null string coercion', async () => {
const actionDefinitionOpIsSet: Action = await createTestAction([
{
properties: [{ type: 'event', key: 'foo', value: ['null'] }],
},
])
const eventFooBar = createTestEvent({ properties: { foo: 'bar' } })
const eventFooBarPolPot = createTestEvent({ properties: { foo: null, pol: 'pot' } })
const eventFooBaR = createTestEvent({ properties: { foo: 'baR' } })
const eventFooBaz = createTestEvent({ properties: { foo: 'baz' } })
const eventFooRabarbar = createTestEvent({ properties: { foo: 'rabarbar' } })
const eventFooNumber = createTestEvent({ properties: { foo: 7 } })
const eventNoNothing = createTestEvent()
const eventFigNumber = createTestEvent({ properties: { fig: 999 } })
const eventFooTrue = createTestEvent({ properties: { foo: true } })
const eventFooNull = createTestEvent({ properties: { foo: null } })
expect(actionMatcher.match(eventFooBar)).toEqual([])
expect(actionMatcher.match(eventFooBarPolPot)).toEqual([actionDefinitionOpIsSet])
expect(actionMatcher.match(eventFooBaR)).toEqual([])
expect(actionMatcher.match(eventFooBaz)).toEqual([])
expect(actionMatcher.match(eventFooRabarbar)).toEqual([])
expect(actionMatcher.match(eventFooNumber)).toEqual([])
expect(actionMatcher.match(eventNoNothing)).toEqual([])
expect(actionMatcher.match(eventFigNumber)).toEqual([])
expect(actionMatcher.match(eventFooTrue)).toEqual([])
expect(actionMatcher.match(eventFooNull)).toEqual([actionDefinitionOpIsSet])
})
})
describe('#checkElementsAgainstSelector()', () => {
const checkElementsAgainstSelector = (elements: Element[], selector: string): boolean => {
return actionMatcher.checkElementsAgainstSelector(
{ elementsList: elements } as PostIngestionEvent,
selector
)
}
it('handles selector with attribute', () => {
const elements: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'], attributes: { 'attr__data-attr': 'xyz' } },
{ tag_name: 'div', attr_class: ['top'] },
{ tag_name: 'div' },
{ tag_name: 'main' },
]
expect(checkElementsAgainstSelector(elements, "[data-attr='xyz']")).toBeTruthy()
expect(checkElementsAgainstSelector(elements, "h1[data-attr='xyz']")).toBeTruthy()
expect(checkElementsAgainstSelector(elements, ".headline[data-attr='xyz']")).toBeTruthy()
expect(checkElementsAgainstSelector(elements, "main [data-attr='xyz']")).toBeTruthy()
expect(checkElementsAgainstSelector(elements, ".top [data-attr='xyz']")).toBeTruthy()
expect(checkElementsAgainstSelector(elements, "[data-attr='foo']")).toBeFalsy()
expect(checkElementsAgainstSelector(elements, "[data-attr='foo'][data-attr='xyz']")).toBeFalsy()
expect(checkElementsAgainstSelector(elements, "main[data-attr='xyz']")).toBeFalsy()
expect(checkElementsAgainstSelector(elements, "div[data-attr='xyz']")).toBeFalsy()
expect(checkElementsAgainstSelector(elements, "div[data-attr='xyz']")).toBeFalsy()
})
it('handles any descendant selector', () => {
const elements: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'div', attr_class: ['top'] },
{ tag_name: 'main' },
]
expect(checkElementsAgainstSelector(elements, 'main h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'main .headline')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'h1 div')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, '.top main')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main div')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'main .top')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'div h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'div .headline')).toBeTruthy()
})
it('handles direct descendant selector', () => {
const elements: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'div', attr_class: ['top'] },
{ tag_name: 'main' },
]
expect(checkElementsAgainstSelector(elements, 'main > h1')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > .headline')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > .top > h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'h1 > div')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, '.top > main')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > div')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'main > .top')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'div > h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'div > .headline')).toBeTruthy()
})
it('handles direct descendant selector edge cases 1', () => {
const elements: Element[] = [
{ tag_name: 'h1', attr_class: ['headline'] },
{ tag_name: 'div', attr_class: ['inner'] },
{ tag_name: 'div', attr_class: ['outer'] },
{ tag_name: 'main' },
]
expect(checkElementsAgainstSelector(elements, 'main > h1')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > .inner')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > .outer > .inner > h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'main > .inner > h1')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > .outer > h1')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'h1 > div')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'outer > main')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'main > div')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'main > .outer')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'div > h1')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, '.inner > .headline')).toBeTruthy()
})
it('handles direct descendant selector edge cases 2', () => {
const elements: Element[] = [
{ tag_name: 'span' },
{ tag_name: 'div' },
{ tag_name: 'a' },
{ tag_name: 'div' },
{ tag_name: 'div' },
{ tag_name: 'aside' },
{ tag_name: 'section' },
]
expect(checkElementsAgainstSelector(elements, 'aside div > span')).toBeTruthy()
})
it('handles direct descendant selector edge cases 3', () => {
const elements: Element[] = [{ tag_name: 'span', nth_child: 2, nth_of_type: 1 }, { tag_name: 'section' }]
expect(checkElementsAgainstSelector(elements, 'section > span:nth-child(2):nth-of-type(1)')).toBeTruthy()
expect(checkElementsAgainstSelector(elements, 'section > span:nth-child(1):nth-of-type(1)')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'section > span:nth-child(2):nth-of-type(3)')).toBeFalsy()
expect(checkElementsAgainstSelector(elements, 'section > span:nth-child(1):nth-child(2)')).toBeFalsy()
})
})
})
describe('castingCompare', () => {
it('compares exact', () => {
expect(castingCompare(2, '2', PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare('2', 2, PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare(true, 'true', PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare(true, true, PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare('90', '90', PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare('1', true, PropertyOperator.Exact)).toBeTruthy()
expect(castingCompare('1', 'true', PropertyOperator.Exact)).toBeFalsy()
expect(castingCompare('1', false, PropertyOperator.Exact)).toBeFalsy()
expect(castingCompare(false, '1', PropertyOperator.Exact)).toBeFalsy()
expect(castingCompare(false, 'true', PropertyOperator.Exact)).toBeFalsy()
})
it('compares less than', () => {
expect(castingCompare(2, '2', PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('2', 2, PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('1', 'true', PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('0', 'true', PropertyOperator.Exact)).toBeFalsy()
expect(castingCompare(true, 'true', PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare(true, true, PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('90', '90', PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('1', true, PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare('1', false, PropertyOperator.LessThan)).toBeFalsy()
expect(castingCompare(false, '1', PropertyOperator.LessThan)).toBeTruthy()
expect(castingCompare(false, 'true', PropertyOperator.LessThan)).toBeTruthy()
expect(castingCompare('2', 3, PropertyOperator.LessThan)).toBeTruthy()
expect(castingCompare('445.3', 9099.2, PropertyOperator.LessThan)).toBeTruthy()
})
it('compares greater than', () => {
expect(castingCompare(2, '2', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('2', 2, PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('1', 'true', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('1', 'false', PropertyOperator.Exact)).toBeFalsy()
expect(castingCompare(true, 'true', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare(true, true, PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('90', '90', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('1', true, PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare(false, '1', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare(false, 'true', PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('2', 3, PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('445.3', 9099.2, PropertyOperator.GreaterThan)).toBeFalsy()
expect(castingCompare('1', false, PropertyOperator.GreaterThan)).toBeTruthy()
expect(castingCompare(true, '-1', PropertyOperator.GreaterThan)).toBeTruthy()
expect(castingCompare(1, 'false', PropertyOperator.GreaterThan)).toBeTruthy()
expect(castingCompare(333, '2', PropertyOperator.GreaterThan)).toBeTruthy()
expect(castingCompare('9032.3', -1.2, PropertyOperator.GreaterThan)).toBeTruthy()
})
})