diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 94c45fc..35f1d6c 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -29,13 +29,17 @@ jobs: - name: Run tests with coverage run: go test -v -race -coverprofile=coverage.out -covermode=atomic ./... + - name: Filter generated files from coverage + run: | + grep -v -e "db/sqlc" -e "docs" -e "iatadb/gen" coverage.out > coverage.filtered.out + - name: Display coverage - run: go tool cover -func=coverage.out + run: go tool cover -func=coverage.filtered.out - name: Extract coverage percentage id: coverage run: | - COVERAGE=$(go tool cover -func=coverage.out | grep ^total | awk '{print $3}' | tr -d '%') + COVERAGE=$(go tool cover -func=coverage.filtered.out | grep ^total | awk '{print $3}' | tr -d '%') echo "pct=$COVERAGE" >> $GITHUB_OUTPUT - name: Update coverage badge diff --git a/.gitignore b/.gitignore index 9bf96a5..4677c15 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ notes.md roadmap.md binaries/ +cover.out diff --git a/db/channels_test.go b/db/channels_test.go new file mode 100644 index 0000000..d78a9c3 --- /dev/null +++ b/db/channels_test.go @@ -0,0 +1,306 @@ +package db + +import ( + "context" + "errors" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "github.com/jackc/pgx/v5/pgtype" + "go.uber.org/mock/gomock" +) + +func TestListChannels_Empty(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + ListChannels(gomock.Any(), sqlc.ListChannelsParams{ + Column1: nil, + Column2: "", + Column3: pgtype.Timestamptz{}, + Limit: 11, + }). + Return([]sqlc.Channel{}, nil) + + store := &Store{q: mock} + page, err := store.ListChannels(context.Background(), 10, nil, "", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(page.Items) != 0 { + t.Errorf("expected 0 items, got %d", len(page.Items)) + } + if page.HasMore { + t.Error("expected HasMore false") + } +} + +func TestListChannels_Pagination(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + isHashtag := false + keyKnown := true + lastSeen := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + + // return limit+1 rows to trigger HasMore + rows := make([]sqlc.Channel, 3) + for i := range rows { + rows[i] = sqlc.Channel{ + ID: int32(i + 1), + ChannelHash: []byte{0xab, 0xcd}, + LastSeen: lastSeen, + IsHashtag: &isHashtag, + KeyKnown: &keyKnown, + } + } + + mock.EXPECT(). + ListChannels(gomock.Any(), sqlc.ListChannelsParams{ + Column1: nil, + Column2: "", + Column3: pgtype.Timestamptz{}, + Limit: 3, // limit+1 + }). + Return(rows, nil) + + store := &Store{q: mock} + page, err := store.ListChannels(context.Background(), 2, nil, "", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(page.Items) != 2 { + t.Errorf("expected 2 items, got %d", len(page.Items)) + } + if !page.HasMore { + t.Error("expected HasMore true") + } + if page.NextCursor == nil { + t.Error("expected NextCursor to be set") + } +} + +func TestListChannels_DBError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + ListChannels(gomock.Any(), gomock.Any()). + Return(nil, errors.New("db error")) + + store := &Store{q: mock} + _, err := store.ListChannels(context.Background(), 10, nil, "", 0) + if err == nil { + t.Fatal("expected error, got nil") + } +} + +func TestGetChannel_Basic(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + isHashtag := false + keyKnown := true + msgCount := int64(5) + lastSeen := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + + mock.EXPECT(). + GetChannelByID(gomock.Any(), int32(1)). + Return(sqlc.Channel{ + ID: 1, + ChannelHash: []byte{0xab, 0xcd}, + LastSeen: lastSeen, + IsHashtag: &isHashtag, + KeyKnown: &keyKnown, + MessageCount: &msgCount, + }, nil) + + store := &Store{q: mock} + ch, err := store.GetChannel(context.Background(), 1) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if ch.ID != 1 { + t.Errorf("expected ID 1, got %d", ch.ID) + } + if ch.ChannelHash != "abcd" { + t.Errorf("expected ChannelHash abcd, got %s", ch.ChannelHash) + } + if ch.MessageCount != 5 { + t.Errorf("expected MessageCount 5, got %d", ch.MessageCount) + } + if ch.KeyFingerprint != nil { + t.Errorf("expected nil KeyFingerprint for non-hashtag channel") + } +} + +func TestGetChannel_HashtagWithFingerprint(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + isHashtag := true + keyKnown := true + fp := []byte{0xde, 0xad, 0xbe, 0xef} + lastSeen := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + + mock.EXPECT(). + GetChannelByID(gomock.Any(), int32(2)). + Return(sqlc.Channel{ + ID: 2, + ChannelHash: []byte{0x01, 0x02}, + LastSeen: lastSeen, + IsHashtag: &isHashtag, + KeyKnown: &keyKnown, + KeyFingerprint: fp, + }, nil) + + store := &Store{q: mock} + ch, err := store.GetChannel(context.Background(), 2) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if ch.KeyFingerprint == nil { + t.Fatal("expected KeyFingerprint to be set for hashtag channel") + } + if *ch.KeyFingerprint != "deadbeef" { + t.Errorf("expected KeyFingerprint deadbeef, got %s", *ch.KeyFingerprint) + } +} + +func TestGetChannel_DBError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetChannelByID(gomock.Any(), int32(1)). + Return(sqlc.Channel{}, errors.New("db error")) + + store := &Store{q: mock} + _, err := store.GetChannel(context.Background(), 1) + if err == nil { + t.Fatal("expected error, got nil") + } +} + +func TestListChannelMessages_AllChannels(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + sentAt := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + senderName := "Alice" + content := "hello" + + mock.EXPECT(). + ListAllChannelMessages(gomock.Any(), sqlc.ListAllChannelMessagesParams{ + Column1: pgtype.Timestamptz{}, + Column2: "YVR", + Column3: "", + Column4: int64(0), + Limit: 3, + }). + Return([]sqlc.ListAllChannelMessagesRow{ + { + ID: 1, + PacketHashHex: "deadbeef", + ChannelHash: []byte{0xab}, + SenderName: &senderName, + Content: &content, + SentAt: sentAt, + ObservationCount: 2, + }, + { + ID: 2, + PacketHashHex: "cafebabe", + ChannelHash: []byte{0xcd}, + SenderName: &senderName, + Content: &content, + SentAt: sentAt, + ObservationCount: 1, + }, + { + ID: 3, + PacketHashHex: "deadcafe", + ChannelHash: []byte{0xef}, + SenderName: &senderName, + Content: &content, + SentAt: sentAt, + ObservationCount: 1, + }, + }, nil) + + store := &Store{q: mock} + page, err := store.ListChannelMessages(context.Background(), nil, time.Time{}, 2, []string{"YVR"}, "", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(page.Items) != 2 { + t.Errorf("expected 2 items, got %d", len(page.Items)) + } + if !page.HasMore { + t.Error("expected HasMore true") + } + if page.NextCursor == nil { + t.Error("expected NextCursor to be set") + } +} + +func TestListChannelMessages_ByChannelID(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + channelID := int32(1) + sentAt := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + senderName := "Bob" + content := "world" + + mock.EXPECT(). + ListChannelMessages(gomock.Any(), sqlc.ListChannelMessagesParams{ + ChannelID: channelID, + Column2: pgtype.Timestamptz{}, + Column3: "YVR", + Column4: "", + Column5: int64(0), + Limit: 3, + }). + Return([]sqlc.ListChannelMessagesRow{ + { + ID: 1, + PacketHashHex: "deadbeef", + ChannelHash: []byte{0xab}, + SenderName: &senderName, + Content: &content, + SentAt: sentAt, + ObservationCount: 1, + }, + }, nil) + + store := &Store{q: mock} + page, err := store.ListChannelMessages(context.Background(), &channelID, time.Time{}, 2, []string{"YVR"}, "", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(page.Items) != 1 { + t.Errorf("expected 1 item, got %d", len(page.Items)) + } + if page.HasMore { + t.Error("expected HasMore false") + } +} + +func TestListChannelMessages_DBError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + ListAllChannelMessages(gomock.Any(), gomock.Any()). + Return(nil, errors.New("db error")) + + store := &Store{q: mock} + _, err := store.ListChannelMessages(context.Background(), nil, time.Time{}, 10, nil, "", 0) + if err == nil { + t.Fatal("expected error, got nil") + } +} diff --git a/db/config_test.go b/db/config_test.go new file mode 100644 index 0000000..7c3079d --- /dev/null +++ b/db/config_test.go @@ -0,0 +1,148 @@ +package db + +import ( + "context" + "errors" + "testing" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "go.uber.org/mock/gomock" +) + +func TestListIATAs(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + lat := 49.1967 + lng := -123.1815 + name := "Vancouver" + + mock.EXPECT(). + ListIATAs(gomock.Any()). + Return([]sqlc.IataCode{ + {Iata: "YVR", DisplayName: &name, ApproxLat: &lat, ApproxLng: &lng}, + }, nil) + + store := &Store{q: mock} + iatas, err := store.ListIATAs(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(iatas) != 1 { + t.Fatalf("expected 1 iata, got %d", len(iatas)) + } + if iatas[0].IATA != "YVR" { + t.Errorf("expected IATA YVR, got %s", iatas[0].IATA) + } + if *iatas[0].Lat != lat { + t.Errorf("expected Lat %f, got %f", lat, *iatas[0].Lat) + } +} + +func TestGetIATA(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + lat := 49.1967 + lng := -123.1815 + name := "Vancouver" + + mock.EXPECT(). + GetIATA(gomock.Any(), "YVR"). + Return(sqlc.IataCode{Iata: "YVR", DisplayName: &name, ApproxLat: &lat, ApproxLng: &lng}, nil) + + store := &Store{q: mock} + iata, err := store.GetIATA(context.Background(), "YVR") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if iata.IATA != "YVR" { + t.Errorf("expected YVR, got %s", iata.IATA) + } + if *iata.Lng != lng { + t.Errorf("expected Lng %f, got %f", lng, *iata.Lng) + } +} + +func TestGetRegion_WithZoomLevel(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + zoom := int32(10) + + mock.EXPECT(). + GetRegion(gomock.Any(), int32(1)). + Return(sqlc.GetRegionRow{ + ID: 1, + Slug: "bc", + Name: "British Columbia", + ZoomLevel: &zoom, + }, nil) + + mock.EXPECT(). + GetRegionIATAs(gomock.Any(), int32(1)). + Return([]string{"YVR", "YYJ"}, nil) + + store := &Store{q: mock} + region, err := store.GetRegion(context.Background(), 1) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if region.Slug != "bc" { + t.Errorf("expected slug bc, got %s", region.Slug) + } + if region.ZoomLevel == nil { + t.Fatal("expected ZoomLevel to be set") + } + if *region.ZoomLevel != 10 { + t.Errorf("expected ZoomLevel 10, got %d", *region.ZoomLevel) + } + if len(region.IATAs) != 2 { + t.Errorf("expected 2 IATAs, got %d", len(region.IATAs)) + } +} + +func TestGetRegion_IATAError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetRegion(gomock.Any(), int32(1)). + Return(sqlc.GetRegionRow{ID: 1, Slug: "bc", Name: "British Columbia"}, nil) + + mock.EXPECT(). + GetRegionIATAs(gomock.Any(), int32(1)). + Return(nil, errors.New("db error")) + + store := &Store{q: mock} + _, err := store.GetRegion(context.Background(), 1) + if err == nil { + t.Fatal("expected error, got nil") + } +} + +func TestGetRegionBySlug(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetRegionBySlug(gomock.Any(), "bc"). + Return(sqlc.GetRegionBySlugRow{ID: 1, Slug: "bc", Name: "British Columbia"}, nil) + + mock.EXPECT(). + GetRegionIATAs(gomock.Any(), int32(1)). + Return([]string{"YVR"}, nil) + + store := &Store{q: mock} + region, err := store.GetRegionBySlug(context.Background(), "bc") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if region.Slug != "bc" { + t.Errorf("expected slug bc, got %s", region.Slug) + } + if len(region.IATAs) != 1 { + t.Errorf("expected 1 IATA, got %d", len(region.IATAs)) + } +} diff --git a/db/scopes_test.go b/db/scopes_test.go new file mode 100644 index 0000000..abd699b --- /dev/null +++ b/db/scopes_test.go @@ -0,0 +1,95 @@ +package db + +import ( + "bytes" + "context" + "testing" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "go.uber.org/mock/gomock" +) + +func TestGetTransportScopes(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetTransportScopes(gomock.Any()). + Return([]sqlc.GetTransportScopesRow{ + { + Name: "default", + TransportKey: []byte{0x01, 0x02}, + KeyFingerprint: []byte{0xde, 0xad}, + }, + }, nil) + + store := &Store{q: mock} + entries, err := store.GetTransportScopes(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(entries) != 1 { + t.Fatalf("expected 1 entry, got %d", len(entries)) + } + if entries[0].Name != "default" { + t.Errorf("expected Name default, got %s", entries[0].Name) + } + if !bytes.Equal(entries[0].TransportKey, []byte{0x01, 0x02}) { + t.Errorf("expected TransportKey [0x01 0x02], got %v", entries[0].TransportKey) + } +} + +func TestGetScopesByIATAs(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetScopesByIATAs(gomock.Any(), "YVR,YYJ"). + Return([]sqlc.GetScopesByIATAsRow{ + {Name: "default", ObserverCount: 3, NodeCount: 10, IataCount: 2}, + }, nil) + + store := &Store{q: mock} + items, err := store.GetScopesByIATAs(context.Background(), []string{"YVR", "YYJ"}) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 1 { + t.Fatalf("expected 1 item, got %d", len(items)) + } + if items[0].IATACount != 2 { + t.Errorf("expected IATACount 2, got %d", items[0].IATACount) + } +} + +func TestGetScopeByName(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetScopeByName(gomock.Any(), "default"). + Return(sqlc.GetScopeByNameRow{ + Name: "default", + PacketCount: 100, + ObserverCount: 5, + NodeCount: 20, + IataCount: 3, + Iatas: []string{"YVR", "YYJ", "YYC"}, + }, nil) + + store := &Store{q: mock} + detail, err := store.GetScopeByName(context.Background(), "default") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if detail.Name != "default" { + t.Errorf("expected Name default, got %s", detail.Name) + } + if len(detail.IATAs) != 3 { + t.Errorf("expected 3 IATAs, got %d", len(detail.IATAs)) + } + if detail.PacketCount != 100 { + t.Errorf("expected PacketCount 100, got %d", detail.PacketCount) + } +} diff --git a/db/sqlc/mock/querier.go b/db/sqlc/mock/querier.go new file mode 100644 index 0000000..3f80676 --- /dev/null +++ b/db/sqlc/mock/querier.go @@ -0,0 +1,1267 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: db/sqlc/querier.go +// +// Generated by this command: +// +// mockgen -source=db/sqlc/querier.go -destination=db/sqlc/mock/querier.go -package=mockdb +// + +// Package mockdb is a generated GoMock package. +package mockdb + +import ( + context "context" + reflect "reflect" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + uuid "github.com/google/uuid" + pgtype "github.com/jackc/pgx/v5/pgtype" + gomock "go.uber.org/mock/gomock" +) + +// MockQuerier is a mock of Querier interface. +type MockQuerier struct { + ctrl *gomock.Controller + recorder *MockQuerierMockRecorder + isgomock struct{} +} + +// MockQuerierMockRecorder is the mock recorder for MockQuerier. +type MockQuerierMockRecorder struct { + mock *MockQuerier +} + +// NewMockQuerier creates a new mock instance. +func NewMockQuerier(ctrl *gomock.Controller) *MockQuerier { + mock := &MockQuerier{ctrl: ctrl} + mock.recorder = &MockQuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockQuerier) EXPECT() *MockQuerierMockRecorder { + return m.recorder +} + +// DeleteOldPackets mocks base method. +func (m *MockQuerier) DeleteOldPackets(ctx context.Context, lastHeardAt pgtype.Timestamptz) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOldPackets", ctx, lastHeardAt) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteOldPackets indicates an expected call of DeleteOldPackets. +func (mr *MockQuerierMockRecorder) DeleteOldPackets(ctx, lastHeardAt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldPackets", reflect.TypeOf((*MockQuerier)(nil).DeleteOldPackets), ctx, lastHeardAt) +} + +// DeleteOldTelemetry mocks base method. +func (m *MockQuerier) DeleteOldTelemetry(ctx context.Context, reportedAt pgtype.Timestamptz) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOldTelemetry", ctx, reportedAt) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteOldTelemetry indicates an expected call of DeleteOldTelemetry. +func (mr *MockQuerierMockRecorder) DeleteOldTelemetry(ctx, reportedAt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldTelemetry", reflect.TypeOf((*MockQuerier)(nil).DeleteOldTelemetry), ctx, reportedAt) +} + +// GetChannelByID mocks base method. +func (m *MockQuerier) GetChannelByID(ctx context.Context, id int32) (sqlc.Channel, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetChannelByID", ctx, id) + ret0, _ := ret[0].(sqlc.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetChannelByID indicates an expected call of GetChannelByID. +func (mr *MockQuerierMockRecorder) GetChannelByID(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChannelByID", reflect.TypeOf((*MockQuerier)(nil).GetChannelByID), ctx, id) +} + +// GetCrossIATANeighbors mocks base method. +func (m *MockQuerier) GetCrossIATANeighbors(ctx context.Context, arg sqlc.GetCrossIATANeighborsParams) ([]sqlc.GetCrossIATANeighborsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCrossIATANeighbors", ctx, arg) + ret0, _ := ret[0].([]sqlc.GetCrossIATANeighborsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCrossIATANeighbors indicates an expected call of GetCrossIATANeighbors. +func (mr *MockQuerierMockRecorder) GetCrossIATANeighbors(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCrossIATANeighbors", reflect.TypeOf((*MockQuerier)(nil).GetCrossIATANeighbors), ctx, arg) +} + +// GetHourlyStats mocks base method. +func (m *MockQuerier) GetHourlyStats(ctx context.Context, arg sqlc.GetHourlyStatsParams) ([]sqlc.MvHourlyIataStat, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHourlyStats", ctx, arg) + ret0, _ := ret[0].([]sqlc.MvHourlyIataStat) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHourlyStats indicates an expected call of GetHourlyStats. +func (mr *MockQuerierMockRecorder) GetHourlyStats(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHourlyStats", reflect.TypeOf((*MockQuerier)(nil).GetHourlyStats), ctx, arg) +} + +// GetIATA mocks base method. +func (m *MockQuerier) GetIATA(ctx context.Context, iata string) (sqlc.IataCode, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIATA", ctx, iata) + ret0, _ := ret[0].(sqlc.IataCode) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIATA indicates an expected call of GetIATA. +func (mr *MockQuerierMockRecorder) GetIATA(ctx, iata any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIATA", reflect.TypeOf((*MockQuerier)(nil).GetIATA), ctx, iata) +} + +// GetKnownRoutesByNode mocks base method. +func (m *MockQuerier) GetKnownRoutesByNode(ctx context.Context, arg sqlc.GetKnownRoutesByNodeParams) ([]sqlc.KnownRoute, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetKnownRoutesByNode", ctx, arg) + ret0, _ := ret[0].([]sqlc.KnownRoute) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetKnownRoutesByNode indicates an expected call of GetKnownRoutesByNode. +func (mr *MockQuerierMockRecorder) GetKnownRoutesByNode(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKnownRoutesByNode", reflect.TypeOf((*MockQuerier)(nil).GetKnownRoutesByNode), ctx, arg) +} + +// GetNodeByID mocks base method. +func (m *MockQuerier) GetNodeByID(ctx context.Context, id uuid.UUID) (sqlc.GetNodeByIDRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNodeByID", ctx, id) + ret0, _ := ret[0].(sqlc.GetNodeByIDRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNodeByID indicates an expected call of GetNodeByID. +func (mr *MockQuerierMockRecorder) GetNodeByID(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeByID", reflect.TypeOf((*MockQuerier)(nil).GetNodeByID), ctx, id) +} + +// GetNodeNeighbors mocks base method. +func (m *MockQuerier) GetNodeNeighbors(ctx context.Context, nodeID uuid.UUID) ([]sqlc.GetNodeNeighborsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNodeNeighbors", ctx, nodeID) + ret0, _ := ret[0].([]sqlc.GetNodeNeighborsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNodeNeighbors indicates an expected call of GetNodeNeighbors. +func (mr *MockQuerierMockRecorder) GetNodeNeighbors(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeNeighbors", reflect.TypeOf((*MockQuerier)(nil).GetNodeNeighbors), ctx, nodeID) +} + +// GetNodesByIDs mocks base method. +func (m *MockQuerier) GetNodesByIDs(ctx context.Context, dollar_1 []uuid.UUID) ([]sqlc.GetNodesByIDsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNodesByIDs", ctx, dollar_1) + ret0, _ := ret[0].([]sqlc.GetNodesByIDsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNodesByIDs indicates an expected call of GetNodesByIDs. +func (mr *MockQuerierMockRecorder) GetNodesByIDs(ctx, dollar_1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodesByIDs", reflect.TypeOf((*MockQuerier)(nil).GetNodesByIDs), ctx, dollar_1) +} + +// GetObserverBrokers mocks base method. +func (m *MockQuerier) GetObserverBrokers(ctx context.Context, observerID uuid.UUID) ([]sqlc.GetObserverBrokersRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverBrokers", ctx, observerID) + ret0, _ := ret[0].([]sqlc.GetObserverBrokersRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverBrokers indicates an expected call of GetObserverBrokers. +func (mr *MockQuerierMockRecorder) GetObserverBrokers(ctx, observerID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverBrokers", reflect.TypeOf((*MockQuerier)(nil).GetObserverBrokers), ctx, observerID) +} + +// GetObserverByID mocks base method. +func (m *MockQuerier) GetObserverByID(ctx context.Context, id uuid.UUID) (sqlc.Observer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverByID", ctx, id) + ret0, _ := ret[0].(sqlc.Observer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverByID indicates an expected call of GetObserverByID. +func (mr *MockQuerierMockRecorder) GetObserverByID(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverByID", reflect.TypeOf((*MockQuerier)(nil).GetObserverByID), ctx, id) +} + +// GetObserverByPubkey mocks base method. +func (m *MockQuerier) GetObserverByPubkey(ctx context.Context, publicKey []byte) (sqlc.Observer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverByPubkey", ctx, publicKey) + ret0, _ := ret[0].(sqlc.Observer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverByPubkey indicates an expected call of GetObserverByPubkey. +func (mr *MockQuerierMockRecorder) GetObserverByPubkey(ctx, publicKey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverByPubkey", reflect.TypeOf((*MockQuerier)(nil).GetObserverByPubkey), ctx, publicKey) +} + +// GetObserverLastIATA mocks base method. +func (m *MockQuerier) GetObserverLastIATA(ctx context.Context, observerID uuid.UUID) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverLastIATA", ctx, observerID) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverLastIATA indicates an expected call of GetObserverLastIATA. +func (mr *MockQuerierMockRecorder) GetObserverLastIATA(ctx, observerID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverLastIATA", reflect.TypeOf((*MockQuerier)(nil).GetObserverLastIATA), ctx, observerID) +} + +// GetObserverRadio mocks base method. +func (m *MockQuerier) GetObserverRadio(ctx context.Context, id uuid.UUID) (sqlc.GetObserverRadioRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverRadio", ctx, id) + ret0, _ := ret[0].(sqlc.GetObserverRadioRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverRadio indicates an expected call of GetObserverRadio. +func (mr *MockQuerierMockRecorder) GetObserverRadio(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverRadio", reflect.TypeOf((*MockQuerier)(nil).GetObserverRadio), ctx, id) +} + +// GetObserverScopes mocks base method. +func (m *MockQuerier) GetObserverScopes(ctx context.Context, observerID uuid.UUID) ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverScopes", ctx, observerID) + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverScopes indicates an expected call of GetObserverScopes. +func (mr *MockQuerierMockRecorder) GetObserverScopes(ctx, observerID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverScopes", reflect.TypeOf((*MockQuerier)(nil).GetObserverScopes), ctx, observerID) +} + +// GetObserverTelemetry mocks base method. +func (m *MockQuerier) GetObserverTelemetry(ctx context.Context, arg sqlc.GetObserverTelemetryParams) ([]sqlc.GetObserverTelemetryRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverTelemetry", ctx, arg) + ret0, _ := ret[0].([]sqlc.GetObserverTelemetryRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverTelemetry indicates an expected call of GetObserverTelemetry. +func (mr *MockQuerierMockRecorder) GetObserverTelemetry(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverTelemetry", reflect.TypeOf((*MockQuerier)(nil).GetObserverTelemetry), ctx, arg) +} + +// GetObserverTelemetryBucketed mocks base method. +func (m *MockQuerier) GetObserverTelemetryBucketed(ctx context.Context, arg sqlc.GetObserverTelemetryBucketedParams) ([]sqlc.GetObserverTelemetryBucketedRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetObserverTelemetryBucketed", ctx, arg) + ret0, _ := ret[0].([]sqlc.GetObserverTelemetryBucketedRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObserverTelemetryBucketed indicates an expected call of GetObserverTelemetryBucketed. +func (mr *MockQuerierMockRecorder) GetObserverTelemetryBucketed(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverTelemetryBucketed", reflect.TypeOf((*MockQuerier)(nil).GetObserverTelemetryBucketed), ctx, arg) +} + +// GetPacketByHash mocks base method. +func (m *MockQuerier) GetPacketByHash(ctx context.Context, packetHash []byte) (sqlc.GetPacketByHashRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPacketByHash", ctx, packetHash) + ret0, _ := ret[0].(sqlc.GetPacketByHashRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPacketByHash indicates an expected call of GetPacketByHash. +func (mr *MockQuerierMockRecorder) GetPacketByHash(ctx, packetHash any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketByHash", reflect.TypeOf((*MockQuerier)(nil).GetPacketByHash), ctx, packetHash) +} + +// GetPacketObservationCount mocks base method. +func (m *MockQuerier) GetPacketObservationCount(ctx context.Context, packetHash []byte) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPacketObservationCount", ctx, packetHash) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPacketObservationCount indicates an expected call of GetPacketObservationCount. +func (mr *MockQuerierMockRecorder) GetPacketObservationCount(ctx, packetHash any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketObservationCount", reflect.TypeOf((*MockQuerier)(nil).GetPacketObservationCount), ctx, packetHash) +} + +// GetPacketsByTraceTag mocks base method. +func (m *MockQuerier) GetPacketsByTraceTag(ctx context.Context, decode string) ([]sqlc.GetPacketsByTraceTagRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPacketsByTraceTag", ctx, decode) + ret0, _ := ret[0].([]sqlc.GetPacketsByTraceTagRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPacketsByTraceTag indicates an expected call of GetPacketsByTraceTag. +func (mr *MockQuerierMockRecorder) GetPacketsByTraceTag(ctx, decode any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketsByTraceTag", reflect.TypeOf((*MockQuerier)(nil).GetPacketsByTraceTag), ctx, decode) +} + +// GetRadioPresets mocks base method. +func (m *MockQuerier) GetRadioPresets(ctx context.Context, arg sqlc.GetRadioPresetsParams) ([]sqlc.MvRadioPreset, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRadioPresets", ctx, arg) + ret0, _ := ret[0].([]sqlc.MvRadioPreset) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRadioPresets indicates an expected call of GetRadioPresets. +func (mr *MockQuerierMockRecorder) GetRadioPresets(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRadioPresets", reflect.TypeOf((*MockQuerier)(nil).GetRadioPresets), ctx, arg) +} + +// GetRegion mocks base method. +func (m *MockQuerier) GetRegion(ctx context.Context, id int32) (sqlc.GetRegionRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRegion", ctx, id) + ret0, _ := ret[0].(sqlc.GetRegionRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRegion indicates an expected call of GetRegion. +func (mr *MockQuerierMockRecorder) GetRegion(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegion", reflect.TypeOf((*MockQuerier)(nil).GetRegion), ctx, id) +} + +// GetRegionBySlug mocks base method. +func (m *MockQuerier) GetRegionBySlug(ctx context.Context, slug string) (sqlc.GetRegionBySlugRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRegionBySlug", ctx, slug) + ret0, _ := ret[0].(sqlc.GetRegionBySlugRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRegionBySlug indicates an expected call of GetRegionBySlug. +func (mr *MockQuerierMockRecorder) GetRegionBySlug(ctx, slug any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionBySlug", reflect.TypeOf((*MockQuerier)(nil).GetRegionBySlug), ctx, slug) +} + +// GetRegionIATAs mocks base method. +func (m *MockQuerier) GetRegionIATAs(ctx context.Context, regionID int32) ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRegionIATAs", ctx, regionID) + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRegionIATAs indicates an expected call of GetRegionIATAs. +func (mr *MockQuerierMockRecorder) GetRegionIATAs(ctx, regionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionIATAs", reflect.TypeOf((*MockQuerier)(nil).GetRegionIATAs), ctx, regionID) +} + +// GetScopeByName mocks base method. +func (m *MockQuerier) GetScopeByName(ctx context.Context, name string) (sqlc.GetScopeByNameRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetScopeByName", ctx, name) + ret0, _ := ret[0].(sqlc.GetScopeByNameRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetScopeByName indicates an expected call of GetScopeByName. +func (mr *MockQuerierMockRecorder) GetScopeByName(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeByName", reflect.TypeOf((*MockQuerier)(nil).GetScopeByName), ctx, name) +} + +// GetScopeNames mocks base method. +func (m *MockQuerier) GetScopeNames(ctx context.Context) ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetScopeNames", ctx) + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetScopeNames indicates an expected call of GetScopeNames. +func (mr *MockQuerierMockRecorder) GetScopeNames(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeNames", reflect.TypeOf((*MockQuerier)(nil).GetScopeNames), ctx) +} + +// GetScopeStats mocks base method. +func (m *MockQuerier) GetScopeStats(ctx context.Context) ([]sqlc.GetScopeStatsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetScopeStats", ctx) + ret0, _ := ret[0].([]sqlc.GetScopeStatsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetScopeStats indicates an expected call of GetScopeStats. +func (mr *MockQuerierMockRecorder) GetScopeStats(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeStats", reflect.TypeOf((*MockQuerier)(nil).GetScopeStats), ctx) +} + +// GetScopesByIATAs mocks base method. +func (m *MockQuerier) GetScopesByIATAs(ctx context.Context, dollar_1 string) ([]sqlc.GetScopesByIATAsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetScopesByIATAs", ctx, dollar_1) + ret0, _ := ret[0].([]sqlc.GetScopesByIATAsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetScopesByIATAs indicates an expected call of GetScopesByIATAs. +func (mr *MockQuerierMockRecorder) GetScopesByIATAs(ctx, dollar_1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopesByIATAs", reflect.TypeOf((*MockQuerier)(nil).GetScopesByIATAs), ctx, dollar_1) +} + +// GetStatsNodeTypes mocks base method. +func (m *MockQuerier) GetStatsNodeTypes(ctx context.Context, dollar_1 string) ([]sqlc.GetStatsNodeTypesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStatsNodeTypes", ctx, dollar_1) + ret0, _ := ret[0].([]sqlc.GetStatsNodeTypesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStatsNodeTypes indicates an expected call of GetStatsNodeTypes. +func (mr *MockQuerierMockRecorder) GetStatsNodeTypes(ctx, dollar_1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsNodeTypes", reflect.TypeOf((*MockQuerier)(nil).GetStatsNodeTypes), ctx, dollar_1) +} + +// GetStatsOverview mocks base method. +func (m *MockQuerier) GetStatsOverview(ctx context.Context, dollar_1 string) (sqlc.GetStatsOverviewRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStatsOverview", ctx, dollar_1) + ret0, _ := ret[0].(sqlc.GetStatsOverviewRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStatsOverview indicates an expected call of GetStatsOverview. +func (mr *MockQuerierMockRecorder) GetStatsOverview(ctx, dollar_1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsOverview", reflect.TypeOf((*MockQuerier)(nil).GetStatsOverview), ctx, dollar_1) +} + +// GetStatsPayloadBreakdown mocks base method. +func (m *MockQuerier) GetStatsPayloadBreakdown(ctx context.Context, arg sqlc.GetStatsPayloadBreakdownParams) ([]sqlc.GetStatsPayloadBreakdownRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStatsPayloadBreakdown", ctx, arg) + ret0, _ := ret[0].([]sqlc.GetStatsPayloadBreakdownRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStatsPayloadBreakdown indicates an expected call of GetStatsPayloadBreakdown. +func (mr *MockQuerierMockRecorder) GetStatsPayloadBreakdown(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsPayloadBreakdown", reflect.TypeOf((*MockQuerier)(nil).GetStatsPayloadBreakdown), ctx, arg) +} + +// GetStatsTopObservers mocks base method. +func (m *MockQuerier) GetStatsTopObservers(ctx context.Context, arg sqlc.GetStatsTopObserversParams) ([]sqlc.GetStatsTopObserversRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStatsTopObservers", ctx, arg) + ret0, _ := ret[0].([]sqlc.GetStatsTopObserversRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStatsTopObservers indicates an expected call of GetStatsTopObservers. +func (mr *MockQuerierMockRecorder) GetStatsTopObservers(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsTopObservers", reflect.TypeOf((*MockQuerier)(nil).GetStatsTopObservers), ctx, arg) +} + +// GetTopNodes mocks base method. +func (m *MockQuerier) GetTopNodes(ctx context.Context, arg sqlc.GetTopNodesParams) ([]sqlc.MvTopNodesByIatum, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTopNodes", ctx, arg) + ret0, _ := ret[0].([]sqlc.MvTopNodesByIatum) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTopNodes indicates an expected call of GetTopNodes. +func (mr *MockQuerierMockRecorder) GetTopNodes(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopNodes", reflect.TypeOf((*MockQuerier)(nil).GetTopNodes), ctx, arg) +} + +// GetTransportScopeByName mocks base method. +func (m *MockQuerier) GetTransportScopeByName(ctx context.Context, name string) (int32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransportScopeByName", ctx, name) + ret0, _ := ret[0].(int32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransportScopeByName indicates an expected call of GetTransportScopeByName. +func (mr *MockQuerierMockRecorder) GetTransportScopeByName(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransportScopeByName", reflect.TypeOf((*MockQuerier)(nil).GetTransportScopeByName), ctx, name) +} + +// GetTransportScopes mocks base method. +func (m *MockQuerier) GetTransportScopes(ctx context.Context) ([]sqlc.GetTransportScopesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransportScopes", ctx) + ret0, _ := ret[0].([]sqlc.GetTransportScopesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransportScopes indicates an expected call of GetTransportScopes. +func (mr *MockQuerierMockRecorder) GetTransportScopes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransportScopes", reflect.TypeOf((*MockQuerier)(nil).GetTransportScopes), ctx) +} + +// InsertChannelMessage mocks base method. +func (m *MockQuerier) InsertChannelMessage(ctx context.Context, arg sqlc.InsertChannelMessageParams) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertChannelMessage", ctx, arg) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InsertChannelMessage indicates an expected call of InsertChannelMessage. +func (mr *MockQuerierMockRecorder) InsertChannelMessage(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChannelMessage", reflect.TypeOf((*MockQuerier)(nil).InsertChannelMessage), ctx, arg) +} + +// InsertObservation mocks base method. +func (m *MockQuerier) InsertObservation(ctx context.Context, arg sqlc.InsertObservationParams) (sqlc.PacketObservation, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertObservation", ctx, arg) + ret0, _ := ret[0].(sqlc.PacketObservation) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InsertObservation indicates an expected call of InsertObservation. +func (mr *MockQuerierMockRecorder) InsertObservation(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertObservation", reflect.TypeOf((*MockQuerier)(nil).InsertObservation), ctx, arg) +} + +// InsertObserverTelemetry mocks base method. +func (m *MockQuerier) InsertObserverTelemetry(ctx context.Context, arg sqlc.InsertObserverTelemetryParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InsertObserverTelemetry", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// InsertObserverTelemetry indicates an expected call of InsertObserverTelemetry. +func (mr *MockQuerierMockRecorder) InsertObserverTelemetry(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertObserverTelemetry", reflect.TypeOf((*MockQuerier)(nil).InsertObserverTelemetry), ctx, arg) +} + +// ListAllChannelMessages mocks base method. +func (m *MockQuerier) ListAllChannelMessages(ctx context.Context, arg sqlc.ListAllChannelMessagesParams) ([]sqlc.ListAllChannelMessagesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAllChannelMessages", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListAllChannelMessagesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAllChannelMessages indicates an expected call of ListAllChannelMessages. +func (mr *MockQuerierMockRecorder) ListAllChannelMessages(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessages", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessages), ctx, arg) +} + +// ListChannelMessages mocks base method. +func (m *MockQuerier) ListChannelMessages(ctx context.Context, arg sqlc.ListChannelMessagesParams) ([]sqlc.ListChannelMessagesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessages", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListChannelMessagesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessages indicates an expected call of ListChannelMessages. +func (mr *MockQuerierMockRecorder) ListChannelMessages(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessages", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessages), ctx, arg) +} + +// ListChannelMessagesByHash mocks base method. +func (m *MockQuerier) ListChannelMessagesByHash(ctx context.Context, arg sqlc.ListChannelMessagesByHashParams) ([]sqlc.ListChannelMessagesByHashRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannelMessagesByHash", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListChannelMessagesByHashRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannelMessagesByHash indicates an expected call of ListChannelMessagesByHash. +func (mr *MockQuerierMockRecorder) ListChannelMessagesByHash(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesByHash", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesByHash), ctx, arg) +} + +// ListChannels mocks base method. +func (m *MockQuerier) ListChannels(ctx context.Context, arg sqlc.ListChannelsParams) ([]sqlc.Channel, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListChannels", ctx, arg) + ret0, _ := ret[0].([]sqlc.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListChannels indicates an expected call of ListChannels. +func (mr *MockQuerierMockRecorder) ListChannels(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannels", reflect.TypeOf((*MockQuerier)(nil).ListChannels), ctx, arg) +} + +// ListIATAs mocks base method. +func (m *MockQuerier) ListIATAs(ctx context.Context) ([]sqlc.IataCode, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListIATAs", ctx) + ret0, _ := ret[0].([]sqlc.IataCode) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListIATAs indicates an expected call of ListIATAs. +func (mr *MockQuerierMockRecorder) ListIATAs(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIATAs", reflect.TypeOf((*MockQuerier)(nil).ListIATAs), ctx) +} + +// ListKnownRoutes mocks base method. +func (m *MockQuerier) ListKnownRoutes(ctx context.Context, arg sqlc.ListKnownRoutesParams) ([]sqlc.KnownRoute, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKnownRoutes", ctx, arg) + ret0, _ := ret[0].([]sqlc.KnownRoute) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKnownRoutes indicates an expected call of ListKnownRoutes. +func (mr *MockQuerierMockRecorder) ListKnownRoutes(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKnownRoutes", reflect.TypeOf((*MockQuerier)(nil).ListKnownRoutes), ctx, arg) +} + +// ListMessagesAfterID mocks base method. +func (m *MockQuerier) ListMessagesAfterID(ctx context.Context, arg sqlc.ListMessagesAfterIDParams) ([]sqlc.ListMessagesAfterIDRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListMessagesAfterID", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListMessagesAfterIDRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListMessagesAfterID indicates an expected call of ListMessagesAfterID. +func (mr *MockQuerierMockRecorder) ListMessagesAfterID(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessagesAfterID", reflect.TypeOf((*MockQuerier)(nil).ListMessagesAfterID), ctx, arg) +} + +// ListNodeObservations mocks base method. +func (m *MockQuerier) ListNodeObservations(ctx context.Context, arg sqlc.ListNodeObservationsParams) ([]sqlc.ListNodeObservationsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNodeObservations", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListNodeObservationsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListNodeObservations indicates an expected call of ListNodeObservations. +func (mr *MockQuerierMockRecorder) ListNodeObservations(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodeObservations", reflect.TypeOf((*MockQuerier)(nil).ListNodeObservations), ctx, arg) +} + +// ListNodes mocks base method. +func (m *MockQuerier) ListNodes(ctx context.Context, arg sqlc.ListNodesParams) ([]sqlc.ListNodesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNodes", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListNodesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListNodes indicates an expected call of ListNodes. +func (mr *MockQuerierMockRecorder) ListNodes(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodes", reflect.TypeOf((*MockQuerier)(nil).ListNodes), ctx, arg) +} + +// ListObservationsForPacket mocks base method. +func (m *MockQuerier) ListObservationsForPacket(ctx context.Context, packetHash []byte) ([]sqlc.ListObservationsForPacketRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListObservationsForPacket", ctx, packetHash) + ret0, _ := ret[0].([]sqlc.ListObservationsForPacketRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObservationsForPacket indicates an expected call of ListObservationsForPacket. +func (mr *MockQuerierMockRecorder) ListObservationsForPacket(ctx, packetHash any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObservationsForPacket", reflect.TypeOf((*MockQuerier)(nil).ListObservationsForPacket), ctx, packetHash) +} + +// ListObserverAdverts mocks base method. +func (m *MockQuerier) ListObserverAdverts(ctx context.Context, arg sqlc.ListObserverAdvertsParams) ([]sqlc.ListObserverAdvertsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListObserverAdverts", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListObserverAdvertsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObserverAdverts indicates an expected call of ListObserverAdverts. +func (mr *MockQuerierMockRecorder) ListObserverAdverts(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObserverAdverts", reflect.TypeOf((*MockQuerier)(nil).ListObserverAdverts), ctx, arg) +} + +// ListObservers mocks base method. +func (m *MockQuerier) ListObservers(ctx context.Context, arg sqlc.ListObserversParams) ([]sqlc.ListObserversRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListObservers", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListObserversRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObservers indicates an expected call of ListObservers. +func (mr *MockQuerierMockRecorder) ListObservers(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObservers", reflect.TypeOf((*MockQuerier)(nil).ListObservers), ctx, arg) +} + +// ListPackets mocks base method. +func (m *MockQuerier) ListPackets(ctx context.Context, arg sqlc.ListPacketsParams) ([]sqlc.ListPacketsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPackets", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListPacketsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPackets indicates an expected call of ListPackets. +func (mr *MockQuerierMockRecorder) ListPackets(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackets", reflect.TypeOf((*MockQuerier)(nil).ListPackets), ctx, arg) +} + +// ListPacketsAfterID mocks base method. +func (m *MockQuerier) ListPacketsAfterID(ctx context.Context, arg sqlc.ListPacketsAfterIDParams) ([]sqlc.ListPacketsAfterIDRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPacketsAfterID", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListPacketsAfterIDRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPacketsAfterID indicates an expected call of ListPacketsAfterID. +func (mr *MockQuerierMockRecorder) ListPacketsAfterID(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPacketsAfterID", reflect.TypeOf((*MockQuerier)(nil).ListPacketsAfterID), ctx, arg) +} + +// ListRegions mocks base method. +func (m *MockQuerier) ListRegions(ctx context.Context) ([]sqlc.ListRegionsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRegions", ctx) + ret0, _ := ret[0].([]sqlc.ListRegionsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRegions indicates an expected call of ListRegions. +func (mr *MockQuerierMockRecorder) ListRegions(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegions", reflect.TypeOf((*MockQuerier)(nil).ListRegions), ctx) +} + +// ListTraceTags mocks base method. +func (m *MockQuerier) ListTraceTags(ctx context.Context, arg sqlc.ListTraceTagsParams) ([]sqlc.ListTraceTagsRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTraceTags", ctx, arg) + ret0, _ := ret[0].([]sqlc.ListTraceTagsRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTraceTags indicates an expected call of ListTraceTags. +func (mr *MockQuerierMockRecorder) ListTraceTags(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTraceTags", reflect.TypeOf((*MockQuerier)(nil).ListTraceTags), ctx, arg) +} + +// ReconfirmNeighbors mocks base method. +func (m *MockQuerier) ReconfirmNeighbors(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconfirmNeighbors", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReconfirmNeighbors indicates an expected call of ReconfirmNeighbors. +func (mr *MockQuerierMockRecorder) ReconfirmNeighbors(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconfirmNeighbors", reflect.TypeOf((*MockQuerier)(nil).ReconfirmNeighbors), ctx) +} + +// ReconfirmRoutes mocks base method. +func (m *MockQuerier) ReconfirmRoutes(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconfirmRoutes", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReconfirmRoutes indicates an expected call of ReconfirmRoutes. +func (mr *MockQuerierMockRecorder) ReconfirmRoutes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconfirmRoutes", reflect.TypeOf((*MockQuerier)(nil).ReconfirmRoutes), ctx) +} + +// RefreshHourlyStats mocks base method. +func (m *MockQuerier) RefreshHourlyStats(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RefreshHourlyStats", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// RefreshHourlyStats indicates an expected call of RefreshHourlyStats. +func (mr *MockQuerierMockRecorder) RefreshHourlyStats(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshHourlyStats", reflect.TypeOf((*MockQuerier)(nil).RefreshHourlyStats), ctx) +} + +// RefreshRadioPresets mocks base method. +func (m *MockQuerier) RefreshRadioPresets(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RefreshRadioPresets", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// RefreshRadioPresets indicates an expected call of RefreshRadioPresets. +func (mr *MockQuerierMockRecorder) RefreshRadioPresets(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshRadioPresets", reflect.TypeOf((*MockQuerier)(nil).RefreshRadioPresets), ctx) +} + +// RefreshTopNodes mocks base method. +func (m *MockQuerier) RefreshTopNodes(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RefreshTopNodes", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// RefreshTopNodes indicates an expected call of RefreshTopNodes. +func (mr *MockQuerierMockRecorder) RefreshTopNodes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTopNodes", reflect.TypeOf((*MockQuerier)(nil).RefreshTopNodes), ctx) +} + +// ResolvePathHashes mocks base method. +func (m *MockQuerier) ResolvePathHashes(ctx context.Context, arg sqlc.ResolvePathHashesParams) ([]sqlc.ResolvePathHashesRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResolvePathHashes", ctx, arg) + ret0, _ := ret[0].([]sqlc.ResolvePathHashesRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResolvePathHashes indicates an expected call of ResolvePathHashes. +func (mr *MockQuerierMockRecorder) ResolvePathHashes(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePathHashes", reflect.TypeOf((*MockQuerier)(nil).ResolvePathHashes), ctx, arg) +} + +// SearchKnownRoutes mocks base method. +func (m *MockQuerier) SearchKnownRoutes(ctx context.Context, arg sqlc.SearchKnownRoutesParams) ([]sqlc.KnownRoute, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchKnownRoutes", ctx, arg) + ret0, _ := ret[0].([]sqlc.KnownRoute) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchKnownRoutes indicates an expected call of SearchKnownRoutes. +func (mr *MockQuerierMockRecorder) SearchKnownRoutes(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchKnownRoutes", reflect.TypeOf((*MockQuerier)(nil).SearchKnownRoutes), ctx, arg) +} + +// SetNodeDefaultScope mocks base method. +func (m *MockQuerier) SetNodeDefaultScope(ctx context.Context, arg sqlc.SetNodeDefaultScopeParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNodeDefaultScope", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetNodeDefaultScope indicates an expected call of SetNodeDefaultScope. +func (mr *MockQuerierMockRecorder) SetNodeDefaultScope(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeDefaultScope", reflect.TypeOf((*MockQuerier)(nil).SetNodeDefaultScope), ctx, arg) +} + +// SetNodeMultibytePaths mocks base method. +func (m *MockQuerier) SetNodeMultibytePaths(ctx context.Context, id uuid.UUID) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNodeMultibytePaths", ctx, id) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetNodeMultibytePaths indicates an expected call of SetNodeMultibytePaths. +func (mr *MockQuerierMockRecorder) SetNodeMultibytePaths(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeMultibytePaths", reflect.TypeOf((*MockQuerier)(nil).SetNodeMultibytePaths), ctx, id) +} + +// SetNodeMultibyteTraces mocks base method. +func (m *MockQuerier) SetNodeMultibyteTraces(ctx context.Context, id uuid.UUID) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNodeMultibyteTraces", ctx, id) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetNodeMultibyteTraces indicates an expected call of SetNodeMultibyteTraces. +func (mr *MockQuerierMockRecorder) SetNodeMultibyteTraces(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeMultibyteTraces", reflect.TypeOf((*MockQuerier)(nil).SetNodeMultibyteTraces), ctx, id) +} + +// SetPacketDecrypted mocks base method. +func (m *MockQuerier) SetPacketDecrypted(ctx context.Context, packetHash []byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPacketDecrypted", ctx, packetHash) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetPacketDecrypted indicates an expected call of SetPacketDecrypted. +func (mr *MockQuerierMockRecorder) SetPacketDecrypted(ctx, packetHash any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPacketDecrypted", reflect.TypeOf((*MockQuerier)(nil).SetPacketDecrypted), ctx, packetHash) +} + +// UpdateObserverStatus mocks base method. +func (m *MockQuerier) UpdateObserverStatus(ctx context.Context, arg sqlc.UpdateObserverStatusParams) (uuid.UUID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateObserverStatus", ctx, arg) + ret0, _ := ret[0].(uuid.UUID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateObserverStatus indicates an expected call of UpdateObserverStatus. +func (mr *MockQuerierMockRecorder) UpdateObserverStatus(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObserverStatus", reflect.TypeOf((*MockQuerier)(nil).UpdateObserverStatus), ctx, arg) +} + +// UpsertChannel mocks base method. +func (m *MockQuerier) UpsertChannel(ctx context.Context, arg sqlc.UpsertChannelParams) (sqlc.Channel, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertChannel", ctx, arg) + ret0, _ := ret[0].(sqlc.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertChannel indicates an expected call of UpsertChannel. +func (mr *MockQuerierMockRecorder) UpsertChannel(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChannel", reflect.TypeOf((*MockQuerier)(nil).UpsertChannel), ctx, arg) +} + +// UpsertChannelHashOnly mocks base method. +func (m *MockQuerier) UpsertChannelHashOnly(ctx context.Context, channelHash []byte) (int32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertChannelHashOnly", ctx, channelHash) + ret0, _ := ret[0].(int32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertChannelHashOnly indicates an expected call of UpsertChannelHashOnly. +func (mr *MockQuerierMockRecorder) UpsertChannelHashOnly(ctx, channelHash any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChannelHashOnly", reflect.TypeOf((*MockQuerier)(nil).UpsertChannelHashOnly), ctx, channelHash) +} + +// UpsertIATA mocks base method. +func (m *MockQuerier) UpsertIATA(ctx context.Context, iata string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertIATA", ctx, iata) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertIATA indicates an expected call of UpsertIATA. +func (mr *MockQuerierMockRecorder) UpsertIATA(ctx, iata any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertIATA), ctx, iata) +} + +// UpsertIATADetails mocks base method. +func (m *MockQuerier) UpsertIATADetails(ctx context.Context, arg sqlc.UpsertIATADetailsParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertIATADetails", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertIATADetails indicates an expected call of UpsertIATADetails. +func (mr *MockQuerierMockRecorder) UpsertIATADetails(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertIATADetails", reflect.TypeOf((*MockQuerier)(nil).UpsertIATADetails), ctx, arg) +} + +// UpsertKnownRoute mocks base method. +func (m *MockQuerier) UpsertKnownRoute(ctx context.Context, arg sqlc.UpsertKnownRouteParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertKnownRoute", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertKnownRoute indicates an expected call of UpsertKnownRoute. +func (mr *MockQuerierMockRecorder) UpsertKnownRoute(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertKnownRoute", reflect.TypeOf((*MockQuerier)(nil).UpsertKnownRoute), ctx, arg) +} + +// UpsertNode mocks base method. +func (m *MockQuerier) UpsertNode(ctx context.Context, arg sqlc.UpsertNodeParams) (sqlc.Node, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNode", ctx, arg) + ret0, _ := ret[0].(sqlc.Node) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertNode indicates an expected call of UpsertNode. +func (mr *MockQuerierMockRecorder) UpsertNode(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNode", reflect.TypeOf((*MockQuerier)(nil).UpsertNode), ctx, arg) +} + +// UpsertNodeIATA mocks base method. +func (m *MockQuerier) UpsertNodeIATA(ctx context.Context, arg sqlc.UpsertNodeIATAParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeIATA", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeIATA indicates an expected call of UpsertNodeIATA. +func (mr *MockQuerierMockRecorder) UpsertNodeIATA(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeIATA), ctx, arg) +} + +// UpsertNodeNeighbor mocks base method. +func (m *MockQuerier) UpsertNodeNeighbor(ctx context.Context, arg sqlc.UpsertNodeNeighborParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeNeighbor", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeNeighbor indicates an expected call of UpsertNodeNeighbor. +func (mr *MockQuerierMockRecorder) UpsertNodeNeighbor(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeNeighbor", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeNeighbor), ctx, arg) +} + +// UpsertNodeShortID mocks base method. +func (m *MockQuerier) UpsertNodeShortID(ctx context.Context, arg sqlc.UpsertNodeShortIDParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeShortID", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeShortID indicates an expected call of UpsertNodeShortID. +func (mr *MockQuerierMockRecorder) UpsertNodeShortID(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeShortID", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeShortID), ctx, arg) +} + +// UpsertObserver mocks base method. +func (m *MockQuerier) UpsertObserver(ctx context.Context, publicKey []byte) (sqlc.Observer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertObserver", ctx, publicKey) + ret0, _ := ret[0].(sqlc.Observer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertObserver indicates an expected call of UpsertObserver. +func (mr *MockQuerierMockRecorder) UpsertObserver(ctx, publicKey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserver", reflect.TypeOf((*MockQuerier)(nil).UpsertObserver), ctx, publicKey) +} + +// UpsertObserverBroker mocks base method. +func (m *MockQuerier) UpsertObserverBroker(ctx context.Context, arg sqlc.UpsertObserverBrokerParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertObserverBroker", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertObserverBroker indicates an expected call of UpsertObserverBroker. +func (mr *MockQuerierMockRecorder) UpsertObserverBroker(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserverBroker", reflect.TypeOf((*MockQuerier)(nil).UpsertObserverBroker), ctx, arg) +} + +// UpsertObserverScope mocks base method. +func (m *MockQuerier) UpsertObserverScope(ctx context.Context, arg sqlc.UpsertObserverScopeParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertObserverScope", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertObserverScope indicates an expected call of UpsertObserverScope. +func (mr *MockQuerierMockRecorder) UpsertObserverScope(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserverScope", reflect.TypeOf((*MockQuerier)(nil).UpsertObserverScope), ctx, arg) +} + +// UpsertPacket mocks base method. +func (m *MockQuerier) UpsertPacket(ctx context.Context, arg sqlc.UpsertPacketParams) (sqlc.UpsertPacketRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertPacket", ctx, arg) + ret0, _ := ret[0].(sqlc.UpsertPacketRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertPacket indicates an expected call of UpsertPacket. +func (mr *MockQuerierMockRecorder) UpsertPacket(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertPacket", reflect.TypeOf((*MockQuerier)(nil).UpsertPacket), ctx, arg) +} + +// UpsertRegion mocks base method. +func (m *MockQuerier) UpsertRegion(ctx context.Context, arg sqlc.UpsertRegionParams) (int32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertRegion", ctx, arg) + ret0, _ := ret[0].(int32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpsertRegion indicates an expected call of UpsertRegion. +func (mr *MockQuerierMockRecorder) UpsertRegion(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRegion", reflect.TypeOf((*MockQuerier)(nil).UpsertRegion), ctx, arg) +} + +// UpsertRegionIATA mocks base method. +func (m *MockQuerier) UpsertRegionIATA(ctx context.Context, arg sqlc.UpsertRegionIATAParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertRegionIATA", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertRegionIATA indicates an expected call of UpsertRegionIATA. +func (mr *MockQuerierMockRecorder) UpsertRegionIATA(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRegionIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertRegionIATA), ctx, arg) +} + +// UpsertTransportScope mocks base method. +func (m *MockQuerier) UpsertTransportScope(ctx context.Context, arg sqlc.UpsertTransportScopeParams) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertTransportScope", ctx, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertTransportScope indicates an expected call of UpsertTransportScope. +func (mr *MockQuerierMockRecorder) UpsertTransportScope(ctx, arg any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTransportScope", reflect.TypeOf((*MockQuerier)(nil).UpsertTransportScope), ctx, arg) +} diff --git a/db/stats_test.go b/db/stats_test.go new file mode 100644 index 0000000..f643d80 --- /dev/null +++ b/db/stats_test.go @@ -0,0 +1,162 @@ +package db + +import ( + "context" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgtype" + "go.uber.org/mock/gomock" +) + +func TestGetStatsOverview(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetStatsOverview(gomock.Any(), "YVR"). + Return(sqlc.GetStatsOverviewRow{ + TotalPackets: 100, + TotalObservations: 500, + ActiveObservers: 10, + ActiveIatas: 3, + }, nil) + + store := &Store{q: mock} + result, err := store.GetStatsOverview(context.Background(), []string{"YVR"}) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.TotalPackets != 100 { + t.Errorf("expected TotalPackets 100, got %d", result.TotalPackets) + } + if result.WindowHours != 24 { + t.Errorf("expected WindowHours 24, got %d", result.WindowHours) + } +} + +func TestGetStatsTopNodes_NilObservationCount(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + nodeID := uuid.MustParse("00000000-0000-0000-0000-000000000001") + lastHeard := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + name := "test-node" + + mock.EXPECT(). + GetTopNodes(gomock.Any(), sqlc.GetTopNodesParams{ + Column1: "YVR", + Limit: 5, + }). + Return([]sqlc.MvTopNodesByIatum{ + { + NodeID: nodeID, + Name: &name, + NodeType: 1, + Iata: "YVR", + ObservationCount: nil, + LastHeard: lastHeard, + }, + }, nil) + + store := &Store{q: mock} + items, err := store.GetStatsTopNodes(context.Background(), []string{"YVR"}, 5) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 1 { + t.Fatalf("expected 1 item, got %d", len(items)) + } + if items[0].ObservationCount != 0 { + t.Errorf("expected ObservationCount 0 for nil, got %d", items[0].ObservationCount) + } +} + +func TestGetStatsTopObservers_IATATypeAssertion(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + observerID := uuid.MustParse("00000000-0000-0000-0000-000000000002") + displayName := "test-observer" + + obsType := "fixed" + mock.EXPECT(). + GetStatsTopObservers(gomock.Any(), gomock.Any()). + Return([]sqlc.GetStatsTopObserversRow{ + { + ID: observerID, + DisplayName: &displayName, + ObserverType: &obsType, + Iata: "YVR", + ObservationCount: 42, + }, + }, nil) + + store := &Store{q: mock} + items, err := store.GetStatsTopObservers(context.Background(), []string{"YVR"}, time.Now().Add(-time.Hour), 5) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 1 { + t.Fatalf("expected 1 item, got %d", len(items)) + } + if items[0].IATA != "YVR" { + t.Errorf("expected IATA YVR, got %s", items[0].IATA) + } + if *items[0].ObserverType != "fixed" { + t.Errorf("expected ObserverType fixed, got %s", *items[0].ObserverType) + } +} + +func TestGetStatsNodeTypes_Mapping(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetStatsNodeTypes(gomock.Any(), "YVR"). + Return([]sqlc.GetStatsNodeTypesRow{ + {NodeType: 1, Count: 10}, + {NodeType: 2, Count: 5}, + }, nil) + + store := &Store{q: mock} + result, err := store.GetStatsNodeTypes(context.Background(), []string{"YVR"}) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(result) != 2 { + t.Fatalf("expected 2 items, got %d", len(result)) + } + if result[0].NodeTypeName == "" { + t.Error("expected NodeTypeName to be set") + } +} + +func TestGetScopeStats(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetScopeStats(gomock.Any()). + Return([]sqlc.GetScopeStatsRow{ + {Name: "default", PacketCount: 100, ObserverCount: 5, NodeCount: 20}, + }, nil) + + store := &Store{q: mock} + items, err := store.GetScopeStats(context.Background()) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 1 { + t.Fatalf("expected 1 item, got %d", len(items)) + } + if items[0].Name != "default" { + t.Errorf("expected Name default, got %s", items[0].Name) + } + if items[0].PacketCount != 100 { + t.Errorf("expected PacketCount 100, got %d", items[0].PacketCount) + } +} diff --git a/db/store_test.go b/db/store_test.go index 26cf581..34b69ef 100644 --- a/db/store_test.go +++ b/db/store_test.go @@ -4,11 +4,16 @@ package db import ( + "context" + "errors" "testing" "time" + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" "github.com/google/uuid" "github.com/jackc/pgx/v5/pgtype" + "go.uber.org/mock/gomock" ) func TestNullableUUID_Zero(t *testing.T) { @@ -89,3 +94,88 @@ func TestToChannelMessage_NilFields(t *testing.T) { t.Errorf("expected empty Content, got %s", msg.Content) } } + +func TestResolvePathHashes_Empty(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + // no EXPECT — sqlc should never be called + store := &Store{q: mock} + + result, err := store.ResolvePathHashes(context.Background(), "YVR", nil) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result != nil { + t.Errorf("expected nil, got %v", result) + } +} + +func TestResolvePathHashes_DBError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + hashes := [][]byte{{0x01, 0x02}} + mock.EXPECT(). + ResolvePathHashes(gomock.Any(), sqlc.ResolvePathHashesParams{ + Iata: "YVR", + Column2: hashes, + }). + Return(nil, errors.New("db error")) + + store := &Store{q: mock} + result, err := store.ResolvePathHashes(context.Background(), "YVR", hashes) + if err == nil { + t.Fatal("expected error, got nil") + } + if result != nil { + t.Errorf("expected nil result on error, got %v", result) + } +} + +func TestResolvePathHashes_Mapping(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + nodeID := uuid.MustParse("00000000-0000-0000-0000-000000000001") + name := "test-node" + lat := 49.1967 + lon := -123.1815 + pubkey := []byte{0xde, 0xad} + hashes := [][]byte{{0xab, 0xcd}} + + mock.EXPECT(). + ResolvePathHashes(gomock.Any(), sqlc.ResolvePathHashesParams{ + Iata: "YVR", + Column2: hashes, + }). + Return([]sqlc.ResolvePathHashesRow{ + { + Hash: []byte{0xab, 0xcd}, + NodeID: nodeID, + Name: &name, + Latitude: &lat, + Longitude: &lon, + PublicKey: pubkey, + }, + }, nil) + + store := &Store{q: mock} + result, err := store.ResolvePathHashes(context.Background(), "YVR", hashes) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + entries, ok := result["abcd"] + if !ok { + t.Fatal("expected key abcd in result") + } + if len(entries) != 1 { + t.Fatalf("expected 1 entry, got %d", len(entries)) + } + if entries[0].NodeID != nodeID { + t.Errorf("expected NodeID %s, got %s", nodeID, entries[0].NodeID) + } + if entries[0].Name != &name { + t.Errorf("expected Name %s, got %v", name, entries[0].Name) + } +} diff --git a/db/traces_test.go b/db/traces_test.go new file mode 100644 index 0000000..1c1cbfd --- /dev/null +++ b/db/traces_test.go @@ -0,0 +1,160 @@ +package db + +import ( + "context" + "errors" + "testing" + "time" + + sqlc "github.com/MeshCore-Beacon/beacon-server/db/sqlc" + mockdb "github.com/MeshCore-Beacon/beacon-server/db/sqlc/mock" + "github.com/jackc/pgx/v5/pgtype" + "go.uber.org/mock/gomock" +) + +func TestListTraceTags_Empty(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + ListTraceTags(gomock.Any(), gomock.Any()). + Return([]sqlc.ListTraceTagsRow{}, nil) + + store := &Store{q: mock} + items, err := store.ListTraceTags(context.Background(), []string{"YVR"}, "", "", time.Time{}, time.Time{}, time.Time{}, 10) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 0 { + t.Errorf("expected 0 items, got %d", len(items)) + } +} + +func TestListTraceTags_WithPayload(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + firstHeard := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + lastHeard := pgtype.Timestamptz{Time: time.UnixMilli(1700000001000), Valid: true} + payload := []byte(`{"pathHashes":["aabb","ccdd"],"snrValues":[10,20]}`) + + mock.EXPECT(). + ListTraceTags(gomock.Any(), gomock.Any()). + Return([]sqlc.ListTraceTagsRow{ + { + TraceTag: "trace-001", + FirstHeardAt: firstHeard, + LastHeardAt: lastHeard, + PacketCount: 3, + IataCount: 1, + TraceType: "trace", + BestPayload: payload, + }, + }, nil) + + store := &Store{q: mock} + items, err := store.ListTraceTags(context.Background(), []string{"YVR"}, "", "", time.Time{}, time.Time{}, time.Time{}, 10) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(items) != 1 { + t.Fatalf("expected 1 item, got %d", len(items)) + } + if items[0].TraceTag != "trace-001" { + t.Errorf("expected TraceTag trace-001, got %s", items[0].TraceTag) + } + if len(items[0].PathHashes) != 2 { + t.Errorf("expected 2 path hashes, got %d", len(items[0].PathHashes)) + } + if items[0].SNRValues[0] != 10 { + t.Errorf("expected SNR 10, got %f", items[0].SNRValues[0]) + } +} + +func TestGetTraceByTag_Empty(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetPacketsByTraceTag(gomock.Any(), "trace-001"). + Return([]sqlc.GetPacketsByTraceTagRow{}, nil) + + store := &Store{q: mock} + detail, err := store.GetTraceByTag(context.Background(), "trace-001") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if detail != nil { + t.Errorf("expected nil for empty result, got %v", detail) + } +} + +func TestGetTraceByTag_WithPacket(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + firstHeard := pgtype.Timestamptz{Time: time.UnixMilli(1700000000000), Valid: true} + lastHeard := pgtype.Timestamptz{Time: time.UnixMilli(1700000001000), Valid: true} + // aabbccdd is valid hex for the packet hash + parsedPayload := []byte(`{"pathHashes":["aabb"],"snrValues":[15.0],"flags":0}`) + + scopeName := "default" + mock.EXPECT(). + GetPacketsByTraceTag(gomock.Any(), "trace-001"). + Return([]sqlc.GetPacketsByTraceTagRow{ + { + PacketHashHex: "aabbccdd", + RouteType: 1, + ScopeName: &scopeName, + FirstHeardAt: firstHeard, + LastHeardAt: lastHeard, + ParsedPayload: parsedPayload, + }, + }, nil) + + mock.EXPECT(). + ListObservationsForPacket(gomock.Any(), []byte{0xaa, 0xbb, 0xcc, 0xdd}). + Return([]sqlc.ListObservationsForPacketRow{ + {Iata: "YVR"}, + }, nil) + + mock.EXPECT(). + ResolvePathHashes(gomock.Any(), sqlc.ResolvePathHashesParams{ + Iata: "YVR", + Column2: [][]byte{{0xaa, 0xbb}}, + }). + Return([]sqlc.ResolvePathHashesRow{}, nil) + + store := &Store{q: mock} + detail, err := store.GetTraceByTag(context.Background(), "trace-001") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if detail == nil { + t.Fatal("expected detail, got nil") + } + if detail.TraceTag != "trace-001" { + t.Errorf("expected TraceTag trace-001, got %s", detail.TraceTag) + } + if len(detail.Packets) != 1 { + t.Fatalf("expected 1 packet, got %d", len(detail.Packets)) + } + if len(detail.Packets[0].RawPath) != 1 { + t.Errorf("expected 1 raw hop, got %d", len(detail.Packets[0].RawPath)) + } +} + +func TestGetTraceByTag_DBError(t *testing.T) { + ctrl := gomock.NewController(t) + mock := mockdb.NewMockQuerier(ctrl) + + mock.EXPECT(). + GetPacketsByTraceTag(gomock.Any(), "trace-001"). + Return(nil, errors.New("db error")) + + store := &Store{q: mock} + _, err := store.GetTraceByTag(context.Background(), "trace-001") + if err == nil { + t.Fatal("expected error, got nil") + } +} diff --git a/go.mod b/go.mod index a84bebc..8468e95 100644 --- a/go.mod +++ b/go.mod @@ -34,6 +34,7 @@ require ( github.com/rogpeppe/go-internal v1.14.1 // indirect github.com/swaggo/files v0.0.0-20220610200504-28940afbdbfe // indirect go.uber.org/atomic v1.11.0 // indirect + go.uber.org/mock v0.6.0 // indirect golang.org/x/crypto v0.51.0 // indirect golang.org/x/mod v0.35.0 // indirect golang.org/x/net v0.53.0 // indirect diff --git a/go.sum b/go.sum index a4ec469..d6e3445 100644 --- a/go.sum +++ b/go.sum @@ -78,6 +78,8 @@ github.com/swaggo/swag v1.16.6 h1:qBNcx53ZaX+M5dxVyTrgQ0PJ/ACK+NzhwcbieTt+9yI= github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4Xesg= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI= golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8= golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=