Skip to content

Commit 007a4bd

Browse files
committed
test(openai-native): expand service tier coverage
1 parent aac9e97 commit 007a4bd

1 file changed

Lines changed: 163 additions & 135 deletions

File tree

‎src/api/providers/__tests__/openai-native.spec.ts‎

Lines changed: 163 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ vitest.mock("@roo-code/telemetry", () => ({
1313
import { Anthropic } from "@anthropic-ai/sdk"
1414
import OpenAI from "openai"
1515

16-
import { ApiProviderError, OpenAiServiceTier, SERVICE_TIER_KEY } from "@roo-code/types"
16+
import { ApiProviderError, OpenAiServiceTier, SERVICE_TIER_KEY, serviceTiers } from "@roo-code/types"
1717

1818
import { OpenAiNativeHandler } from "../openai-native"
1919
import { ApiHandlerOptions } from "../../../shared/api"
@@ -22,6 +22,24 @@ import { Package } from "../../../shared/package"
2222
// Mock OpenAI client - now everything uses Responses API
2323
const mockResponsesCreate = vitest.fn()
2424

25+
const serviceTierPricingCases = [
26+
{
27+
requestedTier: OpenAiServiceTier.Default,
28+
resolvedTier: OpenAiServiceTier.Priority,
29+
expectedCost: 0.00275,
30+
},
31+
{
32+
requestedTier: OpenAiServiceTier.Priority,
33+
resolvedTier: OpenAiServiceTier.Flex,
34+
expectedCost: 0.00055,
35+
},
36+
{
37+
requestedTier: OpenAiServiceTier.Flex,
38+
resolvedTier: OpenAiServiceTier.Default,
39+
expectedCost: 0.0011,
40+
},
41+
]
42+
2543
vitest.mock("openai", () => {
2644
return {
2745
__esModule: true,
@@ -122,142 +140,155 @@ describe("OpenAiNativeHandler", () => {
122140
})
123141

124142
describe("createMessage", () => {
125-
it.each([OpenAiServiceTier.Default, OpenAiServiceTier.Flex, OpenAiServiceTier.Priority])(
126-
"should include the selected %s service tier",
127-
async (serviceTier) => {
143+
it.each(serviceTiers)("should include the selected %s service tier", async (serviceTier) => {
144+
mockResponsesCreate.mockResolvedValue({
145+
async *[Symbol.asyncIterator]() {},
146+
})
147+
handler = new OpenAiNativeHandler({
148+
...mockOptions,
149+
apiModelId: "gpt-5.6-sol",
150+
openAiNativeServiceTier: serviceTier,
151+
})
152+
153+
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
154+
void chunk
155+
}
156+
157+
expect(mockResponsesCreate).toHaveBeenCalledWith(
158+
expect.objectContaining({ [SERVICE_TIER_KEY]: serviceTier }),
159+
expect.any(Object),
160+
)
161+
})
162+
163+
it.each(serviceTierPricingCases)(
164+
"prices SDK stream usage using resolved $resolvedTier tier instead of requested $requestedTier tier",
165+
async ({ requestedTier, resolvedTier, expectedCost }) => {
128166
mockResponsesCreate.mockResolvedValue({
129-
async *[Symbol.asyncIterator]() {},
167+
async *[Symbol.asyncIterator]() {
168+
yield {
169+
type: "response.done",
170+
response: {
171+
[SERVICE_TIER_KEY]: resolvedTier,
172+
usage: { input_tokens: 100, output_tokens: 20 },
173+
},
174+
}
175+
},
130176
})
131177
handler = new OpenAiNativeHandler({
132178
...mockOptions,
133179
apiModelId: "gpt-5.6-sol",
134-
openAiNativeServiceTier: serviceTier,
180+
openAiNativeServiceTier: requestedTier,
135181
})
136182

183+
const chunks = []
137184
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
138-
void chunk
185+
chunks.push(chunk)
139186
}
140187

141-
expect(mockResponsesCreate).toHaveBeenCalledWith(
142-
expect.objectContaining({ [SERVICE_TIER_KEY]: serviceTier }),
143-
expect.any(Object),
188+
expect(chunks).toContainEqual(
189+
expect.objectContaining({
190+
type: "usage",
191+
inputTokens: 100,
192+
outputTokens: 20,
193+
totalCost: expectedCost,
194+
}),
144195
)
145196
},
146197
)
147198

148-
it("prices SDK stream usage using the service tier resolved by OpenAI", async () => {
149-
mockResponsesCreate.mockResolvedValue({
150-
async *[Symbol.asyncIterator]() {
151-
yield {
152-
type: "response.done",
153-
response: {
154-
[SERVICE_TIER_KEY]: OpenAiServiceTier.Priority,
155-
usage: { input_tokens: 100, output_tokens: 20 },
199+
it.each(serviceTierPricingCases)(
200+
"requests $requestedTier but prices manual SSE fallback usage using OpenAI's resolved $resolvedTier tier",
201+
async ({ requestedTier, resolvedTier, expectedCost }) => {
202+
mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
203+
const mockFetch = vitest.fn().mockResolvedValue({
204+
ok: true,
205+
body: new ReadableStream({
206+
start(controller) {
207+
controller.enqueue(
208+
new TextEncoder().encode(
209+
`data: ${JSON.stringify({
210+
type: "response.done",
211+
response: {
212+
[SERVICE_TIER_KEY]: resolvedTier,
213+
usage: { input_tokens: 100, output_tokens: 20 },
214+
},
215+
})}\n\n`,
216+
),
217+
)
218+
controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
219+
controller.close()
156220
},
157-
}
158-
},
159-
})
160-
handler = new OpenAiNativeHandler({
161-
...mockOptions,
162-
apiModelId: "gpt-5.6-sol",
163-
openAiNativeServiceTier: OpenAiServiceTier.Default,
164-
})
221+
}),
222+
})
223+
global.fetch = mockFetch as typeof fetch
224+
handler = new OpenAiNativeHandler({
225+
...mockOptions,
226+
apiModelId: "gpt-5.6-sol",
227+
openAiNativeServiceTier: requestedTier,
228+
})
165229

166-
const chunks = []
167-
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
168-
chunks.push(chunk)
169-
}
230+
const chunks = []
231+
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
232+
chunks.push(chunk)
233+
}
170234

171-
expect(chunks).toContainEqual(
172-
expect.objectContaining({
173-
type: "usage",
174-
inputTokens: 100,
175-
outputTokens: 20,
176-
totalCost: 0.00275,
177-
}),
178-
)
179-
})
235+
const [, request] = mockFetch.mock.calls[0]
236+
expect(JSON.parse(request.body)).toMatchObject({ [SERVICE_TIER_KEY]: requestedTier })
237+
expect(chunks).toContainEqual(expect.objectContaining({ type: "usage", totalCost: expectedCost }))
238+
},
239+
)
180240

181-
it("requests the configured tier but prices manual SSE fallback usage using OpenAI's resolved tier", async () => {
182-
mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
183-
const mockFetch = vitest.fn().mockResolvedValue({
184-
ok: true,
185-
body: new ReadableStream({
186-
start(controller) {
187-
controller.enqueue(
188-
new TextEncoder().encode(
189-
`data: ${JSON.stringify({
190-
type: "response.done",
191-
response: {
192-
[SERVICE_TIER_KEY]: OpenAiServiceTier.Priority,
241+
it.each(serviceTierPricingCases)(
242+
"captures resolved $resolvedTier tier from a manual SSE completion event when $requestedTier was requested",
243+
async ({ requestedTier, resolvedTier, expectedCost }) => {
244+
mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
245+
const mockFetch = vitest.fn().mockResolvedValue({
246+
ok: true,
247+
body: new ReadableStream({
248+
start(controller) {
249+
controller.enqueue(
250+
new TextEncoder().encode(
251+
`data: ${JSON.stringify({
252+
type: "response.completed",
253+
response: { [SERVICE_TIER_KEY]: resolvedTier },
254+
})}\n\n`,
255+
),
256+
)
257+
controller.enqueue(
258+
new TextEncoder().encode(
259+
`data: ${JSON.stringify({
260+
type: "response.usage",
193261
usage: { input_tokens: 100, output_tokens: 20 },
194-
},
195-
})}\n\n`,
196-
),
197-
)
198-
controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
199-
controller.close()
200-
},
201-
}),
202-
})
203-
global.fetch = mockFetch as typeof fetch
204-
handler = new OpenAiNativeHandler({
205-
...mockOptions,
206-
apiModelId: "gpt-5.6-sol",
207-
openAiNativeServiceTier: OpenAiServiceTier.Default,
208-
})
209-
210-
const chunks = []
211-
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
212-
chunks.push(chunk)
213-
}
214-
215-
const [, request] = mockFetch.mock.calls[0]
216-
expect(JSON.parse(request.body)).toMatchObject({ [SERVICE_TIER_KEY]: OpenAiServiceTier.Default })
217-
expect(chunks).toContainEqual(expect.objectContaining({ type: "usage", totalCost: 0.00275 }))
218-
})
219-
220-
it("captures the resolved tier from a manual SSE completion event", async () => {
221-
mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
222-
const mockFetch = vitest.fn().mockResolvedValue({
223-
ok: true,
224-
body: new ReadableStream({
225-
start(controller) {
226-
controller.enqueue(
227-
new TextEncoder().encode(
228-
`data: ${JSON.stringify({
229-
type: "response.completed",
230-
response: { [SERVICE_TIER_KEY]: OpenAiServiceTier.Priority },
231-
})}\n\n`,
232-
),
233-
)
234-
controller.enqueue(
235-
new TextEncoder().encode(
236-
`data: ${JSON.stringify({
237-
type: "response.usage",
238-
usage: { input_tokens: 100, output_tokens: 20 },
239-
})}\n\n`,
240-
),
241-
)
242-
controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
243-
controller.close()
244-
},
245-
}),
246-
})
247-
global.fetch = mockFetch as typeof fetch
248-
handler = new OpenAiNativeHandler({
249-
...mockOptions,
250-
apiModelId: "gpt-5.6-sol",
251-
openAiNativeServiceTier: OpenAiServiceTier.Default,
252-
})
262+
})}\n\n`,
263+
),
264+
)
265+
controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
266+
controller.close()
267+
},
268+
}),
269+
})
270+
global.fetch = mockFetch as typeof fetch
271+
handler = new OpenAiNativeHandler({
272+
...mockOptions,
273+
apiModelId: "gpt-5.6-sol",
274+
openAiNativeServiceTier: requestedTier,
275+
})
253276

254-
const chunks = []
255-
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
256-
chunks.push(chunk)
257-
}
277+
const chunks = []
278+
for await (const chunk of handler.createMessage(systemPrompt, messages)) {
279+
chunks.push(chunk)
280+
}
258281

259-
expect(chunks).toContainEqual(expect.objectContaining({ type: "usage", totalCost: 0.00275 }))
260-
})
282+
expect(chunks).toContainEqual(
283+
expect.objectContaining({
284+
type: "usage",
285+
inputTokens: 100,
286+
outputTokens: 20,
287+
totalCost: expectedCost,
288+
}),
289+
)
290+
},
291+
)
261292

262293
it("should handle streaming responses via Responses API", async () => {
263294
// Mock fetch for Responses API fallback
@@ -358,27 +389,24 @@ describe("OpenAiNativeHandler", () => {
358389
)
359390
})
360391

361-
it.each([OpenAiServiceTier.Default, OpenAiServiceTier.Flex, OpenAiServiceTier.Priority])(
362-
"should include the selected %s service tier",
363-
async (serviceTier) => {
364-
mockResponsesCreate.mockResolvedValue({ output: [] })
365-
handler = new OpenAiNativeHandler({
366-
...mockOptions,
367-
apiModelId: "gpt-5.6-sol",
368-
openAiNativeServiceTier: serviceTier,
369-
})
392+
it.each(serviceTiers)("should include the selected %s service tier", async (serviceTier) => {
393+
mockResponsesCreate.mockResolvedValue({ output: [] })
394+
handler = new OpenAiNativeHandler({
395+
...mockOptions,
396+
apiModelId: "gpt-5.6-sol",
397+
openAiNativeServiceTier: serviceTier,
398+
})
370399

371-
await handler.completePrompt("Test prompt")
400+
await handler.completePrompt("Test prompt")
372401

373-
expect(mockResponsesCreate).toHaveBeenCalledWith(
374-
expect.objectContaining({
375-
stream: false,
376-
[SERVICE_TIER_KEY]: serviceTier,
377-
}),
378-
expect.any(Object),
379-
)
380-
},
381-
)
402+
expect(mockResponsesCreate).toHaveBeenCalledWith(
403+
expect.objectContaining({
404+
stream: false,
405+
[SERVICE_TIER_KEY]: serviceTier,
406+
}),
407+
expect.any(Object),
408+
)
409+
})
382410

383411
it("should omit the service tier when none is configured", async () => {
384412
mockResponsesCreate.mockResolvedValue({ output: [] })

0 commit comments

Comments
 (0)