auser-poolparty 1.2.12 → 1.3.0

data/spec/poolparty/core/float.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Float" do
-  it "should be able to round to the nearest integer" do
-    10.95.round_to(1).should == 11
-  end
-  it "should be able to get the ceiling" do
-    10.54.ceil_to(1).should == 10.6
-  end
-  it "should be able to get the floor" do
-    10.14.floor_to(1).should == 10.1
-  end
-end

data/spec/poolparty/core/hash_spec.rb

@@ -1,83 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Hash" do
-  before(:each) do
-    @a = {:a => "10", :b => "20", :c => "30"}
-  end
-  it "should preserve the contents of the original hash when safe_merge'ing" do
-    a = {:a => "10", :b => "20"}
-    b = {:b => "30", :c => "40"}
-    a.safe_merge(b).should == {:a => "10", :b => "20", :c => "40"}
-  end
-  it "should preserve the contents of the original hash when safe_merge!'ing" do
-    a = {:a => "10", :b => "20"}
-    b = {:b => "30", :c => "40"}
-    a.safe_merge!(b)
-    a.should == {:a => "10", :b => "20", :c => "40"}
-  end
-  it "should be able to turn itself into an open struct" do
-    @a.to_os.class.should == MyOpenStruct
-  end
-  it "should respond to to_hash" do
-    @a.to_os.respond_to?(:to_hash).should == true
-  end
-  it "should be able to turn itself into an open struct with the method to_hash on the object" do
-    @a.to_os.to_hash.should == @a
-  end
-  describe "method_missing" do
-    it "should be able to call a key on the hash as a method" do
-      {:first_name => "bob", :last_name => "frank"}.first_name.should == "bob"
-    end
-    it "should return nil if there is no key set in the hash" do
-      lambda {{:first_name => "bob", :last_name => "frank"}.neighbor}.should raise_error
-    end
-  end
-  describe "choose" do
-    before(:each) do
-      @selected_hash = @a.choose {|k,v| k if k == :a}
-    end
-    it "should return a hash when choosing" do
-      @selected_hash.class.should == Hash
-    end
-    it "should only have the key a (choos)" do
-      @selected_hash.keys.should == [:a]
-    end
-  end
-  #TODO: deprecate
-  # describe "extract!" do
-  #   before(:each) do
-  #     @rejected_hash = @a.extract! {|k,v| k == :a }
-  #   end
-  #   it "should have a reject with the keys" do
-  #     @rejected_hash.keys.should == [:a]
-  #   end
-  #   it "should return the old array with the other keys" do
-  #     @a.keys.sort.should == [:b, :c]
-  #   end
-  #   it "should not throw a fit with an empty hash" do
-  # {}.extract!
-  #       lambda {
-  #       {}.extract!
-  #     }.should_not raise_error
-  #   end
-  # end
- 
-  describe "append" do
-    before(:each) do
-      @hash = {:game => "token", :required => "for_play"}
-    end
-    it "should not destroy an option salready on the hash" do
-      @hash.append(:required => "to_play")[:game].should == "token"
-    end
-    it "should change the entry to an array if it already exists" do
-      @hash.append(:game => "coin")[:game].class.should == Array
-    end
-    it "should append the other hash's key to the end of the array" do
-      @hash.append(:game => "coin")[:game][-1].should == "coin"
-    end
-    it "should change the hash with the append(bang) option" do
-      @hash.append!(:game => "coin")
-      @hash[:game][-1].should == "coin"
-    end
-  end
-end

data/spec/poolparty/core/kernel_spec.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Kernel extensions" do
-  before(:each) do
-    @obj = Object.new
-  end
-  it "should eval the string into time" do
-    @obj.should_receive(:sleep).once.with(10.seconds).and_return true
-    @obj.wait "10.seconds"
-  end
-end
-describe "Object extensions" do
-  before(:each) do
-    @klass = Object.new
-    @klass.instance_eval <<-EOE
-      def hello
-        puts "hello"
-      end
-    EOE
-  end
-  it "should be able to get a list of the defined methods on the object" do
-    @klass.my_methods.should == ["hello"]
-  end
-end

data/spec/poolparty/core/object_spec.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Object" do
-  it "should respond to to_os" do
-    Object.new.respond_to?(:to_os).should == true
-  end
-end

data/spec/poolparty/core/ordered_hash_spec.rb

@@ -1,48 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Ordered Hash" do
-  before(:each) do
-    @oh = OrderedHash.new
-    @oh["var1"] = 10
-    @oh["var2"] = 2
-    @oh[:var3] = 3
-    @oh["var4"] = 4
-  end
-  it "should stay in order in enumeration (keys)" do
-    @oh.collect {|k,v| k }.should == ["var1", "var2", :var3, "var4"]
-  end
-  it "should stay in order in enumeration (values)" do
-    @oh.collect {|k,v| v }.should == [10,2,3,4]
-  end
-  it "should be able to be pulled out with the hash convention" do
-    @oh['var1'].should == 10
-    @oh['var2'].should == 2
-    @oh[:var3].should == 3
-    @oh["var4"].should == 4
-  end
-  it "should retain order in a merge" do
-    @oh.merge!(:var5 => 5)
-    @oh.collect {|k,v| v }.should == [10,2,3,4,5]
-  end
-  it "should retain order in a non-descructive merge" do
-    @oh = @oh.merge(:var5 => 5)
-    @oh.collect {|k,v| v }.should == [10,2,3,4,5]
-  end
-  it "should keep the keys in order too!" do
-    @oh.keys.should == ["var1", "var2", :var3, "var4"]
-  end
-  it "should have values method" do
-    @oh.values.should === [10,2,3,4]
-  end
-  it "should to_json" do
-    @oh[:arr] = [1,2,3]
-    @oh.to_json.should == "{\"var1\":10,\"var2\":2,\"var3\":3,\"var4\":4,\"arr\":[1,2,3]}"
-  end
-  it "PoolParty Key" #do
-#       @oh[:key] = [Key.new, Key.new('path/to/nowhere')]
-#       expected=<<JSO
-#  {\"var1\":10,\"var2\":2,\"var3\":3,\"var4\":4,\"key\":[{\"basename\":\"id_rsa\",\"full_filepath\": \"/etc/poolparty/id_rsa\"},{\"basename\":\"path/to/nowhere\",\"full_filepath\": \"/etc/poolparty/path/to/nowhere\"}]}
-# JSO
-#       @oh.to_json.should == expected.strip
-  # end
-end

data/spec/poolparty/core/string_spec.rb

@@ -1,145 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "String" do
-  describe "hasherize" do
-    before(:each) do
-      @str=<<-EOE
-hello world
-you are my
-hero
-      EOE
-      @hashed = @str.hasherize(%w(hello you))
-    end
-    it "should return a hash from the string" do
-      @hashed.class.should == Hash
-    end
-    it "should have hello as a key" do
-      @hashed.has_key?(:hello).should == true
-    end
-    describe "arrayable" do
-      it "should be able to turn the string into an array" do
-        @str.arrayable.class.should == Array
-      end
-    end    
-  end
-  before(:each) do
-    @string = "string"
-    @string.stub!(:bucket_objects).and_return([])
-  end
-  # Dumb test
-  it "should be able to call bucket_objects on itself" do
-    @string.should_receive(:bucket_objects)
-    @string.bucket_objects
-  end
-  describe "with config replacements" do
-    it "should replace those syms in the string" do
-      ("new :port" ^ {:port => 100}).should == "new 100"
-    end
-    it "should be able to detect vars" do
-      @string=<<-EOC
-listen web_proxy 127.0.0.1::client_port
-\tserver web1 127.0.0.1::port weight 1 minconn 3 maxconn 6 check inter 30000
-      EOC
-      (@string ^ {:client_port => 3000, :port => 3001}).should ==<<-EOO
-listen web_proxy 127.0.0.1:3000
-\tserver web1 127.0.0.1:3001 weight 1 minconn 3 maxconn 6 check inter 30000
-      EOO
-    end
-  end
-  describe "collect_each_line_with_index" do
-    before(:each) do
-      @longer_string = "hot\npotato\nthrough\nthe\nwindow"
-    end
-    it "should run the same code on the entire string" do
-      @longer_string.collect_each_line_with_index do |str, index|
-        "#{index}_#{str}"
-      end.should == ["0_hot", "1_potato", "2_through", "3_the", "4_window"]
-    end
-  end
-  describe "String" do
-    before(:each) do
-      @str =<<-EOS
-        echo 'hi'
-        puts 'hi'
-      EOS
-    end
-    it "should be able to convert a big string with \n to a runnable string" do
-      @str.runnable.should == "echo 'hi' &&         puts 'hi'"
-    end
-  end
-  describe "Constantize" do
-    before(:each) do
-      @str = "prok"
-    end
-    it "should be able to turn itself into constant" do
-      @str.class_constant.should == PoolPartyProk
-    end
-    it "should turn itself into a class constant" do
-      @str.class_constant.class.should == Class
-    end
-    it "should not recreate the constant if it exists" do
-      Class.should_receive(:new).once.and_return Class.new
-      @str.class_constant
-      @str.class_constant
-    end
-    it "should set the parent class when sent with the superclass" do
-      "stirer".class_constant(String).ancestors[1].should == String
-    end
-    it "should be able to create a module into a constant" do
-      @str.module_constant.should == ProkModule
-    end
-    it "should turn itself into a class constant" do
-      @str.module_constant.class.should == Module
-    end
-    it "should create the module on preserved module constant" do
-      Module.should_receive(:new).once
-      @str.preserved_module_constant.should == Prok
-      @str.preserved_module_constant
-      @str.preserved_module_constant
-    end
-    describe "with a block" do
-      before(:each) do
-        @str = "nack"
-      end
-      it "should be able to yield a block on the module and set methods" do
-        "tippy".module_constant do
-          def tippy
-            puts "etc"
-          end
-        end
-        Class.new.extend("tippy".module_constant).methods.include?("tippy").should == true
-      end
-    end
-  end
-  describe "top level class" do
-    it "should be able to get the top level class" do
-      "PoolParty::Resources::File".top_level_class.should == "file"
-    end
-    it "should turn file into a class" do
-      "file".camelcase.should == "File"
-    end
-  end
-  
-  describe "sanitize" do
-    it "should remove the periods from the string" do
-      "xnot.org".sanitize.should == "xnotorg"
-    end
-    it "should be able to turn a string into a dir safe name" do
-      "Rails app/".dir_safe.should == "rails_app/"
-    end
-  end
-  describe "nice_runnable" do
-    before(:each) do
-      @tasks = ["ls -l", "echo 'hello'"]
-    end
-    it "should turn an array into a string" do
-        @tasks.nice_runnable.class.should == String
-    end
-    it "should add \\n between the commands" do
-      @tasks.nice_runnable.should == "ls -l \n echo 'hello'"
-    end
-    it "should strip out excess lines" do
-      (@tasks << []).nice_runnable.should == "ls -l \n echo 'hello'"
-    end
-  end
-end

data/spec/poolparty/core/time_spec.rb

@@ -1,49 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Time" do
-  describe "parsing" do
-    it "should be able to parse seconds" do
-      10.seconds.should == 10
-    end
-    it "should be able to parse minutes" do
-      80.minutes.should == 4800
-    end
-    it "should be able to parse hours" do
-      2.hours.should == 7200
-    end
-    it "should be able to parse days" do
-      1.days.should == 86400
-    end
-    it "should be able to parse weeks" do
-      2.weeks.should == 1209600
-    end
-  end
-  describe "from" do
-    it "should be able to find minutes ago" do
-      10.minutes.ago.to_s.should == (Time.new - 10.minutes).to_s
-    end
-    it "should be able to find from now" do
-      10.minutes.from_now.to_s.should == (Time.now + 10.minutes).to_s
-    end
-  end
-  describe "time_ago string" do
-    it "should be able to turn 10.minutes.ago into a string" do
-      10.minutes.time_ago.should == "10 minutes ago"
-    end
-    it "should be able to turn 30.seconds into Less than a minute ago" do
-      30.seconds.time_ago.should == "Less than a minute ago"
-    end
-    it "should turn 1.year.ago into 1 year ago" do
-      2.years.time_ago.should == "2 years ago"
-    end
-    it "should turn 35.days into 35 days ago" do
-      29.days.time_ago.should == "4 weeks ago"
-    end
-    it "should turn 45.days into 1 month ago" do
-      45.days.time_ago.should == "1 month ago"
-    end
-    it "should turn 70.days into 2 months ago" do
-      70.days.time_ago.should == "2 months ago"
-    end
-  end
-end

data/spec/poolparty/dependencies_spec.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-include PoolParty
-describe "Dependencies" do
-  it "should have a method called dedependencies" do
-    Dependencies.respond_to?(:dependencies).should == true
-  end
-  it "should have a package(file) method" do
-    Dependencies.respond_to?(:package).should == true
-  end
-end

data/spec/poolparty/dependency_resolver/chef_resolver_spec.rb

@@ -1,105 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "ChefResolver" do
-  before :all do
-    reset!
-    @cloud_reference_hash = {
-      :options => {:name => "dog", :keypair => "bob", :users => ["ari", "michael"]},
-      :resources => [
-        {:name => "/etc/motd", :content => "Welcome to the cloud", :pp_type => "file"},
-        {:name => "/etc/profile", :content => "profile info", :pp_type => "file"},
-        {:name => "/var/www", :pp_type => "directory"}
-      ],
-      :services => {
-        :apache => [{
-          :options => {:listen => "8080"},
-          :resources => [
-            {:name => "/etc/apache2/apache2.conf", :pp_type => "file", :template => "/absolute/path/to/template", :content => "rendered template string"}
-          ],
-          :services => {}
-        }]
-      }
-    }
-  end
-  
-  it "throw an exception if not given a hash" do
-    pending # odd error with should raise_error
-    # lambda { PoolParty::ChefResolver.compile }.should raise_error
-  end
-  it "accept a hash" do
-    lambda { PoolParty::ChefResolver.compile(@cloud_reference_hash)}.should_not raise_error
-  end
-  
-  describe "when passed a valid cloud hash" do
-    
-    before(:all) do
-      @dr = ChefResolver.new(@cloud_reference_hash)
-      @compiled = @dr.compile
-    end
-    
-    # describe "variables" do
-    #   it "output options as Chef variables" do
-    #     @compiled.should match(/bob/)
-    #     @compiled.instance_of?(String).should == true
-    #     @compiled.should match(/\$users = \[ \".* \]/)
-    #   end
-    # end
-    
-    describe "resources" do
-      it "should print resources in the proper layout" do
-        @compiled.should =~ /template "\/etc\/motd" do/
-      end
-    end
-    
-    describe "services" do
-      it "should print apache into a class definition" do
-        # puts "<pre>#{@compiled.to_yaml}</pre>"
-        # @compiled.should =~ /class apache \{/
-        pending
-      end
-    end
-    
-  end
-  
-  describe "with a cloud" do
-    before(:each) do
-      class ChefResolverSpec
-      end
-      @cloud = cloud :hope do
-        keypair "bob"
-        has_file :name => "/etc/motd", :content => "Welcome to the cloud"        
-        has_file :name => "/etc/profile", :content => "profile info"        
-        has_directory :name => "/var/www"
-        has_file :name => "/var/www/index.html", :content => "profile info", :requires => get_directory("/var/www")
-        # has_package :name => "bash"        
-        # parent == cloud
-        apache do
-          # parent == apache
-          listen "8080"
-          has_file :name => "/etc/apache2/apache2.conf", :template => "#{::File.dirname(__FILE__)}/../fixtures/test_template.erb", :friends => "bob"
-          has_exec :command => "ls /etc/apache2"
-        end
-      end
-      @properties = @cloud.to_properties_hash
-      
-      # puts "<pre>#{@cloud_reference_hash.to_yaml}\n\n#{@properties.to_yaml}</pre>"
-      @dr = ChefResolver.new(@properties)
-      @compiled = @dr.compile
-      # puts "---\n#{@compiled}"
-    end
-    it "should compile to a string" do
-      # puts "<pre>#{@compiled.to_yaml}</pre>"
-      @compiled.class.should == String
-    end
-    it "should include apache class" do
-      @compiled.should =~ /# apache/
-    end
-    it "should require the file to have the directory (written as file)" do
-      @compiled.should =~ /directory \"\/var\/www\" do/
-    end
-    after(:all) do
-      # ::FileUtils.rm_rf "/tmp/poolparty/dr_configure/"
-    end
-  end
-  
-end

data/spec/poolparty/dependency_resolver/dependency_resolver_cloud_extensions_spec.rb

@@ -1,131 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class DependencyResolverCloudExtensionsSpecBase < PoolParty::PoolPartyBaseClass
-  include Dslify
-end
-
-# files, directories, etc...
-class DependencyResolverSpecTestResource
-  include Dslify
-  include PoolParty::DependencyResolverResourceExtensions
-  
-  dsl_methods :name, :template, :content
-end
-
-# plugins, base_packages
-class DependencyResolverSpecTestService < DependencyResolverCloudExtensionsSpecBase
-  dsl_methods :listen
-end
-
-# clouds, duh
-class DependencyResolverSpecTestCloud < DependencyResolverCloudExtensionsSpecBase
-  dsl_methods :keypair, :name
-end
-
-# class JunkClassForDefiningPlugin
-#   apache_plugin do
-#     default_options(
-#       :listen => 80
-#     )
-#     def loaded(o={},&block)
-#     end
-#   end  
-# end
-
-describe "Resolution spec" do
-  before(:each) do
-    @apache_file = DependencyResolverSpecTestResource.new
-    @apache_file.name = "/etc/apache2/apache2.conf"
-    @apache_file.template = "/absolute/path/to/template"
-    @apache_file.content = "rendered template string"
-    
-    @apache = DependencyResolverSpecTestService.new :apache_file
-    @apache.listen = "8080"
-    @apache.resources[:file] = []
-    @apache.resources[:file] << @apache_file
-        
-    @cloud = DependencyResolverSpecTestCloud.new :cloud
-    @cloud.keypair = "bob"
-    @cloud.name = "dog"
-    
-    (@cloud.resources[:apache] ||= []) << @apache
-
-    @cloud_file_motd = DependencyResolverSpecTestResource.new
-    @cloud_file_motd.name = "/etc/motd"
-    @cloud_file_motd.content = "Welcome to the cloud"
-    
-    @cloud_file_profile = DependencyResolverSpecTestResource.new
-    @cloud_file_profile.name = "/etc/profile"
-    @cloud_file_profile.content = "profile info"
-        
-    @cloud.resources[:file] = []
-    @cloud.resources[:file] << @cloud_file_motd
-    @cloud.resources[:file] << @cloud_file_profile
-    
-    @cloud_directory_var_www = DependencyResolverSpecTestResource.new
-    @cloud_directory_var_www.name = "/var/www"
-    
-    @cloud.resources[:directory] = []
-    @cloud.resources[:directory] << @cloud_directory_var_www    
-  end
-  it "be able to call to_properties_hash" do
-    @cloud.respond_to?(:to_properties_hash).should == true
-  end
-  describe "to_properties_hash" do
-    it "should output a hash" do
-      @cloud.to_properties_hash.class.should == Hash
-    end
-    it "should have resources on the cloud as an array of hashes" do      
-      @cloud.to_properties_hash[:resources].class.should == Array
-    end
-  end
-
-  describe "defined cloud" do
-    before(:each) do
-      reset!
-      ::File.stub!(:basename).and_return "template"
-      @file = "Hello <%= friends %> on port <%= port %>"
-      @file.stub!(:read).and_return @file
-      Template.stub!(:open).and_return @file
-
-      cloud :dog_for_test do
-        keypair "bob"
-        has_file :name => "/etc/motd", :content => "Welcome to the cloud"
-        has_file :name => "/etc/profile", :content => "profile info"
-        has_directory :name => "/var/www"
-        has_package :name => "bash"
-        # parent == nil
-        apache do
-          # parent == TestClass
-          # puts "<pre>#{parent}</pre> on <pre>#{context_stack.map {|a| a.class }.join(", ")} from #{self.class}</pre>"
-          listen "8080"
-          has_file :name => "/etc/apache2/apache2.conf", 
-                   :template => "/absolute/path/to/template", 
-                   :friends => "bob", 
-                   :render_as => :erb
-        end
-      end
-      @cloud = clouds[:dog_for_test]
-      @properties = @cloud.to_properties_hash
-      @apache_key = @properties[:resources].select {|hsh| hsh[:name] =~ /apache/ }.first
-    end
-    
-    it "should have the method to_properties_hash on the cloud" do
-      @cloud.respond_to?(:to_properties_hash).should == true
-    end
-    it "should have resources on the cloud as an array of hashes" do
-      # puts "<pre>#{cloud(:dog).to_properties_hash.to_yaml}</pre>"
-      @properties[:resources].class.should == Array
-    end
-    it "contain content in the template's hash" do
-      @apache_key.resources.select_with_hash(:pp_type => "file").first[:content].should == "Hello bob on port 8080"
-    end
-    it "contain the files in a hash" do
-      # puts "<pre>#{@properties.to_yaml}</pre>"
-      @properties[:resources].select {|a| a[:name] == "/etc/motd" }.first.nil?.should == false
-    end
-    it "contain the directory named /var/www" do
-      @properties[:resources].select {|a| a[:name] == "/var/www" }.first.nil?.should == false
-    end
-  end
-end

data/spec/poolparty/dependency_resolver/dependency_resolver_spec.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Resolution spec" do
-  before(:each) do
-    @dr = DependencyResolver.new({})
-    DependencyResolver.stub!(:new).and_return @dr
-  end
-  
-  it "should have a tree_hash associated with the resolver" do
-    @dr.properties_hash.should == {}
-  end
-  it "runs compile on a new object when calling compile on the class" do    
-    @dr.should_receive(:compile)
-    DependencyResolver.compile(hash)
-  end
-end