mirrors/dendrite
1
0
Fork 0
mirror of https://github.com/matrix-org/dendrite.git synced 2026-01-16 18:43:10 -06:00
Code Issues Packages Projects Releases Wiki Activity

Remove redundant tests for assumed offline table

Browse source
This commit is contained in:
Devon Hudson 2023-01-17 10:33:58 -07:00
parent 16eb9e4e49
commit 8090f20c20
No known key found for this signature in database
GPG key ID: CD06B18E77F6A628
2 changed files with 25 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
federationapi/storage/storage_test.go
View file

@ -254,35 +254,45 @@ func TestServersAssumedOffline(t *testing.T) {
db, closeDB := mustCreateFederationDatabase(t, dbType)
defer closeDB()
// Set server1 & server2 as assumed offline.
err := db.SetServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
isOffline, err := db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.True(t, isOffline)
err = db.RemoveServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
isOffline, err = db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.False(t, isOffline)
err = db.SetServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
err = db.SetServerAssumedOffline(context.Background(), server2)
assert.Nil(t, err)
isOffline, err = db.IsServerAssumedOffline(context.Background(), server1)
// Ensure both servers are assumed offline.
isOffline, err := db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.True(t, isOffline)
isOffline, err = db.IsServerAssumedOffline(context.Background(), server2)
assert.Nil(t, err)
assert.True(t, isOffline)
// Set server1 as not assumed offline.
err = db.RemoveServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
// Ensure both servers have correct state.
isOffline, err = db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.False(t, isOffline)
isOffline, err = db.IsServerAssumedOffline(context.Background(), server2)
assert.Nil(t, err)
assert.True(t, isOffline)
// Re-set server1 as assumed offline.
err = db.SetServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
// Ensure server1 is assumed offline.
isOffline, err = db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.True(t, isOffline)
err = db.RemoveAllServersAssumedOffline(context.Background())
assert.Nil(t, err)
// Ensure both servers have correct state.
isOffline, err = db.IsServerAssumedOffline(context.Background(), server1)
assert.Nil(t, err)
assert.False(t, isOffline)

152
federationapi/storage/tables/assumed_offline_table_test.go
View file

@ -1,152 +0,0 @@
package tables_test
import (
"context"
"database/sql"
"testing"
"github.com/matrix-org/dendrite/federationapi/storage/postgres"
"github.com/matrix-org/dendrite/federationapi/storage/sqlite3"
"github.com/matrix-org/dendrite/federationapi/storage/tables"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/dendrite/setup/config"
"github.com/matrix-org/dendrite/test"
"github.com/stretchr/testify/assert"
)
type AssumedOfflineDatabase struct {
DB *sql.DB
Writer sqlutil.Writer
Table tables.FederationAssumedOffline
}
func mustCreateAssumedOfflineTable(t *testing.T, dbType test.DBType) (database AssumedOfflineDatabase, close func()) {
t.Helper()
connStr, close := test.PrepareDBConnectionString(t, dbType)
db, err := sqlutil.Open(&config.DatabaseOptions{
ConnectionString: config.DataSource(connStr),
}, sqlutil.NewExclusiveWriter())
assert.NoError(t, err)
var tab tables.FederationAssumedOffline
switch dbType {
case test.DBTypePostgres:
tab, err = postgres.NewPostgresAssumedOfflineTable(db)
assert.NoError(t, err)
case test.DBTypeSQLite:
tab, err = sqlite3.NewSQLiteAssumedOfflineTable(db)
assert.NoError(t, err)
}
assert.NoError(t, err)
database = AssumedOfflineDatabase{
DB: db,
Writer: sqlutil.NewDummyWriter(),
Table: tab,
}
return database, close
}
func TestShouldInsertAssumedOfflineServer(t *testing.T) {
ctx := context.Background()
test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
db, close := mustCreateAssumedOfflineTable(t, dbType)
defer close()
err := db.Table.InsertAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed inserting server: %s", err.Error())
}
isOffline, err := db.Table.SelectAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed retrieving server: %s", err.Error())
}
assert.Equal(t, true, isOffline)
})
}
func TestShouldDeleteCorrectAssumedOfflineServer(t *testing.T) {
ctx := context.Background()
test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
db, close := mustCreateAssumedOfflineTable(t, dbType)
defer close()
err := db.Table.InsertAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed inserting server: %s", err.Error())
}
err = db.Table.InsertAssumedOffline(ctx, nil, server2)
if err != nil {
t.Fatalf("Failed inserting server: %s", err.Error())
}
isOffline, err := db.Table.SelectAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, true, isOffline)
err = db.Table.DeleteAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed deleting server: %s", err.Error())
}
isOffline, err = db.Table.SelectAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, false, isOffline)
isOffline2, err := db.Table.SelectAssumedOffline(ctx, nil, server2)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, true, isOffline2)
})
}
func TestShouldDeleteAllAssumedOfflineServers(t *testing.T) {
ctx := context.Background()
test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
db, close := mustCreateAssumedOfflineTable(t, dbType)
defer close()
err := db.Table.InsertAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed inserting server: %s", err.Error())
}
err = db.Table.InsertAssumedOffline(ctx, nil, server2)
if err != nil {
t.Fatalf("Failed inserting server: %s", err.Error())
}
isOffline, err := db.Table.SelectAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, true, isOffline)
isOffline2, err := db.Table.SelectAssumedOffline(ctx, nil, server2)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, true, isOffline2)
err = db.Table.DeleteAllAssumedOffline(ctx, nil)
if err != nil {
t.Fatalf("Failed deleting server: %s", err.Error())
}
isOffline, err = db.Table.SelectAssumedOffline(ctx, nil, server1)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, false, isOffline)
isOffline2, err = db.Table.SelectAssumedOffline(ctx, nil, server2)
if err != nil {
t.Fatalf("Failed retrieving server status: %s", err.Error())
}
assert.Equal(t, false, isOffline2)
})
}