poolparty 0.0.4 → 0.2.6

data/spec/poolparty/net/remoter_base_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include Remote
+
+class TestRemoter
+  include RemoterBase  
+end
+
+describe "RemoterBase" do
+  describe "methods" do
+    before(:each) do
+      @tr = TestRemoter.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
+          lambda { @tr.#{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
+    describe "lists" do
+      before(:each) do
+        stub_list_of_instances_for(@tr)
+      end
+      it "should gather a list of the running instances" do
+        @tr.list_of_running_instances.map {|a| a.name }.should == ["master", "node1"]
+      end
+      it "should be able to gather a list of the pending instances" do
+        @tr.list_of_pending_instances.map {|a| a.name }.should == ["node3"]
+      end
+      it "should be able to gather a list of the terminating instances" do
+        @tr.list_of_terminating_instances.map {|a| a.name }.should == []
+      end
+      it "should be able to gather a list of the non-terminated instances" do
+        @tr.list_of_nonterminated_instances.map {|a| a.name }.should == ["master", "node1", "node3"]
+      end
+      it "should return a list of remote instances" do
+        @tr.remote_instances_list.first.class.should == RemoteInstance
+      end
+      describe "by keypairs" do
+        it "should be able to grab all the alist keypairs" do
+          @tr.list_of_instances("fake_keypair").map {|a| a[:name] }.should == ["master", "node1", "node2", "node3"]
+        end
+        it "should be able to grab all the blist keypairs" do
+          @tr.list_of_instances("blist").map {|a| a[:name] }.should == ["node4"]
+        end
+      end
+      describe "get by name" do
+        it "should fetch the instance by number " do
+          @tr.get_instance_by_number(1).name.should == "node1"
+        end
+        it "should fetch the master by number 0" do
+          @tr.get_instance_by_number(0).name.should == "master"
+        end
+        it "should not throw a fit if the node doesn't exist" do
+          lambda {@tr.get_instance_by_number(1000)}.should_not raise_error
+        end
+      end
+    end
+    
+    describe "adding custom install tasks (like set_hostname, for example)" do
+      before(:each) do
+        @master = Object.new
+        @master.stub!(:ip).and_return "192.68.0.1"
+        @tr.stub!(:master).and_return @master
+      end
+      it "should have the method custom_install_tasks" do;@tr.respond_to?(:custom_install_tasks_for).should == true;end
+      it "should have the method custom_configure_tasks" do;@tr.respond_to?(:custom_configure_tasks_for).should == true;end
+    end
+  end
+end

data/spec/poolparty/net/remoter_spec.rb

@@ -0,0 +1,191 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include PoolParty::Remote
+
+class TestClass
+  include CloudResourcer
+  include Remote
+  using :ec2
+  attr_accessor :parent
+    
+  def keypair
+    "fake_keypair"
+  end
+end
+describe "Remoter" do
+  before(:each) do
+    @cloud = cloud :app do;end
+    @tc = TestClass.new
+    @tc.parent = @cloud
+    ::File.stub!(:exists?).with("#{File.expand_path(Base.base_keypair_path)}/id_rsa-fake_keypair").and_return true
+    @sample_instances_list = [{:ip => "192.168.0.1", :name => "master"}, {:ip => "192.168.0.2", :name => "node1"}]
+  end
+  describe "ssh_string" do
+    it "should have the ssh command" do
+      @tc.ssh_string.should =~ /ssh -o StrictHostKeyChecking=no -l '#{Base.user}' -i/
+    end
+    it "should have the keypair in the ssh_string" do
+      @tc.ssh_string.should =~ /#{@tc.keypair}/
+    end
+  end
+  describe "ssh_array" do
+    it "should have StrictHostKeyChecking set to no" do
+      @tc.ssh_array.include?("-o StrictHostKeyChecking=no").should == true
+    end
+    it "should have the user set to the base user class" do
+      @tc.ssh_array.include?("-l '#{Base.user}'").should == true
+    end
+    it "should have the keypair path in the ssh_array" do
+      @tc.ssh_array.include?('-i "'+@tc.full_keypair_path+'"').should == true
+    end
+  end
+  describe "rsync_command" do
+    before(:each) do
+      @ri = Class.new
+      @ri.stub!(:ip).and_return "192.168.0.22"
+    end
+    it "should have rsync in the rsync_command" do
+      @tc.rsync_command.should == "rsync --delete -azP --exclude cache -e '#{@tc.ssh_string}'"
+    end
+    it "should be able to rsync storage commands" do
+      @tc.rsync_storage_files_to_command(@ri).should == "#{@tc.rsync_command} #{Dir.pwd}/tmp 192.168.0.22:/var/poolparty"
+    end
+  end
+  describe "launch_and_configure_master!" do
+    before(:each) do
+      @tc.stub!(:wait).and_return true
+      stub_list_from_remote_for(@tc)
+      @tc.stub!(:maximum_instances).and_return 5
+      @tc.stub!(:list_of_pending_instances).and_return []
+      @tc.stub!(:list_of_running_instances).and_return []
+      @tc.stub!(:master).and_return ris.first
+      Provisioner.stub!(:provision_master).and_return true
+    end
+    it "should have the method launch_master!" do
+      @tc.respond_to?(:launch_and_configure_master!).should == true
+    end
+    it "should test if it can start a new instance" do
+      @tc.should_receive(:can_start_a_new_instance?).once.and_return false      
+    end
+    it "should test if the master is running" do
+      @tc.should_receive(:is_master_running?).and_return false
+    end
+    it "should ask to request_launch_new_instances when the master is not running and we can start a new instance" do
+      @tc.should_receive(:request_launch_new_instances).with(1)
+      @tc.stub!(:can_start_a_new_instance?).and_return true
+      @tc.stub!(:is_master_running?).and_return false
+    end
+    it "should tell the provisioner to provision_master" do
+      Provisioner.should_receive(:provision_master).once.and_return true
+    end
+    after(:each) do
+      @tc.launch_and_configure_master!
+    end
+  end
+  describe "listing" do
+    before(:each) do
+      @loc = Base.storage_directory + "/tc-instances.list"
+      @locations = [@loc]
+      @tc.stub!(:local_instances_list_file_locations).and_return @locations
+    end
+    it "should have the method list_from_local available" do
+      TestClass.respond_to?(:list_from_local).should == true
+    end
+    it "should have the method list_from_remote available" do
+      TestClass.respond_to?(:list_from_remote).should == true
+    end
+    describe "remote" do
+      before(:each) do
+        @tc.stub!(:list_of_instances).and_return @sample_instances_list
+        @tc.stub!(:local_instances_list_file_locations).and_return [
+          "#{Base.storage_directory}/tc-instances.list"
+        ]
+      end
+      it "should call list_of_instances when trying to list from remote" do
+        TestClass.should_receive(:list_of_instances).once.and_return @sample_instances_list
+        TestClass.list_from_remote
+      end
+      it "should create a new RemoteInstance for each hashed instance" do
+        PoolParty::Remote::RemoteInstance.should_receive(:new).exactly(2).and_return @ri
+        @tc.list_from_remote
+      end
+      it "should return a string" do
+        @tc.list_from_remote.class.should == Array
+      end
+      it "should contain the master in the listing" do
+        @tc.list_from_remote.first.name.should == "master"
+        @tc.list_from_remote.first.master?.should == true
+      end
+      it "should write to the first (preferred) local instances list file location for next time" do
+        @tc.list_from_remote(:cache => true)
+        ::File.file?(@tc.local_instances_list_file_locations.first).should == true
+      end
+      after(:all) do
+        # Cleanup after ourselves
+        # FileUtils.rm @loc if ::File.file?(@loc)
+      end
+    end
+    describe "local" do
+      describe "listing" do
+        before(:each) do
+          stub_list_from_remote_for(@tc)
+          @tc.stub!(:list_of_instances).and_return([@ri])
+        end
+        it "should call local_instances_list_file_locations" do
+          @tc.should_receive(:local_instances_list_file_locations).at_least(1).and_return [@loc]
+        end
+        it "should call File.file? on the local_instances_list_file_locations locations" do        
+          File.should_receive(:file?).with(@loc).at_least(1).and_return false
+        end
+        it "should call get_working_listing_file to get the working local instance file" do
+          @tc.should_receive(:get_working_listing_file).at_least(1).and_return nil
+        end
+        after(:each) do
+          @tc.list_from_local
+        end
+      end
+      describe "with listing" do
+        before(:each) do
+          str = "master 192.168.0.1
+          node1 192.168.0.2"
+          @loc.stub!(:read).and_return str
+          TestClass.stub!(:open).and_return @loc
+          TestClass.stub!(:get_working_listing_file).and_return @loc
+          @ri = PoolParty::Remote::RemoteInstance.new({:ip => "192.168.0.1", :name => "master"})
+          PoolParty::Remote::RemoteInstance.stub!(:new).and_return @ri          
+          stub_list_from_remote_for(@tc)          
+        end
+        it "should call open on the get_working_listing_file" do
+          @tc.should_receive(:open).with(@loc).at_least(1).and_return @loc
+          @tc.list_from_local
+        end
+        it "should create a new RemoteInstance for each line in the file" do
+          PoolParty::Remote::RemoteInstance.should_receive(:new).at_least(2)
+          @tc.list_from_local
+        end
+        it "should return a string" do
+          @tc.list_from_local.class.should == Array
+        end
+        it "should have the name of the master and the ip in the list_from_local" do
+          @tc.list_from_local[0].name.should == "master"
+        end
+        it "should have name in the listing" do
+          @ri.should_receive(:name).at_least(1).and_return "node0"
+          @ri.to_s
+        end
+        it "should have the ip in the listing" do
+          @ri.should_receive(:ip).at_least(1).and_return "127.0.0.1"
+          @ri.to_s
+        end
+        it "should call to_s on the RemoteInstance instances" do          
+          PoolParty::Remote::RemoteInstance.should_receive(:new).at_least(2).and_return @ri
+          @ri.should_receive(:to_s).at_least(1)
+          @ri.to_s
+        end
+      end
+      after(:each) do
+        @tc.list_from_local
+      end
+    end
+  end
+end

data/spec/poolparty/plugins/git_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestClass
+  include PoolParty::Resources
+end
+describe "Remote Instance" do
+  before(:each) do
+    @tc = TestClass.new
+  end
+  it "should be a string" do
+    @tc.has_git(:name => "gitrepos.git", :source => "git://source.git").to_string.should =~ /file \{/
+  end
+  it "should included the flushed out options" do
+    @tc.has_git({:name => "git.git", :source => "git://source.git", :user => "finger"}).to_string.should =~ /finger@git:/
+  end
+  it "should not include the user if none is given" do
+    @tc.has_git({:name => "git.git", :source => "git://source.git"}).to_string.should =~ /git clone git:/
+  end
+  describe "in resource" do
+    before(:each) do
+      @tc.instance_eval do
+        git(:name => "gittr") do
+          source "git://source.git"
+          path "/var/www/xnot.org"
+          symlink "/var/www/xnot.org/public"
+        end
+      end
+    end
+    it "should have the path set within the resource" do
+      @tc.resource(:git).first.to_string.should =~ /file \{/
+    end
+  end
+end

data/spec/poolparty/plugins/line_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestClass
+  include PoolParty::Resources
+end
+describe "Remote Instance" do
+  before(:each) do
+    @tc = TestClass.new
+  end
+  it "should be a string" do
+    @tc.has_line_in_file("hi", "ho").to_string.should =~ /line \{/
+  end
+  it "should included the flushed out options" do
+    @tc.has_line_in_file("hi", "who", {:name => "finger"}).to_string.should =~ /name => 'finger'/
+  end
+end

data/spec/poolparty/plugins/svn_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestClass
+  include PoolParty::Resources
+end
+describe "Remote Instance" do
+  before(:each) do
+    @tc = TestClass.new
+  end
+  it "should be a string" do
+    @tc.has_svnpath({:name => "name", :source => "svn://"}).to_string.should =~ /svnserve \{/
+  end
+  it "should included the flushed out options" do
+    @tc.has_svnpath({:user => "finger"}).to_string.should =~ /user => \"finger\"/
+  end
+end

data/spec/poolparty/pool/base_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Base" do
+  before(:each) do
+    ENV.stub!(:[]).with("AWS_ACCESS_KEY_ID").and_return "KEY"
+    ENV.stub!(:[]).with("AWS_SECRET_ACCESS_ID").and_return "SECRET"
+  end
+  it "should set the environment, if not set to production" do
+    Base.environment.should == "production"
+  end
+  it "should set the user to root" do
+    Base.user.should == "root"
+  end
+  it "should set the base keypair path to ~/.ec2" do
+    Base.base_keypair_path.should == "~/.ec2"
+  end
+  it "should set the storage_directory to the tmp directory of the current working directory" do
+    Base.storage_directory.should == "#{Dir.pwd}/tmp"
+  end
+  it "should set the tmp path to tmp" do
+    Base.tmp_path.should == "tmp"
+  end
+  it "should set the remote storage path to /var/poolparty" do
+    Base.remote_storage_path.should == "/var/poolparty"
+  end
+  it "should set the fileserver_base to puppet://" do
+    Base.fileserver_base.should =~ /puppet:\/\//
+  end
+  it "should have an access key" do
+    Base.access_key.should == "KEY"
+  end
+  it "should have a secret access key" do
+    Base.secret_access_key.should == "SECRET"
+  end
+  describe "keys" do
+    it "should have an array of key_file_locations" do
+      Base.key_file_locations.class.should == Array
+    end
+    it "should test if the files exist when looking for the file" do
+      ::File.stub!(:file?).and_return false
+      ::File.stub!(:file?).with("ppkeys").and_return true
+      Base.get_working_key_file_locations.should == "ppkeys"
+    end
+    describe "with keyfile" do
+      before(:each) do
+        @keyfile = "ppkeys"
+        @str = "---
+        :access_key: KEY
+        :secret_access_key: SECRET"
+        @keyfile.stub!(:read).and_return @str
+        Base.stub!(:get_working_key_file_locations).and_return @keyfile
+        Base.stub!(:open).with(@keyfile).and_return @keyfile
+      end
+      it "should call YAML::load on the working key file" do
+        YAML.should_receive(:load).with(@str)
+        Base.load_keys_from_file
+      end
+      it "should return a hash" do
+        Base.load_keys_from_file.class.should == Hash
+      end
+      it "should be able to fetch the access key from the loaded keys" do
+        Base.load_keys_from_file[:access_key].should == "KEY"
+      end
+      it "should be able to fetch the secret_access_key from the loaded key file" do
+        Base.load_keys_from_file[:secret_access_key].should == "SECRET"
+      end
+      describe "without keyfile" do
+        before(:each) do
+          Base.stub!(:get_working_key_file_locations).and_return nil
+          ENV.stub!(:[]).with("AWS_ACCESS_KEY_ID").and_return nil
+          ENV.stub!(:[]).with("AWS_SECRET_ACCESS_ID").and_return nil
+          Base.reset!
+        end
+        it "should render the access_key nil" do
+          Base.access_key.should == nil
+        end
+        it "should render the secret_access_key as nil" do
+          Base.secret_access_key.should == nil
+        end
+      end
+    end
+    describe "storing keyfile" do
+      before(:each) do
+        @ak = "KEY"
+        @pk = "SECRET"
+        @str = "weee"
+        @hash = {:access_key => @ak, :secret_access_key => @pk}
+        Base.stub!(:access_key).and_return @ak
+        Base.stub!(:secret_access_key).and_return @pk
+        Base.stub!(:write_to_file).and_return true
+        Base.stub!(:key_file_locations).and_return ["ppkey"]
+      end
+      it "should call access_key.nil?" do
+        @ak.should_receive(:nil?).and_return false
+        @pk.should_receive(:nil?).and_return true        
+      end
+      it "should call YAML::dump" do
+        YAML.should_receive(:dump).and_return @str
+      end
+      it "should call write_to_file with the key file location" do
+        Base.should_receive(:write_to_file).with("ppkey", YAML::dump(@hash)).and_return true
+      end
+      after(:each) do
+        Base.store_keys_in_file
+      end
+    end
+  end
+end