Fix tests on CI (2)

scnserver/test/database_test.go

@@ -294,582 +294,34 @@ func TestRequestsDB_Current(t *testing.T) {
 }
 
 func TestPrimaryDB_Migrate_from_3_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 3
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 3)
 }
 
 func TestPrimaryDB_Migrate_from_4_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 4
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 4)
 }
 
 func TestPrimaryDB_Migrate_from_5_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 5
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 5)
 }
 
 func TestPrimaryDB_Migrate_from_6_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 6
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 6)
 }
 
 func TestPrimaryDB_Migrate_from_7_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 7
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 7)
 }
 
 func TestPrimaryDB_Migrate_from_8_to_latest(t *testing.T) {
-	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
-	defer stop()
-
-	ctx := context.Background()
-
-	tt.AssertAny(dbf1)
-	tt.AssertAny(dbf2)
-	tt.AssertAny(dbf3)
-	tt.AssertAny(conf)
-
-	schemavers := 8
-
-	{
-		url := fmt.Sprintf("file:%s", dbf1)
-
-		xdb, err := sqlx.Open("sqlite3", url)
-		tt.TestFailIfErr(t, err)
-
-		qqdb := sq.NewDB(xdb, sq.DBOptions{})
-
-		dbschema := schema.PrimarySchema[schemavers]
-
-		_, err = qqdb.Exec(ctx, dbschema.SQL, sq.PP{})
-		tt.TestFailIfErr(t, err)
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
-			"key": "schema",
-			"val": schemavers,
-		})
-
-		_, err = qqdb.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
-			"key": "schema_hash",
-			"val": dbschema.Hash,
-		})
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, qqdb)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", dbschema.Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = qqdb.Exit()
-		tt.TestFailIfErr(t, err)
-	}
-
-	{
-		db1, err := primary.NewPrimaryDatabase(conf)
-		tt.TestFailIfErr(t, err)
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema1, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema1", schemavers, schema1)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		//================================================
-		{
-			err = db1.Migrate(ctx)
-			tt.TestFailIfErr(t, err)
-		}
-		//================================================
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-
-			schema2, err := db1.ReadSchema(tctx)
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schema2", schema.PrimarySchemaVersion, schema2)
-
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		{
-			tctx := simplectx.CreateSimpleContext(ctx, nil)
-			schemHashDB, err := sq.HashSqliteDatabase(tctx, db1.DB())
-			tt.TestFailIfErr(t, err)
-			tt.AssertEqual(t, "schemHashDB", schema.PrimarySchema[schema.PrimarySchemaVersion].Hash, schemHashDB)
-			err = tctx.CommitTransaction()
-			tt.TestFailIfErr(t, err)
-		}
-
-		err = db1.Stop(ctx)
-		tt.TestFailIfErr(t, err)
-	}
+	_internalTestPrimaryDBMigrateToLatest(t, 9)
 }
 
 func TestPrimaryDB_Migrate_from_9_to_latest(t *testing.T) {
+	_internalTestPrimaryDBMigrateToLatest(t, 9)
+}
+
+func _internalTestPrimaryDBMigrateToLatest(t *testing.T, schemavers int) {
 	dbf1, dbf2, dbf3, conf, stop := tt.StartSimpleTestspace(t)
 	defer stop()
 
@@ -880,8 +332,6 @@ func TestPrimaryDB_Migrate_from_9_to_latest(t *testing.T) {
 	tt.AssertAny(dbf3)
 	tt.AssertAny(conf)
 
-	schemavers := 9
-
 	{
 		url := fmt.Sprintf("file:%s", dbf1)
 

scnserver/test/requestlog_test.go

@@ -130,21 +130,22 @@ func TestRequestLogAPI(t *testing.T) {
 	defer stop()
 
 	data := tt.InitDefaultData(t, ws)
-	time.Sleep(900 * time.Millisecond)
+	time.Sleep(5000 * time.Millisecond)
 
-	ctx := ws.NewSimpleTransactionContext(5 * time.Second)
-	defer ctx.Cancel()
+	ctx1 := ws.NewSimpleTransactionContext(5 * time.Second)
+	defer ctx1.Cancel()
 
-	rl1, _, err := ws.Database.Requests.ListRequestLogs(ctx, models.RequestLogFilter{}, nil, ct.Start())
+	rl1, _, err := ws.Database.Requests.ListRequestLogs(ctx1, models.RequestLogFilter{}, nil, ct.Start())
 	tt.TestFailIfErr(t, err)
 
 	tt.RequestAuthGet[gin.H](t, data.User[0].ReadKey, baseUrl, "/api/v2/users/"+data.User[0].UID)
-	time.Sleep(900 * time.Millisecond)
 
-	ws.MainDatabaseLock.Lock()
-	defer ws.MainDatabaseLock.Unlock()
+	time.Sleep(5000 * time.Millisecond)
 
-	rl2, _, err := ws.Database.Requests.ListRequestLogs(ctx, models.RequestLogFilter{}, nil, ct.Start())
+	ctx2 := ws.NewSimpleTransactionContext(5 * time.Second)
+	defer ctx2.Cancel()
+
+	rl2, _, err := ws.ListRequestLogs(ctx2, models.RequestLogFilter{}, nil, ct.Start())
 	tt.TestFailIfErr(t, err)
 
 	tt.AssertEqual(t, "requestlog.count", len(rl1)+1, len(rl2))