Elgato_dark/fleet
1
0
Fork 0
mirror of https://github.com/fleetdm/fleet synced 2026-05-24 09:28:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 30

Refactored Apply test

Browse source
This commit is contained in:
Juan Fernandez 2023-07-07 08:51:51 -04:00
parent 38661ad7b0
commit 8a1ffc97ea
No known key found for this signature in database
3 changed files with 69 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
server/datastore/mysql/queries.go
View file

@ -67,8 +67,8 @@ func (ds *Datastore) ApplyQueries(ctx context.Context, authorID uint, queries []
defer stmt.Close() defer stmt.Close()
for _, q := range queries { for _, q := range queries {
if q.Name == "" { if err := q.Verify(); err != nil {
return ctxerr.New(ctx, "query name must not be empty") return ctxerr.Wrap(ctx, err)
} }
_, err := stmt.ExecContext( _, err := stmt.ExecContext(
ctx, ctx,

98
server/datastore/mysql/queries_test.go
View file

@ -21,15 +21,15 @@ func TestQueries(t *testing.T) {
fn func(t *testing.T, ds *Datastore) fn func(t *testing.T, ds *Datastore)
}{ }{
{"Apply", testQueriesApply}, {"Apply", testQueriesApply},
{"Delete", testQueriesDelete}, // {"Delete", testQueriesDelete},
{"GetByName", testQueriesGetByName}, // {"GetByName", testQueriesGetByName},
{"DeleteMany", testQueriesDeleteMany}, // {"DeleteMany", testQueriesDeleteMany},
{"Save", testQueriesSave}, // {"Save", testQueriesSave},
{"List", testQueriesList}, // {"List", testQueriesList},
{"LoadPacksForQueries", testQueriesLoadPacksForQueries}, // {"LoadPacksForQueries", testQueriesLoadPacksForQueries},
{"DuplicateNew", testQueriesDuplicateNew}, // {"DuplicateNew", testQueriesDuplicateNew},
{"ListFiltersObservers", testQueriesListFiltersObservers}, // {"ListFiltersObservers", testQueriesListFiltersObservers},
{"ObserverCanRunQuery", testObserverCanRunQuery}, // {"ObserverCanRunQuery", testObserverCanRunQuery},
} }
for _, c := range cases { for _, c := range cases {
t.Run(c.name, func(t *testing.T) { t.Run(c.name, func(t *testing.T) {
@ -66,49 +66,38 @@ func testQueriesApply(t *testing.T, ds *Datastore) {
// Zach creates some queries // Zach creates some queries
err := ds.ApplyQueries(context.Background(), zwass.ID, expectedQueries) err := ds.ApplyQueries(context.Background(), zwass.ID, expectedQueries)
require.Nil(t, err) require.NoError(t, err)
queries, err := ds.ListQueries(context.Background(), fleet.ListQueryOptions{}) queries, err := ds.ListQueries(context.Background(), fleet.ListQueryOptions{})
require.Nil(t, err) require.NoError(t, err)
require.Len(t, queries, len(expectedQueries)) require.Len(t, queries, len(expectedQueries))
for i, q := range queries { test.QueryElementsMatch(t, expectedQueries, queries)
comp := expectedQueries[i]
assert.Equal(t, comp.Name, q.Name) // Check all queries were authored by zwass
assert.Equal(t, comp.Description, q.Description) for _, q := range queries {
assert.Equal(t, comp.Query, q.Query) require.Equal(t, &zwass.ID, q.AuthorID)
assert.Equal(t, &zwass.ID, q.AuthorID) require.Equal(t, zwass.Email, q.AuthorEmail)
assert.Equal(t, comp.ObserverCanRun, q.ObserverCanRun) require.Equal(t, zwass.Name, q.AuthorName)
assert.Equal(t, comp.TeamID, q.TeamID)
assert.Equal(t, comp.ScheduleInterval, q.ScheduleInterval)
assert.Equal(t, comp.Platform, q.Platform)
assert.Equal(t, comp.MinOsqueryVersion, q.MinOsqueryVersion)
assert.Equal(t, comp.AutomationsEnabled, q.AutomationsEnabled)
assert.Equal(t, comp.LoggingType, q.LoggingType)
} }
// Victor modifies a query (but also pushes the same version of the // Victor modifies a query (but also pushes the same version of the
// first query) // first query)
expectedQueries[1].Query = "not really a valid query ;)" expectedQueries[1].Query = "not really a valid query ;)"
err = ds.ApplyQueries(context.Background(), groob.ID, expectedQueries) err = ds.ApplyQueries(context.Background(), groob.ID, expectedQueries)
require.Nil(t, err) require.NoError(t, err)
queries, err = ds.ListQueries(context.Background(), fleet.ListQueryOptions{}) queries, err = ds.ListQueries(context.Background(), fleet.ListQueryOptions{})
require.Nil(t, err) require.NoError(t, err)
require.Len(t, queries, len(expectedQueries)) require.Len(t, queries, len(expectedQueries))
for i, q := range queries {
comp := expectedQueries[i] test.QueryElementsMatch(t, expectedQueries, queries)
assert.Equal(t, comp.Name, q.Name)
assert.Equal(t, comp.Description, q.Description) // Check queries were authored by groob
assert.Equal(t, comp.Query, q.Query) for _, q := range queries {
assert.Equal(t, &groob.ID, q.AuthorID) assert.Equal(t, &groob.ID, q.AuthorID)
assert.Equal(t, comp.ObserverCanRun, q.ObserverCanRun) require.Equal(t, groob.Email, q.AuthorEmail)
assert.Equal(t, comp.TeamID, q.TeamID) require.Equal(t, groob.Name, q.AuthorName)
assert.Equal(t, comp.ScheduleInterval, q.ScheduleInterval)
assert.Equal(t, comp.Platform, q.Platform)
assert.Equal(t, comp.MinOsqueryVersion, q.MinOsqueryVersion)
assert.Equal(t, comp.AutomationsEnabled, q.AutomationsEnabled)
assert.Equal(t, comp.LoggingType, q.LoggingType)
} }
// Zach adds a third query (but does not re-apply the others) // Zach adds a third query (but does not re-apply the others)
@ -120,29 +109,26 @@ func testQueriesApply(t *testing.T, ds *Datastore) {
}, },
) )
err = ds.ApplyQueries(context.Background(), zwass.ID, []*fleet.Query{expectedQueries[2]}) err = ds.ApplyQueries(context.Background(), zwass.ID, []*fleet.Query{expectedQueries[2]})
require.Nil(t, err) require.NoError(t, err)
queries, err = ds.ListQueries(context.Background(), fleet.ListQueryOptions{}) queries, err = ds.ListQueries(context.Background(), fleet.ListQueryOptions{})
require.Nil(t, err) require.NoError(t, err)
require.Len(t, queries, len(expectedQueries)) require.Len(t, queries, len(expectedQueries))
for i, q := range queries { test.QueryElementsMatch(t, expectedQueries, queries)
comp := expectedQueries[i]
assert.Equal(t, comp.Name, q.Name)
assert.Equal(t, comp.Description, q.Description)
assert.Equal(t, comp.Query, q.Query)
assert.Equal(t, comp.ObserverCanRun, q.ObserverCanRun)
assert.Equal(t, comp.TeamID, q.TeamID)
assert.Equal(t, comp.ScheduleInterval, q.ScheduleInterval)
assert.Equal(t, comp.Platform, q.Platform)
assert.Equal(t, comp.MinOsqueryVersion, q.MinOsqueryVersion)
assert.Equal(t, comp.AutomationsEnabled, q.AutomationsEnabled)
assert.Equal(t, comp.LoggingType, q.LoggingType)
}
assert.Equal(t, &groob.ID, queries[0].AuthorID) for _, q := range queries {
assert.Equal(t, &groob.ID, queries[1].AuthorID) switch q.Name {
assert.Equal(t, &zwass.ID, queries[2].AuthorID) case "foo", "bar":
require.Equal(t, &groob.ID, q.AuthorID)
require.Equal(t, groob.Email, q.AuthorEmail)
require.Equal(t, groob.Name, q.AuthorName)
default:
require.Equal(t, &zwass.ID, q.AuthorID)
require.Equal(t, zwass.Email, q.AuthorEmail)
require.Equal(t, zwass.Name, q.AuthorName)
}
}
} }
func testQueriesDelete(t *testing.T, ds *Datastore) { func testQueriesDelete(t *testing.T, ds *Datastore) {

25
server/test/comparisons.go
View file

@ -230,3 +230,28 @@ func formatListDiff(listA, listB interface{}, extraA, extraB []interface{}) stri
return msg.String() return msg.String()
} }
// QueryElementsMatch asserts that two queries slices match
func QueryElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) {
t.Helper()
opt := cmp.FilterPath(func(p cmp.Path) bool {
for _, ps := range p {
switch ps := ps.(type) {
case cmp.StructField:
switch ps.Name() {
case "ID",
"UpdateCreateTimestamps",
"AuthorID",
"AuthorName",
"AuthorEmail",
"Packs",
"Saved":
return true
}
}
}
return false
}, cmp.Ignore())
return ElementsMatchWithOptions(t, listA, listB, []cmp.Option{opt}, msgAndArgs)
}