Skip to content

Commit 9a252ca

Browse files
timfishtimfish
committed
Fix linting
1 parent 26e5b0c commit 9a252ca

File tree

2 files changed

+179
-177
lines changed

2 files changed

+179
-177
lines changed

‎packages/core/src/transports/offline.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ const MAX_DELAY = 2_000_000_000;
66
const DEFAULT_QUEUE_SIZE = 30;
77

88
function wasRateLimited(result: TransportMakeRequestResponse): boolean {
9-
return !!(result.headers && 'x-sentry-rate-limits' in result.headers && result.headers['x-sentry-rate-limits']);
9+
return !!(result.headers && result.headers['x-sentry-rate-limits']);
1010
}
1111

1212
type BeforeSendResponse = 'send' | 'queue' | 'drop';
@@ -58,7 +58,7 @@ export function makeOfflineTransport<TO>(
5858
createTransport: (options: TO) => Transport,
5959
createStore: CreateOfflineStore,
6060
): (options: TO & OfflineTransportOptions) => Transport {
61-
return (options: TO & OfflineTransportOptions) => {
61+
return options => {
6262
const baseTransport = createTransport(options);
6363
const maxQueueSize = options.maxQueueSize === undefined ? DEFAULT_QUEUE_SIZE : options.maxQueueSize;
6464
const store = createStore(maxQueueSize);

‎packages/core/test/lib/transports/offline.test.ts‎

Lines changed: 177 additions & 175 deletions
Original file line numberDiff line numberDiff line change
@@ -1,175 +1,177 @@
1-
import type {
2-
EventEnvelope,
3-
EventItem,
4-
TransportMakeRequestResponse,
5-
Envelope,
6-
Transport,
7-
InternalBaseTransportOptions,
8-
} from '@sentry/types';
9-
import { createEnvelope } from '@sentry/utils';
10-
import { TextEncoder } from 'util';
11-
12-
import { makeOfflineTransport, createTransport } from '../../../src';
13-
import { CreateOfflineStore, START_DELAY } from '../../../src/transports/offline';
14-
15-
const ERROR_ENVELOPE = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' }, [
16-
[{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
17-
]);
18-
19-
const transportOptions = {
20-
recordDroppedEvent: () => undefined, // noop
21-
textEncoder: new TextEncoder(),
22-
};
23-
24-
type MockResult<T> = T | Error;
25-
26-
const createTestTransport = (
27-
...sendResults: MockResult<TransportMakeRequestResponse>[]
28-
): { getSendCount: () => number; baseTransport: (options: InternalBaseTransportOptions) => Transport } => {
29-
let sendCount = 0;
30-
31-
return {
32-
getSendCount: () => sendCount,
33-
baseTransport: (options: InternalBaseTransportOptions) =>
34-
createTransport(options, () => {
35-
return new Promise((resolve, reject) => {
36-
const next = sendResults.shift();
37-
38-
if (next instanceof Error) {
39-
reject(next);
40-
} else {
41-
sendCount += 1;
42-
resolve(next as TransportMakeRequestResponse | undefined);
43-
}
44-
});
45-
}),
46-
};
47-
};
48-
49-
type StoreEvents = ('add' | 'pop')[];
50-
51-
function createTestStore(...popResults: MockResult<Envelope | undefined>[]): {
52-
getCalls: () => StoreEvents;
53-
store: CreateOfflineStore;
54-
} {
55-
const calls: StoreEvents = [];
56-
57-
return {
58-
getCalls: () => calls,
59-
store: (maxQueueCount: number) => ({
60-
insert: async env => {
61-
if (popResults.length < maxQueueCount) {
62-
popResults.push(env);
63-
calls.push('add');
64-
}
65-
},
66-
pop: async () => {
67-
calls.push('pop');
68-
const next = popResults.shift();
69-
70-
if (next instanceof Error) {
71-
throw next;
72-
}
73-
74-
return next;
75-
},
76-
}),
77-
};
78-
}
79-
80-
function delay(ms: number): Promise<void> {
81-
return new Promise(resolve => setTimeout(resolve, ms));
82-
}
83-
84-
describe('makeOfflineTransport', () => {
85-
it('Sends envelope and checks the store for further envelopes', async () => {
86-
expect.assertions(3);
87-
88-
const { getCalls, store } = createTestStore();
89-
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 });
90-
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
91-
const result = await transport.send(ERROR_ENVELOPE);
92-
93-
expect(result).toEqual({ statusCode: 200 });
94-
expect(getSendCount()).toEqual(1);
95-
// After a successful send, the store should be checked
96-
expect(getCalls()).toEqual(['pop']);
97-
});
98-
99-
it('After successfully sending, sends further envelopes found in the store', async () => {
100-
const { getCalls, store } = createTestStore(ERROR_ENVELOPE);
101-
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
102-
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
103-
const result = await transport.send(ERROR_ENVELOPE);
104-
105-
expect(result).toEqual({ statusCode: 200 });
106-
107-
await delay(100);
108-
109-
expect(getSendCount()).toEqual(2);
110-
// After a successful send, the store should be checked again to ensure it's empty
111-
expect(getCalls()).toEqual(['pop', 'pop']);
112-
});
113-
114-
it('Queues envelope if wrapped transport throws error', async () => {
115-
const { getCalls, store } = createTestStore();
116-
const { getSendCount, baseTransport } = createTestTransport(new Error());
117-
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
118-
const result = await transport.send(ERROR_ENVELOPE);
119-
120-
expect(result).toEqual({});
121-
122-
await delay(100);
123-
124-
expect(getSendCount()).toEqual(0);
125-
expect(getCalls()).toEqual(['add']);
126-
});
127-
128-
it('Queues envelope if rate limited', async () => {
129-
const { getCalls, store } = createTestStore();
130-
const { getSendCount, baseTransport } = createTestTransport({
131-
headers: { 'x-sentry-rate-limits': 'something', 'retry-after': null },
132-
});
133-
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
134-
const result = await transport.send(ERROR_ENVELOPE);
135-
expect(result).toEqual({});
136-
137-
await delay(100);
138-
139-
expect(getSendCount()).toEqual(1);
140-
expect(getCalls()).toEqual(['add']);
141-
});
142-
143-
it(
144-
'Retries sending envelope after failure',
145-
async () => {
146-
const { getCalls, store } = createTestStore();
147-
const { getSendCount, baseTransport } = createTestTransport(new Error(), { statusCode: 200 });
148-
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
149-
const result = await transport.send(ERROR_ENVELOPE);
150-
expect(result).toEqual({});
151-
expect(getCalls()).toEqual(['add']);
152-
153-
await delay(START_DELAY + 1_000);
154-
155-
expect(getSendCount()).toEqual(1);
156-
expect(getCalls()).toEqual(['add', 'pop', 'pop']);
157-
},
158-
START_DELAY + 2_000,
159-
);
160-
161-
it(
162-
'When enabled, sends envelopes found in store shortly after startup',
163-
async () => {
164-
const { getCalls, store } = createTestStore(ERROR_ENVELOPE, ERROR_ENVELOPE);
165-
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
166-
const _transport = makeOfflineTransport(baseTransport, store)({ ...transportOptions, flushAtStartup: true });
167-
168-
await delay(START_DELAY + 1_000);
169-
170-
expect(getSendCount()).toEqual(2);
171-
expect(getCalls()).toEqual(['pop', 'pop', 'pop']);
172-
},
173-
START_DELAY + 2_000,
174-
);
175-
});
1+
import type {
2+
Envelope,
3+
EventEnvelope,
4+
EventItem,
5+
InternalBaseTransportOptions,
6+
Transport,
7+
TransportMakeRequestResponse,
8+
} from '@sentry/types';
9+
import { createEnvelope } from '@sentry/utils';
10+
import { TextEncoder } from 'util';
11+
12+
import { createTransport, makeOfflineTransport } from '../../../src';
13+
import type { CreateOfflineStore } from '../../../src/transports/offline';
14+
import { START_DELAY } from '../../../src/transports/offline';
15+
16+
const ERROR_ENVELOPE = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' }, [
17+
[{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
18+
]);
19+
20+
const transportOptions = {
21+
recordDroppedEvent: () => undefined, // noop
22+
textEncoder: new TextEncoder(),
23+
};
24+
25+
type MockResult<T> = T | Error;
26+
27+
const createTestTransport = (
28+
...sendResults: MockResult<TransportMakeRequestResponse>[]
29+
): { getSendCount: () => number; baseTransport: (options: InternalBaseTransportOptions) => Transport } => {
30+
let sendCount = 0;
31+
32+
return {
33+
getSendCount: () => sendCount,
34+
baseTransport: (options: InternalBaseTransportOptions) =>
35+
createTransport(options, () => {
36+
return new Promise((resolve, reject) => {
37+
const next = sendResults.shift();
38+
39+
if (next instanceof Error) {
40+
reject(next);
41+
} else {
42+
sendCount += 1;
43+
resolve(next as TransportMakeRequestResponse | undefined);
44+
}
45+
});
46+
}),
47+
};
48+
};
49+
50+
type StoreEvents = ('add' | 'pop')[];
51+
52+
function createTestStore(...popResults: MockResult<Envelope | undefined>[]): {
53+
getCalls: () => StoreEvents;
54+
store: CreateOfflineStore;
55+
} {
56+
const calls: StoreEvents = [];
57+
58+
return {
59+
getCalls: () => calls,
60+
store: (maxQueueCount: number) => ({
61+
insert: async env => {
62+
if (popResults.length < maxQueueCount) {
63+
popResults.push(env);
64+
calls.push('add');
65+
}
66+
},
67+
pop: async () => {
68+
calls.push('pop');
69+
const next = popResults.shift();
70+
71+
if (next instanceof Error) {
72+
throw next;
73+
}
74+
75+
return next;
76+
},
77+
}),
78+
};
79+
}
80+
81+
function delay(ms: number): Promise<void> {
82+
return new Promise(resolve => setTimeout(resolve, ms));
83+
}
84+
85+
describe('makeOfflineTransport', () => {
86+
it('Sends envelope and checks the store for further envelopes', async () => {
87+
expect.assertions(3);
88+
89+
const { getCalls, store } = createTestStore();
90+
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 });
91+
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
92+
const result = await transport.send(ERROR_ENVELOPE);
93+
94+
expect(result).toEqual({ statusCode: 200 });
95+
expect(getSendCount()).toEqual(1);
96+
// After a successful send, the store should be checked
97+
expect(getCalls()).toEqual(['pop']);
98+
});
99+
100+
it('After successfully sending, sends further envelopes found in the store', async () => {
101+
const { getCalls, store } = createTestStore(ERROR_ENVELOPE);
102+
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
103+
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
104+
const result = await transport.send(ERROR_ENVELOPE);
105+
106+
expect(result).toEqual({ statusCode: 200 });
107+
108+
await delay(100);
109+
110+
expect(getSendCount()).toEqual(2);
111+
// After a successful send, the store should be checked again to ensure it's empty
112+
expect(getCalls()).toEqual(['pop', 'pop']);
113+
});
114+
115+
it('Queues envelope if wrapped transport throws error', async () => {
116+
const { getCalls, store } = createTestStore();
117+
const { getSendCount, baseTransport } = createTestTransport(new Error());
118+
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
119+
const result = await transport.send(ERROR_ENVELOPE);
120+
121+
expect(result).toEqual({});
122+
123+
await delay(100);
124+
125+
expect(getSendCount()).toEqual(0);
126+
expect(getCalls()).toEqual(['add']);
127+
});
128+
129+
it('Queues envelope if rate limited', async () => {
130+
const { getCalls, store } = createTestStore();
131+
const { getSendCount, baseTransport } = createTestTransport({
132+
headers: { 'x-sentry-rate-limits': 'something', 'retry-after': null },
133+
});
134+
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
135+
const result = await transport.send(ERROR_ENVELOPE);
136+
expect(result).toEqual({});
137+
138+
await delay(100);
139+
140+
expect(getSendCount()).toEqual(1);
141+
expect(getCalls()).toEqual(['add']);
142+
});
143+
144+
it(
145+
'Retries sending envelope after failure',
146+
async () => {
147+
const { getCalls, store } = createTestStore();
148+
const { getSendCount, baseTransport } = createTestTransport(new Error(), { statusCode: 200 });
149+
const transport = makeOfflineTransport(baseTransport, store)(transportOptions);
150+
const result = await transport.send(ERROR_ENVELOPE);
151+
expect(result).toEqual({});
152+
expect(getCalls()).toEqual(['add']);
153+
154+
await delay(START_DELAY + 1_000);
155+
156+
expect(getSendCount()).toEqual(1);
157+
expect(getCalls()).toEqual(['add', 'pop', 'pop']);
158+
},
159+
START_DELAY + 2_000,
160+
);
161+
162+
it(
163+
'When enabled, sends envelopes found in store shortly after startup',
164+
async () => {
165+
const { getCalls, store } = createTestStore(ERROR_ENVELOPE, ERROR_ENVELOPE);
166+
const { getSendCount, baseTransport } = createTestTransport({ statusCode: 200 }, { statusCode: 200 });
167+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
168+
const _transport = makeOfflineTransport(baseTransport, store)({ ...transportOptions, flushAtStartup: true });
169+
170+
await delay(START_DELAY + 1_000);
171+
172+
expect(getSendCount()).toEqual(2);
173+
expect(getCalls()).toEqual(['pop', 'pop', 'pop']);
174+
},
175+
START_DELAY + 2_000,
176+
);
177+
});

0 commit comments

Comments
 (0)