tcell_agent 1.1.12 → 2.0.0

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

@@ -0,0 +1,161 @@
+
+require 'spec_helper'
+
+module TCellAgent
+  module Policies
+    describe HeadersPolicy do
+      describe '#initialize' do
+        context 'empty enablements' do
+          it 'should disable the policy' do
+            native_agent = double('native_agent')
+            policy = HeadersPolicy.new(native_agent, {})
+            expect(policy.enabled).to eq(false)
+          end
+        end
+      end
+
+      describe '#get_headers' do
+        context 'with disabled policy' do
+          it 'should not call the native library' do
+            native_agent = double('native_agent')
+            policy = HeadersPolicy.new(native_agent, {})
+
+            expect(native_agent).to_not receive(:get_headers)
+
+            tcell_context = double('tcell_context')
+            policy.get_headers(tcell_context)
+          end
+        end
+
+        context 'with enabled policy' do
+          before(:each) do
+            configuration = TCellAgent::Tests::ConfigurationBuilder.new.update_attribute(
+              'max_csp_header_bytes', 105
+            ).build
+            @native_agent = TCellAgent::Rust::NativeAgent.create_agent(
+              configuration
+            )
+            @tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+              'session_id', 'session-id'
+            ).update_attribute(
+              'route_id', 'route-id'
+            ).build
+          end
+
+          after(:each) do
+            TCellAgent::Rust::NativeAgent.free_agent(@native_agent.agent_ptr)
+          end
+
+          it 'should return csp header' do
+            enablements = @native_agent.update_policies(
+              {
+                'csp-headers' => {
+                  'version' => 1,
+                  'policy_id' => 'xyzd',
+                  'headers' => [
+                    { 'name' => 'Content-Security-Policy',
+                      'value' => 'test321' }
+                  ]
+                }
+              }
+            )['enablements']
+            expect(enablements['headers']).to eq(true)
+
+            @policy = HeadersPolicy.new(@native_agent, enablements)
+            expect(@policy.enabled).to eq(true)
+
+            expect(
+              @policy.get_headers(@tcell_context)
+            ).to eq(
+              [{ 'name' => 'Content-Security-Policy', 'value' => 'test321' }]
+            )
+          end
+
+          context 'header with report uri' do
+            it 'should return csp header' do
+              enablements = @native_agent.update_policies(
+                {
+                  'csp-headers' => {
+                    'version' => 1,
+                    'policy_id' => 'xyzd',
+                    'headers' => [
+                      { 'name' => 'Content-Security-Policy',
+                        'value' => 'normalvalue',
+                        'report_uri' => 'https://www.example.com/xys' }
+                    ]
+                  }
+                }
+              )['enablements']
+              expect(enablements['headers']).to eq(true)
+
+              @policy = HeadersPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              expect(
+                @policy.get_headers(@tcell_context)
+              ).to eq(
+                [{ 'name' => 'Content-Security-Policy',
+                   'value' => 'normalvalue; report-uri https://www.example.com/xys?sid=ab7074d0bf86c2884766d88b6ad9de4a&rid=route-id' }]
+              )
+            end
+          end
+
+          context 'header equal to max csp header bytes' do
+            it 'should return csp header' do
+              enablements = @native_agent.update_policies(
+                {
+                  'csp-headers' => {
+                    'version' => 1,
+                    'policy_id' => 'xyzd',
+                    'headers' => [
+                      { 'name' => 'Content-Security-Policy',
+                        'value' => 'normalvalue',
+                        'report_uri' => 'https://www.example.com/1234567' }
+                    ]
+                  }
+                }
+              )['enablements']
+              expect(enablements['headers']).to eq(true)
+
+              @policy = HeadersPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              expect(
+                @policy.get_headers(@tcell_context)
+              ).to eq(
+                [{ 'name' => 'Content-Security-Policy',
+                   'value' => 'normalvalue; report-uri https://www.example.com/1234567?sid=ab7074d0bf86c2884766d88b6ad9de4a&rid=route-id' }]
+              )
+            end
+          end
+
+          context 'header exceeding to max csp header bytes' do
+            it 'should not return csp header' do
+              enablements = @native_agent.update_policies(
+                {
+                  'csp-headers' => {
+                    'version' => 1,
+                    'policy_id' => 'xyzd',
+                    'headers' => [
+                      { 'name' => 'Content-Security-Policy',
+                        'value' => 'normalvalue',
+                        'report_uri' => 'https://www.example.com/12345678' }
+                    ]
+                  }
+                }
+              )['enablements']
+              expect(enablements['headers']).to eq(true)
+
+              @policy = HeadersPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              expect(
+                @policy.get_headers(@tcell_context)
+              ).to eq([])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module TCellAgent
           'session_id_protections' => { 'body' => ['redact'], 'log' => ['event'] }
         }
       }
-      policy_two = DataLossPolicy.from_json(policy_json_two)
+      policy_two = DataLossPolicy.new(policy_json_two)
       context 'check session_id_protections' do
         it 'gives the right actions' do
           expect(policy_two.get_actions_for_session_id.body_redact).to eq(true)
@@ -37,7 +37,7 @@ module TCellAgent
               ]
             }
           }
-          db_one_policy = DataLossPolicy.from_json(policy_json_requests)
+          db_one_policy = DataLossPolicy.new(policy_json_requests)
           expect(db_one_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred')).to eq(nil)
         end
         it 'Partial Policy' do
@@ -56,7 +56,7 @@ module TCellAgent
               ]
             }
           }
-          db_one_policy = DataLossPolicy.from_json(policy_json_requests)
+          db_one_policy = DataLossPolicy.new(policy_json_requests)
           expect(db_one_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred').to_a[0].log_redact).to eq(true)
           expect(db_one_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred', 'abcd').to_a[0].log_redact).to eq(true)
         end
@@ -80,7 +80,7 @@ module TCellAgent
               ]
             }
           }
-          db_two_policy = DataLossPolicy.from_json(policy_json_request_ids)
+          db_two_policy = DataLossPolicy.new(policy_json_request_ids)
           expect(db_two_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred').to_a.size).to eq(0)
           expect(db_two_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred', 'other_route').to_a.size).to eq(0)
           expect(db_two_policy.get_actions_for_table('dave', 'sam', 'tommy', 'fred', 'abcd').to_a.size).to eq(1)
@@ -107,7 +107,7 @@ module TCellAgent
               ]
             }
           }
-          policy_three = DataLossPolicy.from_json(policy_json_requests)
+          policy_three = DataLossPolicy.new(policy_json_requests)
           expect(policy_three.get_actions_for_request('form', 'test123').to_a[0].body_event).to eq(true)
           expect(policy_three.get_actions_for_request('form', 'test123').to_a[0].log_event).to eq(nil)
         end
@@ -129,7 +129,7 @@ module TCellAgent
               ]
             }
           }
-          policy_three = DataLossPolicy.from_json(policy_json_requests)
+          policy_three = DataLossPolicy.new(policy_json_requests)
           entry_wildcard_route = policy_three.get_actions_for_request('form', 'TeSt123')
           entry_given_route = policy_three.get_actions_for_request('form', 'TeSt123', 'routex')
           expect(entry_wildcard_route).to eq(nil)
@@ -156,7 +156,7 @@ module TCellAgent
               ]
             }
           }
-          policy_three = DataLossPolicy.from_json(policy_json_requests)
+          policy_three = DataLossPolicy.new(policy_json_requests)
           entry_wildcard_route = policy_three.get_actions_for_request('cookie', 'test123')
           entry_given_route = policy_three.get_actions_for_request('cookie', 'test123', 'routex')
           expect(entry_wildcard_route).to eq(nil)
@@ -183,7 +183,7 @@ module TCellAgent
               ]
             }
           }
-          policy_three = DataLossPolicy.from_json(policy_json_requests)
+          policy_three = DataLossPolicy.new(policy_json_requests)
           entry_wildcard_route = policy_three.get_actions_for_request('cookie', 'test123')
           entry_given_route = policy_three.get_actions_for_request('cookie', 'test123', 'routex')
           expect(entry_wildcard_route).to eq(nil)
@@ -208,7 +208,7 @@ module TCellAgent
               ]
             }
           }
-          policy_three = DataLossPolicy.from_json(policy_json_requests)
+          policy_three = DataLossPolicy.new(policy_json_requests)
           entry_wildcard_route = policy_three.get_actions_for_request('header', 'TeSt123')
           entry_given_route = policy_three.get_actions_for_request('header', 'TeSt123', 'routex')
           expect(entry_wildcard_route).to eq(nil)

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

@@ -3,232 +3,277 @@ require 'spec_helper'
 module TCellAgent
   module Policies
     describe HttpRedirectPolicy do
-      context 'with defaults' do
-        it 'returns true' do
-          http_redirect_plain = HttpRedirectPolicy.new
-          expect(http_redirect_plain.policy_id).to eq(nil)
-          expect(http_redirect_plain.enabled).to eq(false)
-          expect(http_redirect_plain.block).to eq(false)
-          expect(http_redirect_plain.whitelist).to eq([])
-          expect(http_redirect_plain.data_scheme_allowed).to eq(false)
+      describe '#initialize' do
+        context 'empty enablements' do
+          it 'should disable the policy' do
+            native_agent = double('native_agent')
+            policy = HttpRedirectPolicy.new(native_agent, {})
+            expect(policy.enabled).to eq(false)
+          end
         end
       end
 
-      describe '#suspicious_redirect?' do
-        it "see's other domain" do
-          http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                'policy_id' => 'x1a1',
-                                                                'data' => {
-                                                                  'enabled' => true
-                                                                }
-                                                              })
-          expect(http_redirect_policy.policy_id).to eq('x1a1')
-          expect(http_redirect_policy.enabled).to eq(true)
-
-          expect(http_redirect_policy.suspicious_redirect?('test.google.com', 'www.test.com')).to eq(true)
-        end
-
-        context 'with wildcard domain' do
-          it 'should be false' do
-            http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                  'policy_id' => 'x1a1',
-                                                                  'data' => {
-                                                                    'enabled' => true,
-                                                                    'whitelist' => ['*.google.com']
-                                                                  }
-                                                                })
+      describe '#check_redirect' do
+        context 'with disabled policy' do
+          it 'should not call the native library' do
+            native_agent = double('native_agent')
+            policy = HttpRedirectPolicy.new(native_agent, {})
 
-            expect(http_redirect_policy.suspicious_redirect?('test.google.com', 'www.test.com')).to eq(false)
+            expect(native_agent).to_not receive(:check_http_redirect)
 
-            expect(http_redirect_policy.suspicious_redirect?('test.google.net', 'www.test.com')).to eq(true)
+            tcell_context = double('tcell_context')
+            expect(
+              policy.check_redirect(
+                'http://localhost:8011/abc/def',
+                'localhost:8011',
+                200,
+                tcell_context
+              )
+            ).to eq('http://localhost:8011/abc/def')
           end
         end
-      end
 
-      describe '#enforce' do
-        context 'with a disabled policy' do
-          it 'should not enfore the policy' do
-            http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                  'policy_id' => 'x1a1',
-                                                                  'data' => {
-                                                                    'enabled' => false,
-                                                                    'block' => true,
-                                                                    'whitelist' => ['*.google.com']
-                                                                  }
-                                                                })
-
-            expect(http_redirect_policy.enforce(
-                     'https://test.google.com', 'www.test.com', '/path/a', 'GET', 'routex', '1.1.1.1', 400
-            )).to eq(nil)
+        context 'with native agent' do
+          before(:each) do
+            configuration = TCellAgent::Tests::ConfigurationBuilder.new.build
+            @native_agent = TCellAgent::Rust::NativeAgent.create_agent(
+              configuration
+            )
           end
-        end
 
-        context 'with an enabled policy' do
-          context 'redirecting to non whitelisted domain' do
-            it 'should block the redirect' do
-              http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                    'policy_id' => 'x1a1',
-                                                                    'data' => {
-                                                                      'enabled' => true,
-                                                                      'block' => true,
-                                                                      'whitelist' => ['good.com']
-                                                                    }
-                                                                  })
-
-              expect(http_redirect_policy.enforce(
-                       'https://www.google.com/abc/def', 'localhost', '/path/a', 'GET', 'routey', '1.1.1.1', 400
-              )).to eq('/')
-            end
+          after(:each) do
+            TCellAgent::Rust::NativeAgent.free_agent(@native_agent.agent_ptr)
           end
 
-          context 'with a wildcard whitelist' do
-            it 'should not enfore allowed domains properly' do
-              http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                    'policy_id' => 'x1a1',
-                                                                    'data' => {
-                                                                      'enabled' => true,
-                                                                      'block' => true,
-                                                                      'whitelist' => ['*.allowed*.com']
-                                                                    }
-                                                                  })
-
-              expect(http_redirect_policy.enforce(
-                       'https://allowed.com', 'localhost', '/path/a', 'GET', 'routey', '1.1.1.1', 400
-              )).to eq(nil)
-
-              expect(http_redirect_policy.enforce(
-                       'https://www.alloweddomain.com', 'localhost', '/path/a', 'GET', 'routey', '1.1.1.1', 400
-              )).to eq(nil)
+          context 'redirect to the same' do
+            it 'should not block the redirect' do
+              enablements = @native_agent.update_policies(
+                {
+                  'http-redirect' => {
+                    'version' => 1,
+                    'policy_id' => 'nyzd',
+                    'data' => {
+                      'enabled' => true,
+                      'whitelist' => ['whitelisted'],
+                      'block' => true
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['http_redirect']).to eq(true)
+
+              @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'path', '/etc/123'
+              ).update_attribute(
+                'remote_address', '0.1.1.0'
+              ).update_attribute(
+                'fullpath', '/etc/123'
+              ).build
+              check = @policy.check_redirect(
+                'http://localhost:8011/abc/def',
+                'localhost:8011',
+                200,
+                tcell_context
+              )
+
+              expect(check).to eq('http://localhost:8011/abc/def')
             end
           end
-        end
 
-        context 'with ports' do
-          it 'should remove ports in redirect event' do
-            http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                  'policy_id' => 'x1a1',
-                                                                  'data' => {
-                                                                    'enabled' => true,
-                                                                    'block' => false
-                                                                  }
-                                                                })
-
-            expect(TCellAgent).to receive(:send_event).with({
-                                                              'event_type' => 'redirect',
-                                                              'method' => 'GET',
-                                                              'from_domain' => 'www.test.com',
-                                                              'status_code' => 400,
-                                                              'remote_addr' => '1.1.1.1',
-                                                              'to' => 'www.google.com',
-                                                              'from' => '/path/a',
-                                                              'rid' => 'routex'
-                                                            })
-
-            result = http_redirect_policy.enforce(
-              'https://www.google.com:80', 'http://www.test.com', '/path/a', 'GET', 'routex', 400, '1.1.1.1'
-            )
-            expect(result).to eq(nil)
+          context 'asterisk in whitelisted domain' do
+            it 'should allow the redirect' do
+              enablements = @native_agent.update_policies(
+                {
+                  'http-redirect' => {
+                    'version' => 1,
+                    'policy_id' => 'nyzd',
+                    'data' => {
+                      'enabled' => true,
+                      'whitelist' => ['*.allowed*.com'],
+                      'block' => true
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['http_redirect']).to eq(true)
+
+              @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'path', '/etc/123'
+              ).update_attribute(
+                'remote_address', '0.1.1.0'
+              ).update_attribute(
+                'fullpath', '/etc/123'
+              ).build
+              check = @policy.check_redirect(
+                'http://allowed.com',
+                'localhost:8011',
+                200,
+                tcell_context
+              )
+
+              expect(check).to eq('http://allowed.com')
+            end
           end
-        end
 
-        context 'data_scheme_allowed' do
-          context 'is not allowed' do
-            it 'should send an event' do
-              @http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                     'policy_id' => 'x1a1',
-                                                                     'data' => {
-                                                                       'enabled' => true,
-                                                                       'whitelist' => [],
-                                                                       'block' => false,
-                                                                       'data_scheme_allowed' => false
-                                                                     }
-                                                                   })
-
-              expect(TCellAgent).to receive(:send_event).with({
-                                                                'event_type' => 'redirect',
-                                                                'method' => 'GET',
-                                                                'from_domain' => 'www.test.com',
-                                                                'status_code' => 400,
-                                                                'remote_addr' => '1.1.1.1',
-                                                                'to' => 'data:text/html base64',
-                                                                'from' => '/path/a',
-                                                                'rid' => 'routex'
-                                                              })
-
-              result = @http_redirect_policy.enforce(
-                'data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K',
-                'http://www.test.com',
-                '/path/a',
-                'GET',
-                'routex',
-                400,
-                '1.1.1.1'
+          context 'domain with a port' do
+            it 'should block the redirect' do
+              enablements = @native_agent.update_policies(
+                {
+                  'http-redirect' => {
+                    'version' => 1,
+                    'policy_id' => 'nyzd',
+                    'data' => {
+                      'enabled' => true,
+                      'whitelist' => [],
+                      'block' => true
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['http_redirect']).to eq(true)
+
+              @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'path', '/some/path'
+              ).update_attribute(
+                'remote_address', '0.1.1.0'
+              ).update_attribute(
+                'fullpath', '/some/path'
+              ).build
+              check = @policy.check_redirect(
+                'http://user:pass@192.168.99.100:3000',
+                'localhost:8011',
+                200,
+                tcell_context
               )
-              expect(result).to eq(nil)
+
+              expect(check).to eq('/')
             end
+          end
+
+          context 'data scheme redirect' do
+            context 'not allowed' do
+              it 'should block the redirect' do
+                enablements = @native_agent.update_policies(
+                  {
+                    'http-redirect' => {
+                      'version' => 1,
+                      'policy_id' => 'nyzd',
+                      'data' => {
+                        'enabled' => true,
+                        'whitelist' => ['whitelisted'],
+                        'block' => true,
+                        'data_scheme_allowed' => false
+                      }
+                    }
+                  }
+                )['enablements']
+                expect(enablements['http_redirect']).to eq(true)
+
+                @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+                expect(@policy.enabled).to eq(true)
 
-            context 'and blocking is enabled' do
-              it 'should send an event and redirect to root' do
-                @http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                       'policy_id' => 'x1a1',
-                                                                       'data' => {
-                                                                         'enabled' => true,
-                                                                         'whitelist' => [],
-                                                                         'block' => true,
-                                                                         'data_scheme_allowed' => false
-                                                                       }
-                                                                     })
-
-                expect(TCellAgent).to receive(:send_event).with({
-                                                                  'event_type' => 'redirect',
-                                                                  'method' => 'GET',
-                                                                  'from_domain' => 'www.test.com',
-                                                                  'status_code' => 400,
-                                                                  'remote_addr' => '1.1.1.1',
-                                                                  'to' => 'data:text/html base64',
-                                                                  'from' => '/path/a',
-                                                                  'rid' => 'routex'
-                                                                })
-
-                result = @http_redirect_policy.enforce(
+                tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                  'path', '/some/path'
+                ).update_attribute(
+                  'remote_address', '0.1.1.0'
+                ).update_attribute(
+                  'fullpath', '/some/path'
+                ).build
+                check = @policy.check_redirect(
                   'data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K',
-                  'http://www.test.com',
-                  '/path/a',
-                  'GET',
-                  'routex',
-                  400,
-                  '1.1.1.1'
+                  'localhost:8011',
+                  200,
+                  tcell_context
                 )
-                expect(result).to eq('/')
+
+                expect(check).to eq('/')
+              end
+            end
+
+            context 'is allowed' do
+              it 'should allow the redirect' do
+                enablements = @native_agent.update_policies(
+                  {
+                    'http-redirect' => {
+                      'version' => 1,
+                      'policy_id' => 'nyzd',
+                      'data' => {
+                        'enabled' => true,
+                        'whitelist' => ['whitelisted'],
+                        'block' => true,
+                        'data_scheme_allowed' => true
+                      }
+                    }
+                  }
+                )['enablements']
+                expect(enablements['http_redirect']).to eq(true)
+
+                @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+                expect(@policy.enabled).to eq(true)
+
+                tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                  'path', '/some/path'
+                ).update_attribute(
+                  'remote_address', '0.1.1.0'
+                ).update_attribute(
+                  'fullpath', '/some/path'
+                ).build
+                check = @policy.check_redirect(
+                  'data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K',
+                  'localhost:8011',
+                  200,
+                  tcell_context
+                )
+
+                expect(check).to eq('data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K')
               end
             end
           end
 
-          context 'is allowed' do
-            it 'should not send an event' do
-              @http_redirect_policy = HttpRedirectPolicy.from_json({
-                                                                     'policy_id' => 'x1a1',
-                                                                     'data' => {
-                                                                       'enabled' => true,
-                                                                       'whitelist' => [],
-                                                                       'block' => false,
-                                                                       'data_scheme_allowed' => true
-                                                                     }
-                                                                   })
-
-              expect(TCellAgent).to_not receive(:send_event)
-
-              result = @http_redirect_policy.enforce(
-                'data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K',
-                'http://www.test.com',
-                '/path/a',
-                'GET',
-                'routex',
-                400,
-                '1.1.1.1'
+          context 'relative redirect' do
+            it 'should allow the redirect' do
+              enablements = @native_agent.update_policies(
+                {
+                  'http-redirect' => {
+                    'version' => 1,
+                    'policy_id' => 'nyzd',
+                    'data' => {
+                      'enabled' => true,
+                      'whitelist' => [],
+                      'block' => true
+                    }
+                  }
+                }
+              )['enablements']
+              expect(enablements['http_redirect']).to eq(true)
+
+              @policy = HttpRedirectPolicy.new(@native_agent, enablements)
+              expect(@policy.enabled).to eq(true)
+
+              tcell_context = TCellAgent::Tests::TCellContextBuilder.new.update_attribute(
+                'path', '/some/path'
+              ).update_attribute(
+                'remote_address', '0.1.1.0'
+              ).update_attribute(
+                'fullpath', '/some/path'
+              ).build
+              check = @policy.check_redirect(
+                '/admin/login/?next=/admin/',
+                'localhost:8011',
+                200,
+                tcell_context
               )
 
-              expect(result).to eq(nil)
+              expect(check).to eq('/admin/login/?next=/admin/')
             end
           end
         end