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
  ✔️ ReflagClient > bootstrap parameter > should use pre-fetched flags and skip initialization when flags are provided

test/flagCache.test.ts
  ✔️ cache > caches items
  ✔️ cache > sets stale
  ✔️ cache > expires on set

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 > ignores overrides for flags not returned by API
  ✔️ FlagsClient > pre-fetched flags > should have flags available when bootstrapped flags are provided in constructor
  ✔️ FlagsClient > pre-fetched flags > should skip fetching when already initialized with pre-fetched flags
  ✔️ FlagsClient > pre-fetched flags > should trigger onUpdated when pre-fetched flags are set
  ✔️ FlagsClient > pre-fetched flags > should work with fallback flags when initialization fails

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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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

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 quote object keys with special characters
  ✔️ 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
  ✔️ JSON utilities > quoteKey > should quote keys with special characters

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

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
  ✔️ 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 > `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 check event
  ✔️ ReflagClient > getFlags > should use flag overrides
  ✔️ ReflagClient > getFlags > should use flag overrides from function
  ✔️ ReflagClient > getFlagsForBootstrap > should return raw flags without wrapper functions
  ✔️ ReflagClient > getFlagsForBootstrap > should return raw flags when only user is defined
  ✔️ ReflagClient > getFlagsForBootstrap > should return raw flags when only company is defined
  ✔️ ReflagClient > getFlagsForBootstrap > should return raw flags when only other context is defined
  ✔️ ReflagClient > getFlagsForBootstrap > should return fallback flags when client is not initialized
  ✔️ ReflagClient > getFlagsForBootstrap > should return fallback flags when flag definitions are not available
  ✔️ ReflagClient > getFlagsForBootstrap > should handle enableTracking parameter
  ✔️ ReflagClient > getFlagsForBootstrap > should properly define the rate limiter key
  ✔️ ReflagClient > getFlagsForBootstrap > should work in offline mode
  ✔️ ReflagClient > getFlagsForBootstrap > should use fallback flags when provided and no definitions available
  ✔️ getFlagsRemote > should return evaluated flags
  ✔️ getFlagsRemote > should not try to append the context if it's empty
  ✔️ getFlagRemote > should return evaluated flag
  ✔️ getFlagRemote > should not try to append the context if it's empty
  ✔️ 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 > should return raw flags for bootstrap from bound client
  ✔️ BoundReflagClient > getFlagRemote/getFlagsRemote > should return evaluated flags
  ✔️ BoundReflagClient > getFlagRemote/getFlagsRemote > should return evaluated flag

test/config.test.ts
  ✔️ config tests > should load config file
  ✔️ config tests > should load ENV VARS

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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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
  ✔️ 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

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

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

test/usage.test.tsx
  ✔️ <ReflagProvider /> > calls initialize
  ✔️ <ReflagProvider /> > only calls init once with the same args
  ✔️ <ReflagProvider /> > handles 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
  ✔️ <ReflagBootstrappedProvider /> > renders with pre-fetched flags
  ✔️ <ReflagBootstrappedProvider /> > renders in bootstrap mode
  ✔️ <ReflagBootstrappedProvider /> > shows content after initialization
  ✔️ useFlag with ReflagBootstrappedProvider > returns bootstrapped flag values
  ✔️ useFlag with ReflagBootstrappedProvider > returns disabled flag for non-existent flags
  ✔️ <ReflagClientProvider /> > renders with external client and optional loadingComponent
  ✔️ <ReflagClientProvider /> > renders with external client and loadingComponent
  ✔️ <ReflagClientProvider /> > provides client to child components
  ✔️ <ReflagClientProvider /> > handles client state changes
  ✔️ <ReflagClientProvider /> > works with useFlag hook
  ✔️ ReflagProvider with deprecated properties > works with deprecated user property
  ✔️ ReflagProvider with deprecated properties > works with deprecated company property
  ✔️ ReflagProvider with deprecated properties > works with deprecated otherContext property
  ✔️ ReflagProvider with deprecated properties > context property overrides deprecated properties
  ✔️ ReflagProvider with deprecated properties > merges deprecated properties with context
  ✔️ ReflagProvider with deprecated properties > handles all deprecated properties together
  ✔️ useIsLoading > returns loading state during initialization
  ✔️ useIsLoading > throws error when used outside provider
  ✔️ useOnEvent > subscribes to flagsUpdated event
  ✔️ useOnEvent > works with external client parameter
  ✔️ useOnEvent > cleans up event listeners on unmount
  ✔️ useOnEvent > throws error when used outside provider without client parameter
  ✔️ useOnEvent > handles multiple event subscriptions

test/usage.test.ts
  ✔️ ReflagProvider > provides the client
  ✔️ ReflagProvider > throws without provider
  ✔️ ReflagBootstrappedProvider > provides the client with bootstrapped flags