test(e2e): address assertion review feedback

Author: SantiagoDePolonia

tests/e2e/admin_test.go

@@ -322,23 +322,26 @@ func TestAdminAPI_UsageEndpoints_E2E(t *testing.T) {
 		expectedTotalTokens                      = expectedInputTokens + expectedOutputTokens
 	)
 
-	// Mock provider usage is 10 input + 20 output tokens per request, and this test sends 2 requests.
-	requestDate := time.Now().UTC()
-	today := requestDate.Format("2006-01-02")
-
 	usageFixture := setupSQLiteUsageFixture(t)
 	ts := setupE2EAdminServer(t, e2eServerOptions{
 		adminUsageReader: usageFixture.reader,
 		usageLogger:      usageFixture.logger,
 	})
 	defer ts.Close()
 
+	// Mock provider usage is 10 input + 20 output tokens per request, and this test sends 2 requests.
+	requestWindowStart := time.Now().UTC()
 	for i := 0; i < expectedRequests; i++ {
 		resp := sendJSONRequest(t, ts.URL+chatCompletionsPath, defaultChatReq("Hello usage"))
 		require.Equal(t, http.StatusOK, resp.StatusCode)
 		closeBody(resp)
 	}
 	usageFixture.flush(t)
+	requestWindowEnd := time.Now().UTC()
+	expectedDailyDates := []string{requestWindowStart.Format("2006-01-02")}
+	if endDate := requestWindowEnd.Format("2006-01-02"); endDate != expectedDailyDates[0] {
+		expectedDailyDates = append(expectedDailyDates, endDate)
+	}
 
 	t.Run("summary includes persisted usage", func(t *testing.T) {
 		resp, err := http.Get(ts.URL + "/admin/usage/summary")
@@ -369,18 +372,32 @@ func TestAdminAPI_UsageEndpoints_E2E(t *testing.T) {
 		require.NoError(t, json.Unmarshal(body, &daily))
 		require.NotEmpty(t, daily)
 
-		var todayEntry *usage.DailyUsage
+		var matchedEntries []usage.DailyUsage
 		for i := range daily {
-			if daily[i].Date == today {
-				todayEntry = &daily[i]
-				break
+			for _, expectedDate := range expectedDailyDates {
+				if daily[i].Date == expectedDate {
+					matchedEntries = append(matchedEntries, daily[i])
+					break
+				}
 			}
 		}
-		require.NotNil(t, todayEntry, "expected daily usage entry for %s", today)
-		assert.Equal(t, expectedRequests, todayEntry.Requests)
-		assert.Equal(t, expectedInputTokens, todayEntry.InputTokens)
-		assert.Equal(t, expectedOutputTokens, todayEntry.OutputTokens)
-		assert.Equal(t, expectedTotalTokens, todayEntry.TotalTokens)
+		require.NotEmpty(t, matchedEntries, "expected daily usage entry for one of %v", expectedDailyDates)
+
+		var actualRequests int
+		var actualInputTokens int64
+		var actualOutputTokens int64
+		var actualTotalTokens int64
+		for _, entry := range matchedEntries {
+			actualRequests += entry.Requests
+			actualInputTokens += entry.InputTokens
+			actualOutputTokens += entry.OutputTokens
+			actualTotalTokens += entry.TotalTokens
+		}
+
+		assert.Equal(t, expectedRequests, actualRequests)
+		assert.Equal(t, expectedInputTokens, actualInputTokens)
+		assert.Equal(t, expectedOutputTokens, actualOutputTokens)
+		assert.Equal(t, expectedTotalTokens, actualTotalTokens)
 	})
 
 	t.Run("query params accepted", func(t *testing.T) {

tests/e2e/auditlog_test.go

@@ -245,7 +245,8 @@ func TestAuditLogMiddleware(t *testing.T) {
 		msg, ok := choice0["message"].(map[string]interface{})
 		require.True(t, ok)
 		assert.Equal(t, "assistant", msg["role"])
-		content, _ := msg["content"].(string)
+		content, ok := msg["content"].(string)
+		require.True(t, ok, "message.content should be a string, got %T", msg["content"])
 		assert.Contains(t, content, "Test message", "captured response body should echo our input via the mock")
 	})
 

tests/e2e/helpers_test.go

@@ -250,11 +250,11 @@ func extractResponsesStreamContent(events []ResponsesStreamEvent) string {
 	return content.String()
 }
 
-// hasResponsesCompletedEvent checks if the stream contains the Responses API
+// hasResponsesCompletedEvent checks if the stream contains a typed Responses
 // completion event that carries the final response payload.
 func hasResponsesCompletedEvent(events []ResponsesStreamEvent) bool {
 	for _, event := range events {
-		if event.Type == "response.completed" {
+		if event.Type == "response.completed" || event.Type == "response.done" {
 			return true
 		}
 	}

tests/e2e/release-e2e-scenarios.md

@@ -136,7 +136,7 @@ assert_chat_stream_contains() {
     | jq -s -e --arg expected "$expected" '
       any(.[]; .object == "chat.completion.chunk")
       and ([.[]?.choices[]?.delta.content? // empty] | join("") | contains($expected))
-      and any(.[]; .choices[]?.finish_reason == "stop")
+      and any(.[]; (.choices[]?.finish_reason? // "") != "")
     ' >/dev/null
 }
 
@@ -151,14 +151,12 @@ assert_responses_stream_contains() {
   local file="$1"
   local expected="$2"
 
-  grep -qF 'event: response.created' "$file"
-  grep -qF 'event: response.output_text.delta' "$file"
-  grep -qF 'event: response.completed' "$file"
   grep -qF 'data: [DONE]' "$file"
   grep '^data: {' "$file" | sed 's/^data: //' \
     | jq -s -e --arg expected "$expected" '
-      ([.[] | select(.type == "response.output_text.delta") | .delta] | join("") | contains($expected))
-      and any(.[]; .type == "response.completed" and ((.response.usage.total_tokens // 0) > 0))
+      any(.[]; .type == "response.created")
+      and ([.[] | select(.type == "response.output_text.delta") | .delta] | join("") | contains($expected))
+      and any(.[]; (.type == "response.completed" or .type == "response.done") and ((.response.usage.total_tokens // .usage.total_tokens // 0) > 0))
     ' >/dev/null
 }
 

tests/e2e/responses_test.go

@@ -173,7 +173,7 @@ func TestResponsesStreaming(t *testing.T) {
 
 		events := readResponsesStream(t, resp.Body)
 		require.Greater(t, len(events), 0)
-		assert.True(t, hasResponsesCompletedEvent(events), "Should receive response.completed event")
+		assert.True(t, hasResponsesCompletedEvent(events), "Should receive response.completed or response.done event")
 		assert.True(t, hasResponsesDoneMarker(events), "Should receive [DONE] marker")
 	})
 
@@ -197,7 +197,7 @@ func TestResponsesStreaming(t *testing.T) {
 
 		events := readResponsesStream(t, resp.Body)
 		require.Greater(t, len(events), 0, "Should receive at least one SSE event")
-		assert.True(t, hasResponsesCompletedEvent(events), "Should receive response.completed event")
+		assert.True(t, hasResponsesCompletedEvent(events), "Should receive response.completed or response.done event")
 		assert.True(t, hasResponsesDoneMarker(events), "Should receive [DONE] marker")
 
 		recorded := requireRecordedRequest(t, "/responses")