/
requestdata.test.ts
124 lines (91 loc) · 4.53 KB
/
requestdata.test.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import { getCurrentHub, Hub, makeMain } from '@sentry/core';
import { Event, EventProcessor } from '@sentry/types';
import * as http from 'http';
import { NodeClient } from '../../src/client';
import { requestHandler } from '../../src/handlers';
import { RequestData, RequestDataIntegrationOptions } from '../../src/integrations/requestdata';
import * as requestDataModule from '../../src/requestdata';
import { getDefaultNodeClientOptions } from '../helper/node-client-options';
const addRequestDataToEventSpy = jest.spyOn(requestDataModule, 'addRequestDataToEvent');
const requestDataEventProcessor = jest.fn();
const headers = { ears: 'furry', nose: 'wet', tongue: 'spotted', cookie: 'favorite=zukes' };
const method = 'wagging';
const protocol = 'mutualsniffing';
const hostname = 'the.dog.park';
const path = '/by/the/trees/';
const queryString = 'chase=me&please=thankyou';
function initWithRequestDataIntegrationOptions(integrationOptions: RequestDataIntegrationOptions): void {
const setMockEventProcessor = (eventProcessor: EventProcessor) =>
requestDataEventProcessor.mockImplementationOnce(eventProcessor);
const requestDataIntegration = new RequestData({
...integrationOptions,
});
const client = new NodeClient(
getDefaultNodeClientOptions({
dsn: 'https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012',
integrations: [requestDataIntegration],
}),
);
client.setupIntegrations = () => requestDataIntegration.setupOnce(setMockEventProcessor, getCurrentHub);
client.getIntegration = () => requestDataIntegration as any;
const hub = new Hub(client);
makeMain(hub);
}
describe('`RequestData` integration', () => {
let req: http.IncomingMessage, event: Event;
beforeEach(() => {
req = {
headers,
method,
protocol,
hostname,
originalUrl: `${path}?${queryString}`,
} as unknown as http.IncomingMessage;
event = { sdkProcessingMetadata: { request: req } };
});
afterEach(() => {
jest.clearAllMocks();
});
describe('option conversion', () => {
it('leaves `ip` and `user` at top level of `include`', () => {
initWithRequestDataIntegrationOptions({ include: { ip: false, user: true } });
requestDataEventProcessor(event);
const passedOptions = addRequestDataToEventSpy.mock.calls[0][2];
expect(passedOptions?.include).toEqual(expect.objectContaining({ ip: false, user: true }));
});
it('moves `transactionNamingScheme` to `transaction` include', () => {
initWithRequestDataIntegrationOptions({ transactionNamingScheme: 'path' });
requestDataEventProcessor(event);
const passedOptions = addRequestDataToEventSpy.mock.calls[0][2];
expect(passedOptions?.include).toEqual(expect.objectContaining({ transaction: 'path' }));
});
it('moves `true` request keys into `request` include, but omits `false` ones', async () => {
initWithRequestDataIntegrationOptions({ include: { data: true, cookies: false } });
requestDataEventProcessor(event);
const passedOptions = addRequestDataToEventSpy.mock.calls[0][2];
expect(passedOptions?.include?.request).toEqual(expect.arrayContaining(['data']));
expect(passedOptions?.include?.request).not.toEqual(expect.arrayContaining(['cookies']));
});
it('moves `true` user keys into `user` include, but omits `false` ones', async () => {
initWithRequestDataIntegrationOptions({ include: { user: { id: true, email: false } } });
requestDataEventProcessor(event);
const passedOptions = addRequestDataToEventSpy.mock.calls[0][2];
expect(passedOptions?.include?.user).toEqual(expect.arrayContaining(['id']));
expect(passedOptions?.include?.user).not.toEqual(expect.arrayContaining(['email']));
});
});
describe('usage with express request handler', () => {
it('uses options from request handler', async () => {
const sentryRequestMiddleware = requestHandler({ include: { transaction: 'methodPath' } });
const res = new http.ServerResponse(req);
const next = jest.fn();
initWithRequestDataIntegrationOptions({ transactionNamingScheme: 'path' });
sentryRequestMiddleware(req, res, next);
await getCurrentHub().getScope()!.applyToEvent(event, {});
requestDataEventProcessor(event);
const passedOptions = addRequestDataToEventSpy.mock.calls[0][2];
// `transaction` matches the request middleware's option, not the integration's option
expect(passedOptions?.include).toEqual(expect.objectContaining({ transaction: 'methodPath' }));
});
});
});