seat-belt 0.10.0

data/spec/lib/seatbelt/core/proxy_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Seatbelt::Proxy do
+  before(:all) do
+    Seatbelt::Proxy.class_eval do
+      def klass
+        @klass = [] unless defined?(@klass)
+        @klass
+      end
+      private :klass
+    end
+  end
+  describe "instance methods" do
+
+    it "prodvides #call" do
+      expect(subject).to respond_to(:call)
+    end
+
+    it "provides #tunnel" do 
+      expect(subject).to respond_to(:tunnel)
+    end
+
+    describe "#call" do
+
+      it "calls a method of its klass" do
+        proxy = Seatbelt::Proxy.new
+        expect(proxy.call(:empty?)).to be true
+        expect do
+          proxy.call(:push, 1)
+        end.to change{ proxy.send(:klass).size }.by(1)
+        expect do
+          proxy.push(1)
+        end.to change{ proxy.send(:klass).size }.by(1)
+      end
+
+    end
+
+    describe "#tunnel" do 
+      let(:klass){ double(:region) }
+      let(:proxy){ Seatbelt::Proxy.new }
+      let(:implementation_object){ double("implementation") }
+      def define_doubles
+        implementation_object.stub(:my_implementation_attribute).
+                              and_return("Black")
+        eigenmethod = double("Seatbelt::Eigenmethod")
+        eigenmethod.stub(:callee).and_return(implementation_object)
+        implementation_object.stub(:eigenmethods).and_return([eigenmethod])
+        klass.stub(:hasable).and_return(implementation_object)
+      end
+
+      before do 
+        define_doubles
+        proxy.stub(:object).and_return(klass)
+      end
+
+      it "delegates a method chain call to the underlying callee object" do 
+        expect(proxy.tunnel("hasable.my_implementation_attribute")).to eq "Black"
+      end
+
+      context "calling a not existing object" do 
+
+        it "raises a Seatbelt::Errors::ObjectDoesNotExistError" do 
+          expect do 
+            proxy.tunnel("likeable.an_attribute")
+          end.to raise_error(Seatbelt::Errors::ObjectDoesNotExistError, 
+                             "The object you called does not exist.")
+        end
+      end
+
+      context "calling with an unchained argument" do 
+
+        it "generates a warning" do 
+          implementation_object.stub(:hasable).and_return([])
+          proxy.should_receive(:warn).with("You called a single object. Use #call instead.")
+          proxy.tunnel("hasable")
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "calling not allowable methods on proxy object" do
+
+    it "raises a NoMethodError" do
+      proxy = Seatbelt::Proxy.new
+      expect{ proxy.klass }.to raise_error(NoMethodError)
+      expect(proxy.object).to be_instance_of Array
+
+      Seatbelt::Proxy.class_eval do
+        def klass
+          @klass = Array unless defined?(@klass)
+          @klass  
+        end
+        private :klass
+      end
+
+      proxy = Seatbelt::Proxy.new
+      expect{ proxy.klass }.to raise_error(NoMethodError)
+      expect(proxy.object).to be Array
+      expect do
+        proxy.try_convert([1])
+      end.to_not raise_error
+    end
+  end
+
+end

data/spec/lib/seatbelt/core/terminal_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Seatbelt::Terminal do
+
+  describe "class methods" do
+
+    it "provides #luggage=" do
+      expect(Seatbelt::Terminal).to respond_to(:luggage=)
+    end
+
+    it "provides #luggage" do
+      expect(Seatbelt::Terminal).to respond_to(:luggage)
+    end
+
+    it "provides #call" do
+      expect(Seatbelt::Terminal).to respond_to(:call)
+    end
+
+    describe "#call" do
+
+      context "lugagge store is empty" do
+
+        it "calling a method raises Seatbelt::MethodNotImplementedError" do
+          stub_eigenmethods(Hash)
+          expect do
+            Seatbelt::Terminal.call(:my_method, Hash, 1,2)
+          end.to raise_error(Seatbelt::Errors::MethodNotImplementedError)
+        end
+
+      end
+
+      context "method to call is not implemented" do
+
+        module Seatbelt
+          class Array < ::Array
+            include Seatbelt::Gate
+          end
+        end
+
+        before do
+          proxy                 = Seatbelt::Eigenmethod.new
+          proxy.method          = Array.instance_method(:push)
+          proxy.implemented_as  = :add_item
+          proxy.scope           = :class
+          proxy.namespace       = "Seatbelt::Array"
+          proxy.receiver        = Array
+
+          Seatbelt::Terminal.luggage << proxy
+
+          proxy                 = Seatbelt::Eigenmethod.new
+          proxy.method          = Array.instance_method(:push)
+          proxy.implemented_as  = :my_method
+          proxy.scope           = :instance
+          proxy.namespace       = "Seatbelt::Array"
+          proxy.receiver        = Array
+
+          Seatbelt::Terminal.luggage << proxy
+        end
+
+        it "raises Seatbelt::MethodNotImplementedError" do
+          stub_eigenmethods(Seatbelt::Array)
+          expect do
+            Seatbelt::Terminal.call(:my_method, Seatbelt::Array, 1,2)
+          end.to raise_error(Seatbelt::Errors::MethodNotImplementedError)
+        end
+
+        context "the same method name but different namespace" do
+
+          it "raises Seatbelt::MethodNotImplementedError" do
+            hsh = {}
+            stub_eigenmethods(hsh)
+            expect do
+              Seatbelt::Terminal.call(:my_method, hsh, 1,2)
+            end.to raise_error(Seatbelt::Errors::MethodNotImplementedError)
+          end
+
+        end
+
+      end
+
+      context "method to call is implemented" do
+
+        before(:all) do
+          class ASample
+            include Seatbelt::Ghost
+            def abs_of_number(number)
+              number.abs
+            end
+
+            def self.klass_method
+              1
+            end
+          end
+
+          module Seatbelt
+            class ImplementA
+              include Gate
+
+              def method_to_call(num)
+                2+num+proxy.call(:abs_of_number, -2)
+              end
+              implement :method_to_call, :as => "ASample#my_method"
+
+              def acts_as_class_method(factor1, factor2)
+                #p proxy
+                factor1 * factor2 - proxy.call(:klass_method)
+              end
+              implement :acts_as_class_method, :as => "ASample.c_method"
+
+              def return_proxy
+                return proxy.object
+              end
+              implement :return_proxy, :as => "ASample#chain"
+
+              def self.klass_method
+                return 2 + proxy.call(:klass_method)
+              end
+              implement :klass_method, :as => "ASample.klass_method",
+                        :type => :class
+            end
+          end
+        end
+
+        context "and it's an instance method" do
+          it "delegates to the implemented method" do
+            packages = Seatbelt::Terminal.for_scope_and_namespace(:instance,
+                                                                  "ASample")
+            asample = ASample.new
+            packages.each do |package|
+              Seatbelt::EigenmethodProxy.set(Seatbelt::Proxy.new,
+                                              { :eigenmethod => package,
+                                                :object      => asample,
+                                                :receiver    => package.receiver,
+                                              })
+            end
+            expect(Seatbelt::Terminal.call(:my_method, ASample.new ,1,2)).to eq 6
+
+            expect(Seatbelt::Terminal.call(:chain, ASample.new, 0)).to \
+                  respond_to(:abs_of_number)
+
+          end
+
+          it "raises an ArgumentError if too few arguments passed through" do
+            expect do
+              Seatbelt::Terminal.call(:my_method, ASample.new)
+            end.to raise_error(ArgumentError)
+          end
+
+        end
+
+        context "and it's a class method" do
+          it "delegates to the implemented method" do
+            package = Seatbelt::Terminal.luggage.select do |pack|
+              pack.implemented_as.eql?(:c_method)
+            end.first
+            options = {
+              :eigenmethod => package,
+              :receiver    => ASample.new,
+              :add_to      => true,
+            }
+            #Seatbelt::EigenmethodProxy.set(Seatbelt::Proxy.new, options)
+            ASample.class_eval do
+              api_method  :c_method, :scope => :class,
+                          :args => [:sum1, :sum2]
+            end
+            ASample.c_method(2,3)
+            #expect(Seatbelt::Terminal.call(:c_method, ASample,2,3)).to eq 5
+            #expect(Seatbelt::Terminal.call(:klass_method, ASample)).to eq 3
+          end
+
+          it "raises an ArgumentError if too few arguments passed through" do
+            expect do
+              Seatbelt::Terminal.call(:c_method, ASample,3)
+            end.to raise_error(ArgumentError)
+
+          end
+        end
+
+      end
+    end
+
+  end
+
+end

data/spec/lib/seatbelt/document_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe Seatbelt::Document do
+
+  describe "included in a class" do
+
+    before(:all) do
+      class SampleDocument
+        include Seatbelt::Document
+      end
+    end
+
+    describe "provides class methods" do
+
+      it "#attribute" do
+        expect(SampleDocument).to respond_to(:attribute)
+      end
+
+
+      it "#validates_presence_of" do
+        expect(SampleDocument).to respond_to(:validates_presence_of)
+      end
+
+      it "#provides #has_many" do
+        expect(SampleDocument).to respond_to(:has_many)
+      end
+
+      it "provides #has" do
+        expect(SampleDocument).to respond_to(:has)
+      end
+
+    end
+
+    describe "defining attributes" do
+      before(:all) do
+        SampleDocument.class_eval do
+          attribute :name,    String
+          attribute :length,  Integer, :default => 120
+        end
+      end
+
+      let(:document){ SampleDocument.new }
+
+      it "returns the value type" do
+        document.name = "API-doc.pdf"
+        expect(document.name).to be_instance_of String
+        expect(document.length).to be_instance_of Fixnum
+        expect(document.length).to be 120
+
+      end
+
+      it "returns the value after setting it" do
+        name          = "API-doc.pdf"
+        document.name = name
+        expect(document.name).to eq name
+      end
+
+      describe "accessing attributes in implementation classes" do
+
+        before(:all) do
+          SampleDocument.class_eval do
+            include Seatbelt::Ghost
+            api_method :foo
+            api_method :foobar
+
+            api_method :bar, :scope => :class
+
+            def self.class_foo
+              "Summer"
+            end
+          end
+
+          class ImplementsSampleDocument
+            include Seatbelt::Gate
+
+            attr_accessor :single_num
+
+            def implementation_method
+              #proxy.call("name=", "Winter")
+              @single_num = 13
+              #p self
+              return [proxy.call(:name), self.object_id]
+            end
+            implement :implementation_method, :as => "SampleDocument#foo"
+
+            def implementation_method2
+              #p self
+              return [self.object_id, single_num]
+            end
+            implement :implementation_method2, :as => "SampleDocument#foobar"
+
+            def self.another_implementation_method
+              return proxy.call(:class_foo)
+            end
+            implement :another_implementation_method,
+                      :as => "SampleDocument.bar",
+                      :type => :class
+          end
+        end
+
+        it "evaluates the attributes value" do
+          document = SampleDocument.new(:name => "Winter")
+          #expect(document.foo).to eq "Winter"
+          name, object_id1 = document.foo
+          object_id2, single_num = document.foobar
+
+          expect(object_id1).to eq object_id2
+          expect(single_num).to eq 13
+
+          expect(SampleDocument.bar).to eq "Summer"
+        end
+      end
+    end
+
+    describe "validating of attributes" do
+      before(:all) do
+        SampleDocument.class_eval do
+          attribute :name, String
+
+          validates_presence_of :name
+        end
+      end
+
+      describe "#validates_presence_of" do
+
+        context "attribute is given" do
+
+          it "then the model is valid" do
+            document = SampleDocument.new(:name => "Peter")
+            expect(document).to be_valid
+          end
+
+        end
+
+        context "attribute is not given" do
+
+          it "then the model isn't valid" do
+            document = SampleDocument.new
+            expect(document).to_not be_valid
+          end
+
+        end
+
+      end
+    end
+
+    describe "defining associations" do
+
+      describe "#has_many" do
+
+        before(:all) do
+          SampleDocument.class_eval do
+            has_many :hotels, Seatbelt::Models::Hotel
+          end
+        end
+
+        let(:document){ SampleDocument.new }
+
+        it "returns an instance of array" do
+          expect(document.hotels).to respond_to(:count)
+        end
+
+        context "adding a model that isn't of required type" do
+
+          it "raises a Seatbelt::Errors::TypeMissmatchError" do
+            message = "An instance of Seatbelt::Models::Hotel awaited but "
+            message += "get an instance of Seatbelt::Models::Offer."
+            expect do
+              document.hotels << Seatbelt::Models::Offer.new
+            end.to raise_error Seatbelt::Errors::TypeMissmatchError, message
+          end
+        end
+
+        context "adding a model that is of required type" do
+
+          it "increases the association collection size" do
+            expect do
+              document.hotels << Seatbelt::Models::Hotel.new(:name => "Atlanta")
+            end.to change{ document.hotels.size }.by(1)
+          end
+
+          context "by only adding an attribute hash" do
+
+            it "increases the association collection size" do
+              expect do
+                document.hotels << {:name => "Westin"}
+              end.to change{ document.hotels.size }.by(1)
+            end
+
+          end
+
+        end
+
+        context "add multiple #has_many associations" do
+
+          before(:all) do
+            SampleDocument.class_eval do
+              has_many :offers, Seatbelt::Models::Offer
+            end
+          end
+
+          it "passes validation for every #has_many definition" do
+            document = SampleDocument.new
+            expect do
+              document.hotels << Seatbelt::Models::Hotel.new
+            end.to change { document.hotels.size }.by(1)
+            expect do
+              document.offers << Seatbelt::Models::Offer.new
+            end.to change { document.offers.size }.by(1)
+          end
+
+          it "raises an TypeMissmatchError if model isn't required type" do
+            document = SampleDocument.new
+            message = "An instance of Seatbelt::Models::Hotel awaited but "
+            message += "get an instance of Seatbelt::Models::Offer."
+            expect do
+              document.hotels << Seatbelt::Models::Offer.new
+            end.to raise_error Seatbelt::Errors::TypeMissmatchError, message
+            message = "An instance of Seatbelt::Models::Offer awaited but "
+            message += "get an instance of Seatbelt::Models::Hotel."
+            expect do
+              document.offers << Seatbelt::Models::Hotel.new
+            end.to raise_error Seatbelt::Errors::TypeMissmatchError, message
+          end
+
+        end
+      end
+
+      describe "#has" do
+
+        context "defining a reference without class" do
+          before(:all) do
+            SampleDocument.class_eval do
+              has :flight
+            end
+          end
+
+          let(:document){ SampleDocument.new }
+
+          it "takes Seatbelt::Models namespace" do
+            expect(document).to respond_to(:flight)
+          end
+
+          context "assigning the reference " do
+
+            context "has instance then the getter" do
+              it "returns the instance of guessed class" do
+                document.flight = Seatbelt::Models::Flight.new
+                expect(document.flight).to be_instance_of(Seatbelt::Models::Flight)
+              end
+            end
+
+            context "has attribute hash" do
+              it "returns the instance of guessed class" do
+                document.flight = {:trip_length => 12}
+                expect(document.flight).to be_instance_of(Seatbelt::Models::Flight)
+              end
+            end
+          end
+        end
+
+        context "defining a reference with class" do
+          before(:all) do
+            class TrashBin
+              include Seatbelt::Document
+
+              attribute :empty, Boolean
+            end
+            SampleDocument.class_eval do
+              has :trash_bin, TrashBin
+            end
+          end
+
+          let(:document){ SampleDocument.new }
+
+          it "takes the given class namespace" do
+            expect(document).to respond_to(:trash_bin)
+            document.trash_bin = TrashBin.new
+            expect(document.trash_bin).to be_instance_of(TrashBin)
+            document.trash_bin = {:emtpy => false}
+            expect(document.trash_bin).to be_instance_of(TrashBin)
+          end
+        end
+      end
+    end
+  end
+end