aldous 1.0.0

data/spec/aldous/controller/preconditions_execution_service_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Aldous::Controller::PreconditionsExecutionService do
+  let(:preconditions_execution_service) {described_class.new(action_wrapper, controller)}
+
+  let(:controller) {double "controller"}
+  let(:action_wrapper) {double 'action wrapper', preconditions: preconditions, controller_action: action}
+  let(:action) {double 'action'}
+
+  let(:preconditions) { [] }
+
+  describe "#perform" do
+    subject(:perform) {preconditions_execution_service.perform}
+
+    context "when no preconditions defined" do
+      it "returns an array of nils" do
+        expect(perform).to eq [nil, nil]
+      end
+    end
+
+    context "when preconditions defined" do
+      let(:preconditions) { [precondition_class] }
+      let(:precondition_class) {double 'precondition_class', build: precondition}
+      let(:precondition) {double "precondition", perform: nil}
+
+      it "builds the precondition with the controller_aciont" do
+        expect(precondition_class).to receive(:build).with(action)
+        perform
+      end
+
+      context "but they don't short-circuit execution" do
+        it "returns an array of nils" do
+          expect(perform).to eq [nil, nil]
+        end
+      end
+
+      context "and they short-circuit execution" do
+        let(:precondition) {double "precondition", perform: precondition_result}
+        let(:precondition_result) {Aldous::Respondable::Renderable.new(nil, nil, nil)}
+
+        it "returns an array of precondition and precondition result" do
+          expect(perform).to eq [precondition, precondition_result]
+        end
+      end
+    end
+  end
+end

data/spec/aldous/controller_action_spec.rb

@@ -0,0 +1,97 @@
+RSpec.describe Aldous::ControllerAction do
+  before do
+    class ExampleControllerAction < Aldous::ControllerAction
+    end
+  end
+
+  after do
+    Object.send :remove_const, 'ExampleControllerAction'
+  end
+
+  let(:action) {ExampleControllerAction.new(controller)}
+
+  let(:controller) {double 'controller', view_context: view_context}
+  let(:view_context) {double "view_context"}
+
+  describe "::build" do
+    before do
+      allow(ExampleControllerAction).to receive(:new).and_return(action)
+      allow(Aldous::Controller::Action::Wrapper).to receive(:new)
+    end
+
+    it "wraps a controller action instance" do
+      expect(Aldous::Controller::Action::Wrapper).to receive(:new).with(action)
+      ExampleControllerAction.build(controller)
+    end
+  end
+
+  describe "::perform" do
+    let(:wrapper) {double "wrapper", perform: nil}
+
+    before do
+      allow(ExampleControllerAction).to receive(:new).and_return(action)
+      allow(Aldous::Controller::Action::Wrapper).to receive(:new).and_return(wrapper)
+    end
+
+    it "calls perform on the wrapper" do
+      expect(wrapper).to receive(:perform)
+      ExampleControllerAction.perform(controller)
+    end
+  end
+
+  describe "::inherited" do
+    context "a controller action instance" do
+      Aldous.configuration.controller_methods_exposed_to_action.each do |method_name|
+        it "responds to #{method_name}" do
+          expect(action).to respond_to method_name
+        end
+      end
+    end
+  end
+
+  describe "#perform" do
+    it "raises an error since it should be overridden" do
+      expect{action.perform}.to raise_error
+    end
+  end
+
+  describe "#default_view_data" do
+    it "is a blank hash by default" do
+      expect(action.default_view_data).to eq Hash.new
+    end
+  end
+
+  describe "#preconditions" do
+    it "is a blank array by default" do
+      expect(action.preconditions).to eq []
+    end
+  end
+
+  describe "#default_error_respondable" do
+    it "is a blank html view by default" do
+      expect(action.default_error_respondable).to eq Aldous::View::Blank::HtmlView
+    end
+  end
+
+  describe "#build_view" do
+    before do
+      allow(Aldous::BuildRespondableService).to receive(:new).with(
+        view_context: view_context,
+        default_view_data: Hash.new,
+        respondable_class: respondable_class,
+        status: nil,
+        extra_data: extra_data
+      ).and_return(build_respondable_service)
+    end
+
+    let(:respondable_class) {double "respondable_class"}
+    let(:extra_data) { {hello: 1} }
+
+    let(:build_respondable_service) {double "build_respondable_service", perform: nil}
+
+    it "executes the BuildRespondableService" do
+      expect(build_respondable_service).to receive(:perform)
+      action.build_view(respondable_class, extra_data)
+    end
+  end
+end

data/spec/aldous/controller_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe Aldous::Controller do
+  before do
+    class ExampleController
+      include Aldous::Controller
+    end
+  end
+
+  describe "::controller_actions" do
+    before do
+      ExampleController.controller_actions(:hello, :world)
+    end
+
+    context "a controller instance" do
+      let(:controller) {ExampleController.new}
+
+      it "responds to :hello" do
+        expect(controller).to respond_to :hello
+      end
+
+      it "responds to :world" do
+        expect(controller).to respond_to :world
+      end
+    end
+  end
+end

data/spec/aldous/dummy_error_reporter_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe Aldous::DummyErrorReporter do
+  describe "::report" do
+    let(:error) {RuntimeError.new('blah')}
+    let(:data) { Hash.new }
+
+    it "responds to the report method correctly" do
+      expect(described_class.report(error, data)).to eq nil
+    end
+  end
+end

data/spec/aldous/dummy_logger_spec.rb

@@ -0,0 +1,7 @@
+RSpec.describe Aldous::DummyLogger do
+  describe "::info" do
+    it "responds to the info method correctly" do
+      expect(described_class.info('blah')).to eq nil
+    end
+  end
+end

data/spec/aldous/logging_wrapper_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Aldous::LoggingWrapper do
+  describe "::log" do
+    subject(:log) {described_class.log(error)}
+    let(:error) {"hello world"}
+
+    let(:aldous_config) {
+      double "aldous_config", error_reporter: error_reporter, logger: logger
+    }
+    let(:error_reporter) {double "error_reporter", report: nil}
+    let(:logger) {double "logger", info: nil}
+
+    before do
+      allow(Aldous).to receive(:config).and_return(aldous_config)
+    end
+
+    context "when error is a string" do
+      let(:error) {"hello world"}
+
+      it "reports the error" do
+        expect(error_reporter).to receive(:report).with(error)
+        log
+      end
+
+      it "logs the error" do
+        expect(logger).to receive(:info).with(error)
+        log
+      end
+    end
+
+    context "when error is an error object" do
+      let(:error) {RuntimeError.new(message)}
+      let(:message) {"hello"}
+      let(:backtrace) {"foobar"}
+
+      before do
+        error.set_backtrace(backtrace)
+      end
+
+      it "reports the error message" do
+        expect(error_reporter).to receive(:report).with(error)
+        log
+      end
+
+      it "logs the error message" do
+        expect(logger).to receive(:info).with(message)
+        log
+      end
+
+      it "logs the error backtrace" do
+        expect(logger).to receive(:info).with(backtrace)
+        log
+      end
+    end
+  end
+end

data/spec/aldous/params_spec.rb

@@ -0,0 +1,39 @@
+RSpec.describe Aldous::Params do
+  describe "::build" do
+    it "instantiates a new params object" do
+      expect(described_class).to receive(:new)
+      described_class.build({})
+    end
+  end
+
+  describe "#fetch" do
+    let(:params_object) {described_class.new(params)}
+    let(:params) { {} }
+
+    context "when error occurs" do
+      before do
+        allow(params_object).to receive(:permitted_params).and_raise(RuntimeError.new)
+        allow(Aldous::LoggingWrapper).to receive(:log)
+      end
+
+      it "logs the error" do
+        expect(Aldous::LoggingWrapper).to receive(:log)
+        params_object.fetch
+      end
+
+      it "returns nil" do
+        expect(params_object.fetch).to be_nil
+      end
+    end
+
+    context "when no error occurs" do
+      before do
+        allow(params_object).to receive(:permitted_params).and_return('hello')
+      end
+
+      it "returns the permitted_params" do
+        expect(params_object.fetch).to eq 'hello'
+      end
+    end
+  end
+end

data/spec/aldous/respondable/base_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Aldous::Respondable::Base do
+  let(:status) {:foo}
+  let(:view_data) {double("view_data")}
+  let(:view_context) {double("view context")}
+
+  describe "::new" do
+    it "object can be instantiated with the right params" do
+      expect{described_class.new(status, view_data, view_context)}.to_not raise_error
+    end
+  end
+end

data/spec/aldous/respondable/headable/head_action_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Aldous::Respondable::Headable::HeadAction do
+  subject(:respondable) {described_class.new(controller, status)}
+
+  let(:controller) {double 'controller'}
+  let(:status) {'hello'}
+
+  before do
+    allow(controller).to receive(:head).with(status)
+  end
+
+  describe "#execute" do
+    it "calls head on controller with status" do
+      expect(controller).to receive(:head).with(status)
+      respondable.execute
+    end
+  end
+end

data/spec/aldous/respondable/headable_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Aldous::Respondable::Headable do
+  subject(:headable) {described_class.new(status, view_data, view_context)}
+
+  let(:status) {:foo}
+  let(:view_data) {double("view_data")}
+  let(:view_context) {double("view context")}
+
+  describe "::action" do
+    let(:controller) {double("controller")}
+
+    it "returns a head response action object" do
+      expect(headable.action(controller)).to be_kind_of Aldous::Respondable::Headable::HeadAction
+    end
+
+    it 'creates a head response action with the relevant parameters' do
+      expect(Aldous::Respondable::Headable::HeadAction).to receive(:new).with(controller, status)
+      headable.action(controller)
+    end
+  end
+end

data/spec/aldous/respondable/redirectable/redirect_action_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Aldous::Respondable::Redirectable::RedirectAction do
+  subject(:respondable) {described_class.new(location, controller, view_data, status)}
+
+  let(:location) {"hello"}
+  let(:controller) {double 'controller', redirect_to: nil, flash: flash }
+  let(:view_data) {"blah"}
+  let(:response_status) {'world'}
+  let(:status) { :found }
+
+  let(:flash) { double("flash") }
+  let(:flash_object) { instance_double Aldous::Respondable::Shared::Flash, set_error: nil }
+
+
+  describe "#execute" do
+    before do
+      allow(Aldous::Respondable::Shared::Flash).to receive(:new){ flash_object }
+    end
+
+    it "calls redirect_to on controller with the relevant options" do
+      expect(controller).to receive(:redirect_to).with(location, {status: status})
+      respondable.execute
+    end
+
+    it "tries to set flash" do
+      expect(Aldous::Respondable::Shared::Flash).to receive(:new).with(view_data, flash)
+      respondable.execute
+    end
+
+    it "calls set_error on flash object" do
+      expect(flash_object).to receive(:set_error)
+      respondable.execute
+    end
+  end
+end

data/spec/aldous/respondable/redirectable_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Aldous::Respondable::Redirectable do
+  class Aldous::Respondable::Redirectable::Dummy < described_class
+    def location
+      'hello'
+    end
+  end
+
+  subject(:redirectable) {Aldous::Respondable::Redirectable::Dummy.new(status, view_data, view_context)}
+
+  let(:status) {:foo}
+  let(:view_data) {double("view_data")}
+  let(:view_context) {double("view context")}
+
+  describe "::action" do
+    let(:controller) {double("controller")}
+
+    it "returns a redirect response action object" do
+      expect(redirectable.action(controller)).to be_kind_of Aldous::Respondable::Redirectable::RedirectAction
+    end
+
+    it 'creates a redirect response action with the relevant parameters' do
+      expect(Aldous::Respondable::Redirectable::RedirectAction).to receive(:new).with(redirectable.location, controller, view_data, status)
+      redirectable.action(controller)
+    end
+  end
+end

data/spec/aldous/respondable/renderable/render_action_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Aldous::Respondable::Renderable::RenderAction do
+  subject(:respondable) {described_class.new(template, status, controller, view_data)}
+
+  let(:status) {:foo}
+  let(:template) { {hello: 'world'} }
+  let(:controller) {double 'controller', render: nil, flash: flash }
+  let(:view_data) {"blah"}
+  let(:response_status) {'world'}
+
+  let(:flash) { double("flash", now: flash_now) }
+  let(:flash_now) { double("flash_now") }
+  let(:flash_object) { instance_double Aldous::Respondable::Shared::Flash, set_error: nil }
+
+  describe "#execute" do
+    before do
+      allow(Aldous::Respondable::Shared::Flash).to receive(:new){ flash_object }
+    end
+
+    it "calls render on controller with the relevant options" do
+      expect(controller).to receive(:render).with(template.merge(status: status))
+      respondable.execute
+    end
+
+    it "tries to set flash" do
+      expect(Aldous::Respondable::Shared::Flash).to receive(:new).with(view_data, flash_now)
+      respondable.execute
+    end
+
+    it "calls set_error on flash object" do
+      expect(flash_object).to receive(:set_error)
+      respondable.execute
+    end
+  end
+end

data/spec/aldous/respondable/renderable_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Aldous::Respondable::Renderable do
+  class Aldous::Respondable::Renderable::Dummy < described_class
+    def template_data
+      {
+        locals: {hello: 1}
+      }
+    end
+
+    def default_template_locals
+      {
+        hello: 2
+      }
+    end
+  end
+
+  subject(:renderable) {Aldous::Respondable::Renderable::Dummy.new(status, view_data, view_context)}
+
+  let(:status) {:foo}
+  let(:view_data) {double("view_data")}
+  let(:view_context) {double("view context")}
+
+  describe "#action" do
+    let(:controller) {double("controller")}
+
+    it "returns a render response action object" do
+      expect(renderable.action(controller)).to be_kind_of Aldous::Respondable::Renderable::RenderAction
+    end
+
+    it 'creates a redirect response action with the relevant parameters' do
+      expect(Aldous::Respondable::Renderable::RenderAction).to receive(:new).with(renderable.template, status, controller, view_data)
+      renderable.action(controller)
+    end
+  end
+
+  describe "#template" do
+    subject(:renderable) {Aldous::Respondable::Renderable::Dummy.new(status, view_data, view_context)}
+
+    it "overrides the default locals with the template locals" do
+      expect(renderable.template).to eq({locals: {hello: 1}})
+    end
+
+    it "overrides the template locals with the provided locals" do
+      expect(renderable.template(hello: 3)).to eq({locals: {hello: 3}})
+    end
+  end
+end

data/spec/aldous/respondable/send_data/send_data_action_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Aldous::Respondable::SendData::SendDataAction do
+  subject(:respondable) {described_class.new(data, options, controller, result)}
+
+  let(:data) { 'hello' }
+  let(:options) {'world'}
+  let(:controller) {double 'controller', render: nil}
+  let(:result) {"blah"}
+
+  describe "#execute" do
+    it "calls render on controller with the relevant options" do
+      expect(controller).to receive(:send_data).with(data, options)
+      respondable.execute
+    end
+  end
+end

data/spec/aldous/respondable/send_data_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Aldous::Respondable::SendData do
+  class Aldous::Respondable::SendData::Dummy < described_class
+    def data
+      'hello'
+    end
+
+    def options
+      'world'
+    end
+  end
+
+  subject(:send_data) {Aldous::Respondable::SendData::Dummy.new(status, view_data, view_context)}
+
+  let(:status) {:foo}
+  let(:view_data) {double("view_data")}
+  let(:view_context) {double("view context")}
+
+  describe "::action" do
+    let(:controller) {double("controller")}
+
+    it "returns a send_data response action object" do
+      expect(send_data.action(controller)).to be_kind_of Aldous::Respondable::SendData::SendDataAction
+    end
+
+    it 'creates a send_data response action with the relevant parameters' do
+      expect(Aldous::Respondable::SendData::SendDataAction).to receive(:new).with(send_data.data, send_data.options, controller, view_data)
+      send_data.action(controller)
+    end
+  end
+end

data/spec/aldous/respondable/shared/flash_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Aldous::Respondable::Shared::Flash do
+  let(:flash) {described_class.new(result, flash_container)}
+
+  let(:controller) {double 'controller', flash: flash_container}
+  let(:result) {double 'result', errors: errors}
+  let(:errors) {['1', '2']}
+  let(:flash_container) {double 'flash container', now: flash_now}
+  let(:flash_now) { {} }
+
+  describe "#set_error" do
+    context "when errors exist" do
+      let(:flash_container) { {} }
+
+      it "sets the error on the flash container" do
+        flash.set_error
+        expect(flash_container[:error]).to eq '1'
+      end
+    end
+
+    context "when errors don't exist" do
+      let(:errors) {[]}
+      let(:flash_container) { {} }
+
+      it "doesn't set the error on the flash container" do
+        flash.set_error
+        expect(flash_container[:error]).to eq nil
+      end
+    end
+  end
+end

data/spec/aldous/service/result/failure_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Aldous::Service::Result::Failure do
+  subject(:result) {described_class.new}
+
+  describe "#failure?" do
+    it {expect(result.failure?).to eq true}
+  end
+
+  describe "#success?" do
+    it {expect(result.success?).to eq false}
+  end
+end

data/spec/aldous/service/result/success_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Aldous::Service::Result::Success do
+  subject(:result) {described_class.new}
+
+  describe "#failure?" do
+    it {expect(result.failure?).to eq false}
+  end
+
+  describe "#success?" do
+    it {expect(result.success?).to eq true}
+  end
+end