tcell_agent 0.4.0 → 1.0.0

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

@@ -2,24 +2,23 @@ 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
+      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",
+              '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"
+                :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)
@@ -27,164 +26,170 @@ module TCellAgent
           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
+        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",
+                  '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"
+                    :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")
+                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(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
+            context 'is empty' do
+              it 'should not start the policy polling loop' do
                 configuration = double(
-                  "configuration",
+                  '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"
+                    :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")
+                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(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
+            context 'is blank space' do
+              it 'should not start the policy polling loop' do
                 configuration = double(
-                  "configuration",
+                  '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"
+                    :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")
+                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(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
+          context 'app_id' do
+            context 'is nil ' do
+              it 'should not start the policy polling loop' do
                 configuration = double(
-                  "configuration",
+                  '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"
+                    :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")
+                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(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
+            context 'is empty' do
+              it 'should not start the policy polling loop' do
                 configuration = double(
-                  "configuration",
+                  '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"
+                    :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")
+                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(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
+            context 'is blank space' do
+              it 'should not start the policy polling loop' do
                 configuration = double(
-                  "configuration",
+                  '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"
+                    :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")
+                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(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
@@ -193,29 +198,27 @@ module TCellAgent
         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
+      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
                 TCellAgent.thread_agent.cache(
-                  "http-redirect",
+                  'http-redirect',
                   {
-                    "app_id"=>"raftest-EyJZR",
-                    "policy_id"=>"363b8b60-a9a8-11e5-bb10-a9372a56b8a7",
-                    "data"=> {
-                      "enabled"=>true,
-                      "block"=>false,
-                      "whitelist"=>[]
+                    '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
+              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
@@ -223,14 +226,14 @@ module TCellAgent
                   end
 
                   TCellAgent.thread_agent.cache(
-                    "http-redirect",
+                    'http-redirect',
                     {
-                      "app_id"=>"raftest-EyJZR",
-                      "policy_id"=>"363b8b60-a9a8-11e5-bb10-a9372a56b8a7",
-                      "data"=> {
-                        "enabled"=>true,
-                        "block"=>false,
-                        "whitelist"=>[]
+                      'app_id' => 'raftest-EyJZR',
+                      'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
+                      'data' =>  {
+                        'enabled' => true,
+                        'block' => false,
+                        'whitelist' => []
                       }
                     }
                   )
@@ -238,19 +241,19 @@ module TCellAgent
 
                 file_lock_holder.run_until(:before_dump).wait
 
-                logger = double("logger")
+                logger = double('logger')
                 expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with("execution expired")
+                expect(logger).to receive(:warn).with('execution expired')
 
                 TCellAgent.thread_agent.cache(
-                  "http-redirect",
+                  'http-redirect',
                   {
-                    "app_id"=>"raftest-EyJZR",
-                    "policy_id"=>"363b8b60-a9a8-11e5-bb10-a9372a56b8a7",
-                    "data"=> {
-                      "enabled"=>true,
-                      "block"=>false,
-                      "whitelist"=>[]
+                    'app_id' => 'raftest-EyJZR',
+                    'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
+                    'data' =>  {
+                      'enabled' => true,
+                      'block' => false,
+                      'whitelist' => []
                     }
                   }
                 )
@@ -258,7 +261,6 @@ module TCellAgent
                 file_lock_holder.finish.wait
               end
 
-
               after(:each) do
                 File.delete(TCellAgent.configuration.cache_filename_with_app_id)
               end
@@ -266,9 +268,9 @@ module TCellAgent
           end
         end
 
-        context "with 10 processes updating the cached file" do
-          xit "should update the cached file with all updates" do
-            processes = 5.times.map do |process_number|
+        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|
@@ -279,120 +281,141 @@ module TCellAgent
                 TCellAgent.thread_agent.cache(
                   "process_#{process_number}",
                   {
-                    "app_id"=>"raftest-EyJZR",
-                    "policy_id"=>"policy_id",
-                    "data"=> { "enabled"=>true }
+                    'app_id' => 'raftest-EyJZR',
+                    'policy_id' => 'policy_id',
+                    'data' =>  { 'enabled' => true }
                   }
                 )
-
               end
             end
 
             processes.map(&:finish).map(&:wait)
 
-            policies = JSON.parse(open(TCellAgent.configuration.cache_filename_with_app_id).read)
+            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}}
-            })
+            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
+      describe '#policies_from_cachefile' do
+        context 'with no cache file' do
+          it 'should return nil' do
+            rust_policies = double('rust_policies')
 
-            expect(File).to receive(:exist?).with(/tcell\/cache\/tcell_agent.cache/).and_return(false)
+            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(:processPolicyJson)
             agent = TCellAgent::Agent.new(Process.pid)
 
-            expect(agent.policies).to eq({})
+            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(/tcell\/cache\/tcell_agent.cache/).and_return(true)
+        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(:read).and_return('')
               expect(cache_file).to receive(:close)
 
-              logger = double("logger")
+              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!")
+              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(:processPolicyJson)
 
               agent = TCellAgent::Agent.new(Process.pid)
 
-              expect(agent.policies).to eq({})
+              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(/tcell\/cache\/tcell_agent.cache/).and_return(true)
+          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(:read).and_return('bad_json')
                 expect(cache_file).to receive(:close)
 
-                logger = double("logger")
+                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(:processPolicyJson)
 
+                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({})
+                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(/tcell\/cache\/tcell_agent.cache/).and_return(true)
+            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(: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(:processPolicyJson).with({}, false)
 
-                agent = TCellAgent::Agent.new(Process.pid)
+                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(/tcell\/cache\/tcell_agent.cache/).and_return(true)
+            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}}
+                    :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(:processPolicyJson).with(
-                  {"process_0"=>{"app_id"=>"raftest-EyJZR", "policy_id"=>"policy_id", "data"=>{"enabled"=>true}}},
+                  {
+                    '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
@@ -400,7 +423,96 @@ module TCellAgent
           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