taketo 0.0.10 → 0.1.0

data/spec/lib/taketo/config_traverser_spec.rb

@@ -1,62 +1,49 @@
 require 'spec_helper'
+require 'support/helpers/construct_spec_helper'
 require 'taketo/config_traverser'
 
-# config           1
-#                 / \
-# project        1   2
+# config           1--
+#                 / \ \
+# project        1   2 server_3
 #               / \
 # environment  1   2
 #                 /|\
 # server         1 2 3
 
 describe Taketo::ConfigTraverser do
-  let(:server_1) { stub(:Server1, :node_type => :server, :name => :server_1).as_null_object }
-  let(:server_2) { stub(:Server2, :node_type => :server, :name => :server_2).as_null_object }
-  let(:server_3) { stub(:Server3, :node_type => :server, :name => :server_3).as_null_object }
+  include ConstructsFixtures
 
-  let(:environment_1) { stub(:Environment1, :node_type => :environment, :name => :environment_1) }
-  let(:environment_2) { stub(:Environment2, :node_type => :environment, :name => :environment_2, :servers => [server_1, server_2, server_3]) }
+  let(:server_1) { server(:Server1) }
+  let(:server_2) { server(:Server2) }
+  let(:server_3) { server(:Server3) }
 
-  let(:project_1) { stub(:Project1, :node_type => :project, :name => :project_1, :environments => [environment_1, environment_2]) }
-  let(:project_2) { stub(:Project2, :node_type => :project, :name => :project_2) }
+  let(:environment_1) { environment(:Environment1) }
+  let(:environment_2) { environment(:Environment2, :servers => [server_1, server_2]) }
 
-  let(:config) { stub(:Config, :node_type => :config, :projects => [project_1, project_2], :name => :config) }
+  let(:project_1) { project(:Project1, :environments => [environment_1, environment_2]) }
+  let(:project_2) { project(:Project2) }
 
-  let(:traverser) { described_class.new(config) }
-
-  before do
-    config.stub(:has_nodes?).with(:projects).and_return(true)
-    config.stub(:nodes).with(:projects).and_return([project_1, project_2])
-
-    project_1.stub(:has_nodes?).with(:environments).and_return(true)
-    project_1.stub(:nodes).with(:environments).and_return([environment_1, environment_2])
-
-    project_2.stub(:has_nodes?).with(:environments).and_return(false)
-    project_2.should_not_receive(:nodes)
+  let(:config) { create_config(:projects => [project_1, project_2], :servers => server_3) }
 
-    environment_1.stub(:has_nodes?).with(:servers).and_return(false)
-    environment_1.should_not_receive(:nodes)
-
-    environment_2.stub(:has_nodes?).with(:servers).and_return(true)
-    environment_2.stub(:nodes).and_return([server_1, server_2, server_3])
-  end
+  let(:traverser) { described_class.new(config) }
 
   class PrintingVisitor
+    attr_reader :result
+
     def initialize
       @result = []
     end
 
-    def visit(type)
+    def visit(node)
+      @result << node.name
     end
   end
 
   describe "#visit_depth_first" do
     it "traverses in depth with visitor" do
-      visitor = stub(:Visitor)
-      [config, project_1, environment_1, environment_2, server_1, server_2, server_3, project_2].each do |node|
-        visitor.should_receive(:visit).with(node).ordered
-      end
+      visitor = PrintingVisitor.new
       traverser.visit_depth_first(visitor)
+      visitor.result.should == [config, server_3, project_1, environment_1, environment_2, server_1, server_2, project_2].map(&:name)
     end
   end
 end

data/spec/lib/taketo/config_validator_spec.rb

@@ -18,12 +18,12 @@ end
 describe "ConfigValidator::ConfigValidatorVisitor" do
   subject(:visitor) { ConfigValidator::ConfigValidatorVisitor.new }
 
-  it "requires config to have projects" do
-    config = stub(:Config, :has_projects? => false)
-    error_message = /no projects/
+  it "requires config to have servers" do
+    config = stub(:Config, :has_servers? => false)
+    error_message = /no servers/
     expect { visitor.visit_config(config) }.to raise_error ConfigError, error_message
 
-    config.stub(:has_projects? => true)
+    config.stub(:has_servers? => true)
     expect { visitor.visit_config(config) }.not_to raise_error ConfigError, error_message
   end
 

data/spec/lib/taketo/config_visitor_spec.rb

@@ -43,9 +43,5 @@ describe "ConfigVisitor" do
     end
     expect(visitor.visit(c.new)).to eq("captured as Numeric")
   end
-
-  it "raises if doesn't know how to visit" do
-    expect { visitor.visit([]) }.to raise_error /Array/
-  end
 end
 

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

@@ -16,15 +16,47 @@ describe "BaseConstruct" do
     expect(construct.qualified_name).to eq('test_base_construct my_node')
   end
 
-  specify "#parent= sets default server config to parent's default server config" do
-    parent_default_server_config = proc {}
-    construct.parent = stub(:default_server_config => parent_default_server_config)
-    expect(construct.default_server_config).to eq(parent_default_server_config)
+  describe "#parent=" do
+    it "stores parent" do
+      parent = stub
+      construct.parent = parent
+      construct.parent.should == parent
+    end
+  end
+
+  shared_context "parents" do
+    let(:grand_parent) { TestBaseConstruct.new(:grand_parent) }
+    let(:parent) { TestBaseConstruct.new(:parent) }
+
+    before(:each) do
+      parent.parent = grand_parent
+      construct.parent = parent
+    end
+  end
+
+  describe "#parents" do
+    include_context "parents"
+
+    it "returns parent nodes up until NullConstruct" do
+      expect(construct.parents).to eq([parent, grand_parent])
+    end
+  end
+
+  specify "#parents returns an empty array if there are no parents" do
+    expect(construct.parents).to eq([])
+  end
+
+  describe "#path" do
+    include_context "parents"
+
+    it "returns names of parents separated by :" do
+      expect(construct.path).to eq("grand_parent:parent:my_node")
+    end
   end
 
   describe "#default_server_config=" do
     let(:default_server_config) { proc { call_from_self } }
-    let(:context) { stub }
+    let(:context) { stub(:Context) }
 
     it "sets default server config" do
       construct.default_server_config = default_server_config

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

@@ -14,7 +14,7 @@ describe "Environment" do
   it_behaves_like "a construct with nodes", :servers, :server
 
   specify "#project_name returns project name" do
-    environment.project = stub(:Project, :name => "TheProject")
+    environment.parent = Taketo::Constructs::Project.new("TheProject")
     expect(environment.project_name).to eq("TheProject")
   end
 end

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

@@ -11,12 +11,6 @@ describe "Project" do
     expect(project.name).to eq(:foo)
   end
 
-  specify "#append_environment sets project attribute on an environment to self" do
-    environment = mock(:Environment, :name => :bar)
-    environment.should_receive(:project=).with(project)
-    project.append_environment(environment)
-  end
-
   it_behaves_like "a construct with nodes", :environments, :environment
 end
 

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

@@ -48,9 +48,7 @@ describe "Server" do
   end
 
   describe "#parent=" do
-    let(:environment) { environment = stub(:Environment, :name => :the_environment, :default_server_config => proc {}) }
-
-    it { should have_accessor(:environment, environment) }
+    let(:environment) { environment = Taketo::Constructs::Environment.new(:the_environment) }
 
     it "sets RAILS_ENV environment variable" do
       server.environment_variables.should == {}

data/spec/lib/taketo/destination_resolver_spec.rb

@@ -1,53 +1,31 @@
 require 'spec_helper'
+require 'support/helpers/construct_spec_helper'
 require 'taketo/destination_resolver'
 require 'taketo/support/named_nodes_collection'
 
 include Taketo
 
 describe "DestinationResolver" do
-  class TestNode
-    attr_reader :name, :node_type
-    def initialize(node_type, name, *nodes)
-      @node_type, @name, @nodes = node_type, name, nodes
-    end
-
-    def find(type, name)
-      @nodes.detect { |s| s.name == name } or raise KeyError, name.to_s
-    end
-
-    def nodes(type)
-      @nodes
-    end
-
-    def global_alias
-      :the_alias if name == :s1 && node_type == :server
-    end
-  end
-
-  [:project, :environment, :server].each do |node_type|
-    define_method node_type do |name, *nodes|
-      TestNode.new(node_type, name, *nodes)
-    end
-  end
+  include ConstructsFixtures
 
-  let(:server1) { server(:s1) }
-  let(:environment1) { environment(:bar, server1) }
-  let(:project1) { project(:foo, environment1) }
+  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, server2) }
-  let(:project2) { project(:baz, environment2) }
+  let(:environment2) { environment(:qux, :servers => server2) }
+  let(:project2) { project(:baz, :environments => environment2) }
 
   let(:server3) { server(:s3) }
   let(:server4) { server(:s4) }
-  let(:environment3) { environment(:corge, server3, server4) }
-  let(:project3) { environment(:quux, environment3) }
+  let(:environment3) { environment(:corge, :servers => [server3, server4]) }
+  let(:project3) { project(:quux, :environments => environment3) }
 
-  let(:environment4) { environment(:garply, server(:s5), server(:s6)) }
-  let(:environment5) { environment(:waldo, server(:s7)) }
-  let(:project4) { project(:grault, environment4, environment5) }
+  let(:environment4) { environment(:garply, :servers => [server(:s5), server(:s6)]) }
+  let(:environment5) { environment(:waldo, :servers => server(:s7)) }
+  let(:project4) { project(:grault, :environments => [environment4, environment5]) }
 
-  let(:config) { TestNode.new(:config, nil, project1, project2, project3, project4) }
+  let(:config) { create_config(:projects => [project1, project2, project3, project4]) }
 
   context "when project, environment and server specified" do
     it "returns server if it exists" do
@@ -114,43 +92,38 @@ describe "DestinationResolver" do
         context "when there's one environment" do
           context "when there's one server" do
             it "executes command without asking project/environment/server" do
-              config = TestNode.new(:config, nil, project1)
-              config.stub(:default_destination => nil)
+              config = create_config(:projects => project1)
               expect(resolver(config, "").resolve).to eq(server1)
             end
           end
 
           context "when there are multiple servers" 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
+              config = create_config(:projects => project3)
+              expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /s3.*s4/i
             end
           end
         end
 
         context "when there are multiple environments" 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
+            config = create_config(:projects => project4)
+            expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /garply:s5.*garply:s6.*waldo:s7/i
           end
         end
       end
 
       context "when there are multiple projects" do
         it "asks for project" do
-          config = TestNode.new(:config, nil, project3, project4)
-          config.stub(:default_destination => nil)
-
-          expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /projects/i
+          config = create_config(:projects => [project3, project4])
+          expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /corge:s3.*corge:s4.*garply:s5.*garply:s6.*waldo:s7/i
         end
       end
     end
 
     context "when there is default destination" do
       it "resolves by default destination" do
-        config.stub(:default_destination => "foo:bar:s1")
+        config.default_destination = "foo:bar:s1"
         expect(resolver(config, "").resolve).to eq(server1)
       end
     end
@@ -176,12 +149,10 @@ describe "DestinationResolver" do
     end
 
     it "returns the config if path has is empty and there's no default destination" do
-      config.stub(:default_destination => nil)
       expect(resolver(config, "").get_node).to eq(config)
     end
 
     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
   end
@@ -190,9 +161,5 @@ describe "DestinationResolver" do
     DestinationResolver.new(*args)
   end
 
-  def list(*items)
-    Taketo::Support::NamedNodesCollection.new(items)
-  end
-
 end
 

data/spec/lib/taketo/dsl_spec.rb

@@ -21,49 +21,51 @@ describe "DSL" do
     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 "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                                                                                    #
+  shared_examples "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                                                                                    #
+    end
   end
 
   shared_examples "a scoped method" do |attribute_name, parent_scope_names, parent_scope_method, example_value|
@@ -166,7 +168,7 @@ describe "DSL" do
   end
 
   describe "#server" do
-    it_behaves_like "a scope", :server, :environment
+    it_behaves_like "a scope", :server, [:environment, :config, :project]
 
     it "evaluates default_server_config" do
       dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|

data/spec/spec_helper.rb

@@ -17,5 +17,5 @@ require 'rspec/autorun'
 
 $:.unshift File.expand_path('../../lib', __FILE__)
 
-Dir[File.dirname(__FILE__) + "/support/matchers/*.rb"].each {|f| require f}
+Dir[File.dirname(__FILE__) + "/support/matchers/*.rb"].each { |f| require f }
 

data/spec/support/helpers/construct_spec_helper.rb

@@ -1,3 +1,5 @@
+require 'taketo/constructs'
+
 shared_examples "a construct with nodes" do |name_plural, name_singular|
   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
@@ -13,3 +15,30 @@ shared_examples "a construct with nodes" do |name_plural, name_singular|
   end                                                                      # end
 end
 
+module ConstructsFixtures
+  include Taketo::Constructs
+
+  [Project, Environment, Server].each do |node_type|
+    define_method node_type.name.downcase.gsub(/\w*::/, '') do |name, *args|
+      n = node_type.new(name)
+      add_nodes(n, args.first || {})
+      n
+    end
+  end
+
+  def create_config(nodes_by_types = {})
+    c = Taketo::Constructs::Config.new
+    add_nodes(c, nodes_by_types)
+    c
+  end
+
+  def add_nodes(node, nodes_by_types)
+    nodes_by_types.each do |child_type, children_of_type|
+      Array(children_of_type).each do |c|
+        node.nodes(child_type) << c
+        c.parent = node
+      end
+    end
+  end
+end
+