tcell_agent 0.2.29 → 0.4.0

data/spec/lib/tcell_agent/policies/appsensor/database_sensor_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-module TCellAgent
-  module Policies
-
-    describe DatabaseSensor do
-
-      context "#initialize" do
-        context "default sensor" do
-          it "should have properties set to defaults" do
-            sensor = DatabaseSensor.new
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.max_rows).to eq(1001)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting enabled on sensor" do
-          it "should have properties set to defaults" do
-            sensor = DatabaseSensor.new({"enabled" => true})
-            expect(sensor.enabled).to eq(true)
-            expect(sensor.max_rows).to eq(1001)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting max_rows on sensor" do
-          it "should have properties set to defaults" do
-            sensor = DatabaseSensor.new({"large_result" => {"limit" => 1}})
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.max_rows).to eq(1)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting excluded routes on sensor" do
-          it "should have properties set to defaults" do
-            sensor = DatabaseSensor.new({"exclude_routes" => ["1", "10", "20"]})
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.max_rows).to eq(1001)
-            expect(sensor.excluded_route_ids).to eq({"1"=>true, "10"=>true, "20"=>true})
-          end
-        end
-      end
-
-      context "#check" do
-        context "with disabled sensor" do
-          it "should not send event" do
-            sensor = DatabaseSensor.new({"enabled" => false})
-
-            expect(TCellAgent).to_not receive(:send_event)
-            sensor.check({}, 10)
-          end
-        end
-
-        context "with enabled sensor" do
-          context "records is less than limit" do
-            it "should not send event" do
-              sensor = DatabaseSensor.new({
-                "enabled" => true,
-                "large_result" => { "limit" => 10},
-                "exclude_routes" => []
-              })
-
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-              sensor.check(tcell_data, 1)
-            end
-          end
-
-          context "records are more than limit" do
-            it "should send event" do
-              sensor = DatabaseSensor.new({
-                "enabled" => true,
-                "large_result" => { "limit" => 10},
-                "exclude_routes" => []
-              })
-
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-              tcell_data.ip_address = "ip_address"
-              tcell_data.request_method = "get"
-              tcell_data.uri = "location"
-              tcell_data.route_id = "route_id"
-              tcell_data.session_id = "session_id"
-              tcell_data.user_id = "user_id"
-              tcell_data.transaction_id = "transaction_id"
-
-              expect(TCellAgent).to receive(:send_event).with(
-                {
-                  "event_type" => "as",
-                  "dp" => DatabaseSensor::DP_CODE,
-                  "remote_addr" => "ip_address",
-                  "rid" => "route_id",
-                  "m" => "get",
-                  "meta" => {"rows" => 11}
-                }
-              )
-              sensor.check(tcell_data, 11)
-            end
-          end
-
-          context "records are more than limit" do
-            context "route_id is excluded" do
-              it "should not send event" do
-                sensor = DatabaseSensor.new({
-                  "enabled" => true,
-                  "large_result" => { "limit" => 10},
-                  "exclude_routes" => ["route_id"]
-                })
-
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.ip_address = "ip_address"
-                tcell_data.request_method = "get"
-                tcell_data.uri = "location"
-                tcell_data.route_id = "route_id"
-                tcell_data.session_id = "session_id"
-                tcell_data.user_id = "user_id"
-                tcell_data.transaction_id = "transaction_id"
-
-                expect(TCellAgent).to_not receive(:send_event)
-
-                sensor.check(tcell_data, 11)
-              end
-            end
-
-            context "route is not excluded" do
-              it "should send event" do
-                sensor = DatabaseSensor.new({
-                  "enabled" => true,
-                  "large_result" => { "limit" => 10},
-                  "exclude_routes" => ["nonmatching_route_id"]
-                })
-
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.ip_address = "ip_address"
-                tcell_data.request_method = "get"
-                tcell_data.uri = "location"
-                tcell_data.route_id = "route_id"
-                tcell_data.session_id = "session_id"
-                tcell_data.user_id = "user_id"
-                tcell_data.transaction_id = "transaction_id"
-
-                expect(TCellAgent).to receive(:send_event).with(
-                  {
-                    "event_type" => "as",
-                    "dp" => DatabaseSensor::DP_CODE,
-                    "remote_addr" => "ip_address",
-                    "rid" => "route_id",
-                    "m" => "get",
-                    "meta" => {"rows" => 11}
-                  }
-                )
-                sensor.check(tcell_data, 11)
-              end
-            end
-          end
-
-        end
-      end
-
-    end
-
-  end
-end

data/spec/lib/tcell_agent/policies/appsensor/misc_sensor_spec.rb

@@ -1,429 +0,0 @@
-require 'spec_helper'
-
-
-module TCellAgent
-  module Policies
-
-    class FakeInvalidAuthenticityToken < StandardError
-    end
-
-    class FakeStatementInvalid < StandardError
-    end
-
-    describe MiscSensor do
-      context "#initialize" do
-        context "default sensor" do
-          it "should have properties set to defaults" do
-            sensor = MiscSensor.new
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.csrf_exception_enabled).to eq(false)
-            expect(sensor.sql_exception_enabled).to eq(false)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting enabled on sensor" do
-          it "should have enabled set" do
-            sensor = MiscSensor.new({"enabled" => true})
-            expect(sensor.enabled).to eq(true)
-            expect(sensor.csrf_exception_enabled).to eq(false)
-            expect(sensor.sql_exception_enabled).to eq(false)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting csrf_exception_enabled on sensor" do
-          it "should csrf_exception_enabled set" do
-            sensor = MiscSensor.new({"csrf_exception_enabled" => true})
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.csrf_exception_enabled).to eq(true)
-            expect(sensor.sql_exception_enabled).to eq(false)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting sql_exception_enabled on sensor" do
-          it "should sql_exception_enabled set" do
-            sensor = MiscSensor.new({"sql_exception_enabled" => true})
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.csrf_exception_enabled).to eq(false)
-            expect(sensor.sql_exception_enabled).to eq(true)
-            expect(sensor.excluded_route_ids).to eq({})
-          end
-        end
-
-        context "setting excluded_route_ids on sensor" do
-          it "should excluded_route_ids set" do
-            sensor = MiscSensor.new({"sql_exception_enabled" => true, "exclude_routes" => ["route_id"]})
-            expect(sensor.enabled).to eq(false)
-            expect(sensor.csrf_exception_enabled).to eq(false)
-            expect(sensor.sql_exception_enabled).to eq(true)
-            expect(sensor.excluded_route_ids).to eq({"route_id" => true})
-          end
-        end
-      end
-
-      describe "#csrf_rejected" do
-        before(:each) do
-          @exception_class = FakeInvalidAuthenticityToken
-        end
-
-        context "with disabled sensor" do
-          context "with disabled csrf_exception_enabled sensor" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => false, "csrf_exception_enabled" => false})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.csrf_rejected(tcell_data, @exception_class)
-            end
-          end
-
-          context "with enabled csrf_exception_enabled" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => false, "csrf_exception_enabled" => true})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.csrf_rejected(tcell_data, @exception_class)
-            end
-
-            context "with nil tcell-data" do
-              it "should not send event" do
-                sensor = MiscSensor.new({"enabled" => false, "csrf_exception_enabled" => true})
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-                expect(TCellAgent).to_not receive(:send_event)
-
-                sensor.csrf_rejected(tcell_data, @exception_class)
-              end
-            end
-          end
-        end
-
-        context "with enabled sensor" do
-          context "with disabled csrf_exception_enabled sensor" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => true, "csrf_exception_enabled" => false})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.csrf_rejected(tcell_data, @exception_class)
-            end
-
-            context "no excluded routes" do
-              it "should not send an event" do
-                sensor = MiscSensor.new({
-                  "enabled" => true,
-                  "csrf_exception_enabled" => false,
-                  "exclude_routes" => []
-                })
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.route_id = "route_id"
-
-                expect(TCellAgent).to_not receive(:send_event)
-
-                sensor.csrf_rejected(tcell_data, @exception_class)
-              end
-            end
-
-            context "has excluded routes" do
-              context "route id matches" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "csrf_exception_enabled" => false,
-                    "exclude_routes" => []
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.csrf_rejected(tcell_data, @exception_class)
-                end
-              end
-
-              context "route id does not match" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "csrf_exception_enabled" => false,
-                    "exclude_routes" => ["nonmatching"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.csrf_rejected(tcell_data, @exception_class)
-                end
-              end
-            end
-          end
-
-          context "with enabled csrf_exception_enabled" do
-            it "should send event" do
-              sensor = MiscSensor.new({"enabled" => true, "csrf_exception_enabled" => true})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to receive(:send_event).with({
-                "event_type"=>"as",
-                "dp"=>"excsrf",
-                "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken"
-              })
-
-              sensor.csrf_rejected(tcell_data, @exception_class)
-            end
-
-            context "no excluded routes" do
-              it "should send an event" do
-                sensor = MiscSensor.new({
-                  "enabled" => true,
-                  "csrf_exception_enabled" => true,
-                  "exclude_routes" => []
-                })
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.route_id = "route_id"
-
-                expect(TCellAgent).to receive(:send_event).with({
-                  "event_type"=>"as",
-                  "dp"=>"excsrf",
-                  "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken",
-                  "rid"=>"route_id"
-                })
-
-                sensor.csrf_rejected(tcell_data, @exception_class)
-              end
-            end
-
-            context "has excluded routes" do
-              context "route id matches" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "csrf_exception_enabled" => true,
-                    "exclude_routes" => ["route_id"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.csrf_rejected(tcell_data, @exception_class)
-                end
-              end
-
-              context "route id does not match" do
-                it "should send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "csrf_exception_enabled" => true,
-                    "exclude_routes" => ["nonmatching"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to receive(:send_event).with({
-                    "event_type"=>"as",
-                    "dp"=>"excsrf",
-                    "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken",
-                    "rid"=>"route_id"
-                  })
-
-                  sensor.csrf_rejected(tcell_data, @exception_class)
-                end
-              end
-            end
-          end
-        end
-
-      end
-
-      describe "#sql_exception_enabled" do
-        before(:each) do
-          @exception = FakeStatementInvalid.new
-        end
-
-        context "with disabled sensor" do
-          context "with disabled sql_exception_enabled sensor" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => false, "sql_exception_enabled" => false})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.sql_exception_detected(tcell_data, @exception)
-            end
-          end
-
-          context "with enabled sql_exception_enabled" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => false, "sql_exception_enabled" => true})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.sql_exception_detected(tcell_data, @exception)
-            end
-
-            context "with nil tcell-data" do
-              it "should not send event" do
-                sensor = MiscSensor.new({"enabled" => false, "sql_exception_enabled" => true})
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-                expect(TCellAgent).to_not receive(:send_event)
-
-                sensor.sql_exception_detected(tcell_data, @exception)
-              end
-            end
-          end
-        end
-
-        context "with enabled sensor" do
-          context "with disabled sql_exception_enabled sensor" do
-            it "should not send event" do
-              sensor = MiscSensor.new({"enabled" => true, "sql_exception_enabled" => false})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              sensor.sql_exception_detected(tcell_data, @exception)
-            end
-
-            context "no excluded routes" do
-              it "should not send an event" do
-                sensor = MiscSensor.new({
-                  "enabled" => true,
-                  "sql_exception_enabled" => false,
-                  "exclude_routes" => []
-                })
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.route_id = "route_id"
-
-                expect(TCellAgent).to_not receive(:send_event)
-
-                sensor.sql_exception_detected(tcell_data, @exception)
-              end
-            end
-
-            context "has excluded routes" do
-              context "route id matches" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "sql_exception_enabled" => false,
-                    "exclude_routes" => []
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.sql_exception_detected(tcell_data, @exception)
-                end
-              end
-
-              context "route id does not match" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "sql_exception_enabled" => false,
-                    "exclude_routes" => ["nonmatching"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.sql_exception_detected(tcell_data, @exception)
-                end
-              end
-            end
-          end
-
-          context "with enabled sql_exception_enabled" do
-            it "should send event" do
-              sensor = MiscSensor.new({"enabled" => true, "sql_exception_enabled" => true})
-              tcell_data = TCellAgent::Instrumentation::TCellData.new
-
-              expect(TCellAgent).to receive(:send_event).with({
-                "event_type"=>"as",
-                "dp"=>"exsql",
-                "param"=>"TCellAgent::Policies::FakeStatementInvalid"
-              })
-
-              sensor.sql_exception_detected(tcell_data, @exception)
-            end
-
-            context "no excluded routes" do
-              it "should send an event" do
-                sensor = MiscSensor.new({
-                  "enabled" => true,
-                  "sql_exception_enabled" => true,
-                  "exclude_routes" => []
-                })
-                tcell_data = TCellAgent::Instrumentation::TCellData.new
-                tcell_data.route_id = "route_id"
-
-                expect(TCellAgent).to receive(:send_event).with({
-                  "event_type"=>"as",
-                  "dp"=>"exsql",
-                  "param"=>"TCellAgent::Policies::FakeStatementInvalid",
-                  "rid"=>"route_id"
-                })
-
-                sensor.sql_exception_detected(tcell_data, @exception)
-              end
-            end
-
-            context "has excluded routes" do
-              context "route id matches" do
-                it "should not send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "sql_exception_enabled" => true,
-                    "exclude_routes" => ["route_id"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to_not receive(:send_event)
-
-                  sensor.sql_exception_detected(tcell_data, @exception)
-                end
-              end
-
-              context "route id does not match" do
-                it "should send an event" do
-                  sensor = MiscSensor.new({
-                    "enabled" => true,
-                    "sql_exception_enabled" => true,
-                    "exclude_routes" => ["nonmatching"]
-                  })
-                  tcell_data = TCellAgent::Instrumentation::TCellData.new
-                  tcell_data.route_id = "route_id"
-
-                  expect(TCellAgent).to receive(:send_event).with({
-                    "event_type"=>"as",
-                    "dp"=>"exsql",
-                    "param"=>"TCellAgent::Policies::FakeStatementInvalid",
-                    "rid"=>"route_id"
-                  })
-
-                  sensor.sql_exception_detected(tcell_data, @exception)
-                end
-              end
-            end
-          end
-        end
-
-      end
-
-    end
-
-  end
-end