Skip to content

Commit 62d1c1a

Browse files
davidgamerodavidgamero
committed
abort testing
1 parent 19208ce commit 62d1c1a

1 file changed

Lines changed: 173 additions & 104 deletions

File tree

  • samples/openapi3/client/petstore/typescript/tests/default/test/api

‎samples/openapi3/client/petstore/typescript/tests/default/test/api/PetApi.test.ts‎

Lines changed: 173 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -14,36 +14,66 @@ tag.id = Math.floor(Math.random() * 100000)
1414
let pet: petstore.Pet;
1515
function overridePetIDMiddleware(id: number): Middleware {
1616
return {
17-
pre: (c: RequestContext) => {
18-
return new Promise((resolve) => {
19-
const segments = c.getUrl().split('/')
20-
segments[segments.length - 1] = id.toString()
21-
const newURL = segments.join('/')
22-
c.setUrl(newURL)
23-
resolve(c)
24-
})
17+
pre: async (c: RequestContext) => {
18+
const segments = c.getUrl().split('/')
19+
segments[segments.length - 1] = id.toString()
20+
const newURL = segments.join('/')
21+
c.setUrl(newURL)
22+
return c
2523
},
26-
post: (c: ResponseContext) => {
27-
return new Promise<ResponseContext>((resolve) => {
28-
resolve(c)
29-
})
24+
post: async (c: ResponseContext) => {
25+
return c
3026
},
3127
}
3228
}
3329

34-
function NoopMiddleware(onPre: () => void, onPost: () => void): Middleware {
30+
function noopMiddleware(onPre: () => void, onPost: () => void): Middleware {
3531
return {
36-
pre: (c: RequestContext) => {
37-
return new Promise((resolve) => {
38-
onPre()
39-
resolve(c)
40-
})
32+
pre: async (c: RequestContext) => {
33+
onPre()
34+
return c
35+
},
36+
post: async (c: ResponseContext) => {
37+
onPost()
38+
return c
4139
},
42-
post: (c: ResponseContext) => {
40+
}
41+
}
42+
43+
/**
44+
* Middleware that adds an abort signal to the request context.
45+
* This can be used to abort requests using an AbortController.
46+
* @param signal AbortSignal to use for the request
47+
* @returns Middleware that sets the signal in the request context
48+
*/
49+
function abortSignalMiddleware(signal: AbortSignal): Middleware {
50+
return {
51+
pre: async (c: RequestContext) => {
52+
c.setSignal(signal)
53+
return c
54+
},
55+
post: async (c: ResponseContext) => {
56+
return c
57+
},
58+
}
59+
}
60+
61+
/**
62+
* Middleware that delays the request/response by a specified amount of time.
63+
* @param delay in milliseconds
64+
* @returns Middleware that delays the request/response
65+
*/
66+
function delayMiddleware(delay: number): Middleware {
67+
return {
68+
pre: async (c: RequestContext) => {
69+
return new Promise<RequestContext>((resolve) => {
70+
setTimeout(() => resolve(c), delay);
71+
});
72+
},
73+
post: async (c: ResponseContext) => {
4374
return new Promise<ResponseContext>((resolve) => {
44-
onPost()
45-
resolve(c)
46-
})
75+
setTimeout(() => resolve(c), delay);
76+
});
4777
},
4878
}
4979
}
@@ -52,8 +82,8 @@ function MiddlewareCallTracker() {
5282
let CallOrder = [] as string[]
5383
return {
5484
CallOrder,
55-
BaseMiddleware: NoopMiddleware(() => CallOrder.push('base-pre'), () => CallOrder.push('base-post')),
56-
CalltimeMiddleware: NoopMiddleware(() => CallOrder.push('call-pre'), () => CallOrder.push('call-post'))
85+
BaseMiddleware: noopMiddleware(() => CallOrder.push('base-pre'), () => CallOrder.push('base-post')),
86+
CalltimeMiddleware: noopMiddleware(() => CallOrder.push('call-pre'), () => CallOrder.push('call-post'))
5787
}
5888
}
5989

@@ -74,88 +104,127 @@ describe("PetApi", () => {
74104
expect(createdPet).to.deep.equal(pet);
75105
})
76106

77-
it("addPetViaMiddleware", async () => {
78-
const wrongId = pet.id + 1
79-
const createdPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(pet.id)] })
80-
expect(createdPet).to.deep.equal(pet);
81-
})
82-
83-
it("appendMiddleware petid", async () => {
84-
const wrongId = pet.id + 100
85-
const configuration = petstore.createConfiguration({ promiseMiddleware: [overridePetIDMiddleware(wrongId)] })
86-
const petApi = new petstore.PetApi(configuration)
87-
try {
88-
void await petApi.getPetById(pet.id)
89-
} catch (err) {
90-
expect(err.code).to.equal(404);
91-
expect(err.message).to.include("Pet not found");
92-
}
93-
const callTimeAppendedRightPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(pet.id)], middlewareMergeStrategy: 'append' })
94-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
95-
})
96-
97-
it("should keep middleware when no options are given", async () => {
98-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
99-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
100-
const petApi = new petstore.PetApi(configuration);
101-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id);
102-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
103-
expect(CallOrder).deep.equal(['base-pre', 'base-post'])
104-
})
105-
106-
it("should keep middleware when options are given without middleware", async () => {
107-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
108-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
109-
const petApi = new petstore.PetApi(configuration);
110-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, {});
111-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
112-
expect(CallOrder).deep.equal(['base-pre', 'base-post'])
113-
})
114-
115-
it("should replace middleware when options contain an empty array of middlewares", async () => {
116-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
117-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
118-
const petApi = new petstore.PetApi(configuration);
119-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [] });
120-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
121-
expect(CallOrder).deep.equal([])
122-
})
123-
124-
it("replace Middleware call order", async () => {
125-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
126-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
127-
const petApi = new petstore.PetApi(configuration)
128-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware] })
129-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
130-
expect(CallOrder).deep.equal(['call-pre', 'call-post'])
131-
})
132-
133-
it("prepend Middleware call order", async () => {
134-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
135-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
136-
const petApi = new petstore.PetApi(configuration)
137-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware], middlewareMergeStrategy: 'prepend' })
138-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
139-
expect(CallOrder).deep.equal(['call-pre', 'base-pre', 'base-post','call-post'])
140-
})
141-
142-
143-
it("append Middleware call order", async () => {
144-
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
145-
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
146-
const petApi = new petstore.PetApi(configuration)
147-
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware],middlewareMergeStrategy: 'append' })
148-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
149-
expect(CallOrder).deep.equal(['base-pre','call-pre','call-post','base-post'])
107+
describe("Middeware", () => {
108+
109+
it("addPetViaMiddleware", async () => {
110+
const wrongId = pet.id + 1
111+
const createdPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(pet.id)] })
112+
expect(createdPet).to.deep.equal(pet);
113+
})
114+
115+
it("appendMiddleware petid", async () => {
116+
const wrongId = pet.id + 100
117+
const configuration = petstore.createConfiguration({ promiseMiddleware: [overridePetIDMiddleware(wrongId)] })
118+
const petApi = new petstore.PetApi(configuration)
119+
try {
120+
void await petApi.getPetById(pet.id)
121+
} catch (err) {
122+
expect(err.code).to.equal(404);
123+
expect(err.message).to.include("Pet not found");
124+
}
125+
const callTimeAppendedRightPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(pet.id)], middlewareMergeStrategy: 'append' })
126+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
127+
})
128+
129+
it("should keep middleware when no options are given", async () => {
130+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
131+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
132+
const petApi = new petstore.PetApi(configuration);
133+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id);
134+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
135+
expect(CallOrder).deep.equal(['base-pre', 'base-post'])
136+
})
137+
138+
it("should keep middleware when options are given without middleware", async () => {
139+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
140+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
141+
const petApi = new petstore.PetApi(configuration);
142+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, {});
143+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
144+
expect(CallOrder).deep.equal(['base-pre', 'base-post'])
145+
})
146+
147+
it("should replace middleware when options contain an empty array of middlewares", async () => {
148+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
149+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] });
150+
const petApi = new petstore.PetApi(configuration);
151+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [] });
152+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
153+
expect(CallOrder).deep.equal([])
154+
})
155+
156+
it("replace Middleware call order", async () => {
157+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
158+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
159+
const petApi = new petstore.PetApi(configuration)
160+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware] })
161+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
162+
expect(CallOrder).deep.equal(['call-pre', 'call-post'])
163+
})
164+
165+
it("prepend Middleware call order", async () => {
166+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
167+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
168+
const petApi = new petstore.PetApi(configuration)
169+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware], middlewareMergeStrategy: 'prepend' })
170+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
171+
expect(CallOrder).deep.equal(['call-pre', 'base-pre', 'base-post', 'call-post'])
172+
})
173+
174+
175+
it("append Middleware call order", async () => {
176+
let { CallOrder, BaseMiddleware, CalltimeMiddleware } = MiddlewareCallTracker()
177+
const configuration = petstore.createConfiguration({ promiseMiddleware: [BaseMiddleware] })
178+
const petApi = new petstore.PetApi(configuration)
179+
const callTimeAppendedRightPet = await petApi.getPetById(pet.id, { middleware: [CalltimeMiddleware], middlewareMergeStrategy: 'append' })
180+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
181+
expect(CallOrder).deep.equal(['base-pre', 'call-pre', 'call-post', 'base-post'])
182+
})
183+
184+
185+
it("prependMiddleware pet id", async () => {
186+
const wrongId = pet.id + 100
187+
const configuration = petstore.createConfiguration({ promiseMiddleware: [overridePetIDMiddleware(pet.id)] })
188+
const petApi = new petstore.PetApi(configuration)
189+
const callTimeAppendedRightPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(wrongId)], middlewareMergeStrategy: 'prepend' })
190+
expect(callTimeAppendedRightPet).to.deep.equal(pet);
191+
})
150192
})
151193

152-
153-
it("prependMiddleware pet id", async () => {
154-
const wrongId = pet.id + 100
155-
const configuration = petstore.createConfiguration({ promiseMiddleware: [overridePetIDMiddleware(pet.id)] })
156-
const petApi = new petstore.PetApi(configuration)
157-
const callTimeAppendedRightPet = await petApi.getPetById(wrongId, { middleware: [overridePetIDMiddleware(wrongId)], middlewareMergeStrategy: 'prepend' })
158-
expect(callTimeAppendedRightPet).to.deep.equal(pet);
194+
describe("AbortController", () => {
195+
it("fails on invalid requests", async () => {
196+
const controller = new AbortController();
197+
const abortMiddleware = abortSignalMiddleware(controller.signal);
198+
const wrongId = pet.id + 1
199+
try {
200+
await petApi.getPetById(wrongId, { middleware: [abortMiddleware] })
201+
} catch (err) {
202+
expect(err.code).to.equal(404);
203+
}
204+
})
205+
it("succeeds on valid requests", async () => {
206+
const controller = new AbortController();
207+
const abortMiddleware = abortSignalMiddleware(controller.signal);
208+
const createdPet = await petApi.getPetById(pet.id, { middleware: [abortMiddleware] })
209+
expect(createdPet).to.deep.equal(pet);
210+
})
211+
it("aborts request", async () => {
212+
const signal = AbortSignal.timeout(10); // Set a timeout to ensure the request is aborted
213+
const abortMiddleware = abortSignalMiddleware(signal);
214+
try {
215+
await petApi.getPetById(pet.id, { middleware: [abortMiddleware, delayMiddleware(20)] })
216+
} catch (err) {
217+
expect(err.name).to.equal("AbortError");
218+
return;
219+
}
220+
throw new Error("Request was not aborted!");
221+
})
222+
it("ignores abort after response", async () => {
223+
const signal = AbortSignal.timeout(20); // Set a timeout to ensure the request is aborted
224+
const abortMiddleware = abortSignalMiddleware(signal);
225+
const createdPet = await petApi.getPetById(pet.id, { middleware: [abortMiddleware, delayMiddleware(10)] })
226+
expect(createdPet).to.deep.equal(pet);
227+
})
159228
})
160229

161230
it("should override http api from option", async () => {

0 commit comments

Comments
 (0)