@datadog/mobile-react-native-openfeature 3.7.0 → 3.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +187 -15
- package/lib/commonjs/index.js +7 -0
- package/lib/commonjs/index.js.map +1 -1
- package/lib/commonjs/provider.js +1 -1
- package/lib/commonjs/provider.js.map +1 -1
- package/lib/commonjs/rumContext.js +44 -0
- package/lib/commonjs/rumContext.js.map +1 -0
- package/lib/module/index.js +2 -1
- package/lib/module/index.js.map +1 -1
- package/lib/module/provider.js +1 -1
- package/lib/module/provider.js.map +1 -1
- package/lib/module/rumContext.js +37 -0
- package/lib/module/rumContext.js.map +1 -0
- package/lib/typescript/core/src/flags/internal.d.ts.map +1 -1
- package/lib/typescript/core/src/flags/rumIntegration.d.ts +14 -0
- package/lib/typescript/core/src/flags/rumIntegration.d.ts.map +1 -0
- package/lib/typescript/core/src/index.d.ts +2 -1
- package/lib/typescript/core/src/index.d.ts.map +1 -1
- package/lib/typescript/core/src/sdk/AttributesEncoding/defaultEncoders.d.ts.map +1 -1
- package/lib/typescript/core/src/sdk/AttributesEncoding/utils.d.ts +1 -0
- package/lib/typescript/core/src/sdk/AttributesEncoding/utils.d.ts.map +1 -1
- package/lib/typescript/core/src/sdk/DdSdkInternal.d.ts +1 -8
- package/lib/typescript/core/src/sdk/DdSdkInternal.d.ts.map +1 -1
- package/lib/typescript/core/src/utils/time-provider/TimeProvider.d.ts.map +1 -1
- package/lib/typescript/core/src/version.d.ts +1 -1
- package/lib/typescript/react-native-openfeature/src/index.d.ts +4 -2
- package/lib/typescript/react-native-openfeature/src/index.d.ts.map +1 -1
- package/lib/typescript/react-native-openfeature/src/provider.d.ts.map +1 -1
- package/lib/typescript/react-native-openfeature/src/rumContext.d.ts +23 -0
- package/lib/typescript/react-native-openfeature/src/rumContext.d.ts.map +1 -0
- package/package.json +3 -3
- package/src/__tests__/__utils__/rumContext.types.ts +55 -0
- package/src/__tests__/__utils__/tsconfig.json +8 -0
- package/src/__tests__/provider.test.ts +30 -0
- package/src/__tests__/rumContext.compatibility.test.ts +122 -0
- package/src/__tests__/rumContext.integration.test.ts +414 -0
- package/src/__tests__/rumContext.test.ts +100 -0
- package/src/__tests__/rumContext.types.test.ts +27 -0
- package/src/index.ts +4 -1
- package/src/provider.ts +5 -3
- package/src/rumContext.ts +54 -0
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
|
|
3
|
+
* This product includes software developed at Datadog (https://www.datadoghq.com/).
|
|
4
|
+
* Copyright 2016-Present Datadog, Inc.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import { __ddEnrichEvaluationContextWithRumUser } from '@datadog/mobile-react-native';
|
|
8
|
+
import type { EvaluationContext } from '@openfeature/web-sdk';
|
|
9
|
+
|
|
10
|
+
import type { EnrichableEvaluationContext } from '../../index';
|
|
11
|
+
import { enrichWithRumUser } from '../../index';
|
|
12
|
+
|
|
13
|
+
// Compiled, not executed: valid inputs must compile, and invalid inputs must stay rejected.
|
|
14
|
+
export const checkRumContextTypes = (optionalId: string | undefined) => {
|
|
15
|
+
const applicationContext: EnrichableEvaluationContext = {
|
|
16
|
+
targetingKey: optionalId,
|
|
17
|
+
email: undefined,
|
|
18
|
+
plan: undefined,
|
|
19
|
+
region: 'us-east-1',
|
|
20
|
+
profile: { tier: 'pro' },
|
|
21
|
+
roles: ['admin'],
|
|
22
|
+
createdAt: new Date(),
|
|
23
|
+
active: true,
|
|
24
|
+
age: 42,
|
|
25
|
+
nullable: null
|
|
26
|
+
};
|
|
27
|
+
const existingContext: EvaluationContext = { targetingKey: 'user-123' };
|
|
28
|
+
const emailTombstone = { email: undefined };
|
|
29
|
+
const optionalTargetingKey = { targetingKey: optionalId, region: 'us' };
|
|
30
|
+
|
|
31
|
+
const results: EvaluationContext[] = [
|
|
32
|
+
enrichWithRumUser(applicationContext),
|
|
33
|
+
enrichWithRumUser(existingContext),
|
|
34
|
+
enrichWithRumUser({}),
|
|
35
|
+
enrichWithRumUser({ email: undefined, plan: undefined }),
|
|
36
|
+
enrichWithRumUser(emailTombstone),
|
|
37
|
+
enrichWithRumUser({ targetingKey: undefined }),
|
|
38
|
+
enrichWithRumUser(optionalTargetingKey)
|
|
39
|
+
];
|
|
40
|
+
|
|
41
|
+
// @ts-expect-error A targeting key must be a string or undefined.
|
|
42
|
+
enrichWithRumUser({ targetingKey: 42 });
|
|
43
|
+
// @ts-expect-error Functions are not OpenFeature context values.
|
|
44
|
+
enrichWithRumUser({ callback: () => true });
|
|
45
|
+
// @ts-expect-error Tombstones only apply to top-level attributes.
|
|
46
|
+
enrichWithRumUser({ profile: { tier: undefined } });
|
|
47
|
+
|
|
48
|
+
const coreResult = __ddEnrichEvaluationContextWithRumUser({
|
|
49
|
+
email: undefined
|
|
50
|
+
});
|
|
51
|
+
// @ts-expect-error Enrichment does not preserve the input's exact shape.
|
|
52
|
+
const unchangedShape: { email: undefined } = coreResult;
|
|
53
|
+
|
|
54
|
+
return { results, unchangedShape };
|
|
55
|
+
};
|
|
@@ -58,6 +58,36 @@ describe('DatadogOpenFeatureProvider', () => {
|
|
|
58
58
|
);
|
|
59
59
|
});
|
|
60
60
|
|
|
61
|
+
it('recovers after a context update fails', async () => {
|
|
62
|
+
const provider = new DatadogOpenFeatureProvider();
|
|
63
|
+
mockFlagsClient.setEvaluationContext
|
|
64
|
+
.mockResolvedValueOnce(undefined)
|
|
65
|
+
.mockRejectedValueOnce(new Error('temporarily offline'))
|
|
66
|
+
.mockResolvedValueOnce(undefined);
|
|
67
|
+
|
|
68
|
+
await provider.initialize({ targetingKey: 'user-1' });
|
|
69
|
+
|
|
70
|
+
await expect(
|
|
71
|
+
provider.onContextChange(
|
|
72
|
+
{ targetingKey: 'user-1' },
|
|
73
|
+
{ targetingKey: 'user-2' }
|
|
74
|
+
)
|
|
75
|
+
).rejects.toThrow('temporarily offline');
|
|
76
|
+
|
|
77
|
+
await expect(
|
|
78
|
+
provider.onContextChange(
|
|
79
|
+
{ targetingKey: 'user-2' },
|
|
80
|
+
{ targetingKey: 'user-3' }
|
|
81
|
+
)
|
|
82
|
+
).resolves.toBeUndefined();
|
|
83
|
+
|
|
84
|
+
expect(mockFlagsClient.setEvaluationContext).toHaveBeenCalledTimes(3);
|
|
85
|
+
expect(mockFlagsClient.setEvaluationContext).toHaveBeenNthCalledWith(
|
|
86
|
+
3,
|
|
87
|
+
expect.objectContaining({ targetingKey: 'user-3' })
|
|
88
|
+
);
|
|
89
|
+
});
|
|
90
|
+
|
|
61
91
|
it('resolves boolean evaluation through the client', () => {
|
|
62
92
|
const provider = new DatadogOpenFeatureProvider();
|
|
63
93
|
|
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
|
|
3
|
+
* This product includes software developed at Datadog (https://www.datadoghq.com/).
|
|
4
|
+
* Copyright 2016-Present Datadog, Inc.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import * as DatadogSdk from '@datadog/mobile-react-native';
|
|
8
|
+
import { OpenFeature } from '@openfeature/web-sdk';
|
|
9
|
+
|
|
10
|
+
import { DatadogOpenFeatureProvider, enrichWithRumUser } from '../index';
|
|
11
|
+
|
|
12
|
+
const mockFlagsClient = {
|
|
13
|
+
setEvaluationContext: jest.fn(() => Promise.resolve()),
|
|
14
|
+
getBooleanDetails: jest.fn(() => ({
|
|
15
|
+
value: true,
|
|
16
|
+
reason: 'TARGETING_MATCH',
|
|
17
|
+
variant: 'enabled'
|
|
18
|
+
}))
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
jest.mock('@datadog/mobile-react-native', () => ({
|
|
22
|
+
__esModule: true,
|
|
23
|
+
DdFlags: { getClient: jest.fn(() => mockFlagsClient) },
|
|
24
|
+
configurationFromString: jest.fn()
|
|
25
|
+
}));
|
|
26
|
+
|
|
27
|
+
describe('RUM context core compatibility', () => {
|
|
28
|
+
beforeEach(() => {
|
|
29
|
+
jest.clearAllMocks();
|
|
30
|
+
Reflect.deleteProperty(
|
|
31
|
+
DatadogSdk,
|
|
32
|
+
'__ddEnrichEvaluationContextWithRumUser'
|
|
33
|
+
);
|
|
34
|
+
jest.spyOn(console, 'warn').mockImplementation(() => {});
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
afterEach(async () => {
|
|
38
|
+
await OpenFeature.clearProviders();
|
|
39
|
+
await OpenFeature.clearContext();
|
|
40
|
+
jest.restoreAllMocks();
|
|
41
|
+
});
|
|
42
|
+
it('keeps the provider usable with a core version that predates enrichment', async () => {
|
|
43
|
+
const provider = new DatadogOpenFeatureProvider();
|
|
44
|
+
|
|
45
|
+
await provider.initialize({
|
|
46
|
+
targetingKey: 'explicit-user',
|
|
47
|
+
plan: 'pro'
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
expect(mockFlagsClient.setEvaluationContext).toHaveBeenCalledWith({
|
|
51
|
+
targetingKey: 'explicit-user',
|
|
52
|
+
attributes: { plan: 'pro' }
|
|
53
|
+
});
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
it('returns the context unchanged and warns when the helper and InternalLog are missing', () => {
|
|
57
|
+
const context = Object.freeze({
|
|
58
|
+
targetingKey: 'application-user',
|
|
59
|
+
email: undefined,
|
|
60
|
+
profile: { plan: 'pro' }
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
expect(DatadogSdk.InternalLog).toBeUndefined();
|
|
64
|
+
expect(enrichWithRumUser(context)).toBe(context);
|
|
65
|
+
expect(console.warn).toHaveBeenCalledTimes(1);
|
|
66
|
+
expect(console.warn).toHaveBeenCalledWith(
|
|
67
|
+
'DATADOG: `enrichWithRumUser` could not access the core RUM enrichment helper. Returning the application context unchanged. Check SDK compatibility.'
|
|
68
|
+
);
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
it.each([undefined, null, false, 42, 'not a function', {}])(
|
|
72
|
+
'returns the context unchanged when the helper is not callable (%p)',
|
|
73
|
+
enricher => {
|
|
74
|
+
Object.assign(DatadogSdk, {
|
|
75
|
+
__ddEnrichEvaluationContextWithRumUser: enricher
|
|
76
|
+
});
|
|
77
|
+
const context = { targetingKey: 'application-user', plan: 'pro' };
|
|
78
|
+
|
|
79
|
+
expect(enrichWithRumUser(context)).toBe(context);
|
|
80
|
+
expect(console.warn).toHaveBeenCalledTimes(1);
|
|
81
|
+
}
|
|
82
|
+
);
|
|
83
|
+
|
|
84
|
+
it('allows OpenFeature startup and flag evaluation with the application context', async () => {
|
|
85
|
+
const context = {
|
|
86
|
+
targetingKey: 'application-user',
|
|
87
|
+
plan: 'pro',
|
|
88
|
+
email: undefined
|
|
89
|
+
};
|
|
90
|
+
|
|
91
|
+
await OpenFeature.setContext(enrichWithRumUser(context));
|
|
92
|
+
await OpenFeature.setProviderAndWait(new DatadogOpenFeatureProvider());
|
|
93
|
+
|
|
94
|
+
expect(OpenFeature.getContext()).toStrictEqual(context);
|
|
95
|
+
expect(mockFlagsClient.setEvaluationContext).toHaveBeenCalledWith({
|
|
96
|
+
targetingKey: 'application-user',
|
|
97
|
+
attributes: { plan: 'pro', email: undefined }
|
|
98
|
+
});
|
|
99
|
+
expect(
|
|
100
|
+
OpenFeature.getClient().getBooleanValue('test-flag', false)
|
|
101
|
+
).toBe(true);
|
|
102
|
+
expect(mockFlagsClient.getBooleanDetails).toHaveBeenCalledWith(
|
|
103
|
+
'test-flag',
|
|
104
|
+
false
|
|
105
|
+
);
|
|
106
|
+
expect(console.warn).toHaveBeenCalledTimes(1);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
it('delegates to an available helper without warning', () => {
|
|
110
|
+
const context = { region: 'us' };
|
|
111
|
+
const enriched = { targetingKey: 'rum-user', region: 'us' };
|
|
112
|
+
const enricher = jest.fn(() => enriched);
|
|
113
|
+
Object.assign(DatadogSdk, {
|
|
114
|
+
__ddEnrichEvaluationContextWithRumUser: enricher
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
expect(enrichWithRumUser(context)).toBe(enriched);
|
|
118
|
+
expect(enricher).toHaveBeenCalledWith(context);
|
|
119
|
+
expect(enricher).toHaveBeenCalledTimes(1);
|
|
120
|
+
expect(console.warn).not.toHaveBeenCalled();
|
|
121
|
+
});
|
|
122
|
+
});
|
|
@@ -0,0 +1,414 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
|
|
3
|
+
* This product includes software developed at Datadog (https://www.datadoghq.com/).
|
|
4
|
+
* Copyright 2016-Present Datadog, Inc.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import { DdFlags, DdSdkReactNative } from '@datadog/mobile-react-native';
|
|
8
|
+
import { InMemoryProvider, OpenFeature } from '@openfeature/web-sdk';
|
|
9
|
+
|
|
10
|
+
import { InternalLog } from '../../../core/src/InternalLog';
|
|
11
|
+
import { SdkVerbosity } from '../../../core/src/config/types/SdkVerbosity';
|
|
12
|
+
import { UserInfoSingleton } from '../../../core/src/sdk/UserInfoSingleton/UserInfoSingleton';
|
|
13
|
+
import NativeDdFlags from '../../../core/src/specs/NativeDdFlags';
|
|
14
|
+
import { DatadogOpenFeatureProvider } from '../provider';
|
|
15
|
+
import { enrichWithRumUser } from '../rumContext';
|
|
16
|
+
|
|
17
|
+
jest.mock('../../../core/src/specs/NativeDdFlags', () => ({
|
|
18
|
+
__esModule: true,
|
|
19
|
+
default: {
|
|
20
|
+
enable: jest.fn(() => Promise.resolve()),
|
|
21
|
+
setEvaluationContext: jest.fn(() =>
|
|
22
|
+
Promise.resolve({
|
|
23
|
+
'test-flag': {
|
|
24
|
+
key: 'test-flag',
|
|
25
|
+
value: true,
|
|
26
|
+
allocationKey: 'allocation',
|
|
27
|
+
variationKey: 'enabled',
|
|
28
|
+
reason: 'TARGETING_MATCH',
|
|
29
|
+
doLog: true,
|
|
30
|
+
variationType: 'boolean',
|
|
31
|
+
variationValue: 'true',
|
|
32
|
+
extraLogging: {}
|
|
33
|
+
}
|
|
34
|
+
})
|
|
35
|
+
),
|
|
36
|
+
trackEvaluation: jest.fn(() => Promise.resolve())
|
|
37
|
+
}
|
|
38
|
+
}));
|
|
39
|
+
|
|
40
|
+
jest.mock('../../../core/src/specs/NativeDdSdk', () => ({
|
|
41
|
+
__esModule: true,
|
|
42
|
+
default: {
|
|
43
|
+
setUserInfo: jest.fn(() => Promise.resolve()),
|
|
44
|
+
clearUserInfo: jest.fn(() => Promise.resolve())
|
|
45
|
+
}
|
|
46
|
+
}));
|
|
47
|
+
|
|
48
|
+
let testSequence = 0;
|
|
49
|
+
|
|
50
|
+
const setupProvider = async (context: Record<string, unknown>) => {
|
|
51
|
+
testSequence += 1;
|
|
52
|
+
const domain = `rum-context-domain-${testSequence}`;
|
|
53
|
+
const clientName = `rum-context-client-${testSequence}`;
|
|
54
|
+
|
|
55
|
+
await OpenFeature.setContext(domain, context);
|
|
56
|
+
await OpenFeature.setProviderAndWait(
|
|
57
|
+
domain,
|
|
58
|
+
new DatadogOpenFeatureProvider({ clientName })
|
|
59
|
+
);
|
|
60
|
+
|
|
61
|
+
return { clientName, domain };
|
|
62
|
+
};
|
|
63
|
+
|
|
64
|
+
describe('explicit RUM context enrichment', () => {
|
|
65
|
+
beforeEach(async () => {
|
|
66
|
+
jest.clearAllMocks();
|
|
67
|
+
UserInfoSingleton.reset();
|
|
68
|
+
Object.assign(DdFlags, {
|
|
69
|
+
isFeatureEnabled: false,
|
|
70
|
+
clients: {}
|
|
71
|
+
});
|
|
72
|
+
await DdFlags.enable();
|
|
73
|
+
jest.spyOn(InternalLog, 'log').mockImplementation(() => {});
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
afterEach(async () => {
|
|
77
|
+
await OpenFeature.clearProviders();
|
|
78
|
+
await OpenFeature.clearContext();
|
|
79
|
+
jest.restoreAllMocks();
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
it('does not implicitly add the RUM user to provider context', async () => {
|
|
83
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
84
|
+
id: 'rum-user',
|
|
85
|
+
email: 'rum@example.com'
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
const { clientName } = await setupProvider({});
|
|
89
|
+
|
|
90
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenCalledWith(
|
|
91
|
+
clientName,
|
|
92
|
+
'',
|
|
93
|
+
{}
|
|
94
|
+
);
|
|
95
|
+
});
|
|
96
|
+
|
|
97
|
+
it('makes explicitly enriched context visible to OpenFeature and evaluation tracking', async () => {
|
|
98
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
99
|
+
id: 'rum-user',
|
|
100
|
+
email: 'rum@example.com',
|
|
101
|
+
extraInfo: {
|
|
102
|
+
targetingKey: 'custom-user',
|
|
103
|
+
name: 'custom-name',
|
|
104
|
+
email: 'custom@example.com',
|
|
105
|
+
company_name: 'Example, Inc.',
|
|
106
|
+
nullable: null
|
|
107
|
+
}
|
|
108
|
+
});
|
|
109
|
+
const enrichedContext = enrichWithRumUser({
|
|
110
|
+
email: 'explicit@example.com'
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
const { clientName, domain } = await setupProvider(enrichedContext);
|
|
114
|
+
await OpenFeature.getClient(domain).getBooleanValue('test-flag', false);
|
|
115
|
+
|
|
116
|
+
const expectedAttributes = {
|
|
117
|
+
name: 'custom-name',
|
|
118
|
+
email: 'explicit@example.com',
|
|
119
|
+
company_name: 'Example, Inc.'
|
|
120
|
+
};
|
|
121
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual(enrichedContext);
|
|
122
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenCalledWith(
|
|
123
|
+
clientName,
|
|
124
|
+
'rum-user',
|
|
125
|
+
expectedAttributes
|
|
126
|
+
);
|
|
127
|
+
expect(NativeDdFlags.trackEvaluation).toHaveBeenCalledWith(
|
|
128
|
+
clientName,
|
|
129
|
+
'test-flag',
|
|
130
|
+
expect.any(Object),
|
|
131
|
+
'rum-user',
|
|
132
|
+
expectedAttributes
|
|
133
|
+
);
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
it.each([
|
|
137
|
+
['extraInfo', 42],
|
|
138
|
+
['extraInfo', true],
|
|
139
|
+
['extraInfo', false],
|
|
140
|
+
['application', 42],
|
|
141
|
+
['application', true],
|
|
142
|
+
['application', false],
|
|
143
|
+
['unenriched application', 42],
|
|
144
|
+
['unenriched application', true],
|
|
145
|
+
['unenriched application', false]
|
|
146
|
+
])(
|
|
147
|
+
'validates a final targeting key from %s with value %p only after merging',
|
|
148
|
+
async (source, targetingKey) => {
|
|
149
|
+
const applicationContext = { region: 'us' };
|
|
150
|
+
if (source === 'extraInfo') {
|
|
151
|
+
UserInfoSingleton.getInstance().addUserExtraInfo({
|
|
152
|
+
targetingKey,
|
|
153
|
+
plan: 'pro'
|
|
154
|
+
});
|
|
155
|
+
} else {
|
|
156
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
157
|
+
id: 'rum-user',
|
|
158
|
+
extraInfo: { targetingKey: 'custom-user', plan: 'pro' }
|
|
159
|
+
});
|
|
160
|
+
}
|
|
161
|
+
const context =
|
|
162
|
+
source === 'unenriched application'
|
|
163
|
+
? { targetingKey, plan: 'pro', ...applicationContext }
|
|
164
|
+
: enrichWithRumUser({
|
|
165
|
+
...applicationContext,
|
|
166
|
+
...(source === 'application'
|
|
167
|
+
? { targetingKey: targetingKey as never }
|
|
168
|
+
: {})
|
|
169
|
+
});
|
|
170
|
+
const expectedAttributes = { plan: 'pro', region: 'us' };
|
|
171
|
+
expect(context).toStrictEqual({
|
|
172
|
+
targetingKey,
|
|
173
|
+
...expectedAttributes
|
|
174
|
+
});
|
|
175
|
+
expect(InternalLog.log).not.toHaveBeenCalled();
|
|
176
|
+
|
|
177
|
+
const { clientName, domain } = await setupProvider(context);
|
|
178
|
+
await OpenFeature.getClient(domain).getBooleanValue(
|
|
179
|
+
'test-flag',
|
|
180
|
+
false
|
|
181
|
+
);
|
|
182
|
+
|
|
183
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual(context);
|
|
184
|
+
expect(InternalLog.log).toHaveBeenCalledWith(
|
|
185
|
+
"The evaluation context targetingKey is not a string. Using the anonymous subject ('') instead.",
|
|
186
|
+
SdkVerbosity.WARN
|
|
187
|
+
);
|
|
188
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenCalledWith(
|
|
189
|
+
clientName,
|
|
190
|
+
'',
|
|
191
|
+
expectedAttributes
|
|
192
|
+
);
|
|
193
|
+
expect(NativeDdFlags.trackEvaluation).toHaveBeenCalledWith(
|
|
194
|
+
clientName,
|
|
195
|
+
'test-flag',
|
|
196
|
+
expect.any(Object),
|
|
197
|
+
'',
|
|
198
|
+
expectedAttributes
|
|
199
|
+
);
|
|
200
|
+
}
|
|
201
|
+
);
|
|
202
|
+
|
|
203
|
+
it('preserves the RUM targeting key through evaluation when a custom property throws', async () => {
|
|
204
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
205
|
+
id: 'rum-user',
|
|
206
|
+
email: 'rum@example.com',
|
|
207
|
+
extraInfo: {
|
|
208
|
+
get broken() {
|
|
209
|
+
throw new Error('cannot read custom property');
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
});
|
|
213
|
+
const { clientName, domain } = await setupProvider(
|
|
214
|
+
enrichWithRumUser({ region: 'us' })
|
|
215
|
+
);
|
|
216
|
+
await OpenFeature.getClient(domain).getBooleanValue('test-flag', false);
|
|
217
|
+
|
|
218
|
+
const expectedAttributes = { email: 'rum@example.com', region: 'us' };
|
|
219
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual({
|
|
220
|
+
targetingKey: 'rum-user',
|
|
221
|
+
...expectedAttributes
|
|
222
|
+
});
|
|
223
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenCalledWith(
|
|
224
|
+
clientName,
|
|
225
|
+
'rum-user',
|
|
226
|
+
expectedAttributes
|
|
227
|
+
);
|
|
228
|
+
expect(NativeDdFlags.trackEvaluation).toHaveBeenCalledWith(
|
|
229
|
+
clientName,
|
|
230
|
+
'test-flag',
|
|
231
|
+
expect.any(Object),
|
|
232
|
+
'rum-user',
|
|
233
|
+
expectedAttributes
|
|
234
|
+
);
|
|
235
|
+
});
|
|
236
|
+
|
|
237
|
+
it('uses the latest RUM user when the application reapplies its original context', async () => {
|
|
238
|
+
const applicationContext = { region: 'us' };
|
|
239
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
240
|
+
id: 'rum-user-a',
|
|
241
|
+
email: 'a@example.com'
|
|
242
|
+
});
|
|
243
|
+
const { clientName, domain } = await setupProvider(
|
|
244
|
+
enrichWithRumUser(applicationContext)
|
|
245
|
+
);
|
|
246
|
+
|
|
247
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
248
|
+
id: 'rum-user-b',
|
|
249
|
+
email: 'b@example.com',
|
|
250
|
+
extraInfo: { plan: 'pro' }
|
|
251
|
+
});
|
|
252
|
+
await OpenFeature.setContext(
|
|
253
|
+
domain,
|
|
254
|
+
enrichWithRumUser(applicationContext)
|
|
255
|
+
);
|
|
256
|
+
await OpenFeature.getClient(domain).getBooleanValue('test-flag', false);
|
|
257
|
+
|
|
258
|
+
const expectedContext = {
|
|
259
|
+
targetingKey: 'rum-user-b',
|
|
260
|
+
email: 'b@example.com',
|
|
261
|
+
plan: 'pro',
|
|
262
|
+
region: 'us'
|
|
263
|
+
};
|
|
264
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual(expectedContext);
|
|
265
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenLastCalledWith(
|
|
266
|
+
clientName,
|
|
267
|
+
'rum-user-b',
|
|
268
|
+
{
|
|
269
|
+
email: 'b@example.com',
|
|
270
|
+
plan: 'pro',
|
|
271
|
+
region: 'us'
|
|
272
|
+
}
|
|
273
|
+
);
|
|
274
|
+
expect(
|
|
275
|
+
NativeDdFlags.trackEvaluation
|
|
276
|
+
).toHaveBeenLastCalledWith(
|
|
277
|
+
clientName,
|
|
278
|
+
'test-flag',
|
|
279
|
+
expect.any(Object),
|
|
280
|
+
'rum-user-b',
|
|
281
|
+
{ email: 'b@example.com', plan: 'pro', region: 'us' }
|
|
282
|
+
);
|
|
283
|
+
expect(applicationContext).toStrictEqual({ region: 'us' });
|
|
284
|
+
});
|
|
285
|
+
|
|
286
|
+
it('uses the anonymous subject after clearing the RUM user and reapplying application context', async () => {
|
|
287
|
+
const applicationContext = { region: 'us' };
|
|
288
|
+
await DdSdkReactNative.setUserInfo({
|
|
289
|
+
id: 'rum-user',
|
|
290
|
+
email: 'user@example.com',
|
|
291
|
+
extraInfo: { plan: 'pro' }
|
|
292
|
+
});
|
|
293
|
+
const { clientName, domain } = await setupProvider(
|
|
294
|
+
enrichWithRumUser(applicationContext)
|
|
295
|
+
);
|
|
296
|
+
|
|
297
|
+
await DdSdkReactNative.setUserInfo({ id: '' });
|
|
298
|
+
expect(enrichWithRumUser(applicationContext)).toStrictEqual({
|
|
299
|
+
targetingKey: 'rum-user',
|
|
300
|
+
email: 'user@example.com',
|
|
301
|
+
plan: 'pro',
|
|
302
|
+
region: 'us'
|
|
303
|
+
});
|
|
304
|
+
|
|
305
|
+
await DdSdkReactNative.clearUserInfo();
|
|
306
|
+
await OpenFeature.setContext(
|
|
307
|
+
domain,
|
|
308
|
+
enrichWithRumUser(applicationContext)
|
|
309
|
+
);
|
|
310
|
+
await OpenFeature.getClient(domain).getBooleanValue('test-flag', false);
|
|
311
|
+
|
|
312
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual(
|
|
313
|
+
applicationContext
|
|
314
|
+
);
|
|
315
|
+
expect(
|
|
316
|
+
NativeDdFlags.setEvaluationContext
|
|
317
|
+
).toHaveBeenLastCalledWith(clientName, '', { region: 'us' });
|
|
318
|
+
expect(
|
|
319
|
+
NativeDdFlags.trackEvaluation
|
|
320
|
+
).toHaveBeenLastCalledWith(
|
|
321
|
+
clientName,
|
|
322
|
+
'test-flag',
|
|
323
|
+
expect.any(Object),
|
|
324
|
+
'',
|
|
325
|
+
{ region: 'us' }
|
|
326
|
+
);
|
|
327
|
+
});
|
|
328
|
+
|
|
329
|
+
it('isolates RUM login and logout updates from providers inheriting the global context', async () => {
|
|
330
|
+
const globalContext = { region: 'shared-region' };
|
|
331
|
+
await OpenFeature.setContext(globalContext);
|
|
332
|
+
const otherProvider = Object.assign(new InMemoryProvider({}), {
|
|
333
|
+
onContextChange: jest.fn(() => Promise.resolve())
|
|
334
|
+
});
|
|
335
|
+
await OpenFeature.setProviderAndWait('other-provider', otherProvider);
|
|
336
|
+
|
|
337
|
+
const applicationContext = { region: 'datadog-region' };
|
|
338
|
+
const { domain } = await setupProvider(
|
|
339
|
+
enrichWithRumUser(applicationContext)
|
|
340
|
+
);
|
|
341
|
+
await DdSdkReactNative.setUserInfo({
|
|
342
|
+
id: 'rum-user',
|
|
343
|
+
email: 'user@example.com'
|
|
344
|
+
});
|
|
345
|
+
await OpenFeature.setContext(
|
|
346
|
+
domain,
|
|
347
|
+
enrichWithRumUser(applicationContext)
|
|
348
|
+
);
|
|
349
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual({
|
|
350
|
+
targetingKey: 'rum-user',
|
|
351
|
+
email: 'user@example.com',
|
|
352
|
+
region: 'datadog-region'
|
|
353
|
+
});
|
|
354
|
+
expect(
|
|
355
|
+
OpenFeature.getClient(domain).getBooleanValue('test-flag', false)
|
|
356
|
+
).toBe(true);
|
|
357
|
+
|
|
358
|
+
await DdSdkReactNative.clearUserInfo();
|
|
359
|
+
await OpenFeature.setContext(
|
|
360
|
+
domain,
|
|
361
|
+
enrichWithRumUser(applicationContext)
|
|
362
|
+
);
|
|
363
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual(
|
|
364
|
+
applicationContext
|
|
365
|
+
);
|
|
366
|
+
expect(OpenFeature.getContext()).toStrictEqual(globalContext);
|
|
367
|
+
expect(OpenFeature.getContext('other-provider')).toStrictEqual(
|
|
368
|
+
globalContext
|
|
369
|
+
);
|
|
370
|
+
expect(otherProvider.onContextChange).not.toHaveBeenCalled();
|
|
371
|
+
});
|
|
372
|
+
|
|
373
|
+
it('is independent of RUM feature flag evaluation tracking', async () => {
|
|
374
|
+
await DdFlags.enable({ rumIntegrationEnabled: false });
|
|
375
|
+
UserInfoSingleton.getInstance().setUserInfo({ id: 'rum-user' });
|
|
376
|
+
|
|
377
|
+
const { clientName } = await setupProvider(enrichWithRumUser({}));
|
|
378
|
+
|
|
379
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenLastCalledWith(
|
|
380
|
+
clientName,
|
|
381
|
+
'rum-user',
|
|
382
|
+
{}
|
|
383
|
+
);
|
|
384
|
+
});
|
|
385
|
+
|
|
386
|
+
it('uses undefined application fields as tombstones for RUM attributes', async () => {
|
|
387
|
+
UserInfoSingleton.getInstance().setUserInfo({
|
|
388
|
+
id: 'rum-user',
|
|
389
|
+
email: 'rum@example.com',
|
|
390
|
+
extraInfo: { plan: 'pro' }
|
|
391
|
+
});
|
|
392
|
+
|
|
393
|
+
const { clientName, domain } = await setupProvider(
|
|
394
|
+
enrichWithRumUser({ email: undefined, plan: undefined })
|
|
395
|
+
);
|
|
396
|
+
await OpenFeature.getClient(domain).getBooleanValue('test-flag', false);
|
|
397
|
+
|
|
398
|
+
expect(OpenFeature.getContext(domain)).toStrictEqual({
|
|
399
|
+
targetingKey: 'rum-user'
|
|
400
|
+
});
|
|
401
|
+
expect(NativeDdFlags.setEvaluationContext).toHaveBeenCalledWith(
|
|
402
|
+
clientName,
|
|
403
|
+
'rum-user',
|
|
404
|
+
{}
|
|
405
|
+
);
|
|
406
|
+
expect(NativeDdFlags.trackEvaluation).toHaveBeenCalledWith(
|
|
407
|
+
clientName,
|
|
408
|
+
'test-flag',
|
|
409
|
+
expect.any(Object),
|
|
410
|
+
'rum-user',
|
|
411
|
+
{}
|
|
412
|
+
);
|
|
413
|
+
});
|
|
414
|
+
});
|