taketo 0.0.6 → 0.0.7

data/spec/lib/taketo/destination_resolver_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/destination_resolver'
 require 'taketo/support/named_nodes_collection'
 
@@ -50,29 +50,29 @@ describe "DestinationResolver" do
   let(:config) { TestNode.new(:config, nil, project1, project2, project3, project4) }
 
   context "when project, environment and server specified" do
-    it "should return server if it exists" do
-      resolver(config, "foo:bar:s1").resolve.should == server1
+    it "returns server if it exists" do
+      expect(resolver(config, "foo:bar:s1").resolve).to eq(server1)
     end
 
-    it "should raise error if server does not exist" do
+    it "raises error if server does not exist" do
       expect { resolver(config, "foo:bar:noserver").resolve }.to raise_error(NonExistentDestinationError)
     end
   end
 
   context "when there are 2 segments in path" do
     context "when there is matching project - environment pair" do
-      it "should return server if only one specified" do
-        resolver(config, "foo:bar").resolve.should == server1
-        resolver(config, "baz:qux").resolve.should == server2
+      it "returns server if only one specified" do
+        expect(resolver(config, "foo:bar").resolve).to eq(server1)
+        expect(resolver(config, "baz:qux").resolve).to eq(server2)
       end
 
-      it "should raise error if there are multiple servers" do
+      it "raises error if there are multiple servers" do
         expect { resolver(config, "quux:corge").resolve }.to raise_error(AmbiguousDestinationError)
       end
     end
 
     context "when there is no matching project - environment pair" do
-      it "should raise error if no such project - environment pair exist" do
+      it "raises error if no such project - environment pair exist" do
         expect { resolver(config, "chunky:bacon").resolve }.to raise_error(NonExistentDestinationError)
       end
     end
@@ -82,27 +82,27 @@ describe "DestinationResolver" do
     context "when project with given name exists" do
       context "when there's one environment" do
         context "when there's one server" do
-          it "should return the server" do
-            resolver(config, "foo").resolve.should == server1
+          it "returns the server" do
+            expect(resolver(config, "foo").resolve).to eq(server1)
           end
         end
 
         context "when there are multiple servers" do
-          it "should raise error" do
+          it "raises error" do
             expect { resolver(config, "quux").resolve }.to raise_error(AmbiguousDestinationError)
           end
         end
       end
 
       context "when there are multiple environments" do
-        it "should raise error" do
+        it "raises error" do
           expect { resolver(config, "grault").resolve }.to raise_error(AmbiguousDestinationError)
         end
       end
     end
 
     context "when there is no such project" do
-      it "should raise error" do
+      it "raises error" do
         expect { resolver(config, "chunky").resolve }.to raise_error(NonExistentDestinationError)
       end
     end
@@ -113,15 +113,15 @@ describe "DestinationResolver" do
       context "when there's one project" do
         context "when there's one environment" do
           context "when there's one server" do
-            it "should execute command without asking project/environment/server" do
+            it "executes command without asking project/environment/server" do
               config = TestNode.new(:config, nil, project1)
               config.stub(:default_destination => nil)
-              resolver(config, "").resolve.should == server1
+              expect(resolver(config, "").resolve).to eq(server1)
             end
           end
 
           context "when there are multiple servers" do
-            it "should ask for server" do
+            it "asks for server" do
               config = TestNode.new(:config, nil, project3)
               config.stub(:default_destination => nil)
               expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /server/i
@@ -130,7 +130,7 @@ describe "DestinationResolver" do
         end
 
         context "when there are multiple environments" do
-          it "should ask for environment" do
+          it "asks for environment" do
             config = TestNode.new(:config, nil, project4)
             config.stub(:default_destination => nil)
             expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /environment/i
@@ -139,7 +139,7 @@ describe "DestinationResolver" do
       end
 
       context "when there are multiple projects" do
-        it "should ask for project" do
+        it "asks for project" do
           config = TestNode.new(:config, nil, project3, project4)
           config.stub(:default_destination => nil)
 
@@ -149,38 +149,38 @@ describe "DestinationResolver" do
     end
 
     context "when there is default destination" do
-      it "should resolve by default destination" do
+      it "resolves by default destination" do
         config.stub(:default_destination => "foo:bar:s1")
-        resolver(config, "").resolve.should == server1
+        expect(resolver(config, "").resolve).to eq(server1)
       end
     end
   end
 
   context "when there is global matching server alias" do
-    it "should resolve by alias" do
-      resolver(config, "the_alias").resolve.should == server1
+    it "resolves by alias" do
+      expect(resolver(config, "the_alias").resolve).to eq(server1)
     end
   end
 
   describe "#get_node" do
-    it "should return server when path has 3 segments and is correct" do
-      resolver(config, "foo:bar:s1").get_node.should == server1
+    it "returns server when path has 3 segments and is correct" do
+      expect(resolver(config, "foo:bar:s1").get_node).to eq(server1)
     end
 
-    it "should return environment when path has 2 segments and is correct" do
-      resolver(config, "foo:bar").get_node.should == environment1
+    it "returns environment when path has 2 segments and is correct" do
+      expect(resolver(config, "foo:bar").get_node).to eq(environment1)
     end
 
-    it "should return project when path has 1 segment and is correct" do
-      resolver(config, "foo").get_node.should == project1
+    it "returns project when path has 1 segment and is correct" do
+      expect(resolver(config, "foo").get_node).to eq(project1)
     end
 
-    it "should return the config if path has is empty and there's no default destination" do
+    it "returns the config if path has is empty and there's no default destination" do
       config.stub(:default_destination => nil)
-      resolver(config, "").get_node.should == config
+      expect(resolver(config, "").get_node).to eq(config)
     end
 
-    it "should raise NonExistentDestinationError when path is not correct" do
+    it "raises NonExistentDestinationError when path is not correct" do
       config.should_receive(:find).with(:project, :i).and_raise(KeyError)
       expect { resolver(config, "i").get_node }.to raise_error(NonExistentDestinationError)
     end

data/spec/lib/taketo/dsl_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'support/helpers/dsl_spec_helper'
 require 'taketo/dsl'
 
@@ -8,57 +8,57 @@ describe "DSL" do
   extend DSLSpec
   include DSLSpec
 
-  shared_examples "a scope" do |scope_name, parent_scope_name|
+  shared_examples "a scoped construct" do |name, parent_scope_name, with_block|
     parent_scope = scopes[parent_scope_name]
-
-    it { should enclose_scope(scope_name).under(parent_scope) }
-    it { should be_appropriate_construct(scope_name, :foo).under(parent_scope) }
+    it { should be_appropriate_construct(name, :foo).with_block(with_block).under(parent_scope) }
 
     scopes.except(parent_scope_name).each do |inappropriate_scope|
-      it { should_not be_appropriate_construct(scope_name, :foo).under(inappropriate_scope) }
+      it { should_not be_appropriate_construct(name, :foo).with_block(with_block).under(inappropriate_scope) }
     end
+  end
+
+  shared_examples "a scope" do |scope_name, parent_scope_name|
+    parent_scope = scopes[parent_scope_name]
+
+    it_behaves_like "a scoped construct", scope_name, parent_scope_name, true
+
+    it { should enclose_scope(scope_name).under(parent_scope) }
 
-    it "should create a #{scope_name} and set it as current scope object" do # it "should create project and set it as current scope object"
+    it "creates a #{scope_name} and set it as current scope object" do       # it "creates project and set it as current scope object"
       dsl(parent_scope, factory.create(parent_scope_name)) do |c|            #   dsl([:config], factory.create(:config)) do |c|
         stub_find_or_create_scope_object(c, scope_name, :bar)                #     stub_find_or_create_scope_object(c, :project, :bar)
         c.send(scope_name, :bar) do                                          #     c.project(:bar) do
-          c.current_scope_object.should_not be_nil                           #       c.current_scope_object.should_not be_nil
-          c.current_scope_object.should == factory.send(scope_name)          #       c.current_scope_object.should == factory.project
+          expect(c.current_scope_object).not_to be_nil                       #       expect(c.current_scope_object).not_to be_nil
+          expect(c.current_scope_object).to eq(factory.send(scope_name))     #       expect(c.current_scope_object).to eq(factory.project)
         end                                                                  #     end
       end                                                                    #   end
     end                                                                      # end
 
-    it "should not leak #{scope_name} as current scope object" do            # it "should not leak project as current scope object"
+    it "does not leak #{scope_name} as current scope object" do              # it "does not leak project as current scope object"
       dsl(parent_scope, factory.create(parent_scope_name)) do |c|            #   dsl([:config], factory.create(:config)) do |c|
         stub_find_or_create_scope_object(c, scope_name, :bar)                #     stub_find_or_create_scope_object(c, :project, :bar)
         c.send(scope_name, :bar) do                                          #     c.project(:bar) do
-          c.current_scope_object.should == factory.send(scope_name)          #       c.current_scope_object.should == factory.project
+          expect(c.current_scope_object).to eq(factory.send(scope_name))     #       expect(c.current_scope_object).to eq(factory.project)
         end                                                                  #     end
-        c.current_scope_object.should_not == factory.send(scope_name)        #     c.current_scope_object.should_not == factory.project
+        expect(c.current_scope_object).not_to eq(factory.send(scope_name))   #     expect(c.current_scope_object).not_to eq(factory.project)
       end                                                                    #   end
     end                                                                      # end
 
-    it "should add a #{scope_name} to the #{parent_scope_name}'s #{scope_name}s collection" do # it "should add a project to the config's projects collection" do
-      dsl(parent_scope, factory.create(parent_scope_name)) do |c|                              #   dsl([:config], factory.create(:config)) do |c|
-        stub_find_or_create_scope_object(c, scope_name, :bar)                                  #     stub_find_or_create_scope_object(c, :project, :bar)
-        c.current_scope_object.should_receive("append_#{scope_name}").                         #     c.current_scope_object.should_receive(:append_project).
-          with(factory.send(scope_name))                                                       #       with(factory.project)
-        c.send(scope_name, :bar) {}                                                            #     c.project(:bar) {}
-      end                                                                                      #   end
-    end                                                                                        # end
+    it "adds a #{scope_name} to the #{parent_scope_name}'s #{scope_name}s collection" do   # it "adds a project to the config's projects collection" do
+      dsl(parent_scope, factory.create(parent_scope_name)) do |c|                          #   dsl([:config], factory.create(:config)) do |c|
+        stub_find_or_create_scope_object(c, scope_name, :bar)                              #     stub_find_or_create_scope_object(c, :project, :bar)
+        c.current_scope_object.should_receive("append_#{scope_name}").                     #     c.current_scope_object.should_receive(:append_project).
+          with(factory.send(scope_name))                                                   #       with(factory.project)
+        c.send(scope_name, :bar) {}                                                        #     c.project(:bar) {}
+      end                                                                                  #   end
+    end                                                                                    # end
   end
 
   shared_examples "a scoped method" do |attribute_name, parent_scope_name, parent_scope_method, example_value|
-    parent_scope = scopes[parent_scope_name]
-
-    it { should be_appropriate_construct(attribute_name, example_value).under(parent_scope) }
+    it_behaves_like "a scoped construct", attribute_name, parent_scope_name, false
 
-    scopes.except(parent_scope_name).each do |inaproppriate_scope|
-      it { should_not be_appropriate_construct(attribute_name, example_value).under(inaproppriate_scope) }
-    end
-
-    it "should call #{parent_scope_method} on current #{parent_scope_name}" do                  # it "should call default_location= on current server" do
-      dsl(parent_scope, factory.create(parent_scope_name, :foo)) do |c|                         #   dsl([:config, :project, :environment, :server], factory.create(:server, :foo)) do |c|
+    it "calls #{parent_scope_method} on current #{parent_scope_name}" do                        # it "calls default_location= on current server" do
+      dsl(scopes[parent_scope_name], factory.create(parent_scope_name, :foo)) do |c|            #   dsl([:config, :project, :environment, :server], factory.create(:server, :foo)) do |c|
         factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value) #     factory.server.should_receive(:default_location=).with('/var/app/')
         c.send(attribute_name, example_value)                                                   #   c.location "/var/app"
       end                                                                                       # end
@@ -69,143 +69,160 @@ describe "DSL" do
     it_behaves_like "a scoped method", :default_destination, :config, :default_destination=, "foo:bar:baz"
   end
 
-  describe "Shared server config" do
-    specify "#shared_server_config should store a block" do
+  describe "#shared_server_config" do
+    it_behaves_like "a scoped construct", :shared_server_config, :config
+
+    it "stores a block" do
       dsl(scopes[:config], factory.create(:config)) do |c|
         cfg = proc { any_method_call_here }
         c.shared_server_config(:foo, &cfg)
-        c.shared_server_configs[:foo].should == cfg
+        expect(c.shared_server_configs[:foo]).to eq(cfg)
       end
     end
+  end
 
-    describe "#include_shared_server_config" do
-      it "should execute the block on dsl object in server scope" do
-        dsl(scopes[:server], factory.create(:server)) do |c|
-          c.stub(:shared_server_configs => { :foo => proc { any_method_call_here } })
-          c.should_receive(:any_method_call_here)
-          c.include_shared_server_config(:foo)
-        end
+  describe "#include_shared_server_config" do
+    it "executes the block on dsl object in server scope for given shared config names" do
+      dsl(scopes[:server], factory.create(:server)) do |c|
+        c.stub(:shared_server_configs => { :foo => proc { any_method_call_here }, :bar => proc { second_method_call_here } })
+        c.should_receive(:any_method_call_here)
+        c.should_receive(:second_method_call_here)
+        c.include_shared_server_config(:foo, :bar)
       end
+    end
 
-      it "should accept arguments" do
-        dsl(scopes[:server], factory.create(:server)) do |c|
-          c.stub(:shared_server_configs => { :foo => proc { |qux| any_method_call_here(qux) } })
-          c.should_receive(:any_method_call_here).with(321)
-          c.include_shared_server_config(:foo, 321)
+    context "when the only argument is hash where shared config names are keys" do
+      context "when hash values are arrays" do
+        it "includes config corresponding to hash key and passes exploded arguments" do
+          dsl(scopes[:server], factory.create(:server)) do |c|
+            c.stub(:shared_server_configs => { :foo => proc { |a, b| any_method_call_here(a, b) } })
+            c.should_receive(:any_method_call_here).with(321, 322)
+            c.include_shared_server_config(:foo => [321, 322])
+          end
         end
       end
 
-      it "should raise ConfigError if non-existent config included" do
-        dsl(scopes[:server], factory.create(:server)) do |c|
-          expect { c.include_shared_server_config(:foo) }.to raise_error(Taketo::DSL::ConfigError, "Shared server config 'foo' is not defined!")
+      context "when hash values are single values" do
+        it "includes config corresponding to hash key and passes the argument" do
+          dsl(scopes[:server], factory.create(:server)) do |c|
+            c.stub(:shared_server_configs => { :foo => proc { |qux| any_method_call_here(qux) } })
+            c.should_receive(:any_method_call_here).with(321)
+            c.include_shared_server_config(:foo => 321)
+          end
         end
       end
     end
+
+    it "raises ConfigError if non-existent config included" do
+      dsl(scopes[:server], factory.create(:server)) do |c|
+        expect { c.include_shared_server_config(:foo) }.to raise_error(Taketo::DSL::ConfigError, "Shared server config 'foo' is not defined!")
+      end
+    end
   end
 
   describe "#project" do
     it_behaves_like "a scope", :project, :config
+  end
 
-    describe "#environment" do
-      it_behaves_like "a scope", :environment, :project
+  describe "#environment" do
+    it_behaves_like "a scope", :environment, :project
+  end
 
-      describe "#server" do
-        it_behaves_like "a scope", :server, :environment
+  describe "#server" do
+    it_behaves_like "a scope", :server, :environment
 
-        it "should have name optional" do
-          dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
-            stub_find_or_create_scope_object(c, :server, :default)
-            c.server do
-              c.current_scope_object.name.should == :default
-            end
-          end
+    it "has name optional" do
+      dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
+        stub_find_or_create_scope_object(c, :server, :default)
+        c.server do
+          expect(c.current_scope_object.name).to eq(:default)
         end
+      end
+    end
 
-        describe "#host" do
-          it_behaves_like "a scoped method", :host, :server, :host=, "127.0.0.2"
-        end
+    describe "#host" do
+      it_behaves_like "a scoped method", :host, :server, :host=, "127.0.0.2"
+    end
 
-        describe "#port" do
-          it_behaves_like "a scoped method", :port, :server, :port=, 4096
-        end
+    describe "#port" do
+      it_behaves_like "a scoped method", :port, :server, :port=, 4096
+    end
 
-        describe "#user" do
-          it_behaves_like "a scoped method", :user, :server, :username=, "deployer"
-        end
+    describe "#user" do
+      it_behaves_like "a scoped method", :user, :server, :username=, "deployer"
+    end
 
-        describe "#location" do
-          it_behaves_like "a scoped method", :location, :server, :default_location=, "/var/app/"
-        end
+    describe "#location" do
+      it_behaves_like "a scoped method", :location, :server, :default_location=, "/var/app/"
+    end
 
-        describe "#env" do
-          it_behaves_like "a scoped method", :env, :server, :env, { :FOO => "bar" }
-        end
+    describe "#env" do
+      it_behaves_like "a scoped method", :env, :server, :env, { :FOO => "bar" }
+    end
 
-        describe "#global_alias" do
-          it_behaves_like "a scoped method", :global_alias, :server, :global_alias=, "foobared"
-        end
+    describe "#global_alias" do
+      it_behaves_like "a scoped method", :global_alias, :server, :global_alias=, "foobared"
+    end
 
-        describe "#identity_file" do
-          it_behaves_like "a scoped method", :identity_file, :server, :identity_file=, "/home/gor/.ssh/qqq"
-        end
+    describe "#identity_file" do
+      it_behaves_like "a scoped method", :identity_file, :server, :identity_file=, "/home/gor/.ssh/qqq"
+    end
 
-        describe "#command" do
-          it_behaves_like "a scope", :command, :server
+    describe "#command" do
+      it_behaves_like "a scope", :command, :server
 
-          describe "#execute" do
-            it_behaves_like "a scoped method", :execute, :command, :command=, "rails c"
-          end
+      describe "#execute" do
+        it_behaves_like "a scoped method", :execute, :command, :command=, "rails c"
+      end
 
-          describe "#desc" do
-            it_behaves_like "a scoped method", :desc, :command, :description=, "Run rails console"
-          end
-        end
+      describe "#desc" do
+        it_behaves_like "a scoped method", :desc, :command, :description=, "Run rails console"
       end
     end
   end
 
   describe "#current_scope_object" do
-    it "should be config initially" do
+    it "is config initially" do
       dsl do |c|
-        c.current_scope_object.should == factory.config
+        expect(c.current_scope_object).to eq(factory.config)
       end
     end
 
-    it "should correspond to current scope" do
+    it "corresponds to current scope" do
       dsl(:project, factory.create_project(:foo)) do |c|
-        c.current_scope_object.should == factory.project
+        expect(c.current_scope_object).to eq(factory.project)
       end
 
       dsl(:server, factory.create_server(:foo)) do |c|
-        c.current_scope_object.should == factory.server
+        expect(c.current_scope_object).to eq(factory.server)
       end
     end
   end
 
   describe "#configure" do
-    it "should read config from file if filename passed" do
+    it "reads config from file if filename passed" do
       File.stub(:read => "the config")
       dsl = Taketo::DSL.new(factory)
       dsl.should_receive(:instance_eval) do |config, *args|
-        config.should == "the config"
+        expect(config).to eq("the config")
       end
       dsl.configure("path/to/config")
     end
 
-    it "should be configured from block unless filename specified" do
+    it "is configured from block unless filename specified" do
       dsl = Taketo::DSL.new(factory)
       config = proc { }
       dsl.should_receive(:instance_eval).with(&config)
       dsl.configure &config
     end
 
-    it "should raise an error if neither config filename nor block passed" do
+    it "raises an error if neither config filename nor block passed" do
       expect do
         Taketo::DSL.new(factory).configure
       end.to raise_error ArgumentError, /(config|block)/
     end
 
-    it "should raise meaningful error if config parse failed"
+    it "raises meaningful error if config parse failed"
   end
 
   def stub_find_or_create_scope_object(scope_object, scope, name)

data/spec/lib/taketo/support/named_nodes_collection_spec.rb

@@ -1,37 +1,65 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/support/named_nodes_collection'
 
+include Taketo::Support
+
 describe "NamedNodesCollection" do
-  let(:collection) { Taketo::Support::NamedNodesCollection.new }
+  subject(:collection) { NamedNodesCollection.new }
   let(:node1) { stub(:name => :foo) }
   let(:node2) { stub(:name => :bar) }
 
-  it "should be able to initialize with array" do
-    Taketo::Support::NamedNodesCollection.new([1, 2, 3]).length.should == 3
+  it "can be initialized with array" do
+    expect(NamedNodesCollection.new([1, 2, 3]).length).to eq(3)
   end
 
-  it "should mimic Array" do
-    collection.should be_empty
-    collection << node1
-    collection.push node2
-    collection[0].should == node1
-    collection.map(&:name).should == [:foo, :bar]
-    collection.length.should == 2
-    collection.size.should == 2
-    collection.first.should == node1
-    collection.last.should == node2
+  [:empty?, :each, :length, :size, :first, :last].each do |delegated_method|
+    it { should respond_to(delegated_method) }
+  end
+
+  it "is Enumerable" do
+    expect(collection).to be_kind_of(Enumerable)
   end
 
-  it "should raise error if element not found" do
-    expect { collection[3] }.to raise_error KeyError, /#3/i
-    expect { collection[:quux] }.to raise_error KeyError, /name/i
+  describe "#[]" do
+    subject(:collection) { NamedNodesCollection.new([node1]) }
+
+    it "retrieves node by index" do
+      expect(collection[0]).to eq(node1)
+    end
+
+    it "retrieves node by name" do
+      expect(collection[:foo]).to eq(node1)
+    end
+
+    it "raises error if node not found" do
+      expect { collection[3] }.to raise_error KeyError, /#3/i
+      expect { collection[:quux] }.to raise_error KeyError, /name/i
+    end
+  end
+
+  describe "#push, #<<" do
+    it "adds node to the collection" do
+      collection.push(node1)
+      expect(collection.length).to eq(1)
+      collection << node2
+      expect(collection.length).to eq(2)
+    end
+
+    it "does nothing if node with same name exists" do
+      collection.push(node1)
+      collection.push(node1)
+      expect(collection.length).to eq(1)
+    end
+
+    it "supports chaining" do
+      collection << node1 << node2
+      expect(collection.length).to eq(2)
+    end
   end
 
-  it "should not add if node with same name exists" do
+  it "compares itself to array" do
     collection << node1
-    collection.push node1
-    collection.length.should == 1
-    collection.first.should == node1
+    expect(collection).to eq([node1])
   end
 end
 

data/spec/support/helpers/construct_spec_helper.rb

@@ -1,15 +1,15 @@
 shared_examples "a construct with nodes" do |name_plural, name_singular|
-  specify "#append_#{name_singular} should add a #{name_singular} to " +   # specify "#append_server should add a server to " +
-    "#{subject.class.name}'s #{name_plural} collection" do                 #   "environment's servers collection" do
+  specify "#append_#{name_singular} adds a #{name_singular} to " +         # specify "#append_server adds a server to " +
+    "the #{name_plural} collection" do                                     #   "the servers collection" do
     node = mock(:name => :foo).as_null_object                              #   server = mock(:name => :foo).as_null_object
     subject.send("append_#{name_singular}", node)                          #   environment.append_server(server)
-    subject.send(name_plural).should include(node)                         #   environment.servers.should include(server)
+    expect(subject.send(name_plural)).to include(node)                     #   expect(environment.servers).to include(server)
   end                                                                      # end
 
-  specify "#find_#{name_singular} should find #{name_singular} by name" do # specify "#find_server should find server by name" do
+  specify "#find_#{name_singular} finds #{name_singular} by name" do       # specify "#find_server finds server by name" do
     subject.send(name_plural).should_receive(:find_by_name).               #   environment.servers.should_receive(:find_by_name).
       with(:foo).and_return(:bar)                                          #     with(:foo).and_return(:bar)
-    subject.send("find_#{name_singular}", :foo).should == :bar             #   environment.find_server(:foo).should == :bar
+    expect(subject.send("find_#{name_singular}", :foo)).to eq(:bar)        #   expect(environment.find_server(:foo)).to eq(:bar)
   end                                                                      # end
 end
 

data/spec/support/matchers/be_appropriate_construct_matcher.rb

@@ -5,6 +5,10 @@ RSpec::Matchers.define :be_appropriate_construct do |construct, *args|
     @enclosing_scope = enclosing_scope
   end
 
+  chain(:with_block) do |with_block|
+    @blk = Proc.new {} if with_block
+  end
+
   match do |actual|
     unless @enclosing_scope
       raise ArgumentError, "#under must be called to set enclosing scope"
@@ -13,7 +17,11 @@ RSpec::Matchers.define :be_appropriate_construct do |construct, *args|
     @result = true
     dsl(@enclosing_scope) do |c|
       begin
-        c.send(construct, *args) {} 
+        if @blk
+          c.send(construct, *args, &@blk)
+        else
+          c.send(construct, *args)
+        end
       rescue Taketo::DSL::ScopeError => e
         @result = false
       rescue

data/spec/support/matchers/have_accessor_matcher.rb

@@ -1,7 +1,10 @@
-RSpec::Matchers.define :have_accessor do |accessor|
+RSpec::Matchers.define :have_accessor do |*args|
+  accessor = args.shift or raise ArgumentError, "No accessor name supplied"
+  value = args.shift || :foo
+
   match do |construct|
-    construct.send("#{accessor}=", :foo)
-    construct.send(accessor) == :foo
+    construct.send("#{accessor}=", value)
+    construct.send(accessor) == value
   end
 end