390 lines
11 KiB
Go
390 lines
11 KiB
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)
|
|
}
|