automateit 0.70923

data/spec/unit/plugins_spec.rb

@@ -0,0 +1,253 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+#===[ stub classes ]====================================================# {{{
+
+class MyManager < AutomateIt::Plugin::Manager
+  alias_methods :mymethod
+
+  def mymethod(opts)
+    dispatch(opts)
+  end
+end
+
+class MyManager::BaseDriver < AutomateIt::Plugin::Driver
+  # Is abstract by default
+end
+
+class MyManager::AnotherBaseDriver < MyManager::BaseDriver
+  abstract_driver
+end
+
+class MyManager::MyUnsuitableDriver < MyManager::BaseDriver
+  # +suitability+ method deliberately not implemented to test errors
+
+  depends_on \
+    :files => ["non_existent_file"],
+    :directories => ["non_existent_directory"],
+    :programs => ["non_existent_program"]
+
+  def unavailable_method
+    _raise_unless_available
+  end
+end
+
+class MyManager::MyUnimplementedDriver < MyManager::BaseDriver
+  def available?
+    true
+  end
+
+  def suitability(method, *args)
+    return 50
+  end
+
+  # +mymethod+ method deliberately not implemented to test errors
+end
+
+
+class MyManager::MyFirstDriver < MyManager::BaseDriver
+  depends_on :directories => ["/"]
+
+  def suitability(method, *args)
+    case method
+    when :mymethod
+      return args.first[:one] == 1 ? 10 : 0
+    else
+      return -1
+    end
+  end
+
+  def mymethod(opts)
+    opts[:one]
+  end
+end
+
+class MyManager::MySecondDriver < MyManager::BaseDriver
+  def available?
+    true
+  end
+
+  def suitability(method, *args)
+    case method
+    when :mymethod
+      return args.first[:one] == 1 ? 5 : 0
+    else
+      return -1
+    end
+  end
+
+  def mymethod(opts)
+    opts[:one]
+  end
+end
+
+class MyManagerSubclass < AutomateIt::Plugin::Manager
+  abstract_manager
+end
+
+class MyManagerSubclassImplementation < MyManagerSubclass
+end
+# }}}
+#===[ rspec ]===========================================================
+
+describe "AutomateIt::Plugin::Manager" do
+  before(:all) do
+    @x = AutomateIt::Plugin::Manager
+  end
+
+  it "should have plugins" do
+    @x.classes.should include(MyManager)
+  end
+
+  it "should not have abstract plugins" do
+    @x.classes.should_not include(MyManagerSubclass)
+  end
+
+  it "should have implementations of abstract plugins" do
+    @x.classes.should include(MyManagerSubclassImplementation)
+  end
+end
+
+describe "MyManager" do
+  before(:all) do
+    @m = MyManager.new
+  end
+
+  it "should have drivers" do
+    for driver in [MyManager::MyUnsuitableDriver, MyManager::MyFirstDriver, MyManager::MySecondDriver]
+      @m.class.driver_classes.should include(driver)
+    end
+  end
+
+  it "should inherit common instance mehtods" do
+    @m.should respond_to(:log)
+  end
+
+  it "should access drivers by index keys" do
+    @m[:my_first_driver].should be_a_kind_of(MyManager::MyFirstDriver)
+    @m.drivers[:my_first_driver].should be_a_kind_of(MyManager::MyFirstDriver)
+  end
+
+  it "should have aliased methods" do
+    @m.class.aliased_methods.should include(:mymethod)
+  end
+
+  it "should respond to aliased methods" do
+    @m.should respond_to(:mymethod)
+  end
+
+  it "should have an interpreter instance" do
+    @m.interpreter.should be_a_kind_of(AutomateIt::Interpreter)
+  end
+
+  # XXX Plugins spec -- Instantiating a Plugin outside of an Interpreter should retain consistent object references
+#  it "should inject interpreter instance into drivers" do
+#    @m.interpreter.object_id.should == m[:my_first_driver].interpreter.object_id
+#  end
+end
+
+describe "MyManager's drivers" do
+  before(:all) do
+    @m = MyManager.new
+  end
+
+  it "should be available" do
+    MyManager::MyFirstDriver.new.available?.should be_true
+  end
+
+  it "should fail on unavailable methods" do
+    lambda{ MyManager::MyUnsuitableDriver.new.unavailable_method }.should
+      raise_error(NotImplementedError, /non_existent/)
+  end
+
+  it "should have a token" do
+    MyManager::MyFirstDriver.token.should == :my_first_driver
+  end
+
+  it "should consider good drivers to be suitable" do
+    MyManager::MyFirstDriver.new.suitability(:mymethod, :one => 1).should > 0
+  end
+
+  it "should not consider drivers that don't declare their suitability" do
+    MyManager::MyUnsuitableDriver.new.suitability(:mymethod, :one => 1).should < 0
+  end
+
+  it "should determine suitability levels" do
+    rs = @m.driver_suitability_levels_for(:mymethod, :one => 1)
+    rs[:my_first_driver].should == 10
+    rs[:my_second_driver].should == 5
+    rs[:my_unsuitable_driver].should be_nil
+  end
+
+  it "should choose suitable driver" do
+    @m.driver_for(:mymethod, :one => 1).should be_a_kind_of(MyManager::MyFirstDriver)
+  end
+
+  it "should not choose driver if none match" do
+    lambda { @m.driver_for(:mymethod, :one => 9) }.should raise_error(NotImplementedError)
+  end
+
+  it "should dispatch_to suitable driver" do
+    @m.dispatch_to(:mymethod, :one => 1).should == 1
+    @m.mymethod(:one => 1).should == 1
+  end
+
+  it "should fail dispatch_to if no suitable driver is found" do
+    lambda { @m.dispatch_to(:mymethod, :one => 9) }.should raise_error(NotImplementedError)
+    lambda { @m.mymethod(:one => 9) }.should raise_error(NotImplementedError)
+  end
+
+  it "should dispatch_to to default driver regardless of suitability" do
+    @m.default(:my_unimplemented_driver)
+    lambda { @m.dispatch_to(:mymethod, :one => 1) }.should raise_error(NoMethodError)
+    lambda { @m.mymethod(:one => 1) }.should raise_error(NoMethodError)
+  end
+
+  it "should have an interpreter instance" do
+    MyManager::MyFirstDriver.new.interpreter.should be_a_kind_of(AutomateIt::Interpreter)
+  end
+
+  it "should share object instances" do
+    @m[:my_first_driver].should == @m.interpreter.my_manager[:my_first_driver]
+  end
+end
+
+describe AutomateIt::Interpreter do
+  before(:all) do
+    @a = AutomateIt::Interpreter.new
+  end
+
+  it "should instantiate plugins" do
+    @a.should respond_to(:plugins)
+    @a.plugins.should include(:my_manager)
+  end
+
+  it "should expose plugin instance aliases" do
+    @a.should respond_to(:my_manager)
+    @a.my_manager.class.should == MyManager
+  end
+
+  it "should expose plugin method aliases" do
+    @a.should respond_to(:mymethod)
+    lambda {@a.mymethod(:one => 1)}.should_not raise_error
+  end
+
+  it "should inject itself into plugins" do
+    @a.my_manager.interpreter.should == @a
+  end
+
+  it "should inject itself into drivers" do
+    @a.my_manager[:my_first_driver].interpreter.should == @a
+  end
+
+  it "should not see abstract managers" do
+    @a.plugins.should_not include(MyManagerSubclass.token)
+  end
+
+  it "should not see abstract drivers" do
+    @a.my_manager.drivers.should_not include(MyManager::AnotherBaseDriver.token)
+  end
+
+  it "should not see base drivers" do
+    @a.my_manager.drivers.should_not include(MyManager::BaseDriver.token)
+  end
+end

data/spec/unit/tag_manager_spec.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+describe "AutomateIt::TagManager", :shared => true do
+  before(:all) do
+    @a = AutomateIt.new
+    @a.address_manager.should_receive(:hostnames).any_number_of_times.and_return(["kurou", "kurou.foo"])
+    @a.platform_manager.setup(
+      :default => :struct,
+      :struct => {
+        :os => "mizrahi",
+        :arch => "realian",
+        :distro => "momo",
+        :version => "s100",
+      }
+    )
+    @m = @a.tag_manager
+  end
+
+  it "should have tags" do
+    @a.tags.should be_a_kind_of(Enumerable)
+  end
+
+  it "should have tags that include tag for hostname" do
+    @a.tags.should include("kurou")
+  end
+
+  it "should have tag for short hostname" do
+    @a.tagged?("kurou").should be_true
+  end
+
+  it "should have tag for long hostname" do
+    @a.tagged?("kurou.foo").should be_true
+  end
+
+  it "should have tag for OS" do
+    @a.tagged?("mizrahi").should be_true
+  end
+
+  it "should have tag for OS/arch" do
+    @a.tagged?("mizrahi_realian").should be_true
+  end
+
+  it "should have tag for distro/release" do
+    @a.tagged?("momo_s100").should be_true
+  end
+
+  it "should have tag for a role" do
+    @a.tagged?("apache_servers").should be_true
+  end
+
+  it "should match a symbol query" do
+    @a.tagged?(:apache_servers).should be_true
+  end
+
+  it "should match a string query" do
+    @a.tagged?("apache_servers").should be_true
+  end
+
+  it "should not match unknown symbol keys" do
+    @a.tagged?(:foo).should be_false
+  end
+
+  it "should not match unknown string keys" do
+    @a.tagged?("foo").should be_false
+  end
+
+  it "should match an AND query" do
+    @a.tagged?("kurou && apache_servers").should be_true
+  end
+
+  it "should match an OR query" do
+    @a.tagged?("kurou || apache_servers").should be_true
+  end
+
+  it "should match a grouped AND and OR query" do
+    @a.tagged?("(kurou || apache_servers) && momo_s100").should be_true
+  end
+
+  it "should not match AND with unknown keys" do
+    @a.tagged?("kurou && foo").should be_false
+  end
+
+  it "should not match OR with unknown keys" do
+    @a.tagged?("foo && bar").should be_false
+  end
+
+  it "should query tags for a specific host" do
+    @a.tagged?("proxy_servers", "kurou").should be_false
+    @a.tagged?("proxy_servers", "akane.foo").should be_true
+    @a.tagged?("proxy_servers", "akane").should be_true
+  end
+
+  it "should append tags" do
+    @a.tagged?("magic").should be_false
+    @a.tags << "magic"
+    @a.tagged?("magic").should be_true
+  end
+
+  it "should find tags for a host using an array" do
+    @a.tags_for(["kurou"]).should include("apache_servers")
+  end
+
+  it "should find tags for a host using a string" do
+    @a.tags_for("akane.foo.bar").should include("proxy_servers")
+  end
+
+  it "should find hosts with a tag" do
+    hosts = @a.hosts_tagged_with("apache_servers")
+    hosts.should include("kurou")
+    hosts.should include("shirou")
+    hosts.should_not include("akane")
+  end
+
+  it "should find using negative queries" do
+    @a.tagged?("akane").should be_false
+    @a.tagged?("!akane").should be_true
+    @a.tagged?("!akane && !proxy_servers").should be_true
+  end
+
+  it "should include group aliases" do
+    @a.hosts_tagged_with("all_servers").sort.should == ["kurou", "shirou", "akane.foo"].sort
+  end
+
+  it "should exclude hosts from groups" do
+    @a.hosts_tagged_with("apache_servers_except_kurou").should == ["shirou"]
+  end
+
+  it "should exclude groups from groups" do
+    @a.hosts_tagged_with("all_servers_except_proxy_servers").sort.should == ["kurou", "shirou"].sort
+  end
+end
+
+describe "AutomateIt::TagManager::Struct" do
+  it_should_behave_like "AutomateIt::TagManager"
+
+  before(:all) do
+    @m.setup(
+      :default => :struct,
+      :struct => {
+        "apache_servers" => [
+          "kurou",
+          "shirou",
+        ],
+        "proxy_servers" => [
+          "akane.foo",
+        ],
+        "all_servers" => [
+          "@apache_servers",
+          "@proxy_servers",
+        ],
+        "apache_servers_except_kurou" => [
+          "@apache_servers",
+          "!kurou",
+        ],
+        "all_servers_except_proxy_servers" => [
+          "@all_servers",
+          "!@proxy_servers",
+        ],
+      }
+    )
+  end
+end
+
+describe "AutomateIt::TagManager::YAML" do
+  it_should_behave_like "AutomateIt::TagManager"
+
+  before(:all) do
+    @m[:yaml].should_receive(:_read).with("demo.yml").and_return(<<-EOB)
+      <%="apache_servers"%>:
+        - kurou
+        - shirou
+      proxy_servers:
+        - akane.foo
+      all_servers:
+        - @apache_servers
+        - @proxy_servers
+      apache_servers_except_kurou:
+        - @apache_servers
+        - !kurou
+      all_servers_except_proxy_servers:
+        - @all_servers
+        - !@proxy_servers
+    EOB
+    @m.setup(
+      :default => :yaml,
+      :file => "demo.yml"
+    )
+  end
+end

data/spec/unit/template_manager_erb_spec.rb

@@ -0,0 +1,137 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+describe "AutomateIt::TemplateManager::ERB" do
+  before(:all) do
+    @a = AutomateIt.new(:verbosity => Logger::WARN)
+    @m = @a.template_manager
+    @d = @m[:erb]
+
+    @source = "source_for_template"
+    @target = "target_for_template"
+  end
+
+  after(:each) do
+    if File.exists?(@target)
+      File.unlink(@target)
+      raise "A write wasn't intercepted by the mocks! Removing file and giving up."
+    end
+  end
+
+  it "should render a string template" do
+    @d.should_receive(:_exists?).once.with(@target).and_return(false)
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(:text => "my template content", :to => @target).should be_true
+  end
+
+  it "should render a file template" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(false)
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target).should be_true
+  end
+
+  it "should render with local variables" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(false)
+    @d.should_receive(:_read).once.with(@source).and_return("hello <%=entity%>")
+    @d.should_receive(:_write).once.with(@target, "hello world").and_return(true)
+
+    @a.render(@source, @target, :locals => {:entity => "world"}).should be_true
+  end
+
+  it "should render when the template was updated" do
+    timestamp = Time.now
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_read).once.with(@target).and_return("my old content")
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_mtime).once.with(@source).and_return(timestamp+1)
+    @d.should_receive(:_mtime).once.with(@target).and_return(timestamp)
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target, :check => :timestamp).should be_true
+  end
+
+  it "shouldn't render when the template wasn't updated" do
+    timestamp = Time.now
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_mtime).once.with(@source).and_return(timestamp)
+    @d.should_receive(:_mtime).once.with(@target).and_return(timestamp+1)
+
+    @a.render(@source, @target, :check => :timestamp).should be_false
+  end
+
+  it "should render when the template's dependencies are updated" do
+    timestamp = Time.now
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_read).once.with(@target).and_return("my old content")
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_mtime).once.with("foo").and_return(timestamp+1)
+    @d.should_receive(:_mtime).once.with(@source).and_return(timestamp)
+    @d.should_receive(:_mtime).once.with(@target).and_return(timestamp)
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target, :check => :timestamp, :dependencies => ["foo"]).should be_true
+  end
+
+  it "shouldn't render when the template's dependencies weren't updated" do
+    timestamp = Time.now
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_mtime).once.with("foo").and_return(timestamp)
+    @d.should_receive(:_mtime).once.with(@source).and_return(timestamp)
+    @d.should_receive(:_mtime).once.with(@target).and_return(timestamp+1)
+
+    @a.render(@source, @target, :check => :timestamp, :dependencies => ["foo"]).should be_false
+  end
+
+  it "should render when forced even if the template wasn't updated" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_read).once.with(@target).and_return("my old content")
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target, :check => :timestamp, :dependencies => ["foo"], :force => true).should be_true
+  end
+
+  it "should render if told to check the existence of output and it doesn't exist" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(false)
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target, :check => :exists).should be_true
+  end
+
+  it "shouldn't render if told to check the existence of output and it exists" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+
+    @a.render(@source, @target, :check => :exists).should be_false
+  end
+
+  it "should render if told to compare if the output is different" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_read).once.with(@target).and_return("my old content")
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+    @d.should_receive(:_write).once.with(@target, "my template content").and_return(true)
+
+    @a.render(@source, @target, :check => :compare).should be_true
+  end
+
+  it "shouldn't render if told to compare if the output is the same" do
+    @d.should_receive(:_exists?).once.with(@source).and_return(true)
+    @d.should_receive(:_exists?).once.with(@target).and_return(true)
+    @d.should_receive(:_read).once.with(@target).and_return("my template content")
+    @d.should_receive(:_read).once.with(@source).and_return("my template content")
+
+    @a.render(@source, @target, :check => :compare).should be_false
+  end
+end