tcell_agent 1.1.12 → 2.0.0

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module TCellAgent
+  module Policies
+    describe JsAgentPolicy do
+      describe '#initialize' do
+        context 'empty enablements' do
+          it 'should disable the policy' do
+            native_agent = double('native_agent')
+            policy = JsAgentPolicy.new(native_agent, {})
+            expect(policy.enabled).to eq(false)
+          end
+        end
+      end
+
+      describe '#check_redirect' do
+        context 'with disabled policy' do
+          it 'should not call the native library' do
+            native_agent = double('native_agent')
+            policy = JsAgentPolicy.new(native_agent, {})
+
+            expect(native_agent).to_not receive(:get_js_agent_script_tag)
+
+            tcell_context = double('tcell_context')
+            expect(
+              policy.get_js_agent_script_tag(tcell_context)
+            ).to eq(nil)
+          end
+        end
+
+        context 'with native agent' do
+          before(:each) do
+            configuration = TCellAgent::Tests::ConfigurationBuilder.new.build
+            @native_agent = TCellAgent::Rust::NativeAgent.create_agent(
+              configuration
+            )
+          end
+
+          after(:each) do
+            TCellAgent::Rust::NativeAgent.free_agent(@native_agent.agent_ptr)
+          end
+
+          context 'enabled js agent policy' do
+            it 'should return js agent script tag' do
+              enablements = @native_agent.update_policies(
+                {
+                  'jsagentinjection' => {
+                    'enabled' => true,
+                    'api_key' => 'AQABBA',
+                    'excludes' => [],
+                    'policy_id' => 'jsagentinjection-v1-1',
+                    'version' => 1
+                  }
+                }
+              )['enablements']
+              expect(enablements['jsagentinjection']).to eq(true)
+
+              @policy = JsAgentPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.build
+              expect(
+                @policy.get_js_agent_script_tag(tcell_context)
+              ).to eq(
+                '<script src="https://jsagent.tcell.io/tcellagent.min.js" ' \
+                'tcellappid="TestAppId-AppId" tcellapikey="AQABBA" ' \
+                'tcellbaseurl="https://api.tcell-preview.io/agents/api/v1"></script>'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,44 +2,176 @@ require 'spec_helper'
 
 module TCellAgent
   module Policies
-    describe LoginFraudPolicy do
-      policy_json_empty = {
-        'policy_id' => '01a1',
-        'data' => {
-          'options' => {}
-        }
-      }
-
-      policy_json_one = {
-        'policy_id' => '01a1',
-        'data' => {
-          'options' => {
-            'login_failed_enabled' => true,
-            'login_success_enabled' => true,
-            'session_hijacking_enabled' => true
-          }
-        }
-      }
-
-      empty_policy = LoginFraudPolicy.from_json(policy_json_empty)
-      context 'test empty agent' do
-        it 'enabled is false' do
-          expect(empty_policy.policy_id).to eq('01a1')
-          expect(empty_policy.login_failed_enabled).to eq(false)
-          expect(empty_policy.login_success_enabled).to eq(false)
-          expect(empty_policy.session_hijacking_metrics).to eq(false)
+    describe LoginPolicy do
+      describe '#initialize' do
+        context 'empty enablements' do
+          it 'should disable the policy' do
+            native_agent = double('native_agent')
+            policy = LoginPolicy.new(native_agent, {})
+            expect(policy.login_success_enabled).to eq(false)
+            expect(policy.login_failed_enabled).to eq(false)
+          end
         end
       end
 
-      policy_one = LoginFraudPolicy.from_json(policy_json_one)
-      context 'enabled agent' do
-        it 'enabled is true' do
-          expect(empty_policy.policy_id).to eq('01a1')
-          expect(policy_one.login_failed_enabled).to eq(true)
-          expect(policy_one.login_success_enabled).to eq(true)
-          expect(policy_one.session_hijacking_metrics).to eq(true)
+      context 'with native agent' do
+        before(:each) do
+          configuration = TCellAgent::Tests::ConfigurationBuilder.new.build
+          @native_agent = TCellAgent::Rust::NativeAgent.create_agent(
+            configuration
+          )
+        end
+
+        after(:each) do
+          TCellAgent::Rust::NativeAgent.free_agent(@native_agent.agent_ptr)
+        end
+
+        describe '#report_login_success' do
+          context 'with disabled policy' do
+            it 'should not call the native library' do
+              native_agent = double('native_agent')
+              policy = LoginPolicy.new(native_agent, {})
+
+              expect(native_agent).to_not receive(:login_fraud_apply)
+
+              user_id = double('user_id')
+              headers = double('headers')
+              tcell_context = double('tcell_context')
+              expect(
+                policy.report_login_success(user_id, headers, tcell_context)
+              ).to eq({})
+            end
+          end
+
+          context 'with enabled policy' do
+            it 'should report login success' do
+              enablements = @native_agent.update_policies(
+                {
+                  'login' => {
+                    'policy_id' => '00a1',
+                    'version' => 1,
+                    'data' => {
+                      'options' => {
+                        'login_failed_enabled' => true,
+                        'login_success_enabled' => true
+                      }
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['login_success_enabled']).to eq(true)
+
+              @policy = LoginPolicy.new(@native_agent, enablements)
+              expect(@policy.login_success_enabled).to eq(true)
+
+              user_id = 'user-id'
+              headers = ['user-agent']
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'user_id', 'user-id'
+              ).build
+              expect(
+                @policy.report_login_success(user_id, headers, tcell_context)
+              ).to eq(
+                { 'events_created' => 1 }
+              )
+            end
+          end
+        end
+
+        describe '#report_login_failure' do
+          context 'with disabled policy' do
+            it 'should not call the native library' do
+              native_agent = double('native_agent')
+              policy = LoginPolicy.new(native_agent, {})
+
+              expect(native_agent).to_not receive(:login_fraud_apply)
+
+              user_id = double('user_id')
+              password = nil
+              headers = double('headers')
+              user_valid = false
+              tcell_context = double('tcell_context')
+              expect(
+                policy.report_login_failure(
+                  user_id,
+                  password,
+                  headers,
+                  user_valid,
+                  tcell_context
+                )
+              ).to eq({})
+            end
+          end
+
+          context 'with enabled policy' do
+            it 'should report login failure' do
+              enablements = @native_agent.update_policies(
+                {
+                  'login' => {
+                    'policy_id' => '00a1',
+                    'version' => 1,
+                    'data' => {
+                      'options' => {
+                        'login_failed_enabled' => true,
+                        'login_success_enabled' => true
+                      }
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['login_failed_enabled']).to eq(true)
+
+              @policy = LoginPolicy.new(@native_agent, enablements)
+              expect(@policy.login_failed_enabled).to eq(true)
+
+              user_id = 'user-id'
+              password = nil
+              headers = ['user-agent']
+              user_valid = nil
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'user_id', 'user-id'
+              ).build
+              expect(
+                @policy.report_login_failure(
+                  user_id,
+                  password,
+                  headers,
+                  user_valid,
+                  tcell_context
+                )
+              ).to eq(
+                { 'events_created' => 1 }
+              )
+            end
+          end
         end
       end
     end
   end
 end
+
+#    def login_failed_test(self):
+#        policies_rsp = self.native_agent.update_policies({
+#            "login": {
+#                "policy_id": "00a1",
+#                "version": 1,
+#                "data": {
+#                    "options": {
+#                        "login_failed_enabled": True,
+#                        "login_success_enabled": True
+#                    }
+#                }
+#            }
+#        })
+
+#        login_policy = LoginPolicy(self.native_agent, policies_rsp["enablements"], None)
+#        context = ContextBuilder().update_attribute("user_id", "user-id").build()
+#        response = login_policy.report_login_failure(
+#            user_id="user-id",
+#            password="password",
+#            header_keys=["user-agent", "content-length"],
+#            user_valid=False,
+#            tcell_context=context
+#        )
+#
+#        self.assertEqual(response, {"events_created": 1})

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

@@ -2,308 +2,115 @@ require 'spec_helper'
 
 module TCellAgent
   module Policies
-    describe RustPolicies do
-      before(:each) do
-        configuration = double(
-          'configuration',
-          {
-            'app_id' => 'app_id',
-            'api_key' => 'api_key',
-            'allow_payloads' => true,
-            'js_agent_api_base_url' => 'http://api.tcell.com/',
-            'js_agent_url' => 'https://jsagent.tcell.io/tcellagent.min.js',
-            'max_csp_header_bytes' => nil
-          }
-        )
-        expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-        @rust_policies = RustPolicies.new
-      end
-
-      describe '#update_policies' do
-        context 'with a nil policy' do
-          it 'should return nil' do
-            expect(TCellAgent).to_not receive(:logger)
-
-            @rust_policies.update_policies(nil)
-
-            expect(@rust_policies.patches_enabled).to eq(false)
-          end
-        end
-
-        context 'with an empty policy' do
-          it 'should raise a policy missing error' do
-            expect(TCellAgent).to_not receive(:logger)
-
-            @rust_policies.update_policies({})
-
-            expect(@rust_policies.patches_enabled).to eq(false)
-          end
-        end
-
-        context 'with an empty version' do
-          it 'should have empty version' do
-            logger = double('logger')
-
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              'Error updating policies: Failed to decode patches policy: missing field `version`'
-            )
-            @rust_policies.update_policies(
+    describe PatchesPolicy do
+      blocked_ip_policy = {
+        'patches' => {
+          'policy_id' => 'policy_id',
+          'version' => 2,
+          'data' => {
+            'rules' => [
               {
-                'patches' => {
-                  'policy_id' => 'policy_id'
-                }
+                'id' => 'blocked-ips-rule',
+                'title' => 'Blocked ips rule',
+                'action' => 'BlockIf',
+                'destinations' => { 'check_equals' => [{ 'path' => '*' }] },
+                'ignore' => [],
+                'matches' => [
+                  {
+                    'all' => [],
+                    'any' => [
+                      {
+                        'ips' => [{ 'type' => 'IP', 'values' => ['1.1.1.1'] }]
+                      }
+                    ]
+                  }
+                ]
               }
-            )
-
-            expect(@rust_policies.patches_enabled).to eq(false)
+            ]
+          }
+        }
+      }
+
+      describe '#initialize' do
+        context 'empty enablements' do
+          it 'should disable the policy' do
+            native_agent = double('native_agent')
+            policy = PatchesPolicy.new(native_agent, {})
+            expect(policy.enabled).to eq(false)
           end
         end
+      end
 
-        context 'with an empty data' do
-          it 'should have disabled ip blocking' do
-            expect(TCellAgent).to_not receive(:logger)
+      describe '#block_request?' do
+        context 'with disabled policy' do
+          it 'should not call the native library' do
+            native_agent = double('native_agent')
+            policy = PatchesPolicy.new(native_agent, {})
 
-            @rust_policies.update_policies(
-              {
-                'patches' => {
-                  'policy_id' => 'policy_id',
-                  'version' => 1
-                }
-              }
-            )
+            expect(native_agent).to_not receive(:apply_patches)
 
-            expect(@rust_policies.patches_enabled).to eq(false)
+            appsensor_meta = double('appsensor_meta')
+            policy.block_request?(appsensor_meta)
           end
         end
 
-        context 'with an empty block_rules' do
-          it 'should have disabled ip blocking' do
-            expect(TCellAgent).to_not receive(:logger)
-
-            @rust_policies.update_policies(
-              {
-                'patches' => {
-                  'policy_id' => 'policy_id',
-                  'version' => 1,
-                  'data' => {}
-                }
-              }
+        context 'with blocked ip policy' do
+          before(:each) do
+            configuration = TCellAgent::Tests::ConfigurationBuilder.new.build
+            @native_agent = TCellAgent::Rust::NativeAgent.create_agent(
+              configuration
             )
+            enablements = @native_agent.update_policies(
+              blocked_ip_policy
+            )['enablements']
+            expect(enablements['patches']).to eq(true)
 
-            expect(@rust_policies.patches_enabled).to eq(true)
+            @policy = PatchesPolicy.new(@native_agent, enablements)
+            expect(@policy.enabled).to eq(true)
           end
-        end
 
-        context 'with blocked_ips' do
-          context 'as an empty list' do
-            it 'should have ip blocking disabled' do
-              expect(TCellAgent).to_not receive(:logger)
-
-              @rust_policies.update_policies(
-                {
-                  'patches' => {
-                    'policy_id' => 'policy_id',
-                    'version' => 1,
-                    'data' => {
-                      'blocked_ips' => []
-                    }
-                  }
-                }
-              )
-
-              expect(@rust_policies.patches_enabled).to eq(true)
-            end
+          after(:each) do
+            TCellAgent::Rust::NativeAgent.free_agent(@native_agent.agent_ptr)
           end
 
-          context 'a non empty list' do
-            it 'should have ip blocking enabled' do
-              expect(TCellAgent).to_not receive(:logger)
-
-              @rust_policies.update_policies(
-                {
-                  'patches' => {
-                    'policy_id' => 'policy_id',
-                    'version' => 1,
-                    'data' => {
-                      'blocked_ips' => [
-                        { 'ip' => '0.0.0.0' },
-                        { 'ip' => '1.1.1.1' }
-                      ]
-                    }
-                  }
-                }
-              )
-
-              expect(@rust_policies.patches_enabled).to eq(true)
+          context 'request has nil ip' do
+            it 'should not block request' do
+              meta_data = TCellAgent::Tests::MetaDataBuilder.new.update_attribute(
+                'remote_address', nil
+              ).build
+              resp = @policy.block_request?(meta_data)
+              expect(resp).to eq(false)
             end
           end
-        end
-
-        context 'with block_rules' do
-          context 'as an empty list' do
-            it 'should have ip blocking disabled' do
-              expect(TCellAgent).to_not receive(:logger)
 
-              @rust_policies.update_policies(
-                {
-                  'patches' => {
-                    'policy_id' => 'policy_id',
-                    'version' => 1,
-                    'data' => {
-                      'block_rules' => []
-                    }
-                  }
-                }
-              )
-
-              expect(@rust_policies.patches_enabled).to eq(true)
+          context 'request has empty ip' do
+            it 'should not block request' do
+              meta_data = TCellAgent::Tests::MetaDataBuilder.new.update_attribute(
+                'remote_address', ''
+              ).build
+              resp = @policy.block_request?(meta_data)
+              expect(resp).to eq(false)
             end
           end
 
-          context 'a non empty list' do
-            it 'should have ip blocking enabled' do
-              expect(TCellAgent).to_not receive(:logger)
-
-              @rust_policies.update_policies(
-                {
-                  'patches' => {
-                    'policy_id' => 'policy_id',
-                    'version' => 1,
-                    'data' => {
-                      'block_rules' => [
-                        { 'assume_this_is_well_formed' => 'well_formed' },
-                        { 'assume_this_is_well_formed_dos' => 'well_formed_dos' }
-                      ]
-                    }
-                  }
-                }
-              )
-
-              expect(@rust_policies.patches_enabled).to eq(true)
-            end
-
-            context 'with a malformed block rule' do
-              it 'should ignore the block rule' do
-                expect(TCellAgent).to_not receive(:logger)
-
-                @rust_policies.update_policies(
-                  {
-                    'patches' => {
-                      'policy_id' => 'policy_id',
-                      'version' => 1,
-                      'data' => {
-                        'block_rules' => [
-                          { 'assume_this_is_ill_formed' => 'ill_formed' }
-                        ]
-                      }
-                    }
-                  }
-                )
-
-                expect(@rust_policies.patches_enabled).to eq(true)
-              end
-            end
-
-            context 'with a malformed block rule and a well formed block rule' do
-              it 'should ignore the block rule' do
-                expect(TCellAgent).to_not receive(:logger)
-
-                @rust_policies.update_policies(
-                  {
-                    'patches' => {
-                      'policy_id' => 'policy_id',
-                      'version' => 1,
-                      'data' => {
-                        'block_rules' => [
-                          { 'assume_this_is_ill_formed' => 'ill_formed' },
-                          { 'assume_this_is_well_formed' => 'well_formed' }
-                        ]
-                      }
-                    }
-                  }
-                )
-
-                expect(@rust_policies.patches_enabled).to eq(true)
-              end
-            end
-
-            context 'with a wrong version number' do
-              xit 'should have ip blocking disabled' do
-                expect(TCellAgent).to_not receive(:logger)
-
-                @rust_policies.update_policies(
-                  {
-                    'patches' => {
-                      'policy_id' => 'policy_id',
-                      'version' => 2,
-                      'data' => {
-                        'block_rules' => [
-                          { 'assume_this_is_well_formed' => 'well_formed' }
-                        ]
-                      }
-                    }
-                  }
-                )
-
-                expect(@rust_policies.patches_enabled).to eq(false)
-              end
+          context 'request comes from non-blocked ip' do
+            it 'should not block request' do
+              meta_data = TCellAgent::Tests::MetaDataBuilder.new.update_attribute(
+                'remote_address', '2.2.2.2'
+              ).build
+              resp = @policy.block_request?(meta_data)
+              expect(resp).to eq(false)
             end
           end
-        end
-      end
 
-      describe '#block_request?' do
-        context 'supports ip blocking' do
-          it 'should block blacklisted ip' do
-            @rust_policies.update_policies(
-              {
-                'patches' => {
-                  'version' => 1,
-                  'policy_id' => 'some uuid',
-                  'data' => {
-                    'rules' => [{
-                      'id' => 'blocked-ips-rule',
-                      'title' => 'Blocked ips rule',
-                      'action' => 'BlockIf',
-                      'destinations' => { 'check_equals' => [{ 'path' => '*' }] },
-                      'ignore' => [],
-                      'matches' => [{
-                        'all' => [],
-                        'any' => [{
-                          'ips' => [{
-                            'type' => 'IP',
-                            'values' => ['1.3.3.4']
-                          }]
-                        }]
-                      }]
-                    }]
-                  }
-                }
-              }
-            )
-
-            meta_data = TCellAgent::MetaData.new(
-              'get',
-              '1.3.3.4',
-              'route_id',
-              'session_id',
-              'user_id',
-              'transaction_id',
-              'http://test.com/?some_param=present'
-            )
-            expect(@rust_policies.block_request?(meta_data)).to eq(true)
-
-            meta_data = TCellAgent::MetaData.new(
-              'get',
-              '1.1.1.1',
-              'route_id',
-              'session_id',
-              'user_id',
-              'transaction_id',
-              'http://test.com/?some_param=present'
-            )
-            expect(@rust_policies.block_request?(meta_data)).to eq(false)
+          context 'request comes from non-blocked ip' do
+            it 'should not block request' do
+              meta_data = TCellAgent::Tests::MetaDataBuilder.new.update_attribute(
+                'remote_address', '1.1.1.1'
+              ).build
+              resp = @policy.block_request?(meta_data)
+              expect(resp).to eq(true)
+            end
           end
         end
       end