mixpanel-ruby 3.0.0 → 3.2.0

data/spec/mixpanel-ruby/consumer_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 require 'webmock'
 
 require 'mixpanel-ruby/consumer'
+require 'mixpanel-ruby/credentials'
 
 describe Mixpanel::Consumer do
   before { WebMock.reset! }
@@ -95,6 +96,56 @@ describe Mixpanel::Consumer do
     it_behaves_like 'consumer'
   end
 
+  context 'service account credentials' do
+    it 'should send a request to api.mixpanel.com/import with service account credentials' do
+      stub_request(:any, 'https://api.mixpanel.com/import?project_id=test-project-123').to_return({:body => '{"status": 1, "error": null}'})
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project-123')
+      consumer = Mixpanel::Consumer.new(nil, nil, nil, nil, credentials: credentials)
+
+      consumer.send!(:import, {'data' => 'TEST EVENT MESSAGE'}.to_json)
+
+      # Should use Basic Auth header with username:secret
+      # Should add project_id as query parameter
+      # Should NOT include credentials in POST body or message
+      expect(WebMock).to have_requested(:post, 'https://api.mixpanel.com/import?project_id=test-project-123').
+        with(
+          :body => {
+            'data' => 'IlRFU1QgRVZFTlQgTUVTU0FHRSI=',
+            'verbose' => '1'
+          },
+          :headers => {
+            'Authorization' => 'Basic ' + Base64.strict_encode64('test-user:test-secret')
+          }
+        )
+    end
+
+    it 'should raise ArgumentError when credentials is not ServiceAccountCredentials' do
+      consumer = Mixpanel::Consumer.new
+
+      expect {
+        consumer.request('https://api.mixpanel.com/import', {'data' => 'test', 'verbose' => '1'}, credentials: 'invalid', type: :import)
+      }.to raise_error(ArgumentError, /credentials must be ServiceAccountCredentials, got String/)
+    end
+
+    it 'should not include api_key when credentials are present' do
+      stub_request(:any, 'https://api.mixpanel.com/import?project_id=test-project').to_return({:body => '{"status": 1, "error": null}'})
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'test-project')
+      consumer = Mixpanel::Consumer.new(nil, nil, nil, nil, credentials: credentials)
+
+      # Message includes api_key but it should be ignored when credentials are present
+      consumer.send!(:import, {'data' => 'TEST EVENT MESSAGE', 'api_key' => 'SHOULD_BE_IGNORED'}.to_json)
+
+      # api_key should NOT be in the request body (only data and verbose)
+      expect(WebMock).to have_requested(:post, 'https://api.mixpanel.com/import?project_id=test-project').
+        with(
+          :body => {
+            'data' => 'IlRFU1QgRVZFTlQgTUVTU0FHRSI=',
+            'verbose' => '1'
+          }
+        )
+    end
+  end
+
 end
 
 describe Mixpanel::BufferedConsumer do
@@ -205,4 +256,34 @@ describe Mixpanel::BufferedConsumer do
     end
   end
 
+  context 'with service account credentials' do
+    it 'should pass credentials to consumer when using BufferedConsumer' do
+      stub_request(:any, 'https://api.mixpanel.com/import?project_id=buffered-project').to_return({:body => '{"status": 1, "error": null}'})
+      credentials = Mixpanel::ServiceAccountCredentials.new('buffered-user', 'buffered-secret', 'buffered-project')
+      consumer = Mixpanel::BufferedConsumer.new(nil, nil, nil, 2, credentials: credentials)
+
+      # Import messages are not buffered - they're sent immediately
+      consumer.send!(:import, {'data' => 'EVENT 1'}.to_json)
+
+      # Verify credentials were used in the request
+      expect(WebMock).to have_requested(:post, 'https://api.mixpanel.com/import?project_id=buffered-project').
+        with(
+          :headers => {
+            'Authorization' => 'Basic ' + Base64.strict_encode64('buffered-user:buffered-secret')
+          }
+        ).once
+    end
+  end
+
+end
+
+describe 'Connection error handling' do
+  it 'should raise ConnectionError when network error occurs' do
+    stub_request(:any, 'https://api.mixpanel.com/track').to_raise(StandardError.new('Network timeout'))
+    consumer = Mixpanel::Consumer.new
+
+    expect {
+      consumer.send!(:event, {'data' => 'TEST EVENT MESSAGE'}.to_json)
+    }.to raise_error(Mixpanel::ConnectionError, /Could not connect to Mixpanel, with error "Network timeout"/)
+  end
 end

data/spec/mixpanel-ruby/credentials_security_spec.rb

@@ -0,0 +1,108 @@
+require 'mixpanel-ruby'
+require 'json'
+
+describe 'Credentials Security' do
+  describe 'import with constructor credentials (recommended)' do
+    it 'should NOT include credentials in message payload' do
+      messages = []
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project')
+
+      # Create tracker with credentials in constructor
+      tracker = Mixpanel::Tracker.new('TOKEN', nil, credentials: credentials) do |type, message|
+        messages << [type, message]
+      end
+
+      # Call import with nil api_key (recommended pattern)
+      tracker.import(nil, 'user123', 'Test Event', {'prop' => 'value'})
+
+      # Verify message was sent
+      expect(messages.length).to eq(1)
+      type, message_json = messages[0]
+      expect(type).to eq(:import)
+
+      # Parse the message
+      message = JSON.parse(message_json)
+
+      # CRITICAL: Credentials should NOT be in the message
+      expect(message).not_to have_key('credentials')
+      expect(message_json).not_to include('test-secret')
+      expect(message_json).not_to include('test-user')
+
+      # Message should only contain data
+      expect(message).to have_key('data')
+      expect(message['data']).to have_key('event')
+      expect(message['data']['event']).to eq('Test Event')
+    end
+
+    it 'should NOT include credentials in buffered messages' do
+      messages = []
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project')
+
+      # Create buffered consumer with credentials
+      consumer = Mixpanel::BufferedConsumer.new(nil, nil, nil, 5, credentials: credentials) do |type, message|
+        messages << [type, message]
+      end
+
+      # Send multiple event messages (events are buffered, imports are not)
+      5.times do |i|
+        consumer.send!(:event, {'data' => {'event' => "Event #{i}"}}.to_json)
+      end
+
+      # Verify batched message was sent (auto-flushed when buffer reaches max_length)
+      expect(messages.length).to eq(1)
+      type, message_json = messages[0]
+
+      # CRITICAL: Credentials should NOT be in the batched message
+      expect(message_json).not_to include('credentials')
+      expect(message_json).not_to include('test-secret')
+      expect(message_json).not_to include('test-user')
+    end
+  end
+
+  describe 'tracking events' do
+    it 'should never include credentials in event messages' do
+      messages = []
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project')
+
+      tracker = Mixpanel::Tracker.new('TOKEN', nil, credentials: credentials) do |type, message|
+        messages << [type, message]
+      end
+
+      # Track a regular event
+      tracker.track('user123', 'Test Event', {'prop' => 'value'})
+
+      # Verify message
+      expect(messages.length).to eq(1)
+      type, message_json = messages[0]
+      expect(type).to eq(:event)
+
+      # Credentials should NEVER be in event messages
+      expect(message_json).not_to include('credentials')
+      expect(message_json).not_to include('test-secret')
+    end
+  end
+
+  describe 'legacy API key pattern' do
+    it 'should include api_key in message but not credentials' do
+      messages = []
+      tracker = Mixpanel::Tracker.new('TOKEN') do |type, message|
+        messages << [type, message]
+      end
+
+      # Use legacy API key pattern
+      tracker.import('MY_API_KEY', 'user123', 'Test Event', {'prop' => 'value'})
+
+      # Verify message
+      expect(messages.length).to eq(1)
+      type, message_json = messages[0]
+      message = JSON.parse(message_json)
+
+      # API key should be in message (legacy pattern)
+      expect(message).to have_key('api_key')
+      expect(message['api_key']).to eq('MY_API_KEY')
+
+      # But credentials should NOT be
+      expect(message).not_to have_key('credentials')
+    end
+  end
+end

data/spec/mixpanel-ruby/credentials_spec.rb

@@ -0,0 +1,54 @@
+require 'mixpanel-ruby'
+
+describe Mixpanel::ServiceAccountCredentials do
+  describe '#initialize' do
+    it 'creates credentials with valid parameters' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'project123')
+      expect(credentials.username).to eq('user')
+      expect(credentials.secret).to eq('secret')
+      expect(credentials.project_id).to eq('project123')
+    end
+
+    it 'raises ArgumentError when username is nil' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new(nil, 'secret', 'project123')
+      }.to raise_error(ArgumentError, 'username is required')
+    end
+
+    it 'raises ArgumentError when username is empty' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new('', 'secret', 'project123')
+      }.to raise_error(ArgumentError, 'username is required')
+    end
+
+    it 'raises ArgumentError when secret is nil' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new('user', nil, 'project123')
+      }.to raise_error(ArgumentError, 'secret is required')
+    end
+
+    it 'raises ArgumentError when secret is empty' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new('user', '', 'project123')
+      }.to raise_error(ArgumentError, 'secret is required')
+    end
+
+    it 'raises ArgumentError when project_id is nil' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new('user', 'secret', nil)
+      }.to raise_error(ArgumentError, 'project_id is required')
+    end
+
+    it 'raises ArgumentError when project_id is empty' do
+      expect {
+        Mixpanel::ServiceAccountCredentials.new('user', 'secret', '')
+      }.to raise_error(ArgumentError, 'project_id is required')
+    end
+
+    it 'accepts integer project_id and converts to string' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 12345)
+      expect(credentials.project_id).to eq('12345')
+    end
+  end
+
+end

data/spec/mixpanel-ruby/events_spec.rb

@@ -3,6 +3,7 @@ require 'time'
 
 require 'mixpanel-ruby/events.rb'
 require 'mixpanel-ruby/version.rb'
+require 'mixpanel-ruby/credentials.rb'
 
 describe Mixpanel::Events do
   before(:each) do
@@ -73,4 +74,155 @@ describe Mixpanel::Events do
         }
     } ]])
   end
+
+  it 'should send a well formed import/ message with service account credentials' do
+    credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project-123')
+
+    # Create new Events instance with credentials in constructor
+    events_with_creds = Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials) do |type, message|
+      @log << [type, JSON.load(message)]
+    end
+
+    # New API: pass nil for api_key, credentials come from instance
+    events_with_creds.import(nil, 'TEST ID', 'Test Event', {
+        'Circumstances' => 'During a test'
+    })
+
+    expect(@log.length).to eq(1)
+    expect(@log[0][0]).to eq(:import)
+
+    message = @log[0][1]
+    # Credentials should NOT be in message (secure API)
+    expect(message).not_to have_key('credentials')
+    expect(message).not_to have_key('api_key')
+    expect(message['data']).to eq({
+        'event' => 'Test Event',
+        'properties' => {
+            'Circumstances' => 'During a test',
+            'distinct_id' => 'TEST ID',
+            'mp_lib' => 'ruby',
+            '$lib_version' => Mixpanel::VERSION,
+            'token' => 'TEST TOKEN',
+            'time' => @time_now.to_i * 1000
+        }
+    })
+  end
+
+  it 'should raise ArgumentError when import is called without authentication' do
+    # Create Events without credentials
+    events = Mixpanel::Events.new('TEST TOKEN') do |type, message|
+      @log << [type, JSON.load(message)]
+    end
+
+    # Try to import with nil api_key and no credentials
+    expect {
+      events.import(nil, 'TEST ID', 'Test Event', {})
+    }.to raise_error(ArgumentError, /import requires authentication/)
+  end
+
+  describe 'import_events' do
+    it 'should send a well formed import/ message with constructor credentials' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project-123')
+
+      events_with_creds = Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials) do |type, message|
+        @log << [type, JSON.load(message)]
+      end
+
+      # Clean API - no nil!
+      events_with_creds.import_events('TEST ID', 'Test Event', {
+        'Circumstances' => 'During a test'
+      })
+
+      expect(@log.length).to eq(1)
+      expect(@log[0][0]).to eq(:import)
+
+      message = @log[0][1]
+      # Credentials should NOT be in message
+      expect(message).not_to have_key('credentials')
+      expect(message).not_to have_key('api_key')
+      expect(message['data']).to eq({
+        'event' => 'Test Event',
+        'properties' => {
+          'Circumstances' => 'During a test',
+          'distinct_id' => 'TEST ID',
+          'mp_lib' => 'ruby',
+          '$lib_version' => Mixpanel::VERSION,
+          'token' => 'TEST TOKEN',
+          'time' => @time_now.to_i * 1000
+        }
+      })
+    end
+
+    it 'should raise ArgumentError when called without constructor credentials' do
+      events = Mixpanel::Events.new('TEST TOKEN') do |type, message|
+        @log << [type, JSON.load(message)]
+      end
+
+      expect {
+        events.import_events('TEST ID', 'Test Event', {})
+      }.to raise_error(ArgumentError, /import_events requires credentials in constructor/)
+    end
+  end
+
+  describe 'warnings' do
+    it 'should warn when credentials are passed with a custom block' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'project')
+
+      expect {
+        Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials) do |type, message|
+          # Custom block
+        end
+      }.to output(/credentials passed to Events\/Tracker are ignored/).to_stderr
+    end
+
+    it 'should not warn when credentials are passed without a block' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'project')
+
+      expect {
+        Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials)
+      }.not_to output.to_stderr
+    end
+
+    it 'should warn when using deprecated api_key in import' do
+      events = Mixpanel::Events.new('TEST TOKEN') do |type, message|
+        @log << [type, JSON.load(message)]
+      end
+
+      expect {
+        events.import('API_KEY', 'TEST ID', 'Test Event', {})
+      }.to output(/DEPRECATION.*api_key to import\(\) is deprecated/).to_stderr
+
+      # Second call should also warn
+      expect {
+        events.import('API_KEY', 'TEST ID', 'Test Event 2', {})
+      }.to output(/DEPRECATION.*api_key to import\(\) is deprecated/).to_stderr
+    end
+
+    it 'should warn when using import(nil, ...) with credentials' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'project')
+      events = Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials) do |type, message|
+        @log << [type, JSON.load(message)]
+      end
+
+      expect {
+        events.import(nil, 'TEST ID', 'Test Event', {})
+      }.to output(/DEPRECATION.*import\(nil, \.\.\.\) is deprecated.*import_events/).to_stderr
+
+      # Second call should also warn
+      expect {
+        events.import(nil, 'TEST ID', 'Test Event 2', {})
+      }.to output(/DEPRECATION.*import\(nil, \.\.\.\) is deprecated.*import_events/).to_stderr
+    end
+
+    it 'should not warn when using import_events' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('user', 'secret', 'project')
+      events = Mixpanel::Events.new('TEST TOKEN', nil, credentials: credentials) do |type, message|
+        @log << [type, JSON.load(message)]
+      end
+
+      expect {
+        events.import_events('TEST ID', 'Test Event', {})
+      }.not_to output(/DEPRECATION/).to_stderr
+    end
+  end
 end

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

@@ -1,6 +1,8 @@
 require 'json'
+require 'timeout'
 require 'mixpanel-ruby/flags/local_flags_provider'
 require 'mixpanel-ruby/flags/types'
+require 'mixpanel-ruby/credentials'
 require 'webmock/rspec'
 
 describe Mixpanel::Flags::LocalFlagsProvider do
@@ -16,7 +18,8 @@ describe Mixpanel::Flags::LocalFlagsProvider do
       test_token,
       config,
       mock_tracker,
-      mock_error_handler
+      mock_error_handler,
+      nil  # credentials
     )
   end
 
@@ -100,6 +103,34 @@ describe Mixpanel::Flags::LocalFlagsProvider do
     }
   end
 
+  describe '#initialize' do
+    it 'raises ArgumentError when polling_interval_in_seconds is not a positive number' do
+      [0, -1, 'sixty', :foo].each do |bad_value|
+        expect do
+          Mixpanel::Flags::LocalFlagsProvider.new(
+            test_token,
+            { polling_interval_in_seconds: bad_value },
+            mock_tracker,
+            mock_error_handler
+          )
+        end.to raise_error(ArgumentError, /polling_interval_in_seconds/)
+      end
+    end
+
+    it 'falls back to the default polling_interval_in_seconds when caller passes nil' do
+      # nil must not silently override the default — CV#wait(mutex, nil) blocks
+      # indefinitely, which would silently disable polling.
+      expect do
+        Mixpanel::Flags::LocalFlagsProvider.new(
+          test_token,
+          { polling_interval_in_seconds: nil },
+          mock_tracker,
+          mock_error_handler
+        )
+      end.not_to raise_error
+    end
+  end
+
   describe '#get_variant_value' do
     it 'returns fallback when no flag definitions' do
       stub_flag_definitions([])
@@ -741,7 +772,8 @@ describe Mixpanel::Flags::LocalFlagsProvider do
         test_token,
         { enable_polling: true, polling_interval_in_seconds: 0.1 },
         mock_tracker,
-        mock_error_handler
+        mock_error_handler,
+        nil  # credentials
       )
 
       begin
@@ -755,5 +787,180 @@ describe Mixpanel::Flags::LocalFlagsProvider do
         polling_provider.stop_polling_for_definitions!
       end
     end
+
+    it 'shuts down promptly while the polling thread is waiting on the interval' do
+      flag = create_test_flag
+      stub_flag_definitions([flag])
+
+      polling_provider = Mixpanel::Flags::LocalFlagsProvider.new(
+        test_token,
+        # A long interval ensures the polling thread is parked on the wait when
+        # shutdown is requested — pre-fix, the join would have to ride out the
+        # full interval before the thread checked @stop_polling.
+        { enable_polling: true, polling_interval_in_seconds: 30 },
+        mock_tracker,
+        mock_error_handler
+      )
+
+      polling_provider.start_polling_for_definitions!
+      begin
+        # Wait until the polling thread is parked on the condition variable
+        # (status 'sleep') so the spec deterministically exercises the CV-wakeup
+        # path.
+        polling_thread = polling_provider.instance_variable_get(:@polling_thread)
+        Timeout.timeout(2) { sleep 0.01 until polling_thread.status == 'sleep' }
+
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        polling_provider.stop_polling_for_definitions!
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+        expect(elapsed).to be < 1.0
+      ensure
+        polling_provider.stop_polling_for_definitions!
+      end
+    end
+
+    it 'shuts down promptly when stop races an in-flight fetch' do
+      flag = create_test_flag
+      fetch_count = 0
+      fetch_count_mutex = Mutex.new
+      second_fetch_started = Queue.new
+      second_fetch_release = Queue.new
+
+      stub_request(:get, endpoint_url_regex)
+        .to_return do |_request|
+          this_call = fetch_count_mutex.synchronize { fetch_count += 1 }
+          if this_call == 2
+            second_fetch_started << true
+            second_fetch_release.pop
+          end
+          {
+            status: 200,
+            body: { code: 200, flags: [flag] }.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        end
+
+      polling_provider = Mixpanel::Flags::LocalFlagsProvider.new(
+        test_token,
+        # 1 s interval — large enough that the lost-wakeup race (if reintroduced)
+        # would be detectable as ~1 s of extra teardown after the fetch finishes,
+        # but small enough that the second polling-thread fetch starts quickly.
+        { enable_polling: true, polling_interval_in_seconds: 1.0 },
+        mock_tracker,
+        mock_error_handler
+      )
+
+      polling_provider.start_polling_for_definitions!
+      begin
+        # Bounded wait: if a regression keeps the polling thread from reaching
+        # the second fetch, fail fast rather than hanging the suite.
+        Timeout.timeout(5) { second_fetch_started.pop }
+
+        # Trigger shutdown while the polling thread is mid-fetch (NOT on the
+        # CV), so the broadcast goes to no waiter. Run it in a thread so we can
+        # release the fetch afterwards.
+        stopper = Thread.new { polling_provider.stop_polling_for_definitions! }
+        # Wait until the stopper has set @stop_polling and broadcast, so
+        # releasing the fetch deterministically lands in the lost-wakeup window
+        # this spec targets.
+        Timeout.timeout(2) { sleep 0.01 until polling_provider.instance_variable_get(:@stop_polling) }
+
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        second_fetch_release << true
+        stopper.join
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+
+        # With the predicate-inside-mutex check, the polling thread re-enters
+        # the mutex after fetch, sees @stop_polling = true, skips the wait, and
+        # breaks immediately. Without it, the thread would call wait(1.0 s),
+        # ride out the full interval, and only then break — elapsed would be
+        # ~1 s.
+        expect(elapsed).to be < 0.5
+      ensure
+        # Unblock any in-flight stub fetch in case we raised before releasing
+        # it normally — otherwise the polling thread stays blocked at
+        # second_fetch_release.pop and stop_polling_for_definitions!'s join
+        # would hang the suite.
+        second_fetch_release << true
+        polling_provider.stop_polling_for_definitions!
+      end
+    end
+
+    it 'stop arriving during the initial fetch wins; start does not spawn a thread' do
+      fetch_in_progress = Queue.new
+      fetch_release = Queue.new
+
+      stub_request(:get, endpoint_url_regex).to_return do |_req|
+        fetch_in_progress << true
+        fetch_release.pop
+        {
+          status: 200,
+          body: { code: 200, flags: [] }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      polling_provider = Mixpanel::Flags::LocalFlagsProvider.new(
+        test_token,
+        { enable_polling: true, polling_interval_in_seconds: 30 },
+        mock_tracker,
+        mock_error_handler
+      )
+
+      starter = Thread.new { polling_provider.start_polling_for_definitions! }
+      begin
+        # Wait until start is blocked inside the initial fetch.
+        Timeout.timeout(5) { fetch_in_progress.pop }
+
+        # Stop arrives while start is mid-fetch (start has already cleared
+        # @stop_polling, so this is the bad case where stop's set must "win"
+        # despite happening between start's clear and start's spawn-decision).
+        polling_provider.stop_polling_for_definitions!
+
+        # Let start finish its fetch and reach the lifecycle check.
+        fetch_release << true
+        starter.join
+
+        # No polling thread should have been spawned — stop's postcondition
+        # (polling is off when stop returns) must hold even when start was
+        # mid-fetch at the time of the stop call.
+        expect(polling_provider.instance_variable_get(:@polling_thread)).to be_nil
+      ensure
+        fetch_release << true
+        starter&.join
+        polling_provider.stop_polling_for_definitions!
+      end
+    end
+  end
+
+  describe 'service account credentials' do
+    it 'uses service account credentials for authentication' do
+      credentials = Mixpanel::ServiceAccountCredentials.new('test-user', 'test-secret', 'test-project')
+      flag = create_test_flag
+
+      stub_request(:get, endpoint_url_regex)
+        .with(
+          basic_auth: ['test-user', 'test-secret']
+        )
+        .to_return(
+          status: 200,
+          body: { code: 200, flags: [flag] }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+
+      credentials_provider = Mixpanel::Flags::LocalFlagsProvider.new(
+        test_token,
+        config,
+        mock_tracker,
+        mock_error_handler,
+        credentials
+      )
+
+      credentials_provider.start_polling_for_definitions!
+      result = credentials_provider.get_variant_value('test_flag', 'fallback', test_context, report_exposure: false)
+
+      expect(result).not_to eq('fallback')
+      credentials_provider.stop_polling_for_definitions!
+    end
   end
 end