auser-poolparty 1.0.0 → 1.1.1

data/spec/poolparty/poolparty/{base_spec.rb → default_spec.rb}

@@ -1,53 +1,56 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe "Base" do
+describe "Default" do
   before(:each) do
     # To clear out the instance variables just in case
-    Base.instance_eval do
+    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
-    Base.user.should == "root"
+    Default.user.should == "root"
   end
   it "should set the base keypair path to $HOME/.ec2" do
-    Base.base_keypair_path.should =~ /\.ec2/
+    Default.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 =~ /tmp/
+    # 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
-    Base.tmp_path.should == "/tmp/poolparty"
+    Default.tmp_path.should == "/tmp/poolparty"
   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:\/\//
+    Default.remote_storage_path.should == "/var/poolparty"
   end
-  it "should have an access key" do
-    Base.access_key.should == "KEY"
+  it "should have an access key" do    
+    Default.access_key.should == "KEY"
   end
   it "should have a secret access key" do
-    Base.secret_access_key.should == "SECRET"
+    Default.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
+      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
-      Base.get_working_key_file_locations.should == "ppkeys"
+      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
-      Base.stub!(:open).and_return @str
-      Base.should_receive(:get_working_key_file_locations)
-      Base.read_keyfile
+      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
@@ -56,39 +59,39 @@ describe "Base" do
         :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!(:read_keyfile).and_return @str
-        Base.stub!(:open).and_return @str
-        Base.reset!
+        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)
-        Base.load_keys_from_file
+        Default.load_keys_from_file
       end
       it "should return a hash" do
-        Base.load_keys_from_file.class.should == Hash
+        Default.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"
+        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
-        Base.load_keys_from_file[:secret_access_key].should == "SECRET"
+        Default.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
-          Base.instance_eval 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
-          Base.reset!
+          Default.reset!
         end
         it "should render the access_key nil" do
-          Base.access_key.should == nil
+          Default.access_key.should == nil
         end
         it "should render the secret_access_key as nil" do
-          Base.secret_access_key.should == nil
+          Default.secret_access_key.should == nil
         end
       end
       describe "store_keys_in_file_for" do
@@ -96,15 +99,15 @@ describe "Base" do
           @obj = Class.new
           @obj.stub!(:access_key).and_return "MYACCESSKEY"
           @obj.stub!(:secret_access_key).and_return "MYSECRETACCESSKEY"
-          Base.stub!(:store_keys_in_file).and_return true
+          Default.stub!(:store_keys_in_file).and_return true
           
-          Base.store_keys_in_file_for(@obj)
+          Default.store_keys_in_file_for(@obj)
         end
         it "should take the access key from the object" do          
-          Base.access_key.should == "MYACCESSKEY"
+          Default.access_key.should == "MYACCESSKEY"
         end
         it "should take the secret_access_key from the object" do
-          Base.secret_access_key.should == "MYSECRETACCESSKEY"
+          Default.secret_access_key.should == "MYSECRETACCESSKEY"
         end
       end
     end
@@ -114,10 +117,10 @@ describe "Base" do
         @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"]
+        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
@@ -126,10 +129,10 @@ describe "Base" 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
+        Default.should_receive(:write_to_file).with("ppkey", YAML::dump(@hash)).and_return true
       end
       after(:each) do
-        Base.store_keys_in_file
+        Default.store_keys_in_file
       end
     end
   end

data/spec/poolparty/poolparty/example_spec.rb

@@ -3,26 +3,58 @@ require "open-uri"
 
 describe "basic" do
   before(:each) do
-    @example_dir = ::File.join(::File.dirname(__FILE__), "..", "..", "..", "examples")
-    reset!
-    PoolParty::Script.inflate open(@example_dir + "/basic.rb").read
+    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(:app).should_not be_nil
+    pool(:application).should_not == nil
+    pools[:application].should_not == nil
   end
   it "should have a cloud called :app" do
-    pool(:app).cloud(:app).should_not be_nil
+    clouds[:basic_app].should_not == nil
   end
   it "should have a cloud called :db" do
-    pool(:app).cloud(:db).should_not be_nil
+    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
-    pool(:app).cloud(:app).minimum_instances.should == 2
+  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 5" do
-    pool(:app).cloud(:app).maximum_instances.should == 5
+  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
-    pool(:app).cloud(:db).minimum_instances.should == 3
+    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

@@ -1,54 +1,44 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-include PoolParty::Resources
 require File.dirname(__FILE__) + '/test_plugins/webserver'
 
 describe "Plugin" do
-  before(:each) do
-    @p = pool :poolpartyrb do
-      cloud :app do
-        apache do                
-          enable_php
-          site("heady", {
-            :document_root => "/root"
-          })
-        end
+  before(:each) do    
+    @c = cloud :test_plugin_model_cloud do
+      apachetest do                
+        enable_php
+        site("heady", {
+          :document_root => "/root"
+        })
       end
     end
-    @c = @p.cloud(:app)
   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 = "apache".class_constant.new(@c)
+      @plugin = @c.apachetest
     end
     describe "storage" do
-      it "should store the plugin in a Hash on the pool" do
-        @c.plugins.class.should == Hash
-      end
       it "should be able to retrieve the plugin as a name" do
-        @c.plugin("apache").should_not be_nil
+        @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 set the pool on the plugin" do
-      @plugin.parent.should == @c
-    end
     it "should have the plugin name as a method on the cloud " do
-      @c.respond_to?(:apache).should == true
+      @c.respond_to?(:apachetest).should == true
     end
     describe "methods" do
-      before(:each) do
-        reset!
-      end
       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_not == true
+        @plugin.php?.should == false
         @plugin.enable_php
         @plugin.php.should == true
       end

data/spec/poolparty/poolparty/plugin_spec.rb

@@ -4,109 +4,38 @@ include PoolParty::Resources
 require File.dirname(__FILE__) + '/test_plugins/webserver'
 
 describe "Plugin" do
-  before(:each) do
-    reset_resources!
-  end
   describe "wrapped" do
     before(:each) do
       reset!
-      pool :poolpartyrb do      
-        cloud :app do
-          apache do
-            enable_php
-            site("heady", {
-              :document_root => "/root"
-            })
-          end
-        end      
-      end
-      @p = pool :poolpartyrb
-      @c = @p.cloud(:app)
-    end
-
-    it "should allow access to the pool on the cloud" do
-      @c.parent.should == @p
-    end
-    describe "instance" do
-      before(:each) do        
-        @plugin = @c.apache
-      end
-      it "should not be empty" do
-        @plugin.class.should == PoolPartyApacheClass
-      end
-      it "should have access to the cloud's container" do
-        @plugin.parent.should == @c
-      end
-      it "should have enable_php as a method" do
-        @plugin.respond_to?(:enable_php).should == true
-      end
-      describe "after eval'ing" do
-        before(:each) do
-          @plugin.instance_eval do
-            enable_php
-            has_gempackage(:name => "aska")
-          end
-        end
-        it "should call enable_php on the class" do
-          @plugin.php.should == true
-        end
-        it "should have resources attached to it" do
-          @plugin.resources.class.should == Hash
-        end
-        it "should have an array of gem resources" do
-          @plugin.resource(:gempackage).class.should == Array
-        end
-        it "should have 1 gem in the resources defined" do
-          @plugin.resource(:gempackage).size.should == 1
-        end
-        it "should have the gem named aska in the gem resource" do
-          @plugin.get_resource(:gempackage, "aska").name.should == "aska"
+      cloud :app_for_plugin do
+        apachetest do
+          enable_php
+          site("heady", {
+            :document_root => "/root"
+          })
         end
-        it "should have its resources visible to its parent" do
-          @plugin.parent = @c
-          @c.resources
-        end
-      end
-      describe "before eval'ing" do
-        before(:each) do
-          reset!
-          @plugin = "apache".class_constant.new(@c)
-        end
-        it "should call has_line_in_file" do
-          @plugin.should_receive(:php).and_return true
-        end
-        it "should call site" do
-          @plugin.should_receive(:site).with("frank").and_return true
-        end
-        after do
-          @plugin.instance_eval do
-            enable_php
-            site("frank")
-          end
+        apachetest do
+          site("boob")
         end
       end
+      @plugin = clouds[:app_for_plugin].apachetest
     end
-    describe "DSL" do
-      it "should have a cloud method from within the plugin" do
-        @plugin.respond_to?(:cloud).should == true
-      end
-      it "should get a hold of the containing cloud" do
-        @plugin.cloud.should == @c
-      end
-      describe "enable" do
-        before(:each) do
-          reset!
-          @plugin = PoolParty::Plugin::Plugin.new
-          Kernel::PoolPartyApacheClass.stub!(:new).and_return @plugin          
-        end
-        it "should call enable on calling realize! when there is no block included" do
-          @plugin.should_receive(:enable).at_least(1).and_return true
-          @cloud = cloud :app do
-            apache
-          end
-          @cloud.realize_plugins!
-        end
-      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

@@ -36,7 +36,9 @@ describe "Pool" do
           plugin_directory "yaway"
         end
       end
-      it "should call Dir when the plugin directory is set" do        
+      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