mobility-accounts/storage/postgresql_test.go

package storage

import (
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/spf13/viper"
	"reflect"
	"testing"
)

// Tests must be run in order

var cfg *viper.Viper

func init() {
	cfg = viper.New()
	cfg.Set("storage.db.psql.host", "localhost")
	cfg.Set("storage.db.psql.port", "5432")
	cfg.Set("storage.db.psql.user", "postgres")
	cfg.Set("storage.db.psql.password", "postgres")
	cfg.Set("storage.db.psql.dbname", "mobilityaccounts")
}

func TestNewPostgresqlStorage(t *testing.T) {
	storage, err := NewPostgresqlStorage(cfg)
	storage.DbConnection.Exec("Delete from account_auth ;")
	storage.DbConnection.Exec("Delete from accounts ;")
	if err != nil {
		t.Errorf("error creating new PostgreSQL storage: %v", err)
	}
	defer storage.DbConnection.Close()
}

func generateUUIDv4() string {
	uuid := make([]byte, 16)
	_, err := rand.Read(uuid)
	if err != nil {
		panic(err)
	}
	uuid[6] = (uuid[6] & 0x0f) | 0x40
	uuid[8] = (uuid[8] & 0xbf) | 0x80
	return hex.EncodeToString(uuid[:4]) + "-" + hex.EncodeToString(uuid[4:6]) + "-" +
		hex.EncodeToString(uuid[6:8]) + "-" + hex.EncodeToString(uuid[8:10]) + "-" +
		hex.EncodeToString(uuid[10:])
}

func TestGetAccount(t *testing.T) {
	// Open a database connection
	db, err := NewPostgresqlStorage(cfg)
	Id := generateUUIDv4()
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	// Insert data into accounts table
	accountData := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	accountMetadata := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	account := Account{
		ID:        Id,
		Namespace: "test_namespace",
		Data:      accountData,
		Metadata:  accountMetadata,
	}
	dataJSON, err := json.Marshal(map[string]any{
		"key1": "value1",
		"key2": "value2",
	})
	if err != nil {
		t.Errorf("error account data and metdata")
	}
	_, err = db.DbConnection.Exec("INSERT INTO accounts (id, namespace, data, metadata) "+
		"VALUES ($1, $2, $3, $4)", account.ID, account.Namespace, dataJSON, dataJSON)
	if err != nil {
		t.Errorf("error in inserting a new account")
	}
	// Insert data into account_auth table
	emailValidation := Validation{
		Validated:      true,
		ValidationCode: "code",
	}
	localAuth := LocalAuth{
		Username:              "testuser",
		Password:              "testpassword",
		Email:                 "test@test.com",
		EmailValidation:       emailValidation,
		PhoneNumber:           "1234567890",
		PhoneNumberValidation: emailValidation,
	}
	localAuthJSON, err := json.Marshal(emailValidation)
	if err != nil {
		t.Errorf("error account_auth localAuth")
	}
	_, err = db.DbConnection.Exec("INSERT INTO account_auth (account_id, username, password, "+
		"email, email_validation, "+
		"phone_number,phone_number_validation) VALUES ($1, $2, $3, $4, $5, $6, $7)", account.ID,
		localAuth.Username, localAuth.Password, localAuth.Email, localAuthJSON, localAuth.PhoneNumber, localAuthJSON)
	if err != nil {
		fmt.Println(err)
		t.Errorf("error in iserting a new account in account_auth")
	}
	account_, err := db.GetAccount(Id)
	if err != nil {
		t.Errorf("failed")
		fmt.Println(err)
	}
	expectedAccount := &Account{
		ID:        Id,
		Namespace: "test_namespace",
		Data:      accountData,
		Metadata:  accountMetadata,
		Authentication: AccountAuth{
			Local: localAuth,
		},
	}
	if reflect.DeepEqual(account_, expectedAccount) {
		fmt.Println("PASS")
	} else {
		t.Errorf("The received account is not the same as expected")
	}
}

func TestPostgresqlStorage_CreateAccount(t *testing.T) {
	db, err := NewPostgresqlStorage(cfg)
	Id := generateUUIDv4()
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	emailValidation := Validation{
		Validated:      true,
		ValidationCode: "code",
	}
	localAuth := LocalAuth{
		Username:              "salim",
		Password:              "testpassword",
		Email:                 "test@test.com",
		EmailValidation:       emailValidation,
		PhoneNumber:           "1234567890",
		PhoneNumberValidation: emailValidation,
	}
	accountData := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	accountMetadata := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	account := Account{
		ID:        Id,
		Namespace: "namespace",
		Authentication: AccountAuth{
			Local: localAuth,
		},
		Data:     accountData,
		Metadata: accountMetadata,
	}
	err = db.CreateAccount(account)
	if err != nil {
		fmt.Println(err)
		t.Errorf("Failed to create account")
	}
}

func TestPostgresqlStorage_UpdateAccount(t *testing.T) {
	db, err := NewPostgresqlStorage(cfg)
	Id := generateUUIDv4()
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	emailValidation := Validation{
		Validated:      true,
		ValidationCode: "code",
	}
	localAuth := LocalAuth{
		Username:              "salim",
		Password:              "testpassword",
		Email:                 "test@test.com",
		EmailValidation:       emailValidation,
		PhoneNumber:           "1234567890",
		PhoneNumberValidation: emailValidation,
	}
	accountData := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	accountMetadata := map[string]any{
		"key1": "value1",
		"key2": "value2",
	}
	account := Account{
		ID:        Id,
		Namespace: "test_namespace",
		Authentication: AccountAuth{
			Local: localAuth,
		},
		Data:     accountData,
		Metadata: accountMetadata,
	}
	err = db.CreateAccount(account)
	if err != nil {
		fmt.Println(err)
		t.Errorf("Failed to create account")
	}
	account2 := Account{
		ID:        Id,
		Namespace: "salim",
		Authentication: AccountAuth{
			Local: LocalAuth{
				Username: "salim",
				Password: "salim",
				Email:    "salim@test.com",
				EmailValidation: Validation{
					Validated:      false,
					ValidationCode: "123",
				},
				PhoneNumber: "12345",
				PhoneNumberValidation: Validation{
					Validated:      true,
					ValidationCode: "1233",
				},
			},
		},
		Data: map[string]any{
			"key1": "salim1",
			"key2": "salim2",
		},
		Metadata: map[string]any{
			"key1": "salim1",
			"key2": "salim2",
		},
	}
	err = db.UpdateAccount(account2)
	if err != nil {
		fmt.Println(err)
		t.Errorf("failed")
	}
}

func TestPostgresqlStorage_LocalAuthentication(t *testing.T) {
	db, err := NewPostgresqlStorage(cfg)
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	accountByUsername, err := db.LocalAuthentication("test_namespace", "testuser",
		"", "")
	if err != nil {
		t.Errorf("Failed LocalAuthentication based on username and namespace")
	}
	fmt.Println(accountByUsername)
	accountByEmail, err := db.LocalAuthentication("test_namespace", "",
		"test@test.com", "")
	if err != nil {
		t.Errorf("Failed LocalAuthentication based on username and namespace")
	}
	fmt.Println(accountByEmail)
	accountByPhone, err := db.LocalAuthentication("test_namespace", "",
		"", "1234567890")
	if err != nil {
		t.Errorf("Failed LocalAuthentication based on username and namespace")
	}
	fmt.Println(accountByPhone)
	accountByAll, err := db.LocalAuthentication("test_namespace", "testuser",
		"test@test.com", "1234567890")
	if err != nil {
		t.Errorf("Failed LocalAuthentication based on username and namespace")
	}
	fmt.Println(accountByAll)
}

func TestPostgresqlStorage_GetAccounts(t *testing.T) {
	db, err := NewPostgresqlStorage(cfg)
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	accounts, err := db.GetAccounts([]string{"test_namespace", "salim", "namespace"})
	if err != nil {
		t.Errorf("Failed")
	}
	for _, account := range accounts {
		fmt.Println(account)
	}
}

func TestPostgresqlStorage_GetAccountsByIds(t *testing.T) {
	db, err := NewPostgresqlStorage(cfg)
	if err != nil {
		t.Errorf("failed to create new psql connection")
	}
	account := Account{
		ID:        "772315f1-8113-486a-90c7-9073410065bd",
		Namespace: "oo",
		Authentication: AccountAuth{
			Local: LocalAuth{
				Username: "username",
				Password: "password",
				Email:    "salim@test.com",
				EmailValidation: Validation{
					Validated:      true,
					ValidationCode: "123",
				},
				PhoneNumber: "12345",
				PhoneNumberValidation: Validation{
					Validated:      true,
					ValidationCode: "1233",
				},
			},
		},
		Data: map[string]any{
			"key1": "salim1",
			"key2": "salim2",
		},
		Metadata: map[string]any{
			"key1": "salim1",
			"key2": "salim2",
		},
	}
	err = db.CreateAccount(account)
	if err != nil {
		t.Errorf("Failed to create account")
	}
	accounts, err := db.GetAccountsByIds([]string{"772315f1-8113-486a-90c7-9073410065bd"})
	if err != nil {
		t.Errorf("Failed to get account by ID")
	}
	for _, acc := range accounts {
		fmt.Println(acc)
	}
}