seat-belt 0.10.0

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Seatbelt::GhostTunnel do
+  let(:tunnel){ Seatbelt::GhostTunnel }
+
+  it "is a module" do
+    expect(tunnel).to be_a Module
+  end
+
+  describe "methods" do
+
+    it "provides #enable_tunneling!" do
+      expect(tunnel).to respond_to(:enable_tunneling!)
+    end
+
+    it "provides #disable_tunneling!" do
+      expect(tunnel).to respond_to(:disable_tunneling!)
+    end
+  end
+
+end

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

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe Seatbelt::LookupTable do
+  let(:table){ Seatbelt::LookupTable.new }
+
+  it{ should be_a_kind_of(Array)}
+
+  describe "instance methods" do
+
+    it "provides #add_method" do
+      expect(subject).to respond_to(:add_method)
+    end
+
+    it "provides #set" do
+      expect(subject).to respond_to(:set)
+    end
+
+    it "provides #get" do
+      expect(subject).to respond_to(:get)
+    end
+
+    it "provides #unset" do
+      expect(subject).to respond_to(:unset)
+    end
+
+    it "provides #remove_method" do
+      expect(subject).to respond_to(:remove_method)
+    end
+
+    it "provides #find_method" do
+      expect(subject).to respond_to(:find_method)
+    end
+
+    it "provides #has?" do
+      expect(subject).to respond_to(:has?)
+    end
+
+    describe "#has?" do
+
+      before(:all) do
+        @table = Seatbelt::LookupTable.new
+        @options = {
+          :has_method => {
+            :scope          => :class,
+            :block_required => false
+          }
+        }
+        @table.set(@options)
+      end
+
+      after(:all){ @table.clear }
+
+      describe "with the method name as argument" do
+
+        context "and a method with this name exists" do
+
+          it "returns true" do
+            expect(@table.has?(:has_method, scope: :class)).to be true
+          end
+
+        end
+
+        context "and no method wthis name exists" do
+
+          it "returns false" do
+            expect(@table.has?(:method_I_havent)).to be false
+          end
+
+        end
+      end
+
+      describe "with method configuration as argument" do
+
+        context "and a method with this configuration exists" do
+
+          it "returns true" do
+            options = {
+              :has_method => {
+                :scope          => :class,
+                :block_required => false,
+              }
+            }
+            expect(@table.has?(options)).to be true
+          end
+        end
+
+        context "and no method with this configuration exists" do
+
+          it "returns false" do
+            options = {
+              :has_method => {
+                :scope          => :class,
+                :block_required => true,
+              }
+            }
+            expect(@table.has?(options)).to be false
+          end
+        end
+      end
+
+    end
+
+    describe "#find_method" do
+      before do
+        @option_class = {
+          :foobar => {
+            :scope          => :class,
+            :block_required => false
+          }
+        }
+
+        @option_instance = {
+          :foobar => {
+            :scope          => :instance,
+            :block_required => true
+          }
+        }
+
+        table.set(@option_class)
+        table.set(@option_instance)
+      end
+
+      it "finds instance method by default" do
+        expect(table.find_method(:foobar, scope: :instance)).to eq @option_instance
+      end
+
+    end
+
+    describe "#get" do
+
+      describe "lookup has a method to get " do
+
+        before(:all) do
+          @table = Seatbelt::LookupTable.new
+          @options = {
+              :get_flights => {
+                :scope          => :class,
+                :block_required => false,
+              }
+            }
+          @table.set(@options)
+        end
+
+        context "by method name" do
+
+          it "returns the method configuration" do
+            fetched_method = @table.get(:get_flights, scope: :class)
+            expect(fetched_method).to eq @options
+          end
+
+        end
+
+        context "by method configuration" do
+
+          it "returns the method configuration" do
+            fetched_method = @table.get(@options)
+            expect(fetched_method).to eq @options
+          end
+
+        end
+
+      end
+
+      describe "lookup has no method to get " do
+        before(:all){ @table = Seatbelt::LookupTable.new }
+
+        context "by method name" do
+
+          it "returns nil" do
+            expect(@table.get(:my_method)).to be nil
+          end
+
+        end
+
+        context "by method configuration" do
+
+          it "returns nil" do
+            expect(@table.get({:method => {:scope => :class}})).to be nil
+          end
+        end
+      end
+
+    end
+
+    describe "#remove_method" do
+      context "lookup table did not contain any methods" do
+
+        it "nothing happens" do
+          expect do
+            table.remove_method(:my_method)
+          end.to_not change{ table.size }
+          expect(table).to be_empty
+        end
+
+      end
+
+      describe "lookup table contains methods" do
+        context "and method to remove is included" do
+
+          let(:method_options) do
+            {
+              :my_method => {
+                :scope          => :class,
+                :block_required => false
+              }
+            }
+          end
+
+          before  { table.set(method_options) }
+          after   { table.clear }
+
+          it "removes the method and returns the removed configuration" do
+            config = {}
+            expect do
+              config = table.remove_method(:my_method, scope: :class)
+            end.to change{ table.size }.by(-1)
+            expect(config).to be_a_kind_of(Hash)
+            expect(config).to eq method_options
+          end
+
+        end
+
+        context "and method to remove is not included" do
+
+          it "nothing happens" do
+            expect do
+              table.remove_method(:any_other_method)
+            end.to change{ table.size }.by(0)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe Seatbelt::Pool::Api do
+  let(:pool){ Seatbelt::Pool::Api }
+
+  it "is a module" do
+    expect(pool).to be_a Module
+  end
+
+  describe "methods" do
+
+    it "provides #api_method" do
+      expect(pool).to respond_to(:api_method)
+    end
+
+    it "provides #lookup_tbl as class attribute accessor" do
+      expect(pool).to respond_to(:lookup_tbl)
+    end
+
+    describe '#lookup_tbl' do
+
+      it "is empty at the beginning" do
+        expect(pool.lookup_tbl).to be_empty
+      end
+
+      context "adding something to the lookup table" do
+
+        it "increases the lookup tables size" do
+          expect{ pool.lookup_tbl << 1 }.to change{ pool.lookup_tbl.size }.by(1)
+        end
+
+      end
+
+      context "removing something from the lookup table" do
+
+        it "decreases the lookup table size" do
+          expect do
+            pool.lookup_tbl.pop
+            pool.lookup_tbl
+          end.to change{ pool.lookup_tbl.size }.by(-1)
+        end
+
+      end
+
+    end
+
+    describe "#api_method" do
+
+      context "its signature" do
+
+        after do
+          pool.instance_variable_set(:@lookup_tbl, Seatbelt::LookupTable.new)
+        end
+
+        it "requires at least a method name" do
+          expect do
+            pool.api_method
+          end.to raise_error(Seatbelt::Errors::ArgumentsMissmatchError)
+
+          expect do
+            pool.api_method :scope          =>  :class,
+                            :block_required =>  true
+          end.to raise_error(Seatbelt::Errors::MissingMetaMethodName)
+
+        end
+
+      end
+
+      context "adding meta-method definitions to the pools lookup_tbl" do
+
+        context "with just a meta-method name" do
+
+          it "uses default attributes" do
+            expect do
+              pool.api_method :sample_method
+              pool.lookup_tbl
+            end.to change{ pool.lookup_tbl.size }.by(1)
+            lookup_tbl_entry = pool.lookup_tbl.first
+
+            expect(lookup_tbl_entry).to be_instance_of(Hash)
+            expect(lookup_tbl_entry.keys.first).to eq :sample_method
+            expect(lookup_tbl_entry[:sample_method]).to_not be_empty
+
+            meta_method_options = lookup_tbl_entry[:sample_method]
+            expect(meta_method_options).to have_key(:scope)
+            expect(meta_method_options).to have_key(:block_required)
+            expect(meta_method_options[:scope]).to eq :instance
+            expect(meta_method_options[:block_required]).to eq false
+          end
+
+        end
+
+        context "with a meta-method name and a scope" do
+
+          it "uses the scope and default attributes" do
+            expect do
+              pool.api_method :find_scope,
+                              :scope => :class
+            end.to change{ pool.lookup_tbl.size }.by(1)
+            expect(pool.lookup_tbl.size).to eq 2
+            lookup_tbl_entry = pool.lookup_tbl.last
+            expect(lookup_tbl_entry).to be_instance_of(Hash)
+            expect(lookup_tbl_entry.keys.first).to eq :find_scope
+            expect(lookup_tbl_entry[:find_scope]).to_not be_empty
+
+            meta_method_options = lookup_tbl_entry[:find_scope]
+            expect(meta_method_options).to have_key(:scope)
+            expect(meta_method_options).to have_key(:block_required)
+            expect(meta_method_options[:scope]).to eq :class
+            expect(meta_method_options[:block_required]).to eq false
+          end
+
+        end
+
+        context "with a meta-method name, a scope and block required" do
+
+          it "uses the passed arguments" do
+            expect do
+              pool.api_method :block_box,
+                              :scope => :class,
+                              :block_required => true
+            end.to change{ pool.lookup_tbl.size }.by(1)
+            expect(pool.lookup_tbl.size).to eq 3
+            lookup_tbl_entry = pool.lookup_tbl.last
+            expect(lookup_tbl_entry).to be_instance_of(Hash)
+            expect(lookup_tbl_entry.keys.first).to eq :block_box
+            expect(lookup_tbl_entry[:block_box]).to_not be_empty
+
+            meta_method_options = lookup_tbl_entry[:block_box]
+            expect(meta_method_options).to have_key(:scope)
+            expect(meta_method_options).to have_key(:block_required)
+            expect(meta_method_options[:scope]).to eq :class
+            expect(meta_method_options[:block_required]).to eq true
+          end
+
+        end
+
+        context "with a meta-method name and block_required" do
+
+          it "uses the block_required and default attributes" do
+            expect do
+              pool.api_method :parameter_box,
+                              :block_required => true
+            end.to change{ pool.lookup_tbl.size }.by(1)
+            expect(pool.lookup_tbl.size).to eq 4
+            lookup_tbl_entry = pool.lookup_tbl.last
+            expect(lookup_tbl_entry).to be_instance_of(Hash)
+            expect(lookup_tbl_entry.keys.first).to eq :parameter_box
+            expect(lookup_tbl_entry[:parameter_box]).to_not be_empty
+
+            meta_method_options = lookup_tbl_entry[:parameter_box]
+            expect(meta_method_options).to have_key(:scope)
+            expect(meta_method_options).to have_key(:block_required)
+            expect(meta_method_options[:scope]).to eq :instance
+            expect(meta_method_options[:block_required]).to eq true
+          end
+
+        end
+
+        context "with a duplicated meta-method name" do
+
+          it "raises a Seatbelt::MetaMethodDuplicateError error" do
+            expect do
+              pool.api_method :block_box
+            end.to raise_error Seatbelt::Errors::MetaMethodDuplicateError
+          end
+        end
+
+        describe "#arity" do
+
+          context "specifying arguments" do
+
+            describe "without argument list" do
+
+              it "is an unsigned number of arguments passed to #api_method" do
+                pool.api_method :method_with_attrs, :args => [:a, :b, :c]
+                expect(pool.lookup_tbl.last[:method_with_attrs][:arity]).to eq 3
+              end
+
+              describe "and default values" do
+
+                it "is a signed number of arguments passed to #api_method" do
+                  pool.api_method :method_with_defaults, :args => [:a, :b,"k=1"]
+                  method = pool.lookup_tbl.last[:method_with_defaults]
+                  expect(method[:arity]).to eq -3
+                end
+
+              end
+
+              describe "and block" do
+
+                it "ignores the block argument" do
+                  pool.api_method :method_with_block, :args => [:a, :b, "&c"]
+                  method = pool.lookup_tbl.last[:method_with_block]
+                  expect(method[:arity]).to eq 2
+                end
+
+                describe "and default values" do
+
+                  it "is a signed number of arguments passed to #api_method" do
+                    args = [:a,"k=1", "&block"]
+                    pool.api_method :method_block_defaults, :args => args
+                    method = pool.lookup_tbl.last[:method_block_defaults]
+                    expect(method[:arity]).to eq -2
+                  end
+
+              end
+
+              end
+
+            end
+
+            describe "with arguments list" do
+
+              it "is a signed number of arguments passed to #api_method" do
+                pool.api_method :method_wth_args_list,
+                                :args => ["a", "b", "c", "*f"]
+                method = pool.lookup_tbl.last[:method_wth_args_list][:arity]
+                expect(method).to eq -4
+              end
+
+              describe "and default values" do
+
+                it "is a signed number of arguments passed to #api_method" do
+                  pool.api_method :method_args_a_defs,
+                                  :args => ["a", "b", "c=12","*f"]
+                  method = pool.lookup_tbl.last[:method_args_a_defs]
+                  expect(method[:arity]).to eq -3
+                end
+
+              end
+
+              describe "and block" do
+                it "ignores the block argument" do
+                  pool.api_method :method_args_l_block, :args => [:a, "*f", "&c"]
+                  method = pool.lookup_tbl.last[:method_args_l_block]
+                  expect(method[:arity]).to eq -2
+                end
+
+                describe "and default values" do
+                  it "is a signed number of arguments passed to #api_method" do
+                    pool.api_method :method_args_a_defs_block,
+                                    :args => ["a", "b", "c=12","*f" , "&block"]
+                    method = pool.lookup_tbl.last[:method_args_a_defs_block]
+                    expect(method[:arity]).to eq -3
+                  end
+                end
+
+              end
+
+            end
+
+          end
+
+          context "omitting arguments" do
+            it "is 0" do
+              pool.api_method :my_method
+              expect(pool.lookup_tbl.last[:my_method][:arity]).to equal 0
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end