2023-10-12 15:42:36 +02:00
|
|
|
package server
|
|
|
|
|
|
|
|
import (
|
2024-07-03 11:33:02 +02:00
|
|
|
"context"
|
2023-10-12 15:42:36 +02:00
|
|
|
"fmt"
|
2024-04-20 22:04:20 +02:00
|
|
|
"math/rand"
|
2023-10-12 15:42:36 +02:00
|
|
|
"net"
|
2024-04-18 18:14:21 +02:00
|
|
|
"net/netip"
|
2024-05-16 18:28:37 +02:00
|
|
|
"os"
|
2023-10-12 15:42:36 +02:00
|
|
|
"runtime"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/stretchr/testify/require"
|
2023-11-28 13:45:26 +01:00
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
nbdns "github.com/netbirdio/netbird/dns"
|
|
|
|
nbgroup "github.com/netbirdio/netbird/management/server/group"
|
|
|
|
|
2024-04-18 18:14:21 +02:00
|
|
|
route2 "github.com/netbirdio/netbird/route"
|
|
|
|
|
2024-03-10 19:09:45 +01:00
|
|
|
"github.com/netbirdio/netbird/management/server/status"
|
|
|
|
|
2023-11-28 13:45:26 +01:00
|
|
|
nbpeer "github.com/netbirdio/netbird/management/server/peer"
|
2023-10-12 15:42:36 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
func TestSqlite_NewStore(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2023-10-12 15:42:36 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 0 {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expected to create a new empty Accounts map when creating a new FileStore")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-20 22:04:20 +02:00
|
|
|
func TestSqlite_SaveAccount_Large(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-04-20 22:04:20 +02:00
|
|
|
}
|
2024-10-10 12:35:03 +02:00
|
|
|
|
2024-07-12 09:28:53 +02:00
|
|
|
t.Run("SQLite", func(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-07-12 09:28:53 +02:00
|
|
|
runLargeTest(t, store)
|
|
|
|
})
|
2024-10-10 12:35:03 +02:00
|
|
|
|
2024-07-12 09:28:53 +02:00
|
|
|
// create store outside to have a better time counter for the test
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-07-12 09:28:53 +02:00
|
|
|
t.Run("PostgreSQL", func(t *testing.T) {
|
|
|
|
runLargeTest(t, store)
|
|
|
|
})
|
|
|
|
}
|
2024-04-20 22:04:20 +02:00
|
|
|
|
2024-07-12 09:28:53 +02:00
|
|
|
func runLargeTest(t *testing.T, store Store) {
|
|
|
|
t.Helper()
|
2024-04-20 22:04:20 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), "account_id", "testuser", "")
|
2024-04-20 22:04:20 +02:00
|
|
|
groupALL, err := account.GetGroupAll()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
2024-07-12 09:28:53 +02:00
|
|
|
const numPerAccount = 6000
|
2024-04-20 22:04:20 +02:00
|
|
|
for n := 0; n < numPerAccount; n++ {
|
|
|
|
netIP := randomIPv4()
|
|
|
|
peerID := fmt.Sprintf("%s-peer-%d", account.Id, n)
|
|
|
|
|
|
|
|
peer := &nbpeer.Peer{
|
|
|
|
ID: peerID,
|
|
|
|
Key: peerID,
|
|
|
|
SetupKey: "",
|
|
|
|
IP: netIP,
|
|
|
|
Name: peerID,
|
|
|
|
DNSLabel: peerID,
|
|
|
|
UserID: userID,
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: false, LastSeen: time.Now()},
|
|
|
|
SSHEnabled: false,
|
|
|
|
}
|
|
|
|
account.Peers[peerID] = peer
|
|
|
|
group, _ := account.GetGroupAll()
|
|
|
|
group.Peers = append(group.Peers, peerID)
|
|
|
|
user := &User{
|
|
|
|
Id: fmt.Sprintf("%s-user-%d", account.Id, n),
|
|
|
|
AccountID: account.Id,
|
|
|
|
}
|
|
|
|
account.Users[user.Id] = user
|
|
|
|
route := &route2.Route{
|
2024-05-06 14:47:49 +02:00
|
|
|
ID: route2.ID(fmt.Sprintf("network-id-%d", n)),
|
2024-04-20 22:04:20 +02:00
|
|
|
Description: "base route",
|
2024-05-06 14:47:49 +02:00
|
|
|
NetID: route2.NetID(fmt.Sprintf("network-id-%d", n)),
|
2024-04-20 22:04:20 +02:00
|
|
|
Network: netip.MustParsePrefix(netIP.String() + "/24"),
|
|
|
|
NetworkType: route2.IPv4Network,
|
|
|
|
Metric: 9999,
|
|
|
|
Masquerade: false,
|
|
|
|
Enabled: true,
|
|
|
|
Groups: []string{groupALL.ID},
|
|
|
|
}
|
|
|
|
account.Routes[route.ID] = route
|
|
|
|
|
|
|
|
group = &nbgroup.Group{
|
|
|
|
ID: fmt.Sprintf("group-id-%d", n),
|
|
|
|
AccountID: account.Id,
|
|
|
|
Name: fmt.Sprintf("group-id-%d", n),
|
|
|
|
Issued: "api",
|
|
|
|
Peers: nil,
|
|
|
|
}
|
|
|
|
account.Groups[group.ID] = group
|
|
|
|
|
|
|
|
nameserver := &nbdns.NameServerGroup{
|
|
|
|
ID: fmt.Sprintf("nameserver-id-%d", n),
|
|
|
|
AccountID: account.Id,
|
|
|
|
Name: fmt.Sprintf("nameserver-id-%d", n),
|
|
|
|
Description: "",
|
|
|
|
NameServers: []nbdns.NameServer{{IP: netip.MustParseAddr(netIP.String()), NSType: nbdns.UDPNameServerType}},
|
|
|
|
Groups: []string{group.ID},
|
|
|
|
Primary: false,
|
|
|
|
Domains: nil,
|
|
|
|
Enabled: false,
|
|
|
|
SearchDomainsEnabled: false,
|
|
|
|
}
|
|
|
|
account.NameServerGroups[nameserver.ID] = nameserver
|
|
|
|
|
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2024-04-20 22:04:20 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 1 {
|
2024-04-20 22:04:20 +02:00
|
|
|
t.Errorf("expecting 1 Accounts to be stored after SaveAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
a, err := store.GetAccount(context.Background(), account.Id)
|
2024-04-20 22:04:20 +02:00
|
|
|
if a == nil {
|
|
|
|
t.Errorf("expecting Account to be stored after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy stored after SaveAccount(), got %d", len(a.Policies))
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies[0].Rules) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy rule stored after SaveAccount(), got %d", len(a.Policies[0].Rules))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Peers) != numPerAccount {
|
|
|
|
t.Errorf("expecting Account to have %d peers stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount, len(a.Peers))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Users) != numPerAccount+1 {
|
|
|
|
t.Errorf("expecting Account to have %d users stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount+1, len(a.Users))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Routes) != numPerAccount {
|
|
|
|
t.Errorf("expecting Account to have %d routes stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount, len(a.Routes))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.NameServerGroups) != numPerAccount {
|
|
|
|
t.Errorf("expecting Account to have %d NameServerGroups stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount, len(a.NameServerGroups))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.NameServerGroups) != numPerAccount {
|
|
|
|
t.Errorf("expecting Account to have %d NameServerGroups stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount, len(a.NameServerGroups))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.SetupKeys) != numPerAccount+1 {
|
|
|
|
t.Errorf("expecting Account to have %d SetupKeys stored after SaveAccount(), got %d",
|
|
|
|
numPerAccount+1, len(a.SetupKeys))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func randomIPv4() net.IP {
|
|
|
|
rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
|
|
b := make([]byte, 4)
|
|
|
|
for i := range b {
|
|
|
|
b[i] = byte(rand.Intn(256))
|
|
|
|
}
|
|
|
|
return net.IP(b)
|
|
|
|
}
|
|
|
|
|
2023-10-12 15:42:36 +02:00
|
|
|
func TestSqlite_SaveAccount(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2023-10-12 15:42:36 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), "account_id", "testuser", "")
|
2023-10-12 15:42:36 +02:00
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
2023-11-28 13:45:26 +01:00
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
2023-10-12 15:42:36 +02:00
|
|
|
Key: "peerkey",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
2023-11-28 13:45:26 +01:00
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
2023-10-12 15:42:36 +02:00
|
|
|
Name: "peer name",
|
2023-11-28 13:45:26 +01:00
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account2 := newAccountWithId(context.Background(), "account_id2", "testuser2", "")
|
2023-10-12 15:42:36 +02:00
|
|
|
setupKey = GenerateDefaultSetupKey()
|
|
|
|
account2.SetupKeys[setupKey.Key] = setupKey
|
2023-11-28 13:45:26 +01:00
|
|
|
account2.Peers["testpeer2"] = &nbpeer.Peer{
|
2023-10-12 15:42:36 +02:00
|
|
|
Key: "peerkey2",
|
|
|
|
SetupKey: "peerkeysetupkey2",
|
|
|
|
IP: net.IP{127, 0, 0, 2},
|
2023-11-28 13:45:26 +01:00
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
2023-10-12 15:42:36 +02:00
|
|
|
Name: "peer name 2",
|
2023-11-28 13:45:26 +01:00
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account2)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 2 {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expecting 2 Accounts to be stored after SaveAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
a, err := store.GetAccount(context.Background(), account.Id)
|
2023-10-12 15:42:36 +02:00
|
|
|
if a == nil {
|
|
|
|
t.Errorf("expecting Account to be stored after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy stored after SaveAccount(), got %d", len(a.Policies))
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies[0].Rules) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy rule stored after SaveAccount(), got %d", len(a.Policies[0].Rules))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByPeerPubKey(context.Background(), "peerkey"); a == nil {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expecting PeerKeyID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByUser(context.Background(), "testuser"); a == nil {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expecting UserID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByPeerID(context.Background(), "testpeer"); a == nil {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expecting PeerID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountBySetupKey(context.Background(), setupKey.Key); a == nil {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Errorf("expecting SetupKeyID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-28 14:23:38 +01:00
|
|
|
func TestSqlite_DeleteAccount(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2023-11-28 14:23:38 +01:00
|
|
|
|
|
|
|
testUserID := "testuser"
|
|
|
|
user := NewAdminUser(testUserID)
|
|
|
|
user.PATs = map[string]*PersonalAccessToken{"testtoken": {
|
|
|
|
ID: "testtoken",
|
|
|
|
Name: "test token",
|
|
|
|
}}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), "account_id", testUserID, "")
|
2023-11-28 14:23:38 +01:00
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
2023-11-30 11:08:51 +01:00
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
2023-11-28 14:23:38 +01:00
|
|
|
Key: "peerkey",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
2023-11-30 11:08:51 +01:00
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
2023-11-28 14:23:38 +01:00
|
|
|
Name: "peer name",
|
2023-11-30 11:08:51 +01:00
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
2023-11-28 14:23:38 +01:00
|
|
|
}
|
|
|
|
account.Users[testUserID] = user
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2023-11-28 14:23:38 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 1 {
|
2023-11-28 14:23:38 +01:00
|
|
|
t.Errorf("expecting 1 Accounts to be stored after SaveAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.DeleteAccount(context.Background(), account)
|
2023-11-28 14:23:38 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 0 {
|
2023-11-28 14:23:38 +01:00
|
|
|
t.Errorf("expecting 0 Accounts to be stored after DeleteAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPeerPubKey(context.Background(), "peerkey")
|
2023-11-28 14:23:38 +01:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by peer public key")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByUser(context.Background(), "testuser")
|
2023-11-28 14:23:38 +01:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by user")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPeerID(context.Background(), "testpeer")
|
2023-11-28 14:23:38 +01:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by peer id")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountBySetupKey(context.Background(), setupKey.Key)
|
2023-11-28 14:23:38 +01:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by setup key")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), account.Id)
|
2023-11-28 14:23:38 +01:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by id")
|
|
|
|
|
|
|
|
for _, policy := range account.Policies {
|
|
|
|
var rules []*PolicyRule
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Model(&PolicyRule{}).Find(&rules, "policy_id = ?", policy.ID).Error
|
2023-11-28 14:23:38 +01:00
|
|
|
require.NoError(t, err, "expecting no error after removing DeleteAccount when searching for policy rules")
|
|
|
|
require.Len(t, rules, 0, "expecting no policy rules to be found after removing DeleteAccount")
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, accountUser := range account.Users {
|
|
|
|
var pats []*PersonalAccessToken
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Model(&PersonalAccessToken{}).Find(&pats, "user_id = ?", accountUser.Id).Error
|
2023-11-28 14:23:38 +01:00
|
|
|
require.NoError(t, err, "expecting no error after removing DeleteAccount when searching for personal access token")
|
|
|
|
require.Len(t, pats, 0, "expecting no personal access token to be found after removing DeleteAccount")
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2024-03-10 19:09:45 +01:00
|
|
|
func TestSqlite_GetAccount(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-03-10 19:09:45 +01:00
|
|
|
|
|
|
|
id := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccount(context.Background(), id)
|
2024-03-10 19:09:45 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, id, account.Id, "account id should match")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), "non-existing-account")
|
2024-03-10 19:09:45 +01:00
|
|
|
assert.Error(t, err)
|
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
|
|
|
}
|
|
|
|
|
2024-07-26 07:49:05 +02:00
|
|
|
func TestSqlite_SavePeer(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-07-26 07:49:05 +02:00
|
|
|
|
|
|
|
account, err := store.GetAccount(context.Background(), "bf1c8084-ba50-4ce7-9439-34653001fc3b")
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
// save status of non-existing peer
|
|
|
|
peer := &nbpeer.Peer{
|
|
|
|
Key: "peerkey",
|
|
|
|
ID: "testpeer",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{Hostname: "testingpeer"},
|
|
|
|
Name: "peer name",
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
|
|
|
}
|
|
|
|
ctx := context.Background()
|
|
|
|
err = store.SavePeer(ctx, account.Id, peer)
|
|
|
|
assert.Error(t, err)
|
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
|
|
|
|
|
|
|
// save new status of existing peer
|
|
|
|
account.Peers[peer.ID] = peer
|
|
|
|
|
|
|
|
err = store.SaveAccount(context.Background(), account)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
updatedPeer := peer.Copy()
|
|
|
|
updatedPeer.Status.Connected = false
|
|
|
|
updatedPeer.Meta.Hostname = "updatedpeer"
|
|
|
|
|
|
|
|
err = store.SavePeer(ctx, account.Id, updatedPeer)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
account, err = store.GetAccount(context.Background(), account.Id)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
actual := account.Peers[peer.ID]
|
|
|
|
assert.Equal(t, updatedPeer.Status, actual.Status)
|
|
|
|
assert.Equal(t, updatedPeer.Meta, actual.Meta)
|
|
|
|
}
|
|
|
|
|
2023-10-12 15:42:36 +02:00
|
|
|
func TestSqlite_SavePeerStatus(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2023-10-12 15:42:36 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccount(context.Background(), "bf1c8084-ba50-4ce7-9439-34653001fc3b")
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
// save status of non-existing peer
|
2024-07-16 17:38:12 +02:00
|
|
|
newStatus := nbpeer.PeerStatus{Connected: false, LastSeen: time.Now().UTC()}
|
2023-10-12 15:42:36 +02:00
|
|
|
err = store.SavePeerStatus(account.Id, "non-existing-peer", newStatus)
|
|
|
|
assert.Error(t, err)
|
2024-03-10 19:09:45 +01:00
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
2023-10-12 15:42:36 +02:00
|
|
|
|
|
|
|
// save new status of existing peer
|
2023-11-28 13:45:26 +01:00
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
2023-10-12 15:42:36 +02:00
|
|
|
Key: "peerkey",
|
|
|
|
ID: "testpeer",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
2023-11-28 13:45:26 +01:00
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
2023-10-12 15:42:36 +02:00
|
|
|
Name: "peer name",
|
2024-07-16 17:38:12 +02:00
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = store.SavePeerStatus(account.Id, "testpeer", newStatus)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err = store.GetAccount(context.Background(), account.Id)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
actual := account.Peers["testpeer"].Status
|
|
|
|
assert.Equal(t, newStatus, *actual)
|
2024-07-25 16:22:04 +02:00
|
|
|
|
|
|
|
newStatus.Connected = true
|
|
|
|
|
|
|
|
err = store.SavePeerStatus(account.Id, "testpeer", newStatus)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
account, err = store.GetAccount(context.Background(), account.Id)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
actual = account.Peers["testpeer"].Status
|
|
|
|
assert.Equal(t, newStatus, *actual)
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
2024-07-26 07:49:05 +02:00
|
|
|
|
2024-02-20 09:59:56 +01:00
|
|
|
func TestSqlite_SavePeerLocation(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccount(context.Background(), "bf1c8084-ba50-4ce7-9439-34653001fc3b")
|
2024-02-20 09:59:56 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
peer := &nbpeer.Peer{
|
|
|
|
AccountID: account.Id,
|
|
|
|
ID: "testpeer",
|
|
|
|
Location: nbpeer.Location{
|
|
|
|
ConnectionIP: net.ParseIP("0.0.0.0"),
|
|
|
|
CountryCode: "YY",
|
|
|
|
CityName: "City",
|
|
|
|
GeoNameID: 1,
|
|
|
|
},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
|
|
|
}
|
|
|
|
// error is expected as peer is not in store yet
|
|
|
|
err = store.SavePeerLocation(account.Id, peer)
|
|
|
|
assert.Error(t, err)
|
|
|
|
|
|
|
|
account.Peers[peer.ID] = peer
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2024-02-20 09:59:56 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
peer.Location.ConnectionIP = net.ParseIP("35.1.1.1")
|
|
|
|
peer.Location.CountryCode = "DE"
|
|
|
|
peer.Location.CityName = "Berlin"
|
|
|
|
peer.Location.GeoNameID = 2950159
|
|
|
|
|
|
|
|
err = store.SavePeerLocation(account.Id, account.Peers[peer.ID])
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err = store.GetAccount(context.Background(), account.Id)
|
2024-02-20 09:59:56 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
actual := account.Peers[peer.ID].Location
|
|
|
|
assert.Equal(t, peer.Location, actual)
|
2024-03-10 19:09:45 +01:00
|
|
|
|
|
|
|
peer.ID = "non-existing-peer"
|
|
|
|
err = store.SavePeerLocation(account.Id, peer)
|
|
|
|
assert.Error(t, err)
|
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
2024-02-20 09:59:56 +01:00
|
|
|
}
|
2023-10-12 15:42:36 +02:00
|
|
|
|
|
|
|
func TestSqlite_TestGetAccountByPrivateDomain(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2023-10-12 15:42:36 +02:00
|
|
|
existingDomain := "test.com"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccountByPrivateDomain(context.Background(), existingDomain)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err, "should found account")
|
|
|
|
require.Equal(t, existingDomain, account.Domain, "domains should match")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPrivateDomain(context.Background(), "missing-domain.com")
|
2023-10-12 15:42:36 +02:00
|
|
|
require.Error(t, err, "should return error on domain lookup")
|
2024-03-10 19:09:45 +01:00
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_GetTokenIDByHashedToken(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2023-10-12 15:42:36 +02:00
|
|
|
hashed := "SoMeHaShEdToKeN"
|
|
|
|
id := "9dj38s35-63fb-11ec-90d6-0242ac120003"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
token, err := store.GetTokenIDByHashedToken(context.Background(), hashed)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, id, token)
|
2024-03-10 19:09:45 +01:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetTokenIDByHashedToken(context.Background(), "non-existing-hash")
|
2024-03-10 19:09:45 +01:00
|
|
|
require.Error(t, err)
|
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_GetUserByTokenID(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
t.Skip("The SQLite store is not properly supported by Windows yet")
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2023-10-12 15:42:36 +02:00
|
|
|
id := "9dj38s35-63fb-11ec-90d6-0242ac120003"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
user, err := store.GetUserByTokenID(context.Background(), id)
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, id, user.PATs[id].ID)
|
2024-03-10 19:09:45 +01:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetUserByTokenID(context.Background(), "non-existing-id")
|
2024-03-10 19:09:45 +01:00
|
|
|
require.Error(t, err)
|
|
|
|
parsedErr, ok := status.FromError(err)
|
|
|
|
require.True(t, ok)
|
|
|
|
require.Equal(t, status.NotFound, parsedErr.Type(), "should return not found error")
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
2024-04-18 18:14:21 +02:00
|
|
|
func TestMigrate(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-04-18 18:14:21 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
// TODO: figure out why this fails on postgres
|
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
2024-04-18 18:14:21 +02:00
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
|
|
|
err = migrate(context.Background(), store.(*SqlStore).db)
|
2024-04-18 18:14:21 +02:00
|
|
|
require.NoError(t, err, "Migration should not fail on empty db")
|
|
|
|
|
|
|
|
_, ipnet, err := net.ParseCIDR("10.0.0.0/24")
|
|
|
|
require.NoError(t, err, "Failed to parse CIDR")
|
|
|
|
|
|
|
|
type network struct {
|
|
|
|
Network
|
|
|
|
Net net.IPNet `gorm:"serializer:gob"`
|
|
|
|
}
|
|
|
|
|
2024-05-07 13:01:45 +02:00
|
|
|
type location struct {
|
|
|
|
nbpeer.Location
|
|
|
|
ConnectionIP net.IP
|
|
|
|
}
|
|
|
|
|
|
|
|
type peer struct {
|
|
|
|
nbpeer.Peer
|
|
|
|
Location location `gorm:"embedded;embeddedPrefix:location_"`
|
|
|
|
}
|
|
|
|
|
2024-04-18 18:14:21 +02:00
|
|
|
type account struct {
|
|
|
|
Account
|
|
|
|
Network *network `gorm:"embedded;embeddedPrefix:network_"`
|
2024-05-07 13:01:45 +02:00
|
|
|
Peers []peer `gorm:"foreignKey:AccountID;references:id"`
|
2024-04-18 18:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
act := &account{
|
|
|
|
Network: &network{
|
|
|
|
Net: *ipnet,
|
|
|
|
},
|
2024-05-07 13:01:45 +02:00
|
|
|
Peers: []peer{
|
|
|
|
{Location: location{ConnectionIP: net.IP{10, 0, 0, 1}}},
|
|
|
|
},
|
2024-04-18 18:14:21 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Save(act).Error
|
2024-04-18 18:14:21 +02:00
|
|
|
require.NoError(t, err, "Failed to insert Gob data")
|
|
|
|
|
|
|
|
type route struct {
|
|
|
|
route2.Route
|
|
|
|
Network netip.Prefix `gorm:"serializer:gob"`
|
|
|
|
PeerGroups []string `gorm:"serializer:gob"`
|
|
|
|
}
|
|
|
|
|
|
|
|
prefix := netip.MustParsePrefix("11.0.0.0/24")
|
|
|
|
rt := &route{
|
|
|
|
Network: prefix,
|
|
|
|
PeerGroups: []string{"group1", "group2"},
|
2024-06-18 15:39:54 +02:00
|
|
|
Route: route2.Route{ID: "route1"},
|
2024-04-18 18:14:21 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Save(rt).Error
|
2024-04-18 18:14:21 +02:00
|
|
|
require.NoError(t, err, "Failed to insert Gob data")
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = migrate(context.Background(), store.(*SqlStore).db)
|
2024-04-18 18:14:21 +02:00
|
|
|
require.NoError(t, err, "Migration should not fail on gob populated db")
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = migrate(context.Background(), store.(*SqlStore).db)
|
2024-04-18 18:14:21 +02:00
|
|
|
require.NoError(t, err, "Migration should not fail on migrated db")
|
2024-06-18 15:39:54 +02:00
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Delete(rt).Where("id = ?", "route1").Error
|
2024-06-18 15:39:54 +02:00
|
|
|
require.NoError(t, err, "Failed to delete Gob data")
|
|
|
|
|
|
|
|
prefix = netip.MustParsePrefix("12.0.0.0/24")
|
|
|
|
nRT := &route2.Route{
|
|
|
|
Network: prefix,
|
|
|
|
ID: "route2",
|
|
|
|
Peer: "peer-id",
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Save(nRT).Error
|
2024-06-18 15:39:54 +02:00
|
|
|
require.NoError(t, err, "Failed to insert json nil slice data")
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = migrate(context.Background(), store.(*SqlStore).db)
|
2024-06-18 15:39:54 +02:00
|
|
|
require.NoError(t, err, "Migration should not fail on json nil slice populated db")
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = migrate(context.Background(), store.(*SqlStore).db)
|
2024-06-18 15:39:54 +02:00
|
|
|
require.NoError(t, err, "Migration should not fail on migrated db")
|
|
|
|
|
2024-04-18 18:14:21 +02:00
|
|
|
}
|
|
|
|
|
2024-05-16 18:28:37 +02:00
|
|
|
func newSqliteStore(t *testing.T) *SqlStore {
|
2023-10-12 15:42:36 +02:00
|
|
|
t.Helper()
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
store, err := NewSqliteStore(context.Background(), t.TempDir(), nil)
|
2024-10-03 15:50:35 +02:00
|
|
|
t.Cleanup(func() {
|
|
|
|
store.Close(context.Background())
|
|
|
|
})
|
2023-10-12 15:42:36 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.NotNil(t, store)
|
|
|
|
|
|
|
|
return store
|
|
|
|
}
|
|
|
|
|
|
|
|
func newAccount(store Store, id int) error {
|
|
|
|
str := fmt.Sprintf("%s-%d", uuid.New().String(), id)
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), str, str+"-testuser", "example.com")
|
2023-10-12 15:42:36 +02:00
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
2023-11-28 13:45:26 +01:00
|
|
|
account.Peers["p"+str] = &nbpeer.Peer{
|
2023-10-12 15:42:36 +02:00
|
|
|
Key: "peerkey" + str,
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
2023-11-28 13:45:26 +01:00
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
2023-10-12 15:42:36 +02:00
|
|
|
Name: "peer name",
|
2023-11-28 13:45:26 +01:00
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
return store.SaveAccount(context.Background(), account)
|
2023-10-12 15:42:36 +02:00
|
|
|
}
|
2024-05-16 18:28:37 +02:00
|
|
|
|
|
|
|
func TestPostgresql_NewStore(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 0 {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expected to create a new empty Accounts map when creating a new FileStore")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_SaveAccount(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), "account_id", "testuser", "")
|
2024-05-16 18:28:37 +02:00
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
|
|
|
Key: "peerkey",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
|
|
|
Name: "peer name",
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account2 := newAccountWithId(context.Background(), "account_id2", "testuser2", "")
|
2024-05-16 18:28:37 +02:00
|
|
|
setupKey = GenerateDefaultSetupKey()
|
|
|
|
account2.SetupKeys[setupKey.Key] = setupKey
|
|
|
|
account2.Peers["testpeer2"] = &nbpeer.Peer{
|
|
|
|
Key: "peerkey2",
|
|
|
|
SetupKey: "peerkeysetupkey2",
|
|
|
|
IP: net.IP{127, 0, 0, 2},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
|
|
|
Name: "peer name 2",
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account2)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 2 {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting 2 Accounts to be stored after SaveAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
a, err := store.GetAccount(context.Background(), account.Id)
|
2024-05-16 18:28:37 +02:00
|
|
|
if a == nil {
|
|
|
|
t.Errorf("expecting Account to be stored after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy stored after SaveAccount(), got %d", len(a.Policies))
|
|
|
|
}
|
|
|
|
|
|
|
|
if a != nil && len(a.Policies[0].Rules) != 1 {
|
|
|
|
t.Errorf("expecting Account to have one policy rule stored after SaveAccount(), got %d", len(a.Policies[0].Rules))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByPeerPubKey(context.Background(), "peerkey"); a == nil {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting PeerKeyID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByUser(context.Background(), "testuser"); a == nil {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting UserID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountByPeerID(context.Background(), "testpeer"); a == nil {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting PeerID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if a, err := store.GetAccountBySetupKey(context.Background(), setupKey.Key); a == nil {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting SetupKeyID2AccountID index updated after SaveAccount(): %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_DeleteAccount(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
|
|
|
testUserID := "testuser"
|
|
|
|
user := NewAdminUser(testUserID)
|
|
|
|
user.PATs = map[string]*PersonalAccessToken{"testtoken": {
|
|
|
|
ID: "testtoken",
|
|
|
|
Name: "test token",
|
|
|
|
}}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account := newAccountWithId(context.Background(), "account_id", testUserID, "")
|
2024-05-16 18:28:37 +02:00
|
|
|
setupKey := GenerateDefaultSetupKey()
|
|
|
|
account.SetupKeys[setupKey.Key] = setupKey
|
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
|
|
|
Key: "peerkey",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
|
|
|
Name: "peer name",
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()},
|
|
|
|
}
|
|
|
|
account.Users[testUserID] = user
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 1 {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting 1 Accounts to be stored after SaveAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.DeleteAccount(context.Background(), account)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
if len(store.GetAllAccounts(context.Background())) != 0 {
|
2024-05-16 18:28:37 +02:00
|
|
|
t.Errorf("expecting 0 Accounts to be stored after DeleteAccount()")
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPeerPubKey(context.Background(), "peerkey")
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by peer public key")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByUser(context.Background(), "testuser")
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by user")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPeerID(context.Background(), "testpeer")
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by peer id")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountBySetupKey(context.Background(), setupKey.Key)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by setup key")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), account.Id)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "expecting error after removing DeleteAccount when getting account by id")
|
|
|
|
|
|
|
|
for _, policy := range account.Policies {
|
|
|
|
var rules []*PolicyRule
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Model(&PolicyRule{}).Find(&rules, "policy_id = ?", policy.ID).Error
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err, "expecting no error after removing DeleteAccount when searching for policy rules")
|
|
|
|
require.Len(t, rules, 0, "expecting no policy rules to be found after removing DeleteAccount")
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, accountUser := range account.Users {
|
|
|
|
var pats []*PersonalAccessToken
|
2024-10-10 12:35:03 +02:00
|
|
|
err = store.(*SqlStore).db.Model(&PersonalAccessToken{}).Find(&pats, "user_id = ?", accountUser.Id).Error
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err, "expecting no error after removing DeleteAccount when searching for personal access token")
|
|
|
|
require.Len(t, pats, 0, "expecting no personal access token to be found after removing DeleteAccount")
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_SavePeerStatus(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccount(context.Background(), "bf1c8084-ba50-4ce7-9439-34653001fc3b")
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
// save status of non-existing peer
|
|
|
|
newStatus := nbpeer.PeerStatus{Connected: true, LastSeen: time.Now().UTC()}
|
|
|
|
err = store.SavePeerStatus(account.Id, "non-existing-peer", newStatus)
|
|
|
|
assert.Error(t, err)
|
|
|
|
|
|
|
|
// save new status of existing peer
|
|
|
|
account.Peers["testpeer"] = &nbpeer.Peer{
|
|
|
|
Key: "peerkey",
|
|
|
|
ID: "testpeer",
|
|
|
|
SetupKey: "peerkeysetupkey",
|
|
|
|
IP: net.IP{127, 0, 0, 1},
|
|
|
|
Meta: nbpeer.PeerSystemMeta{},
|
|
|
|
Name: "peer name",
|
|
|
|
Status: &nbpeer.PeerStatus{Connected: false, LastSeen: time.Now().UTC()},
|
|
|
|
}
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
err = store.SaveAccount(context.Background(), account)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = store.SavePeerStatus(account.Id, "testpeer", newStatus)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err = store.GetAccount(context.Background(), account.Id)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
actual := account.Peers["testpeer"].Status
|
|
|
|
assert.Equal(t, newStatus.Connected, actual.Connected)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_TestGetAccountByPrivateDomain(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
|
|
|
existingDomain := "test.com"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
account, err := store.GetAccountByPrivateDomain(context.Background(), existingDomain)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err, "should found account")
|
|
|
|
require.Equal(t, existingDomain, account.Domain, "domains should match")
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
_, err = store.GetAccountByPrivateDomain(context.Background(), "missing-domain.com")
|
2024-05-16 18:28:37 +02:00
|
|
|
require.Error(t, err, "should return error on domain lookup")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_GetTokenIDByHashedToken(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
|
|
|
hashed := "SoMeHaShEdToKeN"
|
|
|
|
id := "9dj38s35-63fb-11ec-90d6-0242ac120003"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
token, err := store.GetTokenIDByHashedToken(context.Background(), hashed)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, id, token)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPostgresql_GetUserByTokenID(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
if (os.Getenv("CI") == "true" && runtime.GOOS == "darwin") || runtime.GOOS == "windows" {
|
|
|
|
t.Skip("skip CI tests on darwin and windows")
|
2024-05-16 18:28:37 +02:00
|
|
|
}
|
|
|
|
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(PostgresStoreEngine))
|
|
|
|
store, cleanUp, err := NewTestStoreFromSQL(context.Background(), "testdata/store.sql", t.TempDir())
|
|
|
|
t.Cleanup(cleanUp)
|
|
|
|
assert.NoError(t, err)
|
2024-05-16 18:28:37 +02:00
|
|
|
|
|
|
|
id := "9dj38s35-63fb-11ec-90d6-0242ac120003"
|
|
|
|
|
2024-07-03 11:33:02 +02:00
|
|
|
user, err := store.GetUserByTokenID(context.Background(), id)
|
2024-05-16 18:28:37 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, id, user.PATs[id].ID)
|
|
|
|
}
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
func TestSqlite_GetTakenIPs(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-03 15:50:35 +02:00
|
|
|
defer cleanup()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
existingAccountID := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-10-03 15:50:35 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), existingAccountID)
|
2024-09-16 15:47:03 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
takenIPs, err := store.GetTakenIPs(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, []net.IP{}, takenIPs)
|
|
|
|
|
|
|
|
peer1 := &nbpeer.Peer{
|
|
|
|
ID: "peer1",
|
|
|
|
AccountID: existingAccountID,
|
|
|
|
IP: net.IP{1, 1, 1, 1},
|
|
|
|
}
|
|
|
|
err = store.AddPeerToAccount(context.Background(), peer1)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
takenIPs, err = store.GetTakenIPs(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
ip1 := net.IP{1, 1, 1, 1}.To16()
|
|
|
|
assert.Equal(t, []net.IP{ip1}, takenIPs)
|
|
|
|
|
|
|
|
peer2 := &nbpeer.Peer{
|
|
|
|
ID: "peer2",
|
|
|
|
AccountID: existingAccountID,
|
|
|
|
IP: net.IP{2, 2, 2, 2},
|
|
|
|
}
|
|
|
|
err = store.AddPeerToAccount(context.Background(), peer2)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
takenIPs, err = store.GetTakenIPs(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
ip2 := net.IP{2, 2, 2, 2}.To16()
|
|
|
|
assert.Equal(t, []net.IP{ip1, ip2}, takenIPs)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_GetPeerLabelsInAccount(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-03 15:50:35 +02:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
t.Cleanup(cleanup)
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
existingAccountID := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-10-03 15:50:35 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), existingAccountID)
|
2024-09-16 15:47:03 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
labels, err := store.GetPeerLabelsInAccount(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, []string{}, labels)
|
|
|
|
|
|
|
|
peer1 := &nbpeer.Peer{
|
|
|
|
ID: "peer1",
|
|
|
|
AccountID: existingAccountID,
|
|
|
|
DNSLabel: "peer1.domain.test",
|
|
|
|
}
|
|
|
|
err = store.AddPeerToAccount(context.Background(), peer1)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
labels, err = store.GetPeerLabelsInAccount(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, []string{"peer1.domain.test"}, labels)
|
|
|
|
|
|
|
|
peer2 := &nbpeer.Peer{
|
|
|
|
ID: "peer2",
|
|
|
|
AccountID: existingAccountID,
|
|
|
|
DNSLabel: "peer2.domain.test",
|
|
|
|
}
|
|
|
|
err = store.AddPeerToAccount(context.Background(), peer2)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
labels, err = store.GetPeerLabelsInAccount(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, []string{"peer1.domain.test", "peer2.domain.test"}, labels)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_GetAccountNetwork(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-03 15:50:35 +02:00
|
|
|
t.Cleanup(cleanup)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
existingAccountID := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-10-03 15:50:35 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), existingAccountID)
|
2024-09-16 15:47:03 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
network, err := store.GetAccountNetwork(context.Background(), LockingStrengthShare, existingAccountID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
ip := net.IP{100, 64, 0, 0}.To16()
|
|
|
|
assert.Equal(t, ip, network.Net.IP)
|
|
|
|
assert.Equal(t, net.IPMask{255, 255, 0, 0}, network.Net.Mask)
|
|
|
|
assert.Equal(t, "", network.Dns)
|
|
|
|
assert.Equal(t, "af1c8024-ha40-4ce2-9418-34653101fc3c", network.Identifier)
|
|
|
|
assert.Equal(t, uint64(0), network.Serial)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_GetSetupKeyBySecret(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-03 15:50:35 +02:00
|
|
|
t.Cleanup(cleanup)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
existingAccountID := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-10-03 15:50:35 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), existingAccountID)
|
2024-09-16 15:47:03 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
setupKey, err := store.GetSetupKeyBySecret(context.Background(), LockingStrengthShare, "A2C8E62B-38F5-4553-B31E-DD66C696CEBB")
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "A2C8E62B-38F5-4553-B31E-DD66C696CEBB", setupKey.Key)
|
|
|
|
assert.Equal(t, "bf1c8084-ba50-4ce7-9439-34653001fc3b", setupKey.AccountID)
|
|
|
|
assert.Equal(t, "Default key", setupKey.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestSqlite_incrementSetupKeyUsage(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-03 15:50:35 +02:00
|
|
|
t.Cleanup(cleanup)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2024-09-16 15:47:03 +02:00
|
|
|
|
|
|
|
existingAccountID := "bf1c8084-ba50-4ce7-9439-34653001fc3b"
|
|
|
|
|
2024-10-03 15:50:35 +02:00
|
|
|
_, err = store.GetAccount(context.Background(), existingAccountID)
|
2024-09-16 15:47:03 +02:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
setupKey, err := store.GetSetupKeyBySecret(context.Background(), LockingStrengthShare, "A2C8E62B-38F5-4553-B31E-DD66C696CEBB")
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, 0, setupKey.UsedTimes)
|
|
|
|
|
|
|
|
err = store.IncrementSetupKeyUsage(context.Background(), setupKey.Id)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
setupKey, err = store.GetSetupKeyBySecret(context.Background(), LockingStrengthShare, "A2C8E62B-38F5-4553-B31E-DD66C696CEBB")
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, 1, setupKey.UsedTimes)
|
|
|
|
|
|
|
|
err = store.IncrementSetupKeyUsage(context.Background(), setupKey.Id)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
setupKey, err = store.GetSetupKeyBySecret(context.Background(), LockingStrengthShare, "A2C8E62B-38F5-4553-B31E-DD66C696CEBB")
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, 2, setupKey.UsedTimes)
|
|
|
|
}
|
2024-10-04 16:17:01 +02:00
|
|
|
|
|
|
|
func TestSqlite_CreateAndGetObjectInTransaction(t *testing.T) {
|
2024-10-10 12:35:03 +02:00
|
|
|
t.Setenv("NETBIRD_STORE_ENGINE", string(SqliteStoreEngine))
|
|
|
|
store, cleanup, err := NewTestStoreFromSQL(context.Background(), "testdata/extended-store.sql", t.TempDir())
|
2024-10-04 16:17:01 +02:00
|
|
|
t.Cleanup(cleanup)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2024-10-10 12:35:03 +02:00
|
|
|
|
2024-10-04 16:17:01 +02:00
|
|
|
group := &nbgroup.Group{
|
|
|
|
ID: "group-id",
|
|
|
|
AccountID: "account-id",
|
|
|
|
Name: "group-name",
|
|
|
|
Issued: "api",
|
|
|
|
Peers: nil,
|
|
|
|
}
|
|
|
|
err = store.ExecuteInTransaction(context.Background(), func(transaction Store) error {
|
|
|
|
err := transaction.SaveGroup(context.Background(), LockingStrengthUpdate, group)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("failed to save group")
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
group, err = transaction.GetGroupByID(context.Background(), LockingStrengthUpdate, group.ID, group.AccountID)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("failed to get group")
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
t.Logf("group: %v", group)
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
assert.NoError(t, err)
|
|
|
|
}
|