Skip to content

Commit 5518dab

Browse files
onurtemizkanonurtemizkan
committed
Update integration tests
1 parent 982c420 commit 5518dab

File tree

3 files changed

+98
-94
lines changed

3 files changed

+98
-94
lines changed

‎packages/remix/test/integration/app/root.tsx‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -15,12 +15,12 @@ export const ErrorBoundary: ErrorBoundaryComponent = () => {
1515
);
1616
};
1717

18-
export const meta: MetaFunction = ({ data }) => [
18+
// With Server-Timing headers as the primary trace propagation method,
19+
// meta tags for sentry-trace and baggage are no longer needed.
20+
export const meta: MetaFunction = () => [
1921
{ charset: 'utf-8' },
2022
{ title: 'New Remix App' },
2123
{ name: 'viewport', content: 'width=device-width,initial-scale=1' },
22-
{ name: 'sentry-trace', content: data.sentryTrace },
23-
{ name: 'baggage', content: data.sentryBaggage },
2424
];
2525

2626
export const loader: LoaderFunction = async ({ request }) => {

‎packages/remix/test/integration/test/client/meta-tags.test.ts‎

Lines changed: 25 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -2,65 +2,51 @@ import { expect, test } from '@playwright/test';
22
import type { Event } from '@sentry/core';
33
import { getFirstSentryEnvelopeRequest } from './utils/helpers';
44

5-
test('should inject `sentry-trace` and `baggage` meta tags inside the root page.', async ({ page }) => {
5+
// With Server-Timing headers as the primary trace propagation method,
6+
// meta tags are no longer injected in Node.js/Cloudflare environments.
7+
8+
test('should NOT inject `sentry-trace` and `baggage` meta tags inside the root page (Server-Timing is used instead)', async ({
9+
page,
10+
}) => {
611
await page.goto('/');
712

813
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
9-
const sentryTraceContent = await sentryTraceTag?.getAttribute('content');
10-
11-
expect(sentryTraceContent).toEqual(expect.any(String));
12-
1314
const sentryBaggageTag = await page.$('meta[name="baggage"]');
14-
const sentryBaggageContent = await sentryBaggageTag?.getAttribute('content');
1515

16-
expect(sentryBaggageContent).toEqual(expect.any(String));
16+
// Meta tags should not be present - Server-Timing headers are used instead
17+
expect(sentryTraceTag).toBeNull();
18+
expect(sentryBaggageTag).toBeNull();
1719
});
1820

19-
test('should inject `sentry-trace` and `baggage` meta tags inside a parameterized route.', async ({ page }) => {
21+
test('should NOT inject `sentry-trace` and `baggage` meta tags inside a parameterized route (Server-Timing is used instead)', async ({
22+
page,
23+
}) => {
2024
await page.goto('/loader-json-response/0');
2125

2226
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
23-
const sentryTraceContent = await sentryTraceTag?.getAttribute('content');
24-
25-
expect(sentryTraceContent).toEqual(expect.any(String));
26-
2727
const sentryBaggageTag = await page.$('meta[name="baggage"]');
28-
const sentryBaggageContent = await sentryBaggageTag?.getAttribute('content');
2928

30-
expect(sentryBaggageContent).toEqual(expect.any(String));
29+
// Meta tags should not be present - Server-Timing headers are used instead
30+
expect(sentryTraceTag).toBeNull();
31+
expect(sentryBaggageTag).toBeNull();
3132
});
3233

33-
test('should send transactions with corresponding `sentry-trace` and `baggage` inside root page', async ({
34-
page,
35-
browserName,
36-
}) => {
34+
test('should send pageload transaction with valid trace context from Server-Timing (root page)', async ({ page }) => {
3735
const envelope = await getFirstSentryEnvelopeRequest<Event>(page, '/');
3836

39-
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
40-
const sentryTraceContent = await sentryTraceTag?.getAttribute('content');
41-
const sentryBaggageTag = await page.$('meta[name="baggage"]');
42-
const sentryBaggageContent = await sentryBaggageTag?.getAttribute('content');
43-
44-
expect(sentryTraceContent).toContain(
45-
`${envelope.contexts?.trace?.trace_id}-${envelope.contexts?.trace?.parent_span_id}-`,
46-
);
47-
48-
expect(sentryBaggageContent).toContain(envelope.contexts?.trace?.trace_id);
37+
// Verify trace propagation worked - transaction should have valid trace context
38+
expect(envelope.contexts?.trace?.trace_id).toHaveLength(32);
39+
expect(envelope.contexts?.trace?.parent_span_id).toHaveLength(16);
40+
expect(envelope.contexts?.trace?.op).toBe('pageload');
4941
});
5042

51-
test('should send transactions with corresponding `sentry-trace` and `baggage` inside a parameterized route', async ({
43+
test('should send pageload transaction with valid trace context from Server-Timing (parameterized route)', async ({
5244
page,
5345
}) => {
5446
const envelope = await getFirstSentryEnvelopeRequest<Event>(page, '/loader-json-response/0');
5547

56-
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
57-
const sentryTraceContent = await sentryTraceTag?.getAttribute('content');
58-
const sentryBaggageTag = await page.$('meta[name="baggage"]');
59-
const sentryBaggageContent = await sentryBaggageTag?.getAttribute('content');
60-
61-
expect(sentryTraceContent).toContain(
62-
`${envelope.contexts?.trace?.trace_id}-${envelope.contexts?.trace?.parent_span_id}-`,
63-
);
64-
65-
expect(sentryBaggageContent).toContain(envelope.contexts?.trace?.trace_id);
48+
// Verify trace propagation worked - transaction should have valid trace context
49+
expect(envelope.contexts?.trace?.trace_id).toHaveLength(32);
50+
expect(envelope.contexts?.trace?.parent_span_id).toHaveLength(16);
51+
expect(envelope.contexts?.trace?.op).toBe('pageload');
6652
});

‎packages/remix/test/integration/test/client/root-loader.test.ts‎

Lines changed: 70 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -1,106 +1,124 @@
1-
import { type Page, expect, test } from '@playwright/test';
1+
import { expect, test } from '@playwright/test';
22

3-
async function extractTraceAndBaggageFromMeta(
4-
page: Page,
5-
): Promise<{ sentryTrace?: string | null; sentryBaggage?: string | null }> {
6-
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
7-
const sentryTraceContent = await sentryTraceTag?.getAttribute('content');
8-
9-
const sentryBaggageTag = await page.$('meta[name="baggage"]');
10-
const sentryBaggageContent = await sentryBaggageTag?.getAttribute('content');
11-
12-
return { sentryTrace: sentryTraceContent, sentryBaggage: sentryBaggageContent };
13-
}
3+
// With Server-Timing headers as the primary trace propagation method,
4+
// meta tags are no longer injected in Node.js/Cloudflare environments.
5+
// These tests verify that meta tags are NOT present for various loader types.
146

15-
test('should inject `sentry-trace` and `baggage` meta tags with empty loader', async ({ page }) => {
7+
test('should NOT inject meta tags with empty loader (Server-Timing is used instead)', async ({ page }) => {
168
await page.goto('/?type=empty');
17-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
189

19-
expect(sentryTrace).toMatch(/.+/);
20-
expect(sentryBaggage).toMatch(/.+/);
10+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
11+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
12+
13+
// Meta tags should not be present - Server-Timing headers are used instead
14+
expect(sentryTraceTag).toBeNull();
15+
expect(sentryBaggageTag).toBeNull();
2116
});
2217

23-
test('should inject `sentry-trace` and `baggage` meta tags with plain object loader', async ({ page }) => {
18+
test('should NOT inject meta tags with plain object loader (Server-Timing is used instead)', async ({ page }) => {
2419
await page.goto('/?type=plain');
25-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
2620

27-
expect(sentryTrace).toMatch(/.+/);
28-
expect(sentryBaggage).toMatch(/.+/);
21+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
22+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
23+
24+
expect(sentryTraceTag).toBeNull();
25+
expect(sentryBaggageTag).toBeNull();
2926
});
3027

31-
test('should inject `sentry-trace` and `baggage` meta tags with JSON response loader', async ({ page }) => {
28+
test('should NOT inject meta tags with JSON response loader (Server-Timing is used instead)', async ({ page }) => {
3229
await page.goto('/?type=json');
33-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
3430

35-
expect(sentryTrace).toMatch(/.+/);
36-
expect(sentryBaggage).toMatch(/.+/);
31+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
32+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
33+
34+
expect(sentryTraceTag).toBeNull();
35+
expect(sentryBaggageTag).toBeNull();
3736
});
3837

39-
test('should inject `sentry-trace` and `baggage` meta tags with deferred response loader', async ({ page }) => {
38+
test('should NOT inject meta tags with deferred response loader (Server-Timing is used instead)', async ({ page }) => {
4039
await page.goto('/?type=defer');
41-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
4240

43-
expect(sentryTrace).toMatch(/.+/);
44-
expect(sentryBaggage).toMatch(/.+/);
41+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
42+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
43+
44+
expect(sentryTraceTag).toBeNull();
45+
expect(sentryBaggageTag).toBeNull();
4546
});
4647

47-
test('should inject `sentry-trace` and `baggage` meta tags with null loader', async ({ page }) => {
48+
test('should NOT inject meta tags with null loader (Server-Timing is used instead)', async ({ page }) => {
4849
await page.goto('/?type=null');
49-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
5050

51-
expect(sentryTrace).toMatch(/.+/);
52-
expect(sentryBaggage).toMatch(/.+/);
51+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
52+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
53+
54+
expect(sentryTraceTag).toBeNull();
55+
expect(sentryBaggageTag).toBeNull();
5356
});
5457

55-
test('should inject `sentry-trace` and `baggage` meta tags with undefined loader', async ({ page }) => {
58+
test('should NOT inject meta tags with undefined loader (Server-Timing is used instead)', async ({ page }) => {
5659
await page.goto('/?type=undefined');
57-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
5860

59-
expect(sentryTrace).toMatch(/.+/);
60-
expect(sentryBaggage).toMatch(/.+/);
61+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
62+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
63+
64+
expect(sentryTraceTag).toBeNull();
65+
expect(sentryBaggageTag).toBeNull();
6166
});
6267

63-
test('should inject `sentry-trace` and `baggage` meta tags with throw redirect loader', async ({ page }) => {
68+
test('should NOT inject meta tags with throw redirect loader (Server-Timing is used instead)', async ({ page }) => {
6469
await page.goto('/?type=throwRedirect');
65-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
6670

6771
// We should be successfully redirected to the path.
6872
expect(page.url()).toEqual(expect.stringContaining('/?type=plain'));
6973

70-
expect(sentryTrace).toMatch(/.+/);
71-
expect(sentryBaggage).toMatch(/.+/);
74+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
75+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
76+
77+
// Meta tags should not be present after redirect either
78+
expect(sentryTraceTag).toBeNull();
79+
expect(sentryBaggageTag).toBeNull();
7280
});
7381

74-
test('should inject `sentry-trace` and `baggage` meta tags with return redirect loader', async ({ page, baseURL }) => {
82+
test('should NOT inject meta tags with return redirect loader (Server-Timing is used instead)', async ({
83+
page,
84+
baseURL,
85+
}) => {
7586
await page.goto(`${baseURL}/?type=returnRedirect`);
76-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
7787

7888
// We should be successfully redirected to the path.
7989
expect(page.url()).toEqual(expect.stringContaining('/?type=plain'));
8090

81-
expect(sentryTrace).toMatch(/.+/);
82-
expect(sentryBaggage).toMatch(/.+/);
91+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
92+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
93+
94+
// Meta tags should not be present after redirect either
95+
expect(sentryTraceTag).toBeNull();
96+
expect(sentryBaggageTag).toBeNull();
8397
});
8498

85-
test('should return redirect to an external path with no baggage and trace injected.', async ({ page, baseURL }) => {
99+
test('should return redirect to an external path with no baggage and trace meta tags.', async ({ page, baseURL }) => {
86100
await page.goto(`${baseURL}/?type=returnRedirectToExternal`);
87101

88102
expect(page.url()).toEqual(expect.stringContaining('docs.sentry.io'));
89103

90-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
104+
// External page won't have our meta tags
105+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
106+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
91107

92-
expect(sentryTrace).toBeUndefined();
93-
expect(sentryBaggage).toBeUndefined();
108+
expect(sentryTraceTag).toBeNull();
109+
expect(sentryBaggageTag).toBeNull();
94110
});
95111

96-
test('should throw redirect to an external path with no baggage and trace injected.', async ({ page, baseURL }) => {
112+
test('should throw redirect to an external path with no baggage and trace meta tags.', async ({ page, baseURL }) => {
97113
await page.goto(`${baseURL}/?type=throwRedirectToExternal`);
98114

99115
// We should be successfully redirected to the external path.
100116
expect(page.url()).toEqual(expect.stringContaining('docs.sentry.io'));
101117

102-
const { sentryTrace, sentryBaggage } = await extractTraceAndBaggageFromMeta(page);
118+
// External page won't have our meta tags
119+
const sentryTraceTag = await page.$('meta[name="sentry-trace"]');
120+
const sentryBaggageTag = await page.$('meta[name="baggage"]');
103121

104-
expect(sentryTrace).toBeUndefined();
105-
expect(sentryBaggage).toBeUndefined();
122+
expect(sentryTraceTag).toBeNull();
123+
expect(sentryBaggageTag).toBeNull();
106124
});

0 commit comments

Comments
 (0)