chore: more linting fix

Author: adityachoudhari26

apps/workspace-engine/pkg/db/changeset.go

@@ -27,7 +27,7 @@ func FlushChangeset(ctx context.Context, cs *changeset.ChangeSet) error {
 	if err != nil {
 		return err
 	}
-	defer tx.Rollback(ctx)
+	defer func() { _ = tx.Rollback(ctx) }()
 
 	for _, change := range cs.Changes {
 		if err := applyChange(ctx, tx, change); err != nil {

apps/workspace-engine/pkg/db/relationships.go

@@ -245,9 +245,11 @@ func convertDbRelationshipRuleToOapiRelationshipRule(dbRelationship *dbRelations
 	name := getName(dbRelationship)
 
 	matcher := &oapi.RelationshipRule_Matcher{}
-	matcher.FromPropertiesMatcher(oapi.PropertiesMatcher{
+	if err := matcher.FromPropertiesMatcher(oapi.PropertiesMatcher{
 		Properties: propertyMatchers,
-	})
+	}); err != nil {
+		return nil, err
+	}
 	return &oapi.RelationshipRule{
 		Id:               dbRelationship.ID,
 		Name:             name,

apps/workspace-engine/pkg/memsql/memsql_test.go

@@ -1177,7 +1177,9 @@ func TestMemSQL_CRUD_Integration(t *testing.T) {
 	}
 
 	// Update (via delete and re-insert)
-	memSQL.DeleteOne("ID = ?", "2")
+	if err := memSQL.DeleteOne("ID = ?", "2"); err != nil {
+		t.Fatalf("DeleteOne failed: %v", err)
+	}
 	if err := memSQL.Insert(User{ID: "2", Name: "Bob Updated", Email: "[email protected]", Age: 26}); err != nil {
 		t.Fatalf("Insert failed: %v", err)
 	}
@@ -1558,7 +1560,9 @@ func TestMemSQL_StructPB_Update(t *testing.T) {
 		Name:   "Test Agent",
 		Config: config1,
 	}
-	memSQL.Insert(agent)
+	if err := memSQL.Insert(agent); err != nil {
+		t.Fatalf("Insert failed: %v", err)
+	}
 
 	// Update with new config (delete and re-insert)
 	config2, _ := structpb.NewStruct(map[string]interface{}{
@@ -1567,9 +1571,13 @@ func TestMemSQL_StructPB_Update(t *testing.T) {
 		"newField": "value",
 	})
 
-	memSQL.DeleteOne("id = ?", "agent1")
+	if err := memSQL.DeleteOne("id = ?", "agent1"); err != nil {
+		t.Fatalf("DeleteOne failed: %v", err)
+	}
 	agent.Config = config2
-	memSQL.Insert(agent)
+	if err := memSQL.Insert(agent); err != nil {
+		t.Fatalf("Insert failed: %v", err)
+	}
 
 	// Query back
 	agents, _ := memSQL.Query("SELECT * FROM job_agents WHERE id = ?", "agent1")
@@ -1610,10 +1618,12 @@ func TestMemSQL_StructPB_Delete(t *testing.T) {
 	config1, _ := structpb.NewStruct(map[string]interface{}{"type": "k8s"})
 	config2, _ := structpb.NewStruct(map[string]interface{}{"type": "docker"})
 
-	memSQL.InsertMany([]JobAgent{
+	if err := memSQL.InsertMany([]JobAgent{
 		{ID: "agent1", Name: "Agent 1", Config: config1},
 		{ID: "agent2", Name: "Agent 2", Config: config2},
-	})
+	}); err != nil {
+		t.Fatalf("InsertMany failed: %v", err)
+	}
 
 	// Delete one
 	rowsAffected, err := memSQL.Delete("id = ?", "agent1")
@@ -1655,10 +1665,12 @@ func TestMemSQL_StructPB_QueryWithWhere(t *testing.T) {
 	config1, _ := structpb.NewStruct(map[string]interface{}{"enabled": true})
 	config2, _ := structpb.NewStruct(map[string]interface{}{"enabled": false})
 
-	memSQL.InsertMany([]JobAgent{
+	if err := memSQL.InsertMany([]JobAgent{
 		{ID: "agent1", Name: "Active Agent", Config: config1},
 		{ID: "agent2", Name: "Inactive Agent", Config: config2},
-	})
+	}); err != nil {
+		t.Fatalf("InsertMany failed: %v", err)
+	}
 
 	// Query specific agent with exact match
 	agents, err := memSQL.Query("SELECT * FROM job_agents_query WHERE name = ?", "Active Agent")
@@ -1692,15 +1704,13 @@ func TestMemSQL_Insert_Upsert(t *testing.T) {
 
 	// Insert initial record
 	user1 := User{ID: "1", Name: "Alice", Email: "[email protected]", Age: 30}
-	err := memSQL.Insert(user1)
-	if err != nil {
+	if err := memSQL.Insert(user1); err != nil {
 		t.Fatalf("First insert failed: %v", err)
 	}
 
 	// Insert again with same ID (should update)
 	user2 := User{ID: "1", Name: "Alice Updated", Email: "[email protected]", Age: 31}
-	err = memSQL.Insert(user2)
-	if err != nil {
+	if err := memSQL.Insert(user2); err != nil {
 		t.Fatalf("Second insert (upsert) failed: %v", err)
 	}
 
@@ -1880,15 +1890,19 @@ func TestMemSQL_Insert_Upsert_WithStructPB(t *testing.T) {
 		"enabled": true,
 	})
 	agent1 := JobAgent{ID: "agent1", Name: "Test Agent", Config: config1}
-	memSQL.Insert(agent1)
+	if err := memSQL.Insert(agent1); err != nil {
+		t.Fatalf("First insert failed: %v", err)
+	}
 
 	// Upsert with new config
 	config2, _ := structpb.NewStruct(map[string]interface{}{
 		"version": "2.0.0",
 		"enabled": false,
 	})
 	agent2 := JobAgent{ID: "agent1", Name: "Test Agent Updated", Config: config2}
-	memSQL.Insert(agent2)
+	if err := memSQL.Insert(agent2); err != nil {
+		t.Fatalf("Second insert (upsert) failed: %v", err)
+	}
 
 	// Verify was updated
 	agents, _ := memSQL.Query("SELECT * FROM job_agents_upsert WHERE id = ?", "agent1")
@@ -1920,19 +1934,23 @@ func TestMemSQL_InsertMany_Upsert_Mixed(t *testing.T) {
 	memSQL := NewMemSQL[User](tableBuilder)
 
 	// Insert 3 users initially
-	memSQL.InsertMany([]User{
+	if err := memSQL.InsertMany([]User{
 		{ID: "1", Name: "Alice", Email: "[email protected]", Age: 30},
 		{ID: "2", Name: "Bob", Email: "[email protected]", Age: 25},
 		{ID: "3", Name: "Charlie", Email: "[email protected]", Age: 35},
-	})
+	}); err != nil {
+		t.Fatalf("InsertMany failed: %v", err)
+	}
 
 	// Upsert: update 2, insert 2 new
-	memSQL.InsertMany([]User{
+	if err := memSQL.InsertMany([]User{
 		{ID: "1", Name: "Alice Updated", Email: "[email protected]", Age: 31},
 		{ID: "3", Name: "Charlie Updated", Email: "[email protected]", Age: 36},
 		{ID: "4", Name: "David", Email: "[email protected]", Age: 40},
 		{ID: "5", Name: "Eve", Email: "[email protected]", Age: 28},
-	})
+	}); err != nil {
+		t.Fatalf("InsertMany failed: %v", err)
+	}
 
 	// Verify we have 5 users
 	users, _ := memSQL.Query("SELECT * FROM users ORDER BY ID")
@@ -1974,11 +1992,13 @@ func TestMemSQL_PointerType_Query(t *testing.T) {
 	memSQL := NewMemSQL[*User](tableBuilder)
 
 	// Insert test data using raw SQL
-	memSQL.DB().Exec(`
+	if _, err := memSQL.DB().Exec(`
 		INSERT INTO users (ID, Name, Email, Age) VALUES 
 		('1', 'Alice', '[email protected]', 30),
 		('2', 'Bob', '[email protected]', 25)
-	`)
+	`); err != nil {
+		t.Fatalf("Failed to insert test data: %v", err)
+	}
 
 	// Query should work with pointer type
 	users, err := memSQL.Query("SELECT * FROM users ORDER BY ID")
@@ -2081,14 +2101,21 @@ func TestMemSQL_PointerType_Upsert(t *testing.T) {
 
 	// Initial insert
 	user1 := &User{ID: "1", Name: "Alice", Email: "[email protected]", Age: 30}
-	memSQL.Insert(user1)
+	if err := memSQL.Insert(user1); err != nil {
+		t.Fatalf("Insert failed: %v", err)
+	}
 
 	// Upsert
 	user2 := &User{ID: "1", Name: "Alice Updated", Email: "[email protected]", Age: 31}
-	memSQL.Insert(user2)
+	if err := memSQL.Insert(user2); err != nil {
+		t.Fatalf("Insert failed: %v", err)
+	}
 
 	// Verify update
-	users, _ := memSQL.Query("SELECT * FROM users WHERE ID = ?", "1")
+	users, err := memSQL.Query("SELECT * FROM users WHERE ID = ?", "1")
+	if err != nil {
+		t.Fatalf("Query failed: %v", err)
+	}
 	if len(users) != 1 {
 		t.Fatalf("Expected 1 user, got %d", len(users))
 	}
@@ -2127,7 +2154,10 @@ func TestMemSQL_PointerType_WithTimestamp(t *testing.T) {
 	}
 
 	// Query back
-	events, _ := memSQL.Query("SELECT * FROM events WHERE id = ?", "e1")
+	events, err := memSQL.Query("SELECT * FROM events WHERE id = ?", "e1")
+	if err != nil {
+		t.Fatalf("Query failed: %v", err)
+	}
 	if len(events) != 1 {
 		t.Fatalf("Expected 1 event, got %d", len(events))
 	}
@@ -2171,7 +2201,10 @@ func TestMemSQL_PointerType_WithStructPB(t *testing.T) {
 	}
 
 	// Query back
-	agents, _ := memSQL.Query("SELECT * FROM job_agents_ptr WHERE id = ?", "agent1")
+	agents, err := memSQL.Query("SELECT * FROM job_agents_ptr WHERE id = ?", "agent1")
+	if err != nil {
+		t.Fatalf("Query failed: %v", err)
+	}
 	if len(agents) != 1 {
 		t.Fatalf("Expected 1 agent, got %d", len(agents))
 	}
@@ -2229,7 +2262,10 @@ func TestMemSQL_PointerType_InsertManyWithNil(t *testing.T) {
 	}
 
 	// Verify only 2 users inserted (nil was skipped)
-	result, _ := memSQL.Query("SELECT * FROM users ORDER BY ID")
+	result, err := memSQL.Query("SELECT * FROM users ORDER BY ID")
+	if err != nil {
+		t.Fatalf("Query failed: %v", err)
+	}
 	if len(result) != 2 {
 		t.Fatalf("Expected 2 users, got %d", len(result))
 	}

apps/workspace-engine/pkg/selector/resources_test.go

@@ -25,7 +25,9 @@ func conditionToSelector(t *testing.T, condition unknown.UnknownCondition) *oapi
 	}
 
 	v := &oapi.Selector{}
-	v.FromJsonSelector(oapi.JsonSelector{Json: conditionMap})
+	if err := v.FromJsonSelector(oapi.JsonSelector{Json: conditionMap}); err != nil {
+		t.Fatalf("Failed to create JSON selector: %v", err)
+	}
 	return v
 }
 

apps/workspace-engine/pkg/workspace/releasemanager/policymanager/evaluator/skipdeployed/skipdeployed_test.go

@@ -63,7 +63,9 @@ func TestSkipDeployedEvaluator_PreviousDeploymentFailed(t *testing.T) {
 
 	// Create failed job with completion time
 	completedAt := time.Now()
-	st.Releases.Upsert(ctx, previousRelease)
+	if err := st.Releases.Upsert(ctx, previousRelease); err != nil {
+		t.Fatalf("Failed to upsert previous release: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:          "job-1",
 		ReleaseId:   previousRelease.ID(),
@@ -116,7 +118,9 @@ func TestSkipDeployedEvaluator_AlreadyDeployed(t *testing.T) {
 
 	// Create successful job with completion time
 	completedAt := time.Now()
-	st.Releases.Upsert(ctx, deployedRelease)
+	if err := st.Releases.Upsert(ctx, deployedRelease); err != nil {
+		t.Fatalf("Failed to upsert deployed release: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:          "job-1",
 		ReleaseId:   deployedRelease.ID(),
@@ -173,7 +177,9 @@ func TestSkipDeployedEvaluator_NewVersionAfterSuccessful(t *testing.T) {
 	}
 
 	completedAt := time.Now().Add(-1 * time.Hour)
-	st.Releases.Upsert(ctx, v1Release)
+	if err := st.Releases.Upsert(ctx, v1Release); err != nil {
+		t.Fatalf("Failed to upsert v1 release: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:          "job-v1",
 		ReleaseId:   v1Release.ID(),
@@ -190,7 +196,9 @@ func TestSkipDeployedEvaluator_NewVersionAfterSuccessful(t *testing.T) {
 			Tag: "v2.0.0",
 		},
 	}
-	st.Releases.Upsert(ctx, v2Release)
+	if err := st.Releases.Upsert(ctx, v2Release); err != nil {
+		t.Fatalf("Failed to upsert v2 release: %v", err)
+	}
 
 	evaluator := NewSkipDeployedEvaluator(st)
 
@@ -231,7 +239,9 @@ func TestSkipDeployedEvaluator_JobInProgressNotSuccessful(t *testing.T) {
 	}
 
 	// Create in-progress job
-	st.Releases.Upsert(ctx, release)
+	if err := st.Releases.Upsert(ctx, release); err != nil {
+		t.Fatalf("Failed to upsert release: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:        "job-1",
 		ReleaseId: release.ID(),
@@ -283,7 +293,9 @@ func TestSkipDeployedEvaluator_CancelledJobDeniesRedeploy(t *testing.T) {
 
 	// Create cancelled job with completion time
 	completedAt := time.Now()
-	st.Releases.Upsert(ctx, release)
+	if err := st.Releases.Upsert(ctx, release); err != nil {
+		t.Fatalf("Failed to upsert release: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:          "job-1",
 		ReleaseId:   release.ID(),
@@ -327,7 +339,9 @@ func TestSkipDeployedEvaluator_VariableChangeCreatesNewRelease(t *testing.T) {
 	}
 
 	replicas := oapi.LiteralValue{}
-	replicas.FromIntegerValue(3)
+	if err := replicas.FromIntegerValue(3); err != nil {
+		t.Fatalf("Failed to create replicas: %v", err)
+	}
 
 	release1 := &oapi.Release{
 		ReleaseTarget: *releaseTarget,
@@ -341,7 +355,9 @@ func TestSkipDeployedEvaluator_VariableChangeCreatesNewRelease(t *testing.T) {
 	}
 
 	completedAt := time.Now()
-	st.Releases.Upsert(ctx, release1)
+	if err := st.Releases.Upsert(ctx, release1); err != nil {
+		t.Fatalf("Failed to upsert release1: %v", err)
+	}
 	st.Jobs.Upsert(ctx, &oapi.Job{
 		Id:          "job-1",
 		ReleaseId:   release1.ID(),
@@ -352,7 +368,9 @@ func TestSkipDeployedEvaluator_VariableChangeCreatesNewRelease(t *testing.T) {
 
 	// Deploy same version with different variables: {replicas: 5}
 	replicas2 := oapi.LiteralValue{}
-	replicas2.FromIntegerValue(5)
+	if err := replicas2.FromIntegerValue(5); err != nil {
+		t.Fatalf("Failed to create replicas2: %v", err)
+	}
 
 	release2 := &oapi.Release{
 		ReleaseTarget: *releaseTarget,
@@ -364,7 +382,9 @@ func TestSkipDeployedEvaluator_VariableChangeCreatesNewRelease(t *testing.T) {
 			"replicas": replicas2, // Different value!
 		},
 	}
-	st.Releases.Upsert(ctx, release2)
+	if err := st.Releases.Upsert(ctx, release2); err != nil {
+		t.Fatalf("Failed to upsert release2: %v", err)
+	}
 
 	evaluator := NewSkipDeployedEvaluator(st)