mixpanel-ruby 2.3.0 → 3.0.0

data/spec/mixpanel-ruby/flags/remote_flags_spec.rb

@@ -0,0 +1,441 @@
+require 'json'
+require 'mixpanel-ruby/flags/remote_flags_provider'
+require 'mixpanel-ruby/flags/types'
+require 'webmock/rspec'
+
+describe Mixpanel::Flags::RemoteFlagsProvider do
+  let(:test_token) { 'test-token' }
+  let(:test_context) { { 'distinct_id' => 'user123' } }
+  let(:endpoint_url_regex) { %r{https://api\.mixpanel\.com/flags} }
+  let(:mock_tracker) { double('tracker').as_null_object }
+  let(:mock_error_handler) { double('error_handler', handle: nil) }
+  let(:config) { {} }
+
+  let(:provider) do
+    Mixpanel::Flags::RemoteFlagsProvider.new(
+      test_token,
+      config,
+      mock_tracker,
+      mock_error_handler
+    )
+  end
+
+  before(:each) do
+    WebMock.reset!
+    WebMock.disable_net_connect!(allow_localhost: false)
+  end
+
+  def create_success_response(flags_with_selected_variant)
+    {
+      code: 200,
+      flags: flags_with_selected_variant
+    }
+  end
+
+  def stub_flags_request(response_body)
+    stub_request(:get, endpoint_url_regex)
+      .to_return(
+        status: 200,
+        body: response_body.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+
+  end
+
+  def stub_flags_request_failure(status_code)
+    stub_request(:get, endpoint_url_regex)
+      .with(basic_auth: [test_token, ''])
+      .to_return(status: status_code)
+  end
+
+  def stub_flags_request_error(error)
+    stub_request(:get, endpoint_url_regex)
+      .with(basic_auth: [test_token, ''])
+      .to_raise(error)
+  end
+
+  describe '#get_variant_value' do
+    it 'returns fallback value if call fails' do
+      stub_flags_request_error(Errno::ECONNREFUSED)
+
+      result = provider.get_variant_value('test_flag', 'control', test_context)
+      expect(result).to eq('control')
+    end
+
+    it 'returns fallback value if bad response format' do
+      stub_request(:get, %r{api\.mixpanel\.com/flags})
+        .to_return(
+          status: 200,
+          body: 'invalid json',
+          headers: { 'Content-Type' => 'text/plain' }
+        )
+
+      result = provider.get_variant_value('test_flag', 'control', test_context)
+      expect(result).to eq('control')
+    end
+
+    it 'returns fallback value if success but no flag found' do
+      stub_flags_request(create_success_response({}))
+
+      result = provider.get_variant_value('test_flag', 'control', test_context)
+      expect(result).to eq('control')
+    end
+
+    it 'returns expected variant from API' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 'treatment'
+        }
+      })
+      stub_flags_request(response)
+
+      result = provider.get_variant_value('test_flag', 'control', test_context)
+      expect(result).to eq('treatment')
+    end
+
+    it 'tracks exposure event if variant selected' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 'treatment'
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).to receive(:call).once
+
+      provider.get_variant_value('test_flag', 'control', test_context)
+    end
+
+    it 'does not track exposure event if fallback' do
+      stub_flags_request_error(Errno::ECONNREFUSED)
+
+      expect(mock_tracker).not_to receive(:call)
+
+      provider.get_variant_value('test_flag', 'control', test_context)
+    end
+
+    it 'does not track exposure event when report_exposure is false' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 'treatment'
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).not_to receive(:call)
+
+      provider.get_variant_value('test_flag', 'control', test_context, report_exposure: false)
+    end
+
+    it 'handles different variant value types' do
+      # Test string
+      response = create_success_response({
+        'string_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 'text-value'
+        }
+      })
+      stub_flags_request(response)
+      result = provider.get_variant_value('string_flag', 'default', test_context, report_exposure: false)
+      expect(result).to eq('text-value')
+
+      # Test number
+      WebMock.reset!
+      response = create_success_response({
+        'number_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 42
+        }
+      })
+      stub_flags_request(response)
+      result = provider.get_variant_value('number_flag', 0, test_context, report_exposure: false)
+      expect(result).to eq(42)
+
+      # Test object
+      WebMock.reset!
+      response = create_success_response({
+        'object_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => { 'key' => 'value' }
+        }
+      })
+      stub_flags_request(response)
+      result = provider.get_variant_value('object_flag', {}, test_context, report_exposure: false)
+      expect(result).to eq({ 'key' => 'value' })
+    end
+  end
+
+  describe '#get_variant' do
+    it 'returns variant when served' do
+      response = create_success_response({
+        'new-feature' => {
+          'variant_key' => 'on',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      fallback_variant = Mixpanel::Flags::SelectedVariant.new(variant_value: false)
+      result = provider.get_variant('new-feature', fallback_variant, test_context, report_exposure: false)
+
+      expect(result.variant_key).to eq('on')
+      expect(result.variant_value).to eq(true)
+    end
+
+    it 'selects fallback variant when no flags are served' do
+      stub_flags_request(create_success_response({}))
+
+      fallback_variant = Mixpanel::Flags::SelectedVariant.new(
+        variant_key: 'control',
+        variant_value: false
+      )
+      result = provider.get_variant('any-flag', fallback_variant, test_context)
+
+      expect(result.variant_key).to eq('control')
+      expect(result.variant_value).to eq(false)
+      expect(mock_tracker).not_to have_received(:call)
+    end
+
+    it 'selects fallback variant if flag does not exist in served flags' do
+      response = create_success_response({
+        'different-flag' => {
+          'variant_key' => 'on',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      fallback_variant = Mixpanel::Flags::SelectedVariant.new(
+        variant_key: 'control',
+        variant_value: false
+      )
+      result = provider.get_variant('missing-flag', fallback_variant, test_context)
+
+      expect(result.variant_key).to eq('control')
+      expect(result.variant_value).to eq(false)
+      expect(mock_tracker).not_to have_received(:call)
+    end
+
+    it 'tracks exposure event when variant is selected' do
+      response = create_success_response({
+        'test-flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      fallback_variant = Mixpanel::Flags::SelectedVariant.new(
+        variant_key: 'control',
+        variant_value: false
+      )
+
+      expect(mock_tracker).to receive(:call) do |distinct_id, event_name, properties|
+        expect(distinct_id).to eq('user123')
+        expect(event_name).to eq('$experiment_started')
+        expect(properties['Experiment name']).to eq('test-flag')
+        expect(properties['Variant name']).to eq('treatment')
+        expect(properties['$experiment_type']).to eq('feature_flag')
+        expect(properties['Flag evaluation mode']).to eq('remote')
+      end
+
+      provider.get_variant('test-flag', fallback_variant, test_context)
+    end
+
+    it 'does not track exposure event when fallback variant is selected' do
+      stub_flags_request(create_success_response({}))
+
+      fallback_variant = Mixpanel::Flags::SelectedVariant.new(
+        variant_key: 'control',
+        variant_value: false
+      )
+
+      expect(mock_tracker).not_to receive(:call)
+
+      provider.get_variant('any-flag', fallback_variant, test_context)
+    end
+  end
+
+  describe '#is_enabled' do
+    it 'returns true when variant value is boolean true' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'on',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      result = provider.is_enabled?('test_flag', test_context)
+      expect(result).to eq(true)
+    end
+
+    it 'returns false when variant value is boolean false' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'off',
+          'variant_value' => false
+        }
+      })
+      stub_flags_request(response)
+
+      result = provider.is_enabled?('test_flag', test_context)
+      expect(result).to eq(false)
+    end
+
+    it 'returns false for truthy non-boolean values' do
+      # Test string "true"
+      response = create_success_response({
+        'string_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 'true'
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).to receive(:call).once
+      result = provider.is_enabled?('string_flag', test_context)
+      expect(result).to eq(false)
+
+      # Test number 1
+      WebMock.reset!
+      response = create_success_response({
+        'number_flag' => {
+          'variant_key' => 'treatment',
+          'variant_value' => 1
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).to receive(:call).once
+      result = provider.is_enabled?('number_flag', test_context)
+      expect(result).to eq(false)
+    end
+
+    it 'returns false when flag does not exist' do
+      response = create_success_response({
+        'different-flag' => {
+          'variant_key' => 'on',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      result = provider.is_enabled?('missing-flag', test_context)
+      expect(result).to eq(false)
+    end
+
+    it 'tracks exposure event' do
+      response = create_success_response({
+        'test_flag' => {
+          'variant_key' => 'on',
+          'variant_value' => true
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).to receive(:call) do |distinct_id, event_name, properties|
+        expect(event_name).to eq('$experiment_started')
+        expect(properties['Experiment name']).to eq('test_flag')
+        expect(properties['Variant name']).to eq('on')
+      end
+
+      provider.is_enabled?('test_flag', test_context)
+    end
+
+    it 'returns false on network error' do
+      stub_flags_request_error(Errno::ECONNREFUSED)
+
+      result = provider.is_enabled?('test_flag', test_context)
+      expect(result).to eq(false)
+    end
+  end
+
+  describe '#get_all_variants' do
+    it 'returns all variants from API' do
+      response = create_success_response({
+        'flag-1' => {
+          'variant_key' => 'treatment',
+          'variant_value' => true
+        },
+        'flag-2' => {
+          'variant_key' => 'control',
+          'variant_value' => false
+        },
+        'flag-3' => {
+          'variant_key' => 'blue',
+          'variant_value' => 'blue-theme'
+        }
+      })
+      stub_flags_request(response)
+
+      result = provider.get_all_variants(test_context)
+
+      expect(result.keys).to contain_exactly('flag-1', 'flag-2', 'flag-3')
+      expect(result['flag-1'].variant_key).to eq('treatment')
+      expect(result['flag-1'].variant_value).to eq(true)
+      expect(result['flag-2'].variant_key).to eq('control')
+      expect(result['flag-2'].variant_value).to eq(false)
+      expect(result['flag-3'].variant_key).to eq('blue')
+      expect(result['flag-3'].variant_value).to eq('blue-theme')
+    end
+
+    it 'returns empty hash when no flags served' do
+      stub_flags_request(create_success_response({}))
+
+      result = provider.get_all_variants(test_context)
+
+      expect(result).to eq({})
+    end
+
+    it 'does not track any exposure events' do
+      response = create_success_response({
+        'flag-1' => {
+          'variant_key' => 'treatment',
+          'variant_value' => true
+        },
+        'flag-2' => {
+          'variant_key' => 'control',
+          'variant_value' => false
+        }
+      })
+      stub_flags_request(response)
+
+      expect(mock_tracker).not_to receive(:call)
+
+      provider.get_all_variants(test_context)
+    end
+
+    it 'returns nil on network error' do
+      stub_flags_request_error(Errno::ECONNREFUSED)
+
+      result = provider.get_all_variants(test_context)
+
+      expect(result).to be_nil
+    end
+
+    it 'handles empty response' do
+      stub_flags_request(create_success_response({}))
+
+      result = provider.get_all_variants(test_context)
+
+      expect(result).to eq({})
+    end
+  end
+
+  describe '#track_exposure_event' do
+    it 'successfully tracks' do
+      variant = Mixpanel::Flags::SelectedVariant.new(
+        variant_key: 'treatment',
+        variant_value: 'treatment'
+      )
+
+      expect(mock_tracker).to receive(:call).once
+
+      provider.send(:track_exposure_event, 'test_flag', variant, test_context)
+    end
+  end
+end

data/spec/mixpanel-ruby/flags/utils_spec.rb

@@ -0,0 +1,110 @@
+require 'rspec'
+require 'mixpanel-ruby/flags/utils'
+
+describe Mixpanel::Flags::Utils do
+  describe '.generate_traceparent' do
+    it 'should generate traceparent in W3C format' do
+      traceparent = Mixpanel::Flags::Utils.generate_traceparent
+
+      # W3C traceparent format: 00-{32 hex chars}-{16 hex chars}-01
+      # https://www.w3.org/TR/trace-context/#traceparent-header
+      pattern = /^00-[0-9a-f]{32}-[0-9a-f]{16}-01$/
+
+      expect(traceparent).to match(pattern)
+    end
+  end
+
+  describe '.normalized_hash' do
+    def expect_valid_hash(hash)
+      expect(hash).to be_a(Float)
+      expect(hash).to be >= 0.0
+      expect(hash).to be < 1.0
+    end
+
+    it 'should match known test vectors' do
+      hash1 = Mixpanel::Flags::Utils.normalized_hash('abc', 'variant')
+      expect(hash1).to eq(0.72)
+
+      hash2 = Mixpanel::Flags::Utils.normalized_hash('def', 'variant')
+      expect(hash2).to eq(0.21)
+    end
+
+    it 'should produce consistent results' do
+      hash1 = Mixpanel::Flags::Utils.normalized_hash('test_key', 'salt')
+      hash2 = Mixpanel::Flags::Utils.normalized_hash('test_key', 'salt')
+      hash3 = Mixpanel::Flags::Utils.normalized_hash('test_key', 'salt')
+
+      expect(hash1).to eq(hash2)
+      expect(hash2).to eq(hash3)
+    end
+
+    it 'should produce different hashes when salt is changed' do
+      hash1 = Mixpanel::Flags::Utils.normalized_hash('same_key', 'salt1')
+      hash2 = Mixpanel::Flags::Utils.normalized_hash('same_key', 'salt2')
+      hash3 = Mixpanel::Flags::Utils.normalized_hash('same_key', 'different_salt')
+
+      expect(hash1).not_to eq(hash2)
+      expect(hash1).not_to eq(hash3)
+      expect(hash2).not_to eq(hash3)
+    end
+
+    it 'should produce different hashes when order is changed' do
+      hash1 = Mixpanel::Flags::Utils.normalized_hash('abc', 'salt')
+      hash2 = Mixpanel::Flags::Utils.normalized_hash('bac', 'salt')
+      hash3 = Mixpanel::Flags::Utils.normalized_hash('cba', 'salt')
+
+      expect(hash1).not_to eq(hash2)
+      expect(hash1).not_to eq(hash3)
+      expect(hash2).not_to eq(hash3)
+    end
+
+    describe 'edge cases with empty strings' do
+      it 'should return valid hash for empty key' do
+        hash = Mixpanel::Flags::Utils.normalized_hash('', 'salt')
+        expect_valid_hash(hash)
+      end
+
+      it 'should return valid hash for empty salt' do
+        hash = Mixpanel::Flags::Utils.normalized_hash('key', '')
+        expect_valid_hash(hash)
+      end
+
+      it 'should return valid hash for both empty' do
+        hash = Mixpanel::Flags::Utils.normalized_hash('', '')
+        expect_valid_hash(hash)
+      end
+
+      it 'empty strings in different positions should produce different results' do
+        hash1 = Mixpanel::Flags::Utils.normalized_hash('', 'salt')
+        hash2 = Mixpanel::Flags::Utils.normalized_hash('key', '')
+        expect(hash1).not_to eq(hash2)
+      end
+    end
+
+    describe 'special characters' do
+      test_cases = [
+        { key: '🎉', description: 'emoji' },
+        { key: 'beyoncé', description: 'accented characters' },
+        { key: 'key@#$%^&*()', description: 'special symbols' },
+        { key: 'key with spaces', description: 'spaces' }
+      ]
+
+      test_cases.each do |test_case|
+        it "should return valid hash for #{test_case[:description]}" do
+          hash = Mixpanel::Flags::Utils.normalized_hash(test_case[:key], 'salt')
+          expect_valid_hash(hash)
+        end
+      end
+
+      it 'produces different results for different special characters' do
+        hashes = test_cases.map { |tc| Mixpanel::Flags::Utils.normalized_hash(tc[:key], 'salt') }
+
+        hashes.each_with_index do |hash1, i|
+          hashes.each_with_index do |hash2, j|
+            expect(hash1).not_to eq(hash2) if i != j
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mixpanel-ruby/groups_spec.rb

@@ -23,7 +23,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$set' => {
             '$groupname' => 'Mixpanel',
             '$grouprevenue' => 200
@@ -39,7 +39,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$set' => {
             'created_at' => '2013-01-02T03:04:05'
         }
@@ -54,7 +54,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$set' => {
             'created_at' => '2013-01-02T02:04:05'
         }
@@ -70,7 +70,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$set' => {
             'created_at' => '2013-01-02T02:04:05'
         }
@@ -86,7 +86,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$set_once' => {
             '$groupname' => 'Mixpanel',
             '$grouprevenue' => 200
@@ -102,7 +102,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$remove' => {
             'Albums' => 'Diamond Dogs'
         }
@@ -117,7 +117,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$union' => {
             'Albums' => ['Diamond Dogs']
         }
@@ -130,7 +130,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$unset' => ['Albums']
     }]])
   end
@@ -141,7 +141,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$unset' => ['Albums', 'Vinyls']
     }]])
   end
@@ -152,7 +152,7 @@ describe Mixpanel::Groups do
         '$token' => 'TEST TOKEN',
         '$group_key' => 'TEST GROUP KEY',
         '$group_id' => 'TEST GROUP ID',
-        '$time' => @time_now.to_i * 1000,
+        '$time' => (@time_now.to_f * 1000).to_i,
         '$delete' => ''
     }]])
   end

data/spec/mixpanel-ruby/tracker_spec.rb

@@ -29,7 +29,7 @@ describe Mixpanel::Tracker do
       'mp_lib' => 'ruby',
       '$lib_version' => Mixpanel::VERSION,
       'token' => 'TEST TOKEN',
-      'time' => @time_now.to_i
+      'time' => @time_now.to_i * 1000
     }
     expected_data = {'event' => event, 'properties' => properties.merge(default_properties)}
 
@@ -61,7 +61,7 @@ describe Mixpanel::Tracker do
       with { |req| body = req.body }
 
     message_urlencoded = body[/^data=(.*?)(?:&|$)/, 1]
-    message_json = Base64.strict_decode64(URI.unescape(message_urlencoded))
+    message_json = Base64.strict_decode64(CGI.unescape(message_urlencoded))
     message = JSON.load(message_json)
     expect(message).to eq({
         'event' => 'TEST EVENT',
@@ -71,7 +71,7 @@ describe Mixpanel::Tracker do
             'mp_lib' => 'ruby',
             '$lib_version' => Mixpanel::VERSION,
             'token' => 'TEST TOKEN',
-            'time' => @time_now.to_i
+            'time' => @time_now.to_i * 1000
         }
     })
   end
@@ -94,7 +94,7 @@ describe Mixpanel::Tracker do
               'mp_lib' => 'ruby',
               '$lib_version' => Mixpanel::VERSION,
               'token' => 'TEST TOKEN',
-              'time' => @time_now.to_i
+              'time' => @time_now.to_i * 1000
             }
           }
         ],
@@ -106,7 +106,7 @@ describe Mixpanel::Tracker do
                 'mp_lib' => 'ruby',
                 '$lib_version' => Mixpanel::VERSION,
                 'token' => 'TEST TOKEN',
-                'time' => @time_now.to_i
+                'time' => @time_now.to_i * 1000
               }
             },
             'api_key' => 'API_KEY',

data/spec/spec_helper.rb

@@ -1,3 +1,17 @@
+require 'simplecov'
+require 'simplecov-cobertura'
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/demo/'
+
+  # Generate both HTML and Cobertura XML formats since CodeCov typically requires XML
+  formatter SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::CoberturaFormatter
+  ])
+end
+
 require 'json'
 require 'webmock/rspec'