seat-belt 0.10.0

data/spec/lib/seatbelt/synthesizers/document_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Seatbelt::Synthesizers::Document do
+  describe "#synthesize" do
+
+    before(:all) do
+      class ApiDocumentSynthesize
+        include Seatbelt::Document
+        include Seatbelt::Ghost
+
+        attribute :name,  String
+        attribute :age,   Integer
+
+        api_method :lolspeak_my_name
+      end
+
+      class ImplementationApiDocumentSynthesize
+        include Seatbelt::Document
+        include Seatbelt::Gate
+
+        #field :name, :type => String
+        attribute :name, String
+
+        synthesize :from => "ApiDocumentSynthesize"
+
+        def implement_lolspeak_my_name
+          return self
+        end
+        implement :implement_lolspeak_my_name,
+                  :as => "ApiDocumentSynthesize#lolspeak_my_name"
+      end
+    end
+
+    it "synchrones the implementation object with the proxy object" do
+      api = ApiDocumentSynthesize.new(:name => "Hendrik")
+
+      impl_name = api.lolspeak_my_name
+
+      expect(impl_name.name).to eq api.name
+      api.name="Jan"
+      expect(impl_name.name).to eq api.name
+      impl_name.name = "Gerno"
+      expect(api.name).to eq impl_name.name
+    end
+
+    end
+end

data/spec/lib/seatbelt/synthesizers/mongoid_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe Seatbelt::Synthesizers::Mongoid do
+  describe "#synthesize" do
+
+    before(:all) do
+      class ApiMongoidSynthesize
+        include Seatbelt::Document
+        include Seatbelt::Ghost
+
+        attribute :name, String
+        attribute :age,  Integer
+
+        api_method :lolspeak_my_name
+      end
+
+      class ApiMongoidSynthesize2
+        include Seatbelt::Document
+        include Seatbelt::Ghost
+
+        attribute :name,     String
+        attribute :lastname, String
+
+        api_method :lolspeak_lastname
+        api_method :change_my_name
+      end
+
+      class ImplementationApiMongoidSynthesize
+        include ::Mongoid::Document
+        include Seatbelt::Gate
+
+        field :name,      :type => String
+        field :age,       :type => String
+        field :lastname,  :type => String
+
+        synthesize  :from     => "ApiMongoidSynthesize",
+                    :adapter  => "Seatbelt::Synthesizers::Mongoid"
+
+        def implement_lolspeak_my_name
+          return self
+        end
+        implement :implement_lolspeak_my_name,
+                  :as => "ApiMongoidSynthesize#lolspeak_my_name"
+
+        def implement_lolspeak_lastname
+          return self
+        end
+        implement :implement_lolspeak_lastname,
+                  :as => "ApiMongoidSynthesize2#lolspeak_lastname"
+
+        def implement_change_my_name(name_value)
+          @proxy.name = name_value
+          return self
+        end
+        implement :implement_change_my_name,
+                  :as => "ApiMongoidSynthesize2#change_my_name"
+      end
+    end
+
+    it "synchrones the implementation object with the proxy object" do
+      api = ApiMongoidSynthesize.new(:name => "Hendrik")
+
+      impl_name = api.lolspeak_my_name
+
+      expect(impl_name.name).to eq api.name
+      api.name="Jan"
+      expect(impl_name.name).to eq api.name
+      impl_name.name = "Gerno"
+      expect(api.name).to eq impl_name.name
+
+      api2 = ApiMongoidSynthesize.new(:name => "Jon")
+
+      impl2_name = api2.lolspeak_my_name
+      expect(impl2_name.name).to eq api2.name
+    end
+
+    describe "different attributes than API class" do
+      before(:all) do
+        class ApiMongoid
+          include Seatbelt::Document
+          include Seatbelt::Ghost
+
+          attribute :name, String
+          attribute :age,  Integer
+
+          api_method :my_name
+        end
+        class ImplementationApiMongoidSynthesizeDifferentAttrs
+          include ::Mongoid::Document
+          include Seatbelt::Gate
+
+          field :prx_identifier,  :type => String
+          field :n_age,           :type => Integer
+
+          synthesize  :from     => "ApiMongoid",
+                      :adapter  => "Seatbelt::Synthesizers::Mongoid"
+
+          synthesize_map :name => :prx_identifier,:age  => :n_age
+
+          def implement_speak_my_name
+            return self
+          end
+          implement :implement_speak_my_name,
+                    :as => "ApiMongoid#my_name"
+        end
+      end
+      it "synchrones the implementation object with the proxy object" do
+        api = ApiMongoid.new(:name => "John")
+
+        impl_name = api.my_name
+        expect(impl_name.prx_identifier).to eq api.name
+
+        api.name="Jan"
+        expect(impl_name.prx_identifier).to eq api.name
+        impl_name.prx_identifier = "Gerno"
+        expect(api.name).to eq impl_name.prx_identifier
+
+        api.age = 29
+        expect(impl_name.n_age).to eq api.age
+
+        impl_name.n_age = 44
+        expect(api.age).to eq impl_name.n_age
+
+        api2 = ApiMongoid.new(:name => "George",:age => 65)
+
+        impl2_name = api2.my_name
+        expect(impl2_name.prx_identifier).to eq api2.name
+        expect(impl2_name.n_age).to eq api2.age
+
+      end
+    end
+
+  end
+end

data/spec/lib/seatbelt/synthesizers/synthesizer_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Seatbelt::Synthesizer do
+  before(:all) do
+    class ApiFromSynthesize
+      include Seatbelt::Document
+      include Seatbelt::Ghost
+
+      attribute :age, Integer
+      attribute :name, String
+    end
+
+    class ImplementationSynthesize
+      include Mongoid::Document
+
+      field :age, :type => Integer
+    end
+
+    class SynthesizeWrapper
+      include Seatbelt::Synthesizer
+
+      def synthesizable_attributes
+        [:age]
+      end
+    end
+  end
+
+  describe "#instance_methods" do
+    let(:implementation) { ImplementationSynthesize.new }
+    let(:instance) do
+      SynthesizeWrapper.new(ApiFromSynthesize, implementation)
+    end
+
+    it "provides #synthesize" do
+      expect(instance).to respond_to(:synthesize)
+    end
+
+    it "expects a #synthesizable_attributes method" do
+      class InvalidSynthesizer
+        include Seatbelt::Synthesizer
+      end
+
+      synthesizer = InvalidSynthesizer.new(ApiFromSynthesize, implementation)
+
+      expect do
+        synthesizer.synthesize
+      end.to \
+      raise_error(Seatbelt::Errors::SynthesizeableAttributesNotImplementedError,
+                  "Your synthesizer has to implement #synthesizable_attributes.")
+
+    end
+
+    describe "#synthesize" do
+
+      it "sets the attributes of the proxy object and vice versa" do
+        implementation.stub(:proxy).and_return(ApiFromSynthesize.new)
+        implementation.class.stub(:get_synthesize_map).and_return({})
+        instance.synthesize
+
+        implementation.proxy.age = 12
+        expect(implementation.age).to eq implementation.proxy.age
+
+        implementation.age = 44
+        expect(implementation.proxy.age).to eq implementation.age
+      end
+
+      describe "and a #synthesize_map" do
+        before(:all) do
+
+          class ImplementationSynthesizeWithDifferentAttributes
+            include Mongoid::Document
+
+            field :lc_age,          :type => Integer
+            field :prx_identifier,  :type => String
+
+            def self.synthesize_map
+              {
+                :age  => :lc_age,
+                :name => :prx_identifier
+              }
+            end
+
+            SynthesizeWrapper.class_eval do
+              def synthesizable_attributes
+                [:lc_age, :prx_identifier]
+              end
+            end
+          end
+
+        end
+
+        it "sets the attributes of the proxy object and vice versa" do
+          implementation2 = ImplementationSynthesizeWithDifferentAttributes.new
+          instance = SynthesizeWrapper.new(ApiFromSynthesize, implementation2)
+          implementation2.stub(:proxy).and_return(ApiFromSynthesize.new)
+
+          instance.synthesize
+          implementation2.proxy.age   = 12
+          implementation2.proxy.name  = "Kafka"
+          expect(implementation2.lc_age).to eq implementation2.proxy.age
+          expect(implementation2.prx_identifier).to eq implementation2.proxy.name
+
+          implementation2.lc_age = 44
+          expect(implementation2.proxy.age).to eq implementation2.lc_age
+          implementation2.prx_identifier = "Roberts"
+          expect(implementation2.proxy.name).to eq implementation2.prx_identifier
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/seatbelt/tape_deck_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Seatbelt::TapeDeck  do
+
+  describe "#class_methods" do
+
+    before(:all) do
+      class Sample
+        include Seatbelt::TapeDeck
+      end
+    end
+
+    it "provides #tapes" do
+      expect(Sample).to respond_to(:tapes)
+    end
+
+    it "provides #use_tape" do
+      expect(Sample).to respond_to(:use_tape)
+    end
+
+    it "provides #use_tapes" do
+      expect(Sample).to respond_to(:use_tapes)
+    end
+
+    it "provides #add_tape" do
+      expect(Sample).to respond_to(:add_tape)
+    end
+
+    it "provides #respond" do
+      expect(Sample).to respond_to(:respond)
+    end
+
+    describe "#tapes" do
+
+      let(:mock_tape){ double("ATape") }
+
+      it "is a store to hold tapes for the class" do
+        expect do
+          Sample.tapes << mock_tape
+        end.to change { Sample.tapes.size }.by(1)
+      end
+
+    end
+
+    describe "#use_tape" do
+
+      let(:sample_tape){ double("SampleTape") }
+
+      it "adds a tape to the tape store for this class" do
+        sample_tape.stub(:tape_deck=)
+        sample_tape.stub(:tape_deck).and_return(nil)
+        expect do
+          Sample.use_tape sample_tape
+        end.to change { Sample.tapes.size }.by(1)
+
+      end
+
+      it "a tape is not useable in multiple tapedecks" do
+        sample_tape.stub(:tape_deck).and_return(Sample)
+        class Sample2
+          include Seatbelt::TapeDeck
+        end
+        expect do
+          Sample2.use_tape sample_tape
+        end.to raise_error(Seatbelt::Errors::MultipleTapeUsageDetectedError)
+      end
+
+      context "the tape is already in the tape store for this class" do
+
+        before(:all) do
+          class SampleTape < Seatbelt::Tape
+          end
+          Sample.instance_eval do
+            self.instance_variable_set(:@tapes, [])
+          end
+          Sample.use_tape SampleTape
+        end
+
+        it "then it didn't add the tape again" do
+          expect do
+            Sample.use_tape SampleTape
+          end.to change{ Sample.tapes.size }.by(0)
+        end
+      end
+
+    end
+
+    describe "#use_tapes" do
+
+      before(:all) do
+        class RegionTape < Seatbelt::Tape;end
+        class HotelTape < Seatbelt::Tape;end
+      end
+
+      it "adds a bunch of tapes to the tape store for this class" do
+        expect do
+          Sample.use_tapes RegionTape, HotelTape
+        end.to change{ Sample.tapes.size }.by(2)
+      end
+
+    end
+
+    describe "#respond" do
+
+      before(:all) do
+        Sample.instance_eval do
+          self.instance_variable_set(:@tapes, [])
+        end
+
+        class TestTape < Seatbelt::Tape
+        end
+
+        Sample.class_eval do
+          use_tape TestTape
+        end
+      end
+
+      it "finds an answer on the tapes for the class that matches a query" do
+        TestTape.class_eval do
+          translate /Call me (\w+) !/ do |sentence, name|
+            name
+          end
+        end
+
+        query   = "Call me Harry !"
+        expect(Sample.respond(query)).to eq "Harry"
+      end
+
+      it "passes the original query as first param to the block" do
+        TestTape.class_eval do
+          translate /Super summer party at (\d+)/ do |sentence, data|
+            sentence
+          end
+        end
+        query2  = "Super summer party at 12.08.2014"
+        expect(Sample.respond(query2)).to eq query2
+      end
+
+      it "passes the matched data as second param list to the block" do
+        TestTape.class_eval do
+          translate /Add (\d+) to (\d+) and divide it by (\d+)/ do |sentence,
+                                                                        sum1,
+                                                                        sum2,
+                                                                        divider|
+            result = sum1.to_i  + sum2.to_i
+            result/divider.to_i
+          end
+        end
+        query = "Add 5 to 11 and divide it by 2"
+        result = Sample.respond(query)
+        expect(result).to be_instance_of Fixnum
+        expect(result).to eq 8
+      end
+
+      it "raises an error if no answer is found for the query" do
+        expect do
+          Sample.respond(%Q{Show me 2 hotels nearby London})
+        end.to raise_error(Seatbelt::Errors::NoTapeFoundForQueryError)
+      end
+
+      context "translate block takes just one argument" do
+
+        it "then the argument is not the query sentence" do
+          TestTape.class_eval do
+            translate /Finde für mich (\d+) Hotels nahe meiner aktuellen Position/ do |count|
+              count.to_i
+            end
+          end
+
+          query   = "Finde für mich 5 Hotels nahe meiner aktuellen Position"
+          result  = Sample.answer(query)
+          expect(result).to_not eq query
+          expect(result).to eq 5
+        end
+      end
+
+    end
+  end
+
+end