Merged in bugfix/tests (pull request #107)

Fix Fullsuite

* save

* foundthefix..

* codeandrequire

api/clientSyncRunner/runner_test.go

@@ -54,7 +54,7 @@ func TestQueryRunner(t *testing.T) {
 			ID: uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(bod)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/docCleanRunner/runner_test.go

@@ -61,7 +61,7 @@ func TestDocCleanRunner(t *testing.T) {
 			ID: uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(bod)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/docInitRunner/runner.go

@@ -53,17 +53,17 @@ type S3EventRecord struct {
 	EventSource  string               `json:"eventSource"`
 	AwsRegion    string               `json:"awsRegion"`
 	EventTime    string               `json:"eventTime"`
-	EventName    string               `json:"eventName"`
+	EventName    EventS3              `json:"eventName"`
 	S3           S3EventRecordDetails `json:"s3"`
 }
 type S3EventNotification struct {
 	Records []S3EventRecord `json:"Records"`
 }
 
-type S3Events string
+type EventS3 string
 
 const (
-	S3EventObjectCreatedPut = "ObjectCreated:Put"
+	EventS3ObjectCreatedPut = "ObjectCreated:Put"
 )
 
 func (s Runner) Process(ctx context.Context, req *types.Message) bool {
@@ -118,6 +118,6 @@ func (s Runner) processRecord(ctx context.Context, record S3EventRecord) error {
 	return nil
 }
 
-func (s Runner) isSupportedEvent(name string) bool {
-	return name == S3EventObjectCreatedPut
+func (s Runner) isSupportedEvent(name EventS3) bool {
+	return name == EventS3ObjectCreatedPut
 }

api/docInitRunner/runner_test.go

@@ -59,7 +59,7 @@ func TestDocInitRunner(t *testing.T) {
 		doc := S3EventNotification{
 			Records: []S3EventRecord{
 				{
-					EventName: "ObjectCreated:Put",
+					EventName: EventS3ObjectCreatedPut,
 					S3: S3EventRecordDetails{
 						Bucket: S3Bucket{
 							Name: bucketName,
@@ -73,7 +73,7 @@ func TestDocInitRunner(t *testing.T) {
 			},
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,
@@ -150,7 +150,7 @@ func TestProcessRecord(t *testing.T) {
 			Hash:     "example_hash",
 		}
 		record := S3EventRecord{
-			EventName: S3EventObjectCreatedPut,
+			EventName: EventS3ObjectCreatedPut,
 			S3: S3EventRecordDetails{
 				Bucket: S3Bucket{
 					Name: bucketName,
@@ -191,7 +191,7 @@ func TestProcessRecord(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = runner.processRecord(ctx, record)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("invalid_event", func(t *testing.T) {
 		record := S3EventRecord{
@@ -199,12 +199,12 @@ func TestProcessRecord(t *testing.T) {
 		}
 
 		err = runner.processRecord(ctx, record)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("invalid id", func(t *testing.T) {
 		location := "cc/aaa"
 		record := S3EventRecord{
-			EventName: S3EventObjectCreatedPut,
+			EventName: EventS3ObjectCreatedPut,
 			S3: S3EventRecordDetails{
 				Object: S3Object{
 					Key: location,
@@ -213,7 +213,7 @@ func TestProcessRecord(t *testing.T) {
 		}
 
 		err = runner.processRecord(ctx, record)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -221,7 +221,7 @@ func TestIsSupportedEvent(t *testing.T) {
 	runner := Runner{}
 
 	t.Run("put", func(t *testing.T) {
-		assert.True(t, runner.isSupportedEvent(S3EventObjectCreatedPut))
+		assert.True(t, runner.isSupportedEvent(EventS3ObjectCreatedPut))
 	})
 	t.Run("invalid", func(t *testing.T) {
 		assert.False(t, runner.isSupportedEvent("invalid"))

api/docSyncRunner/runner_test.go

@@ -63,7 +63,7 @@ func TestDocInitRunner(t *testing.T) {
 			ID: docinfo.ID,
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/docTextRunner/runner_test.go

@@ -53,7 +53,7 @@ func TestDocCleanRunner(t *testing.T) {
 			ID: uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/queryAPI/api.gen.go

@@ -729,68 +729,68 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL
 // Base64 encoded, gzipped, json marshaled Swagger object
 var swaggerSpec = []string{
 
-	"H4sIAAAAAAAC/+xc23LbSHN+lSnkv1ueSYmUUqkKf8nrZWLLXklObSIrrCHQJGcDYKiZgWTaxXdPzQln",
-	"kCBNavdCVb4QiDl093R/3dPd8A/HpcGKhhAK7lz+cJaAPWDqz1ss4AMJiJAPHnCXkZUgNHQu1Svky3eI",
-	"hHPKAixfIBIi/YC+Ourtv76Q0KMv/yZIAE3991fHaTjwDQcrH5xLp9vp2EHdjtNwuLuEAMsdS8ecyzEB",
-	"/vYBwoVYOpf9XsNZYSGASbL+96HTvHj8xQ7WT/9wGo5Yr+RCXDASLpzNZiNnMRyAMLxe+QRCMbkusnq/",
-	"BOSqt2hy3XIaDpG/rrBYOg0nxIFcl3hOw2HwFBEGnnMpWARpTv7BYO5cOv/STkTd1m95O95Y0nRN3SjY",
-	"Qodn3p+EktTmkpZ331aUVVIC6u1J6Ig3llT8HgFbVxExuUZ0jsQS0JMcdnxS7O5KYRjwFQ05KH2ZhFLl",
-	"sP+OMcrkDy4NBYTKVPBq5RNXWUT7Ty6p/VGXdbnaR+AcL0BvmmXa7oo4sGdgCOR4yXaV1ZZtZsa2k4Fq",
-	"p0n4jH3i3cJTBFy8IktqW8T0vmhGvfWROLqn9CMO14Yj/mos3RpFQdGKhkhQigIcri2H/AjcNZxbEGzd",
-	"HM8FsKJt3ETBDJi0DQ4uDT2OZjCnDJBgaxIuEF5gErbSMNztddI2oUFc2k4o+j2NuCSIAudydD7odBpO",
-	"QEL93ImxlYQCFsCkQDYN50uII7GkjHyXNvfagn9ZQoiiFAlH0aiNFVHKY1zh8G4dusUzmGhgMp6DcIR9",
-	"n74o6buCPAPi69DliWuaUeoDDuXZmpUZYAHlwLdidAVMEODS3yJXDiVUHWnySk4lXn3/YwGzzvgbOVKD",
-	"osXVBw20ao3HmC06+xNckXC1w8PCNwNwaq0kAhiPxzm/f57x+60yL5/s+U/qrbfuS7yfk11REtUiuDFS",
-	"riRGiTDLPQMBWQH0zvaQwJ3AIuLFTe9W4JK5VCOpq1yNkrCBDSkKI0Jp5w/O5GZ69983V07Dufl0r/58",
-	"d516mNy8T/FcTkD5MYwt32b/dECpZVc8Gx4ztPt8DPP5MzJLVJ/Tlx26SqwzjkLyFEFeZTvdi7PRWd9t",
-	"juae1xwOXa8565+7zd7ZWW/QnXme1+87jQRqo0gtkNPxCnl+WXl1wEEssUABXqOZdEZySomeuziccoNh",
-	"u6VpAe8wuCiKmnrwX8A40X6gJOQFLk8MudQD9KxHttJyI6E4H6Rd1EWv1+8Pe53++ehsMByedzIOq1t0",
-	"WJIK3wdX0BJfGr9CAfXAL4pPw/n0OWFimzwsr5uGo9Vouh9Ezwn43m7Ft0T/qodvGo6PBXBxAJlGclNX",
-	"uidgdVdIH2xqFQHfxEFL5Kw3EV4sk2pSK7YvCKWRP8xScMjItlxpFUV5L63CATu5qEe1rCmzt7aqhqMu",
-	"PzX0KLnNZGVp/E28zG6uq10YjcQqEkYAcuHWdrf1gJvfx83/eazwXjk9rha2dBtFCRMBwZ7GopQVf5vo",
-	"mYpcQxZmDK8zVN1BSWrkM177FHvqyBXmqpgPXVWf/MEIcjAY/H1suqBo19TVeLfTueXilCM5tdNGzA0n",
-	"qrvBl/K4Uq/QsEYb8/lYLkuV0dmRTEokVyLHn3NSldaKQ0+Z6zP2I4jh0ZKUDqR+WIrW3Rgb9LSE2HXP",
-	"uRz0kse+TfPYH86cy4duo9foP5bp3BLz5S7+fpNjaulHLo9WOL+061I7xwLbdoY7U4L6CpOLPzvevDnr",
-	"z0fNYX8wal7gWbfZhbOzWX/eHYE3PCD+tPTcRUGA2XoHUVyP2qpiryt9tVuZoDPJhQJX18mTBB6VeMtq",
-	"aWCnOmsaoSDi8obg+pEHCCP7cpNnPqja0FCC9K8zqfTKveGIQ/ag4+0W5BlQAGhBqZe+RR1wccxJzlJZ",
-	"KjeVrr0GgYnPt7tDkzQWjCwWwJBNqB4JdXToMfWpzi2Va6Z9K8OFlyVxl0qqhrDvZIXmxAf0Qnxf3pnm",
-	"NApzZsX7l+02nrnt8bjd6/TOOr1uv61sbYjdZmfYnzWHnYtRczTonTdn2LsYduYj92I4aLn8OXcSncEo",
-	"cxRq7dYv8p8qXfwYbdqtX75+lVNL46N612B9QhXX4DQabbkS16oGVEAQNAfeWbc57Pbd5sUIoDk4H8Co",
-	"P+p2591DrsAZfsqjBMo5mfkxYZIxDT02myHF5IMAT9UMpitGFwy4vETMMfHBK81l6I3vtfpuV3Wj4yr2",
-	"Cw0ZRT1XuD+dE9+WobIL/qpe6NyMS1eAZpiDh2ho4msTbCtnyGvHuyoM1EvXCHZJuAAu6TmEzHgySqpt",
-	"RSlA6E2r0xk+5gLJ1xJ34wUzKQD5tilIAMXaYJnJMFG5HeFoTtgRNyyGG2UBSPpIKsSrbxEu9aMgLOIl",
-	"DT0iaoTfqY2u4jk2YpsefgXVKlh+gPodijjMIx8JqhRFK1NGZ/dPbiaq2+108qqbw7kUh42UvGLSH7cf",
-	"y1VawlsARxvmPD6yeKcM+vjA+VQssdx/ofL8zD66PuXgTVVy8Rn7TsOhKwjTzz7MxbQ4jJHFsux3E4Qo",
-	"YNZ/lUHbbyYI2xLLmVh1mwOrOKeJVxlXjREn4cIHJLG/KgefnfLFplshFGROgOnYIhRErFt7u5N6mfsP",
-	"hAsbWfLtckoyEfHVtBYs5wPr3dAsifo9AkbKLG+MOAiJYE96RFG2T1VT5bq5mbU4UPmlLN1n3d4Ou7RU",
-	"lEldL1jCmk8XxEVRSBSd8A3cqLz+dXhyloZzsqjF8ZUeWut2EqfgfiIha6U3TR3gtqm3ZrzZWyWAtKhr",
-	"0HovB5ZepNQShYxpga/Kc72KJZxPuMvfI6bDdJsZiBs8tsHP168/ZLi8KQUhvem2omocoiDLrPRWqrgq",
-	"73AxCQXfu7+m/PVnqGZXHk5VoK9kUJ1qgPn5WXN4Pjxvjjy4aF4MBv0zfNHv94f4gDhfEw9cpHpSdtbC",
-	"zTkhqYS25aJ4aBasp/slFGySfF+jzck+vXt+ycoj0YLQN+ZySdj7NJozGmQEURSATqAV+/qAR77IdFXF",
-	"C+zt+HNc6y2r+TPqvK1CLWcWWr5sUPUfd59upu/+uL8dX91/unUaztWnm/t3f9xPf/3y4UNp0KP2PbyU",
-	"mta3v9r1/DyglN1LCqMqY4UYMbXOTK73DBu0de0IeGoViitqxNk2pl53MByM+ueD4Y5epobDwY0YEes7",
-	"Sa4W7MrHLiyp7wEbR6Ikbv6cDEB2PlL86lz3PBIRA0QkfkogsGk61b2oe4+S/sU/muPPk+Z/wjqxMLwi",
-	"8lm1JJFwTm2HFXYVSEKAie9cOkHgLiIShsD5v2PMQEDLpUGy8kfiLjH46KP73gxzGk7E5FSPut/XanSh",
-	"y2r8eRIHu1knrU4SfWLuErgwDpwDeyaujiJ94oJBL0NBFJrfvHjnl5eXlnEtdn9BhPIzZeuPP0/kJc5q",
-	"htNpdVpdlQ5cQYhXxLl0+q1Oq+8ovFqq82u7cYVpRcv8ig4TOMIohBfb7/FChM4Wrhh9Jh54yNNJz5a+",
-	"pGmCJl4839SxtHECF7b95Si9cJkmsZJeOG0Sir7ycMZNU5e0xuYbXXud7pFpNu1YJTTr94ZED/HIdYHz",
-	"eeT7x2oJHXQ6VTNirtu5Tlg1rbt7WqblUU7qXeyelO9R3TScs3o0pvuP0zjlXD6UINTD4+ax4XBbtDEa",
-	"mlFwCS94waUrNY1T2nSdR7m8sZn2D+JtJHmLstr3LQhG4FlZDtee27XmM1sjIrjpGM+ay3sQKVvJKF/n",
-	"aMqXFJarNS9l0G/Kdjxlew8iBhypB5PrLbqW/TLjoZy2ZEiqBPSoIN4t8cc6xuM6FU+4aslIo7o0gkow",
-	"15NfAcxNJLoDzAU18WcN6O6UuDbNtg1h3zD2dGqvzzPtamvia9tN9yPugbRxr6IB28x3S0XMtcP/uTZG",
-	"5J0SgJMmyzIAjkl/w+BTYnBaQ2LtSGtm0tt2SkC+A2G3T0jaDcV31Up7AlBOt/ntBuUZqIx7aafnLpwe",
-	"bOs7lqu+wfTpLOMuaxnbjSGP1F66KLQDqaVa+CZfklSLZuv0h0JlUJ0pPr0OVmfrXVsC5pgNydibZh5X",
-	"M1VyTWRqizrlWAgo4rM6CmznlVy3r6h0yU94gtJMyyQkgqjYPNWHtWJUol3REkzrje7DORHsZ5t8KnDf",
-	"EGpwXUm+9aqplKSkXkLhu0yf3VuUf1IjNZqStHmlzNJ0qlV6j6R/r4br4OvQtd/I1YrvzUd3rxPc5z/z",
-	"q/YZhoW3OP9kcb79njJRmNPkW6Q6W9dUNzEoUlGz+oIj7i8yOq2LywVlvk4+DThlilDvUaK89t2b3p5O",
-	"b72cjBOVOG6oky7pKyXWwL1dha+W4P6f1l83YswimapHZ1p8s6qbNCvDKVU324VfHRMsMUczgBDFDdBv",
-	"inzkyorUk0zjeWtLRLCv6ib/OY5S3CfbIbczSehnm/rSreSqe9tlRAAjuPz6adsMT3zltNuU6O84z8Gb",
-	"3p7gsvkUn7NVWFVzH3+eaF2tUS3XDSB7F8t1r+dprnTp1r9DSuVPKdr+Btc73QbxViV/5Sq51YISy4ih",
-	"+IDyuLaX7dXxxDhOBL6mdbtK195i3hPWZGIFyBRisri7V4wQN9TtVxBPAXeNevjJ8Xp7NVzXr+23RfH3",
-	"46YHMG7JPKBArjX+rT7+ivXx2sjaFqYN/CcMojSEeac+IVHArBvHo1BnJ6qimez3jLksNXBxcvNI98VX",
-	"2EiuEX6fRHXnFMSa3vUyajWNPPLfakjHTk9L0W43MbUme7bGlGtlZtSL3LiVVzUm60bdpRArftlux63C",
-	"7eeuMjGzR36lT9ZIZJTtK3SVQbZKJ/KkKTmbn9w0ai5jS7XplfLl27qLJUXdeK1C1qnuWsmNyqwUS77u",
-	"CjqVkFohm0PYPG7+PwAA///Y9ZsKxFkAAA==",
+	"H4sIAAAAAAAC/+xc63PbRnD/V27QfGr4JiVS6nSmjOQ4bG3ZkeROOpbKOQJL8lIAR90dJDMe/u+de+EN",
+	"EqRJJR804w8CcY/dvd3f7u0u/N1xabCiIYSCO5ffnSVgD5j68xYL+EACIuSDB9xlZCUIDZ1L9Qr58h0i",
+	"4ZyyAMsXiIRIP6AHR739txcSevTl3wUJoKn/fnCchgPfcLDywbl0up2OHdTtOA2Hu0sIsNyxdMy5HBPg",
+	"bx8gXIilc9nvNZwVFgKYJOt/v3aaF48/28H66Sen4Yj1Si7EBSPhwtlsNnIWwwEIw+uVTyAUk+siq/dL",
+	"QK56iybXLafhEPnrCoul03BCHMh1iec0HAZPEWHgOZeCRZDm5CcGc+fS+Zd2Iuq2fsvb8caSpmvqRsEW",
+	"Ojzz/iSUpDaXtLz7tqKskhJQb09CR7yxpOL3CNi6iojJNaJzJJaAnuSw45Nid1cKw4CvaMhB6csklCqH",
+	"/XeMUSZ/cGkoIFSmglcrn7jKItp/cknt97qsy9U+Aud4AXrTLNN2V8SBPQNDIMdLtqustmwzM7adDFQ7",
+	"TcJn7BPvFp4i4OIVWVLbIqb3RTPqrY/E0T2lH3G4NhzxV2Pp1igKilY0RIJSFOBwbTnkR+Cu4dyCYOvm",
+	"eC6AFW3jJgpmwKRtcHBp6HE0gzllgARbk3CB8AKTsJWG4W6vk7YJDeLSdkLR72nEJUEUOJej80Gn03AC",
+	"EurnToytJBSwACYFsmk4X0IciSVl5C9pc68t+JclhChKkXAUjdpYEaU8xhUO79ahWzyDiQYm4zkIR9j3",
+	"6YuSvivIMyC+Dl2euKYZpT7gUJ6tWZkBFlAOfCtGV8AEAS79LXLlUELVkSav5FTi1fc/FjDrjL+RIzUo",
+	"Wlz9qoFWrfEYs0Vnf4IrEq52eFj4ZgBOrZVEAOPxOOf3zzN+v1Xm5ZM9f6Heeuu+xPsx2RUlUS2CGyPl",
+	"SmKUCLPcMxCQFUDvbA8J3AksIl7c9G4FLplLNZK6ytUoCRvYkKIwIpR2/tWZ3Ezv/ufmymk4N5/u1Z/v",
+	"rlMPk5v3KZ7LCSg/hrHl2+yfDii17Ipnw2OGdp+PYT5/RmaJ6nP6skNXiXXGUUieIsirbKd7cTY667vN",
+	"0dzzmsOh6zVn/XO32Ts76w26M8/z+n2nkUBtFKkFcjpeIc8vK68OOIglFijAazSTzkhOKdFzF4dTbjBs",
+	"tzQt4B0GF0VRUw/+Gxgn2g+UhLzA5Ykhl3qAnvXIVlpuJBTng7SLuuj1+v1hr9M/H50NhsPzTsZhdYsO",
+	"S1Lh++AKWuJL41cooB74RfFpOJ8+J0xsk4flddNwtBpN94PoOQHf2634luhf9fBNw/GxAC4OINNIbupK",
+	"9wSs7grpg02tIuCbOGiJnPUmwotlUk1qxfYFoTTyh1kKDhnZliutoijvpVU4YCcX9aiWNWX21lbVcNTl",
+	"p4YeJbeZrCyNv4mX2c11tQujkVhFwghALtw6zG3lFLhaytJfFEVLBAR7WonSUvxtomcqOg1ZmDG8zlB1",
+	"ByU5kc947VPsqbNWYKuCPXRVfeQHQ8fBKPDPMeaChl1TVwPdTq+WC1CO5M1OGyo3nKjuBl/KA0q9QsNa",
+	"a8znY7ksVSpnRxYpkVyJHH/MO1VaKw49Za7P2I8gxkVLUjqC+m4pWndjbNDTEmLXPedy0Ese+za/Y384",
+	"cy6/dhu9Rv+xTOeWmC938febHFNLP3IJtML5pX2W2jkW2LYz3JkL1HeXXODZ8ebNWX8+ag77g1HzAs+6",
+	"zS6cnc368+4IvOEBgael5y4KAszWO4jietRWFXtd6avdygSdySoUuLpOniTwqIxbVksDO9VZ0wgFEZdX",
+	"A9ePPEAY2ZebPPNB1YaGEqR/nUmlV+4NRxyyBx1vtyDPgAJAC0q99PXpANebk5ylslRuKk97DQITn293",
+	"hyZbLBhZLIAhm0k9EuromGPqU51UKtdM+1aGCy9L4i6VVA1hf5EVmhMf0AvxfXlZmtMozJkV71+223jm",
+	"tsfjdq/TO+v0uv22srUhdpudYX/WHHYuRs3RoHfenGHvYtiZj9yL4aDl8ufcSXQGo8xRqLVbP8t/qmbx",
+	"fbRpt35+eJBTS+OjevdffUIV9980Gm25C9cqA1RAEDQH3lm3Oez23ebFCKA5OB/AqD/qdufdQ+6+GX7K",
+	"owTKOZn5MWGSMQ09No0hxeSDAE8VC6YrRhcMuLw9zDHxwStNYuiN77X6bld1o+Mq9gsNGUU9V7g/nRPf",
+	"1p+yC/6qXuikjEtXgGaYg4doaAJrE2UrZ8hrx7sqDNRL1wh2SbgALuk5hMx4MkrKbEUpQOhNq/MYPuYC",
+	"ydcSd+MFM3d/+bYpSADFomCZyTBRuR3haE7YETcshhtlAUj6SCrEq28RLvWjICziJQ09ImqE36mNruI5",
+	"NmKbHn731CpYfoD6HYo4zCMfCaoURStTRmf3vx4mqtvtdPKqm8O5FIeNlLxi0h+3H8tVWsJbAEcb5jw+",
+	"sninDPr4wPlULLHcf6ES/Mw+uj7l4E1VVvEZ+07DoSsI088+zMW0OIyRxbLsdxOEKGDWf5VB228mCNsS",
+	"y5lYdZsDqziniVcZV40RJ+HCBySxvyr5np3yxeZZIRRkToDp2CIURKxbe7uTein7D4QLG1ny7XJKMhHx",
+	"1bQWLOcD693QLIn6PQJGyixvjDgIiWBPekRRtk9VU+W6uZm1OFCJpSzdZ93eDru0VJRJXS9YwppPF8RF",
+	"UUgUnfAN3Ki88HV4VpaGc7KoxfGVHlrrdhLn3n4gE2ulN00d4Lapt2a82VslgLSoa9B6LweWXqTUEoVU",
+	"aYGvynO9iiWcz7TL3yOmw3SbGYg7O7bBz8PD99a/PjxsSkFIb7qtmhqHKMgyK72VqqrKO1xMQsH37q8p",
+	"f/8ZqtmVh1MV6CsZVKcaYH5+1hyeD8+bIw8umheDQf8MX/T7/SE+IM7XxAMXqWaUnUVwc05IKqHttSge",
+	"mgXr6X4JBZsd39doc7JP755fsvJItCD0jblcEvY+jeaMBhlBFAWgE2jFhj7gkS8y7VTxAns7/hzXestq",
+	"/ow6bytNy5mFXi8bVP3n3aeb6bs/7m/HV/efbp2Gc/Xp5v7dH/fTX798+FAa9Kh9D6+hpvXt73Y9Pw4o",
+	"ZfeSwqjKWCFGTK0zk+s9wwZtXTsCnloV4oricLZ/qdcdDAej/vlguKOJqeFwcCNGxPpOkqsFu/KxC0vq",
+	"e8DGkSiJmz8nA5CdjxS/Otc9j0TEABGJnxIIbJpOtS3qpqOkcfGP5vjzpPlfsE4sDK+IfFa9SCScU9ta",
+	"hV0FkhBg4juXThC4i4iEIXD+HxgzENByaZCs/JG4Sww++ui+N8OchhMxOdWj7l9rNbrQXjX+PImD3ayT",
+	"VieJPjF3CVwYB86BPRNXR5E+ccGgl6EgCs1vXrzzy8tLy7gWu78gQvmZsvXHnyfyEmc1w+m0Oq2uSgeu",
+	"IMQr4lw6/Van1XcUXi3V+bXduMK0omV+RYcJHGEUwott9HghQmcLV4w+Ew885OmkZ0tf0jRBEy+eb+pY",
+	"2jiBC9v3cpQmuEx3WEkTnDYJRV95OOOmqUt6YvMdrr1O98g0mz6sEpr1e0Oih3jkusD5PPL9Y/WCDjqd",
+	"qhkx1+1cC6ya1t09LdPrKCf1LnZPyjenbhrOWT0a043HaZxyLr+WINTXx81jw+G2aGM0NKPgEl7wgktX",
+	"ajqmtOk6j3J5YzPt78TbSPIWZbXvWxCMwLOyHK49t2vNZ7ZGRHDTKp41l/cgUraSUb7O0ZQvKSxXa17K",
+	"oN+U7XjK9h5EDDhSDybXW3Qt+0nG13LakiGpEtCjgni3xB/rGI/rVDzhqiUjjerSCCrBXE9+BTA3kegO",
+	"MBfUxJ81oLtT4to02zaEfcPY06m9Ps+0q62Jr2033Yi4B9LGTYoGbDMfLBUx1w7/ZW2MyDslACfdlWUA",
+	"HJP+hsGnxOC0hsTakdbMpLftlIB8B8Jun5C0G4rvqpX2BKCcbvPbDcozUBn30hbPXTg92NZwLFd9g+nT",
+	"WcZd1jK2G0Meqb10UWgHUku18E2+JKkWzdbpL4TKoDpTfHodrM7Wu7YEzDEbkrE3zTyuZqrkmsjUFnXK",
+	"sRBQxGd1FNjOK7luX1Hpkh/wBKWZlklIBFGxeaoPa8WoRLuiJZjWG92HcyLYzzb5VOC+IdTgupJ861VT",
+	"KUlJvYTCd5k+u7co/6RGajQlafNKmaXpVKv0Hkn/Xg3Xwdehaz+OqxXfm6/tXie4z3/fV+0zDAtvcf7J",
+	"4nz7IWWiMKfJt0h1tq6pbmJQpKJm9QVH3F9kdFoXlwvKfJ18GnDKFKHeo0R57bs3vT2d3no5GScqcdxQ",
+	"J13SV0qsgXu7Cl8twf0/rb9uxJhFMlWPzrT4ZlU3aVaGU6putgu/OiZYYo5mACGKG6DfFPnIlRWpJ5nG",
+	"89aWiGBf1U3+VxyluE+2Q25nktDPNvWlW8lV97bLiABGcPn107YZnvjKabcp0d9xnoM3vT3BZfMpPmer",
+	"sKrmPv480bpao1quG0D2LpbrXs/TXOnSrX+HlMqfUrT9A653ug3irUr+ylVyqwUllhFD8QHlcW0v26vj",
+	"iXGcCHxN63aVrr3FvCesycQKkCnEZHF3rxghbqjbryCeAu4a9fCT4/X2ariuX9tvi+Lvx00PYNySeUCB",
+	"XGv8W338FevjtZG1LUwb+A8YRGkI8059QqKAWTeOR6HOTlRFM9nvGXNZauDi5OaR7ouvsJFcI/w+ierO",
+	"KYg1vetl1GoaeeS/1ZCOnZ6Wot1uYmpN9myNKdfKzKgXuXErr2pM1o26SyFW/LLdjluF289dZWJmj/xK",
+	"n6yRyCjbV+gqg2yVTuRJU3I2P7lp1FzGlmrTK+XLt3UXS4q68VqFrFPdtZIblVkplnzdFXQqIbVCNoew",
+	"edz8fwAAAP//YgULir1ZAAA=",
 }
 
 // GetSwagger returns the content of the embedded swagger specification file

api/queryAPI/client_test.go

@@ -38,7 +38,7 @@ func TestCreateClient(t *testing.T) {
 		Id:   "external_id",
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -52,7 +52,7 @@ func TestCreateClient(t *testing.T) {
 	)
 
 	err = cons.CreateClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusCreated, rec.Code)
 	assert.Equal(t, fmt.Sprintf("{\"id\":\"%s\"}\n", body.Id), rec.Body.String())
 }
@@ -85,12 +85,12 @@ func TestGetClient(t *testing.T) {
 	)
 
 	err = cons.GetClient(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.DocClient
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, queryapi.DocClient{
 		Id:      id,
 		Uid:     clientUid,
@@ -116,7 +116,7 @@ func TestUpdateClient(t *testing.T) {
 		CanSync: &cs,
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -144,7 +144,7 @@ func TestUpdateClient(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = cons.UpdateClient(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 	assert.Empty(t, rec.Body.String())
 }

api/queryAPI/collector_test.go

@@ -59,7 +59,7 @@ func TestSetCollector(t *testing.T) {
 		},
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -115,7 +115,7 @@ func TestSetCollector(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = cons.SetCollectorByClientId(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 	assert.Empty(t, rec.Body.String())
 }
@@ -152,12 +152,12 @@ func TestGetCollectorByclientId(t *testing.T) {
 		)
 
 	err = cons.GetCollectorByClientId(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.Collector
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, queryapi.Collector{
 		ClientId:              id,
 		MinimumCleanerVersion: coll.MinCleanVersion,

api/queryAPI/documents_test.go

@@ -61,12 +61,12 @@ func TestListDocumentsByClientId(t *testing.T) {
 		)
 
 	err = cons.ListDocumentsByClientId(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.ListDocuments
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, doc, res)
 }
 
@@ -111,11 +111,11 @@ func TestGetDocument(t *testing.T) {
 		)
 
 	err = cons.GetDocument(ctx, docId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.Document
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, doc, res)
 }

api/queryAPI/export_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTriggerExport(t *testing.T) {
@@ -22,7 +23,7 @@ func TestTriggerExport(t *testing.T) {
 	cons := queryapi.NewControllers(&queryapi.Services{})
 
 	err := cons.TriggerExport(ctx, "clientid")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 	assert.NotEmpty(t, rec.Body.String())
 }
@@ -38,7 +39,7 @@ func TestExportState(t *testing.T) {
 	id := uuid.New()
 
 	err := cons.ExportState(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 	assert.NotEmpty(t, rec.Body.String())
 }

api/queryAPI/parse_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/oapi-codegen/runtime/types"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseQueries(t *testing.T) {
@@ -27,7 +28,7 @@ func TestParseQueries(t *testing.T) {
 		},
 	}
 	out, err := parseQueries(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, out, len(in))
 	assert.ElementsMatch(t, []Query{
 		{
@@ -56,7 +57,7 @@ func TestParseQuery(t *testing.T) {
 		Config: &cfg,
 	}
 	out, err := parseQuery(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, Query{
 		Id:            in.ID,
 		Type:          CONTEXTFULL,
@@ -78,7 +79,7 @@ func TestParseQueryMinimal(t *testing.T) {
 		LatestVersion: 2,
 	}
 	out, err := parseQuery(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, Query{
 		Id:            in.ID,
 		Type:          CONTEXTFULL,
@@ -90,11 +91,11 @@ func TestParseQueryMinimal(t *testing.T) {
 
 func TestParseQueryType(t *testing.T) {
 	qt, err := parseQueryType(resultprocessor.TypeContextFull)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, CONTEXTFULL, qt)
 
 	qt, err = parseQueryType(resultprocessor.TypeJsonExtractor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JSONEXTRACTOR, qt)
 
 	_, err = parseQueryType(resultprocessor.Type(-1))
@@ -103,11 +104,11 @@ func TestParseQueryType(t *testing.T) {
 
 func TestParseSpecQueryType(t *testing.T) {
 	qt, err := parseSpecQueryType(CONTEXTFULL)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), qt)
 
 	qt, err = parseSpecQueryType(JSONEXTRACTOR)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), qt)
 
 	_, err = parseSpecQueryType("invalid")
@@ -118,12 +119,12 @@ func TestParseStringToUUIDArray(t *testing.T) {
 	ids := []uuid.UUID{uuid.New()}
 
 	out, err := parseStringToUUIDArray(&[]string{ids[0].String()})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, ids, *out)
 	_, err = parseStringToUUIDArray(&[]string{"invalid_uuid"})
 	assert.Error(t, err)
 	out, err = parseStringToUUIDArray(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, out)
 }
 

api/queryAPI/query_test.go

@@ -48,7 +48,7 @@ func TestCreateQuery(t *testing.T) {
 		Type: queryapi.CONTEXTFULL,
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -72,7 +72,7 @@ func TestCreateQuery(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = cons.CreateQuery(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusCreated, rec.Code)
 	assert.Equal(t, fmt.Sprintf("{\"id\":\"%s\"}\n", id), rec.Body.String())
 }
@@ -101,12 +101,12 @@ func TestListQueries(t *testing.T) {
 	)
 
 	err = cons.ListQueries(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.ListQueries
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, res.Queries)
 	assert.ElementsMatch(t, res.Queries, []queryapi.Query{
 		{
@@ -144,12 +144,12 @@ func TestGetQuery(t *testing.T) {
 	)
 
 	err = cons.GetQuery(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.Query
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, queryapi.Query{
 		Id:            id,
 		Type:          queryapi.CONTEXTFULL,
@@ -182,7 +182,7 @@ func TestUpdateQuery(t *testing.T) {
 		ActiveVersion: &av,
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -214,7 +214,7 @@ func TestUpdateQuery(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = cons.UpdateQuery(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 	assert.Empty(t, rec.Body.String())
 }
@@ -254,7 +254,7 @@ func TestTestQuery(t *testing.T) {
 		QueryVersion: params.QueryVersion,
 	}
 	bodyBytes, err := json.Marshal(body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
@@ -279,12 +279,12 @@ func TestTestQuery(t *testing.T) {
 	)
 
 	err = cons.TestQuery(ctx, params.QueryID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.QueryTestResponse
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, queryapi.QueryTestResponse{
 		Value: "old_value",
 	}, res)

api/queryAPI/status_test.go

@@ -49,12 +49,12 @@ func TestGetClientStatus(t *testing.T) {
 	)
 
 	err = cons.GetStatusByClientId(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
 
 	var res queryapi.ClientStatusBody
 	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, queryapi.ClientStatusBody{
 		Status: queryapi.INSYNC,
 	}, res)

api/queryRunner/runner_test.go

@@ -64,7 +64,7 @@ func TestQueryRunner(t *testing.T) {
 			QueryID:    uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/querySyncRunner/runner_test.go

@@ -57,7 +57,7 @@ func TestQueryRunner(t *testing.T) {
 			ID: uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

api/queryVersionSyncRunner/runner_test.go

@@ -54,7 +54,7 @@ func TestQueryRunner(t *testing.T) {
 			ID: uuid.New(),
 		}
 		bodyBytes, err := json.Marshal(doc)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		body := string(bodyBytes)
 		msg := &types.Message{
 			Body: &body,

internal/client/create_test.go

@@ -38,7 +38,7 @@ func TestCreate(t *testing.T) {
 		)
 
 	id, err := svc.Create(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, aid, id)
 }
 
@@ -54,7 +54,7 @@ func TestNormalizeCreate(t *testing.T) {
 		}
 
 		err := svc.normalizeCreate(params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "client_name", params.Name)
 		assert.Equal(t, "external_id", params.ExternalId)
 	})
@@ -65,7 +65,7 @@ func TestNormalizeCreate(t *testing.T) {
 		}
 
 		err := svc.normalizeCreate(params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "client_name", params.Name)
 		assert.Equal(t, "external_id", params.ExternalId)
 	})

internal/client/get_test.go

@@ -35,7 +35,7 @@ func TestGet(t *testing.T) {
 		)
 
 	cli, err := svc.Get(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &Client{
 		ID:         id,
 		ExternalID: "client_id",
@@ -72,7 +72,7 @@ func TestGetByExternalId(t *testing.T) {
 		)
 
 	cli, err := svc.GetByExternalId(ctx, externalId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &Client{
 		ID:         id,
 		ExternalID: "client_id",

internal/client/serviceprivate_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNormalizeName(t *testing.T) {
@@ -24,7 +25,7 @@ func TestNormalizeName(t *testing.T) {
 	}
 	for key, value := range names {
 		err := normalizeName(&key)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, value, key)
 	}
 
@@ -62,19 +63,19 @@ func TestNormalizeNameUpdate(t *testing.T) {
 	}
 
 	err := c.normalizeNameUpdate(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	v := "update_name"
 	val := &v
 	err = c.normalizeNameUpdate(&val)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, val)
 	assert.Equal(t, "update_name", *val)
 
 	v = c.Name
 	val = &v
 	err = c.normalizeNameUpdate(&val)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, val)
 
 	v = "###"

internal/client/status_test.go

@@ -41,7 +41,7 @@ func TestGetStatusByExternalId(t *testing.T) {
 		)
 
 		issynced, err := svc.GetStatusByExternalId(ctx, externalId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, client.IN_SYNC, issynced)
 	})
 	t.Run("not synced", func(t *testing.T) {
@@ -55,7 +55,7 @@ func TestGetStatusByExternalId(t *testing.T) {
 		)
 
 		issynced, err := svc.GetStatusByExternalId(ctx, externalId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, client.NOT_SYNCED, issynced)
 	})
 	t.Run("not syncing", func(t *testing.T) {
@@ -65,7 +65,7 @@ func TestGetStatusByExternalId(t *testing.T) {
 		)
 
 		issynced, err := svc.GetStatusByExternalId(ctx, externalId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, client.NOT_SYNCING, issynced)
 	})
 	t.Run("db error", func(t *testing.T) {

internal/client/sync/sync_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
@@ -85,7 +84,7 @@ func TestTrigger(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.Sync(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("empty batch", func(t *testing.T) {
 		ctx := context.Background()
@@ -111,6 +110,6 @@ func TestTrigger(t *testing.T) {
 			)
 
 		err = svc.Sync(ctx, clientId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }

internal/client/update_test.go

@@ -90,7 +90,7 @@ func TestNormalizeUpdateParams(t *testing.T) {
 		CanSync: &cs,
 	}
 	err = svc.normalizeUpdateParams(current.ID, current, update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	n = "updated_client"
 	cs = true
 	assert.EqualExportedValues(t, Update{
@@ -128,7 +128,7 @@ func TestSubmitUpdate(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = svc.submitUpdate(ctx, c.ID, &update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c.CanSync = true
 	update.CanSync = &c.CanSync
@@ -139,7 +139,7 @@ func TestSubmitUpdate(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = svc.submitUpdate(ctx, c.ID, &update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c.Name = "updated_name"
 	update.Name = &c.Name
@@ -151,7 +151,7 @@ func TestSubmitUpdate(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = svc.submitUpdate(ctx, c.ID, &update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestUpdateByExternalId(t *testing.T) {

internal/collector/get_test.go

@@ -46,7 +46,7 @@ func TestGetByClientID(t *testing.T) {
 		)
 
 	coll, err := svc.GetByClientID(ctx, ogc.ClientID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, ogc, *coll)
 }
 
@@ -77,6 +77,6 @@ func TestListQueries(t *testing.T) {
 		)
 
 	qs, err := svc.ListQueries(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, ogc, qs)
 }

internal/collector/parse_test.go

@@ -9,11 +9,12 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseDBCollector(t *testing.T) {
 	c, err := parseDBCollector(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, c)
 
 	minCleanV := int64(1)
@@ -32,7 +33,7 @@ func TestParseDBCollector(t *testing.T) {
 		Mintextversion:  ogc.MinTextVersion,
 		Fields:          []byte(fmt.Sprintf("{\"example_key\":\"%s\"}", ogc.Fields["example_key"])),
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, ogc, *c)
 
 	ogc.MinCleanVersion = 0
@@ -41,6 +42,6 @@ func TestParseDBCollector(t *testing.T) {
 		Clientid: database.MustToDBUUID(ogc.ClientID),
 		Fields:   []byte(fmt.Sprintf("{\"example_key\":\"%s\"}", ogc.Fields["example_key"])),
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, ogc, *c)
 }

internal/collector/set/set_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
@@ -84,7 +83,7 @@ func TestSet(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.SetByClientId(ctx, current.ClientID, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("no collector", func(t *testing.T) {
 		current := collector.Collector{
@@ -125,7 +124,7 @@ func TestSet(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.SetByClientId(ctx, current.ClientID, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -192,7 +191,7 @@ func TestSetByExternalId(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.SetByClientExternalId(ctx, externalId, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("no collector", func(t *testing.T) {
 		current := collector.Collector{
@@ -237,6 +236,6 @@ func TestSetByExternalId(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.SetByClientExternalId(ctx, externalId, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }

internal/collector/set/setprivate_test.go

@@ -68,7 +68,7 @@ func TestGetSetParams(t *testing.T) {
 		clientId := uuid.New()
 
 		dbparams, err := svc.getSetParams(ctx, clientId, &current, &params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &dbSetParams{
 			ClientID:        database.MustToDBUUID(clientId),
 			ActiveVersion:   &aV,
@@ -227,7 +227,7 @@ func TestSubmitSet(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.submitSet(ctx, &current, &params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("only active version", func(t *testing.T) {
 
@@ -264,7 +264,7 @@ func TestSubmitSet(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.submitSet(ctx, &current, &params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -283,7 +283,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 		}
 
 		err := svc.normalizeActiveVersion(&current, nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("no update", func(t *testing.T) {
@@ -293,7 +293,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 		}
 		update := SetParams{}
 		err := svc.normalizeActiveVersion(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.ActiveVersion)
 	})
 
@@ -307,7 +307,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			ActiveVersion: &version,
 		}
 		err := svc.normalizeActiveVersion(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.ActiveVersion)
 	})
 
@@ -321,7 +321,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			ActiveVersion: &version,
 		}
 		err := svc.normalizeActiveVersion(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, version, *update.ActiveVersion)
 	})
 
@@ -350,7 +350,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 	t.Run("nil update", func(t *testing.T) {
 		current := collector.Collector{}
 		err := svc.normalizeCodeVersions(&current, nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("empty", func(t *testing.T) {
@@ -358,7 +358,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 		update := SetParams{}
 
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -370,7 +370,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 		cv := int64(1)
 		update.MinCleanVersion = &cv
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, cv, *update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -382,7 +382,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 		tv := int64(1)
 		update.MinTextVersion = &tv
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Equal(t, tv, *update.MinTextVersion)
 	})
@@ -394,7 +394,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 		current.MinCleanVersion = 1
 		current.MinTextVersion = 1
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -407,7 +407,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 
 		update.MinCleanVersion = &current.MinCleanVersion
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -420,7 +420,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 
 		update.MinTextVersion = &current.MinTextVersion
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -435,7 +435,7 @@ func TestNormalizeCodeVersions(t *testing.T) {
 		update.MinCleanVersion = &current.MinCleanVersion
 		update.MinTextVersion = &current.MinTextVersion
 		err := svc.normalizeCodeVersions(&current, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, update.MinCleanVersion)
 		assert.Nil(t, update.MinTextVersion)
 	})
@@ -545,7 +545,7 @@ func TestNormalizeSetFieldsToDB(t *testing.T) {
 		)
 
 		dbparams, err := svc.normalizeSetFieldsToDB(ctx, current, &fields)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, &map[string]pgtype.UUID{
 			"example_key": database.MustToDBUUID(fields["example_key"]),
 		}, dbparams)
@@ -598,7 +598,7 @@ func TestNormalizeSetFieldsToDB(t *testing.T) {
 		}
 
 		val, err := svc.normalizeSetFieldsToDB(ctx, current, &fields)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, val)
 	})
 }
@@ -635,7 +635,7 @@ func TestInformSet(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.informSet(ctx, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("with no update", func(t *testing.T) {
 		ctx := context.Background()
@@ -656,7 +656,7 @@ func TestInformSet(t *testing.T) {
 		}
 
 		err = svc.informSet(ctx, &update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -684,7 +684,7 @@ func TestNormalizeFieldsToDB(t *testing.T) {
 	)
 
 	dbparams, err := svc.normalizeFieldsToDB(ctx, &fields)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &map[string]pgtype.UUID{
 		"example_key": database.MustToDBUUID(fields["example_key"]),
 	}, dbparams)

internal/database/migrations/migrations_test.go

@@ -12,6 +12,7 @@ import (
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRunMigrations(t *testing.T) {
@@ -30,7 +31,7 @@ func TestRunMigrations(t *testing.T) {
 	defer cleanup()
 
 	err := migrations.Run(ctx, cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestRunMigrationsNoDB(t *testing.T) {

internal/database/parseuuid_test.go

@@ -8,13 +8,14 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestToDBUUID(t *testing.T) {
 	id := uuid.New()
 
 	dbID, err := database.ToDBUUID(id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.True(t, dbID.Valid)
 	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
@@ -24,7 +25,7 @@ func TestToDBUUIDNil(t *testing.T) {
 	id := uuid.Nil
 
 	dbID, err := database.ToDBUUID(id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.False(t, dbID.Valid)
 	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
@@ -34,7 +35,7 @@ func TestToDBUUIDArray(t *testing.T) {
 	ids := []uuid.UUID{uuid.Nil, uuid.New()}
 
 	dbIDs, err := database.ToDBUUIDArray(ids)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Len(t, dbIDs, 1)
 	assert.ElementsMatch(t, []pgtype.UUID{database.MustToDBUUID(ids[1])}, dbIDs)
@@ -42,10 +43,10 @@ func TestToDBUUIDArray(t *testing.T) {
 
 func TestToUUID(t *testing.T) {
 	dbID, err := database.ToDBUUID(uuid.New())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	id, err := database.ToUUID(dbID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
 }
@@ -55,7 +56,7 @@ func TestToUUIDArray(t *testing.T) {
 	dbIDs := database.MustToDBUUIDArray(ogIDs)
 
 	ids, err := database.ToUUIDArray(dbIDs)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Len(t, ids, 1)
 	assert.ElementsMatch(t, []uuid.UUID{ogIDs[1]}, ids)

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)

internal/document/clean/clean_test.go

@@ -103,7 +103,7 @@ func TestClean(t *testing.T) {
 		}, nil)
 
 	err = svc.clean(ctx, doc.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestExecuteCleanTasks(t *testing.T) {
@@ -154,7 +154,7 @@ func TestExecuteCleanTasks(t *testing.T) {
 		Hash:     hash,
 		Location: inloc,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, ExecuteCleanResponse{
 		location: &inloc,
 	}, *outloc)
@@ -208,7 +208,7 @@ func TestStoreClean(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.storeClean(ctx, doc.ID, params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("diff prev entry", func(t *testing.T) {
 		mimeType := "application/pdf"
@@ -239,7 +239,7 @@ func TestStoreClean(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.storeClean(ctx, doc.ID, params)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("same fail", func(t *testing.T) {
 		reason := InvalidDocumentMimeType

internal/document/clean/contentType_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetBodyMimeType(t *testing.T) {
@@ -48,7 +49,7 @@ func TestGetBodyMimeType(t *testing.T) {
 			}, nil)
 
 		contentType, err := svc.getBodyMimeType(ctx, params, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypeInvalid, contentType)
 	})
 	t.Run("pdf", func(t *testing.T) {
@@ -94,7 +95,7 @@ func TestGetBodyMimeType(t *testing.T) {
 			}, nil)
 
 		contentType, err := svc.getBodyMimeType(ctx, params, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypePDF, contentType)
 	})
 	t.Run("pdf start", func(t *testing.T) {
@@ -140,7 +141,7 @@ func TestGetBodyMimeType(t *testing.T) {
 			}, nil)
 
 		contentType, err := svc.getBodyMimeType(ctx, params, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypeInvalid, contentType)
 	})
 	t.Run("pdf end", func(t *testing.T) {
@@ -186,7 +187,7 @@ func TestGetBodyMimeType(t *testing.T) {
 			}, nil)
 
 		contentType, err := svc.getBodyMimeType(ctx, params, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypeInvalid, contentType)
 	})
 	t.Run("short", func(t *testing.T) {
@@ -281,7 +282,7 @@ func TestGetAcceptedMimeType(t *testing.T) {
 
 		inType := "invalid_type"
 		contentType, err := svc.getAcceptedMimeType(ctx, params, &inType, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypeInvalid, contentType)
 	})
 	t.Run("pdf mimetype", func(t *testing.T) {
@@ -294,7 +295,7 @@ func TestGetAcceptedMimeType(t *testing.T) {
 		}
 		inType := "application/pdf"
 		contentType, err := svc.getAcceptedMimeType(ctx, &CleanParams{}, &inType, 0)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypePDF, contentType)
 	})
 	t.Run("pdf format", func(t *testing.T) {
@@ -340,7 +341,7 @@ func TestGetAcceptedMimeType(t *testing.T) {
 
 		inType := "invalid_type"
 		contentType, err := svc.getAcceptedMimeType(ctx, params, &inType, int64(len(bodyStr)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, MimeTypePDF, contentType)
 	})
 }
@@ -380,7 +381,7 @@ func TestGetBytesBuffer(t *testing.T) {
 			}, nil)
 
 		buffer, err := svc.getBytesBuffer(ctx, params, start, length)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, buffer)
 	})
 	t.Run("negative start", func(t *testing.T) {
@@ -417,7 +418,7 @@ func TestGetBytesBuffer(t *testing.T) {
 			}, nil)
 
 		buffer, err := svc.getBytesBuffer(ctx, params, start, length)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, buffer)
 	})
 	t.Run("zero length", func(t *testing.T) {

internal/document/clean/content_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetContent(t *testing.T) {
@@ -50,7 +51,7 @@ func TestGetContent(t *testing.T) {
 			}, nil)
 
 		content, err := svc.getContent(ctx, params, mimeType)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, content)
 	})
 }

internal/document/clean/create_test.go

@@ -20,7 +20,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
@@ -130,7 +129,7 @@ func TestCreate(t *testing.T) {
 		}, nil)
 
 	err = svc.Clean(ctx, doc.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestInformClean(t *testing.T) {
@@ -156,5 +155,5 @@ func TestInformClean(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err := svc.informClean(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/document/clean/pdf_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu"
 	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu/types"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestIsValidDPI(t *testing.T) {
@@ -17,9 +18,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfHelloWorld))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  TEXTRACT_MIN_DIMENSION,
 			Height: TEXTRACT_MIN_DIMENSION,
@@ -27,7 +28,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Nil(t, reason)
@@ -37,9 +38,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfWithImg))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  TEXTRACT_MIN_DIMENSION,
 			Height: TEXTRACT_MIN_DIMENSION,
@@ -47,7 +48,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Nil(t, reason)
@@ -57,9 +58,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfWithImg))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  math.MaxFloat64,
 			Height: math.MaxFloat64,
@@ -67,7 +68,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Equal(t, InvalidDocumentSmallDPI, *reason)
@@ -77,9 +78,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfWithImg))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  math.MaxFloat64,
 			Height: 1,
@@ -87,7 +88,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Equal(t, InvalidDocumentSmallDPI, *reason)
@@ -97,9 +98,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfWithImg))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  1,
 			Height: math.MaxFloat64,
@@ -107,7 +108,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Equal(t, InvalidDocumentSmallDPI, *reason)
@@ -117,9 +118,9 @@ func TestIsValidDPI(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfWithImg))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		err = pdfCtx.EnsurePageCount()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		dims := types.Dim{
 			Width:  1,
 			Height: 1,
@@ -127,7 +128,7 @@ func TestIsValidDPI(t *testing.T) {
 		boxes, err := pdfCtx.PageBoundaries(types.IntSet{
 			1: true,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDPI(boxes[0].MediaBox(), dims)
 		assert.Nil(t, reason)
@@ -140,7 +141,7 @@ func TestIsValidDimensions(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfHelloWorld))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidDimensions(pdfCtx)
 		assert.Nil(t, reason)
@@ -150,7 +151,7 @@ func TestIsValidDimensions(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfHelloWorld))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		pdf.maxDimension = 1
 
@@ -162,7 +163,7 @@ func TestIsValidDimensions(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfHelloWorld))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		pdf.minDimension = TEXTRACT_MAX_DIMENSION
 
@@ -177,7 +178,7 @@ func TestIsValidPageCount(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfHelloWorld))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		reason := pdf.isValidPageCount(pdfCtx)
 		assert.Nil(t, reason)
@@ -187,7 +188,7 @@ func TestIsValidPageCount(t *testing.T) {
 		pdf := NewPDF(strings.NewReader(pdfTwoPages))
 
 		pdfCtx, err := pdfcpu.ReadWithContext(ctx, pdf.pdf, pdf.config)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		pdf.maxPages = 1
 

internal/document/get_test.go

@@ -40,7 +40,7 @@ func TestGetSummary(t *testing.T) {
 		)
 
 	adoc, err := svc.GetSummary(ctx, doc.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &doc, adoc)
 }
 
@@ -71,6 +71,6 @@ func TestGetExternal(t *testing.T) {
 		)
 
 	adoc, err := svc.GetExternal(ctx, doc.Id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &doc, adoc)
 }

internal/document/init/create_test.go

@@ -86,7 +86,7 @@ func TestCreate(t *testing.T) {
 		Location: location,
 		Hash:     doc.Hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, doc.ID, id)
 }
 
@@ -119,7 +119,7 @@ func TestGetCreateParams(t *testing.T) {
 		Location: location,
 		Hash:     doc.Hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &createDocumentParams{
 		ClientID: database.MustToDBUUID(doc.ClientID),
 		Hash:     doc.Hash,
@@ -158,7 +158,7 @@ func TestGetCreateParamsExisting(t *testing.T) {
 		Location: location,
 		Hash:     doc.Hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	dbid := database.MustToDBUUID(doc.ID)
 	assert.Equal(t, &createDocumentParams{
 		ID:       &dbid,
@@ -234,7 +234,7 @@ func TestSubmitCreate(t *testing.T) {
 		Location: location,
 		Hash:     doc.Hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, doc.ID, id)
 }
 
@@ -271,7 +271,7 @@ func TestSubmitCreateExists(t *testing.T) {
 		Location: location,
 		Hash:     doc.Hash,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, doc.ID, id)
 }
 
@@ -292,10 +292,10 @@ func TestGetClientIDFromKey(t *testing.T) {
 	assert.Error(t, err)
 
 	aid, err := svc.GetClientIDFromKey(fmt.Sprintf("%s/%s/bbb", id.String(), uuid.NewString()))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, aid)
 
 	aid, err = svc.GetClientIDFromKey(fmt.Sprintf("%s/bbb", id.String()))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, aid)
 }

internal/document/list_test.go

@@ -41,6 +41,6 @@ func TestListByClientId(t *testing.T) {
 		)
 
 	adoc, err := svc.ListByClientExternalId(ctx, clientId)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, doc, adoc)
 }

internal/document/sync/sync_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -69,5 +68,5 @@ func TestSync(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.Sync(ctx, doc.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/document/text/create_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -85,7 +84,7 @@ func TestCreate(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err = svc.Extract(ctx, id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("invalid clean", func(t *testing.T) {
 		id := uuid.New()
@@ -103,7 +102,7 @@ func TestCreate(t *testing.T) {
 		)
 
 		err = svc.Extract(ctx, id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -130,5 +129,5 @@ func TestInformClean(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err := svc.informExtraction(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/document/text/extract_test.go

@@ -53,7 +53,7 @@ func TestExtract(t *testing.T) {
 			)
 
 		err = svc.extract(ctx, cleanId)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("fail clean", func(t *testing.T) {
 		id := uuid.New()
@@ -102,6 +102,6 @@ func TestExecuteExtraction(t *testing.T) {
 	)
 
 	outloc, err := svc.executeExtraction(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, location, *outloc)
 }

internal/query/create_test.go

@@ -45,7 +45,7 @@ func TestCreate(t *testing.T) {
 	}
 
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(database.MustToDBUUIDArray(*create.RequiredQueryIDs)).WillReturnRows(
 		pgxmock.NewRows([]string{"all_exist"}).AddRow(true),
@@ -71,7 +71,7 @@ func TestCreate(t *testing.T) {
 	pool.ExpectCommit()
 
 	id, err := svc.Create(ctx, create)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, q.ID, id)
 }
 
@@ -94,7 +94,7 @@ func TestCreateMinimal(t *testing.T) {
 	}
 
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
@@ -110,7 +110,7 @@ func TestCreateMinimal(t *testing.T) {
 	pool.ExpectCommit()
 
 	id, err := svc.Create(ctx, create)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, q.ID, id)
 }
 
@@ -131,7 +131,7 @@ func TestCreateRollback(t *testing.T) {
 	}
 
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	msg := "database failure"

internal/query/createprivate_test.go

@@ -26,12 +26,12 @@ func TestGetCreator(t *testing.T) {
 
 	queryType := resultprocessor.Type(resultprocessor.TypeContextFull)
 	creator, err := svc.getCreator(queryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, creator)
 
 	queryType = resultprocessor.Type(resultprocessor.TypeJsonExtractor)
 	creator, err = svc.getCreator(queryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, creator)
 
 	queryType = resultprocessor.Type(-1)
@@ -50,7 +50,7 @@ func TestParseCreateQuery(t *testing.T) {
 	}
 
 	resultQuery, err := parseCreateQuery(cQuery)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	rQIDs := database.MustToDBUUIDArray(*cQuery.RequiredQueryIDs)
 	qcfg := []byte(*cQuery.Config)
 	assert.EqualExportedValues(t, createQuery{
@@ -100,7 +100,7 @@ func TestSubmitCreate(t *testing.T) {
 	}
 
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
@@ -122,7 +122,7 @@ func TestSubmitCreate(t *testing.T) {
 	pool.ExpectCommit()
 
 	id, err := svc.submitCreate(ctx, create)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, q.ID, id)
 }
 
@@ -145,7 +145,7 @@ func TestSubmitCreateNoReqsOrConfig(t *testing.T) {
 	}
 
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
@@ -161,7 +161,7 @@ func TestSubmitCreateNoReqsOrConfig(t *testing.T) {
 	pool.ExpectCommit()
 
 	id, err := svc.submitCreate(ctx, create)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, q.ID, id)
 }
 
@@ -189,7 +189,7 @@ func TestNormalizeCreate(t *testing.T) {
 	)
 
 	err = svc.normalizeCreate(ctx, create)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, resultprocessor.Create{
 		Type:             resultprocessor.TypeContextFull,
 		Config:           nil,

internal/query/get_test.go

@@ -46,7 +46,7 @@ func TestGet(t *testing.T) {
 	)
 
 	returnQuery, err := svc.Get(ctx, query.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.EqualExportedValues(t, query, *returnQuery)
 }
@@ -83,7 +83,7 @@ func TestGetWithVersion(t *testing.T) {
 	)
 
 	returnQuery, err := svc.GetWithVersion(ctx, query.ID, version)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.EqualExportedValues(t, query, *returnQuery)
 }

internal/query/list_test.go

@@ -48,7 +48,7 @@ func TestList(t *testing.T) {
 	)
 
 	resList, err := svc.List(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.EqualExportedValues(t, []*query.Query{q}, resList)
 }
@@ -83,7 +83,7 @@ func TestListById(t *testing.T) {
 	)
 
 	resList, err := svc.ListById(ctx, []uuid.UUID{q.ID})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.EqualExportedValues(t, []*query.Query{q}, resList)
 }

internal/query/normalize_test.go

@@ -20,43 +20,43 @@ func TestNormalizeConfig(t *testing.T) {
 	s := Service{}
 
 	err := s.NormalizeConfig(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	entity := resultprocessor.Create{}
 
 	entity.Config = nil
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, entity.Config)
 
 	cfg := ""
 	entity.Config = &cfg
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, entity.Config)
 
 	cfg = "   	"
 	entity.Config = &cfg
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, entity.Config)
 
 	cfg = "{}"
 	entity.Config = &cfg
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "{}", *(entity.Config))
 
 	cfg = "{\"hello\":\"bye\"}"
 	entity.Config = &cfg
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))
 
 	cfg = "		   {  \"hello\"  :  	\"bye\"   }     "
 	entity.Config = &cfg
 	err = s.NormalizeConfig(&entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))
 
 	cfg = "{'hello':'bye'}"
@@ -81,18 +81,18 @@ func TestNormalizeQueryIDs(t *testing.T) {
 	s := Service{cfg: cfg}
 
 	err = s.NormalizeQueryIDs(ctx, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	entity := resultprocessor.Create{}
 
 	entity.RequiredQueryIDs = nil
 	err = s.NormalizeQueryIDs(ctx, &entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, entity.RequiredQueryIDs)
 
 	entity.RequiredQueryIDs = &[]uuid.UUID{}
 	err = s.NormalizeQueryIDs(ctx, &entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, entity.RequiredQueryIDs)
 
 	ids := []uuid.UUID{uuid.New()}
@@ -105,7 +105,7 @@ func TestNormalizeQueryIDs(t *testing.T) {
 	)
 
 	err = s.NormalizeQueryIDs(ctx, &entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)
 
 	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
@@ -135,7 +135,7 @@ func TestNormalizeQueryIDs(t *testing.T) {
 	)
 
 	err = s.NormalizeQueryIDs(ctx, &entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, outids, *entity.RequiredQueryIDs)
 }
 
@@ -160,7 +160,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			LatestVersion: 4,
 		}
 		err := s.NormalizeActiveVersion(&current, nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("no update", func(t *testing.T) {
@@ -170,7 +170,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 		}
 		entity := resultprocessor.Update{}
 		err := s.NormalizeActiveVersion(&current, &entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, entity.ActiveVersion)
 	})
 
@@ -184,7 +184,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			ActiveVersion: &version,
 		}
 		err := s.NormalizeActiveVersion(&current, &entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, entity.ActiveVersion)
 	})
 
@@ -198,7 +198,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			ActiveVersion: &version,
 		}
 		err := s.NormalizeActiveVersion(&current, &entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, version, *entity.ActiveVersion)
 	})
 
@@ -212,7 +212,7 @@ func TestNormalizeActiveVersion(t *testing.T) {
 			ActiveVersion: &version,
 		}
 		err := s.NormalizeActiveVersion(&current, &entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, version, *entity.ActiveVersion)
 	})
 

internal/query/parse_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseQuery(t *testing.T) {
@@ -49,7 +50,7 @@ func TestParseFullActiveQuery(t *testing.T) {
 	}
 
 	out, err := query.ParseFullActiveQuery(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	bcfg := string(q.Config)
 	assert.EqualExportedValues(t, query.Query{
 		ID:            database.MustToUUID(q.ID),
@@ -72,7 +73,7 @@ func TestFullActiveQueryEmpty(t *testing.T) {
 	}
 
 	out, err := query.ParseFullActiveQuery(dbQuery)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, query.Query{
 		ID:            database.MustToUUID(dbQuery.ID),
 		Type:          resultprocessor.TypeContextFull,
@@ -90,7 +91,7 @@ func TestFullActiveQueryWithNullUUID(t *testing.T) {
 	}
 
 	out, err := query.ParseFullActiveQuery(dbQuery)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, query.Query{
 		ID:            database.MustToUUID(dbQuery.ID),
 		Type:          resultprocessor.TypeContextFull,
@@ -110,7 +111,7 @@ func TestFullActiveQueryArray(t *testing.T) {
 	}
 
 	out, err := query.ParseFullActiveQueryArray(dbQueries)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, []*query.Query{
 		{
 			ID:            database.MustToUUID(dbQueries[0].ID),

internal/query/result/get_test.go

@@ -21,11 +21,11 @@ func TestGetValueByType(t *testing.T) {
 	_, err := getValueByType(resultprocessor.Type(-1), "example_val")
 	assert.Error(t, err)
 	pro, err := getValueByType(resultprocessor.TypeContextFull, "example_context")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, pro)
 	assert.Equal(t, "example_context", pro.GetStoreValue())
 	pro, err = getValueByType(resultprocessor.TypeJsonExtractor, "example_json")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, pro)
 	assert.Equal(t, "example_json", pro.GetStoreValue())
 }
@@ -56,7 +56,7 @@ func TestGetValueWithVersion(t *testing.T) {
 		)
 
 	val, err := svc.GetValueWithVersion(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	v := jsonextractor.NewResult(value)
 	assert.Equal(t, v, val)
 	assert.Equal(t, value, v.GetStoreValue())

internal/query/result/process_test.go

@@ -62,7 +62,7 @@ func TestProcess(t *testing.T) {
 	)
 
 	val, err := svc.Process(ctx, &params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, val)
 	assert.Equal(t, "example_value", val.GetStoreValue())
 }
@@ -81,11 +81,11 @@ func TestListRequiredValue(t *testing.T) {
 	}
 
 	pr, err := svc.listRequiredValues(ctx, nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, pr)
 
 	pr, err = svc.listRequiredValues(ctx, &Process{}, &resultprocessor.Query{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, pr)
 
 	pr, err = svc.listRequiredValues(ctx, &Process{},
@@ -93,7 +93,7 @@ func TestListRequiredValue(t *testing.T) {
 			RequiredQueryIDs: &[]uuid.UUID{},
 		},
 	)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, pr)
 
 	query := &resultprocessor.Query{
@@ -116,7 +116,7 @@ func TestListRequiredValue(t *testing.T) {
 		)
 
 	pr, err = svc.listRequiredValues(ctx, &params, query)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []resultprocessor.Value{
 		jsonextractor.NewResult(strVal),
 	}, pr)
@@ -126,11 +126,11 @@ func TestGetProcessor(t *testing.T) {
 	svc := Service{}
 
 	pr, err := svc.getProcessor(resultprocessor.TypeJsonExtractor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, pr)
 
 	pr, err = svc.getProcessor(resultprocessor.TypeContextFull)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, pr)
 
 	_, err = svc.getProcessor(resultprocessor.Type(-1))
@@ -148,7 +148,7 @@ func TestParseQueryRequirementValueArray(t *testing.T) {
 	}
 
 	out, err := parseQueryRequirementValueArray(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []resultprocessor.Value{
 		jsonextractor.NewResult(exval),
 	}, out)

internal/query/result/processor/parse_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseDBCollectorQuery(t *testing.T) {
@@ -21,7 +22,7 @@ func TestParseDBCollectorQuery(t *testing.T) {
 		Queryversion: 1,
 	}
 	value, err := resultprocessor.ParseDBCollectorQuery(&dbResult)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, uuid.Nil, value.ID)
 	assert.Nil(t, value.RequiredQueryIDs)
 	assert.Equal(t, int32(1), value.Version)
@@ -35,7 +36,7 @@ func TestParseDBCollectorQuery(t *testing.T) {
 func TestParseDBNullType(t *testing.T) {
 	qType := repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}
 	value, err := resultprocessor.ParseDBNullType(qType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value)
 
 	qType = repository.NullQuerytype{}
@@ -50,19 +51,19 @@ func TestParseDBNullType(t *testing.T) {
 func TestParseDBType(t *testing.T) {
 	qType := repository.QuerytypeJsonExtractor
 	value, err := resultprocessor.ParseDBType(qType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value)
 
 	qType = repository.QuerytypeContextFull
 	value, err = resultprocessor.ParseDBType(qType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), value)
 }
 
 func TestToDBQueryType(t *testing.T) {
 	dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor)
 	value, err := resultprocessor.ToDBQueryType(dbQueryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, repository.Querytype(repository.QuerytypeJsonExtractor), value)
 
 	dbQueryType = resultprocessor.Type(-1)
@@ -71,7 +72,7 @@ func TestToDBQueryType(t *testing.T) {
 
 	dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull)
 	value, err = resultprocessor.ToDBQueryType(dbQueryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, repository.Querytype(repository.QuerytypeContextFull), value)
 }
 
@@ -81,7 +82,7 @@ func TestToDBQueryTypeArray(t *testing.T) {
 		resultprocessor.TypeContextFull,
 	}
 	value, err := resultprocessor.ToDBQueryTypeArray(inArr)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []repository.Querytype{
 		repository.QuerytypeJsonExtractor,
 		repository.QuerytypeContextFull,
@@ -97,7 +98,7 @@ func TestToDBQueryTypeArray(t *testing.T) {
 func TestToDBNullQueryType(t *testing.T) {
 	dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor)
 	value, err := resultprocessor.ToDBNullQueryType(dbQueryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}, value)
 
 	dbQueryType = resultprocessor.Type(-1)
@@ -106,14 +107,14 @@ func TestToDBNullQueryType(t *testing.T) {
 
 	dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull)
 	value, err = resultprocessor.ToDBNullQueryType(dbQueryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeContextFull}, value)
 }
 
 func TestParseFullQuery(t *testing.T) {
 	var q *repository.Fullactivequery
 	out, err := resultprocessor.ParseFullQuery(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, out)
 
 	q = &repository.Fullactivequery{
@@ -124,7 +125,7 @@ func TestParseFullQuery(t *testing.T) {
 	}
 
 	out, err = resultprocessor.ParseFullQuery(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &resultprocessor.Query{
 		ID:      database.MustToUUID(q.ID),
 		Type:    resultprocessor.TypeContextFull,
@@ -140,7 +141,7 @@ func TestParseFullQuery(t *testing.T) {
 	}
 
 	out, err = resultprocessor.ParseFullQuery(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, &resultprocessor.Query{
 		ID:      database.MustToUUID(q.ID),
 		Type:    resultprocessor.TypeContextFull,
@@ -159,7 +160,7 @@ func TestParseFullQuery(t *testing.T) {
 	}
 
 	out, err = resultprocessor.ParseFullQuery(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cfg := "hello"
 	assert.EqualExportedValues(t, &resultprocessor.Query{
 		ID:               database.MustToUUID(q.ID),
@@ -173,7 +174,7 @@ func TestParseFullQuery(t *testing.T) {
 func TestParseFullQueryArray(t *testing.T) {
 	var q []*repository.Fullactivequery
 	out, err := resultprocessor.ParseFullQueryArray(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.ElementsMatch(t, []*resultprocessor.Query{}, out)
 
 	q = []*repository.Fullactivequery{
@@ -186,7 +187,7 @@ func TestParseFullQueryArray(t *testing.T) {
 	}
 
 	out, err = resultprocessor.ParseFullQueryArray(q)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, []*resultprocessor.Query{
 		{
 			ID:      database.MustToUUID(q[0].ID),

internal/query/result/set/set_test.go

@@ -20,7 +20,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -122,7 +121,7 @@ func TestSet(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.Set(ctx, &params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestInformQueryDependents(t *testing.T) {
@@ -186,5 +185,5 @@ func TestInformQueryDependents(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.informQueryDependents(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/result/sync/trigger_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -56,7 +55,7 @@ func TestTriggerSync(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.TriggerSync(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestTriggerMultiSync(t *testing.T) {
@@ -102,5 +101,5 @@ func TestTriggerMultiSync(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.TriggerMultiSync(ctx, docId, qIds)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/test/test_test.go

@@ -65,6 +65,6 @@ func TestTest(t *testing.T) {
 	)
 
 	result, err := svc.Test(ctx, *params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "old_value", result)
 }

internal/query/types/contextFull/creator_test.go

@@ -31,5 +31,5 @@ func TestCreatorValidate(t *testing.T) {
 	}
 
 	err = svc.Validate(ctx, entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/types/contextFull/process_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestContextFull(t *testing.T) {
@@ -25,7 +26,7 @@ func TestContextFull(t *testing.T) {
 	values := []resultprocessor.Value{}
 
 	value, err := extractor.Process(ctx, query, values)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, `{"keyone":"valueone","keytwo":"valuetwo"}`, value)
 
 	values = []resultprocessor.Value{

internal/query/types/contextFull/updator_test.go

@@ -39,5 +39,5 @@ func TestUpdatorValidate(t *testing.T) {
 	}
 
 	err = svc.Validate(ctx, current, entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/types/jsonExtractor/creator_test.go

@@ -34,5 +34,5 @@ func TestCreatorValidate(t *testing.T) {
 	}
 
 	err = svc.Validate(ctx, entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/types/jsonExtractor/process_test.go

@@ -51,7 +51,7 @@ func TestJSONProcess(t *testing.T) {
 		)
 
 	value, err := extractor.Process(ctx, query, values)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, entryValue, value)
 
 	entryValue = ""
@@ -66,7 +66,7 @@ func TestJSONProcess(t *testing.T) {
 		)
 
 	value, err = extractor.Process(ctx, query, values)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, entryValue, value)
 
 	entryValue = "1"
@@ -81,7 +81,7 @@ func TestJSONProcess(t *testing.T) {
 		)
 
 	value, err = extractor.Process(ctx, query, values)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, entryValue, value)
 }
 

internal/query/types/jsonExtractor/updator_test.go

@@ -38,5 +38,5 @@ func TestUpdatorValidate(t *testing.T) {
 	}
 
 	err = svc.Validate(ctx, current, entity)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/update/update_test.go

@@ -21,7 +21,6 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -85,5 +84,5 @@ func TestUpdate(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err = svc.Update(ctx, update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/query/update/updateprivate_test.go

@@ -41,12 +41,12 @@ func TestGetUpdator(t *testing.T) {
 
 	queryType := resultprocessor.Type(resultprocessor.TypeContextFull)
 	updator, err := svc.getUpdator(queryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, updator)
 
 	queryType = resultprocessor.Type(resultprocessor.TypeJsonExtractor)
 	updator, err = svc.getUpdator(queryType)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, updator)
 
 	queryType = resultprocessor.Type(-1)
@@ -102,7 +102,7 @@ func TestSubmitUpdate(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = svc.submitUpdate(ctx, &q, update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestSubmitUpdateRollback(t *testing.T) {
@@ -189,7 +189,7 @@ func TestSubmitUpdateRequiredQueries(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.submitUpdate(ctx, &q, update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("all nil", func(t *testing.T) {
 
@@ -228,7 +228,7 @@ func TestSubmitUpdateRequiredQueries(t *testing.T) {
 		pool.ExpectCommit()
 
 		err = svc.submitUpdate(ctx, &q, update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }
 
@@ -261,7 +261,7 @@ func TestSubmitUpdateActiveVersion(t *testing.T) {
 	pool.ExpectCommit()
 
 	err = svc.submitUpdate(ctx, &q, update)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetSetDifference(t *testing.T) {
@@ -306,7 +306,7 @@ func TestNormalizeUpdate(t *testing.T) {
 		}
 
 		err = svc.normalizeUpdate(ctx, current, update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, resultprocessor.Update{
 			ID:               current.ID,
 			ActiveVersion:    &aV,
@@ -418,7 +418,7 @@ func TestNormalizeUpdateRequiredQueryIDs(t *testing.T) {
 		}
 
 		err = svc.normalizeUpdateRequiredQueryIDs(ctx, current, update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, resultprocessor.Update{
 			ID: current.ID,
 		}, *update)
@@ -521,7 +521,7 @@ func TestNormalizeUpdateRequiredQueryIDs(t *testing.T) {
 		)
 
 		err = svc.normalizeUpdateRequiredQueryIDs(ctx, current, update)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualExportedValues(t, resultprocessor.Update{
 			ID: current.ID,
 		}, *update)
@@ -546,7 +546,7 @@ func TestInformUpdate(t *testing.T) {
 		}
 
 		err := svc.informUpdate(ctx, entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 	t.Run("update active version", func(t *testing.T) {
 		ctx := context.Background()
@@ -576,6 +576,6 @@ func TestInformUpdate(t *testing.T) {
 			Return(&sqs.SendMessageOutput{}, nil)
 
 		err := svc.informUpdate(ctx, entity)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 }

internal/server/api/listener.go

@@ -96,12 +96,6 @@ func New(ctx context.Context, cfg Config) (*Server, error) {
 	}
 
 	e := echo.New()
-	cfg.SetRouter(e)
-
-	opnapi, err := cfg.RegisterHandlers()
-	if err != nil {
-		return nil, err
-	}
 
 	e.Use(echoprometheus.NewMiddleware("echo"))
 	e.GET("/metrics", echoprometheus.NewHandler())
@@ -110,6 +104,12 @@ func New(ctx context.Context, cfg Config) (*Server, error) {
 	e.Use(middleware.Recover())
 	e.Use(middleware.CORS())
 
+	cfg.SetRouter(e)
+	opnapi, err := cfg.RegisterHandlers()
+	if err != nil {
+		return nil, err
+	}
+
 	err = setOapi(e, opnapi)
 	if err != nil {
 		return nil, err
@@ -131,6 +131,10 @@ func New(ctx context.Context, cfg Config) (*Server, error) {
 func setOapi(e *echo.Echo, opnapi *openapi3.T) error {
 	opnapi.Servers = nil
 	validatorOptions := &oapimiddleware.Options{
+		Skipper: func(c echo.Context) bool {
+			return len(c.Path()) >= 8 && (c.Path()[:8] == "/swagger" ||
+				c.Path()[:8] == "/metrics")
+		},
 		Options: openapi3filter.Options{
 			AuthenticationFunc: openapi3filter.NoopAuthenticationFunc,
 			MultiError:         true,

internal/server/api/listener_test.go

@@ -35,12 +35,12 @@ func TestNew(t *testing.T) {
 	defer cleanup()
 
 	registerHandlers := func() (*openapi3.T, error) {
-		return nil, nil
+		return &openapi3.T{}, nil
 	}
 	cfg.RegisterHandlersFunc = registerHandlers
 
 	serverInstance, err := New(ctx, cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 8080, serverInstance.port)
 	assert.Equal(t, "0.0.0.0", serverInstance.host)
 	assert.Equal(t, "0.0.0.0:8080", serverInstance.address)
@@ -61,7 +61,7 @@ func TestRegisterHandlers(t *testing.T) {
 		return &openapi3.T{}, nil
 	}
 	op, err := c.RegisterHandlers()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &openapi3.T{}, op)
 	assert.Equal(t, op, c.OpenAPI)
 }

internal/server/runner/listener_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNew(t *testing.T) {
@@ -30,7 +31,7 @@ func TestNew(t *testing.T) {
 	})
 	defer acleanup()
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
 		Cfg: cfg,
 	})
@@ -46,7 +47,7 @@ func TestNew(t *testing.T) {
 
 	t.Setenv("QUEUE_URL", "queueName")
 	srvPtr, err := New(ctx, cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, srvPtr)
 }
 
@@ -68,7 +69,7 @@ func TestRegisterController(t *testing.T) {
 		return runnermock.NewMockController(t)
 	}
 	err = c.RegisterController()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, runnermock.NewMockController(t), c.Controller)
 }
 
@@ -90,7 +91,7 @@ func TestPingQueue(t *testing.T) {
 		Return(&sqs.GetQueueAttributesOutput{}, nil)
 
 	err := c.PingQueue(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetQueueURL(t *testing.T) {

internal/server/runner/poll_test.go

@@ -10,8 +10,8 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/aws/aws-sdk-go-v2/service/sqs/types"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestPollMessages(t *testing.T) {
@@ -103,7 +103,7 @@ func TestPollMessage(t *testing.T) {
 		Return(&sqs.DeleteMessageOutput{}, nil)
 
 	err := ser.pollMessage(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestProcessMessage(t *testing.T) {
@@ -150,5 +150,5 @@ func TestProcessMessage(t *testing.T) {
 		Return(&sqs.DeleteMessageOutput{}, nil)
 
 	err := ser.processMessage(ctx, msg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/server/server_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/go-playground/validator/v10"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNew(t *testing.T) {
@@ -30,7 +31,7 @@ func TestNew(t *testing.T) {
 	defer cleanup()
 
 	clean, err := server.New(ctx, cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer func() {
 		if err := clean(); err != nil {
 			// Log cleanup error but don't panic since we're shutting down

internal/serviceconfig/database/pool_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSetDBPool(t *testing.T) {
@@ -31,7 +32,7 @@ func TestSetDBPool(t *testing.T) {
 	defer cleanup()
 
 	err := cfg.SetDBPool(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, cfg.GetDBPool())
 }
 
@@ -48,7 +49,7 @@ func TestGetDBPoolConfig(t *testing.T) {
 	cfg.DBUser = "user"
 	cfg.DBSecret = "pass"
 	err = cfg.SetDBPoolConfig()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, cfg.DBPoolConfig)
 }
 

internal/serviceconfig/database/transaction_test.go

@@ -40,10 +40,10 @@ func TestExecuteTransaction(t *testing.T) {
 			Name:       clientName,
 			Externalid: externalId,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, clientID, id)
 
 		return nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/serviceconfig/objectstore/config_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetStoreClient(t *testing.T) {
@@ -28,7 +29,7 @@ func TestStoreClient(t *testing.T) {
 	ctx := context.Background()
 	c := objectstore.ObjectStoreConfig{}
 	err := c.SetStoreClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, c.StoreClient)
 }
 
@@ -51,7 +52,7 @@ func TestPingStoreByName(t *testing.T) {
 		Return(&s3.HeadBucketOutput{}, nil)
 
 	err := c.PingStoreByName(ctx, name)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetS3Client(t *testing.T) {

internal/serviceconfig/queue/config_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetQueueClient(t *testing.T) {
@@ -25,7 +26,7 @@ func TestSetQueueClient(t *testing.T) {
 	ctx := context.Background()
 	c := queue.QueueConfig{}
 	err := c.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, c.QueueClient)
 }
 
@@ -48,7 +49,7 @@ func TestPingQueueByURL(t *testing.T) {
 		Return(&sqs.GetQueueAttributesOutput{}, nil)
 
 	err := c.PingQueueByURL(ctx, url)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 func TestGetSQSEndpoint(t *testing.T) {
 	cfg := queue.QueueConfig{}

internal/serviceconfig/queue/delete_test.go

@@ -7,8 +7,9 @@ import (
 	"queryorchestration/internal/serviceconfig/queue"
 	queuemock "queryorchestration/mocks/queue"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -34,5 +35,5 @@ func TestDelete(t *testing.T) {
 		Return(&sqs.DeleteMessageOutput{}, nil)
 
 	err := cfg.DeleteFromQueue(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/serviceconfig/queue/receive.go

@@ -15,8 +15,8 @@ func (c *QueueConfig) ReceiveFromQueue(ctx context.Context, params *ReceiveParam
 	return c.QueueClient.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
 		QueueUrl:              &params.QueueURL,
 		MaxNumberOfMessages:   1,
-		WaitTimeSeconds:       30,
-		VisibilityTimeout:     5,
+		WaitTimeSeconds:       10,
+		VisibilityTimeout:     10,
 		MessageAttributeNames: params.Attributes,
 	})
 }

internal/serviceconfig/queue/receive_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReceive(t *testing.T) {
@@ -35,6 +36,6 @@ func TestReceive(t *testing.T) {
 		Return(&res, nil)
 
 	ares, err := cfg.ReceiveFromQueue(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualExportedValues(t, res, *ares)
 }

internal/serviceconfig/queue/send_test.go

@@ -8,8 +8,8 @@ import (
 	queuemock "queryorchestration/mocks/queue"
 
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSend(t *testing.T) {
@@ -33,5 +33,5 @@ func TestSend(t *testing.T) {
 		Return(&sqs.SendMessageOutput{}, nil)
 
 	err := cfg.SendToQueue(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/test/container.go

@@ -47,6 +47,7 @@ func createContainer(t testing.TB, ctx context.Context, cfg *containerConfig) (t
 		"AWS_ENDPOINT_URL_SQS":  cfg.Cfg.GetAWSEndpoint(),
 		"AWS_ENDPOINT_URL_S3":   cfg.Cfg.GetAWSEndpoint(),
 		"AWS_S3_USE_PATH_STYLE": strconv.FormatBool(true),
+		"LOG_LEVEL":             "DEBUG",
 	}
 	if cfg.Env != nil {
 		for k, v := range cfg.Env {
@@ -79,14 +80,7 @@ func createContainer(t testing.TB, ctx context.Context, cfg *containerConfig) (t
 		Started:          true,
 	})
 	if err != nil {
-		logs, _ := container.Logs(ctx)
-		defer logs.Close()
-
-		scanner := bufio.NewScanner(logs)
-		for scanner.Scan() {
-			line := scanner.Text()
-			slog.Error(line)
-		}
+		PrintContainerLogs(t, ctx, container)
 
 		require.NoError(t, err)
 	}
@@ -98,3 +92,18 @@ func createContainer(t testing.TB, ctx context.Context, cfg *containerConfig) (t
 		}
 	}
 }
+
+func PrintContainerLogs(t testing.TB, ctx context.Context, container testcontainers.Container) {
+	logs, err := container.Logs(ctx)
+	defer func() {
+		err := logs.Close()
+		require.NoError(t, err)
+	}()
+	require.NoError(t, err)
+
+	scanner := bufio.NewScanner(logs)
+	for scanner.Scan() {
+		line := scanner.Text()
+		slog.Error(line)
+	}
+}

internal/test/container_test.go

@@ -42,5 +42,7 @@ func TestCreateContainer(t *testing.T) {
 	assert.NotNil(t, container)
 	assert.NotNil(t, cleanup)
 
+	PrintContainerLogs(t, ctx, container)
+
 	cleanup()
 }

internal/test/ecosystem.go

@@ -16,6 +16,111 @@ import (
 	"github.com/testcontainers/testcontainers-go"
 )
 
+type Network struct {
+	Dependencies Dependencies
+	APIs         map[string]*Container
+	Runners      map[string]*Container
+	Client       *queryapi.ClientWithResponses
+}
+
+func CreateFullNetwork(t testing.TB, ctx context.Context, cfg FullDependenciesConfig) (Network, func()) {
+	deps, clean := CreateFullDependencies(t, ctx, cfg)
+
+	apiContainers := make(map[string]*Container, len(apis))
+	apiClean := make([]func(), len(apis))
+	for i, s := range apis {
+		c, ccleanup := CreateAPI(t, ctx, &APIConfig{
+			API:     s,
+			Cfg:     cfg,
+			Network: deps.Network,
+		})
+		apiContainers[s.Name] = c
+		apiClean[i] = ccleanup
+	}
+
+	qService, err := queryapi.NewClientWithResponses(apiContainers[QueryAPIName].URI)
+	require.NoError(t, err)
+
+	runnerContainers := make(map[string]*Container, len(runners))
+	runnerClean := make([]func(), len(runners))
+	for i, r := range runners {
+		c, ccleanup := CreateRunner(t, ctx, &RunnerConfig{
+			Runner:  r,
+			Cfg:     cfg,
+			Network: deps.Network,
+		})
+
+		runnerContainers[r.Name] = c
+		runnerClean[i] = ccleanup
+	}
+
+	return Network{
+			Dependencies: deps,
+			APIs:         apiContainers,
+			Runners:      runnerContainers,
+			Client:       qService,
+		}, func() {
+			for _, c := range apiClean {
+				c()
+			}
+			for _, c := range runnerClean {
+				c()
+			}
+			clean()
+		}
+}
+
+type FullDependenciesConfig interface {
+	serviceconfig.ConfigProvider
+	objectstore.ConfigProvider
+}
+
+type Dependencies struct {
+	BucketName string
+	QueueURLs  map[string]string
+	Network    *testcontainers.DockerNetwork
+	AWSConfig  *AWSContainerConfig
+	DBConfig   testcontainers.Container
+}
+
+func CreateFullDependencies(t testing.TB, ctx context.Context, cfg FullDependenciesConfig) (Dependencies, func()) {
+	network, ncleanup := CreateNetwork(t, ctx)
+
+	acfg, awsclean := CreateAWSContainer(t, ctx, &CreateAWSConfig{
+		Cfg:     cfg,
+		Network: network,
+	})
+
+	dbcfg, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{
+		Network:       network,
+		Cfg:           cfg,
+		RunMigrations: true,
+	})
+
+	SetQueueClient(t, ctx, cfg)
+	SetStoreClient(t, ctx, cfg, acfg.ExternalEndpoint)
+
+	urls := map[string]string{}
+	for _, runner := range runners {
+		urls[runner.Name] = CreateQueue(t, ctx, cfg, runner.Name)
+	}
+
+	CreateBucket(t, ctx, cfg, BucketName)
+	SetBucketNotifs(t, ctx, cfg, BucketName)
+
+	return Dependencies{
+			BucketName: BucketName,
+			QueueURLs:  urls,
+			Network:    network,
+			AWSConfig:  acfg,
+			DBConfig:   dbcfg,
+		}, func() {
+			awsclean()
+			dbcleanup()
+			ncleanup()
+		}
+}
+
 func SetCfgProviderWithBasePath(t testing.TB, cfg serviceconfig.ConfigProvider, basePath string) {
 	SetCfgProvider(t, cfg)
 
@@ -81,106 +186,3 @@ func CreateAPINetwork(t testing.TB, ctx context.Context, scfg *ServiceNetworkCon
 		}
 	}
 }
-
-type FullDependenciesConfig interface {
-	serviceconfig.ConfigProvider
-	objectstore.ConfigProvider
-}
-
-type Dependencies struct {
-	BucketName string
-	QueueURLs  map[string]string
-	Network    *testcontainers.DockerNetwork
-	AWSConfig  *AWSContainerConfig
-}
-
-func CreateFullDependencies(t testing.TB, ctx context.Context, cfg FullDependenciesConfig) (Dependencies, func()) {
-	network, ncleanup := CreateNetwork(t, ctx)
-
-	acfg, awsclean := CreateAWSContainer(t, ctx, &CreateAWSConfig{
-		Cfg:     cfg,
-		Network: network,
-	})
-
-	_, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{
-		Network:       network,
-		Cfg:           cfg,
-		RunMigrations: true,
-	})
-
-	SetQueueClient(t, ctx, cfg)
-	SetStoreClient(t, ctx, cfg, acfg.ExternalEndpoint)
-
-	urls := map[string]string{}
-	for _, runner := range runners {
-		urls[runner.Name] = CreateQueue(t, ctx, cfg, runner.Name)
-	}
-
-	CreateBucket(t, ctx, cfg, BucketName)
-	SetBucketNotifs(t, ctx, cfg, BucketName)
-
-	return Dependencies{
-			BucketName: BucketName,
-			QueueURLs:  urls,
-			Network:    network,
-			AWSConfig:  acfg,
-		}, func() {
-			awsclean()
-			dbcleanup()
-			ncleanup()
-		}
-}
-
-type Network struct {
-	Dependencies Dependencies
-	APIs         map[string]*Container
-	Runners      map[string]*Container
-	Client       *queryapi.ClientWithResponses
-}
-
-func CreateFullNetwork(t testing.TB, ctx context.Context, cfg FullDependenciesConfig) (Network, func()) {
-	deps, clean := CreateFullDependencies(t, ctx, cfg)
-
-	apiContainers := make(map[string]*Container, len(apis))
-	apiClean := make([]func(), len(apis))
-	for i, s := range apis {
-		c, ccleanup := CreateAPI(t, ctx, &APIConfig{
-			API:     s,
-			Cfg:     cfg,
-			Network: deps.Network,
-		})
-		apiContainers[s.Name] = c
-		apiClean[i] = ccleanup
-	}
-
-	qService, err := queryapi.NewClientWithResponses(apiContainers[QueryAPIName].URI)
-	require.NoError(t, err)
-
-	runnerContainers := make(map[string]*Container, len(runners))
-	runnerClean := make([]func(), len(runners))
-	for i, r := range runners {
-		c, ccleanup := CreateRunner(t, ctx, &RunnerConfig{
-			Runner:  r,
-			Cfg:     cfg,
-			Network: deps.Network,
-		})
-
-		runnerContainers[r.Name] = c
-		runnerClean[i] = ccleanup
-	}
-
-	return Network{
-			Dependencies: deps,
-			APIs:         apiContainers,
-			Runners:      runnerContainers,
-			Client:       qService,
-		}, func() {
-			for _, c := range apiClean {
-				c()
-			}
-			for _, c := range runnerClean {
-				c()
-			}
-			clean()
-		}
-}

internal/test/objectstore.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"testing"
 
 	objectstore "queryorchestration/internal/serviceconfig/objectstore"
@@ -20,6 +21,7 @@ func CreateBucket(t testing.TB, ctx context.Context, cfg objectstore.ConfigProvi
 		Bucket: aws.String(name),
 	})
 	require.NoError(t, err)
+	slog.Info("create bucket", "bucket", name)
 
 	err = cfg.PingStoreByName(ctx, name)
 	require.NoError(t, err)
@@ -43,7 +45,7 @@ func SetBucketNotifs(t testing.TB, ctx context.Context, cfg objectstore.ConfigPr
 		},
 	})
 	require.NoError(t, err)
-
+	slog.Info("set bucket notifs", "bucket", name, "queueARN", arn)
 }
 
 func SetStoreClient(t testing.TB, ctx context.Context, cfg objectstore.ConfigProvider, endpoint string) {
@@ -61,4 +63,5 @@ func PutObject(t testing.TB, ctx context.Context, cfg objectstore.ConfigProvider
 		Body:   file,
 	})
 	require.NoError(t, err)
+	slog.Info("put object", "bucket", bucket, "key", location)
 }

internal/test/queryAPI/service.go

@@ -3,6 +3,7 @@ package queryapitest
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"testing"
 	"time"
 
@@ -36,7 +37,7 @@ func CreateClientWithSync(t testing.TB, ctx context.Context, client queryapi.Cli
 func WaitForClientStatus(t testing.TB, ctx context.Context, service queryapi.ClientWithResponsesInterface, id string, status queryapi.ClientStatus) {
 	t.Helper()
 
-	timeout := time.After(30 * time.Second)
+	timeout := time.After(60 * time.Second)
 	ticker := time.NewTicker(500 * time.Millisecond)
 	defer ticker.Stop()
 
@@ -47,13 +48,16 @@ func WaitForClientStatus(t testing.TB, ctx context.Context, service queryapi.Cli
 		case <-ticker.C:
 			jRes, err := service.GetStatusByClientIdWithResponse(ctx, id)
 			if err != nil {
-				assert.NoError(t, err)
+				slog.Error("error getting status", "error", err.Error())
+				require.NoError(t, err)
 			}
 
 			if jRes.JSON200.Status == status {
 				assert.Equal(t, status, jRes.JSON200.Status)
 				return
 			}
+
+			slog.Error("unexpected status", "status", jRes.JSON200.Status)
 		}
 	}
 }

internal/test/queue.go

@@ -3,6 +3,7 @@ package test
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"regexp"
 	"testing"
 
@@ -36,6 +37,7 @@ func CreateQueue(t testing.TB, ctx context.Context, cfg serviceconfig.ConfigProv
 		QueueName: aws.String(name),
 	})
 	require.NoError(t, err)
+	slog.Info("create queue", "name", name, "url", *queueM.QueueUrl)
 
 	err = cfg.PingQueueByURL(ctx, *queueM.QueueUrl)
 	require.NoError(t, err)
@@ -45,7 +47,7 @@ func CreateQueue(t testing.TB, ctx context.Context, cfg serviceconfig.ConfigProv
 
 func AssertMessage(t testing.TB, ctx context.Context, cfg serviceconfig.ConfigProvider, params *queue.ReceiveParams) types.Message {
 	result, err := cfg.ReceiveFromQueue(ctx, params)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, result.Messages)
 	assert.Len(t, result.Messages, 1)
 	assert.NotNil(t, result.Messages[0])

internal/test/queue_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateQueue(t *testing.T) {
@@ -30,7 +31,7 @@ func TestCreateQueue(t *testing.T) {
 	defer cleanup()
 
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	url := CreateQueue(t, ctx, cfg, "myname")
 	assert.Equal(t, "http://localstack:4566/queue/us-east-1/000000000000/myname", url)
@@ -50,14 +51,14 @@ func TestAssertMessageWait(t *testing.T) {
 	})
 	defer cleanup()
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	url := CreateQueue(t, ctx, cfg, "myname")
 
 	err = cfg.SendToQueue(ctx, &queue.SendParams{
 		QueueURL: url,
 		Body:     "body",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	msg := AssertMessage(t, ctx, cfg, &queue.ReceiveParams{
 		QueueURL: url,
@@ -79,14 +80,14 @@ func TestAssertMessageBodyWait(t *testing.T) {
 	})
 	defer cleanup()
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	url := CreateQueue(t, ctx, cfg, "myname")
 
 	err = cfg.SendToQueue(ctx, &queue.SendParams{
 		QueueURL: url,
 		Body:     "body",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	AssertMessageBody(t, ctx, cfg, url, regexp.MustCompile("\"body\""))
 }
@@ -105,7 +106,7 @@ func TestAssertMessageAttrWait(t *testing.T) {
 	})
 	defer cleanup()
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	url := CreateQueue(t, ctx, cfg, "myname")
 
 	name := "name"
@@ -121,7 +122,7 @@ func TestAssertMessageAttrWait(t *testing.T) {
 			},
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	AssertMessageAttr(t, ctx, cfg, url, name, regexp.MustCompile(value))
 }

internal/test/runner_test.go

@@ -7,6 +7,7 @@ import (
 	"queryorchestration/internal/serviceconfig"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateRunner(t *testing.T) {
@@ -27,7 +28,7 @@ func TestCreateRunner(t *testing.T) {
 	})
 	defer qcleanup()
 	err := cfg.SetQueueClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_ = CreateQueue(t, ctx, cfg, QueryRunnerName)
 
 	_, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{

internal/validation/validation_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetUpdatedValue(t *testing.T) {
@@ -30,17 +31,17 @@ func TestDeduplicateArray(t *testing.T) {
 
 func TestNormalizeInClosedInterval(t *testing.T) {
 	err := validation.NormalizeInClosedInterval(nil, 1, 1, 1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var param *int32
 	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, param)
 
 	updated := int32(1)
 	param = &updated
 	err = validation.NormalizeInClosedInterval(&param, 1, 1, 1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, param)
 	assert.Equal(t, int32(1), updated)
 
@@ -57,7 +58,7 @@ func TestNormalizeInClosedInterval(t *testing.T) {
 	updated = 2
 	param = &updated
 	err = validation.NormalizeInClosedInterval(&param, 1, 1, 3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int32(2), updated)
 }
 
@@ -175,7 +176,7 @@ func TestGetFieldName(t *testing.T) {
 			fieldone: nil,
 		}
 		name, err := validation.GetFieldName(val, val.fieldone)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "fieldone", name)
 	})
 	t.Run("valid field is populated", func(t *testing.T) {
@@ -187,7 +188,7 @@ func TestGetFieldName(t *testing.T) {
 			fieldone: &strval,
 		}
 		name, err := validation.GetFieldName(val, val.fieldone)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "fieldone", name)
 	})
 }

serviceAPIs/queryAPI.yaml

@@ -652,7 +652,7 @@ components:
       type: string
       description: Configuration for the query.
       maxLength: 2048
-      pattern: '^\{.+\}$'
+      pattern: '^\{.*\}$'
 
     Query:
       description: A logic unit of execution.
@@ -930,7 +930,7 @@ components:
 
     CollectorFieldName:
       type: string
-      pattern: "^[a-zA-Z]+$"
+      pattern: "^.+$"
       maxLength: 256
       description: The output field name.
 

test/process_test.go

@@ -2,6 +2,7 @@ package endtoend_test
 
 import (
 	"context"
+	"net/http"
 	"strings"
 	"testing"
 
@@ -36,6 +37,7 @@ func TestProcess(t *testing.T) {
 		Type: queryapi.CONTEXTFULL,
 	})
 	require.NoError(t, err)
+	require.Equal(t, http.StatusCreated, contextQueryRes.StatusCode())
 	jcfg := `{"path":"keyone"}`
 	jsonQueryRes, err := net.Client.CreateQueryWithResponse(ctx, queryapi.QueryCreate{
 		Type:            queryapi.JSONEXTRACTOR,
@@ -43,8 +45,9 @@ func TestProcess(t *testing.T) {
 		RequiredQueries: &[]types.UUID{contextQueryRes.JSON201.Id},
 	})
 	require.NoError(t, err)
+	require.Equal(t, http.StatusCreated, jsonQueryRes.StatusCode())
 	newActiveVersion := int32(1)
-	_, err = net.Client.SetCollectorByClientIdWithResponse(ctx, client.Id, queryapi.CollectorSet{
+	collRes, err := net.Client.SetCollectorByClientIdWithResponse(ctx, client.Id, queryapi.CollectorSet{
 		ActiveVersion: &newActiveVersion,
 		Fields: &[]queryapi.CollectorField{
 			{
@@ -54,11 +57,12 @@ func TestProcess(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, collRes.StatusCode())
 
 	queryapitest.WaitForClientStatus(t, ctx, net.Client, client.Id, queryapi.INSYNC)
 
 	body := strings.NewReader(pdfHelloWorld)
-	test.PutObject(t, ctx, cfg, client.Uid, net.Dependencies.BucketName, "object_name", body)
+	test.PutObject(t, ctx, cfg, client.Uid, net.Dependencies.BucketName, "objectname", body)
 
 	queryapitest.WaitForClientStatus(t, ctx, net.Client, client.Id, queryapi.NOTSYNCED)
 	queryapitest.WaitForClientStatus(t, ctx, net.Client, client.Id, queryapi.INSYNC)
@@ -114,7 +118,7 @@ func TestProcess(t *testing.T) {
 		QueryVersion: 2,
 		DocumentId:   doc.Id,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "valuetwo", testRes.JSON200.Value)
 
 	docRes, err = net.Client.GetDocumentWithResponse(ctx, doc.Id)

test/queryAPI/accessory_test.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"queryorchestration/internal/test"
 
 	"github.com/stretchr/testify/assert"
@@ -20,22 +22,22 @@ func TestQueryAPIAccessories(t *testing.T) {
 	defer cleanup()
 
 	resp, err := http.Get(fmt.Sprintf("%s/swagger/doc.json", c.URI))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, resp)
 	assert.Equal(t, http.StatusOK, resp.StatusCode)
 
 	resp, err = http.Get(fmt.Sprintf("%s/swagger/doc.yaml", c.URI))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, resp)
 	assert.Equal(t, http.StatusOK, resp.StatusCode)
 
 	resp, err = http.Get(fmt.Sprintf("%s/swagger/index.html", c.URI))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, resp)
 	assert.Equal(t, http.StatusOK, resp.StatusCode)
 
 	resp, err = http.Get(fmt.Sprintf("%s/metrics", c.URI))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, resp)
 	assert.Equal(t, http.StatusOK, resp.StatusCode)
 }

test/queryAPI/client_test.go

@@ -9,6 +9,7 @@ import (
 	queryapi "queryorchestration/pkg/queryAPI"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestClient(t *testing.T) {
@@ -20,10 +21,10 @@ func TestClient(t *testing.T) {
 	defer cleanup()
 
 	client, err := queryapi.NewClientWithResponses(c.URI)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clientErrRes, err := client.GetClientWithResponse(ctx, "INVALID")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, http.StatusBadRequest, clientErrRes.StatusCode())
 	assert.Equal(t, "Unable to get client: no rows in result set", clientErrRes.JSON400.Message)
 
@@ -31,14 +32,15 @@ func TestClient(t *testing.T) {
 		Name: "example_name",
 		Id:   "EXA",
 	})
-	assert.NoError(t, err)
-	assert.NotNil(t, idRes)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusCreated, idRes.StatusCode())
 	assert.NotNil(t, idRes.JSON201)
-	assert.NotNil(t, idRes.JSON201.Id)
+	assert.Equal(t, "EXA", idRes.JSON201.Id)
 	id := idRes.JSON201.Id
 
 	clientRes, err := client.GetClientWithResponse(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, clientRes.StatusCode())
 	assert.Equal(t, id, clientRes.JSON200.Id)
 	assert.Equal(t, "example_name", clientRes.JSON200.Name)
 	assert.False(t, clientRes.JSON200.CanSync)
@@ -49,11 +51,11 @@ func TestClient(t *testing.T) {
 		Name:    &updateName,
 		CanSync: &updateCanSync,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, updateRes)
 
 	clientRes, err = client.GetClientWithResponse(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, clientRes.JSON200.Id)
 	assert.Equal(t, updateName, clientRes.JSON200.Name)
 	assert.True(t, clientRes.JSON200.CanSync)

test/queryAPI/collectorservice_test.go

@@ -10,6 +10,8 @@ import (
 	"queryorchestration/internal/test"
 	queryapi "queryorchestration/pkg/queryAPI"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/oapi-codegen/runtime/types"
 	"github.com/stretchr/testify/assert"
 )
@@ -45,12 +47,12 @@ func TestCollectorService(t *testing.T) {
 	defer cleanup()
 
 	client, err := queryapi.NewClientWithResponses(c.URI)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	contextRes, err := client.CreateQueryWithResponse(ctx, queryapi.QueryCreate{
 		Type: queryapi.CONTEXTFULL,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	jsoncfg := "{\"path\":\"key\"}"
 	jsonRes, err := client.CreateQueryWithResponse(ctx, queryapi.QueryCreate{
@@ -60,17 +62,17 @@ func TestCollectorService(t *testing.T) {
 			contextRes.JSON201.Id,
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	clientRes, err := client.CreateClientWithResponse(ctx, queryapi.ClientCreate{
 		Name: "example_name",
 		Id:   "ID",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	id := clientRes.JSON201.Id
 
 	collRes, err := client.GetCollectorByClientIdWithResponse(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, collRes.JSON200.ClientId)
 	assert.Equal(t, int32(0), collRes.JSON200.ActiveVersion)
 	assert.Equal(t, int32(0), collRes.JSON200.LatestVersion)
@@ -92,11 +94,11 @@ func TestCollectorService(t *testing.T) {
 		MinimumTextVersion:    &minVersion,
 		Fields:                &fields,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 200, uRes.StatusCode())
 
 	collRes, err = client.GetCollectorByClientIdWithResponse(ctx, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id, collRes.JSON200.ClientId)
 	assert.Equal(t, int32(1), collRes.JSON200.ActiveVersion)
 	assert.Equal(t, int32(1), collRes.JSON200.LatestVersion)

test/queryAPI/exportservice_test.go

@@ -7,6 +7,8 @@ import (
 	"queryorchestration/internal/test"
 	queryapi "queryorchestration/pkg/queryAPI"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -19,9 +21,9 @@ func TestExportService(t *testing.T) {
 	defer cleanup()
 
 	client, err := queryapi.NewClientWithResponses(c.URI)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	idRes, err := client.TriggerExportWithResponse(ctx, "CLIENT_ID", queryapi.ExportTrigger{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, idRes)
 }