fairchild-poolparty 1.1.3

data/spec/poolparty/net/remote_spec.rb

@@ -0,0 +1,286 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require "ftools"
+
+class PoolParty::Remote::Hype < PoolParty::Remote::RemoterBase
+  def hyper
+    "beatnick"
+  end
+  def self.describe_instances(o={})
+    []
+  end
+  def instances_list
+    []
+  end  
+end
+
+class PoolParty::Remote::HypeRemoteInstance < PoolParty::Remote::RemoteInstance
+end
+
+PoolParty::Remote.register_remote_base :Hype
+
+describe "Remote" do
+  before(:each) do
+    @cloud = cloud :test_cloud do;end
+    @tc = TestRemoterClass.new
+    @tc.stub!(:verbose).and_return false
+    setup 
+  end
+  it "should have the method 'using'" do
+    @tc.respond_to?(:using).should == true
+  end
+  it "should include the module with using" do
+    @tc.instance_eval do
+      @remote_base = nil
+    end
+    @tc.using :hype
+    @tc.remote_base.class =="Hype".class_constant
+  end
+  it "should keep a list of the remote_bases" do
+    @tc.stub!(:remote_bases).and_return [:ec2, :hype]
+    @tc.available_bases.include?(:ec2).should == true
+    @tc.available_bases.include?(:hype).should == true
+  end
+  it "should be able to register a new base" do
+    @tc.remote_bases.should_receive(:<<).with(:hockey).and_return true
+    @tc.register_remote_base("Hockey")
+  end
+  it "should not extend the module if the remote base isn't found" do
+    @tc.should_not_receive(:extend)
+    hide_output do
+      @tc.using :paper
+    end    
+  end
+  describe "when including" do
+    it "should be able to say if it is using a remote base with using_remoter?" do
+      @tc.using :hype
+      @tc.using_remoter?.should_not == nil
+    end
+    it "should ask if it is using_remoter? when calling using" do
+      @tc.should_receive(:using_remoter?).once
+      @tc.using :hype
+    end
+  end
+  describe "after using" do
+    before(:each) do
+      @hype_cloud = TestCloud.new do
+        using :hype
+      end
+      stub_list_from_remote_for(@hype_cloud, false)
+    end
+    it "should set the remote_base as an instance of the remoter base" do
+      @hype_cloud.remote_base.class.should == Hype
+    end
+    it "should now have the methods available from the module" do
+      lambda {
+        @hype_cloud.hyper
+      }.should_not raise_error
+    end
+    it "should raise an exception because the launch_new_instance! is not defined" do
+      lambda {
+           @tc.launch_new_instance!
+         }.should raise_error
+    end
+    it "should not raise an exception because instances_list is defined" do
+      @hype_cloud.remote_instances_list
+      lambda {
+        @hype_cloud.remote_instances_list
+      }.should_not raise_error
+    end
+    it "should run hyper" do
+      @hype_cloud.hype.hyper.should == "beatnick"
+    end
+  end
+  describe "methods" do
+    before(:each) do
+      @tc = TestClass.new      
+      @tc.using :ec2
+      
+      @tc.reset!
+      @tc.stub!(:minimum_instances).and_return 3
+      @tc.stub!(:maximum_instances).and_return 5
+      
+      stub_list_from_remote_for(@tc)
+      stub_list_of_instances_for(@tc)
+    end
+    describe "minimum_number_of_instances_are_running?" do
+      it "should be false if there aren't" do
+        @tc.minimum_number_of_instances_are_running?.should == false
+      end
+      it "should be true if there are" do
+        add_stub_instance_to(@tc, 8)
+        add_stub_instance_to(@tc, 9)
+        add_stub_instance_to(@tc, 10)
+        @tc.minimum_number_of_instances_are_running?.should == true
+      end
+    end
+    describe "can_shutdown_an_instance?" do
+      it "should say false because minimum instances are not running" do
+        @tc.can_shutdown_an_instance?.should == false
+      end
+      it "should say we false if only the minimum instances are running" do
+        add_stub_instance_to(@tc, 8)
+        @tc.can_shutdown_an_instance?.should == false
+      end
+      it "should say true because the minimum instances + 1 are running" do
+        add_stub_instance_to(@tc, 8)
+        add_stub_instance_to(@tc, 9)
+        @tc.can_shutdown_an_instance?.should == true
+      end
+    end
+    describe "request_launch_new_instances" do
+      it "should requiest to launch a new instance 3 times" do
+        @tc.should_receive(:launch_new_instance!).exactly(3).and_return "launched"
+        @tc.request_launch_new_instances(3)
+      end
+      it "should return a list of hashes" do
+        @tc.should_receive(:launch_new_instance!).exactly(3).and_return({:instance_id => "i-dasfasdf"})
+        @tc.request_launch_new_instances(3).first.class.should == Hash
+      end
+    end
+    describe "can_start_a_new_instance?" do
+      it "should be true because the maximum instances are not running" do
+        @tc.stub!(:list_of_pending_instances).and_return ["none"]
+        @tc.can_start_a_new_instance?.should == false
+      end
+      it "should say that we cannot start a new instance because we are at the maximum instances" do
+        add_stub_instance_to(@tc, 7)
+        add_stub_instance_to(@tc, 8)
+        add_stub_instance_to(@tc, 9)
+        @tc.can_start_a_new_instance?.should == false
+      end
+    end
+    describe "maximum_number_of_instances_are_not_running?" do
+      it "should be true because the maximum are not running" do
+        @tc.maximum_number_of_instances_are_not_running?.should == true
+      end
+      it "should be false because the maximum are running" do
+        add_stub_instance_to(@tc, 7)
+        add_stub_instance_to(@tc, 8)
+        add_stub_instance_to(@tc, 9)
+        @tc.maximum_number_of_instances_are_not_running?.should == false
+      end
+    end
+    describe "launch_minimum_number_of_instances" do
+      it "should not call minimum_number_of_instances_are_running? if if cannot start a new instance" do
+        @tc.stub!(:can_start_a_new_instance?).and_return false
+        @tc.should_not_receive(:minimum_number_of_instances_are_running?)
+        @tc.launch_minimum_number_of_instances
+      end
+      # TODO: Stub methods with wait
+    end
+    describe "request_termination_of_non_master_instance" do
+      before(:each) do
+        @inst = "last instance of the pack"
+        @inst.stub!(:instance_id).and_return "12345"
+        @tc.stub!(:nonmaster_nonterminated_instances).and_return [@inst]
+      end
+      it "should call terminate on an instance" do
+        @tc.should_receive(:terminate_instance!).with("12345").and_return true
+        @tc.request_termination_of_non_master_instance
+      end
+    end
+    describe "expansions" do
+      before(:each) do
+        setup
+        @tc.stub!(:copy_ssh_app).and_return true
+        @tc.stub!(:prepare_reconfiguration).and_return "full"
+        @tc.stub!(:wait).and_return true
+        @tc.stub!(:nonmaster_nonterminated_instances).and_return response_list_of_instances
+        @inst = stub_instance(9, "running")
+        @tc.nonmaster_nonterminated_instances.stub!(:last).and_return @inst
+        @inst.stub!(:options).and_return({:name => "red"})
+        @tc.stub!(:rsync_storage_files_to).and_return true
+        @tc.stub!(:run_command_on).and_return true
+        @tc.stub!(:full_keypair_path).and_return "true"
+      end
+      # describe "expand_cloud_if_necessary" do
+      #   before(:each) do
+      #     setup
+      #     stub_list_from_remote_for(@tc)
+      #     @ri = PoolParty::Remote::RemoteInstance.new(:ip => "127.0.0.1", :num => 1, :name => "master")
+      #     @tc.stub!(:request_launch_new_instances).and_return @ri
+      #     @tc.stub!(:can_start_a_new_instance).and_return true
+      #     @tc.stub!(:list_of_pending_instances).and_return []
+      #     @tc.stub!(:prepare_for_configuration).and_return true
+      #     @tc.stub!(:build_and_store_new_config_file).and_return true          
+      #     PoolParty::Provisioner.stub!(:provision_slaves).and_return true
+      #     @cloud.stub!(:master).and_return @ri
+      #     @cloud.stub!(:list_of_nonterminated_instances).and_return [@ri]
+      #     @cloud.stub!(:full_keypair_path).and_return "keyairs"
+      #     
+      #     @provisioner = PoolParty::Provisioner::Capistrano.new(@ri, @cloud, :ubuntu)
+      #     PoolParty::Provisioner::Capistrano.stub!(:new).and_return @provisioner
+      #     @provisioner.stub!(:install).and_return true
+      #     @provisioner.stub!(:configure).and_return true
+      #   end
+      #   it "should receive can_start_a_new_instance?" do
+      #     @tc.should_receive(:can_start_a_new_instance?).once
+      #   end
+      #   it "should see if we should expand the cloud" do
+      #     @tc.should_receive(:can_expand_cloud?).once.and_return false
+      #   end
+      #   it "should call request_launch_new_instances if we can_expand_cloud?" do
+      #     @tc.should_receive(:can_expand_cloud?).once.and_return true
+      #     @tc.should_receive(:request_launch_one_instance_at_a_time).once.and_return [{:ip => "127.0.0.5", :name => "node2"}]
+      #   end
+      #   it "should call a new slave provisioner" do
+      #     @tc.stub!(:can_expand_cloud?).once.and_return true
+      #     @provisioner.should_receive(:install).at_least(1)
+      #   end
+      #   after(:each) do
+      #     @tc.expand_cloud_if_necessary
+      #   end
+      # end
+      
+      describe "contract_cloud_if_necessary" do
+        before(:each) do
+          @tc.stub!(:request_termination_of_non_master_instance).and_return true
+          @tc.stub!(:are_any_nodes_exceeding_minimum_runtime?).and_return true
+          @tc.stub!(:wait).and_return true
+          @tc.stub!(:valid_rules?).and_return false
+          @tc.stub!(:can_shutdown_an_instance?).and_return true
+        end
+        it "should receive can_shutdown_an_instance?" do
+          @tc.should_receive(:can_shutdown_an_instance?).once
+        end
+        it "should see if we should contract the cloud" do
+          @tc.should_receive(:can_contract_cloud?).once.and_return false
+        end
+        it "should call request_termination_of_non_master_instance if we can_contract_cloud?" do
+          @tc.stub!(:can_contract_cloud?).and_return true
+          @tc.should_receive(:request_termination_of_non_master_instance).once.and_return true
+        end
+        after(:each) do
+          @tc.contract_cloud_if_necessary
+        end
+      end
+    end
+    describe "rsync_storage_files_to" do
+      before(:each) do
+        Kernel.stub!(:system).and_return true
+        @tc.extend CloudResourcer        
+        @obj = Object.new
+        @obj.stub!(:ip).and_return "192.168.0.1"
+      end
+      it "should call exec on the kernel" do
+        lambda {
+          @tc.rsync_storage_files_to(stub_instance(1))
+        }.should_not raise_error
+      end
+      describe "run_command_on" do
+        before(:each) do
+          @obj.stub!(:name).and_return "pop"
+        end
+        it "should call system on the kernel" do
+          ::File.stub!(:exists?).with("#{File.expand_path(Default.base_keypair_path)}/id_rsa-funky").and_return true
+          Kernel.should_receive(:system).with("#{@tc.ssh_string} 192.168.0.1 'ls'").and_return true
+          @tc.run_command_on("ls", @obj)
+        end
+        it "should find the instance" do
+          @tc.should_receive(:get_instance_by_number).with(0).and_return @obj
+          @tc.ssh_into_instance_number
+        end
+      end
+    end
+  end
+end

data/spec/poolparty/net/remoter_base_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestRemoteClass < PoolParty::Remote::RemoteInstance
+  include CloudResourcer
+  include PoolParty::Remote
+end
+
+describe "RemoterBase" do
+  before(:each) do
+    setup
+  end
+  describe "methods" do
+    before(:each) do
+      @tr = TestRemoteClass.new
+    end
+    %w(launch_new_instance! terminate_instance describe_instance instances_list).each do |method|
+      eval <<-EOE
+        it "should raise an exception if #{method} is not defined as a method" do
+          # pending # Weird .should raise_error
+          lambda { @tr.class.#{method} }.should raise_error
+        end
+        it "should not raise an exception if #{method} is defined as a method" do
+          lambda {
+            @tr.instance_eval do
+              def #{method}      
+              end
+            end
+            @tr.#{method}
+          }.should_not raise_error
+        end
+      EOE
+    end
+    
+  end
+end

data/spec/poolparty/net/remoter_bases/ec2_mocks_and_stubs.rb

@@ -0,0 +1,24 @@
+class TestEC2Class < Ec2
+  include CloudResourcer
+  include CloudDsl
+  include Dslify
+  
+  default_options PoolParty::Default.default_options.merge({:access_key => "Not an access key", 
+    :secret_access_key => "not a secret access key", :keypair => 'id_rsa'})
+  
+  def ami;"ami-abc123";end
+  def size; "small";end
+  def security_group; "default";end
+  def ebs_volume_id; "ebs_volume_id";end
+  def availabilty_zone; "us-east-1a";end
+  def verbose; false; end
+  def describe_instances(o={})
+    response_list_of_instances
+  end
+end
+
+class TestEc2RemoteInstance < PoolParty::Remote::Ec2RemoteInstance
+  def initialize(opts, p=TestEC2Class.new)
+    super
+  end
+end

data/spec/poolparty/net/remoter_bases/ec2_remote_instance_spec.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require File.dirname(__FILE__) + '/ec2_mocks_and_stubs.rb'
+
+include PoolParty::Remote
+# include Aska
+
+# require File.dirname(__FILE__) + '/ec2_mocks_and_stubs.rb'
+
+
+describe "Ec2RemoteInstance" do
+  before(:each) do
+    @ec2 = TestEc2RemoteInstance.new( {:name => "node3"}, TestEC2Class.new )
+    # node3 stubbed as  {:ip=>"192.168.0.3", :keypair=>"fake_keypair", :status=>"pending", :name=>"node3", :launching_time=>Time.now
+    @ec2.my_cloud.stub!(:describe_instances).and_return response_list_of_instances
+  end
+  it "should require options" do
+    lambda {TestEc2RemoteInstance.new()}.should raise_error
+  end
+  it "should have the name set in the options" do
+    @ec2.respond_to?(:name).should == false
+    @ec2.options.keys.include?(:name).should == true
+    @ec2.name.should == 'node3'
+  end
+  it "should have access to parent cloud options" do
+    @ec2.my_cloud.class.should ==  TestEC2Class
+    @ec2.my_cloud.should respond_to(:describe_instances)
+    @ec2.my_cloud.size.should == 'small'    
+  end
+  it "should have instance description hash mapped to methods" do
+    # puts  "<ol>"
+    #   @ec2.my_cloud.describe_instances.each{|i| puts "<li>#{i.inspect}</li>"}
+    # puts " </ol>"
+    @ec2.status.should == 'pending'
+    @ec2.name.should  == 'node3'
+    @ec2.ip.should == '192.168.0.3'
+    @ec2.launching_time.should_not be_nil
+    @ec2.valid?.should be_true
+  end
+  it "should not be the master" do
+    @ec2.master?.should_not be_true
+  end
+end
+
+
+
+
+
+
+describe "Remote Instance" do
+  before(:each) do
+    setup
+    @valid_hash = {:ip => "127.0.0.1", :name => "master"}
+  end
+
+  describe "configurable" do
+    it "should set the options sent in the options, overiding passed option with found instance values" do
+      @ec2 = TestEc2RemoteInstance.new(@valid_hash)
+      @ec2.found_at.should_not be_nil
+      @ec2.ip.should_not == "127.0.0.1"
+      @ec2.ip.should == "192.168.0.1"
+    end
+    it "should set the options sent by the parent" do
+      @obj = Object.new
+      @obj.stub!(:options).and_return({:dude => "tte"})
+      @ec2 = @ec2 = TestEc2RemoteInstance.new(@valid_hash, @obj)
+      @ec2.dude.should == "tte"
+    end
+    it "should not overwrite the options that are already set" do
+      @obj = Object.new
+      @obj.stub!(:options).and_return({:ip => "172.176.0.1"})
+      @ec2 = TestEc2RemoteInstance.new(@valid_hash, @obj)
+      @ec2.ip.should == "127.0.0.1"
+    end
+  end
+  it "should create a remote instance with a Hash" do
+    @ec2 = TestEc2RemoteInstance.new(@valid_hash)
+    @ec2.valid?.should == true
+  end
+  it "should not be valid if there is no ip associated" do
+    @ec2 = TestEc2RemoteInstance.new({:ip => nil})
+    @ec2.valid?.should == false
+  end
+  it "should not be valid if there is no name associated" do
+    @ec2 = TestEc2RemoteInstance.new(@valid_hash.merge({:name => nil}))
+    @ec2.valid?.should == false
+  end
+  describe "status" do
+    it "should say it is running when the status == running" do
+      TestEc2RemoteInstance.new(@valid_hash.merge(:status => "running")).running?.should == true
+    end
+    it "should say it is terminating when the status == shutting down" do
+      TestEc2RemoteInstance.new(@valid_hash.merge(:name => "node4")).terminating?.should == true
+    end
+    it "should say it is terminated when the status == terminated" do
+      TestEc2RemoteInstance.new(@valid_hash.merge(:name => "node2")).terminated?.should == true
+    end
+    it "should not say it is running when it is pending" do
+      TestEc2RemoteInstance.new(@valid_hash.merge(:name => "node3") ).running?.should == false
+    end
+  end
+  describe "methods" do
+    before(:each) do
+      @ec2 = TestEc2RemoteInstance.new(@valid_hash)
+    end
+    it "should give the elapsed time" do
+      @ec2.stub!(:launching_time).and_return(30.minutes.ago)
+      @ec2.elapsed_runtime.should be >= 1800
+    end
+    it "should be say that it is the master if the name is master" do
+      @ec2.name.should == "master"
+      @ec2.master?.should == true
+    end
+    it "should say that it is responding? if responding is not nil" do
+      @ec2.running?.should == true
+      @ec2.responding?.should == true
+      # @ec2.responding.should_not be_nil
+    end
+    it "should have the puppet_runner_command" do
+      @ec2.respond_to?(:puppet_runner_command).should == true
+    end
+    it "should return the puppet_runner_command with puppetd" do
+      @ec2.puppet_runner_command.should =~ /puppetrun/
+    end
+  end
+end

data/spec/poolparty/net/remoter_bases/ec2_spec.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+# include Remote
+require File.dirname(__FILE__) + '/ec2_mocks_and_stubs.rb'
+
+describe "ec2 remote base" do
+  before(:each) do
+    setup
+    @tr = TestEC2Class.new    
+    stub_remoter_for(@tr)
+    # @tr.stub!(:get_instances_description).and_return response_list_of_instances
+  end
+  %w(launch_new_instance! terminate_instance! describe_instance describe_instances create_snapshot).each do |method|
+    eval <<-EOE
+      it "should have the method #{method}" do
+        @tr.respond_to?(:#{method}).should == true
+      end
+    EOE
+  end
+  describe "helpers" do
+    it "should be able to convert an ec2 ip to a real ip" do
+      "ec2-72-44-36-12.compute-1.amazonaws.com".convert_from_ec2_to_ip.should == "72.44.36.12"
+    end
+    it "should not throw an error if another string is returned" do
+      "72.44.36.12".convert_from_ec2_to_ip.should == "72.44.36.12"
+    end
+    it "should be able to parse the date from the timestamp" do
+      "2008-11-13T09:33:09+0000".parse_datetime.should == DateTime.parse("2008-11-13T09:33:09+0000")
+    end
+    it "should rescue itself and just return the string if it fails" do
+      "thisisthedate".parse_datetime.should == "thisisthedate"
+    end
+  end
+  describe "launching" do
+    before(:each) do
+      @ret_hash = {:instance_id => "1", :name => "instance"}
+      @tr.ec2.stub!(:run_instances).and_return @ret_hash
+    end
+    it "should call run_instances on the ec2 Base class when asking to launch_new_instance!" do
+      # @tr.ec2.should_receive(:run_instances).and_return true
+      @tr.launch_new_instance!
+    end
+    it "should use a specific security group if one is specified" do
+      @tr.stub!(:security_group).and_return "web"
+      @tr.ec2.should_receive(:run_instances).and_return @ret_hash
+      @tr.launch_new_instance!      
+    end
+    it "should use the default security group if none is specified" do
+      @tr.ec2.should_receive(:run_instances).with(hash_including(:group_id => ['default'])).and_return @ret_hash
+      @tr.launch_new_instance!      
+    end
+    it "should get the hash response from EC2ResponseObject" do
+      EC2ResponseObject.should_receive(:get_hash_from_response).and_return @ret_hash
+      @tr.launch_new_instance! :keypair => "keys"
+    end
+  end
+  describe "terminating" do
+    it "should call terminate_instance! on ec2 when asking to terminate_instance!" do
+      @tr.ec2.should_receive(:terminate_instances).with(:instance_id => "abc-123").and_return true
+      @tr.terminate_instance!({:instance_id => "abc-123"})
+    end
+  end
+  describe "describe_instance" do
+    it "should return a default instance if called with no paramters" do
+      @tr.describe_instances(:id => "i-1234").size.should > 0
+    end
+    it "should return nil if the cloud has no instances" do
+      @tr.stub!(:describe_instances).and_return []
+      @tr.describe_instance.nil?.should == true
+    end
+  end
+  describe "get_instances_description" do  #NOTE MF: this test is sorta bogus since it is just checking what we stubbed 
+    it "should return a hash" do
+      @tr.describe_instances.class.should == Array
+    end
+    it "should call the first node master" do
+      @tr.describe_instances.first[:name].should == "master"
+    end
+    it "should call the second one node1" do
+      @tr.describe_instances[1][:name].should == "node1"
+    end
+    it "should call the third node2" do
+      @tr.describe_instances[2][:name].should == "node2"
+    end
+  end
+  describe "create_keypair" do
+    before(:each) do
+      Kernel.stub!(:system).with("ec2-add-keypair fake_keypair > #{Default.base_keypair_path}/id_rsa-fake_keypair && chmod 600 #{Default.base_keypair_path}/id_rsa-fake_keypair").and_return true
+      # @tr.stub!(:base_keypair_path).and_return "#{ENV["HOME"]}/.ec2"
+    end
+    it "should try to create the directory when making a new keypair" do
+      # FileUtils.should_receive(:mkdir_p).and_return true
+      # ::File.stub!(:directory?).and_return false
+      # @tr.create_keypair
+      pending
+      #TODO Fix with new remoter branch
+    end
+    it "should not create a keypair if the keypair is nil" do
+      pending
+      #TODO Fix with new remoter branch
+      # Kernel.should_not_receive(:system)
+      # @tr.stub!(:keypair).and_return nil
+      # @tr.create_keypair
+    end
+  end
+  describe "create_snapshot" do
+    # We can assume that create_snapshot on the ec2 gem works
+    before(:each) do
+      @tr.ec2.stub!(:create_snapshot).and_return nil
+    end
+    it "should create a snapshot of the current EBS volume" do
+      @tr.ec2.stub!(:create_snapshot).and_return {{"snapshotId" => "snap-123"}}
+      @tr.stub!(:ebs_volume_id).and_return "vol-123"
+      @tr.create_snapshot.should == {"snapshotId" => "snap-123"}
+    end
+    it "should not create a snapshot if there is no EBS volume" do
+      @tr.create_snapshot.should == nil
+    end
+  end
+end