615 lines
24 KiB
Go
615 lines
24 KiB
Go
// Copyright (c) 2026 Probo Inc <hello@probo.com>.
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice appear in all copies.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
// PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
package coredata_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.gearno.de/kit/pg"
|
|
"go.probo.inc/probo/internal/test"
|
|
"go.probo.inc/probo/pkg/coredata"
|
|
"go.probo.inc/probo/pkg/gid"
|
|
)
|
|
|
|
// seedCommonThirdParty inserts a global catalog third party with a
|
|
// collision-free name/slug. The catalog is not tenant-scoped and carries
|
|
// unique indexes, so parallel tests must namespace their rows.
|
|
func seedCommonThirdParty(t *testing.T, ctx context.Context, client *pg.Client) coredata.CommonThirdParty {
|
|
t.Helper()
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
id := gid.New(gid.NilTenant, coredata.CommonThirdPartyEntityType)
|
|
suffix := id.String()
|
|
|
|
party := coredata.CommonThirdParty{
|
|
ID: id,
|
|
Name: "Acme " + suffix,
|
|
Slug: "acme-" + suffix,
|
|
Category: coredata.ThirdPartyCategoryAnalytics,
|
|
Certifications: []string{},
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return party.Insert(ctx, tx)
|
|
}))
|
|
|
|
t.Cleanup(func() {
|
|
_ = client.WithTx(context.Background(), func(ctx context.Context, tx pg.Tx) error {
|
|
_, err := tx.Exec(ctx, `DELETE FROM common_third_parties WHERE id = $1`, id)
|
|
return err
|
|
})
|
|
})
|
|
|
|
return party
|
|
}
|
|
|
|
// insertCommonTrackerPattern inserts a catalog pattern row verbatim
|
|
// (Insert, not Upsert) so a test can stage an exact enrichment state.
|
|
func insertCommonTrackerPattern(
|
|
t *testing.T,
|
|
ctx context.Context,
|
|
client *pg.Client,
|
|
cp coredata.CommonTrackerPattern,
|
|
) {
|
|
t.Helper()
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return cp.Insert(ctx, tx)
|
|
}))
|
|
|
|
t.Cleanup(func() {
|
|
_ = client.WithTx(context.Background(), func(ctx context.Context, tx pg.Tx) error {
|
|
_, err := tx.Exec(ctx, `DELETE FROM common_tracker_patterns WHERE id = $1`, cp.ID)
|
|
return err
|
|
})
|
|
})
|
|
}
|
|
|
|
func loadCommonTrackerPattern(
|
|
t *testing.T,
|
|
ctx context.Context,
|
|
client *pg.Client,
|
|
id gid.GID,
|
|
) coredata.CommonTrackerPattern {
|
|
t.Helper()
|
|
|
|
var reloaded coredata.CommonTrackerPattern
|
|
|
|
require.NoError(t, client.WithConn(ctx, func(ctx context.Context, conn pg.Querier) error {
|
|
return reloaded.LoadByID(ctx, conn, id)
|
|
}))
|
|
|
|
return reloaded
|
|
}
|
|
|
|
// TestCommonTrackerPattern_UpdateEnrichment_AllowsEmptyDescription pins
|
|
// the no-fabrication contract: the enrichment worker records an empty
|
|
// description when it cannot substantiate a purpose, but still writes an
|
|
// enrichment payload so the row reads as having been through the workflow
|
|
// and the stale-recovery loop never re-queues it.
|
|
func TestCommonTrackerPattern_UpdateEnrichment_AllowsEmptyDescription(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
requestedAt := now.Add(-time.Minute)
|
|
cp := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeLocalStorage,
|
|
Pattern: "blank_key_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Description: "",
|
|
Confidence: 0.5,
|
|
EnrichmentRequestedAt: &requestedAt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, cp)
|
|
|
|
payload := json.RawMessage(`{"status":"no_result","fields":{"description":{"status":"not_found"}}}`)
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return cp.UpdateEnrichment(ctx, tx, "", nil, payload)
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
assert.Equal(t, "", reloaded.Description, "blank description must stay blank")
|
|
assert.NotEmpty(t, reloaded.Enrichment, "blank row must still record an enrichment payload")
|
|
assert.Nil(t, reloaded.EnrichmentRequestedAt, "enriched row must leave the queue")
|
|
|
|
// A blank but enriched row must NOT be re-queued by stale recovery:
|
|
// the enrichment payload is present, so the stale sweep skips it.
|
|
require.NoError(t, client.WithConn(ctx, func(ctx context.Context, conn pg.Querier) error {
|
|
return coredata.ResetStaleEnrichments(ctx, conn, 0, 3)
|
|
}))
|
|
|
|
afterSweep := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
assert.Nil(t, afterSweep.EnrichmentRequestedAt, "stale recovery must not re-queue an enriched blank row")
|
|
}
|
|
|
|
// TestCommonTrackerPattern_UpdateEnrichment_LinksThirdPartyWithoutOverride
|
|
// pins the link-no-override contract: the enrichment worker links a
|
|
// resolved third party only when the row has none, and never clobbers an
|
|
// attribution the mapping pipeline already resolved.
|
|
func TestCommonTrackerPattern_UpdateEnrichment_LinksThirdPartyWithoutOverride(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
other := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
|
|
t.Run("links when unset", func(t *testing.T) {
|
|
cp := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "link_unset_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, cp)
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return cp.UpdateEnrichment(ctx, tx, "Analytics tracker.", &party.ID, json.RawMessage(`{"status":"done"}`))
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
require.NotNil(t, reloaded.CommonThirdPartyID)
|
|
assert.Equal(t, party.ID, *reloaded.CommonThirdPartyID, "unlinked row must gain the resolved third party")
|
|
})
|
|
|
|
t.Run("does not override existing link", func(t *testing.T) {
|
|
cp := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
CommonThirdPartyID: &party.ID,
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "link_set_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, cp)
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return cp.UpdateEnrichment(ctx, tx, "Analytics tracker.", &other.ID, json.RawMessage(`{"status":"done"}`))
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
require.NotNil(t, reloaded.CommonThirdPartyID)
|
|
assert.Equal(t, party.ID, *reloaded.CommonThirdPartyID, "existing third party link must not be overridden")
|
|
})
|
|
}
|
|
|
|
// TestCommonTrackerPattern_Upsert_RequeuesBlankRowOnThirdPartyLink pins
|
|
// the re-trigger contract: when a blank, unlinked catalog row later
|
|
// gains a third party through the mapping pipeline's Upsert, enrichment
|
|
// is re-armed so the now-known vendor gets a second, better-informed
|
|
// description attempt.
|
|
func TestCommonTrackerPattern_Upsert_RequeuesBlankRowOnThirdPartyLink(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
attemptAt := now.Add(-time.Hour)
|
|
pattern := "requeue_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String()
|
|
|
|
// Stage a completed blank row: enriched (carries a payload), no
|
|
// description, no vendor, with prior attempts spent.
|
|
blank := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Description: "",
|
|
Confidence: 0.5,
|
|
Enrichment: json.RawMessage(`{"status":"no_result"}`),
|
|
EnrichmentAttempts: 2,
|
|
LastEnrichmentAttemptAt: &attemptAt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, blank)
|
|
|
|
// The mapping pipeline upserts the same key now carrying a vendor.
|
|
linking := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
CommonThirdPartyID: &party.ID,
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Description: "",
|
|
Confidence: 0.7,
|
|
CreatedAt: now,
|
|
UpdatedAt: now.Add(time.Minute),
|
|
}
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
inserted, err := linking.Upsert(ctx, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
assert.False(t, inserted, "Upsert must hit the existing blank row, not insert a new one")
|
|
|
|
return nil
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, blank.ID)
|
|
require.NotNil(t, reloaded.CommonThirdPartyID)
|
|
assert.Equal(t, party.ID, *reloaded.CommonThirdPartyID, "blank row must gain the linked third party")
|
|
assert.NotNil(t, reloaded.EnrichmentRequestedAt, "linking a vendor must re-queue the blank row for enrichment")
|
|
assert.Equal(t, 0, reloaded.EnrichmentAttempts, "re-queued row must get a fresh retry budget")
|
|
assert.Empty(t, reloaded.Enrichment, "re-armed row must drop the prior payload so it reads as not yet completed")
|
|
|
|
// The prior payload must be cleared so a crash between the worker's
|
|
// claim and persist stays recoverable. Simulate the claim (which bumps
|
|
// attempts past zero and stamps the idle clock) without completing, then
|
|
// confirm the stale sweep re-queues the row — it only catches rows whose
|
|
// payload is still null.
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return reloaded.ClearEnrichmentRequestedAt(ctx, tx)
|
|
}))
|
|
|
|
require.NoError(t, client.WithConn(ctx, func(ctx context.Context, conn pg.Querier) error {
|
|
return coredata.ResetStaleEnrichments(ctx, conn, 0, 3)
|
|
}))
|
|
|
|
afterSweep := loadCommonTrackerPattern(t, ctx, client, blank.ID)
|
|
assert.NotNil(t, afterSweep.EnrichmentRequestedAt, "stale recovery must re-queue a re-armed row claimed but never completed")
|
|
}
|
|
|
|
// TestCommonTrackerPattern_Upsert_KeepsDescribedRowTerminal pins the
|
|
// negative case: a row that already has a description is not re-queued
|
|
// when its third party changes, since it already carries a substantiated
|
|
// purpose.
|
|
func TestCommonTrackerPattern_Upsert_KeepsDescribedRowTerminal(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
attemptAt := now.Add(-time.Hour)
|
|
pattern := "described_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String()
|
|
|
|
described := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Description: "An established analytics cookie.",
|
|
Confidence: 0.9,
|
|
Enrichment: json.RawMessage(`{"status":"done"}`),
|
|
EnrichmentAttempts: 1,
|
|
LastEnrichmentAttemptAt: &attemptAt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, described)
|
|
|
|
linking := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
CommonThirdPartyID: &party.ID,
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Description: "",
|
|
Confidence: 0.7,
|
|
CreatedAt: now,
|
|
UpdatedAt: now.Add(time.Minute),
|
|
}
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
_, err := linking.Upsert(ctx, tx)
|
|
return err
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, described.ID)
|
|
assert.Equal(t, "An established analytics cookie.", reloaded.Description, "existing description must be preserved")
|
|
assert.Nil(t, reloaded.EnrichmentRequestedAt, "described row must not be re-queued")
|
|
assert.NotEmpty(t, reloaded.Enrichment, "described row must keep its enrichment payload")
|
|
assert.Equal(t, 1, reloaded.EnrichmentAttempts, "described row's retry budget must be untouched")
|
|
}
|
|
|
|
// TestCommonTrackerPattern_ClearEnrichmentRequestedAt_CountsAttempt pins
|
|
// the claim contract: dequeuing a row counts the attempt and stamps the
|
|
// idle clock, so a crash before UpdateEnrichment still spends part of the
|
|
// retry budget and the stale clock starts at claim time.
|
|
func TestCommonTrackerPattern_ClearEnrichmentRequestedAt_CountsAttempt(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
requestedAt := now.Add(-time.Minute)
|
|
cp := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "claim_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
EnrichmentRequestedAt: &requestedAt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, cp)
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
return cp.ClearEnrichmentRequestedAt(ctx, tx)
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
assert.Nil(t, reloaded.EnrichmentRequestedAt, "claim must remove the row from the queue")
|
|
assert.Equal(t, 1, reloaded.EnrichmentAttempts, "claim must count the attempt")
|
|
assert.NotNil(t, reloaded.LastEnrichmentAttemptAt, "claim must stamp the idle clock")
|
|
}
|
|
|
|
// TestCommonTrackerPattern_ResetStaleEnrichments_RespectsMaxAttempts pins
|
|
// the retry-budget contract: stale recovery re-queues a claimed-but-
|
|
// incomplete row that still has budget, but leaves a row at the
|
|
// max-attempts ceiling alone so a permanently failing row does not loop.
|
|
func TestCommonTrackerPattern_ResetStaleEnrichments_RespectsMaxAttempts(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
staleAttempt := now.Add(-time.Hour)
|
|
|
|
// A claimed-but-incomplete row with budget left: no payload yet, one
|
|
// attempt spent, idle past the threshold.
|
|
eligible := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "stale_eligible_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
EnrichmentAttempts: 1,
|
|
LastEnrichmentAttemptAt: &staleAttempt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, eligible)
|
|
|
|
// A row that has exhausted its retry budget must be left alone.
|
|
exhausted := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "stale_exhausted_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
EnrichmentAttempts: 3,
|
|
LastEnrichmentAttemptAt: &staleAttempt,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, exhausted)
|
|
|
|
require.NoError(t, client.WithConn(ctx, func(ctx context.Context, conn pg.Querier) error {
|
|
return coredata.ResetStaleEnrichments(ctx, conn, time.Minute, 3)
|
|
}))
|
|
|
|
reloadedEligible := loadCommonTrackerPattern(t, ctx, client, eligible.ID)
|
|
assert.NotNil(t, reloadedEligible.EnrichmentRequestedAt, "stale row with budget must be re-queued")
|
|
|
|
reloadedExhausted := loadCommonTrackerPattern(t, ctx, client, exhausted.ID)
|
|
assert.Nil(t, reloadedExhausted.EnrichmentRequestedAt, "row at the max-attempts ceiling must not be re-queued")
|
|
}
|
|
|
|
// TestCommonTrackerPatternAttribution_IsValid pins the enum's accepted
|
|
// values.
|
|
func TestCommonTrackerPatternAttribution_IsValid(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, v := range coredata.CommonTrackerPatternAttributions() {
|
|
assert.True(t, v.IsValid(), "%q must be valid", v)
|
|
}
|
|
|
|
assert.False(t, coredata.CommonTrackerPatternAttribution("").IsValid())
|
|
assert.False(t, coredata.CommonTrackerPatternAttribution("nonsense").IsValid())
|
|
}
|
|
|
|
// TestCommonTrackerPattern_Upsert_RoundTripsAttribution pins that the
|
|
// attribution verdict is persisted and read back, and that an empty
|
|
// verdict defaults to UNDETERMINED.
|
|
func TestCommonTrackerPattern_Upsert_RoundTripsAttribution(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
cp := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeLocalStorage,
|
|
Pattern: "attr_default_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, cp)
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, cp.ID)
|
|
assert.Equal(t, coredata.CommonTrackerPatternAttributionUndetermined, reloaded.Attribution, "empty verdict must default to UNDETERMINED")
|
|
}
|
|
|
|
// TestCommonTrackerPattern_Upsert_PreservesFirstPartyVerdict pins the
|
|
// terminal contract: once a row is FIRST_PARTY, an automated upsert that
|
|
// carries a vendor neither flips the verdict nor attaches the vendor.
|
|
func TestCommonTrackerPattern_Upsert_PreservesFirstPartyVerdict(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
pattern := "first_party_terminal_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String()
|
|
|
|
firstParty := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeLocalStorage,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.8,
|
|
Attribution: coredata.CommonTrackerPatternAttributionFirstParty,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, firstParty)
|
|
|
|
// An automated upsert (same key) that tries to attach a vendor.
|
|
intruder := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
CommonThirdPartyID: &party.ID,
|
|
TrackerType: coredata.TrackerTypeLocalStorage,
|
|
Pattern: pattern,
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.7,
|
|
Attribution: coredata.CommonTrackerPatternAttributionThirdParty,
|
|
CreatedAt: now,
|
|
UpdatedAt: now.Add(time.Minute),
|
|
}
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
_, err := intruder.Upsert(ctx, tx)
|
|
return err
|
|
}))
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, firstParty.ID)
|
|
assert.Equal(t, coredata.CommonTrackerPatternAttributionFirstParty, reloaded.Attribution, "FIRST_PARTY verdict must survive an automated upsert")
|
|
assert.Nil(t, reloaded.CommonThirdPartyID, "a terminal first-party row must stay vendor-free")
|
|
}
|
|
|
|
// TestCommonTrackerPatterns_SetAttributionByIDs pins that the operator
|
|
// helper records the verdict and clears any vendor link.
|
|
func TestCommonTrackerPatterns_SetAttributionByIDs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
linked := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
CommonThirdPartyID: &party.ID,
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "to_first_party_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.8,
|
|
Attribution: coredata.CommonTrackerPatternAttributionThirdParty,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, linked)
|
|
|
|
var affected int64
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
var (
|
|
ps coredata.CommonTrackerPatterns
|
|
err error
|
|
)
|
|
|
|
affected, err = ps.SetAttributionByIDs(ctx, tx, []gid.GID{linked.ID}, coredata.CommonTrackerPatternAttributionFirstParty)
|
|
|
|
return err
|
|
}))
|
|
|
|
assert.Equal(t, int64(1), affected)
|
|
|
|
reloaded := loadCommonTrackerPattern(t, ctx, client, linked.ID)
|
|
assert.Equal(t, coredata.CommonTrackerPatternAttributionFirstParty, reloaded.Attribution)
|
|
assert.Nil(t, reloaded.CommonThirdPartyID, "marking first-party must clear the vendor link")
|
|
}
|
|
|
|
// TestCommonTrackerPatterns_RelinkCommonThirdPartyByIDs_SetsAttribution
|
|
// pins that linking sets THIRD_PARTY and unlinking returns the row to
|
|
// UNDETERMINED.
|
|
func TestCommonTrackerPatterns_RelinkCommonThirdPartyByIDs_SetsAttribution(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
client := test.PGClient(t)
|
|
ctx := context.Background()
|
|
|
|
party := seedCommonThirdParty(t, ctx, client)
|
|
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
row := coredata.CommonTrackerPattern{
|
|
ID: gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType),
|
|
TrackerType: coredata.TrackerTypeCookie,
|
|
Pattern: "relink_attr_" + gid.New(gid.NilTenant, coredata.CommonTrackerPatternEntityType).String(),
|
|
MatchType: coredata.TrackerPatternMatchTypeExact,
|
|
Confidence: 0.5,
|
|
Attribution: coredata.CommonTrackerPatternAttributionUndetermined,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
insertCommonTrackerPattern(t, ctx, client, row)
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
var ps coredata.CommonTrackerPatterns
|
|
|
|
_, err := ps.RelinkCommonThirdPartyByIDs(ctx, tx, []gid.GID{row.ID}, &party.ID)
|
|
|
|
return err
|
|
}))
|
|
|
|
linked := loadCommonTrackerPattern(t, ctx, client, row.ID)
|
|
assert.Equal(t, coredata.CommonTrackerPatternAttributionThirdParty, linked.Attribution, "linking must set THIRD_PARTY")
|
|
require.NotNil(t, linked.CommonThirdPartyID)
|
|
assert.Equal(t, party.ID, *linked.CommonThirdPartyID)
|
|
assert.Equal(t, float32(1), linked.Confidence, "linking must bump confidence to the curated tier")
|
|
|
|
require.NoError(t, client.WithTx(ctx, func(ctx context.Context, tx pg.Tx) error {
|
|
var ps coredata.CommonTrackerPatterns
|
|
|
|
_, err := ps.RelinkCommonThirdPartyByIDs(ctx, tx, []gid.GID{row.ID}, nil)
|
|
|
|
return err
|
|
}))
|
|
|
|
unlinked := loadCommonTrackerPattern(t, ctx, client, row.ID)
|
|
assert.Equal(t, coredata.CommonTrackerPatternAttributionUndetermined, unlinked.Attribution, "unlinking must return the verdict to UNDETERMINED")
|
|
assert.Nil(t, unlinked.CommonThirdPartyID)
|
|
}
|