taketo 0.1.3 → 0.2.0.alpha

data/spec/lib/taketo/associated_nodes_spec.rb

@@ -97,5 +97,39 @@ describe "AssociatedNodes" do
       expect { construct.has_nodes?(:quack) }.to raise_error NodesNotDefinedError
     end
   end
+
+  describe "#has_deeply_nested_nodes?" do
+    class TestNestedNodes
+      include AssociatedNodes
+
+      def name; :foo; end
+
+      has_nodes :foos, :foo
+      has_nodes :bars, :bar
+    end
+
+    subject(:construct) { TestNestedNodes.new }
+    let(:foo) { TestNestedNodes.new }
+
+    context "directly nested nodes" do
+      it "returns true when present" do
+        construct.nodes(:foos) << foo
+        expect(construct).to have_deeply_nested_nodes(:foos)
+      end
+    end
+
+    context "indirectly nested nodes" do
+      before(:each) { construct.nodes(:foos) << foo }
+
+      it "returns true when present" do
+        foo.nodes(:bars) << stub(:Bar, :name => :bar)
+        expect(construct).to have_deeply_nested_nodes(:bars)
+      end
+
+      it "returns false when not present" do
+        expect(construct).not_to have_deeply_nested_nodes(:bars)
+      end
+    end
+  end
 end
 

data/spec/lib/taketo/config_validator_spec.rb

@@ -18,7 +18,7 @@ end
 describe "ConfigValidator::ConfigValidatorVisitor" do
   subject(:visitor) { ConfigValidator::ConfigValidatorVisitor.new }
 
-  { :Config => nil, :Project => "my_project" }.each do |node_type, path|
+  { :Config => nil, :Project => "my_project", :Group => "my_group" }.each do |node_type, path|
     it "requires #{node_type} to have servers" do
       node = stub(node_type, :has_servers? => false, :path => path)
       error_message = /#{path ? path + ": " : ""}no servers/

data/spec/lib/taketo/constructs/config_spec.rb

@@ -5,10 +5,13 @@ require 'taketo/constructs/config'
 include Taketo
 
 describe "Config" do
-  subject { Taketo::Constructs::Config.new }
+  subject(:config) { Taketo::Constructs::Config.new }
 
+  it_behaves_like "a construct with nodes", :groups, :group
   it_behaves_like "a construct with nodes", :projects, :project
 
   it { should have_accessor(:default_destination) }
+
+  it_behaves_like "a node with servers", :servers, :server
 end
 

data/spec/lib/taketo/constructs/environment_spec.rb

@@ -11,12 +11,17 @@ describe "Environment" do
     expect(environment.name).to eq(:foo)
   end
 
-  it_behaves_like "a construct with nodes", :servers, :server
+  it_behaves_like "a construct with nodes", :groups, :group
+  it_behaves_like "a node with servers"
 
   specify "#project_name returns project name" do
     environment.parent = Taketo::Constructs::Project.new("TheProject")
     expect(environment.project_name).to eq("TheProject")
   end
+
+  specify "#rails_env returns name as string" do
+    environment.rails_env.should == "foo"
+  end
 end
 
 

data/spec/lib/taketo/constructs/group_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'support/helpers/construct_spec_helper'
+require 'taketo/constructs/group'
+
+include Taketo
+
+describe "Group" do
+  subject(:group) { Taketo::Constructs::Group.new(:foo) }
+
+  it "has name" do
+    expect(group.name).to eq(:foo)
+  end
+
+  describe "#rails_env" do
+    it "returns parent's #rails_env" do
+      group.parent = stub(:Environment, :rails_env => "bar")
+      expect(group.rails_env).to eq("bar")
+    end
+
+    it "does not fail if parent does not provide #rails_env" do
+      group.parent = 1
+      expect(group.rails_env).to eq(nil)
+    end
+  end
+
+  it_behaves_like "a node with servers"
+end
+
+
+

data/spec/lib/taketo/constructs/project_spec.rb

@@ -12,5 +12,7 @@ describe "Project" do
   end
 
   it_behaves_like "a construct with nodes", :environments, :environment
+  it_behaves_like "a construct with nodes", :groups, :group
+  it_behaves_like "a node with servers"
 end
 

data/spec/lib/taketo/constructs/server_spec.rb

@@ -48,12 +48,16 @@ describe "Server" do
   end
 
   describe "#parent=" do
-    let(:environment) { environment = Taketo::Constructs::Environment.new(:the_environment) }
+    let(:environment) { stub(:Environment, :rails_env => 'the_env') }
 
     it "sets RAILS_ENV environment variable" do
       server.environment_variables.should == {}
       server.parent = environment
-      expect(server.environment_variables[:RAILS_ENV]).to eq(environment.name.to_s)
+      expect(server.environment_variables[:RAILS_ENV]).to eq(environment.rails_env)
+    end
+
+    it "does not fail if parent doesn't provide #rails_env" do
+      expect { server.parent = 1 }.not_to raise_error
     end
   end
 

data/spec/lib/taketo/constructs_factory_spec.rb

@@ -33,6 +33,11 @@ describe "ConstructsFactory" do
     expect(server).to be_an_instance_of(Taketo::Constructs::Server)
   end
 
+  specify "#create_group creates a group object" do
+    group = factory.create_group(:foo)
+    expect(group).to be_an_instance_of(Taketo::Constructs::Group)
+  end
+
   specify "#create_command creates a command object" do
     command = factory.create_command(:foo)
     expect(command).to be_an_instance_of(Taketo::Constructs::Command)

data/spec/lib/taketo/dsl_spec.rb

@@ -8,63 +8,67 @@ describe "DSL" do
   extend DSLSpec
   include DSLSpec
 
-  shared_examples "a scoped construct" do |name, parents, with_block|
+  shared_examples_for "a scoped construct" do |name, parents, with_block|
     parents = Array(parents)
 
     parents.each do |parent_scope_name|
-      parent_scope = scopes[parent_scope_name]
-      it { should be_appropriate_construct(name, :foo).with_block(with_block).under(parent_scope) }
+      scopes[parent_scope_name].each do |parent_scope_variant|
+        it { should be_appropriate_construct(name, :foo).with_block(with_block).under(parent_scope_variant) }
+      end
     end
 
-    scopes.except(*parents).each do |inappropriate_scope|
-      it { should_not be_appropriate_construct(name, :foo).with_block(with_block).under(inappropriate_scope) }
+    scopes.except(*parents).each do |inappropriate_scopes|
+      inappropriate_scopes.each do |inappropriate_scope_variant|
+        it { should_not be_appropriate_construct(name, :foo).with_block(with_block).under(inappropriate_scope_variant) }
+      end
     end
   end
 
-  shared_examples "a scope" do |scope_name, parent_scope_names|
+  shared_examples_for "a scope" do |scope_name, parent_scope_names|
     it_behaves_like "a scoped construct", scope_name, Array(parent_scope_names), true
 
     Array(parent_scope_names).each do |parent_scope_name|
-      parent_scope = scopes[parent_scope_name]
-
-      it { should enclose_scope(scope_name).under(parent_scope) }
-
-      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
-            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 "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
-            expect(c.current_scope_object).to eq(factory.send(scope_name))     #       expect(c.current_scope_object).to eq(factory.project)
-          end                                                                  #     end
-          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 "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
-
-      it "sets #{scope_name}'s parent to the #{parent_scope_name} scope object" do           # it "sets project's parent to the config scope object" 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)
-          factory.send(scope_name).should_receive(:parent=).with(c.current_scope_object)     #     factory.project.should_receive(:parent=).with(c.current_scope_object)
-          c.send(scope_name, :bar) {}                                                        #     c.project(:bar) {}
-        end                                                                                  #   end
-      end                                                                                    #
+      parent_scope_variants = scopes[parent_scope_name]
+
+      context "under #{parent_scope_name} #{parent_scope_variants.inspect}" do
+        it { should enclose_scope(scope_name).under(parent_scope_variants) }
+
+        it "creates a #{scope_name} under #{parent_scope_name} and set it as current scope object" do
+          within_parent_dsl(parent_scope_name) do |c|
+            stub_find_or_create_scope_object(c, scope_name, :bar)
+            c.send(scope_name, :bar) do
+              expect(c.current_scope_object).to eq(factory.send(scope_name))
+            end
+          end
+        end
+
+        it "does not leak #{scope_name} as current scope object" do
+          within_parent_dsl(parent_scope_name) do |c|
+            stub_find_or_create_scope_object(c, scope_name, :bar)
+            c.send(scope_name, :bar) do
+              expect(c.current_scope_object).to eq(factory.send(scope_name))
+            end
+            expect(c.current_scope_object).not_to eq(factory.send(scope_name))
+          end
+        end
+
+        it "adds a #{scope_name} to the #{parent_scope_name}'s #{scope_name}s collection" do
+          within_parent_dsl(parent_scope_name) do |c|
+            stub_find_or_create_scope_object(c, scope_name, :bar)
+            c.current_scope_object.should_receive("append_#{scope_name}").
+              with(factory.send(scope_name))
+            c.send(scope_name, :bar) {}
+          end
+        end
+
+        it "sets #{scope_name}'s parent to the #{parent_scope_name} scope object" do
+          within_parent_dsl(parent_scope_name) do |c|
+            stub_find_or_create_scope_object(c, scope_name, :bar)
+            factory.send(scope_name).should_receive(:parent=).with(c.current_scope_object)
+            c.send(scope_name, :bar) {}
+          end
+        end
+      end
     end
   end
 
@@ -72,11 +76,11 @@ describe "DSL" do
     it_behaves_like "a scoped construct", attribute_name, parent_scope_names, false
 
     Array(parent_scope_names).each do |parent_scope_name|
-      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
+      it "calls #{parent_scope_method} on current #{parent_scope_name}" do
+        within_parent_dsl(parent_scope_name) do |c|
+          factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value)
+          c.send(attribute_name, example_value)
+        end
       end
     end
   end
@@ -86,10 +90,10 @@ describe "DSL" do
   end
 
   describe "#default_server_config" do
-    it_behaves_like "a scoped construct", :default_server_config, [:config, :project, :environment]
+    it_behaves_like "a scoped construct", :default_server_config, [:config, :project, :environment, :group]
 
     it "stores a block" do
-      dsl(scopes[:config], factory.create(:config)) do |c|
+      within_parent_dsl(:config) do |c|
         cfg = proc { any_method_call_here }
         factory.config.should_receive(:default_server_config=).with(cfg)
         c.default_server_config(&cfg)
@@ -101,7 +105,7 @@ describe "DSL" do
     it_behaves_like "a scoped construct", :shared_server_config, :config
 
     it "stores a block" do
-      dsl(scopes[:config], factory.create(:config)) do |c|
+      within_parent_dsl(:config) do |c|
         cfg = proc { any_method_call_here }
         c.shared_server_config(:foo, &cfg)
         expect(c.shared_server_configs[:foo]).to eq(cfg)
@@ -111,10 +115,10 @@ describe "DSL" do
 
   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|
+      within_parent_dsl(:server) do |c|
         c.stub(:shared_server_configs => { :foo => proc { call_from_foo }, :bar => proc { call_from_bar } })
-        c.should_receive(:call_from_foo)
-        c.should_receive(:call_from_bar)
+        c.should_receive(:call_from_foo).once
+        c.should_receive(:call_from_bar).once
         c.include_shared_server_config(:foo, :bar)
       end
     end
@@ -122,7 +126,7 @@ describe "DSL" do
     context "when the 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|
+          within_parent_dsl(: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])
@@ -132,7 +136,7 @@ describe "DSL" do
 
       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|
+          within_parent_dsl(: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)
@@ -143,7 +147,7 @@ describe "DSL" do
 
     context "whne there are symbol arguments (names of shared configs) and a hash" do
       it "includes config corresponding to symbol arguments and hash keys" do
-        dsl(scopes[:server], factory.create(:server)) do |c|
+        within_parent_dsl(:server) do |c|
           c.stub(:shared_server_configs => { :foo => proc { call_from_foo }, :bar => proc { |qux| call_from_bar(qux) } })
           c.should_receive(:call_from_foo)
           c.should_receive(:call_from_bar).with(123)
@@ -153,7 +157,7 @@ describe "DSL" do
     end
 
     it "raises ConfigError if non-existent config included" do
-      dsl(scopes[:server], factory.create(:server)) do |c|
+      within_parent_dsl(: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
@@ -167,25 +171,25 @@ describe "DSL" do
     it_behaves_like "a scope", :environment, :project
   end
 
+  describe "#group" do
+    it_behaves_like "a scope", :group, [:project, :environment, :config]
+  end
+
   describe "#server" do
-    it_behaves_like "a scope", :server, [:environment, :config, :project]
+    it_behaves_like "a scope", :server, [:environment, :config, :project, :group]
 
     it "evaluates default_server_config" do
-      dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
+      within_parent_dsl(:environment) do |c|
         stub_find_or_create_scope_object(c, :server, :bar)
-
         default_server_config = proc { some_setup }
         factory.server.stub(:default_server_config => default_server_config)
-
         c.should_receive(:some_setup)
-
-        c.server(:bar) do
-        end
+        c.server(:bar) {}
       end
     end
 
     it "has name optional" do
-      dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
+      within_parent_dsl(:environment) do |c|
         stub_find_or_create_scope_object(c, :server, :default)
         c.server do
           expect(c.current_scope_object.name).to eq(:default)
@@ -246,11 +250,11 @@ describe "DSL" do
     end
 
     it "corresponds to current scope" do
-      dsl(:project, factory.create_project(:foo)) do |c|
+      within_parent_dsl(:project) do |c|
         expect(c.current_scope_object).to eq(factory.project)
       end
 
-      dsl(:server, factory.create_server(:foo)) do |c|
+      within_parent_dsl(:server) do |c|
         expect(c.current_scope_object).to eq(factory.server)
       end
     end
@@ -282,9 +286,17 @@ describe "DSL" do
     it "raises meaningful error if config parse failed"
   end
 
-  def stub_find_or_create_scope_object(scope_object, scope, name)
-    scope_object.current_scope_object.should_receive(:find).and_yield.and_return(factory.create(scope, name))
-    factory.should_receive(:create).with(scope, name)
+  def stub_find_or_create_scope_object(dsl_object, scope, name)
+    dsl_object.current_scope_object.stub(:find).with(scope, name).and_yield.and_return(factory.create(scope, name))
   end
+
+  def within_parent_dsl(parent_scope, &block)
+    scopes[parent_scope].each do |parent_scope_variant|
+      dsl(parent_scope_variant, factory.create(parent_scope)) do |c|
+        block.call(c)
+      end
+    end
+  end
+
 end
 

data/spec/lib/taketo/group_list_visitor_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'taketo/group_list_visitor'
+
+include Taketo
+
+describe "GroupListVisitor" do
+  subject(:group_list) { GroupListVisitor.new }
+
+  describe "#result" do
+    it "outputs list of qualified server names" do
+      server1 = stub(:Server, :path => "foo")
+      server2 = stub(:Server, :path => "bar")
+      group_list.visit_server(server1)
+      group_list.visit_server(server2)
+      group_list.result.should == "foo\nbar"
+    end
+  end
+end
+
+

data/spec/lib/taketo/group_resolver_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'support/helpers/construct_spec_helper'
+require 'taketo/group_resolver'
+
+include Taketo
+
+describe "GroupResolver" do
+  include ConstructsFixtures
+
+  let(:server1) { s = server(:s1); s.global_alias = :the_alias; s }
+  let(:environment1) { environment(:bar, :servers => server1) }
+  let(:project1) { project(:foo, :environments => environment1) }
+
+  let(:server2) { server(:s2) }
+  let(:environment2) { environment(:qux, :servers => server2) }
+  let(:project2) { project(:baz, :environments => environment2) }
+
+  let(:server3) { server(:s3) }
+  let(:server4) { server(:s4) }
+  let(:environment3) { environment(:corge, :servers => [server3, server4]) }
+  let(:project3) { project(:quux, :environments => environment3) }
+
+  let(:server5) { server(:s5) }
+  let(:server6) { server(:s6) }
+  let(:environment4) { environment(:garply, :servers => [server5, server6]) }
+  let(:environment5) { environment(:waldo, :servers => server(:s7)) }
+  let(:project4) { project(:grault, :environments => [environment4, environment5]) }
+
+  let(:config) { create_config(:projects => [project1, project2, project3, project4]) }
+
+  describe "#resolve" do
+    it "does not resolve to server" do
+      expect{ resolver(config, "foo:bar:s1").resolve }.to raise_error(Taketo::NonExistentDestinationError)
+    end
+
+    it "returns environment when path has 2 segments and is correct" do
+      expect(resolver(config, "foo:bar").resolve).to eq(environment1)
+    end
+
+    it "returns project when path has 1 segment and is correct" do
+      expect(resolver(config, "foo").resolve).to eq(project1)
+    end
+
+    it "returns the config if path has is empty and there's no default destination" do
+      expect(resolver(config, "").resolve).to eq(config)
+    end
+
+    it "raises NonExistentDestinationError when path is not correct" do
+      expect { resolver(config, "i").resolve }.to raise_error(NonExistentDestinationError)
+    end
+  end
+
+  def resolver(*args)
+    GroupResolver.new(*args)
+  end
+
+end
+
+

data/spec/lib/taketo/{destination_resolver_spec.rb → server_resolver_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 require 'support/helpers/construct_spec_helper'
-require 'taketo/destination_resolver'
+require 'taketo/server_resolver'
 
 include Taketo
 
-describe "DestinationResolver" do
+describe "ServerResolver" do
   include ConstructsFixtures
 
   let(:server1) { s = server(:s1); s.global_alias = :the_alias; s }
@@ -145,34 +145,8 @@ describe "DestinationResolver" do
     end
   end
 
-  describe "#get_node" do
-    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 "returns environment when path has 2 segments and is correct" do
-      expect(resolver(config, "foo:bar").get_node).to eq(environment1)
-    end
-
-    it "returns project when path has 1 segment and is correct" do
-      expect(resolver(config, "foo").get_node).to eq(project1)
-    end
-
-    it "returns the config if path has is empty and there's no default destination" do
-      expect(resolver(config, "").get_node).to eq(config)
-    end
-
-    it "resolves to server by global server alias" do
-      expect(resolver(config, "the_alias").get_node).to eq(server1)
-    end
-
-    it "raises NonExistentDestinationError when path is not correct" do
-      expect { resolver(config, "i").get_node }.to raise_error(NonExistentDestinationError)
-    end
-  end
-
   def resolver(*args)
-    DestinationResolver.new(*args)
+    ServerResolver.new(*args)
   end
 
 end

data/spec/support/helpers/construct_spec_helper.rb

@@ -15,6 +15,15 @@ shared_examples "a construct with nodes" do |name_plural, name_singular|
   end                                                                      # end
 end
 
+shared_examples "a node with servers" do
+  it_behaves_like "a construct with nodes", :servers, :server
+
+  specify "#has_servers? should perform deep search on child nodes" do
+    subject.should_receive(:has_deeply_nested_nodes?).with(:servers)
+    subject.has_servers?
+  end
+end
+
 module ConstructsFixtures
   include Taketo::Constructs
 

data/spec/support/helpers/dsl_spec_helper.rb

@@ -1,6 +1,6 @@
 module DSLSpec
   class TestConstructsFactory
-    attr_reader :config, :project, :environment, :server, :command
+    attr_reader :config, :project, :environment, :server, :group, :command
 
     def create(type, *args)
       send("create_#{type}", *args)
@@ -22,6 +22,10 @@ module DSLSpec
       @server ||= RSpec::Mocks::Mock.new(:Server, :name => name, :default_server_config => proc {}).as_null_object
     end
 
+    def create_group(name = :foo)
+      @group ||= RSpec::Mocks::Mock.new(:Group, :name => name, :default_server_config => proc {}).as_null_object
+    end
+
     def create_command(name = :the_cmd)
       @command ||= RSpec::Mocks::Mock.new(:Command, :name => name, :default_server_config => proc {}).as_null_object
     end
@@ -37,7 +41,7 @@ module DSLSpec
     end
   end
 
-  def dsl(scope = [:config], scope_object = nil)
+  def dsl(scope = scopes[:config], scope_object = nil, &block)
     context = DSL.new(factory)
 
     def context.set_scope(s, obj)
@@ -46,17 +50,35 @@ module DSLSpec
     end
 
     context.set_scope(scope, scope_object || factory.create_config)
-
-    yield context
+    block.call(context)
   end
 
   def scopes
     scopes_hash = {
-      :config      => [:config],
-      :project     => [:config, :project],
-      :environment => [:config, :project, :environment],
-      :server      => [:config, :project, :environment, :server],
-      :command     => [:config, :project, :environment, :server, :command]
+      :config      => [[:config]],
+      :project     => [[:config, :project]],
+      :environment => [[:config, :project, :environment]],
+      :group       => [
+        [:config, :group],
+        [:config, :project, :group],
+        [:config, :project, :environment, :group]
+      ],
+      :server      => [
+        # [:config, :server],
+        # [:config, :group, :server],
+        # [:config, :project, :server],
+        # [:config, :project, :group, :server],
+        # [:config, :project, :environment, :server],
+        [:config, :project, :environment, :group, :server]
+      ],
+      :command     => [
+        [:config, :server, :command],
+        [:config, :group, :server, :command],
+        [:config, :project, :server, :command],
+        [:config, :project, :group, :server, :command],
+        [:config, :project, :environment, :server, :command],
+        [:config, :project, :environment, :group, :server, :command]
+      ]
     }
 
     def scopes_hash.except(*keys)