togglecraft 1.0.0

data/spec/togglecraft/connection_pool_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+RSpec.describe ToggleCraft::ConnectionPool do
+  let(:config) do
+    {
+      url: 'https://test.togglecraft.io',
+      sdk_key: 'test-key-123',
+      share_connection: true
+    }
+  end
+
+  after do
+    described_class.clear(force: true)
+  end
+
+  describe '.generate_pool_key' do
+    it 'generates key from url and sdk_key' do
+      key = described_class.generate_pool_key(config)
+      expect(key).to eq('https://test.togglecraft.io:test-key-123')
+    end
+
+    it 'uses custom connection_pool_key if provided' do
+      config_with_custom_key = config.merge(connection_pool_key: 'custom-key')
+      key = described_class.generate_pool_key(config_with_custom_key)
+      expect(key).to eq('custom-key')
+    end
+
+    it 'uses default URL when not provided' do
+      config_without_url = { sdk_key: 'test-key' }
+      key = described_class.generate_pool_key(config_without_url)
+      expect(key).to eq('https://sse.togglecraft.io:test-key')
+    end
+  end
+
+  describe '.get_connection' do
+    it 'returns nil when share_connection is false' do
+      config_no_share = config.merge(share_connection: false)
+      connection = described_class.get_connection(config_no_share)
+      expect(connection).to be_nil
+    end
+
+    it 'creates a new shared connection' do
+      connection = described_class.get_connection(config)
+      expect(connection).to be_a(ToggleCraft::SharedSSEConnection)
+    end
+
+    it 'reuses existing connection for same pool key' do
+      conn1 = described_class.get_connection(config)
+      conn2 = described_class.get_connection(config)
+      expect(conn1).to eq(conn2)
+    end
+
+    it 'creates different connections for different pool keys' do
+      config2 = config.merge(sdk_key: 'different-key')
+
+      conn1 = described_class.get_connection(config)
+      conn2 = described_class.get_connection(config2)
+
+      expect(conn1).not_to eq(conn2)
+    end
+
+    it 'sets up empty callback to clean up connection' do
+      connection = described_class.get_connection(config)
+
+      # Trigger the empty callback
+      connection.instance_variable_get(:@on_empty_callback).call
+
+      # Connection should be removed from pool
+      pool_key = described_class.generate_pool_key(config)
+      expect(described_class.has_connection?(pool_key)).to be false
+    end
+  end
+
+  describe '.stats' do
+    it 'returns stats with no connections' do
+      stats = described_class.stats
+      expect(stats[:total_connections]).to eq(0)
+      expect(stats[:connections]).to eq([])
+    end
+
+    it 'returns stats for existing connections' do
+      described_class.get_connection(config)
+
+      stats = described_class.stats
+      expect(stats[:total_connections]).to eq(1)
+      expect(stats[:connections].length).to eq(1)
+      expect(stats[:connections].first[:key]).to eq('https://test.togglecraft.io:test-key-123')
+    end
+  end
+
+  describe '.clear' do
+    it 'clears all connections' do
+      described_class.get_connection(config)
+      described_class.clear
+
+      expect(described_class.connection_count).to eq(0)
+    end
+
+    it 'force disconnects when force flag is true' do
+      connection = described_class.get_connection(config)
+      expect(connection).to receive(:force_disconnect)
+
+      described_class.clear(force: true)
+    end
+
+    it 'does not force disconnect when force flag is false' do
+      connection = described_class.get_connection(config)
+      expect(connection).not_to receive(:force_disconnect)
+
+      described_class.clear(force: false)
+    end
+  end
+
+  describe '.connection_count' do
+    it 'returns 0 with no connections' do
+      expect(described_class.connection_count).to eq(0)
+    end
+
+    it 'returns count of active connections' do
+      described_class.get_connection(config)
+      described_class.get_connection(config.merge(sdk_key: 'key2'))
+
+      expect(described_class.connection_count).to eq(2)
+    end
+  end
+
+  describe '.total_client_count' do
+    it 'returns 0 with no connections' do
+      expect(described_class.total_client_count).to eq(0)
+    end
+
+    it 'returns total clients across all connections' do
+      conn1 = described_class.get_connection(config)
+      conn2 = described_class.get_connection(config.merge(sdk_key: 'key2'))
+
+      # Mock client counts
+      allow(conn1).to receive(:client_count).and_return(3)
+      allow(conn2).to receive(:client_count).and_return(2)
+
+      expect(described_class.total_client_count).to eq(5)
+    end
+  end
+
+  describe '.has_connection?' do
+    it 'returns false for non-existent pool key' do
+      expect(described_class.has_connection?('missing-key')).to be false
+    end
+
+    it 'returns true for existing pool key' do
+      described_class.get_connection(config)
+      pool_key = described_class.generate_pool_key(config)
+
+      expect(described_class.has_connection?(pool_key)).to be true
+    end
+  end
+
+  describe '.get_connection_by_key' do
+    it 'returns nil for non-existent key' do
+      expect(described_class.get_connection_by_key('missing')).to be_nil
+    end
+
+    it 'returns connection for existing key' do
+      connection = described_class.get_connection(config)
+      pool_key = described_class.generate_pool_key(config)
+
+      expect(described_class.get_connection_by_key(pool_key)).to eq(connection)
+    end
+  end
+
+  describe '.set_debug' do
+    it 'enables debug on existing connections' do
+      connection = described_class.get_connection(config)
+      expect(connection).to receive(:set_debug).with(true)
+
+      described_class.set_debug(true)
+    end
+  end
+end

data/spec/togglecraft/evaluator_spec.rb

@@ -0,0 +1,443 @@
+# frozen_string_literal: true
+
+RSpec.describe ToggleCraft::Evaluator do
+  let(:evaluator) { described_class.new }
+
+  describe '#update_flags' do
+    it 'stores flag data' do
+      flags = {
+        'test-flag' => { type: 'boolean', enabled: true, value: true }
+      }
+      evaluator.update_flags(flags)
+      expect(evaluator.has_flag?('test-flag')).to be true
+    end
+
+    it 'clears existing flags before updating' do
+      evaluator.update_flags({ 'flag1' => { type: 'boolean' } })
+      evaluator.update_flags({ 'flag2' => { type: 'boolean' } })
+
+      expect(evaluator.has_flag?('flag1')).to be false
+      expect(evaluator.has_flag?('flag2')).to be true
+    end
+  end
+
+  describe '#evaluate_boolean' do
+    before do
+      evaluator.update_flags({
+                               'simple-boolean' => {
+                                 type: 'boolean',
+                                 enabled: true,
+                                 value: true
+                               },
+                               'disabled-flag' => {
+                                 type: 'boolean',
+                                 enabled: false,
+                                 value: true
+                               },
+                               'flag-with-rules' => {
+                                 type: 'boolean',
+                                 enabled: true,
+                                 value: false,
+                                 rules: [
+                                   {
+                                     conditions: [
+                                       { attribute: 'user.role', operator: 'equals', values: ['admin'] }
+                                     ],
+                                     value: true
+                                   }
+                                 ]
+                               }
+                             })
+    end
+
+    it 'returns true for enabled boolean flag' do
+      result = evaluator.evaluate_boolean('simple-boolean')
+      expect(result).to be true
+    end
+
+    it 'returns false for disabled flag' do
+      result = evaluator.evaluate_boolean('disabled-flag')
+      expect(result).to be false
+    end
+
+    it 'returns default value for non-existent flag' do
+      result = evaluator.evaluate_boolean('missing', {}, false)
+      expect(result).to be false
+
+      result = evaluator.evaluate_boolean('missing', {}, true)
+      expect(result).to be true
+    end
+
+    it 'evaluates targeting rules' do
+      admin_context = { user: { role: 'admin' } }
+      user_context = { user: { role: 'user' } }
+
+      expect(evaluator.evaluate_boolean('flag-with-rules', admin_context)).to be true
+      expect(evaluator.evaluate_boolean('flag-with-rules', user_context)).to be false
+    end
+
+    it 'warns and returns default for wrong flag type' do
+      evaluator.update_flags({
+                               'multivariate-flag' => { type: 'multivariate', enabled: true }
+                             })
+
+      expect do
+        result = evaluator.evaluate_boolean('multivariate-flag', {}, false)
+        expect(result).to be false
+      end.to output(/not a boolean flag/).to_stderr
+    end
+  end
+
+  describe '#evaluate_multivariate' do
+    before do
+      evaluator.update_flags({
+                               'ab-test' => {
+                                 type: 'multivariate',
+                                 enabled: true,
+                                 default_variant: 'control',
+                                 variants: %w[control variant-a variant-b],
+                                 weights: { 'control' => 50, 'variant-a' => 30, 'variant-b' => 20 }
+                               },
+                               'disabled-multivariate' => {
+                                 type: 'multivariate',
+                                 enabled: false,
+                                 default_variant: 'control'
+                               },
+                               'rule-based-variant' => {
+                                 type: 'multivariate',
+                                 enabled: true,
+                                 default_variant: 'control',
+                                 rules: [
+                                   {
+                                     conditions: [
+                                       { attribute: 'user.plan', operator: 'equals', values: ['premium'] }
+                                     ],
+                                     variant: 'premium-variant'
+                                   }
+                                 ]
+                               }
+                             })
+    end
+
+    it 'returns variant based on weights with consistent hashing' do
+      context = { user: { id: 'user-123' } }
+
+      # Should return same variant for same user
+      variant1 = evaluator.evaluate_multivariate('ab-test', context)
+      variant2 = evaluator.evaluate_multivariate('ab-test', context)
+
+      expect(variant1).to eq(variant2)
+      expect(%w[control variant-a variant-b]).to include(variant1)
+    end
+
+    it 'returns default value parameter for disabled flag' do
+      result = evaluator.evaluate_multivariate('disabled-multivariate', {}, 'my-default')
+      expect(result).to eq('my-default')
+    end
+
+    it 'evaluates targeting rules' do
+      premium_context = { user: { plan: 'premium' } }
+      free_context = { user: { plan: 'free' } }
+
+      expect(evaluator.evaluate_multivariate('rule-based-variant', premium_context)).to eq('premium-variant')
+      expect(evaluator.evaluate_multivariate('rule-based-variant', free_context)).to eq('control')
+    end
+
+    it 'returns default value for non-existent flag' do
+      result = evaluator.evaluate_multivariate('missing', {}, 'default')
+      expect(result).to eq('default')
+    end
+  end
+
+  describe '#evaluate_percentage' do
+    before do
+      evaluator.update_flags({
+                               'rollout-50' => {
+                                 type: 'percentage',
+                                 enabled: true,
+                                 percentage: 50
+                               },
+                               'rollout-0' => {
+                                 type: 'percentage',
+                                 enabled: true,
+                                 percentage: 0
+                               },
+                               'rollout-100' => {
+                                 type: 'percentage',
+                                 enabled: true,
+                                 percentage: 100
+                               },
+                               'disabled-rollout' => {
+                                 type: 'percentage',
+                                 enabled: false,
+                                 percentage: 100
+                               },
+                               'rollout-with-rules' => {
+                                 type: 'percentage',
+                                 enabled: true,
+                                 percentage: 10,
+                                 rules: [
+                                   {
+                                     conditions: [
+                                       { attribute: 'user.beta_tester', operator: 'equals', values: ['true'] }
+                                     ],
+                                     enabled: true
+                                   }
+                                 ]
+                               }
+                             })
+    end
+
+    it 'returns false for 0% rollout' do
+      result = evaluator.evaluate_percentage('rollout-0', { user: { id: '123' } })
+      expect(result).to be false
+    end
+
+    it 'returns true for 100% rollout' do
+      result = evaluator.evaluate_percentage('rollout-100', { user: { id: '123' } })
+      expect(result).to be true
+    end
+
+    it 'returns consistent results for same user' do
+      context = { user: { id: 'user-456' } }
+
+      result1 = evaluator.evaluate_percentage('rollout-50', context)
+      result2 = evaluator.evaluate_percentage('rollout-50', context)
+
+      expect(result1).to eq(result2)
+    end
+
+    it 'distributes users across percentage' do
+      # Test with many users to verify distribution
+      users_in_rollout = 0
+      100.times do |i|
+        context = { user: { id: "user-#{i}" } }
+        users_in_rollout += 1 if evaluator.evaluate_percentage('rollout-50', context)
+      end
+
+      # Should be approximately 50% (allow 20% variance for small sample)
+      expect(users_in_rollout).to be_between(30, 70)
+    end
+
+    it 'returns false for disabled flag' do
+      result = evaluator.evaluate_percentage('disabled-rollout', { user: { id: '123' } })
+      expect(result).to be false
+    end
+
+    it 'evaluates targeting rules' do
+      beta_context = { user: { id: '1', beta_tester: 'true' } }
+      normal_context = { user: { id: '2', beta_tester: 'false' } }
+
+      expect(evaluator.evaluate_percentage('rollout-with-rules', beta_context)).to be true
+      # Normal user depends on hash, just verify it doesn't error
+      evaluator.evaluate_percentage('rollout-with-rules', normal_context)
+    end
+  end
+
+  describe '#current_percentage_for_flag' do
+    it 'returns base percentage when no rollout stages' do
+      flag = { type: 'percentage', percentage: 50, rollout_stages: [] }
+      expect(evaluator.current_percentage_for_flag(flag)).to eq(50)
+    end
+
+    it 'returns active stage percentage when stage is active' do
+      now = Time.now
+      flag = {
+        type: 'percentage',
+        percentage: 10,
+        rollout_stages: [
+          {
+            percentage: 50,
+            start_at: (now - 3600).iso8601, # Started 1 hour ago
+            end_at: (now + 3600).iso8601 # Ends in 1 hour
+          }
+        ]
+      }
+
+      expect(evaluator.current_percentage_for_flag(flag)).to eq(50)
+    end
+
+    it 'returns base percentage when no stage is active' do
+      now = Time.now
+      flag = {
+        type: 'percentage',
+        percentage: 10,
+        rollout_stages: [
+          {
+            percentage: 50,
+            start_at: (now + 3600).iso8601, # Starts in 1 hour
+            end_at: (now + 7200).iso8601 # Ends in 2 hours
+          }
+        ]
+      }
+
+      expect(evaluator.current_percentage_for_flag(flag)).to eq(10)
+    end
+
+    it 'uses most recent active stage when multiple are active' do
+      now = Time.now
+      flag = {
+        type: 'percentage',
+        percentage: 10,
+        rollout_stages: [
+          {
+            percentage: 30,
+            start_at: (now - 7200).iso8601,
+            end_at: (now + 3600).iso8601
+          },
+          {
+            percentage: 50,
+            start_at: (now - 3600).iso8601,
+            end_at: (now + 3600).iso8601
+          }
+        ]
+      }
+
+      expect(evaluator.current_percentage_for_flag(flag)).to eq(50)
+    end
+  end
+
+  describe '#evaluate_rule' do
+    it 'returns true when all AND conditions pass' do
+      rule = {
+        conditions: [
+          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'AND' },
+          { attribute: 'user.active', operator: 'equals', values: ['true'], combinator: 'AND' }
+        ]
+      }
+      context = { user: { role: 'admin', active: 'true' } }
+
+      expect(evaluator.evaluate_rule(rule, context)).to be true
+    end
+
+    it 'returns false when any AND condition fails' do
+      rule = {
+        conditions: [
+          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'AND' },
+          { attribute: 'user.active', operator: 'equals', values: ['true'], combinator: 'AND' }
+        ]
+      }
+      context = { user: { role: 'admin', active: 'false' } }
+
+      expect(evaluator.evaluate_rule(rule, context)).to be false
+    end
+
+    it 'returns true when any OR condition passes' do
+      rule = {
+        conditions: [
+          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'OR' },
+          { attribute: 'user.role', operator: 'equals', values: ['superuser'], combinator: 'OR' }
+        ]
+      }
+      context = { user: { role: 'superuser' } }
+
+      expect(evaluator.evaluate_rule(rule, context)).to be true
+    end
+
+    it 'handles mixed AND/OR combinators' do
+      rule = {
+        conditions: [
+          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'OR' },
+          { attribute: 'user.department', operator: 'equals', values: ['engineering'], combinator: 'AND' },
+          { attribute: 'user.level', operator: 'gt', values: ['5'] }
+        ]
+      }
+
+      # admin OR (engineering AND level > 5)
+      # admin in engineering with level > 5 -> true (admin alone is enough)
+      context1 = { user: { role: 'admin', department: 'engineering', level: '6' } }
+      expect(evaluator.evaluate_rule(rule, context1)).to be true
+
+      # Not admin but in engineering with level > 5 -> true
+      context2 = { user: { role: 'user', department: 'engineering', level: '6' } }
+      expect(evaluator.evaluate_rule(rule, context2)).to be true
+
+      # admin but not in engineering -> true (admin alone is enough)
+      context3 = { user: { role: 'admin', department: 'sales', level: '3' } }
+      expect(evaluator.evaluate_rule(rule, context3)).to be true
+
+      # Not admin, in engineering but level <= 5 -> false
+      context4 = { user: { role: 'user', department: 'engineering', level: '3' } }
+      expect(evaluator.evaluate_rule(rule, context4)).to be false
+    end
+
+    it 'returns false for empty conditions' do
+      rule = { conditions: [] }
+      expect(evaluator.evaluate_rule(rule, {})).to be false
+    end
+  end
+
+  describe 'helper methods' do
+    before do
+      evaluator.update_flags({
+                               'test-flag' => { type: 'boolean', enabled: true },
+                               'another-flag' => { type: 'multivariate', enabled: true }
+                             })
+    end
+
+    describe '#has_flag?' do
+      it 'returns true for existing flags' do
+        expect(evaluator.has_flag?('test-flag')).to be true
+      end
+
+      it 'returns false for non-existent flags' do
+        expect(evaluator.has_flag?('missing')).to be false
+      end
+    end
+
+    describe '#flag_keys' do
+      it 'returns all flag keys' do
+        keys = evaluator.flag_keys
+        expect(keys).to contain_exactly('test-flag', 'another-flag')
+      end
+    end
+
+    describe '#flag_metadata' do
+      it 'returns metadata for boolean flag' do
+        metadata = evaluator.flag_metadata('test-flag')
+        expect(metadata[:type]).to eq('boolean')
+        expect(metadata[:enabled]).to be true
+      end
+
+      it 'returns nil for non-existent flag' do
+        expect(evaluator.flag_metadata('missing')).to be_nil
+      end
+    end
+  end
+
+  describe '#evaluate' do
+    before do
+      evaluator.update_flags({
+                               'bool-flag' => { type: 'boolean', enabled: true, value: true },
+                               'multi-flag' => { type: 'multivariate', enabled: true, default_variant: 'control' },
+                               'percent-flag' => { type: 'percentage', enabled: true, percentage: 100 }
+                             })
+    end
+
+    it 'delegates to evaluate_boolean for boolean flags' do
+      result = evaluator.evaluate('bool-flag', {}, false)
+      expect(result).to be true
+    end
+
+    it 'delegates to evaluate_multivariate for multivariate flags' do
+      result = evaluator.evaluate('multi-flag', {}, nil)
+      expect(result).to eq('control')
+    end
+
+    it 'delegates to evaluate_percentage for percentage flags' do
+      result = evaluator.evaluate('percent-flag', { user: { id: '123' } }, false)
+      expect(result).to be true
+    end
+
+    it 'returns default for unknown flag type' do
+      evaluator.update_flags({
+                               'unknown-type' => { type: 'unknown', enabled: true }
+                             })
+
+      expect do
+        result = evaluator.evaluate('unknown-type', {}, 'default')
+        expect(result).to eq('default')
+      end.to output(/Unknown flag type/).to_stderr
+    end
+  end
+end