taketo 0.0.6 → 0.0.7

data/spec/lib/taketo/config_validator_spec.rb

@@ -1,60 +1,74 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/config_validator'
 
 include Taketo
 
 describe "ConfigValidator" do
-  it "should require at least one project" do
-    config = stub(:projects => [])
-    expect { validator(config).validate! }.to raise_error ConfigError, /projects/i
+  let(:traverser) { stub(:ConfigTraverser) }
+
+  describe "#validate!" do
+    it "should visit all nodes with an instance of ConfigValidator::ConfigValidatorVisitor" do
+      validator = ConfigValidator.new(traverser)
+      traverser.should_receive(:visit_depth_first).with(an_instance_of(ConfigValidator::ConfigValidatorVisitor))
+      validator.validate!
+    end
   end
+end
 
-  it "should require every project to have at least one environment" do
-    project_1 = stub(:Project, :name => :project_1, :environments => [])
-    project_2 = stub(:Project, :name => :project_2, :environments => [stub])
+describe "ConfigValidator::ConfigValidatorVisitor" do
+  subject(:visitor) { ConfigValidator::ConfigValidatorVisitor.new }
 
-    config = stub(:projects => [project_1, project_2])
-    expect { validator(config).validate! }.to raise_error ConfigError, /project_1/i
+  it "should require config to have projects" do
+    config = stub(:Config, :has_projects? => false)
+    error_message = /no projects/
+    expect { visitor.visit_config(config) }.to raise_error ConfigError, error_message
 
-    project_1.stub(:environments => { :e => stub })
-    expect { validator(config).validate! }.not_to raise_error ConfigError, /project_1/i
+    config.stub(:has_projects? => true)
+    expect { visitor.visit_config(config) }.not_to raise_error ConfigError, error_message
   end
 
-  it "should require every environment to have at least one server" do
-    environment_1 = stub(:Environment, :name => :environment_1, :servers => [])
-    environment_2 = stub(:Environment, :name => :environment_2, :servers => [stub])
-    project_1 = stub(:Project, :name => :project_1, :environments => [environment_1])
-    project_2 = stub(:Project, :name => :project_2, :environments => [environment_2])
+  it "should require projects to have environments" do
+    project = stub(:Project, :has_environments? => false, :path => "my_project")
+    error_message = /my_project: no environments/
+    expect { visitor.visit_project(project) }.to raise_error ConfigError, error_message
+
+    project.stub(:has_environments? => true)
+    expect { visitor.visit_project(project) }.not_to raise_error ConfigError, error_message
+  end
 
-    config = stub(:projects => [project_1, project_2])
-    expect { validator(config).validate! }.to raise_error ConfigError, /environment_1/i
+  it "should require environments to have servers" do
+    environment = stub(:Environment, :has_servers? => false, :path => "my_project:my_environment")
+    error_message = /my_project:my_environment: no servers/
+    expect { visitor.visit_environment(environment) }.to raise_error ConfigError, error_message
 
-    environment_2.stub(:servers => [stub])
-    expect { validator(config).validate! }.not_to raise_error ConfigError, /environment_2/i
+    environment.stub(:has_servers? => true)
+    expect { visitor.visit_environment(environment) }.not_to raise_error ConfigError, error_message
   end
 
-  describe "global server aliases" do
-    let(:server_1) { stub(:Server) }
-    let(:server_2) { stub(:Server) }
-    let(:environment) { stub(:Environment, :name => :environment, :servers => [server_1, server_2]) }
-    let(:project) { stub(:Project, :name => :project, :environments => [environment]) }
-    let(:config) { stub(:Config, :projects => [project]) }
-
-    it "should not raise error if unique" do
-      server_1.stub(:global_alias => :foo)
-      server_2.stub(:global_alias => :bar)
-      expect { validator(config).validate! }.not_to raise_error(ConfigError, /alias/i)
-    end
+  it "should require servers to have host" do
+    server = stub(:Server, :host => '', :path => "my_project:my_environment:my_server", :global_alias => nil)
+    error_message = /my_project:my_environment:my_server: host is not defined/
+    expect { visitor.visit_server(server) }.to raise_error ConfigError, error_message
 
-    it "should raise error unless unique" do
-      server_1.stub(:global_alias => :foo)
-      server_2.stub(:global_alias => :foo)
-      expect { validator(config).validate! }.to raise_error(ConfigError, /alias/i)
-    end
+    server.stub(:host => 'the-host')
+    expect { visitor.visit_server(server) }.not_to raise_error ConfigError, error_message
+  end
+
+  it "should require servers to have unique global server aliases" do
+    server1 = stub(:Server, :host => 'the-host1', :path => "my_project:my_environment:my_server", :global_alias => 'foo')
+    server2 = stub(:Server, :host => 'the-host2', :path => "my_project:my_environment2:my_server3", :global_alias => 'foo')
+    error_message = /my_project:my_environment2:my_server3: global alias 'foo' has already been taken.*my_project:my_environment:my_server/
+    @visitor = visitor
+    expect { @visitor.visit_server(server1) }.not_to raise_error ConfigError, error_message
+    expect { @visitor.visit_server(server2) }.to raise_error ConfigError, error_message
   end
 
-  def validator(config)
-    Taketo::ConfigValidator.new(config)
+  it "should require commands to have command specified" do
+    command = stub(:Command, :command => '', :name => 'qux')
+    error_message = /execute/
+    expect { visitor.visit_command(command) }.to raise_error ConfigError, error_message
+    command.stub(:command => 'foo')
+    expect { visitor.visit_command(command) }.not_to raise_error ConfigError, error_message
   end
 end
 

data/spec/lib/taketo/config_visitor_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'taketo/config_visitor'
+
+include Taketo
+
+describe "ConfigVisitor" do
+  class DummyVisitor < ConfigVisitor
+    visit String do |s|
+      s.upcase
+    end
+
+    visit NilClass do |n|
+      "hooray"
+    end
+
+    visit Fixnum do |n|
+      n.to_s.reverse
+    end
+
+    visit Numeric do |n|
+      n.to_s
+    end
+  end
+
+  subject(:visitor) { DummyVisitor.new }
+
+  it "defines #visit* methods" do
+    expect(visitor.visit_string('qwe')).to eq('QWE')
+    expect(visitor.visit_nil_class(nil)).to eq('hooray')
+  end
+
+  it "dispatches according to class" do
+    expect(visitor.visit(700)).to eq("007")
+  end
+
+  it "takes ancestors into account" do
+    expect(visitor.visit(2.0)).to eq("2.0")
+  end
+
+  it "skips anonymous classes/modules" do
+    c = Class.new(Numeric) do
+      def to_s; "captured as Numeric"; end
+    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

@@ -1,84 +1,21 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/constructs/base_construct'
 
 include Taketo
 
 describe "BaseConstruct" do
-  class TestConstruct < Constructs::BaseConstruct
-    attr_reader :foos
+  class TestBaseConstruct < Constructs::BaseConstruct; end
 
-    def initialize(name, foos)
-      super(name)
-      @foos = foos
-    end
+  subject(:construct) { TestBaseConstruct.new(:my_node) }
 
-    def find_foo(name)
-      @foos[name]
-    end
+  specify "#node_type returns demodulized snake-cased class name" do
+    construct.node_type.should == :test_base_construct
   end
 
-  let(:foos) { mock(:NamedNodesCollection) }
-  let(:construct) { TestConstruct.new(:construct, foos) }
-
-  describe "#find" do
-    context "if there is such node" do
-      it "should return node object with corresponding name" do
-        foos.should_receive(:[]).with(:bar).and_return(:qux)
-        construct.find(:foo, :bar).should == :qux
-      end
-    end
-
-    context "if there is no such command" do
-      before(:each) { foos.should_receive(:[]).and_return(nil) }
-
-      it "should yield if block given" do
-        expect { |b| construct.find(:foo, :bar, &b) }.to yield_control
-      end
-
-      it "should raise KeyError if no block given" do
-        expect { construct.find(:foo, :bar) }.to raise_error(KeyError)
-      end
-    end
+  specify "#qualified_name returns node type and name as string" do
+    expect(construct.qualified_name).to eq('test_base_construct my_node')
   end
 
-  describe "#node_type" do
-    it "should return demodulized snake-cased class name" do
-      construct.node_type.should == :test_construct
-    end
-  end
-
-  describe "nodes" do
-    class TestConstruct2 < Constructs::BaseConstruct
-      has_nodes :foos, :foo
-    end
-
-    let(:construct) { TestConstruct2.new(:node_name) }
-
-    let(:foo) { stub(:name => :bar) }
-
-    describe ".has_nodes" do
-      it "should define add node type to class's node_types" do
-        TestConstruct2.node_types.should include(:foos)
-      end
-
-      it "should make nodes accessible via added methods" do
-        construct.append_foo(foo)
-        construct.foos.should include(foo)
-        construct.find_foo(:bar).should == foo
-      end
-    end
-
-    describe "#nodes" do
-      it "should return nodes collection by plural name" do
-        construct.append_foo(foo)
-        construct.nodes(:foos).should include(foo)
-      end
-
-      it "should raise NodesNotDefinedError if non-specified node requested" do
-        expect { construct.nodes(:bars) }.to raise_error(NodesNotDefinedError, /bars/)
-      end
-    end
-  end
 end
 
 

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

@@ -1,10 +1,10 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/constructs/command'
 
 include Taketo
 
 describe "Command" do
-  subject { Taketo::Constructs::Command.new(:the_command) }
+  subject(:command) { Taketo::Constructs::Command.new(:the_command) }
 
   it { should have_accessor(:command) }
   it { should have_accessor(:description) }
@@ -16,14 +16,26 @@ describe "Command" do
            :default_location => "/var/apps/the app")
     end
 
-    it "should pick up server's environment variables and location" do
-      subject.command = "rails c"
-      subject.render(server).should == "cd /var/apps/the\\ app; FOO=bar\\ baz rails c"
+    it "picks up server's environment variables and location" do
+      command.command = "rails c"
+      expect(command.render(server)).to eq("cd /var/apps/the\\ app; FOO=bar\\ baz rails c")
     end
 
-    it "should let user override default directory" do
-      subject.command = "rails c"
-      subject.render(server, :directory => "/var/qux").should == "cd /var/qux; FOO=bar\\ baz rails c"
+    it "lets user override default directory" do
+      command.command = "rails c"
+      expect(command.render(server, :directory => "/var/qux")).to eq("cd /var/qux; FOO=bar\\ baz rails c")
+    end
+  end
+
+  describe ".default" do
+    it "returns 'bash' command" do
+      expect(Taketo::Constructs::Command.default.command).to eq("bash")
+    end
+  end
+
+  describe ".explicit_command" do
+    it "returns given command string encapsulated" do
+      expect(Taketo::Constructs::Command.explicit_command("qq").command).to eq("qq")
     end
   end
 end

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

@@ -1,4 +1,4 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/config'
 
@@ -9,10 +9,6 @@ describe "Config" do
 
   it_behaves_like "a construct with nodes", :projects, :project
 
-  it "should set default_destination" do
-    subject.default_destination.should be_nil
-    subject.default_destination = "foo:bar:baz"
-    subject.default_destination.should == "foo:bar:baz"
-  end
+  it { should have_accessor(:default_destination) }
 end
 

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

@@ -1,23 +1,28 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/environment'
 
 include Taketo
 
 describe "Environment" do
-  subject { Taketo::Constructs::Environment.new(:foo) }
+  subject(:environment) { Taketo::Constructs::Environment.new(:foo) }
 
-  it "should have name" do
-    subject.name.should == :foo
+  it "has name" do
+    expect(environment.name).to eq(:foo)
   end
 
   it_behaves_like "a construct with nodes", :servers, :server
 
-  specify "#append_server should set environment attribute on a server to self" do
+  specify "#append_server sets environment attribute on a server to self" do
     server = mock(:Server, :name => :foo)
-    server.should_receive(:environment=).with(subject)
-    subject.append_server(server)
+    server.should_receive(:environment=).with(environment)
+    environment.append_server(server)
   end
+
+  specify "#project_name returns project name" do
+    environment.project = stub(:Project, :name => "TheProject")
+    expect(environment.project_name).to eq("TheProject")
+  end 
 end
 
 

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

@@ -1,16 +1,22 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/project'
 
 include Taketo
 
 describe "Project" do
-  subject { Taketo::Constructs::Project.new(:foo) }
+  subject(:project) { Taketo::Constructs::Project.new(:foo) }
 
-  it "should have name" do
-    subject.name.should == :foo
+  it "has name" 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

@@ -1,42 +1,51 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/server'
 
 include Taketo
 
 describe "Server" do
-  subject { Taketo::Constructs::Server.new(:foo) }
+  subject(:server) { Taketo::Constructs::Server.new(:foo) }
 
-  it "should have name" do
-    subject.name.should == :foo
+  it "has name" do
+    expect(server.name).to eq(:foo)
   end
 
   it { should have_accessor(:host) }
   it { should have_accessor(:port) }
   it { should have_accessor(:username) }
   it { should have_accessor(:default_location) }
+  it { should have_accessor(:default_command) }
   it { should have_accessor(:global_alias) }
   it { should have_accessor(:identity_file) }
 
+  module Taketo
+    module Constructs
+      Command = Class.new unless defined? Command
+    end
+  end
+
+  it "has default command" do
+    Taketo::Constructs::Command.should_receive(:default).and_return(:qux)
+    expect(server.default_command).to eq(:qux)
+  end
+
   describe "#environment=" do
     let(:environment) { environment = stub(:Environment, :name => :the_environment) }
 
-    it "should set environment" do
-      subject.environment = environment
-      subject.environment.should == environment
-    end
+    it { should have_accessor(:environment, environment) }
 
-    it "should set RAILS_ENV environment variable" do
-      subject.environment_variables.should == {}
-      subject.environment = environment
-      subject.environment_variables[:RAILS_ENV].should == environment.name.to_s
+    it "sets RAILS_ENV environment variable" do
+      server.environment_variables.should == {}
+      server.environment = environment
+      expect(server.environment_variables[:RAILS_ENV]).to eq(environment.name.to_s)
     end
   end
 
-  it "should set environment variables" do
-    subject.env :FOO => "bar"
-    subject.env :BAR => "baz"
-    subject.environment_variables.should include(:FOO => "bar", :BAR => "baz")
+  it "sets environment variables" do
+    server.env :FOO => "bar"
+    server.env :BAR => "baz"
+    expect(server.environment_variables).to include(:FOO => "bar", :BAR => "baz")
   end
 
   it_behaves_like "a construct with nodes", :commands, :command

data/spec/lib/taketo/constructs_factory_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/constructs_factory'
 
 include Taketo
@@ -6,7 +6,7 @@ include Taketo
 describe "ConstructsFactory" do
   let(:factory) { Taketo::ConstructsFactory.new }
 
-  specify "#create should delegate to appropriate method according to the type" do
+  specify "#create delegates to appropriate method according to the type" do
     factory.should_receive(:create_config)
     factory.create(:config)
 
@@ -14,28 +14,28 @@ describe "ConstructsFactory" do
     factory.create(:project, :foo)
   end
 
-  specify "#create_config should create a config object" do
-    factory.create_config.should be_an_instance_of(Taketo::Constructs::Config)
+  specify "#create_config creates a config object" do
+    expect(factory.create_config).to be_an_instance_of(Taketo::Constructs::Config)
   end
 
-  specify "#create_project should create a project object" do
+  specify "#create_project creates a project object" do
     project = factory.create_project(:foo)
-    project.should be_an_instance_of(Taketo::Constructs::Project)
+    expect(project).to be_an_instance_of(Taketo::Constructs::Project)
   end
 
-  specify "#create_environment should create an environment object" do
+  specify "#create_environment creates an environment object" do
     environment = factory.create_environment(:foo)
-    environment.should be_an_instance_of(Taketo::Constructs::Environment)
+    expect(environment).to be_an_instance_of(Taketo::Constructs::Environment)
   end
 
-  specify "#create_server should create a server object" do
+  specify "#create_server creates a server object" do
     server = factory.create_server(:foo)
-    server.should be_an_instance_of(Taketo::Constructs::Server)
+    expect(server).to be_an_instance_of(Taketo::Constructs::Server)
   end
 
-  specify "#create_command should create a command object" do
+  specify "#create_command creates a command object" do
     command = factory.create_command(:foo)
-    command.should be_an_instance_of(Taketo::Constructs::Command)
+    expect(command).to be_an_instance_of(Taketo::Constructs::Command)
   end
 end