auser-poolparty 0.2.2 → 0.2.3

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,19 @@
+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
+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

data/spec/poolparty/pool/cloud_spec.rb

@@ -0,0 +1,299 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include PoolParty::Cloud
+class TestServiceClass
+  plugin :test_service do
+    def enable
+      has_file(:name => "/etc/poolparty/lobos")
+    end                  
+  end
+end
+
+describe "Cloud" do
+  before(:each) do
+    @obj = Object.new
+    @pool = pool :just_pool do; end
+  end
+  it "should respond to the pool method outside the block" do
+    @obj.respond_to?(:cloud).should == true
+  end
+  describe "global" do
+    before(:each) do
+      @cloud1 = cloud :pop do;end
+    end
+    it "should store the cloud in the global list of clouds" do    
+      @obj.clouds.has_key?(:pop).should == true
+    end
+    it "should store the cloud" do
+      @obj.cloud(:pop).should == @cloud1
+    end
+    it "should have set the using base on intantiation to ec2" do
+      @cloud1.using_remoter?.should_not == nil
+    end
+    it "should say the remoter_base is ec2 (by default)" do
+      @cloud1.remote_base.should == PoolParty::Ec2
+    end
+  end
+  it "should return the cloud if the cloud key is already in the clouds list" do
+    @cld = cloud :pop do;end
+    @pool.cloud(:pop).should == @cld
+  end
+  describe "options" do
+    before(:each) do
+      reset!
+      @p = pool :options do
+        minimum_instances 100
+        access_key "access_key"
+        cloud :apple do          
+          access_key "cloud_access_key"
+        end
+      end
+      @c = @p.cloud(:apple)
+    end
+    it "should be able to grab the cloud from the pool" do
+      @c.should == @p.cloud(:apple)
+    end
+    it "should take the options set on the pool" do
+      @p.minimum_instances.should == 100
+    end
+    it "should take the access_key option set from the cloud" do
+      @c.access_key.should == "cloud_access_key"
+    end
+  end
+  describe "block" do
+    before(:each) do
+      reset!
+      @cloud = Cloud.new(:test, @pool) do
+        # Inside cloud block
+        keypair "fake_keypair"
+      end
+    end
+    
+    it "should be able to pull the pool from the cloud" do
+      @cloud.parent == @pool
+    end
+    it "should have services in an array" do
+      @cloud.services.class.should == Array
+    end
+    it "should have no services in the array when there are no services defined" do
+      @cloud.services.size.should == 0
+    end
+    it "should respond to a configure method" do
+      @cloud.respond_to?(:configure).should == true
+    end
+    describe "configuration" do
+      before(:each) do
+        reset!
+        @cloud2 = Cloud.new(:test, @pool) do
+          minimum_instances 1
+          maximum_instances 2
+        end
+      end
+      it "should be able to se the minimum_instances without the var" do
+        @cloud2.minimum_instances.should == 1
+      end
+      it "should be able to se the maximum_instances with the =" do
+        @cloud2.maximum_instances.should == 2
+      end
+    end
+    describe "options" do
+      it "should set the minimum_instances to 2" do
+        @cloud.minimum_instances.should == 2
+      end
+      it "should set the maximum_instances to 4" do
+        @cloud.maximum_instances.should == 4
+      end
+      it "should be able to set the minimum instances" do
+        @cloud.minimum_instances 3
+        @cloud.minimum_instances.should == 3
+      end
+      it "should be able to take a hash from configure and convert it to the options" do
+        @cloud.configure( {:minimum_instances => 1, :maximum_instances => 10, :keypair => "friend"} )
+        @cloud.keypair.should == "friend"
+      end
+      describe "minimum_instances/maximum_instances as a range" do
+        before(:each) do
+          reset!
+          @pool = pool :just_pool do
+            cloud :app do
+              instances 8..15
+            end
+          end
+          @cloud = @pool.cloud(:app)
+        end
+        it "should set the minimum based on the range" do
+          @cloud.minimum_instances.should == 8
+        end
+        it "should set the maximum based on the range set by instances" do
+          @cloud.maximum_instances.should == 15
+        end
+      end
+      describe "keypair" do
+        before(:each) do
+          reset!
+        end
+        it "should be able to define a keypair in the cloud" do
+          @c = cloud :app do
+            keypair "hotdog"
+          end
+          @c.keypair.should == "hotdog"
+        end
+        it "should take the pool parent's keypair if it's defined on the pool" do
+          pool :pool do
+            keypair "ney"
+            cloud :app do
+            end
+            cloud :group do
+            end
+          end
+          pool(:pool).cloud(:app).keypair.should == "ney"
+          pool(:pool).cloud(:group).keypair.should == "ney"
+        end
+        it "should generate a keypair based on the cloud name if none is defined" do
+          pool :pool do
+            cloud :app do
+            end
+            cloud :nickes do
+            end
+          end
+          pool(:pool).cloud(:app).keypair.should == "pool_app"
+          pool(:pool).cloud(:nickes).keypair.should == "pool_nickes"
+        end
+      end
+      describe "Manifest" do
+        before(:each) do
+          reset!
+          stub_list_from_remote_for(@cloud)
+          @cloud.instance_eval do
+            has_file(:name => "/etc/httpd/http.conf") do
+              content <<-EOE
+                hello my lady
+              EOE
+            end
+            has_gem(:name => "poolparty")
+            has_package(:name => "dummy")            
+          end
+        end
+        it "should it should have the method build_manifest" do
+          @cloud.respond_to?(:build_manifest).should == true
+        end
+        it "should have 3 resources" do
+          @cloud.add_poolparty_base_requirements
+          @cloud.number_of_resources.should == 4
+        end
+        it "should receive add_poolparty_base_requirements before building the manifest" do
+          @cloud.should_receive(:add_poolparty_base_requirements).once
+          @cloud.build_manifest
+        end
+        describe "add_poolparty_base_requirements" do
+          before(:each) do
+            reset!            
+            @cloud.instance_eval do
+              @heartbeat = nil
+            end
+            @hb = "heartbeat".class_constant.new(@cloud)
+          end
+          it "should call initialize on heartbeat (in add_poolparty_base_requirements)" do
+            @hb.class.should_receive(:new).and_return true
+            @cloud.add_poolparty_base_requirements
+          end
+          it "should call heartbeat on the cloud" do
+            @cloud.should_receive(:heartbeat).and_return true
+            @cloud.add_poolparty_base_requirements
+          end
+          it "should call Hearbeat.new" do
+            "heartbeat".class_constant.should_receive(:new).and_return @hb
+            @cloud.add_poolparty_base_requirements            
+          end
+          it "should call enable on the plugin call" do
+            @hb = "heartbeat".class_constant
+            "heartbeat".class_constant.stub!(:new).and_return @hb
+            
+            @cloud.add_poolparty_base_requirements
+            @cloud.heartbeat.should == @hb
+          end
+          describe "after adding" do
+            before(:each) do
+              stub_list_from_remote_for(@cloud)
+              @cloud.add_poolparty_base_requirements              
+            end
+            it "should add resources onto the heartbeat class inside the cloud" do
+              @cloud.services.size.should > 0
+            end
+            it "should store the class heartbeat" do              
+              @cloud.services.map {|a| a.class}.include?("heartbeat".class_constant).should == true
+            end
+            it "should have an array of resources on the heartbeat" do
+              @cloud.services.first.resources.class.should == Hash
+            end
+            describe "resources" do
+              before(:each) do
+                @cloud8 = Cloud.new(:tester, @pool) do     
+                  test_service             
+                end
+                @service = @cloud8.services.first
+                @files = @service.resource(:file)
+              end
+              it "should have a file resource" do
+                @files.first.nil?.should == false
+              end
+              it "should have an array of lines" do
+                @files.class.should == Array
+              end
+              it "should not be empty" do
+                @files.should_not be_empty
+              end
+            end
+          end
+        end
+        describe "building" do
+          before(:each) do            
+            str = "master 192.168.0.1
+            node1 192.168.0.2"
+            @sample_instances_list = [{:ip => "192.168.0.1", :name => "master"}, {:ip => "192.168.0.2", :name => "node1"}]
+            @ris = @sample_instances_list.map {|h| PoolParty::Remote::RemoteInstance.new(h, @cloud) }
+            
+            @manifest = @cloud.build_manifest
+          end
+          it "should return a string when calling build_manifest" do
+            @manifest.class.should == String
+          end
+          it "should have a comment of # file in the manifest as described by the has_file" do
+            @manifest.should =~ /file \{/
+          end
+          it "should have the comment of a package in the manifest" do
+            @manifest.should =~ /package \{/
+          end
+          it "should have the comment for heartbeat in the manifest" do
+            @manifest.should =~ /class heartbeat/            
+          end
+          it "should include the poolparty gem" do
+            @manifest.should =~ /package \{/
+          end
+          it "should include custom functions" do
+            @manifest.should =~ /define line\(\$file/
+            
+            File.open("test_manifest.pp", "w+") {|f| f << @manifest}
+          end
+          it "should include the hosts for all the listed local instances" do
+            @manifest.should =~ /host \{\n\t\t"master":/
+          end
+        end
+      end
+    end
+    
+    describe "instances" do
+      before(:each) do
+        @cloud3 = cloud :pop do;keypair "fake_keypair";end
+        stub_list_from_remote_for(@cloud3)
+      end
+      it "should respond to the method master" do
+        @cloud3.respond_to?(:master).should == true
+      end
+      it "should return a master that is not nil" do
+        @cloud3.master.should_not be_nil
+      end
+    end
+    
+  end
+end