quonfig 0.0.2

data/test/test_semver.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+class TestSemanticVersion < Minitest::Test
+  def test_parse_valid_version
+    version = SemanticVersion.parse('1.2.3')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_nil version.prerelease
+    assert_nil version.build_metadata
+  end
+
+  def test_parse_version_with_prerelease
+    version = SemanticVersion.parse('1.2.3-alpha.1')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_equal 'alpha.1', version.prerelease
+    assert_nil version.build_metadata
+  end
+
+  def test_parse_version_with_build_metadata
+    version = SemanticVersion.parse('1.2.3+build.123')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_nil version.prerelease
+    assert_equal 'build.123', version.build_metadata
+  end
+
+  def test_parse_full_version
+    version = SemanticVersion.parse('1.2.3-alpha.1+build.123')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_equal 'alpha.1', version.prerelease
+    assert_equal 'build.123', version.build_metadata
+  end
+
+  def test_parse_invalid_version
+    assert_raises(ArgumentError) { SemanticVersion.parse('invalid') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('1.2') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('1.2.3.4') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('') }
+  end
+
+  def test_parse_quietly
+    assert_nil SemanticVersion.parse_quietly('invalid')
+    refute_nil SemanticVersion.parse_quietly('1.2.3')
+  end
+
+  def test_to_string
+    assert_equal '1.2.3', SemanticVersion.parse('1.2.3').to_s
+    assert_equal '1.2.3-alpha.1', SemanticVersion.parse('1.2.3-alpha.1').to_s
+    assert_equal '1.2.3+build.123', SemanticVersion.parse('1.2.3+build.123').to_s
+    assert_equal '1.2.3-alpha.1+build.123', SemanticVersion.parse('1.2.3-alpha.1+build.123').to_s
+  end
+
+  def test_equality
+    v1 = SemanticVersion.parse('1.2.3')
+    v2 = SemanticVersion.parse('1.2.3')
+    v3 = SemanticVersion.parse('1.2.4')
+    v4 = SemanticVersion.parse('1.2.3-alpha')
+    v5 = SemanticVersion.parse('1.2.3+build.123')
+
+    assert_equal v1, v2
+    refute_equal v1, v3
+    refute_equal v1, v4
+    assert_equal v1, v5  # build metadata is ignored in equality
+  end
+
+  def test_comparison
+    versions = [
+      '1.0.0-alpha',
+      '1.0.0-alpha.1',
+      '1.0.0-beta.2',
+      '1.0.0-beta.11',
+      '1.0.0-rc.1',
+      '1.0.0',
+      '2.0.0',
+      '2.1.0',
+      '2.1.1'
+    ].map { |v| SemanticVersion.parse(v) }
+
+    # Test that each version is less than the next version
+    (versions.length - 1).times do |i|
+      assert versions[i] < versions[i + 1], "Expected #{versions[i]} < #{versions[i + 1]}"
+    end
+  end
+
+  def test_prerelease_comparison
+    # Test specific prerelease comparison cases
+    cases = [
+      ['1.0.0-alpha', '1.0.0-alpha.1', -1],
+      ['1.0.0-alpha.1', '1.0.0-alpha.beta', -1],
+      ['1.0.0-alpha.beta', '1.0.0-beta', -1],
+      ['1.0.0-beta', '1.0.0-beta.2', -1],
+      ['1.0.0-beta.2', '1.0.0-beta.11', -1],
+      ['1.0.0-beta.11', '1.0.0-rc.1', -1],
+      ['1.0.0-rc.1', '1.0.0', -1]
+    ]
+
+    cases.each do |v1_str, v2_str, expected|
+      v1 = SemanticVersion.parse(v1_str)
+      v2 = SemanticVersion.parse(v2_str)
+      assert_equal expected, (v1 <=> v2), "Expected #{v1} <=> #{v2} to be #{expected}"
+    end
+  end
+end

data/test/test_sse_config_client.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'webrick'
+require 'ostruct'
+require 'json'
+
+class TestSSEConfigClient < Minitest::Test
+  def test_connect_url_is_api_v2_sse_config
+    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'test')
+    config_loader = OpenStruct.new(highwater_mark: 0)
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    captured_url = nil
+    fake = OpenStruct.new(closed?: false)
+    fake.define_singleton_method(:on_event) { |&_b| }
+    fake.define_singleton_method(:on_error) { |&_b| }
+    fake.define_singleton_method(:close) { }
+
+    SSE::Client.stub :new, ->(url, *_args, **_kwargs, &block) {
+      captured_url = url
+      block.call(fake) if block
+      fake
+    } do
+      client.connect { |_e, _ev, _s| }
+    end
+
+    assert_equal 'https://stream.example.com/api/v2/sse/config', captured_url
+  end
+
+  def test_on_event_parses_json_into_config_envelope
+    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'test')
+    config_loader = OpenStruct.new(highwater_mark: 0)
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    captured = {}
+    event_handler = nil
+    fake = Object.new
+    fake.define_singleton_method(:on_event) { |&block| event_handler = block }
+    fake.define_singleton_method(:on_error) { |&_b| }
+    fake.define_singleton_method(:close) { }
+    fake.define_singleton_method(:closed?) { false }
+
+    SSE::Client.stub :new, ->(*_args, **_kwargs, &block) {
+      block.call(fake) if block
+      fake
+    } do
+      client.connect do |envelope, event, source|
+        captured[:envelope] = envelope
+        captured[:event] = event
+        captured[:source] = source
+      end
+    end
+
+    json_data = JSON.generate({
+      configs: [{ key: 'my.key', valueType: 'string', default: { rules: [] } }],
+      meta: { version: 'abc123', environment: 'prod' }
+    })
+
+    event_handler.call(OpenStruct.new(data: json_data))
+
+    assert_instance_of Quonfig::ConfigEnvelope, captured[:envelope]
+    assert_equal 1, captured[:envelope].configs.length
+    assert_equal 'my.key', captured[:envelope].configs[0]['key']
+    assert_equal 'abc123', captured[:envelope].meta['version']
+    assert_equal :sse, captured[:source]
+  end
+
+  def test_headers_basic_auth_uses_1_prefix
+    prefab_options = OpenStruct.new(sse_api_urls: ['https://stream.example.com'], sdk_key: 'mykey')
+    config_loader = OpenStruct.new(highwater_mark: 0)
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    h = client.headers
+
+    assert_equal "Basic #{Base64.strict_encode64('1:mykey')}", h['Authorization']
+    assert_match(/\Asdk-ruby-/, h['X-Quonfig-SDK-Version'])
+    refute h.key?('X-Reforge-SDK-Version')
+  end
+
+  def test_recovering_from_disconnection
+    server, = start_webrick_server(4567, DisconnectingEndpoint)
+
+    config_loader = OpenStruct.new(highwater_mark: 4)
+
+    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4567'], sdk_key: 'test')
+    last_event_id = nil
+    client = nil
+
+    begin
+      Thread.new do
+        server.start
+      end
+
+      sse_options = Quonfig::SSEConfigClient::Options.new(
+        sse_default_reconnect_time: 0.1
+      )
+      client = Quonfig::SSEConfigClient.new(prefab_options, config_loader, sse_options)
+
+      client.start do |_configs, event, _source|
+        last_event_id = event.id.to_i
+      end
+
+      wait_for -> { last_event_id && last_event_id > 1 }
+    ensure
+      client.close
+      server.stop
+
+      refute_nil last_event_id, 'Expected to have received an event'
+      assert last_event_id > 1, 'Expected to have received multiple events (indicating a retry)'
+    end
+  end
+
+  def test_recovering_from_an_error
+    log_output = StringIO.new
+    logger = Logger.new(log_output)
+
+    server, = start_webrick_server(4568, ErroringEndpoint)
+
+    config_loader = OpenStruct.new(highwater_mark: 4)
+
+    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4568'], sdk_key: 'test')
+    last_event_id = nil
+    client = nil
+
+    begin
+      Thread.new do
+        server.start
+      end
+
+      sse_options = Quonfig::SSEConfigClient::Options.new(
+        sse_default_reconnect_time: 0.1,
+        seconds_between_new_connection: 0.1,
+        sleep_delay_for_new_connection_check: 0.1,
+        errors_to_close_connection: [SSE::Errors::HTTPStatusError]
+      )
+      client = Quonfig::SSEConfigClient.new(prefab_options, config_loader, sse_options, logger)
+
+      client.start do |_configs, event, _source|
+        last_event_id = event.id.to_i
+      end
+
+      wait_for -> { last_event_id && last_event_id > 2 }
+    ensure
+      server.stop
+      client.close
+
+      refute_nil last_event_id, 'Expected to have received an event'
+      assert last_event_id > 2, 'Expected to have received multiple events (indicating a reconnect)'
+    end
+
+    log_lines = log_output.string.split("\n")
+
+    assert_match(/SSE Streaming Connect/, log_lines[0])
+    assert_match(/SSE Streaming Error/, log_lines[1], 'Expected to have logged an error. If this starts failing after an ld-eventsource upgrade, you might need to tweak NUMBER_OF_FAILURES below')
+    assert_match(/Closing SSE connection/, log_lines[2])
+    assert_match(/Reconnecting SSE client/, log_lines[3])
+    assert_match(/SSE Streaming Connect/, log_lines[4])
+  end
+
+  def start_webrick_server(port, endpoint_class)
+    log_string = StringIO.new
+    logger = WEBrick::Log.new(log_string)
+    server = WEBrick::HTTPServer.new(Port: port, Logger: logger, AccessLog: [])
+    server.mount '/api/v2/sse', endpoint_class
+
+    [server, log_string]
+  end
+
+  module SharedEndpointLogic
+    def event_id
+      @@event_id ||= 0
+      @@event_id += 1
+    end
+
+    def setup_response(response)
+      response.status = 200
+      response['Content-Type'] = 'text/event-stream'
+      response['Cache-Control'] = 'no-cache'
+      response['Connection'] = 'keep-alive'
+
+      response.chunked = false
+    end
+  end
+
+  SAMPLE_JSON_PAYLOAD = '{"configs":[],"meta":{"version":"1","environment":"test"}}'
+
+  class DisconnectingEndpoint < WEBrick::HTTPServlet::AbstractServlet
+    include SharedEndpointLogic
+
+    def do_GET(_request, response)
+      setup_response(response)
+
+      output = response.body
+
+      output << "id: #{event_id}\n"
+      output << "event: message\n"
+      output << "data: #{SAMPLE_JSON_PAYLOAD}\n\n"
+    end
+  end
+
+  class ErroringEndpoint < WEBrick::HTTPServlet::AbstractServlet
+    include SharedEndpointLogic
+    NUMBER_OF_FAILURES = 5
+
+    def do_GET(_request, response)
+      setup_response(response)
+
+      output = response.body
+
+      output << "id: #{event_id}\n"
+
+      if event_id < NUMBER_OF_FAILURES
+        raise 'ErroringEndpoint' # This manifests as an SSE::Errors::HTTPStatusError
+      end
+
+      output << "event: message\n"
+      output << "data: #{SAMPLE_JSON_PAYLOAD}\n\n"
+    end
+  end
+
+  def test_empty_data_validation
+    # Unit test to verify that empty data is properly detected and handled
+    log_output = StringIO.new
+    logger = Logger.new(log_output)
+
+    # Test that empty event.data is detected
+    mock_event = OpenStruct.new(data: '')
+    mock_client = Minitest::Mock.new
+    mock_client.expect(:close, nil)
+
+    # Simulate the on_event handler logic
+    if mock_event.data.nil? || mock_event.data.empty?
+      logger.error "SSE Streaming Error: Received empty data for url http://test"
+      mock_client.close
+    end
+
+    log_lines = log_output.string.split("\n")
+    assert log_lines.any? { |line| line.include?('SSE Streaming Error') && line.include?('empty data') },
+           'Expected to have logged an error about empty data'
+    mock_client.verify
+
+    # Test that nil event.data is detected
+    log_output = StringIO.new
+    logger = Logger.new(log_output)
+    mock_event = OpenStruct.new(data: nil)
+    mock_client = Minitest::Mock.new
+    mock_client.expect(:close, nil)
+
+    if mock_event.data.nil? || mock_event.data.empty?
+      logger.error "SSE Streaming Error: Received empty data for url http://test"
+      mock_client.close
+    end
+
+    log_lines = log_output.string.split("\n")
+    assert log_lines.any? { |line| line.include?('SSE Streaming Error') && line.include?('empty data') },
+           'Expected to have logged an error about empty data for nil'
+    mock_client.verify
+  end
+
+  def test_last_event_id_initialization
+    # Test with positive highwater_mark
+    config_loader = OpenStruct.new(highwater_mark: 42)
+    prefab_options = OpenStruct.new(sse_api_urls: ['http://localhost:4567'], sdk_key: 'test')
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    # Mock SSE::Client.new to capture the last_event_id argument
+    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
+      assert_equal '42', kwargs[:last_event_id], 'Expected last_event_id to be "42"'
+      OpenStruct.new(closed?: false, close: nil)
+    } do
+      client.connect { |_configs, _event, _source| }
+    end
+
+    # Test with nil highwater_mark
+    config_loader = OpenStruct.new(highwater_mark: nil)
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
+      assert_nil kwargs[:last_event_id], 'Expected last_event_id to be nil when highwater_mark is nil'
+      OpenStruct.new(closed?: false, close: nil)
+    } do
+      client.connect { |_configs, _event, _source| }
+    end
+
+    # Test with zero highwater_mark
+    config_loader = OpenStruct.new(highwater_mark: 0)
+    client = Quonfig::SSEConfigClient.new(prefab_options, config_loader)
+
+    SSE::Client.stub :new, ->(*args, **kwargs, &block) {
+      assert_nil kwargs[:last_event_id], 'Expected last_event_id to be nil when highwater_mark is 0'
+      OpenStruct.new(closed?: false, close: nil)
+    } do
+      client.connect { |_configs, _event, _source| }
+    end
+  end
+end

data/test/test_typed_getters.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Typed getters (get_string / get_int / get_bool / get_string_list /
+# get_duration / get_json) on Quonfig::Client. Each verifies both the happy
+# path against an injected ConfigStore and the type-mismatch error path.
+class TestTypedGetters < Minitest::Test
+  KEY = 'my.key'
+
+  def make_config(value:, type:)
+    {
+      'id' => '1',
+      'key' => KEY,
+      'type' => 'config',
+      'valueType' => type,
+      'sendToClientSdk' => false,
+      'default' => {
+        'rules' => [
+          {
+            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
+            'value' => { 'type' => type, 'value' => value }
+          }
+        ]
+      },
+      'environment' => nil
+    }
+  end
+
+  def client_with_value(value:, type:)
+    store = Quonfig::ConfigStore.new
+    store.set(KEY, make_config(value: value, type: type))
+    Quonfig::Client.new(Quonfig::Options.new, store: store)
+  end
+
+  # ---- get_string -------------------------------------------------------
+
+  def test_get_string_returns_string
+    assert_equal 'hello', client_with_value(value: 'hello', type: 'string').get_string(KEY)
+  end
+
+  def test_get_string_raises_on_non_string
+    assert_raises(Quonfig::Errors::TypeMismatchError) do
+      client_with_value(value: 42, type: 'int').get_string(KEY)
+    end
+  end
+
+  def test_get_string_default_when_missing
+    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
+    assert_equal 'fallback', client.get_string('nope', default: 'fallback')
+  end
+
+  # ---- get_int ----------------------------------------------------------
+
+  def test_get_int_returns_integer
+    assert_equal 42, client_with_value(value: 42, type: 'int').get_int(KEY)
+  end
+
+  def test_get_int_raises_on_string
+    assert_raises(Quonfig::Errors::TypeMismatchError) do
+      client_with_value(value: 'oops', type: 'string').get_int(KEY)
+    end
+  end
+
+  # ---- get_float --------------------------------------------------------
+
+  def test_get_float_returns_float
+    assert_in_delta 3.14, client_with_value(value: 3.14, type: 'double').get_float(KEY), 0.0001
+  end
+
+  def test_get_float_raises_on_non_float
+    assert_raises(Quonfig::Errors::TypeMismatchError) do
+      client_with_value(value: 'oops', type: 'string').get_float(KEY)
+    end
+  end
+
+  # ---- get_bool ---------------------------------------------------------
+
+  def test_get_bool_returns_true
+    assert_equal true, client_with_value(value: true, type: 'bool').get_bool(KEY)
+  end
+
+  def test_get_bool_returns_false
+    assert_equal false, client_with_value(value: false, type: 'bool').get_bool(KEY)
+  end
+
+  def test_get_bool_raises_on_string
+    assert_raises(Quonfig::Errors::TypeMismatchError) do
+      client_with_value(value: 'true', type: 'string').get_bool(KEY)
+    end
+  end
+
+  # ---- get_string_list --------------------------------------------------
+
+  def test_get_string_list_returns_array_of_strings
+    assert_equal %w[a b c], client_with_value(value: %w[a b c], type: 'string_list').get_string_list(KEY)
+  end
+
+  def test_get_string_list_raises_on_non_array
+    assert_raises(Quonfig::Errors::TypeMismatchError) do
+      client_with_value(value: 'a,b,c', type: 'string').get_string_list(KEY)
+    end
+  end
+
+  # ---- get_duration -----------------------------------------------------
+
+  def test_get_duration_returns_milliseconds_for_iso_string
+    # ISO-8601 PT1S -> 1 second -> 1000 ms.
+    client = client_with_value(value: 'PT1S', type: 'duration')
+    assert_equal 1000, client.get_duration(KEY)
+  end
+
+  def test_get_duration_passes_through_numeric
+    client = client_with_value(value: 5000, type: 'int')
+    assert_equal 5000, client.get_duration(KEY)
+  end
+
+  # ---- get_json ---------------------------------------------------------
+
+  def test_get_json_returns_hash_unchanged
+    payload = { 'a' => 1, 'b' => [1, 2, 3] }
+    client = client_with_value(value: payload, type: 'json')
+    assert_equal payload, client.get_json(KEY)
+  end
+
+  def test_get_json_returns_array_unchanged
+    payload = [1, 2, 3]
+    client = client_with_value(value: payload, type: 'json')
+    assert_equal payload, client.get_json(KEY)
+  end
+end

data/test/test_types.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'json'
+require 'quonfig/types'
+
+class TestTypes < Minitest::Test
+  def test_value_holds_type_and_value
+    v = Quonfig::Value.new(type: 'double', value: '9.95')
+    assert_equal 'double', v.type
+    assert_equal '9.95', v.value
+    assert_nil v.confidential
+    assert_nil v.decrypt_with
+  end
+
+  def test_criterion_fields_accept_nil
+    c = Quonfig::Criterion.new(operator: 'ALWAYS_TRUE')
+    assert_equal 'ALWAYS_TRUE', c.operator
+    assert_nil c.property_name
+    assert_nil c.value_to_match
+  end
+
+  def test_rule_wires_criteria_and_value
+    value = Quonfig::Value.new(type: 'double', value: '9.95')
+    criterion = Quonfig::Criterion.new(operator: 'ALWAYS_TRUE')
+    rule = Quonfig::Rule.new(criteria: [criterion], value: value)
+    assert_equal [criterion], rule.criteria
+    assert_same value, rule.value
+  end
+
+  def test_rule_set_holds_rules_array
+    rs = Quonfig::RuleSet.new(rules: [])
+    assert_equal [], rs.rules
+  end
+
+  def test_environment_holds_id_and_rules
+    env = Quonfig::Environment.new(id: 'env-1', rules: [])
+    assert_equal 'env-1', env.id
+    assert_equal [], env.rules
+  end
+
+  def test_meta_optional_workspace_id
+    meta = Quonfig::Meta.new(version: '1', environment: 'production')
+    assert_nil meta.workspace_id
+  end
+
+  def test_weighted_value_and_weighted_values_data
+    wv = Quonfig::WeightedValue.new(weight: 100, value: Quonfig::Value.new(type: 'bool', value: true))
+    assert_equal 100, wv.weight
+    wvd = Quonfig::WeightedValuesData.new(weighted_values: [wv])
+    assert_equal [wv], wvd.weighted_values
+    assert_nil wvd.hash_by_property_name
+  end
+
+  def test_schema_data
+    sd = Quonfig::SchemaData.new(schema_type: 'zod', schema: 'z.string()')
+    assert_equal 'zod', sd.schema_type
+    assert_equal 'z.string()', sd.schema
+  end
+
+  def test_provided_data
+    pd = Quonfig::ProvidedData.new(source: 'ENV_VAR', lookup: 'DATABASE_URL')
+    assert_equal 'ENV_VAR', pd.source
+    assert_equal 'DATABASE_URL', pd.lookup
+  end
+
+  def test_config_response_from_integration_fixture
+    path = File.expand_path(
+      '../../integration-test-data/data/integration-tests/configs/my-double-key.json',
+      __dir__
+    )
+    skip "integration-test-data not present at #{path}" unless File.exist?(path)
+
+    raw = JSON.parse(File.read(path))
+    default_rules = raw.fetch('default').fetch('rules').map do |rule|
+      criteria = rule.fetch('criteria').map do |c|
+        Quonfig::Criterion.new(
+          property_name: c['propertyName'],
+          operator: c.fetch('operator'),
+          value_to_match: c['valueToMatch']
+        )
+      end
+      value = rule.fetch('value')
+      Quonfig::Rule.new(
+        criteria: criteria,
+        value: Quonfig::Value.new(type: value['type'], value: value['value'])
+      )
+    end
+
+    response = Quonfig::ConfigResponse.new(
+      id: raw.fetch('id'),
+      key: raw.fetch('key'),
+      type: raw.fetch('type'),
+      value_type: raw.fetch('valueType'),
+      send_to_client_sdk: raw.fetch('sendToClientSdk'),
+      default: Quonfig::RuleSet.new(rules: default_rules)
+    )
+
+    assert_equal 'my-double-key', response.key
+    assert_equal 'config', response.type
+    assert_equal 'double', response.value_type
+    refute response.send_to_client_sdk
+    assert_nil response.environment
+    assert_equal 1, response.default.rules.length
+
+    rule = response.default.rules.first
+    assert_equal 'ALWAYS_TRUE', rule.criteria.first.operator
+    assert_equal 'double', rule.value.type
+    assert_equal '9.95', rule.value.value
+  end
+
+  def test_config_envelope_carries_configs_and_meta
+    meta = Quonfig::Meta.new(version: '1', environment: 'production')
+    envelope = Quonfig::ConfigEnvelope.new(configs: [], meta: meta)
+    assert_equal [], envelope.configs
+    assert_same meta, envelope.meta
+  end
+
+  def test_workspace_config_document_fields
+    doc = Quonfig::WorkspaceConfigDocument.new(
+      id: 'id-1',
+      key: 'feature.x',
+      type: 'feature_flag',
+      value_type: 'bool',
+      send_to_client_sdk: true,
+      default: Quonfig::RuleSet.new(rules: []),
+      environments: []
+    )
+    assert_equal 'feature.x', doc.key
+    assert_equal 'feature_flag', doc.type
+    assert_equal 'bool', doc.value_type
+    assert doc.send_to_client_sdk
+    assert_equal [], doc.environments
+  end
+
+  def test_workspace_environment_fields
+    we = Quonfig::WorkspaceEnvironment.new(id: 'env-1', rules: [])
+    assert_equal 'env-1', we.id
+    assert_equal [], we.rules
+  end
+end