tarquinn 0.2.0 → 0.3.0

data/spec/lib/tarquinn/condition/action_checker_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Tarquinn::Condition::ActionChecker do
@@ -34,7 +36,7 @@ describe Tarquinn::Condition::ActionChecker do
   end
 
   context 'when initialized with more routes' do
-    let(:routes) { [:show, :view] }
+    let(:routes) { %i[show view] }
     let(:subject) { described_class.new(routes) }
 
     context 'when receiving a request for one of the given action' do
@@ -44,7 +46,7 @@ describe Tarquinn::Condition::ActionChecker do
     end
 
     context 'when receiving a request for another action' do
-      let(:routes) { [:update, :view] }
+      let(:routes) { %i[update view] }
       it do
         expect(subject.check?(controller)).to be_falsey
       end

data/spec/lib/tarquinn/condition/method_caller_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Tarquinn::Condition::MethodCaller do
@@ -24,7 +26,7 @@ describe Tarquinn::Condition::MethodCaller do
   end
 
   context 'when initialized with more methods' do
-    let(:methods) { [:true, :false] }
+    let(:methods) { %i[true false] }
     let(:subject) { described_class.new(methods) }
 
     context 'when one return true and the other false' do
@@ -34,14 +36,14 @@ describe Tarquinn::Condition::MethodCaller do
     end
 
     context 'when all return true' do
-      let(:methods) { [:true, :true] }
+      let(:methods) { %i[true true] }
       it do
         expect(subject.check?(controller)).to be_truthy
       end
     end
 
     context 'when all return false' do
-      let(:methods) { [:false, :false] }
+      let(:methods) { %i[false false] }
       it do
         expect(subject.check?(controller)).to be_falsey
       end

data/spec/lib/tarquinn/condition/proc_runner_spec.rb

@@ -1,22 +1,74 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Tarquinn::Condition::ProcRunner do
-  let(:controller) { double }
-  let(:value) { true }
-  let(:subject) { described_class.new { value } }
+  let(:rails_controller) { rails_controller_class.new }
+  let(:controller) { Tarquinn::Controller.new(rails_controller) }
+  let(:subject) { described_class.new(&block) }
+  let(:rails_controller_class) do
+    Class.new(ActionController::Base)
+  end
 
   describe '#check?' do
     context 'when block evaluates into true' do
+      let(:block) { proc { true } }
+
       it do
         expect(subject.check?(controller)).to be_truthy
       end
     end
 
     context 'when block evaluates into false' do
-      let(:value) { false }
+      let(:block) { proc { false } }
+
       it do
         expect(subject.check?(controller)).to be_falsey
       end
     end
+
+    context 'when the block gets calls the controller method' do
+      let(:block) { proc { match? } }
+
+      context 'when the method returns true' do
+        let(:rails_controller_class) do
+          Class.new(ActionController::Base) do
+            def match?
+              true
+            end
+          end
+        end
+
+        it do
+          expect(subject.check?(controller)).to be_truthy
+        end
+      end
+
+      context 'when the method returns false' do
+        let(:rails_controller_class) do
+          Class.new(ActionController::Base) do
+            def match?
+              false
+            end
+          end
+        end
+
+        it do
+          expect(subject.check?(controller)).to be_falsey
+        end
+      end
+    end
+
+    context 'when the block references a value defined outside' do
+      let(:block) do
+        val = value
+        proc { val }
+      end
+      let(:value) { [false, true].sample }
+
+      it do
+        expect(subject.check?(controller)).to eq(value)
+      end
+    end
   end
 end

data/spec/lib/tarquinn/condition_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Tarquinn::Condition do
+  subject(:condition) { described_class.new }
+
+  let(:controller) { instance_double(Tarquinn::Controller) }
+
+  describe '.method_caller' do
+    context 'when methods are given' do
+      let(:methods) { %i[method1 method2] }
+
+      it do
+        expect(described_class.method_caller(methods))
+          .to be_a(Tarquinn::Condition::MethodCaller)
+      end
+
+      it do
+        expect(described_class.method_caller(methods))
+          .to eq(Tarquinn::Condition::MethodCaller.new(methods))
+      end
+    end
+
+    context 'when no methods are given' do
+      let(:methods) { %i[] }
+
+      it do
+        expect(described_class.method_caller(methods)).to be_nil
+      end
+    end
+  end
+
+  describe '.action_checker' do
+    let(:actions) { %i[index show] }
+
+    it do
+      expect(described_class.action_checker(actions))
+        .to be_a(Tarquinn::Condition::ActionChecker)
+    end
+
+    it do
+      expect(described_class.action_checker(actions))
+        .to eq(Tarquinn::Condition::ActionChecker.new(actions))
+    end
+  end
+
+  describe '#check?' do
+    it do
+      expect { condition.check?(controller) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/tarquinn/controller_spec.rb

@@ -1,38 +1,111 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Tarquinn::Controller do
-  let(:controller) { Tarquinn::DummyController.new }
-  let(:subject) { described_class.new(controller) }
+  subject(:controller) { described_class.new(rails_controller) }
+
+  let(:rails_controller) { Tarquinn::DummyController.new }
 
   describe '#call' do
-    it 'redirects a method call to the controller' do
-      expect(controller).to receive(:redirect_to)
-      subject.call(:redirect_to)
+    context 'when no arguments are given' do
+      before do
+        allow(rails_controller).to receive(:redirect_to).with(no_args)
+      end
+
+      it 'delegate a method call to the controller' do
+        subject.call(:redirect_to)
+        expect(rails_controller).to have_received(:redirect_to)
+      end
+    end
+
+    context 'when arguments are given' do
+      before do
+        allow(rails_controller)
+          .to receive(:redirect_to)
+          .with(1, 2, opt: 3)
+      end
+
+      it 'delegate a method call to the controller' do
+        subject.call(:redirect_to, 1, 2, opt: 3)
+
+        expect(rails_controller).to have_received(:redirect_to)
+      end
+    end
+
+    context 'when a block is given' do
+      let(:block) { proc { 12 } }
+
+      before do
+        allow(rails_controller)
+          .to receive(:redirect_to)
+          .with(no_args).and_yield
+      end
+
+      it 'delegate a method call to the controller' do
+        subject.call(:redirect_to, &block)
+
+        expect(rails_controller).to have_received(:redirect_to)
+      end
+
+      it 'passes the block to be executed' do
+        expect(subject.call(:redirect_to, &block)).to eq(12)
+      end
+    end
+  end
+
+  describe '#run' do
+    context 'when block does not call any controller method' do
+      let(:block) { proc { 12 } }
+
+      it 'returns the value from the block' do
+        expect(controller.run(&block)).to eq(12)
+      end
+    end
+
+    context 'when block references a value outside' do
+      let(:block) do
+        value = 15
+        proc { value }
+      end
+
+      it 'returns the value' do
+        expect(controller.run(&block)).to eq(15)
+      end
+    end
+
+    context 'when block references a method in the controller' do
+      let(:block) { proc { params } }
+
+      it 'returns the value' do
+        expect(controller.run(&block))
+          .to eq(ActionController::Parameters.new(action: 'show'))
+      end
     end
   end
 
   describe '#params' do
     it 'returns the instance params call' do
-      expect(subject.params).to eq(action: 'show')
+      expect(subject.params).to eq(ActionController::Parameters.new(action: 'show'))
     end
   end
 
-  describe '#has_method?' do
+  describe '#method?' do
     context 'when calling for a public method that exists' do
       it do
-        expect(subject.has_method?(:parse_request)).to be_truthy
+        expect(subject.method?(:parse_request)).to be_truthy
       end
     end
 
     context 'when calling for a private method that exists' do
       it do
-        expect(subject.has_method?(:redirection_path)).to be_truthy
+        expect(subject.method?(:redirection_path)).to be_truthy
       end
     end
 
     context 'when calling for a non existing method' do
       it do
-        expect(subject.has_method?(:non_existing)).to be_falsey
+        expect(subject.method?(:non_existing)).to be_falsey
       end
     end
   end

data/spec/lib/tarquinn/{config_spec.rb → redirection_config_spec.rb}

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Tarquinn::Config do
+describe Tarquinn::RedirectionConfig do
   let(:subject) { described_class.new(:redirect) }
 
   describe '#add_redirection_rules' do

data/spec/lib/tarquinn/{handler_spec.rb → redirection_handler_spec.rb}

@@ -1,14 +1,32 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Tarquinn::Handler do
+describe Tarquinn::RedirectionHandler do
   let(:redirection_path) { '/path' }
   let(:controller) { Tarquinn::DummyController.new }
-  let(:config) { Tarquinn::Config.new(:redirection_path) }
+  let(:config) { Tarquinn::RedirectionConfig.new(:redirection_path) }
   let(:subject) do
     described_class.new config, Tarquinn::Controller.new(controller)
   end
 
   describe '#perform_redirect?' do
+    context 'when there are no rules' do
+      it do
+        expect(subject.perform_redirect?).to be_truthy
+      end
+
+      context 'but some grant a skip' do
+        before do
+          config.add_skip_rules { true }
+        end
+
+        it do
+          expect(subject.perform_redirect?).to be_falsey
+        end
+      end
+    end
+
     context 'when rules allow for redirection' do
       before do
         config.add_redirection_rules { true }
@@ -98,7 +116,7 @@ describe Tarquinn::Handler do
       end
 
       context 'when configured with a method that does not exist in the controller' do
-        let(:config) { Tarquinn::Config.new('/new_path') }
+        let(:config) { Tarquinn::RedirectionConfig.new('/new_path') }
 
         it 'calls for redirection using static path' do
           expect(controller).to receive(:redirect_to).with('/new_path')

data/spec/lib/tarquinn/request_handler_builder_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Tarquinn::RequestHandlerBuilder do
+  describe '#build' do
+    let(:controller) do
+      double('controller')
+    end
+
+    it do
+      expect(subject.build(controller)).to be_a(Tarquinn::RequestHandler)
+    end
+  end
+end

data/spec/lib/tarquinn/{engine_spec.rb → request_handler_spec.rb}

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Tarquinn::Engine do
+describe Tarquinn::RequestHandler do
   let(:redirection_path) { '/path' }
   let(:redirection_path2) { '/path2' }
   let(:controller) do
     double('controller', redirect_path: redirection_path, redirect_path2: redirection_path2)
   end
-  let(:config) { Tarquinn::Config.new(:redirect_path) }
-  let(:config2) { Tarquinn::Config.new(:redirect_path2) }
+  let(:config) { Tarquinn::RedirectionConfig.new(:redirect_path) }
+  let(:config2) { Tarquinn::RedirectionConfig.new(:redirect_path2) }
   let(:configs) { { redirect_path: config, redirect_path2: config2 } }
   let(:subject) do
     described_class.new configs, Tarquinn::Controller.new(controller)

data/spec/lib/tarquinn_spec.rb

@@ -1,24 +1,187 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Tarquinn do
-  let(:controller) { Tarquinn::DummyController.new }
+describe Tarquinn, type: :controller do
+  describe '.redirection_rule' do
+    context 'when there is only one condition' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection, :should_redirect?
+      end
+
+      before { get :index, params: parameters }
+
+      context 'when request indicates a redirection' do
+        let(:parameters) { { should_redirect: true } }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request does not indicate a redirection' do
+        let(:parameters) { {} }
+
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
+      end
+    end
+
+    # TODO: fix this condition
+    context 'when there is only one block condition' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection do
+          params[:redirect_block]
+        end
+      end
+
+      before { get :index, params: parameters }
+
+      context 'when request indicates a redirection' do
+        let(:parameters) { { redirect_block: true } }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request does not indicate a redirection' do
+        let(:parameters) { {} }
 
-  describe 'redirection' do
-    context 'when configuration calls for a method that allows redirection' do
-      it 'redirects to redirection path given by the method' do
-        expect(controller).to receive(:redirect_to).with('/path')
-        controller.parse_request
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
       end
     end
 
-    context 'when redirection skip method returns true' do
-      before do
-        allow(controller).to receive(:should_skip_redirect?) { true }
+    context 'when there are more conditions' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection, :should_redirect?, :condition2
       end
 
-      it 'does not redirect to redirection path given by the method' do
-        expect(controller).not_to receive(:redirect_to)
-        controller.parse_request
+      before { get :index, params: parameters }
+
+      context 'when request indicates a redirection through first condition' do
+        let(:parameters) { { should_redirect: true } }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request indicates a redirection through second condition' do
+        let(:parameters) { { redirect: true } }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request does not indicate a redirection' do
+        let(:parameters) { {} }
+
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
+      end
+    end
+
+    # TODO: fix this condition
+    context 'when there are no conditions' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection
+      end
+
+      before { get :index }
+
+      it 'performs a redirect' do
+        expect(response).to redirect_to('/path')
+      end
+    end
+  end
+
+  describe '.skip_redirection' do
+    context 'when there is only one skip condition' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection, :always_redirect
+        skip_redirection_rule :redirection, :should_skip?
+      end
+
+      before { get :index, params: parameters }
+
+      context 'when requesting with parameters that do not skip' do
+        let(:parameters) { {} }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request does not indicate a redirection' do
+        let(:parameters) { { should_skip: true } }
+
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
+      end
+    end
+
+    context 'when there are more than oneskip condition' do
+      controller(Tarquinn::DummyRouteController) do
+        redirection_rule :redirection, :always_redirect
+        skip_redirection_rule :redirection, :should_skip?, :do_skip?
+      end
+
+      before { get :index, params: parameters }
+
+      context 'when requesting with parameters that do not skip' do
+        let(:parameters) { {} }
+
+        it 'performs a redirect' do
+          expect(response).to redirect_to('/path')
+        end
+      end
+
+      context 'when request skips redirection using first condition' do
+        let(:parameters) { { should_skip: true } }
+
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
+      end
+
+      context 'when request skips redirection using second condition' do
+        let(:parameters) { { skip: true } }
+
+        it 'does not performs a redirect' do
+          expect(response).not_to redirect_to('/path')
+        end
+      end
+    end
+  end
+
+  describe '.skip_redirection_rule' do
+    controller(Tarquinn::DummyRouteController) do
+      redirection_rule :redirection, :always_redirect
+      skip_redirection :redirection, :index, :delete
+    end
+
+    before { get action }
+
+    context 'when requestin a path that redirects' do
+      let(:action) { :new }
+
+      it 'performs a redirect' do
+        expect(response).to redirect_to('/path')
+      end
+    end
+
+    context 'when request does not indicate a redirection' do
+      let(:action) { :index }
+
+      it 'does not performs a redirect' do
+        expect(response).not_to redirect_to('/path')
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,16 +1,26 @@
+# frozen_string_literal: true
+
 require 'simplecov'
 
-SimpleCov.profiles.define 'gem' do
+SimpleCov.start do
   add_filter '/spec/'
 end
 
-SimpleCov.start 'gem'
-
 require 'tarquinn'
 require 'pry-nav'
 
+require 'active_record'
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3', database: ':memory:'
+)
+
+require File.expand_path('spec/dummy/config/environment')
+# require File.expand_path('spec/dummy/db/schema.rb')
+require 'rspec/rails'
+require 'active_support/railtie'
+
 support_files = File.expand_path('spec/support/**/*.rb')
-Dir[support_files].each { |file| require file  }
+Dir[support_files].each { |file| require file }
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -20,6 +30,6 @@ RSpec.configure do |config|
 
   config.order = 'random'
 
-  config.before do
-  end
+  # config.before do
+  # end
 end

data/spec/support/shared_examples/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'a method that adds a redirection rule' do |expected_class|
   it_behaves_like 'a method that adds a rule', :redirection, expected_class
 end
@@ -11,7 +13,7 @@ shared_examples 'a method that adds a rule' do |rule, expected_class|
   it do
     expect do
       call_method
-    end.to change { subject.public_send("#{rule}_blocks") }
+    end.to change(subject, "#{rule}_blocks")
   end
 
   it do
@@ -22,6 +24,6 @@ shared_examples 'a method that adds a rule' do |rule, expected_class|
   it do
     expect do
       call_method
-    end.not_to change { subject.public_send("#{reverse_rule}_blocks") }
+    end.not_to change(subject, "#{reverse_rule}_blocks")
   end
 end