Introduce inputModes option for showing score and comment fields #472
GitHub Actions / Build & Test Report
succeeded
Sep 10, 2025 in 1s
Build & Test Report ✔️
| Report | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| ./packages/browser-sdk/junit.xml | 113✔️ | 6s | ||
| ./packages/cli/junit.xml | 25✔️ | 13ms | ||
| ./packages/flag-evaluation/junit.xml | 143✔️ | 841ms | ||
| ./packages/node-sdk/junit.xml | 179✔️ | 10s | ||
| ./packages/openfeature-browser-provider/junit.xml | 27✔️ | 1s | ||
| ./packages/openfeature-node-provider/junit.xml | 28✔️ | 537ms | ||
| ./packages/react-sdk/junit.xml | 13✔️ | 3s | ||
| ./packages/vue-sdk/junit.xml | 2✔️ | 2s |
✔️ ./packages/browser-sdk/junit.xml
113 tests were completed in 6s with 113 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/client.test.ts | 5✔️ | 430ms | ||
| test/flagCache.test.ts | 3✔️ | 7ms | ||
| test/flags.test.ts | 14✔️ | 243ms | ||
| test/hooksManager.test.ts | 9✔️ | 15ms | ||
| test/httpClient.test.ts | 8✔️ | 20ms | ||
| test/init.test.ts | 5✔️ | 1s | ||
| test/prompts.test.ts | 6✔️ | 16ms | ||
| test/promptStorage.test.ts | 17✔️ | 11ms | ||
| test/rateLimiter.test.ts | 5✔️ | 9ms | ||
| test/sse.test.ts | 20✔️ | 739ms | ||
| test/usage.test.ts | 21✔️ | 1s |
✔️ test/client.test.ts
test/client.test.ts
✔️ ReflagClient > updateUser > should update the user context
✔️ ReflagClient > updateCompany > should update the company context
✔️ ReflagClient > getFlag > takes overrides into account
✔️ ReflagClient > hooks integration > on adds hooks appropriately, off removes them
✔️ ReflagClient > offline mode > should not make HTTP calls when offline
✔️ test/flagCache.test.ts
test/flagCache.test.ts
✔️ cache > caches items
✔️ cache > sets stale
✔️ cache > expires on set
✔️ test/flags.test.ts
test/flags.test.ts
✔️ cache > caches items
✔️ cache > sets stale
✔️ cache > expires on set
✔️ FlagsClient > fetches flags
✔️ FlagsClient > warns about missing context fields
✔️ FlagsClient > ignores undefined context
✔️ FlagsClient > return fallback flags on failure (string list)
✔️ FlagsClient > return fallback flags on failure (record)
✔️ FlagsClient > caches response
✔️ FlagsClient > use cache when unable to fetch flags
✔️ FlagsClient > stale-while-revalidate should cache but start new fetch
✔️ FlagsClient > expires cache eventually
✔️ FlagsClient > handled overrides
✔️ FlagsClient > handled overrides for flags not returned by API
✔️ test/hooksManager.test.ts
test/hooksManager.test.ts
✔️ HookManager > should add and trigger `check` hooks (is-enabled)
✔️ HookManager > should add and trigger `check` hooks (config)
✔️ HookManager > should add and trigger `flagsUpdated` hooks
✔️ HookManager > should add and trigger `track` hooks
✔️ HookManager > should add and trigger `user` hooks
✔️ HookManager > should add and trigger `company` hooks
✔️ HookManager > should handle multiple hooks of the same type
✔️ HookManager > should remove the given hook and no other hooks
✔️ HookManager > should remove the hook using the function returned from addHook
✔️ test/httpClient.test.ts
test/httpClient.test.ts
✔️ url construction with `/path`: https://front.reflag.com -> https://front.reflag.com/path
✔️ url construction with `/path`: https://front.reflag.com/ -> https://front.reflag.com/path
✔️ url construction with `/path`: https://front.reflag.com/basepath -> https://front.reflag.com/basepath/path
✔️ url construction with `path`: https://front.reflag.com -> https://front.reflag.com/path
✔️ url construction with `path`: https://front.reflag.com/ -> https://front.reflag.com/path
✔️ url construction with `path`: https://front.reflag.com/basepath -> https://front.reflag.com/basepath/path
✔️ sets `credentials` > default credentials
✔️ sets `credentials` > custom credentials
✔️ test/init.test.ts
test/init.test.ts
✔️ init > will accept setup with key and debug logger
✔️ init > will accept setup with custom host
✔️ init > automatically does user/company tracking
✔️ init > can disable tracking and auto. feedback surveys
✔️ init > passes credentials correctly to httpClient
✔️ test/prompts.test.ts
test/prompts.test.ts
✔️ parsePromptMessage > will not parse invalid messages
✔️ parsePromptMessage > will parse valid messages
✔️ processPromptMessage > will not process seen prompts
✔️ processPromptMessage > will not process expired prompts
✔️ processPromptMessage > will process prompts that are ready to be shown
✔️ processPromptMessage > will process and delay prompts that are not yet ready to be shown
✔️ test/promptStorage.test.ts
test/promptStorage.test.ts
✔️ prompt-storage > markPromptMessageCompleted > adds new cookie
✔️ prompt-storage > markPromptMessageCompleted > rewrites existing cookie
✔️ prompt-storage > checkPromptMessageCompleted > cookie with same use and prompt results in true
✔️ prompt-storage > checkPromptMessageCompleted > cookie with different prompt results in false
✔️ prompt-storage > checkPromptMessageCompleted > cookie with different user results in false
✔️ prompt-storage > checkPromptMessageCompleted > no cookie results in false
✔️ prompt-storage > rememberAuthToken > adds new cookie if none was there
✔️ prompt-storage > rememberAuthToken > replaces existing cookie for same user
✔️ prompt-storage > forgetAuthToken > clears the user's cookie if even if there was nothing before
✔️ prompt-storage > forgetAuthToken > clears the user's cookie
✔️ prompt-storage > forgetAuthToken > does nothing if there is a cookie for a different user
✔️ prompt-storage > getAuthToken > returns the auth token if it's available for the user
✔️ prompt-storage > getAuthToken > return undefined if no cookie for user
✔️ prompt-storage > getAuthToken > returns undefined if no cookie
✔️ prompt-storage > getAuthToken > return undefined if corrupted cookie
✔️ prompt-storage > getAuthToken > return undefined if a field is missing
✔️ prompt-storage > manages all cookies for the user
✔️ test/rateLimiter.test.ts
test/rateLimiter.test.ts
✔️ rateLimit > should call the key generator
✔️ rateLimit > should not call the callback when the limit is exceeded
✔️ rateLimit > should reset the limit after a minute
✔️ rateLimit > should measure events separately by key
✔️ rateLimit > should return the value of the callback always
✔️ test/sse.test.ts
test/sse.test.ts
✔️ connection handling > appends /sse to the sseHost
✔️ connection handling > rejects if auth endpoint is not success
✔️ connection handling > rejects if auth endpoint is not 200
✔️ connection handling > rejects if token endpoint rejects
✔️ connection handling > obtains token, connects and subscribes, then closes
✔️ connection handling > reuses cached token
✔️ connection handling > does not reuse cached token with wrong channel
✔️ connection handling > does not try to re-connect if already connecting
✔️ connection handling > does not re-connect if already connected
✔️ connection handling > disconnects only if connected
✔️ message handling > passes message to callback
✔️ message handling > disconnects on unknown event source errors without data
✔️ message handling > disconnects on unknown event source errors with data
✔️ message handling > disconnects when ably reports token errors
✔️ automatic retries > opens and connects to a channel
✔️ automatic retries > opens and connects later to a failed channel
✔️ automatic retries > resets retry count on successful connect
✔️ automatic retries > reconnects if manually disconnected
✔️ automatic retries > opens and does not connect later to a failed channel if no retries
✔️ automatic retries > closes an open channel
✔️ test/usage.test.ts
test/usage.test.ts
✔️ usage > golden path - register `user`, `company`, send `event`, send `feedback`, get `flags`
✔️ usage > accepts `flagKey` instead of `featureId` for manual feedback
✔️ feedback prompting > initiates and stops feedback prompting
✔️ feedback prompting > does not call tracking endpoints if token cached
✔️ feedback prompting > does not initiate feedback prompting if server does not agree
✔️ feedback prompting > skip feedback prompting if no user id configured
✔️ feedback prompting > skip feedback prompting if automated feedback surveys are disabled
✔️ feedback state management > ignores prompt if expired
✔️ feedback state management > ignores prompt if already seen
✔️ feedback state management > propagates prompt to the callback
✔️ feedback state management > propagates timed prompt to the callback
✔️ feedback state management > propagates prompt to the callback and reacts to dismissal
✔️ feedback state management > propagates prompt to the callback and reacts to feedback
✔️ sends "check" events > getFlags() does not send `check` events
✔️ sends "check" events > getFlag > returns get the expected flag details
✔️ sends "check" events > getFlag > does not send check events when offline
✔️ sends "check" events > getFlag > sends check event when accessing "isEnabled"
✔️ sends "check" events > getFlag > sends check event when accessing "config"
✔️ sends "check" events > getFlag > sends check event for not-enabled flags
✔️ sends "check" events > getFlag > calls client.track with the flagKey
✔️ sends "check" events > getFlag > calls client.requestFeedback with the flagKey
✔️ ./packages/cli/junit.xml
25 tests were completed in 13ms with 25 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/json.test.ts | 25✔️ | 13ms |
✔️ test/json.test.ts
test/json.test.ts
✔️ JSON utilities > toTypeAST > should handle primitive values
✔️ JSON utilities > toTypeAST > should handle arrays
✔️ JSON utilities > toTypeAST > should handle arrays with mixed element types
✔️ JSON utilities > toTypeAST > should handle objects
✔️ JSON utilities > toTypeAST > should handle nested structures
✔️ JSON utilities > mergeTypeASTs > should handle empty array
✔️ JSON utilities > mergeTypeASTs > should return the same AST for single item arrays
✔️ JSON utilities > mergeTypeASTs > should merge same primitive types
✔️ JSON utilities > mergeTypeASTs > should create union for different primitive types
✔️ JSON utilities > mergeTypeASTs > should merge array types
✔️ JSON utilities > mergeTypeASTs > should merge object types and mark missing properties as optional
✔️ JSON utilities > mergeTypeASTs > should create union for mixed kinds
✔️ JSON utilities > stringifyTypeAST > should stringify primitive types
✔️ JSON utilities > stringifyTypeAST > should stringify array types
✔️ JSON utilities > stringifyTypeAST > should stringify object types
✔️ JSON utilities > stringifyTypeAST > should stringify empty objects
✔️ JSON utilities > stringifyTypeAST > should stringify union types
✔️ JSON utilities > stringifyTypeAST > should handle complex nested types
✔️ JSON utilities > JSONToType > should handle empty arrays
✔️ JSON utilities > JSONToType > should generate type for array of primitives
✔️ JSON utilities > JSONToType > should handle arrays with simple mixed element types
✔️ JSON utilities > JSONToType > should handle arrays with advanced mixed element types
✔️ JSON utilities > JSONToType > should merge arrays with nested arrays of mixed element types
✔️ JSON utilities > JSONToType > should generate type for array of objects
✔️ JSON utilities > JSONToType > should handle complex nested structures
✔️ ./packages/flag-evaluation/junit.xml
143 tests were completed in 841ms with 143 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/index.test.ts | 143✔️ | 81ms |
✔️ test/index.test.ts
test/index.test.ts
✔️ evaluate flag targeting integration > evaluates all kinds of filters
✔️ evaluate flag targeting integration > evaluates flag when there's no matching rule
✔️ evaluate flag targeting integration > evaluates targeting when there's a matching rule
✔️ evaluate flag targeting integration > evaluates flag with missing values
✔️ evaluate flag targeting integration > returns list of missing context keys
✔️ evaluate flag targeting integration > fails evaluation and includes key in missing keys when rollout attribute is missing from context
✔️ evaluate flag targeting integration > evaluates optimized rule evaluations correctly
✔️ evaluate flag targeting integration > SET and NOT_SET operators > should handle `SET` operator with missing field value
✔️ evaluate flag targeting integration > SET and NOT_SET operators > should handle `NOT_SET` operator with missing field value
✔️ evaluate flag targeting integration > SET and NOT_SET operators > should handle `SET` operator with empty string field value
✔️ evaluate flag targeting integration > SET and NOT_SET operators > should handle `NOT_SET` operator with empty string field value
✔️ evaluate flag targeting integration > 0: evaluates optimized rule evaluations correctly
✔️ evaluate flag targeting integration > 1: evaluates optimized rule evaluations correctly
✔️ evaluate flag targeting integration > 2: evaluates optimized rule evaluations correctly
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should evaluate DATE_AFTER operator in flag rules
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should evaluate DATE_BEFORE operator in flag rules
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should handle complex rules with DATE_AFTER and DATE_BEFORE in groups
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should fail when DATE_AFTER condition is not met
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should fail when DATE_BEFORE condition is not met
✔️ evaluate flag targeting integration > DATE_AFTER and DATE_BEFORE in flag rules > should work with optimized evaluator
✔️ operator evaluation > evaluates 'value' IS 2024-01-10 minus value days = true
✔️ operator evaluation > evaluates 'value' IS 2024-01-10 minus wrong value days = false
✔️ operator evaluation > evaluates 'value' IS_NOT 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'value' IS_NOT 2024-01-10 minus wrong value days = true
✔️ operator evaluation > evaluates 'value' ANY_OF 2024-01-10 minus value days = true
✔️ operator evaluation > evaluates 'value' ANY_OF 2024-01-10 minus nope days = false
✔️ operator evaluation > evaluates 'value' NOT_ANY_OF 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'value' NOT_ANY_OF 2024-01-10 minus nope days = true
✔️ operator evaluation > evaluates 'value' IS_TRUE 2024-01-10 minus days = false
✔️ operator evaluation > evaluates 'value' IS_FALSE 2024-01-10 minus days = false
✔️ operator evaluation > evaluates 'value' SET 2024-01-10 minus days = true
✔️ operator evaluation > evaluates '' SET 2024-01-10 minus days = false
✔️ operator evaluation > evaluates 'value' NOT_SET 2024-01-10 minus days = false
✔️ operator evaluation > evaluates '' NOT_SET 2024-01-10 minus days = true
✔️ operator evaluation > evaluates 'value' GT 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'value' GT 2024-01-10 minus 0 days = false
✔️ operator evaluation > evaluates '1' GT 2024-01-10 minus 0 days = true
✔️ operator evaluation > evaluates '2' GT 2024-01-10 minus 10 days = false
✔️ operator evaluation > evaluates '10' GT 2024-01-10 minus 2 days = true
✔️ operator evaluation > evaluates 'value' LT 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'value' LT 2024-01-10 minus 0 days = false
✔️ operator evaluation > evaluates '0' LT 2024-01-10 minus 1 days = true
✔️ operator evaluation > evaluates '2' LT 2024-01-10 minus 10 days = true
✔️ operator evaluation > evaluates '10' LT 2024-01-10 minus 2 days = false
✔️ operator evaluation > evaluates 'start VALUE end' CONTAINS 2024-01-10 minus value days = true
✔️ operator evaluation > evaluates 'alue' CONTAINS 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'start VALUE end' NOT_CONTAINS 2024-01-10 minus value days = false
✔️ operator evaluation > evaluates 'alue' NOT_CONTAINS 2024-01-10 minus value days = true
✔️ operator evaluation > evaluates '2024-01-15' BEFORE 2024-01-10 minus 5 days = false
✔️ operator evaluation > evaluates '2024-01-15' AFTER 2024-01-10 minus 5 days = true
✔️ operator evaluation > evaluates '2024-01-01' BEFORE 2024-01-10 minus 5 days = true
✔️ operator evaluation > evaluates '2024-01-01' AFTER 2024-01-10 minus 5 days = false
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-15' DATE_AFTER '2024-01-10' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10' DATE_AFTER '2024-01-10' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-05' DATE_AFTER '2024-01-10' = false
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-12-31' DATE_AFTER '2024-01-01' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2023-01-01' DATE_AFTER '2024-01-01' = false
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-05' DATE_BEFORE '2024-01-10' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10' DATE_BEFORE '2024-01-10' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-15' DATE_BEFORE '2024-01-10' = false
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2023-01-01' DATE_BEFORE '2024-01-01' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-12-31' DATE_BEFORE '2024-01-01' = false
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10T10:30:00Z' DATE_AFTER '2024-01-10T10:00:00Z' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10T09:30:00Z' DATE_BEFORE '2024-01-10T10:00:00Z' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10T10:30:00.123Z' DATE_AFTER '2024-01-10T10:00:00.000Z' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '2024-01-10T09:30:00.123Z' DATE_BEFORE '2024-01-10T10:00:00.000Z' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '01/15/2024' DATE_AFTER '01/10/2024' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > evaluates '01/05/2024' DATE_BEFORE '01/10/2024' = true
✔️ operator evaluation > DATE_AFTER and DATE_BEFORE operators > handles invalid date formats gracefully
✔️ rollout hash > evaluates 'EEuoT8KShb' = 38026
✔️ rollout hash > evaluates 'h7BOkvks5W' = 81440
✔️ rollout hash > evaluates 'IZeSn3LCfJ' = 80149
✔️ rollout hash > evaluates 'jxYGR0k2eG' = 70348
✔️ rollout hash > evaluates 'VnaiKHgo1E' = 82432
✔️ rollout hash > evaluates 'I3R27J9tGN' = 88564
✔️ rollout hash > evaluates 'JoCeRRF5wm' = 67104
✔️ rollout hash > evaluates 'D9yQyxGKlc' = 90226
✔️ rollout hash > evaluates 'gvfTO4h4Je' = 98400
✔️ rollout hash > evaluates 'zF5iPhvJuw' = 53236
✔️ rollout hash > evaluates 'jMBqhV9Lzr' = 99182
✔️ rollout hash > evaluates 'HQtiM6m2sM' = 22123
✔️ rollout hash > evaluates 'O4VD9CdVMq' = 72700
✔️ rollout hash > evaluates 'lEI48g7tLX' = 46266
✔️ rollout hash > evaluates 's7sOvfaOQ3' = 57198
✔️ rollout hash > evaluates 'WuCAxrsjwT' = 12755
✔️ rollout hash > evaluates '1UIruKyifl' = 50838
✔️ rollout hash > evaluates 'f8Y0N3i97C' = 42372
✔️ rollout hash > evaluates 'rA57gcwaXG' = 44337
✔️ rollout hash > evaluates '5zNThaRQuB' = 33221
✔️ rollout hash > evaluates 'uLIHKFgFU2' = 49832
✔️ rollout hash > evaluates 'Dq29RMUKnK' = 75136
✔️ rollout hash > evaluates 'pNIWi69N81' = 21686
✔️ rollout hash > evaluates '2lJMZxGGwf' = 7747
✔️ rollout hash > evaluates 'vJHqCdZmo5' = 11319
✔️ rollout hash > evaluates 'qgDRZ2LFvu' = 91245
✔️ rollout hash > evaluates 'iWSiN2Jcad' = 13365
✔️ rollout hash > evaluates 'FTCF9ZRnIY' = 65642
✔️ rollout hash > evaluates 'WxsLfsrQNw' = 41778
✔️ rollout hash > evaluates '9HgMS79hrG' = 88627
✔️ rollout hash > evaluates 'BXrIz1JIiP' = 44341
✔️ rollout hash > evaluates 'oMtRltWl6T' = 85415
✔️ rollout hash > evaluates 'FKP9myTjTo' = 5059
✔️ rollout hash > evaluates 'fqlZoZ4PhD' = 91346
✔️ rollout hash > evaluates 'ohtHmrXWOB' = 45678
✔️ rollout hash > evaluates 'X7xh1uYeTU' = 96239
✔️ rollout hash > evaluates 'zXe7HkAtjC' = 25732
✔️ rollout hash > evaluates 'AnAZ1gugGv' = 62481
✔️ rollout hash > evaluates '0mfxv840GT' = 27268
✔️ rollout hash > evaluates 'eins7hyIvx' = 70954
✔️ rollout hash > evaluates 'es9Wkj86PO' = 48575
✔️ rollout hash > evaluates 'g3AZn8zuTe' = 44126
✔️ rollout hash > evaluates 'NHzNfl4ABW' = 63844
✔️ rollout hash > evaluates '0JZw2gHPg2' = 53707
✔️ rollout hash > evaluates 'GKHMJ46sT9' = 17572
✔️ rollout hash > evaluates 'ZHEpl9s0kN' = 59526
✔️ rollout hash > evaluates 'wSMTYbrr75' = 26396
✔️ rollout hash > evaluates '0WEJv16LYd' = 94865
✔️ rollout hash > evaluates 'dxV85hJ5t3' = 96945
✔️ rollout hash > evaluates '00d1uypkKy' = 38988
✔️ flattenJSON > should handle an empty object correctly
✔️ flattenJSON > should flatten a simple object
✔️ flattenJSON > should flatten nested objects
✔️ flattenJSON > should handle mixed data types
✔️ flattenJSON > should flatten arrays
✔️ flattenJSON > should handle empty arrays
✔️ flattenJSON > should correctly flatten mixed structures involving arrays and objects
✔️ flattenJSON > should flatten deeply nested objects
✔️ flattenJSON > should handle objects with empty values
✔️ flattenJSON > should handle null values
✔️ flattenJSON > should skip undefined values
✔️ flattenJSON > should handle empty nested objects
✔️ flattenJSON > should handle top-level primitive values
✔️ flattenJSON > should handle arrays with null and undefined values
✔️ flattenJSON > should handle deeply nested empty structures
✔️ flattenJSON > should handle keys with special characters
✔️ flattenJSON > should handle edge case numbers and booleans
✔️ unflattenJSON > should handle an empty object correctly
✔️ unflattenJSON > should convert a flat object with one level deep keys to a nested object
✔️ unflattenJSON > should not handle arrays properly
✔️ unflattenJSON > should handle mixed data types in flat JSON
✔️ unflattenJSON > should correctly handle scenarios with overlapping keys (ignore)
✔️ unflattenJSON > should unflatten nested objects correctly
✔️ unflattenJSON > should handle a scenario where a key is an empty string
✔️ ./packages/node-sdk/junit.xml
179 tests were completed in 10s with 179 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/batch-buffer.test.ts | 11✔️ | 126ms | ||
| test/client.test.ts | 91✔️ | 9s | ||
| test/config.test.ts | 2✔️ | 3ms | ||
| test/fetch-http-client.test.ts | 8✔️ | 421ms | ||
| test/flusher.test.ts | 17✔️ | 65ms | ||
| test/inRequestCache.test.ts | 6✔️ | 17ms | ||
| test/periodicallyUpdatingCache.test.ts | 7✔️ | 20ms | ||
| test/rate-limiter.test.ts | 5✔️ | 8ms | ||
| test/utils.test.ts | 32✔️ | 57ms |
✔️ test/batch-buffer.test.ts
test/batch-buffer.test.ts
✔️ BatchBuffer > constructor > should throw an error if options are invalid
✔️ BatchBuffer > constructor > should initialize with specified values
✔️ BatchBuffer > constructor > should initialize with default values if not provided
✔️ BatchBuffer > add > should add item to the buffer and flush immediately if maxSize is reached
✔️ BatchBuffer > add > should set a flush timer if buffer does not reach maxSize
✔️ BatchBuffer > flush > should not do anything if there are no items to flush
✔️ BatchBuffer > flush > calling flush simultaneously should only flush data once
✔️ BatchBuffer > flush > should flush buffer
✔️ BatchBuffer > flush > should log correctly during flush
✔️ BatchBuffer > timer logic > should start the normal timer when adding first item
✔️ BatchBuffer > timer logic > should stop the normal timer if flushed manually
✔️ test/client.test.ts
test/client.test.ts
✔️ ReflagClient > constructor > should initialize with no options
✔️ ReflagClient > constructor > should accept fallback flags as an array
✔️ ReflagClient > constructor > should accept fallback flags as an object
✔️ ReflagClient > constructor > should create a client instance with valid options
✔️ ReflagClient > constructor > should route messages to the supplied logger
✔️ ReflagClient > constructor > should create a client instance with default values for optional fields
✔️ ReflagClient > constructor > should throw an error if options are invalid
✔️ ReflagClient > constructor > should create a new flag events rate-limiter
✔️ ReflagClient > constructor > should not register an exit flush handler if `batchOptions.flushOnExit` is false
✔️ ReflagClient > constructor > should not register an exit flush handler if `offline` is true
✔️ ReflagClient > constructor > should register an exit flush handler if `batchOptions.flushOnExit` is `undefined`
✔️ ReflagClient > constructor > should register an exit flush handler if `batchOptions.flushOnExit` is `true`
✔️ ReflagClient > constructor > should build the URLs correctly https://api.example.com -> https://api.example.com/bulk
✔️ ReflagClient > constructor > should build the URLs correctly https://api.example.com/ -> https://api.example.com/bulk
✔️ ReflagClient > constructor > should build the URLs correctly https://api.example.com/path -> https://api.example.com/path/bulk
✔️ ReflagClient > constructor > should build the URLs correctly https://api.example.com/path/ -> https://api.example.com/path/bulk
✔️ ReflagClient > bindClient > should return a new client instance with the `user`, `company` and `other` set
✔️ ReflagClient > bindClient > should update user in Reflag when called
✔️ ReflagClient > bindClient > should update company in Reflag when called
✔️ ReflagClient > bindClient > should not update `company` or `user` in Reflag when `enableTracking` is `false`
✔️ ReflagClient > bindClient > should throw an error if `user` is invalid
✔️ ReflagClient > bindClient > should throw an error if `company` is invalid
✔️ ReflagClient > bindClient > should throw an error if `other` is invalid
✔️ ReflagClient > bindClient > should throw an error if `enableTracking` is invalid
✔️ ReflagClient > bindClient > should allow context without id
✔️ ReflagClient > updateUser > should successfully update the user
✔️ ReflagClient > updateUser > should successfully update the user
✔️ ReflagClient > updateUser > should log an error if the post request throws
✔️ ReflagClient > updateUser > should log if API call returns false
✔️ ReflagClient > updateUser > should throw an error if opts are not valid or the user is not set
✔️ ReflagClient > updateCompany > should successfully update the company
✔️ ReflagClient > updateCompany > should successfully update the company
✔️ ReflagClient > updateCompany > should log an error if the post request throws
✔️ ReflagClient > updateCompany > should log an error if API responds with success: false
✔️ ReflagClient > updateCompany > should throw an error if company is not valid
✔️ ReflagClient > track > should successfully track the flag usage
✔️ ReflagClient > track > should successfully track the flag usage
✔️ ReflagClient > track > should successfully track the flag usage including user and company
✔️ ReflagClient > track > should log an error if the post request fails
✔️ ReflagClient > track > should log if the API call returns false
✔️ ReflagClient > track > should log if user is not set
✔️ ReflagClient > track > should throw an error if event is invalid
✔️ ReflagClient > user > should return the undefined if user was not set
✔️ ReflagClient > user > should return the user if user was associated
✔️ ReflagClient > company > should return the undefined if company was not set
✔️ ReflagClient > company > should return the user if company was associated
✔️ ReflagClient > otherContext > should return the undefined if custom context was not set
✔️ ReflagClient > otherContext > should return the user if custom context was associated
✔️ ReflagClient > initialize > should initialize the client
✔️ ReflagClient > initialize > should call the backend to obtain flags
✔️ ReflagClient > flush > should flush all bulk data
✔️ ReflagClient > flush > should not flush all bulk data if `offline` is true
✔️ ReflagClient > getFlag > returns a flag
✔️ ReflagClient > getFlag > `track` sends all expected events when `enableTracking` is `true`
✔️ ReflagClient > getFlag > `track` does not send evaluation events when `emitEvaluationEvents` is `false`
✔️ ReflagClient > getFlag > `isEnabled` sends `check` event
✔️ ReflagClient > getFlag > `isEnabled` warns about missing context fields
✔️ ReflagClient > getFlag > `isEnabled` should not warn about missing context fields if not needed
✔️ ReflagClient > getFlag > `config` sends `check` event
✔️ ReflagClient > getFlag > sends events for unknown flags
✔️ ReflagClient > getFlag > sends company/user and track events
✔️ ReflagClient > getFlags > should return evaluated flags
✔️ ReflagClient > getFlags > should properly define the rate limiter key
✔️ ReflagClient > getFlags > should return evaluated flags when only user is defined
✔️ ReflagClient > getFlags > should return evaluated flags when only company is defined
✔️ ReflagClient > getFlags > should not send flag events when `enableTracking` is `false`
✔️ ReflagClient > getFlags > should return evaluated flags when only other context is defined
✔️ ReflagClient > getFlags > should send `track` with user and company if provided
✔️ ReflagClient > getFlags > should send `track` with user if provided
✔️ ReflagClient > getFlags > should not send `track` with only company if no user is provided
✔️ ReflagClient > getFlags > `isEnabled` does not send `check` event
✔️ ReflagClient > getFlags > `config` does not send `check` event
✔️ ReflagClient > getFlags > sends company/user events
✔️ ReflagClient > getFlags > should use fallback flags when `getFlagDefinitions` returns `undefined`
✔️ ReflagClient > getFlags > should not fail if sendFlagEvent fails to send evaluate event
✔️ ReflagClient > getFlags > should not fail if sendFlagEvent fails to send check event
✔️ ReflagClient > getFlags > should use flag overrides
✔️ ReflagClient > getFlags > should use flag overrides from function
✔️ ReflagClient > getFlagsRemote > should return evaluated flags
✔️ ReflagClient > getFlagsRemote > should not try to append the context if it's empty
✔️ ReflagClient > getFlagRemote > should return evaluated flag
✔️ ReflagClient > getFlagRemote > should not try to append the context if it's empty
✔️ ReflagClient > offline mode > should send not send or fetch anything
✔️ BoundReflagClient > should create a client instance
✔️ BoundReflagClient > should return a new client instance with merged attributes
✔️ BoundReflagClient > should allow using expected methods when bound to user
✔️ BoundReflagClient > should add company ID from the context if not explicitly supplied
✔️ BoundReflagClient > should disable tracking within the client if `enableTracking` is `false`
✔️ BoundReflagClient > should allow using expected methods
✔️ BoundReflagClient > getFlagRemote/getFlagsRemote > should return evaluated flags
✔️ BoundReflagClient > getFlagRemote/getFlagsRemote > should return evaluated flag
✔️ test/config.test.ts
test/config.test.ts
✔️ config tests > should load config file
✔️ config tests > should load ENV VARS
✔️ test/fetch-http-client.test.ts
test/fetch-http-client.test.ts
✔️ fetchClient > should make a POST request and return the response
✔️ fetchClient > should make a GET request and return the response
✔️ fetchClient > should timeout a POST request that takes too long
✔️ fetchClient > should timeout a GET request that takes too long
✔️ fetchClient > should handle POST non-20x responses
✔️ fetchClient > should handle GET non-20x responses
✔️ fetchClient > should not handle POST exceptions
✔️ fetchClient > should not handle GET exceptions
✔️ test/flusher.test.ts
test/flusher.test.ts
✔️ flusher > signal handling > signal SIGINT > should handle signal with no existing listeners
✔️ flusher > signal handling > signal SIGINT > should prepend handler when listeners exist
✔️ flusher > signal handling > signal SIGTERM > should handle signal with no existing listeners
✔️ flusher > signal handling > signal SIGTERM > should prepend handler when listeners exist
✔️ flusher > signal handling > signal SIGHUP > should handle signal with no existing listeners
✔️ flusher > signal handling > signal SIGHUP > should prepend handler when listeners exist
✔️ flusher > signal handling > signal SIGBREAK > should handle signal with no existing listeners
✔️ flusher > signal handling > signal SIGBREAK > should prepend handler when listeners exist
✔️ flusher > beforeExit handling > should call callback on beforeExit
✔️ flusher > beforeExit handling > should not call callback multiple times
✔️ flusher > timeout handling > should handle timeout when callback takes too long
✔️ flusher > timeout handling > should not timeout when callback completes in time
✔️ flusher > exit state handling > should log error if exit occurs before flushing starts
✔️ flusher > exit state handling > should log error if exit occurs before flushing completes
✔️ flusher > exit state handling > should not log error if flushing completes before exit
✔️ flusher > exit state handling > should handle callback errors gracefully
✔️ flusher > should run the callback only once
✔️ test/inRequestCache.test.ts
test/inRequestCache.test.ts
✔️ inRequestCache > should update the cached value when refreshing
✔️ inRequestCache > should not allow multiple refreses at the same time
✔️ inRequestCache > should warn if the cached value is stale
✔️ inRequestCache > should handle update failures gracefully
✔️ inRequestCache > should retain the cached value if the new value is undefined
✔️ inRequestCache > should not update if cached value is still valid
✔️ test/periodicallyUpdatingCache.test.ts
test/periodicallyUpdatingCache.test.ts
✔️ cache > should update the cached value when refreshing
✔️ cache > should not allow multiple refreses at the same time
✔️ cache > should warn if the cached value is stale
✔️ cache > should update the cached value after ttl
✔️ cache > should handle update failures gracefully
✔️ cache > should retain the cached value if the new value is undefined
✔️ cache > should not update if cached value is still valid
✔️ test/rate-limiter.test.ts
test/rate-limiter.test.ts
✔️ rateLimiter > isAllowed > should rate limit
✔️ rateLimiter > isAllowed > should reset the limit in given time
✔️ rateLimiter > isAllowed > should measure events separately by key
✔️ rateLimiter > clearStale > should clear expired events, but keep non-expired
✔️ rateLimiter > should periodically clean up expired keys
✔️ test/utils.test.ts
test/utils.test.ts
✔️ isObject > should return true for an object
✔️ isObject > should return false for an array
✔️ isObject > should return false for a string
✔️ isObject > should return false for a number
✔️ isObject > should return false for a boolean
✔️ isObject > should return false for null
✔️ isObject > should return false for undefined
✔️ ok > should throw an error if the condition is false
✔️ ok > should not throw an error if the condition is true
✔️ decorateLogger > should decorate the logger
✔️ decorateLogger > should throw an error if the prefix is not a string
✔️ decorateLogger > should throw an error if the logger is not an object
✔️ mergeSkipUndefined > merges two objects with no undefined values
✔️ mergeSkipUndefined > merges two objects where the source has undefined values
✔️ mergeSkipUndefined > merges two objects where the target has undefined values
✔️ mergeSkipUndefined > merges two objects where both have undefined values
✔️ mergeSkipUndefined > merges two empty objects
✔️ hashObject > should throw if the given value is not an object
✔️ hashObject > should return consistent hash for same object content
✔️ hashObject > should return different hash for different objects
✔️ hashObject > should correctly hash nested objects
✔️ hashObject > should hash arrays within objects
✔️ once() > should call the function only once with void return value
✔️ once() > should call the function only once
✔️ withTimeout() > should resolve when promise completes before timeout
✔️ withTimeout() > should reject with TimeoutError when promise takes too long
✔️ withTimeout() > should propagate original promise rejection
✔️ withTimeout() > should reject immediately for negative timeout
✔️ withTimeout() > should reject immediately for zero timeout
✔️ withTimeout() > should clean up timeout when promise resolves
✔️ withTimeout() > should clean up timeout when promise rejects
✔️ withTimeout() > should not resolve after timeout occurs
✔️ ./packages/openfeature-browser-provider/junit.xml
27 tests were completed in 1s with 27 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| src/index.test.ts | 27✔️ | 26ms |
✔️ src/index.test.ts
src/index.test.ts
✔️ ReflagBrowserSDKProvider > lifecycle > should call initialize function with correct arguments
✔️ ReflagBrowserSDKProvider > lifecycle > should set the status to READY if initialization succeeds
✔️ ReflagBrowserSDKProvider > lifecycle > should call stop function when provider is closed
✔️ ReflagBrowserSDKProvider > lifecycle > onContextChange re-initializes client
✔️ ReflagBrowserSDKProvider > contextTranslator > uses contextTranslatorFn if provided
✔️ ReflagBrowserSDKProvider > contextTranslator > defaultContextTranslator provides the correct context
✔️ ReflagBrowserSDKProvider > contextTranslator > defaultContextTranslator uses targetingKey if provided
✔️ ReflagBrowserSDKProvider > resolving flags > returns error if provider is not initialized
✔️ ReflagBrowserSDKProvider > resolving flags > returns error if flag is not found
✔️ ReflagBrowserSDKProvider > resolving flags > calls the client correctly when evaluating
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating boolean. enabled: true, value: false, default: true, expected: TARGETING_MATCH, reason: undefined, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating boolean. enabled: undefined, value: true, default: true, expected: ERROR, reason: FLAG_NOT_FOUND, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating boolean. enabled: undefined, value: false, default: false, expected: ERROR, reason: FLAG_NOT_FOUND, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return error when evaluating number
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating string. variant: key-1, def: default, expected: key-1, reason: TARGETING_MATCH, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating string. variant: null, def: default, expected: default, reason: DEFAULT, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating string. variant: undefined, def: default, expected: default, reason: DEFAULT, errorCode: %s`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: one, value: {}, default: { a: 1 }, expected: {}, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: two, value: string, default: default, expected: string, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: three, value: 15, default: 16, expected: 15, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: four, value: true, default: true, expected: true, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: five, value: 100, default: string, expected: string, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: six, value: 1337, default: true, expected: true, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: seven, value: string, default: 1337, expected: 1337, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: undefined, value: null, default: { a: 2 }, expected: { a: 2 }, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagBrowserSDKProvider > resolving flags > should return the correct result when evaluating object. variant: undefined, value: undefined, default: a, expected: a, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagBrowserSDKProvider > track > calls the client correctly for track calls
✔️ ./packages/openfeature-node-provider/junit.xml
28 tests were completed in 537ms with 28 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| src/index.test.ts | 28✔️ | 21ms |
✔️ src/index.test.ts
src/index.test.ts
✔️ ReflagNodeProvider > contextTranslator > defaultContextTranslator provides the correct context
✔️ ReflagNodeProvider > contextTranslator > defaultContextTranslator uses targetingKey if provided
✔️ ReflagNodeProvider > lifecycle > calls the constructor of ReflagClient
✔️ ReflagNodeProvider > lifecycle > should set the status to READY if initialization succeeds
✔️ ReflagNodeProvider > lifecycle > should keep the status as READY after closing
✔️ ReflagNodeProvider > lifecycle > calls flush when provider is closed
✔️ ReflagNodeProvider > lifecycle > uses the contextTranslator function
✔️ ReflagNodeProvider > resolving flags > returns error if provider is not initialized
✔️ ReflagNodeProvider > resolving flags > returns error if flag is not found
✔️ ReflagNodeProvider > resolving flags > calls the client correctly when evaluating
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating boolean. enabled: true, value: false, default: true, expected: TARGETING_MATCH, reason: undefined, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating boolean. enabled: undefined, value: true, default: true, expected: ERROR, reason: FLAG_NOT_FOUND, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating boolean. enabled: undefined, value: false, default: false, expected: ERROR, reason: FLAG_NOT_FOUND, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return error when context is missing user ID
✔️ ReflagNodeProvider > resolving flags > should return error when evaluating number
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating string. variant: key-1, def: default, expected: key-1, reason: TARGETING_MATCH, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating string. variant: null, def: default, expected: default, reason: DEFAULT, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating string. variant: undefined, def: default, expected: default, reason: DEFAULT, errorCode: %s`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: {}, default: { a: 1 }, expected: {}, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: string, default: default, expected: string, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: 15, default: -15, expected: 15, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: true, default: false, expected: true, reason: TARGETING_MATCH, errorCode: undefined`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: null, default: { a: 2 }, expected: { a: 2 }, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: 100, default: string, expected: string, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: true, default: 1337, expected: 1337, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: string, default: 1337, expected: 1337, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagNodeProvider > resolving flags > should return the correct result when evaluating object. payload: undefined, default: default, expected: default, reason: ERROR, errorCode: TYPE_MISMATCH`
✔️ ReflagNodeProvider > track > should track
✔️ ./packages/react-sdk/junit.xml
13 tests were completed in 3s with 13 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/usage.test.tsx | 13✔️ | 887ms |
✔️ test/usage.test.tsx
test/usage.test.tsx
✔️ <ReflagProvider /> > calls initialize
✔️ <ReflagProvider /> > only calls init once with the same args
✔️ <ReflagProvider /> > resets loading state when context changes
✔️ useFlag > returns a loading state initially
✔️ useFlag > finishes loading
✔️ useFlag > provides the expected values if flag is enabled
✔️ useTrack > sends track request
✔️ useSendFeedback > sends feedback
✔️ useRequestFeedback > sends feedback
✔️ useUpdateUser > updates user
✔️ useUpdateCompany > updates company
✔️ useUpdateOtherContext > updates other context
✔️ useClient > gets the client
✔️ ./packages/vue-sdk/junit.xml
2 tests were completed in 2s with 2 passed, 0 failed and 0 skipped.
| Test suite | Passed | Failed | Skipped | Time |
|---|---|---|---|---|
| test/usage.test.ts | 2✔️ | 26ms |
✔️ test/usage.test.ts
test/usage.test.ts
✔️ ReflagProvider > provides the client
✔️ ReflagProvider > throws without provider
Loading