tcell_agent 0.4.0 → 1.0.0

data/spec/lib/tcell_agent/policies/secure_headers_policy_spec.rb

@@ -4,61 +4,61 @@ module TCellAgent
   module Policies
     describe SecureHeadersPolicy do
       secure_headers_policy_json = {
-        "policy_id"=>"01a1",
-        "headers"=>[
-          {"name"=>"x-permitted-cross-domain-policies", "value"=>"value123"}
+        'policy_id' => '01a1',
+        'headers' => [
+          { 'name' => 'x-permitted-cross-domain-policies', 'value' => 'value123' }
         ]
       }
       secure_headers_policy = SecureHeadersPolicy.from_json(secure_headers_policy_json)
-      context "secure header example" do
-        it "returns true" do
-          expect(secure_headers_policy.headers[0].name).to eq("x-permitted-cross-domain-policies")
-          expect(secure_headers_policy.headers[0].value).to eq("value123")
+      context 'secure header example' do
+        it 'returns true' do
+          expect(secure_headers_policy.headers[0].name).to eq('x-permitted-cross-domain-policies')
+          expect(secure_headers_policy.headers[0].value).to eq('value123')
         end
       end
     end
     describe SecureHeadersPolicy do
       secure_headers_policy_json = {
-        "policy_id"=>"01a1",
-        "headers"=>[
-          {"name"=>"x-frame-options", "value"=>"DENY"},
-          {"name"=>"x-xss-protection", "value"=>"1; mode=block"}
+        'policy_id' => '01a1',
+        'headers' => [
+          { 'name' => 'x-frame-options', 'value' => 'DENY' },
+          { 'name' => 'x-xss-protection', 'value' => '1; mode=block' }
         ]
       }
       secure_headers_policy = SecureHeadersPolicy.from_json(secure_headers_policy_json)
-      context "secure headers (2) example" do
-        it "returns true" do
-          expect(secure_headers_policy.headers[0].name).to eq("x-frame-options")
-          expect(secure_headers_policy.headers[0].value).to eq("DENY")
-          expect(secure_headers_policy.headers[1].name).to eq("x-xss-protection")
-          expect(secure_headers_policy.headers[1].value).to eq("1; mode=block")
+      context 'secure headers (2) example' do
+        it 'returns true' do
+          expect(secure_headers_policy.headers[0].name).to eq('x-frame-options')
+          expect(secure_headers_policy.headers[0].value).to eq('DENY')
+          expect(secure_headers_policy.headers[1].name).to eq('x-xss-protection')
+          expect(secure_headers_policy.headers[1].value).to eq('1; mode=block')
         end
       end
     end
     describe SecureHeadersPolicy do
       secure_headers_policy_json = {
-        "policy_id"=>"01a1",
-        "headers"=>[
-          {"name"=>"bad-header", "value"=>"value123"}
+        'policy_id' => '01a1',
+        'headers' => [
+          { 'name' => 'bad-header', 'value' => 'value123' }
         ]
       }
       secure_headers_policy = SecureHeadersPolicy.from_json(secure_headers_policy_json)
-      context "secure header example, invalid header" do
-        it "returns false" do
+      context 'secure header example, invalid header' do
+        it 'returns false' do
           expect(secure_headers_policy.headers.length).to eq(0)
         end
       end
     end
     describe SecureHeadersPolicy do
       secure_headers_policy_json = {
-        "policy_id"=>"01a1",
-        "headers"=>[
-          {"name"=>"x-permitted-cross-domain-policies", "value"=>"value123\\nabc"}
+        'policy_id' => '01a1',
+        'headers' => [
+          { 'name' => 'x-permitted-cross-domain-policies', 'value' => 'value123\\nabc' }
         ]
       }
       secure_headers_policy = SecureHeadersPolicy.from_json(secure_headers_policy_json)
-      context "secure header, value is bad" do
-        it "returns false" do
+      context 'secure header, value is bad' do
+        it 'returns false' do
           expect(secure_headers_policy.headers.length).to eq(0)
         end
       end

data/spec/lib/tcell_agent/rails/better_ip_spec.rb

@@ -2,75 +2,71 @@ require 'spec_helper'
 
 module TCellAgent
   module Utils
-
-    describe ".better_ip" do
-
-      context "with reverse_proxy off" do
-        it "should return the normal ip" do
-          configuration = double("configuration")
-          request = double("request", ip: "127.0.0.0")
+    describe '.better_ip' do
+      context 'with reverse_proxy off' do
+        it 'should return the normal ip' do
+          configuration = double('configuration')
+          request = double('request', :ip => '127.0.0.0')
 
           expect(TCellAgent).to receive(:configuration).and_return(configuration)
           expect(configuration).to receive(:reverse_proxy).and_return(false)
-          expect(Rails.better_ip(request)).to eq("127.0.0.0")
+          expect(Rails.better_ip(request)).to eq('127.0.0.0')
         end
       end
 
-      context "with reverse_proxy on" do
-        context "with empty reverse_proxy_ip_address_header" do
-          it "should return normal ip" do
-            configuration = double("configuration")
-            request = double("request", ip: "127.0.0.0")
-            env = double("env")
+      context 'with reverse_proxy on' do
+        context 'with empty reverse_proxy_ip_address_header' do
+          it 'should return normal ip' do
+            configuration = double('configuration')
+            request = double('request', :ip => '127.0.0.0')
+            env = double('env')
 
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
             expect(configuration).to receive(:reverse_proxy).and_return(true)
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
-            expect(configuration).to receive(:reverse_proxy_ip_address_header).and_return("")
+            expect(configuration).to receive(:reverse_proxy_ip_address_header).and_return('')
             expect(request).to receive(:env).and_return(env)
-            expect(env).to receive(:[]).with("HTTP_X_FORWARDED_FOR").and_return("")
-            expect(Rails.better_ip(request)).to eq("127.0.0.0")
+            expect(env).to receive(:[]).with('HTTP_X_FORWARDED_FOR').and_return('')
+            expect(Rails.better_ip(request)).to eq('127.0.0.0')
           end
         end
 
         context "with reverse_proxy_ip_address_header that doesn't exist" do
-          it "should return normal ip" do
-            configuration = double("configuration")
-            request = double("request", ip: "127.0.0.0")
-            env = double("env")
+          it 'should return normal ip' do
+            configuration = double('configuration')
+            request = double('request', :ip => '127.0.0.0')
+            env = double('env')
 
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
             expect(configuration).to receive(:reverse_proxy).and_return(true)
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
             expect(configuration).to receive(:reverse_proxy_ip_address_header).and_return(
-              "weird-http-proxy-header"
+              'weird-http-proxy-header'
             )
             expect(request).to receive(:env).and_return(env)
-            expect(env).to receive(:[]).with("HTTP_WEIRD_HTTP_PROXY_HEADER").and_return(nil)
-            expect(Rails.better_ip(request)).to eq("127.0.0.0")
+            expect(env).to receive(:[]).with('HTTP_WEIRD_HTTP_PROXY_HEADER').and_return(nil)
+            expect(Rails.better_ip(request)).to eq('127.0.0.0')
           end
         end
 
-        context "with reverse_proxy_ip_address_header that exists" do
-          it "should return proxied ip" do
-            configuration = double("configuration")
-            request = double("request", ip: "127.0.0.0")
-            env = double("env")
+        context 'with reverse_proxy_ip_address_header that exists' do
+          it 'should return proxied ip' do
+            configuration = double('configuration')
+            request = double('request', :ip => '127.0.0.0')
+            env = double('env')
 
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
             expect(configuration).to receive(:reverse_proxy).and_return(true)
             expect(TCellAgent).to receive(:configuration).and_return(configuration)
             expect(configuration).to receive(:reverse_proxy_ip_address_header).and_return(
-              "X-Real-IP"
+              'X-Real-IP'
             )
             expect(request).to receive(:env).and_return(env)
-            expect(env).to receive(:[]).with("HTTP_X_REAL_IP").and_return("192.168.99.100")
-            expect(Rails.better_ip(request)).to eq("192.168.99.100")
+            expect(env).to receive(:[]).with('HTTP_X_REAL_IP').and_return('192.168.99.100')
+            expect(Rails.better_ip(request)).to eq('192.168.99.100')
           end
         end
       end
-
     end
-
   end
 end

data/spec/lib/tcell_agent/rails/logger_spec.rb

@@ -1,52 +1,55 @@
 require 'spec_helper'
 
 describe Logger do
-
-  describe "#add" do
-    context "with a warn logger" do
-      context "writing a debug message" do
-        it "should skip the tcell logic" do
+  describe '#add' do
+    context 'with a warn logger' do
+      context 'writing a debug message' do
+        it 'should skip the tcell logic' do
           expect(TCellAgent::Instrumentation).to_not receive(:safe_block_no_log)
 
           logger = Logger.new('/dev/null')
 
           logger.level = Logger::WARN
-          logger.add(Logger::DEBUG, "This will not be logged")
+          logger.add(Logger::DEBUG, 'This will not be logged')
         end
       end
 
-      context "writing a warn message" do
-        it "should run the tcell logic" do
-          expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with("Handling JSAgent add")
+      context 'writing a warn message' do
+        it 'should run the tcell logic' do
+          expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
+            'Handling DLP log message filtering'
+          )
 
           logger = Logger.new('/dev/null')
 
           logger.level = Logger::WARN
-          logger.add(Logger::WARN, "This will be logged")
+          logger.add(Logger::WARN, 'This will be logged')
         end
       end
 
-      context "writing an error message" do
-        it "should run the tcell logic" do
-          expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with("Handling JSAgent add")
+      context 'writing an error message' do
+        it 'should run the tcell logic' do
+          expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
+            'Handling DLP log message filtering'
+          )
 
           logger = Logger.new('/dev/null')
 
           logger.level = Logger::WARN
-          logger.add(Logger::ERROR, "This will be logged")
+          logger.add(Logger::ERROR, 'This will be logged')
         end
 
-        context "with an empty message" do
-          it "should not run the context filter" do
+        context 'with an empty message' do
+          it 'should not run the context filter' do
             expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
-              "Handling JSAgent add"
+              'Handling DLP log message filtering'
             ).and_call_original
             expect(TCellAgent).to receive(:policy).with(TCellAgent::PolicyTypes::DataLoss).and_return(
-              double("dlp_policy")
+              double('dlp_policy')
             )
             expect(TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS).to receive(
               :fetch
-            ).with(anything(), nil).and_return(double("request_env"))
+            ).with(anything, nil).and_return(double('request_env'))
 
             logger = Logger.new('/dev/null')
 
@@ -55,94 +58,92 @@ describe Logger do
           end
         end
 
-        context "with no dlp policy" do
-          it "should not run the context filter" do
+        context 'with no dlp policy' do
+          it 'should not run the context filter' do
             expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
-              "Handling JSAgent add"
+              'Handling DLP log message filtering'
             ).and_call_original
             expect(TCellAgent).to receive(:policy).with(TCellAgent::PolicyTypes::DataLoss).and_return(
               nil
             )
             expect(TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS).to receive(
               :fetch
-            ).with(anything(), nil).and_return(double("request_env"))
+            ).with(anything, nil).and_return(double('request_env'))
 
             logger = Logger.new('/dev/null')
 
             logger.level = Logger::WARN
-            logger.add(Logger::ERROR, "My DLP Policy :(")
+            logger.add(Logger::ERROR, 'My DLP Policy :(')
           end
         end
 
-        context "with no request env" do
-          it "should not run the context filter" do
+        context 'with no request env' do
+          it 'should not run the context filter' do
             expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
-              "Handling JSAgent add"
+              'Handling DLP log message filtering'
             ).and_call_original
             expect(TCellAgent).to receive(:policy).with(TCellAgent::PolicyTypes::DataLoss).and_return(
-              double("dlp_policy")
+              double('dlp_policy')
             )
             expect(TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS).to receive(
               :fetch
-            ).with(anything(), nil).and_return(nil)
+            ).with(anything, nil).and_return(nil)
 
             logger = Logger.new('/dev/null')
 
             logger.level = Logger::WARN
-            logger.add(Logger::ERROR, "My DLP Policy :(")
+            logger.add(Logger::ERROR, 'My DLP Policy :(')
           end
         end
 
-        context "with a dlp policy, a message, and request env" do
-
-          context "with no tcell_context" do
-            it "should not run the context filter" do
-              request_env = double("request_env")
+        context 'with a dlp policy, a message, and request env' do
+          context 'with no tcell_context' do
+            it 'should not run the context filter' do
+              request_env = double('request_env')
 
               expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
-                "Handling JSAgent add"
+                'Handling DLP log message filtering'
               ).and_call_original
               expect(TCellAgent).to receive(:policy).with(TCellAgent::PolicyTypes::DataLoss).and_return(
-                double("dlp_policy")
+                double('dlp_policy')
               )
               expect(TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS).to receive(
                 :fetch
-              ).with(anything(), nil).and_return(request_env)
+              ).with(anything, nil).and_return(request_env)
               expect(request_env).to receive(:[]).and_return(nil)
 
               logger = Logger.new('/dev/null')
 
               logger.level = Logger::WARN
-              logger.add(Logger::ERROR, "My DLP Policy :(")
+              logger.add(Logger::ERROR, 'My DLP Policy :(')
             end
           end
 
-          context "with tcell_context" do
-            it "should not run the context filter" do
-              request_env = double("request_env")
-              tcell_context = double("tcell_context")
+          context 'with tcell_context' do
+            it 'should not run the context filter' do
+              request_env = double('request_env')
+              tcell_context = double('tcell_context')
 
               expect(TCellAgent::Instrumentation).to receive(:safe_block_no_log).with(
-                "Handling JSAgent add"
+                'Handling DLP log message filtering'
               ).and_call_original
               expect(TCellAgent).to receive(:policy).with(TCellAgent::PolicyTypes::DataLoss).and_return(
-                double("dlp_policy")
+                double('dlp_policy')
               )
               expect(TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS).to receive(
                 :fetch
-              ).with(anything(), nil).and_return(request_env)
+              ).with(anything, nil).and_return(request_env)
               expect(request_env).to receive(:[]).and_return(tcell_context)
-              expect(tcell_context).to receive(:filter_log).with("My DLP Policy :(")
+              expect(tcell_context).to receive(:filter_log).with('My DLP Policy :(')
 
               logger = Logger.new('/dev/null')
 
               logger.level = Logger::WARN
-              logger.add(Logger::ERROR, "My DLP Policy :(")
+              logger.add(Logger::ERROR, 'My DLP Policy :(')
             end
           end
         end
       end
     end
   end
-
 end