fairchild-poolparty 1.1.3

data/spec/poolparty/poolparty/configurers/ruby_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../test_plugins/webserver'
+
+describe "Configurer" do
+  before(:each) do
+    reset!
+    @basic = File.join(File.dirname(__FILE__), "files", "ruby_basic.rb")
+    PoolParty::Pool::Pool.load_from_file @basic
+    @conf = Object.new
+  end
+  it "should not be nil" do
+    @conf.should_not be_nil
+  end
+  
+  describe "with a spec file" do
+    before(:each) do
+      @s = Script.new
+      Script.stub!(:new).and_return(@s)
+      @basic = File.join(File.dirname(__FILE__), "files", "ruby_basic.rb")
+    end
+    describe "clouds" do
+      before(:each) do
+        reset!
+        PoolParty::Pool::Pool.load_from_file @basic
+        @cloud = clouds[:app]
+      end
+      it "should contain a list of the clouds within the pool (:app)" do
+        @cloud.should_not be_nil
+      end
+      it "should set the minimum instances on the :app cloud" do
+        @cloud.minimum_instances.should == 1
+      end
+      it "should set the maximum instances on the :app cloud" do
+        @cloud.maximum_instances.should == 5
+      end
+      it "should set the keypair name on the :app cloud too" do
+        @cloud.keypair.to_s.should =~ /id_rsa/
+      end
+    end
+  end
+  
+end

data/spec/poolparty/poolparty/custom_resource_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include PoolParty::Resources
+
+describe "Custom Resource" do
+  before(:each) do
+    @cloud = cloud :name do; end
+  end
+  it "should provide custom_resource as a method" do
+    self.respond_to?(:define_resource).should == true
+  end
+  describe "defining" do
+    it "should not raise ResourceException if custom_function and custom_usage are defined" do
+      lambda {
+        define_resource(:rockstar) do
+          def has_a_line_in_file(line="line_in_file", file="file")
+            call_custom_function "line(#{file}, #{line})"
+          end
+          custom_function <<-EOF
+          define line($file, $line, $ensure = 'present') {
+            case...
+          }
+          EOF
+        end
+      }.should_not raise_error
+    end
+    describe "define_resource" do
+      before(:each) do
+        define_resource(:rockstar) do
+          def has_a_line_in_file(line="line_in_file", file="file")
+            call_custom_function "line(#{file}, #{line})"
+          end
+          custom_function <<-EOF
+          define line($file, $line, $ensure = 'present') {
+            case...
+          }
+          EOF
+        end
+      end
+      it "should create a custom resource available as a class" do
+        lambda {RockstarClass.new }.should_not raise_error
+      end
+      it "should add the method has_a_line_in_file to Resources" do
+        PoolParty::Resources.methods.include?("has_a_line_in_file").should == true
+      end
+    end
+    describe "printing" do
+      before do
+        
+        define_resource(:rockstar) do
+          def has_a_line_in_file(line="line_in_file", file="file")
+            call_custom_function "line(#{file}, #{line})"
+          end
+          custom_function <<-EOF
+          define line($file, $line, $ensure = 'present') {
+            case...
+          }
+          EOF
+        end
+        @resource = RockstarClass.new
+      end
+      it "should not be nil after it is defined" do
+        @resource.should_not be_nil
+      end
+      it "should store the custom_function in the class" do
+        RockstarClass.custom_functions.select {|a| a if a =~ /define line/}.should_not be_empty
+      end
+      it "should allow for the has_a_line_in_file to be called from within a plugin" do        
+        @resource.instance_eval do
+          has_a_line_in_file("hi", "filename")
+        end
+        @resource.resource(:call_function).first.to_string.should == "line(filename, hi)"
+      end
+      it "should be stored in an array" do
+        @resource.resource(:rockstar).class.should == Array
+      end
+    end
+  end
+end

data/spec/poolparty/poolparty/default_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Default" do
+  before(:each) do
+    # To clear out the instance variables just in case
+    Default.instance_eval do
+      @access_key = @secret_access_key = nil
+    end
+    ENV.stub!(:[]).with("HOME").and_return "/home"
+    ENV.stub!(:[]).with("AWS_ACCESS_KEY").and_return "KEY"
+    ENV.stub!(:[]).with("AWS_ACCESS_KEY_ID").and_return nil
+    ENV.stub!(:[]).with("AWS_SECRET_ACCESS_KEY").and_return "SECRET"
+  end
+  it "should set the user to root" do
+    Default.user.should == "root"
+  end
+  it "should set the base keypair path to $HOME/.ec2" do
+    Default.base_keypair_path.should =~ /\.ec2/
+  end
+  it "should set the storage_directory to the tmp directory of the current working directory" do
+    # Default.storage_directory.should =~ /var\/poolparty/
+    pending
+  end
+  it "should have the vendor_path" do
+    ::File.expand_path(Default.vendor_path).should =~ /\/vendor/
+  end
+  it "should set the tmp path to tmp" do
+    Default.tmp_path.should == "/tmp/poolparty"
+  end
+  it "should set the remote storage path to /var/poolparty" do
+    Default.remote_storage_path.should == "/var/poolparty"
+  end
+  it "should have an access key" do    
+    Default.access_key.should == "KEY"
+  end
+  it "should have a secret access key" do
+    Default.secret_access_key.should == "SECRET"
+  end
+  describe "keys" do
+    it "should have an array of key_file_locations" do
+      Default.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
+      Default.get_working_key_file_locations.should == "ppkeys"
+    end
+    it "should call get_working_key_file_locations" do
+      @str = "foo"
+      @str.stub!(:read).and_return true
+      Default.stub!(:open).and_return @str
+      Default.should_receive(:get_working_key_file_locations)
+      Default.read_keyfile
+    end
+    describe "with keyfile" do
+      before(:each) do
+        @keyfile = "ppkeys"
+        @str = "---
+        :access_key: KEY
+        :secret_access_key: SECRET"
+        @keyfile.stub!(:read).and_return @str
+        Default.stub!(:get_working_key_file_locations).and_return @keyfile
+        Default.stub!(:read_keyfile).and_return @str
+        Default.stub!(:open).and_return @str
+        Default.reset!
+      end
+      it "should call YAML::load on the working key file" do
+        YAML.should_receive(:load).with(@str)
+        Default.load_keys_from_file
+      end
+      it "should return a hash" do
+        Default.load_keys_from_file.class.should == Hash
+      end
+      it "should be able to fetch the access key from the loaded keys" do
+        Default.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
+        Default.load_keys_from_file[:secret_access_key].should == "SECRET"
+      end
+      describe "without keyfile" do
+        before(:each) do
+          Default.stub!(:get_working_key_file_locations).and_return nil
+          Default.instance_eval do
+            @access_key = @secret_access_key = nil
+          end
+          ENV.stub!(:[]).with("AWS_ACCESS_KEY").and_return nil
+          ENV.stub!(:[]).with("AWS_SECRET_ACCESS_KEY").and_return nil
+          Default.reset!
+        end
+        it "should render the access_key nil" do
+          Default.access_key.should == nil
+        end
+        it "should render the secret_access_key as nil" do
+          Default.secret_access_key.should == nil
+        end
+      end
+      describe "store_keys_in_file_for" do
+        before(:each) do
+          @obj = Class.new
+          @obj.stub!(:access_key).and_return "MYACCESSKEY"
+          @obj.stub!(:secret_access_key).and_return "MYSECRETACCESSKEY"
+          Default.stub!(:store_keys_in_file).and_return true
+          
+          Default.store_keys_in_file_for(@obj)
+        end
+        it "should take the access key from the object" do          
+          Default.access_key.should == "MYACCESSKEY"
+        end
+        it "should take the secret_access_key from the object" do
+          Default.secret_access_key.should == "MYSECRETACCESSKEY"
+        end
+      end
+    end
+    describe "storing keyfile" do
+      before(:each) do
+        @ak = "KEY"
+        @pk = "SECRET"
+        @str = "weee"
+        @hash = {:access_key => @ak, :secret_access_key => @pk}
+        Default.stub!(:access_key).and_return @ak
+        Default.stub!(:secret_access_key).and_return @pk
+        Default.stub!(:write_to_file).and_return true
+        Default.stub!(:key_file_locations).and_return ["ppkey"]
+      end
+      # it "should call access_key.nil?" do
+      #   @ak.should_receive(:nil?).once.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
+        Default.should_receive(:write_to_file).with("ppkey", YAML::dump(@hash)).and_return true
+      end
+      after(:each) do
+        Default.store_keys_in_file
+      end
+    end
+  end
+end

data/spec/poolparty/poolparty/example_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require "open-uri"
+
+describe "basic" do
+  before(:each) do
+    PoolParty.reset!
+    @example_spec_file = ::File.join(::File.dirname(__FILE__), "..", "..", "..", "examples", 'basic.rb')
+    PoolParty::Pool::Pool.load_from_file(@example_spec_file)
+    @db = clouds[:basic_db]
+    @app = clouds[:basic_app]
+  end
+  it "should have one pool called :app" do
+    pool(:application).should_not == nil
+    pools[:application].should_not == nil
+  end
+  it "should have a cloud called :app" do
+    clouds[:basic_app].should_not == nil
+  end
+  it "should have a cloud called :db" do
+    pools[:application].clouds[:basic_db].should_not == nil
+  end
+  it "should set the minimum_instances on the cloud to 2 (overriding the pool options)" do    
+    pools[:application].minimum_instances.should == 3
+    clouds[:basic_app].minimum_instances.should == 12
+  end
+  it "should set the maximum_instances on the cloud to 50" do
+    clouds[:basic_app].maximum_instances.should == 50
+  end
+  it "should set the minimum_instances on the db cloud to 3" do
+    clouds[:basic_db].minimum_instances.should == 19
+    clouds[:basic_app].minimum_instances.should == 12
+    pools[:application].minimum_instances.should ==3
+  end
+  it "should set ambiguous methods on the cloud" do
+    clouds[:basic_app].junk_yard_dogs.should == "pains"
+    clouds[:basic_db].junk_yard_dogs.should == "are bad"
+  end
+  it "should set the parent to the pool" do
+    clouds[:basic_app].parent.should == pools[:application]
+    clouds[:basic_db].parent.should == pools[:application]
+    clouds[:basic_db].parent.should_not == pools[:app]
+  end
+  it "should have the keypair matching /auser/on the db cloud " do
+    clouds[:basic_db]._keypairs.select{|a| a.filepath.match(/auser/)}
+  end
+  it "cloud should know what remoter base it is using" do
+    clouds[:basic_db].remote_base.class.should == PoolParty::Remote::Ec2
+  end
+  it "cloud should have methods from the remoter base available" do
+    clouds[:basic_db].remote_base.should_receive(:describe_instances).and_return({})
+    clouds[:basic_db].describe_instances.should == {}
+  end
+  it "should not return nil to undefined methods" do
+    lambda {clouds[:basic_db].not_a_method_that_exists_anywhere}.should raise_error
+  end
+  it "should have the keypair set for the specific cloud on top of the keypair stack" do
+    #I think this should be the behavior. mf
+    # pools[:application].clouds[:basic_db].keypairs.last.filepath.should_match(/auser/)
+  end
+end

data/spec/poolparty/poolparty/key_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Key" do
+  it "be able to be instantiated with a keyfile" do
+    lambda {Key.new("file")}.should_not raise_error
+  end
+  it "should fill in the filepath as id_rsa if no filelocation is given" do
+    Key.new.filepath.should == "id_rsa"
+  end
+  it "should provide valid to_json" do
+    lambda {Key.new("file").to_json}.should_not raise_error  end
+  describe "that exists" do
+    before(:each) do
+      @keypair = "/var/home/id_rsa"
+      ::File.stub!(:file?).with(@keypair).and_return true
+      ::File.stub!(:expand_path).with(@keypair).and_return @keypair
+      
+      @key = Key.new(@keypair)
+    end
+    it "say that the key exists" do
+      @key.exists?.should == true
+    end    
+  end
+  describe "that is not a full filepath name" do
+    before(:each) do
+      @keypair = "test_plugins/sshkey_test"
+      Dir.stub!(:pwd).and_return ::File.dirname(__FILE__)
+      
+      @key = Key.new(@keypair)
+    end
+    it "should search in known locations for the key" do
+      @key.should_receive(:search_in_known_locations).and_return nil
+      @key.full_filepath
+    end
+    it "return the full filepath when the key exists (checking last possible Dir.pwd)" do      
+      @key.full_filepath.should =~ /test_plugins\/sshkey_test/
+    end
+    it "should return the content of the keyfile when requested" do
+      @key.content.should == "-- THIS IS A TEST SSH KEY FILE --\n\n"
+    end
+  end
+end

data/spec/poolparty/poolparty/neighborhoods_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include PoolParty
+
+describe "Neighborhoods" do
+  it "should have a constant: Neighborhoods" do
+    Object.const_get("Neighborhoods").should == PoolParty::Neighborhoods
+  end
+  it "should set the schema when starting with a json string (or a hash)" do
+    n = Neighborhoods.new({:instances => "b"})
+    n.schema.nil?.should == false
+    n.schema.class.should == PoolParty::Schema
+  end
+  it "should raise an error if a new Neighborhood is created with a nil parameter" do
+    lambda {Neighborhoods.new}.should raise_error
+  end
+  it "should raise an error if there are no instances defined in the json" do
+    lambda {Neighborhoods.new({:a => "b"})}.should raise_error
+  end
+  it "should not raise a fit if there ARE instances defined" do
+    lambda{Neighborhoods.new({:instances => ["10.0.0.1"]})}.should_not raise_error
+  end
+  it "should return an instance ip when calling for the first instance" do
+    n = Neighborhoods.new(sample_instances_list)
+    n.instances.first.name.should == "master"
+    n.instances.first.ip.should == "127.0.0.1"
+    n.instances[1].ip.should == "127.0.0.2"
+  end
+  it "should return an instance ip when calling for the [0] instance" do
+    n = Neighborhoods.new(sample_instances_list)
+    n[0].ip.should == "127.0.0.1"
+    n[1].ip.should == "127.0.0.2"
+  end
+  it "should be able to try to save the instances into a json file" do
+    filepath = "/tmp/poolparty/neighborhood.json"
+    ::File.should_receive(:open).with(filepath, "w").and_return true
+    Neighborhoods.new(sample_instances_list).clump(filepath)
+  end
+  it "should be able to try to save the instances (class method) into a json file" do
+    filepath = "/tmp/poolparty/neighborhood.json"
+    ::File.should_receive(:open).with(filepath, "w").and_return true
+    Neighborhoods.clump(sample_instances_list,filepath)
+  end
+  it "should load from the default properly with the first's instance's ip" do
+    str = "[{\"name\":\"master\",\"launching_time\":\"2009/03/26 01:06:18 -0700\",\"ip\":\"127.0.0.1\"},{\"name\":\"node1\",\"launching_time\":\"2009/03/26 01:06:18 -0700\",\"ip\":\"127.0.0.2\"}]"
+    ::File.should_receive(:file?).with("/etc/poolparty/neighborhood.json").and_return true
+    ::File.stub!(:file?).and_return false
+    
+    str.stub!(:read).and_return str
+    Neighborhoods.should_receive(:open).with("/etc/poolparty/neighborhood.json").and_return str
+    
+    n = Neighborhoods.load_default
+    n[0].ip.should == "127.0.0.1"
+  end
+  context "load_default" do
+    it "should try to look in the paths to see if the neighborhood file exists" do
+      ::File.should_receive(:file?).with("/etc/poolparty/neighborhood.json").and_return true
+      ::File.stub!(:file?).and_return false
+      @file = sample_instances_list
+      @file.stub!(:read).and_return @file
+      Neighborhoods.should_receive(:open).with("/etc/poolparty/neighborhood.json").and_return @file
+      n = Neighborhoods.load_default
+      n.instances.first.ip.should == "127.0.0.1"
+    end
+  end
+end

data/spec/poolparty/poolparty/plugin_model_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/test_plugins/webserver'
+
+describe "Plugin" do
+  before(:each) do    
+    @c = cloud :test_plugin_model_cloud do
+      apachetest do                
+        enable_php
+        site("heady", {
+          :document_root => "/root"
+        })
+      end
+    end
+  end
+  describe "methods should include" do
+    it "register_plugin(plugin)" do;WebServers.respond_to?(:register_plugin).should == true;end
+  end
+  describe "registered" do
+    before(:each) do
+      @plugin = @c.apachetest
+    end
+    describe "storage" do
+      it "should be able to retrieve the plugin as a name" do
+        @c.plugin("apachetest").should_not be_nil
+      end
+    end
+    it "be of the class apachetesttestClass on the Kernel" do
+      @plugin.class.should == Kernel::ApachetestClass
+    end
+    it "should store the regsitered plugins in an array" do
+      @plugin.should_not be_nil
+    end
+    it "should have the plugin name as a method on the cloud " do
+      @c.respond_to?(:apachetest).should == true
+    end
+    describe "methods" do
+      it "should call the enable_php method when in the defininition of the cloud" do
+        @plugin.respond_to?(:enable_php).should == true
+      end
+      it "should call php = true in the enable_php" do
+        @plugin.php?.should == false
+        @plugin.enable_php
+        @plugin.php.should == true
+      end
+      it "should call the site method when in the defininition of the cloud" do
+        @plugin.respond_to?(:site).should == true
+      end
+      it "should be able to call the plugin method site" do
+        @plugin.should_receive(:virtual_host).with("hop", {:document_root => "/root"})
+        @plugin.virtual_host("hop", {:document_root => "/root"})
+      end
+    end
+  end
+end

data/spec/poolparty/poolparty/plugin_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include PoolParty::Resources
+require File.dirname(__FILE__) + '/test_plugins/webserver'
+
+describe "Plugin" do
+  describe "wrapped" do
+    before(:each) do
+      reset!
+      cloud :app_for_plugin do
+        apachetest do
+          enable_php
+          site("heady", {
+            :document_root => "/root"
+          })
+        end
+        apachetest do
+          site("boob")
+        end
+      end
+      @plugin = clouds[:app_for_plugin].apachetest
+    end
+    it "should not be empty" do
+      clouds[:app_for_plugin].apachetest.class.should == ApachetestClass
+    end
+    it "should set loaded == true" do
+      clouds[:app_for_plugin].apachetest.loaded.should == true
+    end
+    it "should have enable_php as a method" do
+      ApachetestClass.new.respond_to?(:enable_php).should == true
+    end
+    it "should set enable_php" do
+      @plugin.enable_php.should == true
+    end
+    it "should store the plugin in the clouds plugin_store" do
+      clouds[:app_for_plugin].plugin_store[0].class.should == @plugin.class
+      clouds[:app_for_plugin].apachetest
+      clouds[:app_for_plugin].plugin_store[0].class.should == @plugin.class
+    end
+  end
+end

data/spec/poolparty/poolparty/pool_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Pool" do
+  before(:each) do
+    @obj = Object.new
+  end
+  it "should respond to the pool method" do
+    @obj.respond_to?(:pool).should == true
+  end
+  it "should store the pool in the global array" do
+    @p = pool :app do
+    end
+    @obj.pools[:app].should == @p
+  end
+    
+  describe "block" do
+    before(:each) do
+      @pool = Pool.new(:test) do
+        # Inside pool block
+        Proc.new {puts "hello world"}
+      end
+    end
+    
+    it "should be able to define a cloud within the pool block" do
+      @pool.respond_to?(:cloud).should == true
+    end
+    it "should evaluate the block when creating a new pool" do
+      Proc.should_receive(:new).at_least(1)
+      Pool.new(:test) do
+        Proc.new {puts "hi"}
+      end
+    end
+    describe "plugins" do
+      after(:each) do
+        @pool.instance_eval do
+          plugin_directory "yaway"
+        end
+      end
+      it "should call Dir when the plugin directory is set" do
+        ::File.should_receive(:directory?).with("yaway").once.and_return true
+        ::File.stub!(:directory?).and_return(false)
+        Dir.should_receive(:[]).with("yaway/*/*.rb").once.and_return []        
+      end
+    end
+    describe "configuration" do
+      before(:each) do
+        reset!
+        @pool = Pool.new :test do
+          nick_nack "nails"
+          rocky_shores "ranger"
+        end
+      end
+      it "should set the plugin_directory to nails" do
+        @pool.nick_nack.should == "nails"
+      end
+      it "should set the rocky_shores to ranger" do
+        @pool.rocky_shores.should == "ranger"
+      end
+      describe "range for min/max instances" do
+        it "should be able to respond to instances" do
+          @pool.respond_to?(:instances).should == true
+        end
+        it "should be able to pass instances a range" do
+          lambda {
+            @pool.instance_eval do
+              instances 2..5
+            end
+          }.should_not raise_error
+        end
+        it "should set the minimum as the minimum_instances from the range" do
+          @pool.instance_eval do
+            instances 2..5
+          end
+          @pool.minimum_instances.should == 2
+        end
+        it "should set the maximum as the maximum_instances from the range" do
+          @pool.instance_eval do
+            instances 2..5
+          end
+          @pool.maximum_instances.should == 5
+        end
+      end
+    end  
+    describe "with clouds" do
+      before(:each) do
+        reset!
+        @pool = Pool.new :test do
+          cloud :app
+          cloud :db
+        end
+      end
+      it "should have 2 clouds in the pool when there are 2 described" do
+        @pool.clouds.size.should == 2
+      end
+      it "should be able to tel the other clouds from within one cloud" do
+        cloud(:app).other_clouds.should == [cloud(:db)]
+      end
+    end  
+  end
+end