tcell_agent 1.1.12 → 2.0.0

data/lib/tcell_agent/system_info.rb

@@ -1,11 +0,0 @@
-module TCellAgent
-  module SystemInfo
-    def self.get_language_version
-      RUBY_VERSION
-    end
-
-    def self.get_language
-      'Ruby'
-    end
-  end
-end

data/lib/tcell_agent/utils/io.rb

@@ -1,38 +0,0 @@
-require 'pathname'
-require 'tcell_agent/instrumentation'
-require 'tcell_agent/utils/strings'
-
-module TCellAgent
-  module Utils
-    module IO
-      def self.create_directory(dir, owner = nil)
-        return if File.directory?(dir)
-
-        directories = Pathname(dir).each_filename.to_a
-
-        return if directories.empty?
-
-        memoized_path = File::SEPARATOR
-
-        directories.each do |directory|
-          memoized_path = File.join(memoized_path, directory)
-          next if File.directory?(memoized_path)
-          FileUtils.mkdir(memoized_path)
-
-          next unless TCellAgent::Utils::Strings.present?(owner)
-          TCellAgent::Instrumentation.safe_block('Ignoring agent_home_owner value, insufficient privileges') do
-            FileUtils.chown(owner, nil, memoized_path)
-          end
-        end
-      end
-
-      def self.set_owner(filename, owner = nil)
-        TCellAgent::Instrumentation.safe_block('Ignoring agent_home_owner value, insufficient privileges') do
-          if TCellAgent::Utils::Strings.present?(owner) && File.exist?(filename)
-            FileUtils.chown(owner, nil, filename)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/tcell_agent/utils/passwords.rb

@@ -1,28 +0,0 @@
-module TCellAgent
-  module Utils
-    module Passwords
-      def self.fingerprint_password(password, user_id)
-        digest = nil
-
-        app_id = TCellAgent.configuration.app_id
-        password_hmac_key = TCellAgent.configuration.password_hmac_key
-        if app_id &&
-           TCellAgent::Utils::Strings.present?(password_hmac_key) &&
-           TCellAgent::Utils::Strings.present?(password)
-          string_builder = [app_id, ':', password, ':']
-          string_builder.push(user_id) if user_id
-
-          digest = OpenSSL::HMAC.hexdigest(
-            OpenSSL::Digest.new('sha256'),
-            password_hmac_key.to_s,
-            string_builder.join('')
-          )
-
-          digest = digest[0...8]
-        end
-
-        digest
-      end
-    end
-  end
-end

data/lib/tcell_agent/utils/queue_with_timeout.rb

@@ -1,142 +0,0 @@
-# See the file "LICENSE" for the full license governing this code.
-
-require 'tcell_agent/logger'
-require 'thread'
-require 'logger'
-
-module TCellAgent
-  class BoundedQueue
-    def initialize(max_size = :infinite)
-      @lock  = Mutex.new
-      @items = []
-      @item_available = ConditionVariable.new
-      @max_size = max_size
-      @space_available = ConditionVariable.new
-    end
-
-    def push(obj, timeout = :never, &timeout_policy)
-      timeout_policy ||= lambda do
-        raise 'Push timed out'
-      end
-
-      wait_for_condition(
-        @space_available,
-        -> { !full? },
-        timeout,
-        timeout_policy
-      ) do
-
-        @items.push(obj)
-        @item_available.signal
-      end
-    end
-
-    def pop(timeout = :never, &timeout_policy)
-      timeout_policy ||= -> { nil }
-      wait_for_condition(
-        @item_available,
-        -> { @items.any? },
-        timeout,
-        timeout_policy
-      ) do
-
-        item = @items.shift
-        @space_available.signal
-
-        item
-      end
-    end
-
-    def full?
-      return false if @max_size == :infinite
-      @max_size <= @items.size
-    end
-
-    def size
-      @items.size
-    end
-
-    private
-
-    def wait_for_condition(condition_variable, condition_predicate, timeout = :never, timeout_policy = -> { nil })
-      deadline = timeout == :never ? :never : Time.now + timeout
-
-      @lock.synchronize do
-        loop do
-          cv_timeout = timeout == :never ? nil : deadline - Time.now
-
-          if !condition_predicate.call && cv_timeout.to_f >= 0
-            condition_variable.wait(@lock, cv_timeout)
-          end
-
-          if condition_predicate.call # rubocop:disable Style/GuardClause
-            return yield
-
-          elsif :never == deadline || deadline > Time.now # rubocop:disable Style/YodaCondition
-            next
-
-          else
-            return timeout_policy.call
-          end
-        end
-      end
-    end
-  end
-
-  class QueueWithTimeout
-    def initialize
-      @mutex = Mutex.new
-      @queue = []
-      @response_time_table = {}
-      @recieved = ConditionVariable.new
-    end
-
-    def <<(x) # rubocop:disable Naming/UncommunicativeMethodParamName
-      @mutex.synchronize do
-        @queue << x
-        @recieved.signal
-      end
-    end
-
-    def add_response_time(route_id, response_time)
-      @mutex.synchronize do
-        route_id = '?' if route_id.nil? || route_id == ''
-        @response_time_table[route_id] = @response_time_table.fetch(route_id, {})
-        @response_time_table[route_id]['c'] = @response_time_table[route_id].fetch('c', 0) + 1
-        @response_time_table[route_id]['mx'] = [@response_time_table[route_id].fetch('mx', 0), response_time].max
-        @response_time_table[route_id]['mn'] = [@response_time_table[route_id].fetch('mn', response_time), response_time].min
-        @response_time_table[route_id]['t'] = ((@response_time_table[route_id].fetch('t', 0) * (@response_time_table[route_id]['c'] - 1)) + response_time) / @response_time_table[route_id]['c']
-      end
-    end
-
-    def length
-      @queue.length
-    end
-
-    def get_response_time_table
-      @response_time_table
-    end
-
-    def reset_response_time_table
-      @mutex.synchronize do
-        @response_time_table = {}
-      end
-    end
-
-    def pop(non_block = false)
-      pop_with_timeout(non_block ? 0 : nil)
-    end
-
-    def pop_with_timeout(timeout = nil)
-      @mutex.synchronize do
-        if @queue.empty?
-          @recieved.wait(@mutex, timeout) if timeout != 0
-          # if we're still empty after the timeout, raise exception
-          return nil if @queue.empty?
-          # raise ThreadError, "queue empty" if @queue.empty?
-        end
-        @queue.shift
-      end
-    end
-  end
-end

data/spec/lib/tcell_agent/agent/fork_pipe_manager_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-module TCellAgent
-  describe Agent::ForkPipeManager do
-    describe '.send_to_metrics_pipe' do
-      context 'incrementing a route' do
-        it 'should call increment_route on the agent' do
-          expect(TCellAgent).to receive(:increment_route).with('/ma_route', 50)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              '_type' => 'increment_route',
-              'route_id' => '/ma_route',
-              'response_time' => 50
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'discover database fields' do
-        it 'should call discover_database_fields on the agent' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to receive(:discover_database_fields).with(
-            'route_id', 'database', 'schema', 'table', 'fields'
-          )
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              {
-                '_type' => 'discover_database_fields',
-                'route_id' => 'route_id',
-                'database' => 'database',
-                'schema' => 'schema',
-                'table' => 'table',
-                'fields' => 'fields'
-              }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'increment session info' do
-        it 'should call increment_session_info on the agent' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to receive(:increment_session_info).with(
-            'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
-          )
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              {
-                '_type' => 'increment_session_info',
-                'hmac_session_id' => 'hmac_session_id',
-                'user_id' => 'user_id',
-                'ip_address' => 'ip_address',
-                'user_agent' => 'user_agent'
-              }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'unknown metric' do
-        it 'should raise an exception' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          logger = double('logger')
-          expect(TCellAgent).to receive(:logger).and_return(logger)
-          expect(TCellAgent).to receive(:logger).and_return(logger)
-
-          expect(logger).to receive(:debug).with(
-            'Exception in safe_block Handling metrics_pipe_block: StandardError happened, message' \
-            ' is Metrics Pipe Manager received unknown metric: dunno_what_this_is'
-          )
-          expect(logger).to receive(:debug).with(anything)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              { '_type' => 'dunno_what_this_is' }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-    end
-  end
-end

data/spec/lib/tcell_agent/agent/policy_manager_spec.rb

@@ -1,535 +0,0 @@
-require 'spec_helper'
-
-module TCellAgent
-  module SensorEvents
-    describe Agent do
-      describe '#start_policy_polling_loop' do
-        context 'should_start_policy_poll disabled' do
-          it 'should not start the policy polling loop' do
-            configuration = double(
-              'configuration',
-              {
-                :should_start_policy_poll? => false,
-                :event_time_limit_seconds => nil,
-                :event_batch_size_limit => nil,
-                :preload_policy_filename => nil,
-                :cache_filename_with_app_id => 'cache-file.app_id'
-              }
-            )
-
-            expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-            agent = TCellAgent::Agent.new
-
-            expect(Thread).to_not receive(:new)
-            agent.start_policy_polling_loop
-          end
-        end
-
-        context 'should_start_policy_poll enabled' do
-          context 'tcell_api_url' do
-            context 'is nil ' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => nil,
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is empty' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => '',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is blank space' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => '    ',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-          end
-
-          context 'app_id' do
-            context 'is nil ' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => nil,
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is empty' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => '',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is blank space' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => '    ',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-          end
-        end
-      end
-
-      describe '#cache' do
-        context 'with an existing cached file' do
-          context 'with two processes' do
-            context 'while one process is writing to the cached file' do
-              before(:each) do
-                configuration = double(
-                  'configuration',
-                  {
-                    'app_id' => 'app_id',
-                    'api_key' => 'api_key',
-                    'allow_payloads' => true,
-                    'js_agent_api_base_url' => 'http://api.tcell.com/',
-                    'js_agent_url' => 'https://jsagent.tcell.io/tcellagent.min.js',
-                    'max_csp_header_bytes' => nil,
-                    'event_time_limit_seconds' => 15,
-                    'event_batch_size_limit' => 50,
-                    'preload_policy_filename' => nil,
-                    'cache_filename_with_app_id' => '/tcellagent_src/tcell/cache/tcell_agent.cache',
-                    'agent_home_owner' => nil
-                  }
-                )
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                TCellAgent.thread_agent.cache(
-                  'http-redirect',
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                    'data' =>  {
-                      'enabled' => true,
-                      'block' => false,
-                      'whitelist' => []
-                    }
-                  }
-                )
-              end
-
-              it 'should raise a timeout exception when the other process tries to write to it' do
-                file_lock_holder = ForkBreak::Process.new do |breakpoints|
-                  original_dump = JSON.method(:dump)
-                  JSON.stub(:dump) do |*args|
-                    breakpoints << :before_dump
-                    original_dump.call(*args)
-                  end
-
-                  TCellAgent.thread_agent.cache(
-                    'http-redirect',
-                    {
-                      'app_id' => 'raftest-EyJZR',
-                      'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                      'data' =>  {
-                        'enabled' => true,
-                        'block' => false,
-                        'whitelist' => []
-                      }
-                    }
-                  )
-                end
-
-                file_lock_holder.run_until(:before_dump).wait
-
-                logger = double('logger')
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with('execution expired')
-
-                TCellAgent.thread_agent.cache(
-                  'http-redirect',
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                    'data' =>  {
-                      'enabled' => true,
-                      'block' => false,
-                      'whitelist' => []
-                    }
-                  }
-                )
-
-                file_lock_holder.finish.wait
-              end
-
-              after(:each) do
-                File.delete(TCellAgent.configuration.cache_filename_with_app_id)
-              end
-            end
-          end
-        end
-
-        context 'with 10 processes updating the cached file' do
-          xit 'should update the cached file with all updates' do
-            processes = Array.new(5).each do |process_number|
-              ForkBreak::Process.new do |breakpoints|
-                original_dump = JSON.method(:dump)
-                JSON.stub(:dump) do |*args|
-                  breakpoints << :before_dump
-                  original_dump.call(*args)
-                end
-
-                TCellAgent.thread_agent.cache(
-                  "process_#{process_number}",
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => 'policy_id',
-                    'data' =>  { 'enabled' => true }
-                  }
-                )
-              end
-            end
-
-            processes.map(&:finish).map(&:wait)
-
-            policies = JSON.parse(File.open(TCellAgent.configuration.cache_filename_with_app_id).read)
-
-            File.delete(TCellAgent.configuration.cache_filename_with_app_id)
-
-            expect(policies).to eq(
-              {
-                'process_0' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_1' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_2' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_3' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_4' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } }
-              }
-            )
-          end
-        end
-      end
-
-      describe '#policies_from_cachefile' do
-        context 'with no cache file' do
-          it 'should return nil' do
-            rust_policies = double('rust_policies')
-
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-            expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(false)
-            expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-            agent = TCellAgent::Agent.new(Process.pid)
-
-            expect(agent.policies).to eq({ 'rust' => rust_policies })
-          end
-        end
-
-        context 'with a cache file present' do
-          context 'that is empty' do
-            it 'should raise a json error' do
-              cache_file = double('cache_file')
-              expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-              expect(File).to receive(:open).and_return(cache_file)
-              expect(cache_file).to receive(:flock).and_return(true)
-              expect(cache_file).to receive(:read).and_return('')
-              expect(cache_file).to receive(:close)
-
-              logger = double('logger')
-              expect(TCellAgent).to receive(:logger).and_return(logger)
-              expect(logger).to receive(:warn).with('A JSON text must at least contain two octets!')
-
-              rust_policies = double('rust_policies')
-              expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-
-              expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-
-              agent = TCellAgent::Agent.new(Process.pid)
-
-              expect(agent.policies).to eq({ 'rust' => rust_policies })
-            end
-          end
-
-          context 'that has content' do
-            context 'that is malformed' do
-              it 'should raise a json error' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return('bad_json')
-                expect(cache_file).to receive(:close)
-
-                logger = double('logger')
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with(/unexpected token at 'bad_json'/)
-                expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-
-                rust_policies = double('rust_policies')
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-
-                agent = TCellAgent::Agent.new(Process.pid)
-
-                expect(agent.policies).to eq({ 'rust' => rust_policies })
-              end
-            end
-
-            context 'that is an empty json object' do
-              it 'should raise a json error' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return('{}')
-                expect(cache_file).to receive(:close)
-
-                expect(TCellAgent).to_not receive(:logger)
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with({}, false)
-
-                TCellAgent::Agent.new(Process.pid)
-              end
-            end
-
-            context 'that is a valid policy' do
-              it 'should set the policies' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return(
-                  {
-                    :process_0 => {
-                      :app_id => 'raftest-EyJZR',
-                      :policy_id => 'policy_id',
-                      :data => { :enabled => true }
-                    }
-                  }.to_json
-                )
-                expect(cache_file).to receive(:close)
-                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with(
-                  {
-                    'process_0' => {
-                      'app_id' => 'raftest-EyJZR',
-                      'policy_id' => 'policy_id',
-                      'data' => { 'enabled' => true }
-                    }
-                  },
-                  false
-                )
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-
-                TCellAgent::Agent.new(Process.pid)
-              end
-            end
-          end
-        end
-      end
-
-      describe '#policy_polling_iteration' do
-        context 'with policy polling errors' do
-          it 'should extend failure sleep time after each failure' do
-            configuration = double(
-              'configuration',
-              {
-                :should_start_policy_poll? => false,
-                :event_time_limit_seconds => nil,
-                :event_batch_size_limit => nil,
-                :preload_policy_filename => nil,
-                :cache_filename_with_app_id => 'cache-file.app_id'
-              }
-            )
-
-            api = double('api')
-            logger = double('logger')
-
-            expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-            expect(TCellAgent::TCellApi).to receive(:new).and_return(api)
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-            agent = TCellAgent::Agent.new
-
-            # failure sleep time should double after each failed attempt to retrieve policies
-            # until it reaches 480 seconds
-            failure_sleep_time = 30
-            last_poll_time = 0
-
-            # 1st attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(60)
-            expect(last_poll_time).to eq(0)
-
-            # 2nd attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(120)
-            expect(last_poll_time).to eq(0)
-
-            # 3rd attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(240)
-            expect(last_poll_time).to eq(0)
-
-            # 4th attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(480)
-            expect(last_poll_time).to eq(0)
-
-            # 5th attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(480)
-            expect(last_poll_time).to eq(0)
-          end
-        end
-      end
-    end
-  end
-end