fix(http): add missing enabled and order fields to HttpAssert sync

Fixed multiple bugs where enabled and order fields were not properly
handled in HttpAssert CRUD and sync operations:

- ToAPIHttpAssert converter now includes Enabled and Order fields
- HttpAssertInsert reads enabled/order from request instead of hardcoding
- HttpAssertUpdate handles enabled/order field updates
- Sync converter includes enabled/order in insert/update events
- Service Update function now persists DisplayOrder changes

Added comprehensive tests for all fixed functionality.

Author: ElecTwix

packages/server/internal/api/rhttp/rhttp_converter.go

@@ -195,22 +195,27 @@ func httpAssertSyncResponseFrom(event HttpAssertEvent) *apiv1.HttpAssertSyncResp
 
 	switch event.Type {
 	case eventTypeInsert:
-		value_ := event.HttpAssert.GetValue()
 		value = &apiv1.HttpAssertSync_ValueUnion{
 			Kind: apiv1.HttpAssertSync_ValueUnion_KIND_INSERT,
 			Insert: &apiv1.HttpAssertSyncInsert{
 				HttpAssertId: event.HttpAssert.GetHttpAssertId(),
 				HttpId:       event.HttpAssert.GetHttpId(),
-				Value:        value_,
+				Value:        event.HttpAssert.GetValue(),
+				Enabled:      event.HttpAssert.GetEnabled(),
+				Order:        event.HttpAssert.GetOrder(),
 			},
 		}
 	case eventTypeUpdate:
 		value_ := event.HttpAssert.GetValue()
+		enabled := event.HttpAssert.GetEnabled()
+		order := event.HttpAssert.GetOrder()
 		value = &apiv1.HttpAssertSync_ValueUnion{
 			Kind: apiv1.HttpAssertSync_ValueUnion_KIND_UPDATE,
 			Update: &apiv1.HttpAssertSyncUpdate{
 				HttpAssertId: event.HttpAssert.GetHttpAssertId(),
 				Value:        &value_,
+				Enabled:      &enabled,
+				Order:        &order,
 			},
 		}
 	case eventTypeDelete:

packages/server/internal/api/rhttp/rhttp_crud_assert.go

@@ -103,9 +103,9 @@ func (h *HttpServiceRPC) HttpAssertInsert(ctx context.Context, req *connect.Requ
 			ID:           assertID,
 			HttpID:       httpID,
 			Value:        item.Value,
-			Enabled:      true, // Assertions are always active
-			Description:  "",   // No description in API
-			DisplayOrder: 0,    // No order in API
+			Enabled:      item.Enabled,
+			Description:  "",
+			DisplayOrder: item.Order,
 		}
 
 		insertData = append(insertData, struct {
@@ -215,6 +215,12 @@ func (h *HttpServiceRPC) HttpAssertUpdate(ctx context.Context, req *connect.Requ
 		if item.Value != nil {
 			existingAssert.Value = *item.Value
 		}
+		if item.Enabled != nil {
+			existingAssert.Enabled = *item.Enabled
+		}
+		if item.Order != nil {
+			existingAssert.DisplayOrder = *item.Order
+		}
 	}
 
 	// Step 3: Execute updates in transaction

packages/server/internal/api/rhttp/rhttp_crud_assert_rpc_test.go

@@ -28,6 +28,8 @@ func TestHttpAssertInsert(t *testing.T) {
 				HttpAssertId: assertID.Bytes(),
 				HttpId:       httpID.Bytes(),
 				Value:        expression,
+				Enabled:      true,
+				Order:        1.5,
 			},
 		},
 	})
@@ -49,6 +51,50 @@ func TestHttpAssertInsert(t *testing.T) {
 	}
 	require.NotNil(t, found, "assert not found in collection")
 	require.Equal(t, expression, found.Value)
+	require.True(t, found.Enabled)
+	require.Equal(t, float32(1.5), found.Order)
+}
+
+func TestHttpAssertInsert_EnabledFalse(t *testing.T) {
+	t.Parallel()
+	f := newHttpFixture(t)
+	wsID := f.createWorkspace(t, "test-workspace")
+	httpID := f.createHttp(t, wsID, "test-http")
+
+	assertID := idwrap.NewNow()
+	expression := "response.status == 200"
+
+	req := connect.NewRequest(&httpv1.HttpAssertInsertRequest{
+		Items: []*httpv1.HttpAssertInsert{
+			{
+				HttpAssertId: assertID.Bytes(),
+				HttpId:       httpID.Bytes(),
+				Value:        expression,
+				Enabled:      false,
+				Order:        2.0,
+			},
+		},
+	})
+
+	_, err := f.handler.HttpAssertInsert(f.ctx, req)
+	require.NoError(t, err)
+
+	// Verify insertion via Collection
+	colReq := connect.NewRequest(&emptypb.Empty{})
+	resp, err := f.handler.HttpAssertCollection(f.ctx, colReq)
+	require.NoError(t, err)
+
+	var found *httpv1.HttpAssert
+	for _, item := range resp.Msg.Items {
+		if string(item.HttpAssertId) == string(assertID.Bytes()) {
+			found = item
+			break
+		}
+	}
+	require.NotNil(t, found, "assert not found in collection")
+	require.Equal(t, expression, found.Value)
+	require.False(t, found.Enabled, "enabled should be false")
+	require.Equal(t, float32(2.0), found.Order)
 }
 
 func TestHttpAssertInsert_Errors(t *testing.T) {
@@ -91,14 +137,15 @@ func TestHttpAssertUpdate(t *testing.T) {
 	assertID := idwrap.NewNow()
 	// Manually create assertion to control ID
 	assertion := &mhttp.HTTPAssert{
-		ID:          assertID,
-		HttpID:      httpID,
-		Value:       "response.status == 200",
-		Description: "desc",
-		Enabled:     true,
-		IsDelta:     false,
-		CreatedAt:   time.Now().Unix(),
-		UpdatedAt:   time.Now().Unix(),
+		ID:           assertID,
+		HttpID:       httpID,
+		Value:        "response.status == 200",
+		Description:  "desc",
+		Enabled:      true,
+		DisplayOrder: 1.0,
+		IsDelta:      false,
+		CreatedAt:    time.Now().Unix(),
+		UpdatedAt:    time.Now().Unix(),
 	}
 	err := f.handler.httpAssertService.Create(f.ctx, assertion)
 	require.NoError(t, err)
@@ -130,6 +177,63 @@ func TestHttpAssertUpdate(t *testing.T) {
 	}
 	require.NotNil(t, found)
 	require.Equal(t, newValue, found.Value)
+	require.True(t, found.Enabled, "enabled should remain true")
+	require.Equal(t, float32(1.0), found.Order, "order should remain unchanged")
+}
+
+func TestHttpAssertUpdate_EnabledAndOrder(t *testing.T) {
+	t.Parallel()
+	f := newHttpFixture(t)
+	wsID := f.createWorkspace(t, "test-workspace")
+	httpID := f.createHttp(t, wsID, "test-http")
+
+	assertID := idwrap.NewNow()
+	assertion := &mhttp.HTTPAssert{
+		ID:           assertID,
+		HttpID:       httpID,
+		Value:        "response.status == 200",
+		Description:  "desc",
+		Enabled:      true,
+		DisplayOrder: 1.0,
+		IsDelta:      false,
+		CreatedAt:    time.Now().Unix(),
+		UpdatedAt:    time.Now().Unix(),
+	}
+	err := f.handler.httpAssertService.Create(f.ctx, assertion)
+	require.NoError(t, err)
+
+	// Update enabled to false and order to 5.5
+	newEnabled := false
+	newOrder := float32(5.5)
+	req := connect.NewRequest(&httpv1.HttpAssertUpdateRequest{
+		Items: []*httpv1.HttpAssertUpdate{
+			{
+				HttpAssertId: assertID.Bytes(),
+				Enabled:      &newEnabled,
+				Order:        &newOrder,
+			},
+		},
+	})
+
+	_, err = f.handler.HttpAssertUpdate(f.ctx, req)
+	require.NoError(t, err)
+
+	// Verify update
+	colReq := connect.NewRequest(&emptypb.Empty{})
+	resp, err := f.handler.HttpAssertCollection(f.ctx, colReq)
+	require.NoError(t, err)
+
+	var found *httpv1.HttpAssert
+	for _, item := range resp.Msg.Items {
+		if string(item.HttpAssertId) == string(assertID.Bytes()) {
+			found = item
+			break
+		}
+	}
+	require.NotNil(t, found)
+	require.Equal(t, "response.status == 200", found.Value, "value should remain unchanged")
+	require.False(t, found.Enabled, "enabled should be updated to false")
+	require.Equal(t, float32(5.5), found.Order, "order should be updated to 5.5")
 }
 
 func TestHttpAssertUpdate_Errors(t *testing.T) {
@@ -254,3 +358,66 @@ func TestHttpAssertCollection(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, resp.Msg.Items, 3)
 }
+
+func TestHttpAssertCollection_VerifyEnabledAndOrder(t *testing.T) {
+	t.Parallel()
+	f := newHttpFixture(t)
+	wsID := f.createWorkspace(t, "test-workspace")
+	httpID := f.createHttp(t, wsID, "test-http")
+
+	assertID1 := idwrap.NewNow()
+	assertion1 := &mhttp.HTTPAssert{
+		ID:           assertID1,
+		HttpID:       httpID,
+		Value:        "response.status == 200",
+		Description:  "enabled assertion",
+		Enabled:      true,
+		DisplayOrder: 1.5,
+		IsDelta:      false,
+		CreatedAt:    time.Now().Unix(),
+		UpdatedAt:    time.Now().Unix(),
+	}
+	err := f.handler.httpAssertService.Create(f.ctx, assertion1)
+	require.NoError(t, err)
+
+	assertID2 := idwrap.NewNow()
+	assertion2 := &mhttp.HTTPAssert{
+		ID:           assertID2,
+		HttpID:       httpID,
+		Value:        "response.body.length > 0",
+		Description:  "disabled assertion",
+		Enabled:      false,
+		DisplayOrder: 2.5,
+		IsDelta:      false,
+		CreatedAt:    time.Now().Unix(),
+		UpdatedAt:    time.Now().Unix(),
+	}
+	err = f.handler.httpAssertService.Create(f.ctx, assertion2)
+	require.NoError(t, err)
+
+	colReq := connect.NewRequest(&emptypb.Empty{})
+	resp, err := f.handler.HttpAssertCollection(f.ctx, colReq)
+	require.NoError(t, err)
+	require.Len(t, resp.Msg.Items, 2)
+
+	// Find and verify first assertion
+	var found1, found2 *httpv1.HttpAssert
+	for _, item := range resp.Msg.Items {
+		if string(item.HttpAssertId) == string(assertID1.Bytes()) {
+			found1 = item
+		}
+		if string(item.HttpAssertId) == string(assertID2.Bytes()) {
+			found2 = item
+		}
+	}
+
+	require.NotNil(t, found1, "assertion 1 not found")
+	require.Equal(t, "response.status == 200", found1.Value)
+	require.True(t, found1.Enabled, "assertion 1 should be enabled")
+	require.Equal(t, float32(1.5), found1.Order, "assertion 1 order should be 1.5")
+
+	require.NotNil(t, found2, "assertion 2 not found")
+	require.Equal(t, "response.body.length > 0", found2.Value)
+	require.False(t, found2.Enabled, "assertion 2 should be disabled")
+	require.Equal(t, float32(2.5), found2.Order, "assertion 2 order should be 2.5")
+}

packages/server/internal/api/rhttp/rhttp_sync_rpc_test.go

@@ -617,7 +617,7 @@ func TestHttpAssertSync_Streaming(t *testing.T) {
 	case <-time.After(100 * time.Millisecond):
 	}
 
-	// Insert
+	// Insert with enabled and order
 	id := idwrap.NewNow()
 	val := "res.status == 200"
 
@@ -627,6 +627,8 @@ func TestHttpAssertSync_Streaming(t *testing.T) {
 				HttpAssertId: id.Bytes(),
 				HttpId:       httpID.Bytes(),
 				Value:        val,
+				Enabled:      true,
+				Order:        1.5,
 			},
 		},
 	})
@@ -637,14 +639,20 @@ func TestHttpAssertSync_Streaming(t *testing.T) {
 	v := items[0].GetValue()
 	require.Equal(t, httpv1.HttpAssertSync_ValueUnion_KIND_INSERT, v.GetKind())
 	require.Equal(t, val, v.GetInsert().GetValue())
+	require.True(t, v.GetInsert().GetEnabled(), "insert should have enabled=true")
+	require.Equal(t, float32(1.5), v.GetInsert().GetOrder(), "insert should have order=1.5")
 
-	// Update
+	// Update enabled and order
 	newVal := "res.status == 201"
+	newEnabled := false
+	newOrder := float32(2.5)
 	reqUpdate := connect.NewRequest(&httpv1.HttpAssertUpdateRequest{
 		Items: []*httpv1.HttpAssertUpdate{
 			{
 				HttpAssertId: id.Bytes(),
 				Value:        &newVal,
+				Enabled:      &newEnabled,
+				Order:        &newOrder,
 			},
 		},
 	})
@@ -655,6 +663,8 @@ func TestHttpAssertSync_Streaming(t *testing.T) {
 	v = items[0].GetValue()
 	require.Equal(t, httpv1.HttpAssertSync_ValueUnion_KIND_UPDATE, v.GetKind())
 	require.Equal(t, newVal, v.GetUpdate().GetValue())
+	require.False(t, v.GetUpdate().GetEnabled(), "update should have enabled=false")
+	require.Equal(t, float32(2.5), v.GetUpdate().GetOrder(), "update should have order=2.5")
 
 	// Delete
 	reqDelete := connect.NewRequest(&httpv1.HttpAssertDeleteRequest{

packages/server/internal/converter/converter.go

@@ -237,6 +237,8 @@ func ToAPIHttpAssert(assert mhttp.HTTPAssert) *httpv1.HttpAssert {
 		HttpAssertId: assert.ID.Bytes(),
 		HttpId:       assert.HttpID.Bytes(),
 		Value:        assert.Value,
+		Enabled:      assert.Enabled,
+		Order:        assert.DisplayOrder,
 	}
 }
 

packages/server/internal/converter/converter_test.go

@@ -394,16 +394,41 @@ func TestToAPIHttpAssert(t *testing.T) {
 	httpID := idwrap.NewNow()
 
 	assertion := mhttp.HTTPAssert{
-		ID:     assertID,
-		HttpID: httpID,
-		Value:  "status == 200",
+		ID:           assertID,
+		HttpID:       httpID,
+		Value:        "status == 200",
+		Enabled:      true,
+		DisplayOrder: 1.5,
 	}
 
 	res := ToAPIHttpAssert(assertion)
 
 	assert.Equal(t, assertID.Bytes(), res.HttpAssertId)
 	assert.Equal(t, httpID.Bytes(), res.HttpId)
 	assert.Equal(t, "status == 200", res.Value)
+	assert.True(t, res.Enabled)
+	assert.Equal(t, float32(1.5), res.Order)
+}
+
+func TestToAPIHttpAssert_DisabledWithOrder(t *testing.T) {
+	assertID := idwrap.NewNow()
+	httpID := idwrap.NewNow()
+
+	assertion := mhttp.HTTPAssert{
+		ID:           assertID,
+		HttpID:       httpID,
+		Value:        "body.length > 0",
+		Enabled:      false,
+		DisplayOrder: 2.5,
+	}
+
+	res := ToAPIHttpAssert(assertion)
+
+	assert.Equal(t, assertID.Bytes(), res.HttpAssertId)
+	assert.Equal(t, httpID.Bytes(), res.HttpId)
+	assert.Equal(t, "body.length > 0", res.Value)
+	assert.False(t, res.Enabled)
+	assert.Equal(t, float32(2.5), res.Order)
 }
 
 func TestToAPIHttpVersion(t *testing.T) {

packages/server/pkg/service/shttp/assert.go

@@ -160,7 +160,7 @@ func (s *HttpAssertService) Update(ctx context.Context, assert *mhttp.HTTPAssert
 		Value:             assert.Value,
 		Description:       assert.Description,
 		Enabled:           assert.Enabled,
-		DisplayOrder:      float64(currentAssert.DisplayOrder),
+		DisplayOrder:      float64(assert.DisplayOrder),
 		DeltaValue:        stringToNull(currentAssert.DeltaValue),
 		DeltaEnabled:      currentAssert.DeltaEnabled,
 		DeltaDescription:  stringToNull(currentAssert.DeltaDescription),