riveter 0.0.1

data/spec/riveter/attributes_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+describe Riveter::Attributes do
+  describe "class" do
+    subject do
+      # create an anonymous class
+      Class.new().class_eval {
+        include Riveter::Attributes
+
+        def self.name
+          'TestClass'
+        end
+
+        self
+      }
+    end
+
+    describe ".attributes" do
+      it { subject.attributes.should_not be_nil }
+      it { subject.attributes.should be_a(Array) }
+
+      it "each class has it's own set" do
+        subject.attributes.should_not eq(TestClassWithAttributes.attributes)
+      end
+    end
+
+    it_should_behave_like "an attribute", :string, 'A', 'B'
+
+    it_should_behave_like "an attribute", :text, 'B', 'C'
+
+    it_should_behave_like "an attribute", :integer, 1, 2 do
+      describe "additional" do
+        before do
+          subject.attr_integer :an_attribute
+        end
+        let(:instance) { subject.new() }
+
+        it { instance.should validate_numericality_of(:an_attribute) }
+      end
+    end
+
+    it_should_behave_like "an attribute", :date, Date.new(2010, 1, 12), Date.new(2010, 1, 13) do
+      describe "additional" do
+        before do
+          subject.attr_date :an_attribute
+        end
+        let(:instance) { subject.new() }
+
+        it { instance.should validate_timeliness_of(:an_attribute) }
+      end
+    end
+
+    it_should_behave_like "an attribute", :time, Time.new(2010, 1, 12, 8, 4, 45), Time.new(2010, 1, 12, 8, 4, 12) do
+      describe "additional" do
+        before do
+          subject.attr_time :an_attribute
+        end
+        let(:instance) { subject.new() }
+
+        it { instance.should validate_timeliness_of(:an_attribute) }
+      end
+    end
+
+    it_should_behave_like "an attribute", :boolean, true, false do
+      describe "additional" do
+        before do
+          subject.attr_boolean :an_attribute
+        end
+        let(:instance) { subject.new() }
+
+        it { instance.should validate_booleaness_of(:an_attribute) }
+      end
+    end
+
+    it_should_behave_like "an attribute", :enum, TestEnum::Member1, TestEnum::Member2, TestEnum do
+      describe "additional" do
+        before do
+          subject.attr_enum :product_type, TestEnum
+        end
+        let(:instance) { subject.new() }
+
+        it { instance.should ensure_inclusion_of(:product_type).in_array(TestEnum.all) }
+
+        it { should respond_to(:product_type_enum)}
+        it { subject.product_type_enum.should eq(TestEnum) }
+        it { should respond_to(:product_types)}
+        it { subject.product_types.should eq(TestEnum.collection)}
+      end
+    end
+
+    it_should_behave_like "an attribute", :array, [1, 2, 3], [5, 6]
+
+    it_should_behave_like "an attribute", :hash, {:a => :b}, {:c => :d}
+
+    it_should_behave_like "an attribute", :model, TestModel.new(), TestModel.new(), TestModel do
+      describe "additional" do
+        before do
+          subject.attr_model :product, TestModel
+        end
+
+        it { should respond_to(:product_model)}
+        it { subject.product_model.should eq(TestModel) }
+      end
+    end
+
+    it_should_behave_like "an attribute", :object, Object.new(), Object.new()
+  end
+
+  describe "instance" do
+    subject { TestClassWithAttributes.new() }
+
+    describe "#initialize" do
+      it "assigns attribute default values" do
+        subject.string.should eq('A')
+        subject.text.should eq('b')
+        subject.integer.should eq(1)
+        subject.decimal.should eq(9.998)
+        subject.date.should eq(Date.new(2010, 1, 12))
+        subject.time.should eq(Time.new(2010, 1, 12, 14, 56))
+        subject.boolean.should eq(true)
+        subject.enum.should eq(TestEnum::Member1)
+        subject.array.should eq([1, 2, 3])
+        subject.hash.should eq({:a => :b})
+        subject.model.should eq(TestModel)
+        subject.object.should eq('whatever')
+      end
+    end
+
+    describe "#attributes" do
+      it { subject.attributes.should_not be_nil }
+      it { subject.attributes.should be_a(Hash) }
+      it {
+        subject.attributes.should eq({
+          'string' => 'A',
+          'text' => 'b',
+          'integer' => 1,
+          'decimal' => 9.998,
+          'date' => Date.new(2010, 1, 12),
+          'time' => Time.new(2010, 1, 12, 14, 56),
+          'boolean' => true,
+          'enum' => TestEnum::Member1,
+          'array' => [1, 2, 3],
+          'hash' => {:a => :b},
+          'model' => TestModel,
+          'object' => 'whatever'
+        })
+      }
+    end
+
+    describe "#persisted?" do
+      it { subject.persisted?.should be_false }
+    end
+
+    describe "#column_for_attribute" do
+      it { subject.column_for_attribute(:string).should_not be_nil }
+      it { subject.column_for_attribute(:string).name.should eq(:string) }
+    end
+
+    describe "#filter_params" do
+      it "filters out unknown attributes" do
+        params = subject.send(:filter_params, :string => 'AA', :unknown => :value)
+        params.should include(:string)
+        params.should_not include(:unknown)
+      end
+    end
+
+    describe "#clean_params" do
+      it "removes blank attributes" do
+        params = subject.send(:clean_params, :string => '')
+        params.should_not include(:string)
+      end
+
+      it "removes nil attributes" do
+        params = subject.send(:clean_params, :string => nil)
+        params.should_not include(:string)
+      end
+
+      describe "nested attribute arrays" do
+        it "removes blank attributes" do
+          params = subject.send(:clean_params, :string => [1, 2, ''])
+          params.should include(:string)
+          params[:string].length.should eq(2)
+        end
+
+        it "removes nil attributes" do
+          params = subject.send(:clean_params, :string => [1, 2, nil])
+          params.should include(:string)
+          params[:string].length.should eq(2)
+        end
+      end
+
+      describe "nested attribute hashes" do
+        it "removes blank attributes" do
+          params = subject.send(:clean_params, :string => { :a => 'A', :b => '' })
+          params.should include(:string)
+          params[:string].should_not include(:b)
+        end
+
+        it "removes nil attributes" do
+          params = subject.send(:clean_params, :string => { :a => 'A', :b => nil })
+          params.should include(:string)
+          params[:string].should_not include(:b)
+        end
+      end
+    end
+
+    describe "#apply_params" do
+      it "assigns attributes" do
+        subject.string.should eq('A')
+        subject.send(:apply_params, :string => 'test')
+        subject.string.should eq('test')
+      end
+
+      it "raises UnknownAttributeError for unknown attribute" do
+        expect {
+          subject.send(:apply_params, :unknown => 'test')
+        }.to raise_error(Riveter::UnknownAttributeError)
+      end
+
+      it "re-raises error attribute" do
+        allow(subject).to receive(:string=).and_raise(ArgumentError)
+        expect {
+          subject.send(:apply_params, :string => 'test')
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/riveter/command_controller_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'action_controller'
+
+describe Riveter::CommandController do
+  context "when not configured" do
+    describe "class" do
+      subject { TestCommandController }
+
+      it { should respond_to(:command_controller_for) }
+      it { should_not respond_to(:command_class) }
+      it { should_not respond_to(:command_options) }
+    end
+
+    describe "instance" do
+      subject { TestCommandController.new }
+
+      it { should_not respond_to(:new) }
+      it { should_not respond_to(:create) }
+    end
+  end
+
+  context "when configured" do
+    describe "class" do
+      subject { TestTestCommandController }
+
+      it { should respond_to(:command_controller_for) }
+    end
+
+    describe "instance" do
+      subject { TestTestCommandController.new }
+
+      it { should respond_to(:command_class) }
+      it { should respond_to(:command_options) }
+      it { should respond_to(:new) }
+      it { should respond_to(:create) }
+
+      describe "#command_class" do
+        it { subject.command_class.should eq(TestCommand) }
+      end
+
+      describe "#command_options" do
+        it { subject.command_options.should have_key(:as) }
+        it { subject.command_options.should have_key(:attributes) }
+
+        it { subject.command_options[:as].should eq('test') }
+        it { subject.command_options[:attributes].should eq(TestCommand.attributes) }
+      end
+
+      describe "controller action" do
+        describe "#new" do
+          it "assigns @command" do
+            subject.new
+            subject.send(:eval, '@command').should_not be_nil
+          end
+        end
+
+        describe "#create" do
+          before do
+            allow(subject).to receive(:params) { ActionController::Parameters.new({:test => {:name => 'test'}}) }
+          end
+
+          it "assigns @command" do
+            allow_any_instance_of(TestCommand).to receive(:submit) { true }
+            allow(subject).to receive(:on_success) { true }
+
+            subject.create
+            subject.send(:eval, '@command').should_not be_nil
+          end
+
+          it "assigns attributes" do
+            allow_any_instance_of(TestCommand).to receive(:perform) { true }
+            allow(subject).to receive(:on_success) { true }
+
+            subject.create
+            command = subject.send(:eval, '@command')
+            command.name.should eq('test')
+          end
+
+          context "for a valid command" do
+            before do
+              allow_any_instance_of(TestCommand).to receive(:submit) { true }
+            end
+
+            it "invokes 'on_success'" do
+              expect(subject).to receive(:on_success)
+              subject.create
+            end
+
+            it "throws exception when 'on_success' not implemented" do
+              expect {
+                subject.create
+              }.to raise_error(NotImplementedError)
+            end
+          end
+
+          context "for an invalid command" do
+            before do
+              allow_any_instance_of(TestCommand).to receive(:submit) { false }
+              allow(subject).to receive(:render) { true }
+            end
+
+            it "invokes 'on_failure' if defined" do
+              expect(subject).to receive(:on_failure) {}
+              subject.create
+            end
+
+            it "re-renders the 'new' template" do
+              expect(subject).to receive(:render).with(:new) { false }
+              subject.create
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/riveter/command_routes_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'riveter/command_routes'
+
+describe Riveter::CommandRoutes do
+  describe "instance" do
+    subject { TestCommandRoutes.new() }
+
+    describe "#command" do
+      it { should respond_to(:command) }
+
+      it "should define a GET and POST route" do
+        expect(subject).to receive(:get)
+        expect(subject).to receive(:post)
+
+        subject.command :test_command
+      end
+
+      it "should define a GET route for the :new action" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_command,
+          :as => :test_command,
+          :action => :new
+        })
+        allow(subject).to receive(:post)
+
+        subject.command :test
+      end
+
+      it "should define a POST route for the :create action" do
+        allow(subject).to receive(:get)
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_command,
+          :as => nil,
+          :action => :create
+        })
+
+        subject.command :test
+      end
+
+      it "should allow overriding the controller" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :my_controller,
+          :as => :test_command,
+          :action => :new
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :my_controller,
+          :as => nil,
+          :action => :create
+        })
+
+        subject.command :test, :controller => :my_controller
+      end
+
+      it "should allow overriding the path" do
+        expect(subject).to receive(:get).with('do_some_thing', {
+          :controller => :test_command,
+          :as => :test_command,
+          :action => :new
+        })
+        expect(subject).to receive(:post).with('do_some_thing', {
+          :controller => :test_command,
+          :as => nil,
+          :action => :create
+        })
+
+        subject.command :test, :path => 'do_some_thing'
+      end
+
+      it "should allow overriding the path helper name" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_command,
+          :as => :path_name,
+          :action => :new
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_command,
+          :as => nil,
+          :action => :create
+        })
+
+        subject.command :test, :as => :path_name
+      end
+
+      it "should allow overriding the new action" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_command,
+          :as => :test_command,
+          :action => :my_new_action
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_command,
+          :as => nil,
+          :action => :create
+        })
+
+        subject.command :test, :new_action => :my_new_action
+      end
+
+      it "should allow overriding the create action" do
+        expect(subject).to receive(:get).with('test', {
+          :controller => :test_command,
+          :as => :test_command,
+          :action => :new
+        })
+        expect(subject).to receive(:post).with('test', {
+          :controller => :test_command,
+          :as => nil,
+          :action => :my_create_action
+        })
+
+        subject.command :test, :create_action => :my_create_action
+      end
+    end
+  end
+end

data/spec/riveter/command_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Riveter::Command do
+  it_should_behave_like "a class with attributes", TestCommand
+
+  describe "class" do
+    subject { TestCommand }
+
+    describe ".command_name" do
+      it { should respond_to(:command_name) }
+      it { subject.command_name.should be_a(ActiveModel::Name) }
+    end
+
+    describe ".i18n_scope" do
+      it { should respond_to(:i18n_scope) }
+      it { subject.i18n_scope.should eq(:commands) }
+    end
+  end
+
+  describe "instance" do
+    subject { TestCommand.new() }
+
+    describe "#can_perform?" do
+      it "should yield false when invalid" do
+        subject.can_perform?.should be_false
+      end
+
+      it "should yield true when valid" do
+        subject.name = 'test'
+        subject.can_perform?.should be_true
+      end
+    end
+
+    describe "#submit" do
+      it "should yield false when invalid" do
+        subject.submit().should be_false
+      end
+
+      it "should yield true when valid" do
+        allow(subject).to receive(:perform) { true }
+
+        subject.name = 'test'
+        subject.submit().should be_true
+      end
+
+      it "should assign attributes" do
+        allow(subject).to receive(:perform) { true }
+
+        subject.submit(:name => 'test')
+        subject.name.should eq('test')
+      end
+
+      it "should not assign unknown attributes" do
+        subject.submit(:unknown => 'test')
+        subject.name.should be_blank
+      end
+
+      it "should invoke associated service" do
+        allow(subject).to receive(:valid?) { true }
+        expect_any_instance_of(TestService).to receive(:perform) { true }
+
+        subject.submit(:name => 'test')
+      end
+    end
+  end
+end