tcell_agent 0.4.0 → 1.0.0

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

@@ -2,62 +2,61 @@ require 'spec_helper'
 
 module TCellAgent
   module SensorEvents
-
     describe Agent do
-
-      describe ".increment_session_info" do
-        context "when running the parent process" do
-          it "should increment the session info" do
+      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).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"
+              'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
             )
             expect_any_instance_of(SessionsMetric).to receive(:flush).and_return(false)
             expect(TCellAgent).to_not receive(:send_event)
 
-            TCellAgent.increment_session_info("hmac_session_id", "user_id", "ip_address", "user_agent")
+            TCellAgent.increment_session_info('hmac_session_id', 'user_id', 'ip_address', 'user_agent')
           end
 
-          context "and the session becomes full" do
-            it "should increment the session info and send the flush dummy event" do
+          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).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"
+                'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
               )
               expect_any_instance_of(SessionsMetric).to receive(:flush).and_return(true)
               expect(TCellAgent).to receive(:send_event).with(
                 instance_of(TCellAgent::SensorEvents::FlushDummyEvent)
               )
 
-              TCellAgent.increment_session_info("hmac_session_id", "user_id", "ip_address", "user_agent")
+              TCellAgent.increment_session_info('hmac_session_id', 'user_id', 'ip_address', 'user_agent')
             end
           end
         end
 
-        context "when NOT running the parent process" do
-          it "should queue the metric" do
+        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).to receive(:queue_metric).with({
-              "_type"=>"increment_session_info",
-              "hmac_session_id"=>"hmac_session_id",
-              "user_id"=>"user_id",
-              "ip_address"=>"ip_address",
-              "user_agent"=>"user_agent"
-            })
+            expect(TCellAgent).to receive(:queue_metric).with(
+              {
+                '_type' => 'increment_session_info',
+                'hmac_session_id' => 'hmac_session_id',
+                'user_id' => 'user_id',
+                'ip_address' => 'ip_address',
+                'user_agent' => 'user_agent'
+              }
+            )
             expect_any_instance_of(SessionsMetric).to_not receive(:add_session_info)
             expect_any_instance_of(SessionsMetric).to_not receive(:flush)
             expect(TCellAgent).to_not receive(:send_event)
 
-            TCellAgent.increment_session_info("hmac_session_id", "user_id", "ip_address", "user_agent")
+            TCellAgent.increment_session_info('hmac_session_id', 'user_id', 'ip_address', 'user_agent')
           end
         end
       end
 
-      describe ".increment_route" do
-        context "when running the parent process" do
-
+      describe '.increment_route' do
+        context 'when running the parent process' do
           before(:each) do
             TCellAgent.thread_agent.response_time_table = {}
           end
@@ -65,48 +64,47 @@ module TCellAgent
             TCellAgent.thread_agent.response_time_table = {}
           end
 
-          context "with a route present" do
-            it "should increment the route info" do
+          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).to_not receive(:queue_metric)
 
-              TCellAgent.increment_route("/ma_route", 20)
+              TCellAgent.increment_route('/ma_route', 20)
 
               expect(TCellAgent.thread_agent.response_time_table).to eq(
-                {"/ma_route"=>{"c"=>1, "mx"=>20, "mn"=>20, "t"=>20}}
+                { '/ma_route' => { 'c' => 1, 'mx' => 20, 'mn' => 20, 't' => 20 } }
               )
             end
           end
 
-          context "with an empty route" do
-            it "should increment the route info" do
+          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).to_not receive(:queue_metric)
 
-              TCellAgent.increment_route("", 20)
+              TCellAgent.increment_route('', 20)
 
               expect(TCellAgent.thread_agent.response_time_table).to eq(
-                {"?"=>{"c"=>1, "mx"=>20, "mn"=>20, "t"=>20}}
+                { '?' => { 'c' => 1, 'mx' => 20, 'mn' => 20, 't' => 20 } }
               )
             end
           end
 
-          context "with a nil route" do
-            it "should increment the route info" do
+          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).to_not receive(:queue_metric)
 
               TCellAgent.increment_route(nil, 20)
 
               expect(TCellAgent.thread_agent.response_time_table).to eq(
-                {"?"=>{"c"=>1, "mx"=>20, "mn"=>20, "t"=>20}}
+                { '?' => { 'c' => 1, 'mx' => 20, 'mn' => 20, 't' => 20 } }
               )
             end
           end
-
         end
 
-        context "when NOT running the parent process" do
+        context 'when NOT running the parent process' do
           before(:each) do
             TCellAgent.thread_agent.response_time_table = {}
           end
@@ -114,23 +112,22 @@ module TCellAgent
             TCellAgent.thread_agent.response_time_table = {}
           end
 
-          it "should queue the metric" do
+          it 'should queue the metric' do
             expect(TCellAgent::Agent).to receive(:is_parent_process?).and_return(false)
-            expect(TCellAgent).to receive(:queue_metric).with({
-              "_type"=>"increment_route",
-              "route_id"=>"/ma_route",
-              "response_time"=>20
-            })
+            expect(TCellAgent).to receive(:queue_metric).with(
+              {
+                '_type' => 'increment_route',
+                'route_id' => '/ma_route',
+                'response_time' => 20
+              }
+            )
 
-            TCellAgent.increment_route("/ma_route", 20)
+            TCellAgent.increment_route('/ma_route', 20)
 
             expect(TCellAgent.thread_agent.response_time_table).to eq({})
           end
         end
       end
-
     end
-
   end
 end
-

data/spec/lib/tcell_agent/api/api_spec.rb

@@ -1,35 +1,35 @@
 require 'spec_helper'
 require 'addressable/template'
 
-
 module TCellAgent
   class TCellApi
-    describe "successful POST on /user/create" do
-      it "should redirect to dashboard" do
+    describe 'successful POST on /user/create' do
+      it 'should redirect to dashboard' do
         tapi = TCellApi.new
-        TCellAgent.configuration.app_id = "test-appid"
-        TCellAgent.configuration.api_key = "test-apikey"
+        TCellAgent.configuration.app_id = 'test-appid'
+        TCellAgent.configuration.api_key = 'test-apikey'
 
-        def checkreq(req)
-          return '{"result":{"csp-headers":{"app_id":"testapp-Becwu","policy_id":' \
+        def checkreq(_req)
+          '{"result":{"csp-headers":{"app_id":"testapp-Becwu","policy_id":' \
           '"acf60560-4e76-11e5-874c-7d71d425b275","headers":[{"name":"Content-Security-Policy-Report-Only",' \
           '"value":"font-src \'none\'; script-src \'self\'; reflected-xss block; ' \
           'style-src \'self\'; connect-src' \
           ' \'none\'" ,"report-uri":"http://localhost:3000/csp/cab5e750e66d614bd46fd07a7078db1e74b4f427b2a135b2c96eca684a642707"}]}}}'
         end
         uri_template =
-          Addressable::Template.new "https://api.tcell.io/api/v1/app/{app}/update"
-        stub_request(:any, uri_template).
-          to_return(lambda { |request| {
-            :body => checkreq(request),  :status => 200,
-            :headers => { 'Content-Tyoe' => 'application/json' }
-          } })
+          Addressable::Template.new 'https://api.tcell.io/api/v1/app/{app}/update'
+        stub_request(:any, uri_template)
+          .to_return(lambda { |request|
+            {
+              :body => checkreq(request),  :status => 200,
+              :headers => { 'Content-Tyoe' => 'application/json' }
+            }
+          })
 
-        #  to_return(:body => resbody,
-        result = tapi.poll_api()
+        result = tapi.poll_api
         TCellAgent.configuration.app_id = nil
         TCellAgent.configuration.api_key = nil
-        expect(result["csp-headers"]["app_id"]).to eq("testapp-Becwu")
+        expect(result['csp-headers']['app_id']).to eq('testapp-Becwu')
       end
     end
   end

data/spec/lib/tcell_agent/appsensor/injections_reporter_spec.rb

@@ -2,11 +2,10 @@ require 'spec_helper'
 
 module TCellAgent
   module AppSensor
-
     describe InjectionsReporter do
-      describe ".report_and_log" do
-        context "with nil events" do
-          it "should do nothing" do
+      describe '.report_and_log' do
+        context 'with nil events' do
+          it 'should do nothing' do
             expect(TCellAgent).to_not receive(:send_event)
             expect(TCellAgent).to_not receive(:logger)
 
@@ -14,8 +13,8 @@ module TCellAgent
           end
         end
 
-        context "with empty events" do
-          it "should do nothing" do
+        context 'with empty events' do
+          it 'should do nothing' do
             expect(TCellAgent).to_not receive(:send_event)
             expect(TCellAgent).to_not receive(:logger)
 
@@ -23,145 +22,161 @@ module TCellAgent
           end
         end
 
-        context "with one event" do
-          it "should send the event" do
-            events = [{
-                "pattern" => "1",
-                "method" => "request_method",
-                "uri" => "abosolute_uri",
-                "parameter" => "avatar",
-                "meta" => {"l" => "body"},
-                "session_id" => "session_id",
-                "route_id" => "route_id",
-                "detection_point" => "xss",
-                "user_id" => "user_id"
-            }]
+        context 'with one event' do
+          it 'should send the event' do
+            events = [
+              {
+                'pattern' => '1',
+                'method' => 'request_method',
+                'uri' => 'abosolute_uri',
+                'parameter' => 'avatar',
+                'meta' => { 'l' => 'body' },
+                'session_id' => 'session_id',
+                'route_id' => 'route_id',
+                'detection_point' => 'xss',
+                'user_id' => 'user_id'
+              }
+            ]
 
             expect(TCellAgent).to_not receive(:logger)
 
-            expect(TCellAgent).to receive(:send_event).with({
-              "event_type" => "as",
-              "dp" => "xss",
-              "param" => "avatar",
-              "m" => "request_method",
-              "pattern" => "1",
-              "meta" => {"l" => "body"},
-              "rid" => "route_id",
-              "uri" => "abosolute_uri",
-              "uid" => "user_id",
-              "sid" => "session_id"
-            })
+            expect(TCellAgent).to receive(:send_event).with(
+              {
+                'event_type' => 'as',
+                'dp' => 'xss',
+                'param' => 'avatar',
+                'm' => 'request_method',
+                'pattern' => '1',
+                'meta' => { 'l' => 'body' },
+                'rid' => 'route_id',
+                'uri' => 'abosolute_uri',
+                'uid' => 'user_id',
+                'sid' => 'session_id'
+              }
+            )
 
             InjectionsReporter.report_and_log(events)
           end
         end
 
-        context "with one event with full payload" do
-          it "should send and log the event" do
-            events = [{
-                "pattern" => "1",
-                "method" => "request_method",
-                "uri" => "abosolute_uri",
-                "parameter" => "avatar",
-                "meta" => {"l" => "body"},
-                "session_id" => "session_id",
-                "route_id" => "route_id",
-                "detection_point" => "xss",
-                "user_id" => "user_id",
-                "full_payload" => "full_payload"
-            }]
-
-            logger = double("logger")
+        context 'with one event with full payload' do
+          it 'should send and log the event' do
+            events = [
+              {
+                'pattern' => '1',
+                'method' => 'request_method',
+                'uri' => 'abosolute_uri',
+                'parameter' => 'avatar',
+                'meta' => { 'l' => 'body' },
+                'session_id' => 'session_id',
+                'route_id' => 'route_id',
+                'detection_point' => 'xss',
+                'user_id' => 'user_id',
+                'full_payload' => 'full_payload'
+              }
+            ]
+
+            logger = double('logger')
 
             expect(TCellAgent).to receive(:logger).and_return(logger)
             expect(logger).to receive(:info).with(/"payload":"full_payload"/)
 
-            expect(TCellAgent).to receive(:send_event).with({
-              "event_type" => "as",
-              "dp" => "xss",
-              "param" => "avatar",
-              "m" => "request_method",
-              "pattern" => "1",
-              "meta" => {"l" => "body"},
-              "rid" => "route_id",
-              "uri" => "abosolute_uri",
-              "uid" => "user_id",
-              "sid" => "session_id"
-            })
+            expect(TCellAgent).to receive(:send_event).with(
+              {
+                'event_type' => 'as',
+                'dp' => 'xss',
+                'param' => 'avatar',
+                'm' => 'request_method',
+                'pattern' => '1',
+                'meta' => { 'l' => 'body' },
+                'rid' => 'route_id',
+                'uri' => 'abosolute_uri',
+                'uid' => 'user_id',
+                'sid' => 'session_id'
+              }
+            )
 
             InjectionsReporter.report_and_log(events)
           end
         end
 
-        context "with one event with payload" do
-          it "should send the event" do
-            events = [{
-                "pattern" => "1",
-                "method" => "request_method",
-                "uri" => "abosolute_uri",
-                "parameter" => "avatar",
-                "meta" => {"l" => "body"},
-                "session_id" => "session_id",
-                "route_id" => "route_id",
-                "detection_point" => "xss",
-                "user_id" => "user_id",
-                "payload" => "payload"
-            }]
+        context 'with one event with payload' do
+          it 'should send the event' do
+            events = [
+              {
+                'pattern' => '1',
+                'method' => 'request_method',
+                'uri' => 'abosolute_uri',
+                'parameter' => 'avatar',
+                'meta' => { 'l' => 'body' },
+                'session_id' => 'session_id',
+                'route_id' => 'route_id',
+                'detection_point' => 'xss',
+                'user_id' => 'user_id',
+                'payload' => 'payload'
+              }
+            ]
 
             expect(TCellAgent).to_not receive(:logger)
 
-            expect(TCellAgent).to receive(:send_event).with({
-              "event_type" => "as",
-              "dp" => "xss",
-              "param" => "avatar",
-              "m" => "request_method",
-              "pattern" => "1",
-              "meta" => {"l" => "body"},
-              "rid" => "route_id",
-              "uri" => "abosolute_uri",
-              "uid" => "user_id",
-              "sid" => "session_id",
-              "payload" => "payload"
-            })
+            expect(TCellAgent).to receive(:send_event).with(
+              {
+                'event_type' => 'as',
+                'dp' => 'xss',
+                'param' => 'avatar',
+                'm' => 'request_method',
+                'pattern' => '1',
+                'meta' => { 'l' => 'body' },
+                'rid' => 'route_id',
+                'uri' => 'abosolute_uri',
+                'uid' => 'user_id',
+                'sid' => 'session_id',
+                'payload' => 'payload'
+              }
+            )
 
             InjectionsReporter.report_and_log(events)
           end
         end
 
-        context "with one event with payload and full payload" do
-          it "should send and log the event" do
-            events = [{
-                "pattern" => "1",
-                "method" => "request_method",
-                "uri" => "abosolute_uri",
-                "parameter" => "avatar",
-                "meta" => {"l" => "body"},
-                "session_id" => "session_id",
-                "route_id" => "route_id",
-                "detection_point" => "xss",
-                "user_id" => "user_id",
-                "payload" => "payload",
-                "full_payload" => "full_payload"
-            }]
-
-            logger = double("logger")
+        context 'with one event with payload and full payload' do
+          it 'should send and log the event' do
+            events = [
+              {
+                'pattern' => '1',
+                'method' => 'request_method',
+                'uri' => 'abosolute_uri',
+                'parameter' => 'avatar',
+                'meta' => { 'l' => 'body' },
+                'session_id' => 'session_id',
+                'route_id' => 'route_id',
+                'detection_point' => 'xss',
+                'user_id' => 'user_id',
+                'payload' => 'payload',
+                'full_payload' => 'full_payload'
+              }
+            ]
+
+            logger = double('logger')
 
             expect(TCellAgent).to receive(:logger).and_return(logger)
             expect(logger).to receive(:info).with(/"payload":"full_payload"/)
 
-            expect(TCellAgent).to receive(:send_event).with({
-              "event_type" => "as",
-              "dp" => "xss",
-              "param" => "avatar",
-              "m" => "request_method",
-              "pattern" => "1",
-              "meta" => {"l" => "body"},
-              "rid" => "route_id",
-              "uri" => "abosolute_uri",
-              "uid" => "user_id",
-              "sid" => "session_id",
-              "payload" => "payload"
-            })
+            expect(TCellAgent).to receive(:send_event).with(
+              {
+                'event_type' => 'as',
+                'dp' => 'xss',
+                'param' => 'avatar',
+                'm' => 'request_method',
+                'pattern' => '1',
+                'meta' => { 'l' => 'body' },
+                'rid' => 'route_id',
+                'uri' => 'abosolute_uri',
+                'uid' => 'user_id',
+                'sid' => 'session_id',
+                'payload' => 'payload'
+              }
+            )
 
             InjectionsReporter.report_and_log(events)
           end