status-go/services/wallet/walletconnect/database_test.go

package walletconnect

import (
	"strconv"
	"testing"

	"database/sql"

	"github.com/status-im/status-go/services/wallet/common"

	"github.com/stretchr/testify/require"
)

type urlOverride *string
type timestampOverride *int64

// testSession will override defaults for the fields that are not null
type testSession struct {
	url          urlOverride
	created      timestampOverride
	expiry       timestampOverride
	disconnected *bool
	testChains   *bool
}

const testDappUrl = "https://test.url/"

// generateTestData generates alternative disconnected and active sessions starting with the active one
// timestamps start with 1234567890 and increase by 1 for each session
// all sessions will share the same two pairing sessions (roll over after index 1)
// testChains is false if not overridden
func generateTestData(sessions []testSession) []DBSession {
	res := make([]DBSession, len(sessions))
	pairingIdx := 0
	for i := 0; i < len(res); i++ {
		strI := strconv.Itoa(i)
		if i%2 == 0 {
			pairingIdx++
		}
		pairingIdxStr := strconv.Itoa(pairingIdx)

		s := sessions[i]

		url := testDappUrl + strI
		if s.url != nil {
			url = *s.url
		}

		createdTimestamp := 1234567890 + int64(i)
		if s.created != nil {
			createdTimestamp = *s.created
		}

		expiryTimestamp := createdTimestamp + 1000 + int64(i)
		if s.expiry != nil {
			expiryTimestamp = *s.expiry
		}

		disconnected := (i % 2) != 0
		if s.disconnected != nil {
			disconnected = *s.disconnected
		}

		testChains := false
		if s.testChains != nil {
			testChains = *s.testChains
		}

		res[i] = DBSession{
			Topic:            Topic(strI + "aaaaaa1234567890"),
			Disconnected:     disconnected,
			SessionJSON:      "{}",
			Expiry:           expiryTimestamp,
			CreatedTimestamp: createdTimestamp,
			PairingTopic:     Topic(pairingIdxStr + "bbbbbb1234567890"),
			TestChains:       testChains,
			DBDApp: DBDApp{
				URL:     url,
				Name:    "TestApp" + strI,
				IconURL: "https://test.icon" + strI,
			},
		}
	}
	return res
}

func insertTestData(t *testing.T, db *sql.DB, entries []DBSession) {
	for _, entry := range entries {
		err := UpsertSession(db, entry)
		require.NoError(t, err)
	}
}

func TestInsertUpdateAndGetSession(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	entry := generateTestData(make([]testSession, 1))[0]
	err := UpsertSession(db, entry)
	require.NoError(t, err)

	retrievedSession, err := GetSessionByTopic(db, entry.Topic)
	require.NoError(t, err)

	require.Equal(t, entry, *retrievedSession)

	updatedEntry := entry
	updatedEntry.Disconnected = true
	updatedEntry.Expiry = 1111111111
	err = UpsertSession(db, updatedEntry)

	require.NoError(t, err)

	retrievedSession, err = GetSessionByTopic(db, updatedEntry.Topic)
	require.NoError(t, err)

	require.Equal(t, updatedEntry, *retrievedSession)
}

func TestInsertAndGetSessionsByPairingTopic(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	generatedSessions := generateTestData(make([]testSession, 4))
	for _, session := range generatedSessions {
		err := UpsertSession(db, session)
		require.NoError(t, err)
	}

	retrievedSessions, err := GetSessionsByPairingTopic(db, generatedSessions[2].Topic)
	require.NoError(t, err)
	require.Equal(t, 0, len(retrievedSessions))

	retrievedSessions, err = GetSessionsByPairingTopic(db, generatedSessions[2].PairingTopic)
	require.NoError(t, err)
	require.Equal(t, 2, len(retrievedSessions))

	for i := 2; i < 4; i++ {
		found := false
		for _, session := range retrievedSessions {
			if session.Topic == generatedSessions[i].Topic {
				found = true
				require.Equal(t, generatedSessions[i], session)
			}
		}
		require.True(t, found)
	}
}

func TestGet(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	entries := generateTestData(make([]testSession, 3))
	insertTestData(t, db, entries)

	retrievedSession, err := GetSessionByTopic(db, entries[1].Topic)
	require.NoError(t, err)

	require.Equal(t, entries[1], *retrievedSession)

	err = DeleteSession(db, entries[1].Topic)
	require.NoError(t, err)

	deletedSession, err := GetSessionByTopic(db, entries[1].Topic)
	require.ErrorIs(t, err, sql.ErrNoRows)
	require.Nil(t, deletedSession)
}

func TestGetActiveSessions(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	// insert two disconnected and three active sessions
	entries := generateTestData(make([]testSession, 5))
	insertTestData(t, db, entries)

	activeSessions, err := GetActiveSessions(db, entries[2].Expiry)
	require.NoError(t, err)

	require.Equal(t, 2, len(activeSessions))
	// Expect newest on top
	require.Equal(t, entries[4], activeSessions[0])
	require.Equal(t, entries[2], activeSessions[1])
}

func TestDeleteSession(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	entries := generateTestData(make([]testSession, 3))
	insertTestData(t, db, entries)

	err := DeleteSession(db, entries[1].Topic)
	require.NoError(t, err)

	sessions, err := GetSessions(db)
	require.NoError(t, err)
	require.Equal(t, 2, len(sessions))

	require.Equal(t, entries[0], sessions[1])
	require.Equal(t, entries[2], sessions[0])

	err = DeleteSession(db, entries[0].Topic)
	require.NoError(t, err)
	err = DeleteSession(db, entries[2].Topic)
	require.NoError(t, err)

	sessions, err = GetSessions(db)
	require.NoError(t, err)
	require.Equal(t, 0, len(sessions))
}

// urlFor prepares a value to be used in testSession
func urlFor(i int) urlOverride {
	return common.NewAndSet(testDappUrl + strconv.Itoa(i))
}

// at prepares a value to be used in testSession
func at(i int) timestampOverride {
	return common.NewAndSet(int64(i))
}

// TestGetActiveDapps_JoinWorksAsExpected also validates that GetActiveDapps returns the dapps in the order of the last first time added
func TestGetActiveDapps_JoinWorksAsExpected(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	not := common.NewAndSet(false)
	// The first creation date is 1, 2, 3 but the last name update is, respectively, 1, 4, 5
	entries := generateTestData([]testSession{
		{url: urlFor(1), created: at(1), disconnected: not},
		{url: urlFor(1), created: at(2), disconnected: not},
		{url: urlFor(2), created: at(3), disconnected: not},
		{url: urlFor(3), created: at(4), disconnected: not},
		{url: urlFor(2), created: at(5), disconnected: not},
		{url: urlFor(3), created: at(6), disconnected: not},
	})
	insertTestData(t, db, entries)

	getTestnet := false
	validAtTimestamp := entries[0].Expiry
	dapps, err := GetActiveDapps(db, validAtTimestamp, getTestnet)
	require.NoError(t, err)
	require.Equal(t, 3, len(dapps))

	require.Equal(t, 3, len(dapps))
	require.Equal(t, entries[5].Name, dapps[0].Name)
	require.Equal(t, entries[4].Name, dapps[1].Name)
	require.Equal(t, entries[1].Name, dapps[2].Name)
}

// TestGetActiveDapps_ActiveWorksAsExpected tests the combination of disconnected and expired sessions
func TestGetActiveDapps_ActiveWorksAsExpected(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	not := common.NewAndSet(false)
	yes := common.NewAndSet(true)
	timeNow := 4
	entries := generateTestData([]testSession{
		{url: urlFor(1), expiry: at(timeNow - 3), disconnected: not},
		{url: urlFor(1), expiry: at(timeNow - 2), disconnected: yes},
		{url: urlFor(2), expiry: at(timeNow - 2), disconnected: not},
		{url: urlFor(3), expiry: at(timeNow - 1), disconnected: yes},
		// ----- timeNow
		{url: urlFor(3), expiry: at(timeNow + 1), disconnected: not},
		{url: urlFor(4), expiry: at(timeNow + 1), disconnected: yes},
		{url: urlFor(4), expiry: at(timeNow + 2), disconnected: not},
		{url: urlFor(5), expiry: at(timeNow + 2), disconnected: yes},
		{url: urlFor(6), expiry: at(timeNow + 3), disconnected: not},
	})
	insertTestData(t, db, entries)

	getTestnet := false
	dapps, err := GetActiveDapps(db, int64(timeNow), getTestnet)
	require.NoError(t, err)
	require.Equal(t, 3, len(dapps))
}

// TestGetActiveDapps_TestChainsWorksAsExpected tests the combination of disconnected and expired sessions
func TestGetActiveDapps_TestChainsWorksAsExpected(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	not := common.NewAndSet(false)
	yes := common.NewAndSet(true)
	timeNow := 4
	entries := generateTestData([]testSession{
		{url: urlFor(1), testChains: not, expiry: at(timeNow - 3), disconnected: not},
		{url: urlFor(2), testChains: yes, expiry: at(timeNow - 2), disconnected: not},
		{url: urlFor(2), testChains: not, expiry: at(timeNow - 1), disconnected: not},
		// ----- timeNow
		{url: urlFor(3), testChains: not, expiry: at(timeNow + 1), disconnected: not},
		{url: urlFor(4), testChains: not, expiry: at(timeNow + 2), disconnected: not},
		{url: urlFor(4), testChains: yes, expiry: at(timeNow + 3), disconnected: not},
		{url: urlFor(5), testChains: yes, expiry: at(timeNow + 4), disconnected: not},
	})
	insertTestData(t, db, entries)

	getTestnet := true
	dapps, err := GetActiveDapps(db, int64(timeNow), getTestnet)
	require.NoError(t, err)
	require.Equal(t, 2, len(dapps))
}

// TestGetDapps_EmptyDB tests that an empty database will return an empty list
func TestGetDapps_EmptyDB(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	entries := generateTestData([]testSession{})
	insertTestData(t, db, entries)

	getTestnet := false
	validAtTimestamp := int64(0)
	dapps, err := GetActiveDapps(db, validAtTimestamp, getTestnet)
	require.NoError(t, err)
	require.Equal(t, 0, len(dapps))
}

// TestGetDapps_OrphanDapps tests that missing session will place the dapp at the end
func TestGetDapps_OrphanDapps(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	not := common.NewAndSet(false)
	entries := generateTestData([]testSession{
		{url: urlFor(1), disconnected: not},
		{url: urlFor(2), disconnected: not},
		{url: urlFor(2), disconnected: not},
	})
	insertTestData(t, db, entries)

	err := DeleteSession(db, entries[1].Topic)
	require.NoError(t, err)
	err = DeleteSession(db, entries[2].Topic)
	require.NoError(t, err)

	getTestnet := false
	validAtTimestamp := entries[0].Expiry
	dapps, err := GetActiveDapps(db, validAtTimestamp, getTestnet)
	require.NoError(t, err)
	// The orphan dapp is not considered active
	require.Equal(t, 1, len(dapps))
	require.Equal(t, entries[0].Name, dapps[0].Name)
}

func TestDisconnectSession(t *testing.T) {
	db, close := SetupTestDB(t)
	defer close()

	not := common.NewAndSet(false)
	entries := generateTestData([]testSession{
		{url: urlFor(1), disconnected: not},
		{url: urlFor(2), disconnected: not},
		{url: urlFor(2), disconnected: not},
	})
	insertTestData(t, db, entries)

	activeSessions, err := GetActiveSessions(db, 0)
	require.NoError(t, err)
	require.Equal(t, 3, len(activeSessions))

	getTestnet := false
	validAtTimestamp := entries[0].Expiry
	dapps, err := GetActiveDapps(db, validAtTimestamp, getTestnet)
	require.NoError(t, err)
	require.Equal(t, 2, len(dapps))

	err = DisconnectSession(db, entries[1].Topic)
	require.NoError(t, err)

	activeSessions, err = GetActiveSessions(db, 0)
	require.NoError(t, err)
	require.Equal(t, 2, len(activeSessions))

	err = DisconnectSession(db, entries[2].Topic)
	require.NoError(t, err)

	activeSessions, err = GetActiveSessions(db, 0)
	require.NoError(t, err)
	require.Equal(t, 1, len(activeSessions))

	dapps, err = GetActiveDapps(db, validAtTimestamp, getTestnet)
	require.NoError(t, err)
	require.Equal(t, 1, len(dapps))
	require.Equal(t, entries[0].Name, dapps[0].Name)
}