controll 0.2.0

data/spec/controll/flow_handler/redirect/mapper_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+def notice name
+  Hashie::Mash.new(name: name.to_sym, type: :notice)
+end
+
+def error name
+  Hashie::Mash.new(name: name.to_sym, type: :error)
+end
+
+describe Controll::FlowHandler::Redirect::Mapper do
+  let(:redirections) do
+    { 
+      :error => error_map, :notice => notice_map
+    }
+  end
+
+  let(:notice_map)  do
+    {:welcome =>  valid_events }
+  end
+
+  let(:valid_events) { [:hello, :hi] }
+  let(:invalid_events) { [:blip, :blap] }
+
+  let(:error_map)  do
+    {bad: ['bad_payment', 'wrong_payment'] }
+  end
+
+  let(:types) { [:notice, :error] }
+
+  context 'use' do    
+    subject { clazz.new hello, notice_map }
+
+    let(:clazz)         { Controll::FlowHandler::Redirect::Mapper }
+    let(:hello)         { notice :hello }
+    let(:bad_payment)   { error :bad_payment }
+
+    describe '.initialize' do
+      its(:event) { should == hello }
+      its(:redirect_map) { should == notice_map }
+    end
+
+    describe '.map' do
+      specify do
+        subject.map.should == 'welcome'
+      end
+    end
+
+    describe '.matcher event' do
+      specify do
+        subject.send(:matcher, hello).should be_a Controll::Helper::EventMatcher
+      end      
+
+      specify do
+        subject.send(:matcher, hello).event.should == hello
+      end      
+    end
+
+    describe '.valid?' do
+      specify do
+        subject.send(:valid?, valid_events).should be_true
+      end
+
+      specify do
+        subject.send(:valid?, invalid_events).should be_false
+      end
+    end
+  end
+end

data/spec/controll/flow_handler/redirect_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+class HelloToWelcomeRedirect < Controll::FlowHandler::Redirect
+  set_redirections :welcome => [:hello, :hi]
+end
+
+class ErrorBadRedirect < Controll::FlowHandler::Redirect  
+  set_redirections :error, bad: ['bad_payment', 'wrong_payment']
+end
+
+def notification name
+  Hashie::Mash.new(name: name.to_sym, type: :notice)
+end
+
+def error name
+  Hashie::Mash.new(name: name.to_sym, type: :error)
+end
+
+describe Controll::FlowHandler::Redirect do
+
+  describe 'class macros' do
+    before :all do
+      ErrorBadRedirect.set_redirections :error, crap: ['bad_payment', 'wrong_payment']
+    end
+
+    specify {
+      ErrorBadRedirect.redirections_for(:error).should == {crap: ['bad_payment', 'wrong_payment']}
+    }
+
+    specify {
+      ErrorBadRedirect.redirections.should == {error: {crap: ['bad_payment', 'wrong_payment']} }
+    }
+  end
+
+  # context 'use directly without subclassing' do
+  #   subject { clazz.new '/' }
+
+  #   let(:clazz) { Controll::FlowHandler::Redirect }
+
+  #   let(:hello) { notification :hello }
+
+  #   describe '.action event' do
+  #     specify do
+  #       expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::Redirect::NoRedirectionFoundError)
+  #     end
+  #   end
+  # end
+
+  # context 'HelloToWelcomeRedirect subclass' do
+  #   subject { clazz.new '/' }
+
+  #   let(:clazz) { HelloToWelcomeRedirect }
+
+  #   context 'has redirections' do
+  #     describe '.action event' do
+  #       specify do
+  #         expect { clazz.action(:hello) }.to_not raise_error(Controll::FlowHandler::Redirect::NoRedirectionFoundError)
+  #       end
+
+  #       specify do
+  #         clazz.action(:hello).should be_a HelloToWelcomeRedirect
+  #       end
+
+  #       specify do
+  #         clazz.action(:hi).path.should == 'welcome'
+  #       end
+  #     end
+  #   end
+  # end
+
+  context 'ErrorBadRedirect subclass' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { ErrorBadRedirect }
+
+    context 'has error redirections' do
+      describe '.action event' do
+        specify do
+          expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::NoRedirectionFoundError)
+        end
+
+        specify do
+          clazz.action(error :bad_payment).should be_a ErrorBadRedirect
+        end
+
+        specify do
+          clazz.action(error :wrong_payment).path.should == 'crap'
+        end
+      end
+    end
+  end
+
+end

data/spec/controll/flow_handler/render_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+class NoEventsRender < Controll::FlowHandler::Render
+  def self.events
+    []
+  end
+end
+
+class HiRender < Controll::FlowHandler::Render
+  def self.events
+    [:hi]
+  end
+end
+
+class HelloRender < Controll::FlowHandler::Render
+  set_events :hello, :damn
+  set_default_path '/default'
+end
+
+def notification name
+  Hashie::Mash.new(name: name.to_sym, type: :notification)
+end
+
+describe Controll::FlowHandler::Render do
+
+  context 'use directly without sublclassing' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { Controll::FlowHandler::Render }
+
+    let(:hello) { notification :hello }
+
+    describe '.action event' do
+      specify do
+        expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::NoEventsDefinedError)
+      end
+    end
+  end
+
+  context 'NoEventsRender subclass' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { NoEventsRender }
+
+    context 'empty events' do
+      describe '.action event' do
+        specify do
+          expect { clazz.action(:hello) }.to raise_error(Controll::FlowHandler::NoEventsDefinedError)
+        end
+      end
+    end
+  end
+
+  context 'HiRender subclass' do
+    subject { clazz.new '/' }
+
+    let(:clazz) { HiRender }
+    let(:event) { notification :hello }
+
+    context 'has events' do
+      describe '.action event' do
+
+        describe 'does not respond to hello' do
+          specify do
+            expect { clazz.action(:hello) }.to_not raise_error(Controll::FlowHandler::Render::NoEventsDefinedError)
+          end
+
+          specify do
+            clazz.action(event).should == nil
+          end
+
+          specify do
+            clazz.action(:hello).should == nil
+          end
+        end
+
+        describe 'responds to hi' do
+          # default_path not implemented!
+          specify do
+            expect { clazz.action(:hi) }.to raise_error NotImplementedError
+          end
+        end
+      end
+    end
+  end
+
+  context 'HelloRender subclass' do
+    subject { clazz.new default_path }
+
+    let(:clazz) { HelloRender }
+    let(:event) { notification :hello }
+    let(:default_path) { '/default' } 
+
+    context 'has events and default_path' do
+      describe '.action event' do
+        specify do
+          clazz.action(event).should be_a HelloRender
+        end        
+
+        specify do
+          clazz.action(event).path.should == default_path
+        end        
+
+        specify do
+          clazz.action(event, 'other_path').path.should == 'other_path'
+        end        
+      end
+    end
+  end  
+end

data/spec/controll/helper/event_matcher_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Controll::Helper::EventMatcher do
+  subject { Controll::Helper::EventMatcher.new event }
+
+  let(:events)      { %w{sign_in sign_out} }
+  let(:bad_events)  { %w{bad stuff} }
+
+  let(:event)       { 'sign_in' }
+  let(:bad_event)   { 'unknown' }
+
+  describe '.initialize event' do
+    its(:event) { should == 'sign_in' }
+  end
+
+  describe '.match? events' do
+    specify { subject.match?(events).should be_true }
+
+    specify { subject.match?(bad_events).should be_false }
+  end
+end

data/spec/controll/helper/hash_access_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+class Hasher
+  include Controll::Helper::HashAccess  
+
+  attr_reader :params
+
+  def initialize params = nil
+    @params = params || {name: 'kris'}
+  end
+end
+
+describe Controll::Helper::HashAccess do
+
+  subject { clazz.new }
+  let(:clazz) { Hasher }
+
+  describe '.hash_access_methods *args' do
+    before :all do
+      clazz.hash_access_methods :name, hash: :params
+    end
+
+    specify { subject.name.should == 'kris' }
+  end
+end

data/spec/controll/helper/notify_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class Notifier
+  include Controll::Helper::Notify
+end  
+
+describe Controll::Helper::Notify do
+  subject { Notifier.new }
+
+  context 'initial state' do
+    describe '.notifications' do
+      its(:notifications) { should be_empty }      
+    end
+
+    describe '.main_event' do
+      its(:main_event) { should be_a Hashie::Mash }
+    end
+
+    describe '.create_notification' do
+      specify { subject.send(:create_notification, :updated).should be_a Hashie::Mash }
+    end
+
+    describe '.create_event' do
+      specify { subject.send(:create_event, :updated).should be_a Hashie::Mash }
+    end
+
+    describe '.create_notice' do
+      specify { subject.send(:create_notice,:updated).should be_a Hashie::Mash }
+    end
+
+    describe '.notify' do 
+      describe '.with name only' do
+        specify { subject.notify(:updated).main_event.type.should == :notice }
+      end
+
+      describe 'name and :error type' do
+        specify { subject.notify(:updated, :error).main_event.type.should == :error }
+      end
+
+      describe 'name and unknown type' do
+        specify do
+          expect { subject.notify(:updated, :unknown) }.to raise_error
+        end
+      end
+    end
+
+  end
+end

data/spec/controll/helper/params_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class Parameters
+  include Controll::Helper::Params
+
+  attr_reader :params
+
+  def initialize params = nil
+    @params = params || {name: 'kris', shoe_size: 43, gender: 'male' }
+  end
+end
+
+describe Controll::Helper::Params do
+
+  subject { clazz.new }
+  let(:clazz) { Parameters }
+
+  describe '.param_methods *args' do
+    before :all do
+      clazz.param_methods :name, :shoe_size
+      clazz.param_method  :gender
+    end
+
+    its(:name)      { should == 'kris' }
+    its(:shoe_size) { should == 43 }
+    its(:gender)    { should == 'male' }
+  end
+end

data/spec/controll/helper/path_resolver_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class MySweetController
+  include Controll::Helper
+
+  redirect_map :index => %w{success}
+
+  render_map :show => %w{success}
+
+  # Mocking!
+  def render path
+    path
+  end
+  alias_method :redirect_to, :render
+end
+
+describe Controll::Helper::PathResolver do
+  subject { Controll::Helper::PathResolver.new controller }
+
+  let(:controller) { MySweetController.new }
+
+  describe '.extract_path' do
+    describe ':redirect_map' do
+      specify do
+        subject.extract_path(:redirect_map).should == 'index'
+      end
+    end
+
+    describe ':render_paths' do
+      specify do
+        subject.extract_path(:render_paths).should == 'show'
+      end
+    end
+  end
+
+  describe '.resolve_path' do
+    describe ':redirect_map' do
+      specify do
+        subject.resolve_path(:redirect_map).should == 'index'
+      end
+    end
+
+    describe ':render_paths' do
+      specify do
+        subject.resolve_path(:render_paths).should == 'show'
+      end
+    end
+  end
+end