| package sqlignorestore |
| |
| import ( |
| "context" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/google/uuid" |
| "github.com/jackc/pgx/v4/pgxpool" |
| "github.com/stretchr/testify/assert" |
| "github.com/stretchr/testify/require" |
| |
| "go.skia.org/infra/go/paramtools" |
| "go.skia.org/infra/go/testutils/unittest" |
| "go.skia.org/infra/golden/go/ignore" |
| "go.skia.org/infra/golden/go/sql/databuilder" |
| dks "go.skia.org/infra/golden/go/sql/datakitchensink" |
| "go.skia.org/infra/golden/go/sql/schema" |
| "go.skia.org/infra/golden/go/sql/sqltest" |
| "go.skia.org/infra/golden/go/types" |
| ) |
| |
| func TestCreate_RulesAppearInSQLTableAndCanBeListed(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| store := New(db) |
| |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| })) |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "otheruser@example.com", |
| Expires: time.Date(2018, time.January, 10, 10, 10, 0, 0, time.UTC), |
| Query: "model=Pixel1&os=foo&model=Pixel2", |
| Note: "skbug.com/54678", |
| })) |
| |
| // It's good to query the database directly for at least one test, so we can verify List() |
| // is returning the proper data. |
| actualRows := sqltest.GetAllRows(ctx, t, db, "IgnoreRules", &schema.IgnoreRuleRow{}).([]schema.IgnoreRuleRow) |
| require.Len(t, actualRows, 2) |
| firstID := actualRows[0].IgnoreRuleID |
| secondID := actualRows[1].IgnoreRuleID |
| assert.Equal(t, []schema.IgnoreRuleRow{{ |
| IgnoreRuleID: firstID, |
| CreatorEmail: "otheruser@example.com", |
| UpdatedEmail: "otheruser@example.com", |
| Expires: time.Date(2018, time.January, 10, 10, 10, 0, 0, time.UTC), |
| Note: "skbug.com/54678", |
| Query: paramtools.ReadOnlyParamSet{ |
| "model": []string{"Pixel1", "Pixel2"}, |
| "os": []string{"foo"}, |
| }, |
| }, { |
| IgnoreRuleID: secondID, |
| CreatorEmail: "me@example.com", |
| UpdatedEmail: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Note: "skbug.com/1234", |
| Query: paramtools.ReadOnlyParamSet{"model": []string{"NvidiaShield2015"}}, |
| }}, actualRows) |
| |
| rules, err := store.List(ctx) |
| require.NoError(t, err) |
| |
| assert.Equal(t, []ignore.Rule{{ |
| ID: firstID.String(), |
| CreatedBy: "otheruser@example.com", |
| UpdatedBy: "otheruser@example.com", |
| Expires: time.Date(2018, time.January, 10, 10, 10, 0, 0, time.UTC), |
| Query: "model=Pixel1&model=Pixel2&os=foo", |
| Note: "skbug.com/54678", |
| }, { |
| ID: secondID.String(), |
| CreatedBy: "me@example.com", |
| UpdatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| }}, rules) |
| } |
| func TestCreate_InvalidQuery_ReturnsError(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| store := New(nil) |
| require.Error(t, store.Create(context.Background(), ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "%NOT A VALID QUERY", |
| Note: "skbug.com/1234", |
| })) |
| } |
| |
| func TestCreate_AllIgnoreStatusesNull_TracesMatchingRuleUpdated(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := loadTestData() |
| // Set everything to null |
| for i := range existingData.Traces { |
| existingData.Traces[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| for i := range existingData.ValuesAtHead { |
| existingData.ValuesAtHead[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| |
| store := New(db) |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=Sailfish&os=Android", |
| Note: "skbug.com/1234", |
| })) |
| |
| expectedStatuses := map[string]schema.NullableBool{ |
| "SailfishOne": schema.NBTrue, // changed |
| "SailfishTwo": schema.NBTrue, // changed |
| "SailfishThree": schema.NBTrue, // changed |
| "BullheadOne": schema.NBNull, // untouched |
| "BullheadTwo": schema.NBNull, // untouched |
| "BullheadThree": schema.NBNull, // untouched |
| } |
| actualTraces := getTracesAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualTraces) |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualValuesAtHead) |
| } |
| |
| func TestCreate_RuleWithSomeMissingValues_TracesMatchingRuleUpdated(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := loadTestData() |
| // Set everything to null |
| for i := range existingData.Traces { |
| existingData.Traces[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| for i := range existingData.ValuesAtHead { |
| existingData.ValuesAtHead[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| |
| store := New(db) |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| // This rule has some models and names that don't exist. That shouldn't cause anything |
| // to fail - only those traces that do match will be counted. |
| Query: "model=Bullhead&model=Snorlax&model=Bellsprout&os=Android&name=Three&name=Two&name=Four", |
| Note: "skbug.com/1234", |
| })) |
| |
| expectedStatuses := map[string]schema.NullableBool{ |
| "SailfishOne": schema.NBNull, // untouched |
| "SailfishTwo": schema.NBNull, // untouched |
| "SailfishThree": schema.NBNull, // untouched |
| "BullheadOne": schema.NBNull, // untouched |
| "BullheadTwo": schema.NBTrue, // changed |
| "BullheadThree": schema.NBTrue, // changed |
| } |
| actualTraces := getTracesAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualTraces) |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualValuesAtHead) |
| } |
| |
| func TestCreate_RuleWithMissingKey_NothingUpdated(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := loadTestData() |
| // Set everything to null |
| for i := range existingData.Traces { |
| existingData.Traces[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| for i := range existingData.ValuesAtHead { |
| existingData.ValuesAtHead[i].MatchesAnyIgnoreRule = schema.NBNull |
| } |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| |
| store := New(db) |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=Snorlax&os=Android", |
| Note: "skbug.com/1234", |
| })) |
| |
| expectedStatuses := map[string]schema.NullableBool{ |
| "SailfishOne": schema.NBNull, // untouched |
| "SailfishTwo": schema.NBNull, // untouched |
| "SailfishThree": schema.NBNull, // untouched |
| "BullheadOne": schema.NBNull, // untouched |
| "BullheadTwo": schema.NBNull, // untouched |
| "BullheadThree": schema.NBNull, // untouched |
| } |
| actualTraces := getTracesAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualTraces) |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualValuesAtHead) |
| } |
| |
| // loadTestData creates 6 traces of varying ignore states (2 ignored, 4 not) with a single |
| // ignore rule. |
| func loadTestData() schema.Tables { |
| data := databuilder.TablesBuilder{} |
| data.CommitsWithData().Insert("123", "whoever@example.com", "initial commit", "2021-01-11T16:00:00Z") |
| data.SetDigests(map[rune]types.Digest{ |
| 'a': dks.DigestA04Unt, |
| }) |
| data.SetGroupingKeys(types.CorpusField, types.PrimaryKeyField) |
| data.AddTracesWithCommonKeys(paramtools.Params{types.CorpusField: "gm", "os": "Android"}). |
| History("a", "a", "a", "a", "a", "a").Keys([]paramtools.Params{ |
| {"model": "Sailfish", types.PrimaryKeyField: "One"}, |
| {"model": "Sailfish", types.PrimaryKeyField: "Two"}, |
| {"model": "Sailfish", types.PrimaryKeyField: "Three"}, |
| {"model": "Bullhead", types.PrimaryKeyField: "One"}, |
| {"model": "Bullhead", types.PrimaryKeyField: "Two"}, |
| {"model": "Bullhead", types.PrimaryKeyField: "Three"}, |
| }).OptionsAll(paramtools.Params{"ext": "png"}). |
| IngestedFrom([]string{"file"}, []string{"2021-01-11T16:05:00Z"}) |
| data.AddIgnoreRule("me@example.com", "me@example.com", "2021-01-11T17:00:00Z", "ignore test 2", |
| paramtools.ParamSet{types.PrimaryKeyField: []string{"Two"}}) |
| return data.Build() |
| } |
| |
| func getTracesAndStatus(ctx context.Context, t *testing.T, db *pgxpool.Pool, keys ...string) map[string]schema.NullableBool { |
| require.NotEmpty(t, keys) |
| rows := sqltest.GetAllRows(ctx, t, db, "Traces", &schema.TraceRow{}).([]schema.TraceRow) |
| actualTraces := map[string]schema.NullableBool{} |
| for _, r := range rows { |
| combined := "" |
| for _, key := range keys { |
| combined += r.Keys[key] |
| } |
| actualTraces[combined] = r.MatchesAnyIgnoreRule |
| } |
| return actualTraces |
| } |
| |
| func getValuesAtHeadAndStatus(ctx context.Context, t *testing.T, db *pgxpool.Pool, keys ...string) map[string]schema.NullableBool { |
| require.NotEmpty(t, keys) |
| rows := sqltest.GetAllRows(ctx, t, db, "ValuesAtHead", &schema.ValueAtHeadRow{}).([]schema.ValueAtHeadRow) |
| actualValues := map[string]schema.NullableBool{} |
| for _, r := range rows { |
| combined := "" |
| for _, key := range keys { |
| combined += r.Keys[key] |
| } |
| actualValues[combined] = r.MatchesAnyIgnoreRule |
| } |
| return actualValues |
| } |
| |
| func TestUpdate_ExistingRuleExpanded_AdditionalTracesIgnored(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| newExpires := time.Date(2022, time.January, 1, 1, 1, 1, 0, time.UTC) |
| |
| store := New(db) |
| require.NoError(t, store.Update(ctx, ignore.Rule{ |
| ID: idForRule(existingData.IgnoreRules, "Taimen"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserFour, |
| Expires: newExpires, |
| // This rule previously ignored the square and circle test. Now it ignores all three tests. |
| Query: "device=taimen&name=square&name=triangle&name=circle", |
| Note: "Should ignore all 3 tests now", |
| })) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualTraces["taimencircle"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualTraces["taimensquare"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualTraces["taimentriangle"]) // Updated |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyeround rect"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) // not affected |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimencircle"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimensquare"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimentriangle"]) // Updated |
| // walleye + round rect is not landed, so it is not in the table ValuesAtHead |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) // not affected |
| |
| actualIgnoreRules := sqltest.GetAllRows(ctx, t, db, "IgnoreRules", &schema.IgnoreRuleRow{}).([]schema.IgnoreRuleRow) |
| assert.ElementsMatch(t, []schema.IgnoreRuleRow{{ |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "Taimen")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserFour, // Updated |
| Expires: newExpires, // Updated |
| Note: "Should ignore all 3 tests now", // Updated |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{dks.TaimenDevice}, |
| types.PrimaryKeyField: []string{dks.CircleTest, dks.SquareTest, dks.TriangleTest}, |
| }, |
| }, { |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "expired")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserOne, |
| Expires: time.Date(2020, time.February, 14, 13, 12, 11, 0, time.UTC), |
| Note: "This rule has expired (and does not apply to anything)", |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{"Nokia4"}, |
| types.CorpusField: []string{dks.CornersCorpus}, |
| }, |
| }}, actualIgnoreRules) |
| } |
| |
| func TestUpdate_QueryNotChanged_IgnoreRuleUpdated(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| newExpires := time.Date(2022, time.January, 1, 1, 1, 1, 0, time.UTC) |
| |
| store := New(db) |
| require.NoError(t, store.Update(ctx, ignore.Rule{ |
| ID: idForRule(existingData.IgnoreRules, "Taimen"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserFour, |
| Expires: newExpires, |
| Query: "device=taimen&name=square&name=circle", |
| Note: "Note and expires was updated", |
| })) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualTraces["taimencircle"]) |
| assert.Equal(t, schema.NBTrue, actualTraces["taimensquare"]) |
| assert.Equal(t, schema.NBFalse, actualTraces["taimentriangle"]) |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyeround rect"]) |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimencircle"]) |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimensquare"]) |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimentriangle"]) |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) |
| |
| actualIgnoreRules := sqltest.GetAllRows(ctx, t, db, "IgnoreRules", &schema.IgnoreRuleRow{}).([]schema.IgnoreRuleRow) |
| assert.ElementsMatch(t, []schema.IgnoreRuleRow{{ |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "Taimen")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserFour, // Updated |
| Expires: newExpires, // Updated |
| Note: "Note and expires was updated", // Updated |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{dks.TaimenDevice}, |
| types.PrimaryKeyField: []string{dks.CircleTest, dks.SquareTest}, |
| }, |
| }, { |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "expired")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserOne, |
| Expires: time.Date(2020, time.February, 14, 13, 12, 11, 0, time.UTC), |
| Note: "This rule has expired (and does not apply to anything)", |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{"Nokia4"}, |
| types.CorpusField: []string{dks.CornersCorpus}, |
| }, |
| }}, actualIgnoreRules) |
| } |
| |
| func TestUpdate_ExistingRuleReduced_FewerTracesIgnored(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| newExpires := time.Date(2022, time.January, 1, 1, 1, 1, 0, time.UTC) |
| |
| store := New(db) |
| require.NoError(t, store.Update(ctx, ignore.Rule{ |
| ID: idForRule(existingData.IgnoreRules, "Taimen"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserFour, |
| Expires: newExpires, |
| // This rule previously ignored the square and circle test. Now it ignores just the one. |
| Query: "device=taimen&name=square", |
| Note: "Should ignore one test now", |
| })) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualTraces["taimencircle"]) // updated |
| assert.Equal(t, schema.NBTrue, actualTraces["taimensquare"]) // still ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["taimentriangle"]) // still not ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyeround rect"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) // not affected |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimencircle"]) // updated |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimensquare"]) // Still ignored |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimentriangle"]) // still not ignored |
| // walleye + round rect is not landed, so it is not in the table ValuesAtHead |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) // not affected |
| |
| actualIgnoreRules := sqltest.GetAllRows(ctx, t, db, "IgnoreRules", &schema.IgnoreRuleRow{}).([]schema.IgnoreRuleRow) |
| assert.ElementsMatch(t, []schema.IgnoreRuleRow{{ |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "Taimen")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserFour, // Updated |
| Expires: newExpires, // Updated |
| Note: "Should ignore one test now", // Updated |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{dks.TaimenDevice}, |
| types.PrimaryKeyField: []string{dks.SquareTest}, |
| }, |
| }, { |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "expired")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserOne, |
| Expires: time.Date(2020, time.February, 14, 13, 12, 11, 0, time.UTC), |
| Note: "This rule has expired (and does not apply to anything)", |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{"Nokia4"}, |
| types.CorpusField: []string{dks.CornersCorpus}, |
| }, |
| }}, actualIgnoreRules) |
| } |
| |
| func TestUpdate_ExistingRuleChanged_DifferentTracesIgnored(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| newExpires := time.Date(2022, time.January, 1, 1, 1, 1, 0, time.UTC) |
| |
| store := New(db) |
| require.NoError(t, store.Update(ctx, ignore.Rule{ |
| ID: idForRule(existingData.IgnoreRules, "Taimen"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserFour, |
| Expires: newExpires, |
| // This rule previously ignored the taimen square and circle test. Now it ignores the |
| // walleye device and two different tests. |
| Query: "device=walleye&name=triangle&name=round rect", |
| Note: "Should ignore walleye now", |
| })) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualTraces["taimencircle"]) // updated |
| assert.Equal(t, schema.NBFalse, actualTraces["taimensquare"]) // updated |
| assert.Equal(t, schema.NBFalse, actualTraces["taimentriangle"]) // still not ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyecircle"]) // still not ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyesquare"]) // updated |
| assert.Equal(t, schema.NBTrue, actualTraces["walleyetriangle"]) // still not ignored |
| assert.Equal(t, schema.NBTrue, actualTraces["walleyeround rect"]) // updated |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) // not affected |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimencircle"]) // updated |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimensquare"]) // updated |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimentriangle"]) // still not ignored |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["walleyecircle"]) // still not ignored |
| // walleye + round rect is not landed, so it is not in the table ValuesAtHead |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["walleyetriangle"]) // updated |
| |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) // not affected |
| |
| actualIgnoreRules := sqltest.GetAllRows(ctx, t, db, "IgnoreRules", &schema.IgnoreRuleRow{}).([]schema.IgnoreRuleRow) |
| assert.ElementsMatch(t, []schema.IgnoreRuleRow{{ |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "Taimen")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserFour, // Updated |
| Expires: newExpires, // Updated |
| Note: "Should ignore walleye now", // Updated |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{dks.WalleyeDevice}, |
| types.PrimaryKeyField: []string{dks.RoundRectTest, dks.TriangleTest}, |
| }, |
| }, { |
| IgnoreRuleID: uuid.MustParse(idForRule(existingData.IgnoreRules, "expired")), |
| CreatorEmail: dks.UserTwo, |
| UpdatedEmail: dks.UserOne, |
| Expires: time.Date(2020, time.February, 14, 13, 12, 11, 0, time.UTC), |
| Note: "This rule has expired (and does not apply to anything)", |
| Query: paramtools.ReadOnlyParamSet{ |
| dks.DeviceKey: []string{"Nokia4"}, |
| types.CorpusField: []string{dks.CornersCorpus}, |
| }, |
| }}, actualIgnoreRules) |
| } |
| |
| func idForRule(rules []schema.IgnoreRuleRow, s string) string { |
| for _, r := range rules { |
| if strings.Contains(r.Note, s) { |
| return r.IgnoreRuleID.String() |
| } |
| } |
| panic("Could not find rule with matching note") |
| } |
| |
| func TestUpdate_InvalidID_ReturnsErrorAndNothingIsModified(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| store := New(db) |
| |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| })) |
| |
| rules, err := store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 1) |
| recordID := rules[0].ID |
| |
| require.Error(t, store.Update(ctx, ignore.Rule{ |
| ID: "00000000-1111-2222-3333-444444444444", |
| UpdatedBy: "updator@example.com", |
| Expires: time.Date(2020, time.August, 3, 3, 3, 3, 0, time.UTC), |
| Query: "model=NvidiaShield2015&model=Pixel3", |
| Note: "See skbug.com/1234 for more", |
| })) |
| |
| rules, err = store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 1) |
| assert.Equal(t, ignore.Rule{ |
| ID: recordID, |
| CreatedBy: "me@example.com", |
| UpdatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| }, rules[0]) |
| } |
| |
| func TestUpdate_InvalidQuery_ReturnsError(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| store := New(nil) |
| require.Error(t, store.Update(context.Background(), ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "%NOT A VALID QUERY", |
| Note: "skbug.com/1234", |
| })) |
| } |
| |
| func TestDelete_ExistingRule_RuleIsDeleted(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| store := New(db) |
| |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| })) |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "otheruser@example.com", |
| Expires: time.Date(2018, time.January, 10, 10, 10, 0, 0, time.UTC), |
| Query: "model=Pixel1&os=foo&model=Pixel2", |
| Note: "skbug.com/54678", |
| })) |
| |
| rules, err := store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 2) |
| firstID := rules[0].ID |
| secondID := rules[1].ID |
| |
| require.NoError(t, store.Delete(ctx, secondID)) |
| |
| rules, err = store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 1) |
| |
| assert.Equal(t, ignore.Rule{ |
| ID: firstID, |
| CreatedBy: "otheruser@example.com", |
| UpdatedBy: "otheruser@example.com", |
| Expires: time.Date(2018, time.January, 10, 10, 10, 0, 0, time.UTC), |
| Query: "model=Pixel1&model=Pixel2&os=foo", |
| Note: "skbug.com/54678", |
| }, rules[0]) |
| } |
| |
| func TestDelete_MissingID_ErrorReturnedAndNothingIsDeleted(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| store := New(db) |
| |
| require.NoError(t, store.Create(ctx, ignore.Rule{ |
| CreatedBy: "me@example.com", |
| Expires: time.Date(2020, time.May, 11, 10, 9, 0, 0, time.UTC), |
| Query: "model=NvidiaShield2015", |
| Note: "skbug.com/1234", |
| })) |
| |
| rules, err := store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 1) |
| |
| // It is extremely unlikely this is the actual record ID. |
| require.Error(t, store.Delete(ctx, "00000000-1111-2222-3333-444444444444")) |
| |
| rules, err = store.List(ctx) |
| require.NoError(t, err) |
| require.Len(t, rules, 1) |
| } |
| |
| func TestDelete_NoRulesRemain_NoTracesAreIgnored(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := loadTestData() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| |
| store := New(db) |
| require.NoError(t, store.Delete(ctx, existingData.IgnoreRules[0].IgnoreRuleID.String())) |
| |
| expectedStatuses := map[string]schema.NullableBool{ |
| "SailfishOne": schema.NBFalse, // changed |
| "SailfishTwo": schema.NBFalse, // changed |
| "SailfishThree": schema.NBFalse, // changed |
| "BullheadOne": schema.NBFalse, // untouched |
| "BullheadTwo": schema.NBFalse, // untouched |
| "BullheadThree": schema.NBFalse, // untouched |
| } |
| actualTraces := getTracesAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualTraces) |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "model", "name") |
| assert.Equal(t, expectedStatuses, actualValuesAtHead) |
| } |
| |
| func TestDelete_RuleAffectingNothingDeleted_RemainingRuleStillApplies(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| store := New(db) |
| require.NoError(t, store.Delete(ctx, idForRule(existingData.IgnoreRules, "expired"))) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualTraces["taimencircle"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualTraces["taimensquare"]) // Still ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["taimentriangle"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyeround rect"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) // not affected |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimencircle"]) // Still ignored |
| assert.Equal(t, schema.NBTrue, actualValuesAtHead["taimensquare"]) // Still ignored |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimentriangle"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) // not affected |
| } |
| |
| func TestDelete_RuleAffectingSomethingDeleted_RemainingRuleStillApplies(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| store := New(db) |
| require.NoError(t, store.Delete(ctx, idForRule(existingData.IgnoreRules, "Taimen"))) |
| |
| actualTraces := getTracesAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualTraces["taimencircle"]) // no longer ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["taimensquare"]) // no longer ignored |
| assert.Equal(t, schema.NBFalse, actualTraces["taimentriangle"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["walleyeround rect"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualTraces["iPad6,3square"]) // not affected |
| |
| actualValuesAtHead := getValuesAtHeadAndStatus(ctx, t, db, "device", "name") |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimencircle"]) // no longer ignored |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimensquare"]) // no longer ignored |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["taimentriangle"]) // not affected |
| assert.Equal(t, schema.NBFalse, actualValuesAtHead["iPad6,3square"]) // not affected |
| } |
| |
| func TestList_Success(t *testing.T) { |
| unittest.LargeTest(t) |
| |
| ctx := context.Background() |
| db := sqltest.NewCockroachDBForTestsWithProductionSchema(ctx, t) |
| existingData := dks.Build() |
| require.NoError(t, sqltest.BulkInsertDataTables(ctx, db, existingData)) |
| store := New(db) |
| rules, err := store.List(ctx) |
| require.NoError(t, err) |
| assert.Equal(t, []ignore.Rule{{ |
| ID: idForRule(existingData.IgnoreRules, "expired"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserOne, |
| Expires: time.Date(2020, time.February, 14, 13, 12, 11, 0, time.UTC), |
| Query: "device=Nokia4&source_type=corners", |
| Note: "This rule has expired (and does not apply to anything)", |
| }, { |
| ID: idForRule(existingData.IgnoreRules, "Taimen"), |
| CreatedBy: dks.UserTwo, |
| UpdatedBy: dks.UserOne, |
| Expires: time.Date(2030, time.December, 30, 15, 16, 17, 0, time.UTC), |
| Query: "device=taimen&name=square&name=circle", |
| Note: "Taimen isn't drawing correctly enough yet", |
| }}, rules) |
| } |
