tcell_agent 1.1.3 → 1.1.4

data/lib/tcell_agent/userinfo.rb

@@ -1,8 +1,8 @@
 module TCellAgent
   class UserInformation
     # Devise
-    def self.getUserFromRequest(request)
-       return nil
+    def self.get_user_from_request(_request)
+      nil
     end
   end
-end
+end

data/lib/tcell_agent/utils/io.rb

@@ -1,43 +1,38 @@
-require "pathname"
-require "tcell_agent/instrumentation"
-require "tcell_agent/utils/strings"
-
+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)
 
-      def self.create_directory(dir, owner=nil)
-        unless File.directory?(dir)
-          directories = Pathname(dir).each_filename.to_a
+        directories = Pathname(dir).each_filename.to_a
 
-          return if directories.size < 1
+        return if directories.empty?
 
-          memoized_path = File::SEPARATOR
+        memoized_path = File::SEPARATOR
 
-          directories.each do |directory|
-            memoized_path = File.join(memoized_path, directory)
-            unless File.directory?(memoized_path)
-              FileUtils.mkdir(memoized_path)
+        directories.each do |directory|
+          memoized_path = File.join(memoized_path, directory)
+          next if File.directory?(memoized_path)
+          FileUtils.mkdir(memoized_path)
 
-              if 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
+          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.exists?(filename)
-            FileUtils.chown( owner, nil, filename )
+      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/params.rb

@@ -1,16 +1,16 @@
 module TCellAgent
   module Utils
     module Params
-      GET_PARAM = "get"
-      POST_PARAM = "post"
-      JSON_PARAM = "json"
-      URI_PARAM = "uri"
-      COOKIE_PARAM = "cookies"
-      HEADER_PARAM = "header"
+      GET_PARAM = 'get'.freeze
+      POST_PARAM = 'post'.freeze
+      JSON_PARAM = 'json'.freeze
+      URI_PARAM = 'uri'.freeze
+      COOKIE_PARAM = 'cookies'.freeze
+      HEADER_PARAM = 'header'.freeze
 
-      def self.flatten(param_dict, namespace=nil)
+      def self.flatten(param_dict, namespace = nil)
         flattened = {}
-        namespace = [] unless namespace
+        namespace ||= []
         (param_dict || {}).each do |param_name, param_value|
           if param_value.is_a?(Hash)
             flattened = flattened.merge(flatten(param_value, namespace.dup << param_name.to_s))
@@ -22,23 +22,17 @@ module TCellAgent
                 flattened = flattened.merge(flatten(val, new_namespace))
               elsif val.is_a?(String) || val.is_a?(Symbol)
                 flattened[new_namespace.freeze] = val.to_s
-              else
-                # DROP any unrecognized types (like Tempfiles and other such possible things)
               end
             end
 
           elsif param_value.is_a?(String) || param_value.is_a?(Symbol)
             new_key = namespace.dup << param_name.to_s
             flattened[new_key.freeze] = param_value.to_s
-
-          else
-            # DROP any unrecognized types (like Tempfiles and other such possible things)
           end
         end
 
-        return flattened
+        flattened
       end
-
     end
   end
 end

data/lib/tcell_agent/utils/queue_with_timeout.rb

@@ -1,13 +1,11 @@
 # See the file "LICENSE" for the full license governing this code.
 
-require "tcell_agent/logger"
+require 'tcell_agent/logger'
 require 'thread'
 require 'logger'
 
 module TCellAgent
-
   class BoundedQueue
-
     def initialize(max_size = :infinite)
       @lock  = Mutex.new
       @items = []
@@ -16,16 +14,17 @@ module TCellAgent
       @space_available = ConditionVariable.new
     end
 
-    def push(obj, timeout=:never, &timeout_policy)
-      timeout_policy ||= -> do
-        raise "Push timed out"
+    def push(obj, timeout = :never, &timeout_policy)
+      timeout_policy ||= lambda do
+        raise 'Push timed out'
       end
 
       wait_for_condition(
         @space_available,
-        ->{!full?},
+        -> { !full? },
         timeout,
-        timeout_policy) do
+        timeout_policy
+      ) do
 
         @items.push(obj)
         @item_available.signal
@@ -33,12 +32,13 @@ module TCellAgent
     end
 
     def pop(timeout = :never, &timeout_policy)
-      timeout_policy ||= ->{nil}
+      timeout_policy ||= -> { nil }
       wait_for_condition(
         @item_available,
-        ->{@items.any?},
+        -> { @items.any? },
         timeout,
-        timeout_policy) do
+        timeout_policy
+      ) do
 
         item = @items.shift
         @space_available.signal
@@ -58,36 +58,32 @@ module TCellAgent
 
     private
 
-    def wait_for_condition(cv, condition_predicate, timeout=:never, timeout_policy=->{nil})
-
+    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
-            cv.wait(@lock, cv_timeout)
+            condition_variable.wait(@lock, cv_timeout)
           end
 
-          if condition_predicate.call
+          if condition_predicate.call # rubocop:disable Style/GuardClause
             return yield
 
-          elsif :never == deadline || deadline > Time.now
+          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 = []
@@ -95,7 +91,7 @@ module TCellAgent
       @recieved = ConditionVariable.new
     end
 
-    def <<(x)
+    def <<(x) # rubocop:disable Naming/UncommunicativeMethodParamName
       @mutex.synchronize do
         @queue << x
         @recieved.signal
@@ -104,23 +100,21 @@ module TCellAgent
 
     def add_response_time(route_id, response_time)
       @mutex.synchronize do
-        if (route_id == nil || route_id == "")
-          route_id = "?"
-        end
-        @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"]
+        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
-      return @queue.length
+      @queue.length
     end
 
     def get_response_time_table
-      return @response_time_table
+      @response_time_table
     end
 
     def reset_response_time_table
@@ -137,9 +131,9 @@ module TCellAgent
       @mutex.synchronize do
         if @queue.empty?
           @recieved.wait(@mutex, timeout) if timeout != 0
-          #if we're still empty after the timeout, raise exception
+          # if we're still empty after the timeout, raise exception
           return nil if @queue.empty?
-          #raise ThreadError, "queue empty" if @queue.empty?
+          # raise ThreadError, "queue empty" if @queue.empty?
         end
         @queue.shift
       end

data/lib/tcell_agent/utils/strings.rb

@@ -4,19 +4,17 @@ module TCellAgent
       BLANK_RE = /\A[[:space:]]*\z/
 
       def self.blank?(str)
-        str.nil? || str.empty? || BLANK_RE === str
+        str.nil? || str.empty? || BLANK_RE === str # rubocop:disable Style/CaseEquality
       end
 
       def self.present?(str)
-        !self.blank?(str)
+        !blank?(str)
       end
 
       def self.remove_trailing_slash(path)
-        if path && path != "/"
-          return path.chomp("/")
-        end
+        return path.chomp('/') if path && path != '/'
 
-        return path
+        path
       end
 
       # emulate the java String.hashcode() without upcasting to BigInt

data/lib/tcell_agent/version.rb

@@ -1,5 +1,5 @@
 # See the file "LICENSE" for the full license governing this code.
 
 module TCellAgent
-  VERSION = "1.1.3"
+  VERSION = '1.1.4'.freeze
 end

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

@@ -332,7 +332,7 @@ module TCellAgent
 
             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)
+            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 })
@@ -356,7 +356,7 @@ module TCellAgent
               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)
+              expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
 
               agent = TCellAgent::Agent.new(Process.pid)
 
@@ -377,7 +377,7 @@ module TCellAgent
                 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)
+                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)
@@ -400,7 +400,7 @@ module TCellAgent
                 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)
+                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with({}, false)
 
                 TCellAgent::Agent.new(Process.pid)
               end
@@ -422,7 +422,7 @@ module TCellAgent
                   }.to_json
                 )
                 expect(cache_file).to receive(:close)
-                expect_any_instance_of(TCellAgent::Agent).to receive(:processPolicyJson).with(
+                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with(
                   {
                     'process_0' => {
                       'app_id' => 'raftest-EyJZR',

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

@@ -6,7 +6,7 @@ module TCellAgent
       describe '.increment_session_info' do
         context 'when running the parent process' do
           it 'should increment the session info' do
-            expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(true)
+            expect(TCellAgent::Agent).to receive(:parent_process?).and_return(true)
             expect(TCellAgent).to_not receive(:queue_metric)
             expect_any_instance_of(SessionsMetric).to receive(:add_session_info).with(
               'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
@@ -19,7 +19,7 @@ module TCellAgent
 
           context 'and the session becomes full' do
             it 'should increment the session info and send the flush dummy event' do
-              expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(true)
+              expect(TCellAgent::Agent).to receive(:parent_process?).and_return(true)
               expect(TCellAgent).to_not receive(:queue_metric)
               expect_any_instance_of(SessionsMetric).to receive(:add_session_info).with(
                 'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
@@ -36,7 +36,7 @@ module TCellAgent
 
         context 'when NOT running the parent process' do
           it 'should queue the metric' do
-            expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(false)
+            expect(TCellAgent::Agent).to receive(:parent_process?).and_return(false)
             expect(TCellAgent).to receive(:queue_metric).with(
               {
                 '_type' => 'increment_session_info',
@@ -66,7 +66,7 @@ module TCellAgent
 
           context 'with a route present' do
             it 'should increment the route info' do
-              expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(true)
+              expect(TCellAgent::Agent).to receive(:parent_process?).and_return(true)
               expect(TCellAgent).to_not receive(:queue_metric)
 
               TCellAgent.increment_route('/ma_route', 20)
@@ -79,7 +79,7 @@ module TCellAgent
 
           context 'with an empty route' do
             it 'should increment the route info' do
-              expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(true)
+              expect(TCellAgent::Agent).to receive(:parent_process?).and_return(true)
               expect(TCellAgent).to_not receive(:queue_metric)
 
               TCellAgent.increment_route('', 20)
@@ -92,7 +92,7 @@ module TCellAgent
 
           context 'with a nil route' do
             it 'should increment the route info' do
-              expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(true)
+              expect(TCellAgent::Agent).to receive(:parent_process?).and_return(true)
               expect(TCellAgent).to_not receive(:queue_metric)
 
               TCellAgent.increment_route(nil, 20)
@@ -113,7 +113,7 @@ module TCellAgent
           end
 
           it 'should queue the metric' do
-            expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(false)
+            expect(TCellAgent::Agent).to receive(:parent_process?).and_return(false)
             expect(TCellAgent).to receive(:queue_metric).with(
               {
                 '_type' => 'increment_route',

data/spec/lib/tcell_agent/cmdi_spec.rb

@@ -204,7 +204,7 @@ module TCellAgent
         context 'with no command injection' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(nil)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:cmdi_enabled)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:block_command?)
@@ -218,7 +218,7 @@ module TCellAgent
             expect(@rust_policies.cmdi_enabled).to eq(false)
 
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_call_original
             expect(@rust_policies).to_not receive(:block_command?)
@@ -230,7 +230,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(false)
@@ -244,7 +244,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)
@@ -426,7 +426,7 @@ module TCellAgent
         context 'with no command injection' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(nil)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:cmdi_enabled)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:block_command?)
@@ -438,7 +438,7 @@ module TCellAgent
         context 'with command injection disabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(false)
             expect(@rust_policies).to_not receive(:block_command?)
@@ -450,7 +450,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(false)
@@ -464,7 +464,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)
@@ -490,7 +490,7 @@ module TCellAgent
         context 'with no command injection' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(nil)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:cmdi_enabled)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:block_command?)
@@ -502,7 +502,7 @@ module TCellAgent
         context 'with command injection disabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(false)
             expect(@rust_policies).to_not receive(:block_command?)
@@ -514,7 +514,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(false)
@@ -528,7 +528,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)
@@ -575,7 +575,7 @@ module TCellAgent
         context 'with no command injection' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(nil)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:cmdi_enabled)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:block_command?)
@@ -587,7 +587,7 @@ module TCellAgent
         context 'with command injection disabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(false)
             expect(@rust_policies).to_not receive(:block_command?)
@@ -599,7 +599,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test > /dev/null 2>&1', nil).and_return(false)
@@ -613,7 +613,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)
@@ -663,7 +663,7 @@ module TCellAgent
         context 'with no command injection' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(nil)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:cmdi_enabled)
             expect_any_instance_of(TCellAgent::Policies::RustPolicies).to_not receive(:block_command?)
@@ -675,7 +675,7 @@ module TCellAgent
         context 'with command injection disabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(false)
             expect(@rust_policies).to_not receive(:block_command?)
@@ -687,7 +687,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should execute the command' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test > /dev/null 2>&1', nil).and_return(false)
@@ -701,7 +701,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)
@@ -720,7 +720,7 @@ module TCellAgent
         context 'with command injection enabled' do
           it 'should raise a Errno::ENOENT' do
             expect(TCellAgent).to receive(:policy).with(
-              TCellAgent::PolicyTypes::Rust
+              TCellAgent::PolicyTypes::RUST
             ).and_return(@rust_policies)
             expect(@rust_policies).to receive(:cmdi_enabled).and_return(true)
             expect(@rust_policies).to receive(:block_command?).with('echo test', nil).and_return(true)