151 lines
4.3 KiB
Go
151 lines
4.3 KiB
Go
package store_test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/staack/the-other-dude/poller/internal/store"
|
|
"github.com/staack/the-other-dude/poller/internal/testutil"
|
|
)
|
|
|
|
func TestDeviceStore_FetchDevices_Integration(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping integration test in short mode")
|
|
}
|
|
|
|
connStr, cleanup := testutil.SetupPostgres(t)
|
|
defer cleanup()
|
|
|
|
ctx := context.Background()
|
|
tenantID := "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
|
|
dummyCreds := []byte("dummy-encrypted-credentials")
|
|
v7 := "7.16"
|
|
major7 := 7
|
|
|
|
// Insert 3 devices WITH encrypted_credentials (should be returned).
|
|
id1 := testutil.InsertTestDevice(t, connStr, store.Device{
|
|
TenantID: tenantID,
|
|
IPAddress: "192.168.1.1",
|
|
APIPort: 8728,
|
|
APISSLPort: 8729,
|
|
EncryptedCredentials: dummyCreds,
|
|
RouterOSVersion: &v7,
|
|
MajorVersion: &major7,
|
|
})
|
|
id2 := testutil.InsertTestDevice(t, connStr, store.Device{
|
|
TenantID: tenantID,
|
|
IPAddress: "192.168.1.2",
|
|
APIPort: 8728,
|
|
APISSLPort: 8729,
|
|
EncryptedCredentials: dummyCreds,
|
|
})
|
|
id3 := testutil.InsertTestDevice(t, connStr, store.Device{
|
|
TenantID: tenantID,
|
|
IPAddress: "192.168.1.3",
|
|
APIPort: 8728,
|
|
APISSLPort: 8729,
|
|
EncryptedCredentials: dummyCreds,
|
|
})
|
|
|
|
// Insert 1 device WITHOUT encrypted_credentials (should be excluded).
|
|
_ = testutil.InsertTestDevice(t, connStr, store.Device{
|
|
TenantID: tenantID,
|
|
IPAddress: "192.168.1.99",
|
|
APIPort: 8728,
|
|
// EncryptedCredentials is nil -> excluded by FetchDevices WHERE clause
|
|
})
|
|
|
|
ds, err := store.NewDeviceStore(ctx, connStr)
|
|
require.NoError(t, err)
|
|
defer ds.Close()
|
|
|
|
devices, err := ds.FetchDevices(ctx)
|
|
require.NoError(t, err)
|
|
assert.Len(t, devices, 3, "should return only devices with encrypted_credentials")
|
|
|
|
// Collect returned IDs for verification.
|
|
returnedIDs := make(map[string]bool)
|
|
for _, d := range devices {
|
|
returnedIDs[d.ID] = true
|
|
}
|
|
assert.True(t, returnedIDs[id1], "device 1 should be returned")
|
|
assert.True(t, returnedIDs[id2], "device 2 should be returned")
|
|
assert.True(t, returnedIDs[id3], "device 3 should be returned")
|
|
|
|
// Verify fields on the device with version info.
|
|
for _, d := range devices {
|
|
if d.ID == id1 {
|
|
assert.Equal(t, tenantID, d.TenantID)
|
|
assert.Equal(t, "192.168.1.1", d.IPAddress)
|
|
assert.Equal(t, 8728, d.APIPort)
|
|
assert.Equal(t, 8729, d.APISSLPort)
|
|
assert.Equal(t, dummyCreds, d.EncryptedCredentials)
|
|
require.NotNil(t, d.RouterOSVersion)
|
|
assert.Equal(t, "7.16", *d.RouterOSVersion)
|
|
require.NotNil(t, d.MajorVersion)
|
|
assert.Equal(t, 7, *d.MajorVersion)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDeviceStore_GetDevice_Integration(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping integration test in short mode")
|
|
}
|
|
|
|
connStr, cleanup := testutil.SetupPostgres(t)
|
|
defer cleanup()
|
|
|
|
ctx := context.Background()
|
|
tenantID := "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
|
|
dummyCreds := []byte("dummy-encrypted-credentials")
|
|
|
|
id := testutil.InsertTestDevice(t, connStr, store.Device{
|
|
TenantID: tenantID,
|
|
IPAddress: "10.0.0.1",
|
|
APIPort: 8728,
|
|
APISSLPort: 8729,
|
|
EncryptedCredentials: dummyCreds,
|
|
})
|
|
|
|
ds, err := store.NewDeviceStore(ctx, connStr)
|
|
require.NoError(t, err)
|
|
defer ds.Close()
|
|
|
|
// Happy path: existing device.
|
|
d, err := ds.GetDevice(ctx, id)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, id, d.ID)
|
|
assert.Equal(t, tenantID, d.TenantID)
|
|
assert.Equal(t, "10.0.0.1", d.IPAddress)
|
|
assert.Equal(t, dummyCreds, d.EncryptedCredentials)
|
|
|
|
// Sad path: nonexistent device.
|
|
_, err = ds.GetDevice(ctx, "00000000-0000-0000-0000-000000000000")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestDeviceStore_FetchDevices_Empty_Integration(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping integration test in short mode")
|
|
}
|
|
|
|
connStr, cleanup := testutil.SetupPostgres(t)
|
|
defer cleanup()
|
|
|
|
ctx := context.Background()
|
|
|
|
ds, err := store.NewDeviceStore(ctx, connStr)
|
|
require.NoError(t, err)
|
|
defer ds.Close()
|
|
|
|
devices, err := ds.FetchDevices(ctx)
|
|
require.NoError(t, err)
|
|
// FetchDevices returns nil slice when no rows exist (append on nil);
|
|
// this is acceptable Go behavior. The important thing is no error.
|
|
assert.Empty(t, devices, "should return empty result for empty database")
|
|
}
|