Merged in bugfix/tests (pull request #107)

Fix Fullsuite

* save

* foundthefix..

* codeandrequire

internal/database/repository/clean_test.go

@@ -11,6 +11,7 @@ import (
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestClean(t *testing.T) {
@@ -34,18 +35,18 @@ func TestClean(t *testing.T) {
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	hash := "example_hash"
 	id, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, id)
 
 	isclean, err := queries.HasDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isclean)
 
 	bucket := "example_bucket"
@@ -71,19 +72,19 @@ func TestClean(t *testing.T) {
 		Documentid: id,
 		Fail:       fail,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Version: 1,
 		Cleanid: failcleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	isclean, err = queries.HasDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isclean)
 
 	clean, err := queries.GetCleanEntry(ctx, failcleanid)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, clean.Documentid)
 	assert.Nil(t, clean.Bucket)
 	assert.Nil(t, clean.Key)
@@ -97,19 +98,19 @@ func TestClean(t *testing.T) {
 		Key:        &key,
 		Mimetype:   mimetype,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Version: 2,
 		Cleanid: cleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	isclean, err = queries.HasDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isclean)
 
 	clean, err = queries.GetCleanEntry(ctx, cleanid)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, clean.Documentid)
 	assert.False(t, clean.Fail.Valid)
 	assert.Equal(t, bucket, *clean.Bucket)
@@ -119,11 +120,11 @@ func TestClean(t *testing.T) {
 	assert.Equal(t, cleanid, clean.ID)
 
 	docclean, err := queries.GetCleanEntryByDocId(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, clean, docclean)
 
 	recent, err := queries.GetMostRecentDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, clean.Documentid, recent.Documentid)
 	assert.Equal(t, clean.Bucket, recent.Bucket)
 	assert.Equal(t, clean.Key, recent.Key)
@@ -133,25 +134,25 @@ func TestClean(t *testing.T) {
 	assert.Equal(t, clean.ID, recent.ID)
 
 	version, err := queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Clientid:  clientId,
 		Versionid: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetCollectorCleanVersion(ctx, &repository.SetCollectorCleanVersionParams{
 		Clientid:     clientId,
 		Versionid:    5,
 		Addedversion: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	isclean, err = queries.HasDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isclean)
 
 	recent, err = queries.GetMostRecentDocumentCleanEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, clean.Documentid, recent.Documentid)
 	assert.Equal(t, clean.Bucket, recent.Bucket)
 	assert.Equal(t, clean.Key, recent.Key)

internal/database/repository/client_test.go

@@ -11,6 +11,7 @@ import (
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestClient(t *testing.T) {
@@ -36,11 +37,11 @@ func TestClient(t *testing.T) {
 		Name:       name,
 		Externalid: externalId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, id)
 
 	client, err := queries.GetClient(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullclient{
 		ID:         id,
 		Name:       name,
@@ -49,7 +50,7 @@ func TestClient(t *testing.T) {
 	}, client)
 
 	externalClient, err := queries.GetClientByExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, client, externalClient)
 
 	name = "updated_client"
@@ -57,10 +58,10 @@ func TestClient(t *testing.T) {
 		ID:   id,
 		Name: name,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	client, err = queries.GetClient(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullclient{
 		ID:         id,
 		Name:       name,
@@ -72,10 +73,10 @@ func TestClient(t *testing.T) {
 		Clientid: id,
 		Cansync:  true,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	client, err = queries.GetClient(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullclient{
 		ID:         id,
 		Name:       name,
@@ -102,5 +103,5 @@ func TestClient(t *testing.T) {
 		Name:       "sameid",
 		Externalid: "sameid",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/database/repository/collector_test.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCollector(t *testing.T) {
@@ -34,34 +35,34 @@ func TestCollector(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	contextId, err := queries.CreateQuery(ctx, repository.QuerytypeContextFull)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonId, err := queries.CreateQuery(ctx, repository.QuerytypeJsonExtractor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	version, err := queries.AddLatestQueryVersion(ctx, jsonId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonId,
 		Versionid: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(1), version)
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 		Queryid:         jsonId,
 		Requiredqueryid: contextId,
 		Addedversion:    version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clientId, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	minCleanVersion := int64(2)
 	minTextVersion := int64(4)
 
 	coll, err := queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: 0,
@@ -71,11 +72,11 @@ func TestCollector(t *testing.T) {
 	}, coll)
 
 	version, err = queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(1), version)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: 0,
@@ -88,10 +89,10 @@ func TestCollector(t *testing.T) {
 		Versionid: 1,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: 0,
@@ -106,17 +107,17 @@ func TestCollector(t *testing.T) {
 		Addedversion: 1,
 		Name:         "example_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = queries.SetCollectorTextVersion(ctx, &repository.SetCollectorTextVersionParams{
 		Clientid:     clientId,
 		Addedversion: 1,
 		Versionid:    minTextVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: 0,
@@ -131,10 +132,10 @@ func TestCollector(t *testing.T) {
 		Addedversion: 1,
 		Versionid:    minCleanVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: minCleanVersion,
@@ -145,7 +146,7 @@ func TestCollector(t *testing.T) {
 	}, coll)
 
 	qs, err := queries.ListCollectorQueries(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 2)
 	assert.ElementsMatch(t, []*repository.Collectorquerydependencytree{
 		{
@@ -165,7 +166,7 @@ func TestCollector(t *testing.T) {
 	}, qs)
 
 	version, err = queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(2), version)
 
 	err = queries.RemoveCollectorQuery(ctx, &repository.RemoveCollectorQueryParams{
@@ -173,23 +174,23 @@ func TestCollector(t *testing.T) {
 		Queryid:        jsonId,
 		Removedversion: &version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Versionid: 2,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = queries.SetCollectorTextVersion(ctx, &repository.SetCollectorTextVersionParams{
 		Clientid:     clientId,
 		Versionid:    minTextVersion + 1,
 		Addedversion: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: minCleanVersion,
@@ -204,10 +205,10 @@ func TestCollector(t *testing.T) {
 		Versionid:    minCleanVersion + 1,
 		Addedversion: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	coll, err = queries.GetCollectorByClientID(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivecollector{
 		Clientid:        clientId,
 		Mincleanversion: minCleanVersion + 1,

internal/database/repository/db_test.go

@@ -32,7 +32,7 @@ func TestQueriesWithTx(t *testing.T) {
 	pool.ExpectBeginTx(pgx.TxOptions{})
 
 	tx, err := pool.Begin(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	txQueries := queries.WithTx(tx)
 	assert.NotNil(t, txQueries)

internal/database/repository/document_test.go

@@ -9,6 +9,7 @@ import (
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDocument(t *testing.T) {
@@ -32,10 +33,10 @@ func TestDocument(t *testing.T) {
 		Name:       "example_name",
 		Externalid: externalId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	docs, err := queries.ListDocumentsByClientExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 0)
 
 	hash := "example_hash"
@@ -43,7 +44,7 @@ func TestDocument(t *testing.T) {
 		Clientid: clientId,
 		Hash:     hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, id)
 
 	bucketone := "bucketone"
@@ -53,10 +54,10 @@ func TestDocument(t *testing.T) {
 		Bucket:     bucketone,
 		Key:        keyone,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 1)
 	assert.Equal(t, hash, docs[0].Hash)
 
@@ -64,7 +65,7 @@ func TestDocument(t *testing.T) {
 		Clientid: clientId,
 		Hash:     "example_hash_two",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, documentTwoID)
 
 	buckettwo := "buckettwo"
@@ -74,10 +75,10 @@ func TestDocument(t *testing.T) {
 		Bucket:     buckettwo,
 		Key:        keytwo,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 2)
 
 	externalTwoId := "EXAMPLE TWO"
@@ -85,20 +86,20 @@ func TestDocument(t *testing.T) {
 		Name:       "example_name_two",
 		Externalid: externalTwoId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 2)
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalTwoId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 0)
 
 	documentThreeId, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientTwoId,
 		Hash:     hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	bucketthree := "buckettwo"
 	keythree := "keytwo"
@@ -107,18 +108,18 @@ func TestDocument(t *testing.T) {
 		Bucket:     bucketthree,
 		Key:        keythree,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 2)
 	docs, err = queries.ListDocumentsByClientExternalId(ctx, externalTwoId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, docs, 1)
 	assert.Equal(t, hash, docs[0].Hash)
 
 	doc, err := queries.GetDocumentSummary(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Document{
 		ID:       id,
 		Clientid: clientId,
@@ -126,7 +127,7 @@ func TestDocument(t *testing.T) {
 	}, doc)
 
 	docext, err := queries.GetDocumentExternal(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 		ID:       id,
 		Clientid: externalId,
@@ -138,11 +139,11 @@ func TestDocument(t *testing.T) {
 		Hash:     hash,
 		Clientid: clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, id, docid)
 
 	entry, err := queries.GetDocumentEntry(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.GetDocumentEntryRow{
 		Documentid: id,
 		Bucket:     bucketone,
@@ -150,7 +151,7 @@ func TestDocument(t *testing.T) {
 	}, entry)
 
 	entry, err = queries.GetDocumentEntry(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.GetDocumentEntryRow{
 		Documentid: documentTwoID,
 		Bucket:     buckettwo,
@@ -158,7 +159,7 @@ func TestDocument(t *testing.T) {
 	}, entry)
 
 	entry, err = queries.GetDocumentEntry(ctx, documentThreeId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.GetDocumentEntryRow{
 		Documentid: documentThreeId,
 		Bucket:     bucketthree,

internal/database/repository/failtype_test.go

@@ -7,6 +7,7 @@ import (
 	"queryorchestration/internal/database/repository"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFailTypeScan(t *testing.T) {
@@ -14,7 +15,7 @@ func TestFailTypeScan(t *testing.T) {
 
 	stringType := "invalid_mimetype"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullFailTypeScan(t *testing.T) {
@@ -22,7 +23,7 @@ func TestNullFailTypeScan(t *testing.T) {
 
 	stringType := "invalid_mimetype"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullFailTypeValue(t *testing.T) {
@@ -30,10 +31,10 @@ func TestNullFailTypeValue(t *testing.T) {
 
 	stringType := "invalid_mimetype"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	val, err := qType.Value()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, stringType, val)
 }
 

internal/database/repository/mimetype_test.go

@@ -7,6 +7,7 @@ import (
 	"queryorchestration/internal/database/repository"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMimeTypeScan(t *testing.T) {
@@ -14,7 +15,7 @@ func TestMimeTypeScan(t *testing.T) {
 
 	stringType := "application/pdf"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullMimeTypeScan(t *testing.T) {
@@ -22,7 +23,7 @@ func TestNullMimeTypeScan(t *testing.T) {
 
 	stringType := "application/pdf"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullMimeTypeValue(t *testing.T) {
@@ -30,10 +31,10 @@ func TestNullMimeTypeValue(t *testing.T) {
 
 	stringType := "application/pdf"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	val, err := qType.Value()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, stringType, val)
 }
 

internal/database/repository/query_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestQueries(t *testing.T) {
@@ -34,11 +35,11 @@ func TestQueries(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, contextQueryID.Valid)
 
 	contextQuery, err := queries.GetQuery(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            contextQueryID,
 		Type:          repository.QuerytypeContextFull,
@@ -49,11 +50,11 @@ func TestQueries(t *testing.T) {
 	}, contextQuery)
 
 	ctxVersion, err := queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(1), ctxVersion)
 
 	contextQuery, err = queries.GetQuery(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            contextQueryID,
 		Type:          repository.QuerytypeContextFull,
@@ -64,11 +65,11 @@ func TestQueries(t *testing.T) {
 	}, contextQuery)
 
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, jsonQueryID.Valid)
 
 	jsonQuery, err := queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -79,11 +80,11 @@ func TestQueries(t *testing.T) {
 	}, jsonQuery)
 
 	jsonVersion, err := queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(1), jsonVersion)
 
 	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -97,10 +98,10 @@ func TestQueries(t *testing.T) {
 		Versionid: 1,
 		Queryid:   jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -117,10 +118,10 @@ func TestQueries(t *testing.T) {
 		Requiredqueryid: contextQueryID,
 		Addedversion:    1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -131,11 +132,11 @@ func TestQueries(t *testing.T) {
 	}, jsonQuery)
 
 	jsonVersion, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(2), jsonVersion)
 
 	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -151,17 +152,17 @@ func TestQueries(t *testing.T) {
 		Requiredqueryid: contextQueryID,
 		Removedversion:  &removeV,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = queries.SetQueryConfig(ctx, &repository.SetQueryConfigParams{
 		Queryid:      jsonQueryID,
 		Config:       jsonConfig,
 		Addedversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQueryConfig, err := queries.GetActiveQueryConfig(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, jsonConfig, jsonQueryConfig)
 
 	err = queries.SetQueryConfig(ctx, &repository.SetQueryConfigParams{
@@ -169,24 +170,24 @@ func TestQueries(t *testing.T) {
 		Config:       []byte(`{"second":"key"}`),
 		Addedversion: 2,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQueryConfig, err = queries.GetActiveQueryConfig(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, jsonConfig, jsonQueryConfig)
 
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 2,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQueryConfig, err = queries.GetActiveQueryConfig(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(`{"second": "key"}`), jsonQueryConfig)
 
 	jsonQuery, err = queries.GetQuery(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.Fullactivequery{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -201,7 +202,7 @@ func TestQueries(t *testing.T) {
 		ID:      jsonQueryID,
 		Version: &v,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &repository.GetQueryWithVersionRow{
 		ID:            jsonQueryID,
 		Type:          repository.QuerytypeJsonExtractor,
@@ -212,23 +213,23 @@ func TestQueries(t *testing.T) {
 	}, versionedQuery)
 
 	all_exist, err := queries.AllQueriesExist(ctx, []pgtype.UUID{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, all_exist)
 
 	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{database.MustToDBUUID(uuid.New())})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, all_exist)
 
 	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, all_exist)
 
 	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, contextQueryID})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, all_exist)
 
 	all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, database.MustToDBUUID(uuid.New())})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, all_exist)
 }
 
@@ -253,52 +254,52 @@ func TestQueryDependencyTree(t *testing.T) {
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	version, err := queries.AddLatestCollectorVersion(ctx, clientID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Clientid:  clientID,
 		Versionid: version,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	docID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientID,
 		Hash:     "sample",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   contextQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err := queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
@@ -306,19 +307,19 @@ func TestQueryDependencyTree(t *testing.T) {
 		Requiredqueryid: contextQueryID,
 		Addedversion:    1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
@@ -327,42 +328,42 @@ func TestQueryDependencyTree(t *testing.T) {
 		Queryid:      jsonQueryID,
 		Addedversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, dependents)
 
 	secondJsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, secondJsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   secondJsonQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, dependents)
 
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
@@ -370,25 +371,25 @@ func TestQueryDependencyTree(t *testing.T) {
 		Requiredqueryid: jsonQueryID,
 		Addedversion:    1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    secondJsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, dependents)
 
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
@@ -397,60 +398,60 @@ func TestQueryDependencyTree(t *testing.T) {
 		Queryid:      secondJsonQueryID,
 		Addedversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    secondJsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    jsonQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{secondJsonQueryID}, dependents)
 	dependents, err = queries.ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
 		Documentid: docID,
 		Queryid:    contextQueryID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, dependents)
 
 	isdependent, err := queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
 		Queryid:          jsonQueryID,
 		Requiredqueryids: []pgtype.UUID{contextQueryID},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isdependent)
 
 	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
 		Queryid:          jsonQueryID,
 		Requiredqueryids: []pgtype.UUID{secondJsonQueryID},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isdependent)
 
 	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
 		Queryid:          jsonQueryID,
 		Requiredqueryids: []pgtype.UUID{jsonQueryID},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isdependent)
 
 	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
 		Queryid:          secondJsonQueryID,
 		Requiredqueryids: []pgtype.UUID{jsonQueryID, contextQueryID},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isdependent)
 
 	isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
 		Queryid:          contextQueryID,
 		Requiredqueryids: []pgtype.UUID{jsonQueryID, secondJsonQueryID},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isdependent)
 }
 
@@ -472,13 +473,13 @@ func TestQueriesList(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err := queries.ListQueries(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 2)
 	assert.ElementsMatch(t, []*repository.Fullactivequery{
 		{
@@ -500,7 +501,7 @@ func TestQueriesList(t *testing.T) {
 	}, qs)
 
 	qs, err = queries.ListQueriesById(ctx, []pgtype.UUID{jsonQueryID})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []*repository.Fullactivequery{
 		{
@@ -532,79 +533,79 @@ func TestListQueryClients(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	contextID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clients, err := queries.ListQueryClientIDs(ctx, contextID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{}, clients)
 
 	clientOneID, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	versionOne, err := queries.AddLatestCollectorVersion(ctx, clientOneID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Clientid:  clientOneID,
 		Versionid: versionOne,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
 		Clientid:     clientOneID,
 		Queryid:      contextID,
 		Addedversion: 1,
 		Name:         "example_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clients, err = queries.ListQueryClientIDs(ctx, contextID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{clientOneID}, clients)
 
 	clientTwoID, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client_dos",
 		Externalid: "EXAMPLE DOS",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	versionTwo, err := queries.AddLatestCollectorVersion(ctx, clientTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Clientid:  clientTwoID,
 		Versionid: versionTwo,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
 		Clientid:     clientTwoID,
 		Queryid:      contextID,
 		Addedversion: 1,
 		Name:         "example_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clients, err = queries.ListQueryClientIDs(ctx, contextID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{clientOneID, clientTwoID}, clients)
 
 	jsonID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, jsonID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 		Queryid:         jsonID,
 		Requiredqueryid: contextID,
 		Addedversion:    1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
 		Clientid:     clientOneID,
 		Queryid:      jsonID,
 		Addedversion: 1,
 		Name:         "example_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clients, err = queries.ListQueryClientIDs(ctx, jsonID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []pgtype.UUID{clientOneID}, clients)
 }

internal/database/repository/querytype_test.go

@@ -7,6 +7,7 @@ import (
 	"queryorchestration/internal/database/repository"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestQueryTypeScan(t *testing.T) {
@@ -14,7 +15,7 @@ func TestQueryTypeScan(t *testing.T) {
 
 	stringType := "context_full"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullQueryTypeScan(t *testing.T) {
@@ -22,7 +23,7 @@ func TestNullQueryTypeScan(t *testing.T) {
 
 	stringType := "context_full"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNullQueryTypeValue(t *testing.T) {
@@ -30,10 +31,10 @@ func TestNullQueryTypeValue(t *testing.T) {
 
 	stringType := "context_full"
 	err := qType.Scan(stringType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	val, err := qType.Value()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, stringType, val)
 }
 

internal/database/repository/result_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestResults(t *testing.T) {
@@ -32,45 +33,45 @@ func TestResults(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clientId, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err := queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, issynced)
 
 	documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     "example_hash",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, issynced)
 
 	version, err := queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Versionid: version,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, issynced)
 
 	bucket := "example_bucket"
@@ -84,15 +85,15 @@ func TestResults(t *testing.T) {
 			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Cleanid: cleanid,
 		Version: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, issynced)
 
 	textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
@@ -101,10 +102,10 @@ func TestResults(t *testing.T) {
 		Key:          "hello",
 		Cleanentryid: cleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, issynced)
 
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
@@ -113,10 +114,10 @@ func TestResults(t *testing.T) {
 		Addedversion: 1,
 		Name:         "example_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, issynced)
 
 	jsonResultValue := "example_value"
@@ -127,10 +128,10 @@ func TestResults(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	issynced, err = queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, issynced)
 
 	qv := int32(1)
@@ -139,7 +140,7 @@ func TestResults(t *testing.T) {
 		Queryversion: &qv,
 		Documentid:   documentID,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, res.Value)
 	assert.Equal(t, jsonResultValue, *res.Value)
 }
@@ -162,43 +163,43 @@ func TestResultValues(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clientId, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     "example_hash",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	documentTwoID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     "example_hash_two",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   contextQueryID,
 		Versionid: 2,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsonVersion := int32(1)
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
@@ -206,33 +207,33 @@ func TestResultValues(t *testing.T) {
 		Requiredqueryid: contextQueryID,
 		Addedversion:    jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	contextQuery, err := queries.GetQuery(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qResults, err := queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 0)
 	qResults, err = queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentTwoID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 0)
 
 	version, err := queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Versionid: version,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	bucket := "example_bucket"
 	key := "example_key"
@@ -245,19 +246,19 @@ func TestResultValues(t *testing.T) {
 			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Cleanid: cleanid,
 		Version: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
 		Version:      1,
 		Bucket:       "hi",
 		Key:          "hello",
 		Cleanentryid: cleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	result := repository.AddResultParams{
 		Queryid:      contextQueryID,
@@ -267,14 +268,14 @@ func TestResultValues(t *testing.T) {
 	}
 
 	_, err = queries.AddResult(ctx, &result)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qResults, err = queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 1)
 	assert.Equal(t, contextQueryID, qResults[0].Queryid)
 	assert.Equal(t, repository.QuerytypeContextFull, qResults[0].Type)
@@ -286,7 +287,7 @@ func TestResultValues(t *testing.T) {
 		Documentid: documentTwoID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 0)
 
 	_, err = queries.AddResult(ctx, &repository.AddResultParams{
@@ -295,14 +296,14 @@ func TestResultValues(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: contextQuery.Activeversion - 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qResults, err = queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 1)
 	assert.Equal(t, contextQueryID, qResults[0].Queryid)
 	assert.Equal(t, repository.QuerytypeContextFull, qResults[0].Type)
@@ -316,14 +317,14 @@ func TestResultValues(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: contextQuery.Activeversion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qResults, err = queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 1)
 	assert.Equal(t, contextQueryID, qResults[0].Queryid)
 	assert.Equal(t, repository.QuerytypeContextFull, qResults[0].Type)
@@ -337,14 +338,14 @@ func TestResultValues(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qResults, err = queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
 		Queryid:    jsonQueryID,
 		Documentid: documentID,
 		Version:    &jsonVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qResults, 1)
 	assert.Equal(t, contextQueryID, qResults[0].Queryid)
 	assert.Equal(t, repository.QuerytypeContextFull, qResults[0].Type)
@@ -374,49 +375,49 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	version, err := queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Versionid: version,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     "example_hash",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	documentTwoID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     "example_hash_two",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   contextQueryID,
 		Versionid: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 		Queryid:         jsonQueryID,
 		Requiredqueryid: contextQueryID,
 		Addedversion:    1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
 		Clientid:     clientId,
@@ -424,13 +425,13 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Queryid:      jsonQueryID,
 		Addedversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err := queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	bucket := "example_bucket"
@@ -444,18 +445,18 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Cleanid: cleanid,
 		Version: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
@@ -464,14 +465,14 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Key:          "hello",
 		Cleanentryid: cleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{contextQueryID}, qs)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	_, err = queries.AddResult(ctx, &repository.AddResultParams{
@@ -480,14 +481,14 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, qs)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	_, err = queries.AddResult(ctx, &repository.AddResultParams{
@@ -496,13 +497,13 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Textentryid:  textId,
 		Queryversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	cleantwoid, err := queries.AddDocumentClean(ctx, &repository.AddDocumentCleanParams{
@@ -514,18 +515,18 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Cleanid: cleantwoid,
 		Version: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	textTwoId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
@@ -534,7 +535,7 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Key:          "hello",
 		Cleanentryid: cleantwoid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = queries.AddResult(ctx, &repository.AddResultParams{
 		Queryid:      contextQueryID,
@@ -542,13 +543,13 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Textentryid:  textTwoId,
 		Queryversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, qs)
 
@@ -558,29 +559,29 @@ func TestUnsyncedNoDepsQueries(t *testing.T) {
 		Textentryid:  textTwoId,
 		Queryversion: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 0)
 
 	_, err = queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: 2,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, qs)
 	qs, err = queries.ListUnsyncedNoDepsQueriesByDocId(ctx, documentTwoID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, qs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{jsonQueryID}, qs)
 }

internal/database/repository/sync_test.go

@@ -11,6 +11,7 @@ import (
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestListClientDocumentIDs(t *testing.T) {
@@ -34,28 +35,28 @@ func TestListClientDocumentIDs(t *testing.T) {
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ids, err := queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
 		Clientid:   id,
 		Batchsize:  1,
 		Pageoffset: 0,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, ids, 0)
 
 	docOne, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: id,
 		Hash:     "example_hash",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
 		Clientid:   id,
 		Batchsize:  1,
 		Pageoffset: 0,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, ids, 1)
 	total := int64(1)
 	assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
@@ -69,14 +70,14 @@ func TestListClientDocumentIDs(t *testing.T) {
 		Clientid: id,
 		Hash:     "example_hash_two",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
 		Clientid:   id,
 		Batchsize:  1,
 		Pageoffset: 0,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, ids, 1)
 	total = int64(2)
 	assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
@@ -91,7 +92,7 @@ func TestListClientDocumentIDs(t *testing.T) {
 		Batchsize:  1,
 		Pageoffset: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, ids, 1)
 	assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
 		{
@@ -105,7 +106,7 @@ func TestListClientDocumentIDs(t *testing.T) {
 		Batchsize:  2,
 		Pageoffset: 0,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, ids, 2)
 	assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
 		{
@@ -137,54 +138,54 @@ func TestClientSync(t *testing.T) {
 	queries := cfg.GetDBQueries()
 
 	contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	contextQueryVersion, err := queries.AddLatestQueryVersion(ctx, contextQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   contextQueryID,
 		Versionid: contextQueryVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonQueryVersion, err := queries.AddLatestQueryVersion(ctx, jsonQueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 		Queryid:   jsonQueryID,
 		Versionid: jsonQueryVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 		Queryid:         jsonQueryID,
 		Requiredqueryid: contextQueryID,
 		Addedversion:    jsonQueryVersion,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	externalId := "EXAMPLE"
 	clientId, err := queries.CreateClient(ctx, &repository.CreateClientParams{
 		Name:       "example_client",
 		Externalid: externalId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	collectorVersion, err := queries.AddLatestCollectorVersion(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
 		Versionid: collectorVersion,
 		Clientid:  clientId,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
 		Clientid:     clientId,
 		Queryid:      jsonQueryID,
 		Addedversion: collectorVersion,
 		Name:         "first_key",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	isSynced, err := queries.IsClientSynced(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isSynced)
 
 	bucket := "example_bucket"
@@ -194,10 +195,10 @@ func TestClientSync(t *testing.T) {
 			Clientid: clientId,
 			Hash:     "example_noclean",
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		docExternal, err := queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -206,7 +207,7 @@ func TestClientSync(t *testing.T) {
 		}, docExternal)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.False(t, isSynced)
 
 		cleanid, err := queries.AddDocumentClean(ctx, &repository.AddDocumentCleanParams{
@@ -216,18 +217,18 @@ func TestClientSync(t *testing.T) {
 				Cleanfailtype: repository.CleanfailtypeInvalidMimetype,
 			},
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 			Cleanid: cleanid,
 			Version: 1,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, isSynced)
 		docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -241,14 +242,14 @@ func TestClientSync(t *testing.T) {
 			Clientid: clientId,
 			Hash:     "example_hash",
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.False(t, isSynced)
 
 		docExternal, err := queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -266,18 +267,18 @@ func TestClientSync(t *testing.T) {
 				Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 			},
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 			Cleanid: cleanId,
 			Version: 1,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.False(t, isSynced)
 		docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -291,13 +292,13 @@ func TestClientSync(t *testing.T) {
 			Key:          "hello",
 			Cleanentryid: cleanId,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.False(t, isSynced)
 		docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -312,13 +313,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: contextQueryVersion,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -332,13 +333,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: jsonQueryVersion,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -350,14 +351,14 @@ func TestClientSync(t *testing.T) {
 				Resultid:         jsonResultId,
 				Requiredresultid: contextResultId,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.True(t, isSynced)
 
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -367,18 +368,18 @@ func TestClientSync(t *testing.T) {
 		})
 
 		contextLatestVersion, err := queries.AddLatestQueryVersion(ctx, contextQueryID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 			Queryid:   contextQueryID,
 			Versionid: contextLatestVersion,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		isSynced, err = queries.IsClientSynced(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.False(t, isSynced)
 		docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 			ID:       documentID,
 			Clientid: externalId,
@@ -393,13 +394,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: contextLatestVersion,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -413,13 +414,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: jsonQueryVersion,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -431,13 +432,13 @@ func TestClientSync(t *testing.T) {
 				Resultid:         jsonResultId,
 				Requiredresultid: contextResultId,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.True(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -453,13 +454,13 @@ func TestClientSync(t *testing.T) {
 				Key:          "hello",
 				Cleanentryid: cleanId,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -473,13 +474,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: 2,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -493,13 +494,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textId,
 				Queryversion: 1,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -511,13 +512,13 @@ func TestClientSync(t *testing.T) {
 				Resultid:         jsonResultID,
 				Requiredresultid: contextResultID,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.True(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -535,18 +536,18 @@ func TestClientSync(t *testing.T) {
 					Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 				},
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 				Cleanid: cleanthreeid,
 				Version: 1,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -560,13 +561,13 @@ func TestClientSync(t *testing.T) {
 				Key:          "hello",
 				Cleanentryid: cleanthreeid,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -580,13 +581,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textThreeId,
 				Queryversion: contextLatestVersion,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -600,13 +601,13 @@ func TestClientSync(t *testing.T) {
 				Textentryid:  textThreeId,
 				Queryversion: 1,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.False(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -618,13 +619,13 @@ func TestClientSync(t *testing.T) {
 				Resultid:         jsonResultID,
 				Requiredresultid: contextResultId,
 			})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.True(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -633,13 +634,13 @@ func TestClientSync(t *testing.T) {
 			}, docExternal)
 
 			latestCollectorVersion, err := queries.AddLatestCollectorVersion(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			isSynced, err = queries.IsClientSynced(ctx, clientId)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.True(t, isSynced)
 			docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 				ID:       documentID,
 				Clientid: externalId,
@@ -652,13 +653,13 @@ func TestClientSync(t *testing.T) {
 					Versionid: latestCollectorVersion,
 					Clientid:  clientId,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -671,13 +672,13 @@ func TestClientSync(t *testing.T) {
 					Queryid:        jsonQueryID,
 					Removedversion: &latestCollectorVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -691,13 +692,13 @@ func TestClientSync(t *testing.T) {
 					Addedversion: latestCollectorVersion,
 					Name:         "second_key",
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -713,13 +714,13 @@ func TestClientSync(t *testing.T) {
 					Addedversion: latestCollectorVersion,
 					Name:         "example_key",
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -730,20 +731,20 @@ func TestClientSync(t *testing.T) {
 
 			t.Run("add super query", func(t *testing.T) {
 				superQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				superQueryVersion, err := queries.AddLatestQueryVersion(ctx, superQueryID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
 					Queryid:   superQueryID,
 					Versionid: superQueryVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 					Queryid:         contextQueryID,
 					Requiredqueryid: superQueryID,
 					Addedversion:    superQueryVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				superResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
 					Queryid:      superQueryID,
@@ -751,13 +752,13 @@ func TestClientSync(t *testing.T) {
 					Textentryid:  textThreeId,
 					Queryversion: superQueryVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.False(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -771,13 +772,13 @@ func TestClientSync(t *testing.T) {
 					Textentryid:  textThreeId,
 					Queryversion: contextLatestVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.False(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -791,13 +792,13 @@ func TestClientSync(t *testing.T) {
 					Textentryid:  textThreeId,
 					Queryversion: jsonQueryVersion,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.False(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -809,13 +810,13 @@ func TestClientSync(t *testing.T) {
 					Resultid:         contextResultId,
 					Requiredresultid: superResultId,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.False(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,
@@ -827,13 +828,13 @@ func TestClientSync(t *testing.T) {
 					Resultid:         jsonResultId,
 					Requiredresultid: contextResultId,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				isSynced, err = queries.IsClientSynced(ctx, clientId)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, isSynced)
 				docExternal, err = queries.GetDocumentExternal(ctx, documentID)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
 					ID:       documentID,
 					Clientid: externalId,

internal/database/repository/text_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTextExtraction(t *testing.T) {
@@ -35,14 +36,14 @@ func TestTextExtraction(t *testing.T) {
 		Name:       "example_client",
 		Externalid: "EXAMPLE",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	hash := "example_hash"
 	id, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
 		Clientid: clientId,
 		Hash:     hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, id)
 
 	bucket := "example_bucket"
@@ -56,15 +57,15 @@ func TestTextExtraction(t *testing.T) {
 			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
 		Cleanid: cleanid,
 		Version: 1,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	isextract, err := queries.IsDocumentTextExtracted(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isextract)
 
 	textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
@@ -73,16 +74,16 @@ func TestTextExtraction(t *testing.T) {
 		Key:          key,
 		Cleanentryid: cleanid,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, textId)
 	assert.NotEqual(t, pgtype.UUID{}, textId)
 
 	isextract, err = queries.IsDocumentTextExtracted(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isextract)
 
 	text, err := queries.GetTextEntryByDocId(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, text.Documentid)
 	assert.Equal(t, bucket, text.Bucket)
 	assert.Equal(t, key, text.Key)