Files
2026-10-31 03:45:00 -05:00

369 lines
12 KiB
Go

package pgsql_test
import (
"fmt"
"testing"
"time"
"github.com/effective-security/trustyca/api/pb"
"github.com/effective-security/trustyca/internal/db/model"
"github.com/effective-security/trustyca/internal/db/pgsql/query"
"github.com/effective-security/xdb"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func Test_Event(t *testing.T) {
owner, org := setupOwnerAndOrg(t, "Test_Event")
const total = 50
created := make(model.EventSlice, 0, total)
for i := 0; i < total; i++ {
em := &model.Event{
OrgID: org.ID,
Type: pb.EventType_Enum(i%5 + 1),
Title: fmt.Sprintf("Test Event %d", i),
Description: "This is a test event",
Email: xdb.NULLString(owner.Email),
Source: xdb.NULLString(fmt.Sprintf("test-%d", i)),
Metadata: map[string]string{"key": "test"},
ReferenceID: xdb.NewID(uint64(i + 1)),
}
event, err := provider.CreateEvent(ctx, em)
require.NoError(t, err)
assert.Equal(t, em.OrgID.UInt64(), event.OrgID.UInt64())
assert.Equal(t, em.Type, event.Type)
assert.Equal(t, em.Title, event.Title)
assert.Equal(t, em.Description, event.Description)
assert.Equal(t, em.Email, event.Email)
assert.Equal(t, em.Source, event.Source)
assert.Equal(t, em.ReferenceID.UInt64(), event.ReferenceID.UInt64())
assert.Equal(t, em.Metadata, event.Metadata)
created = append(created, event)
// spread created_at so time-range filters have distinct buckets
if i%5 == 4 {
time.Sleep(10 * time.Millisecond)
}
}
newestFirst := reverseEvents(created)
got, err := provider.GetEvent(ctx, created[0].ID.UInt64())
require.NoError(t, err)
assert.Equal(t, created[0].ID, got.ID)
_, err = provider.GetEvent(ctx, 123)
assert.ErrorContains(t, err, "record not found")
t.Run("newest_to_oldest", func(t *testing.T) {
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Limit: uint32(total + 1),
})
require.NoError(t, err)
require.Len(t, res.Rows, total)
assert.False(t, res.HasNextPage)
assert.Equal(t, eventIDs(newestFirst), eventIDs(res.Rows))
requireNewestFirst(t, res.Rows)
})
t.Run("pagination", func(t *testing.T) {
const pageSize = uint32(10)
first, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Limit: pageSize,
})
require.NoError(t, err)
require.Len(t, first.Rows, int(pageSize))
assert.True(t, first.HasNextPage)
assert.Equal(t, pageSize, first.NextOffset)
assert.Equal(t, eventIDs(newestFirst[:pageSize]), eventIDs(first.Rows))
requireNewestFirst(t, first.Rows)
second, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Limit: pageSize,
Offset: first.NextOffset,
})
require.NoError(t, err)
require.Len(t, second.Rows, int(pageSize))
assert.True(t, second.HasNextPage)
assert.Equal(t, uint32(20), second.NextOffset)
assert.Equal(t, eventIDs(newestFirst[10:20]), eventIDs(second.Rows))
requireNewestFirst(t, second.Rows)
var loaded model.EventSlice
req := &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Limit: pageSize,
}
for pages := 0; pages < 10; pages++ {
rs, err := provider.ListEvents(ctx, req)
require.NoError(t, err)
loaded = append(loaded, rs.Rows...)
if !rs.HasNextPage {
break
}
req.Offset = rs.NextOffset
}
assert.Equal(t, eventIDs(newestFirst), eventIDs(loaded))
requireNewestFirst(t, loaded)
})
t.Run("cursor", func(t *testing.T) {
// the pages cross the events that share a created_at, so the
// key continues by id within a time
const pageSize = uint32(7)
var loaded model.EventSlice
req := &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Limit: pageSize,
Cursor: query.NewCursor(0),
}
for pages := 0; pages < 10; pages++ {
rs, err := provider.ListEvents(ctx, req)
require.NoError(t, err)
assert.Zero(t, rs.NextOffset)
loaded = append(loaded, rs.Rows...)
if !rs.HasNextPage {
assert.Empty(t, rs.Cursor)
assert.Nil(t, rs.Pb().NextPage)
break
}
require.Len(t, rs.Rows, int(pageSize))
require.NotEmpty(t, rs.Cursor)
assert.Equal(t, rs.Cursor, rs.Pb().NextPage.Cursor)
req.Cursor, err = query.ParseTimeCursor(rs.Cursor)
require.NoError(t, err)
last := rs.Rows[len(rs.Rows)-1]
at, ok := req.Cursor.Key()[0].(time.Time)
require.True(t, ok)
assert.True(t, at.Equal(time.Time(last.CreatedAt)), "the cursor keeps the time of the last row")
assert.Equal(t, last.ID.UInt64(), req.Cursor.LastID())
}
assert.Equal(t, eventIDs(newestFirst), eventIDs(loaded), "the pages cover every event once")
requireNewestFirst(t, loaded)
// the cursor of a list by id is refused before the query
idCursor, err := query.ParseCursor(query.EncodeCursor(created[0].ID))
require.NoError(t, err)
_, err = provider.ListEvents(ctx, &query.ListEventsRequest{OrgID: org.ID.UInt64(), Limit: pageSize, Cursor: idCursor})
assert.EqualError(t, err, "invalid cursor: the cursor of another list")
})
t.Run("filter_type", func(t *testing.T) {
expected := filterEvents(newestFirst, func(e *model.Event) bool {
return e.Type == pb.EventType_OrgCreated
})
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Type: pb.EventType_OrgCreated,
})
require.NoError(t, err)
require.Len(t, res.Rows, 10)
assert.Equal(t, eventIDs(expected), eventIDs(res.Rows))
for _, event := range res.Rows {
assert.Equal(t, pb.EventType_OrgCreated, event.Type)
}
requireNewestFirst(t, res.Rows)
})
t.Run("filter_email", func(t *testing.T) {
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Email: owner.Email,
})
require.NoError(t, err)
assert.Equal(t, eventIDs(newestFirst), eventIDs(res.Rows))
empty, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Email: "[email protected]",
})
require.NoError(t, err)
assert.Empty(t, empty.Rows)
})
t.Run("filter_source", func(t *testing.T) {
want := created[7]
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
Source: want.Source.String(),
})
require.NoError(t, err)
require.Len(t, res.Rows, 1)
assert.Equal(t, want.ID.UInt64(), res.Rows[0].ID.UInt64())
})
t.Run("filter_reference_id", func(t *testing.T) {
want := created[7]
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
ReferenceID: want.ReferenceID.UInt64(),
})
require.NoError(t, err)
require.Len(t, res.Rows, 1)
assert.Equal(t, want.ID.UInt64(), res.Rows[0].ID.UInt64())
})
t.Run("filter_time_range", func(t *testing.T) {
after := created[5].CreatedAt.UTC()
before := created[35].CreatedAt.UTC()
expected := filterEvents(newestFirst, func(e *model.Event) bool {
ts := e.CreatedAt.UTC()
return !ts.Before(after) && ts.Before(before)
})
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
After: &after,
Before: &before,
})
require.NoError(t, err)
assert.Equal(t, eventIDs(expected), eventIDs(res.Rows))
requireNewestFirst(t, res.Rows)
for _, event := range res.Rows {
ts := event.CreatedAt.UTC()
assert.False(t, ts.Before(after))
assert.True(t, ts.Before(before))
}
})
t.Run("filter_unknown_org", func(t *testing.T) {
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: provider.NextID().UInt64(),
})
require.NoError(t, err)
assert.Empty(t, res.Rows)
})
}
// Test_EventWithoutMetadata covers events built without metadata, as most
// services emit them: the NOT NULL metadata column gets an empty object
// Test_Event_VisibleProjects lists the org-wide events and the events of
// some projects, as the orgs service does for a member with project grants
// only
func Test_Event_VisibleProjects(t *testing.T) {
owner, org := setupOwnerAndOrg(t, "Test_Event_Projects")
project, err := provider.RegisterProject(ctx, &model.Project{OrgID: org.ID, Name: "Events"})
require.NoError(t, err)
other, err := provider.RegisterProject(ctx, &model.Project{OrgID: org.ID, Name: "Other"})
require.NoError(t, err)
create := func(projectID xdb.ID, title string) uint64 {
evt, err := provider.CreateEvent(ctx, &model.Event{
OrgID: org.ID,
ProjectID: projectID,
Type: pb.EventType_ProjectUpdated,
Title: title,
Email: xdb.NULLString(owner.Email),
Source: xdb.NULLString("test"),
})
require.NoError(t, err)
return evt.ID.UInt64()
}
orgWide := create(xdb.ID(0), "org-wide")
inProject := create(project.ID, "project")
inOther := create(other.ID, "other")
list := func(req *query.ListEventsRequest) []uint64 {
req.OrgID = org.ID.UInt64()
req.Limit = 10
req.Cursor = query.NewCursor(0)
res, err := provider.ListEvents(ctx, req)
require.NoError(t, err)
assert.False(t, res.HasNextPage)
requireNewestFirst(t, res.Rows)
return eventIDs(res.Rows)
}
// no project filter: every event of the org
assert.Equal(t, []uint64{inOther, inProject, orgWide}, list(&query.ListEventsRequest{}))
// the org-wide events and the events of one project
assert.Equal(t, []uint64{inProject, orgWide}, list(&query.ListEventsRequest{ProjectIDs: []uint64{project.ID.UInt64()}}))
// the org-wide events only
assert.Equal(t, []uint64{orgWide}, list(&query.ListEventsRequest{ProjectIDs: []uint64{}}))
// an exact project takes precedence
assert.Equal(t, []uint64{inOther}, list(&query.ListEventsRequest{ProjectID: other.ID.UInt64(), ProjectIDs: []uint64{project.ID.UInt64()}}))
}
func Test_EventWithoutMetadata(t *testing.T) {
owner, org := setupOwnerAndOrg(t, "Test_EventWithoutMetadata")
event, err := provider.CreateEvent(ctx, &model.Event{
OrgID: org.ID,
Type: pb.EventType_OrgUpdated,
Title: "Org updated",
ReferenceID: org.ID,
})
require.NoError(t, err)
assert.Empty(t, event.Metadata)
// TryCreateEvent writes in the background
refID := provider.NextID()
provider.TryCreateEvent(&model.Event{
OrgID: org.ID,
Type: pb.EventType_OrgMemberAdded,
Title: "Member added",
ReferenceID: refID,
Email: xdb.NULLString(owner.Email),
})
var rows model.EventSlice
require.Eventually(t, func() bool {
res, err := provider.ListEvents(ctx, &query.ListEventsRequest{
OrgID: org.ID.UInt64(),
ReferenceID: refID.UInt64(),
})
if err != nil {
return false
}
rows = res.Rows
return len(rows) > 0
}, 5*time.Second, 20*time.Millisecond)
require.Len(t, rows, 1)
assert.Equal(t, pb.EventType_OrgMemberAdded, rows[0].Type)
assert.Equal(t, owner.Email, rows[0].Email.String())
assert.Empty(t, rows[0].Metadata)
}
func reverseEvents(events model.EventSlice) model.EventSlice {
out := make(model.EventSlice, len(events))
for i, event := range events {
out[len(events)-1-i] = event
}
return out
}
func filterEvents(events model.EventSlice, match func(*model.Event) bool) model.EventSlice {
var out model.EventSlice
for _, event := range events {
if match(event) {
out = append(out, event)
}
}
return out
}
func eventIDs(events model.EventSlice) []uint64 {
ids := make([]uint64, len(events))
for i, event := range events {
ids[i] = event.ID.UInt64()
}
return ids
}
func requireNewestFirst(t *testing.T, events model.EventSlice) {
t.Helper()
for i := 0; i < len(events)-1; i++ {
cur, next := events[i], events[i+1]
curAt, nextAt := cur.CreatedAt.UTC(), next.CreatedAt.UTC()
if curAt.Equal(nextAt) {
require.Greater(t, cur.ID.UInt64(), next.ID.UInt64(), "id DESC at index %d", i)
continue
}
require.True(t, curAt.After(nextAt), "created_at DESC at index %d: %s vs %s", i, curAt, nextAt)
}
}