auser-poolparty 0.1.2 → 0.2.2

data/spec/lib/poolparty/optioner_spec.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "Optioner with options" do
-  it "should be able to pull out the lonely arguments without any switches" do
-    Optioner.parse("hello".split(" ")).should == ["hello"]
-  end
-  it "should be able to pull out the lonely arguments with switches" do
-    Optioner.parse("-s 30.seconds -m hello world".split(" ")).should == ["world"]
-  end
-  it "should be able to pull out start from the the string" do
-    Optioner.parse("-c 'config/config.yml' -A 'Who' -S 'DarkwingDuck' list".split(" ")).should == ["list"]
-  end
-  it "should be able to pull out the lonely arguments with optional argument switches" do
-    Optioner.parse("-s 30 -q -n start".split(" "), %w(-q -n)).should == ["start"]
-  end
-  it "should be able to pull out the lonely arguments with optional argument switches in any order" do
-    Optioner.parse("start -s 30 -q -n".split(" "), %w(-q -n)).should == ["start"]
-  end
-  it "should be able to pull out the lonely, default arguments with optional argument switches" do
-    Optioner.parse("-s 30 -q -n start -i -v".split(" "), %w(-q -n)).should == ["start"]
-  end
-  it "should pull out the lonely arguments if none are there" do
-    Optioner.parse("-s 30 -q".split(" ")).should == []
-  end
-  it "should pull out empty array if there are no lonely arguments" do
-    Optioner.parse("-s 30".split(" ")).should == []
-  end
-  it "should pull out quoted arguments" do
-    Optioner.parse("-s 30 'ls'".split(" ")).should == ["'ls'"]
-  end
-  it "should be able to pull out a quoted argument in a sea of nonquotes" do
-    Optioner.parse("-v -k auser scp 'pkg/poolparty-0.0.9.gem'".split(" ")).should == ["scp", "'pkg/poolparty-0.0.9.gem'"]
-  end
-end

data/spec/lib/poolparty/plugin_spec.rb

@@ -1,115 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../helpers/ec2_mock'
-
-class TestPlugin < PoolParty::Plugin
-  after_define_tasks :takss
-  after_install :email_updates, :echo_hosts
-  before_configure_cloud :echo_hosts  
-  after_start :echo_start
-  
-  def echo_start(master)
-    "start"
-  end
-  def echo_hosts(caller)
-    write_out "hosts"
-  end
-  def email_updates(caller)
-    write_out "email_updates"
-  end
-  def takss(tasks)
-    "tasks"
-  end
-  def write_out(msg="")    
-  end
-end
-
-describe "Plugin" do
-  it "should define run_before method" do
-    TestPlugin.methods.include?("before_install").should == true
-  end
-  it "should define run_after method" do
-    TestPlugin.methods.include?("after_install").should == true
-  end
-  it "should define a singleton method on the plugin'ed class" do
-    Master.new.methods.include?("testplugin").should == true
-  end
-  describe "usage" do
-    before(:each) do
-      stub_option_load
-      @num = 2
-      @test, @master, @instances = PoolParty::PluginSpecHelper.define_stubs(TestPlugin, @num)
-      @instance = @instances.first
-    end
-    it "should should call echo_hosts after calling configure" do
-      @test.should_receive_at_least_once(:write_out).with("email_updates")
-      @instance.install
-    end
-    describe "installation" do
-      before(:each) do
-        Application.stub!(:install_on_load?).and_return true        
-      end
-      it "should call install on each of the instances after calling install_cloud" do
-        @test.should_receive(:email_updates).exactly(@num)
-        @test.should_receive(:echo_hosts).exactly(@num)
-        @master.install_cloud
-      end
-      it "should call email_updates after calling install" do
-        @test.should_receive(:email_updates).twice
-        @master.install_cloud
-      end
-      it "should call echo_hosts before it calls configure" do
-        @test.should_receive(:echo_hosts).at_least(1).and_return "hi"
-        @master.install_cloud
-      end
-    end
-    it "should say that it started on the master" do
-      @master.stub!(:launch_minimum_instances)
-      @master.stub!(:wait_for_all_instances_to_boot)
-      @master.stub!(:setup_cloud)
-      @test.should_receive(:echo_start).at_least(1).and_return "hi"
-      @master.start
-    end
-    it "should not call echo_hosts after if configures" do
-      @test.stub!(:echo_hosts).and_return true
-      @test.should_not_receive(:email_updates)
-      @master.configure_cloud
-    end
-    describe "user-data" do
-      it "should be able to add to the user-data with a string" do
-        @test.add_user_data("hollow")
-        Application.launching_user_data.should =~ /:user_data: hollow/
-      end
-      it "should be able to add a hash to the user-data with a hash" do
-        @test.add_user_data(:box => "box")
-        Application.launching_user_data.should =~ /:box: box/
-      end
-    end
-    describe "instance methods" do
-      before(:each) do
-        @str = "filename"
-        @str.stub!(:read).and_return "filename"
-        @test.stub!(:open).and_return @str
-      end
-      it "should try to open the file with the given filename" do
-        @test.should_receive(:open).with("filename").and_return @str
-        @test.read_config_file("filename")
-      end
-      it "should open a yaml file" do
-        YAML.should_receive(:load).with("filename").and_return ""
-        @test.read_config_file("filename")
-      end
-      describe "when reading the yaml file" do
-        before(:each) do
-          @str.stub!(:read).and_return ":username: eddie\n:password: eddie"
-        end
-        it "should parse the yaml file to a Hash" do
-          @str.should_receive(:read).and_return ":username: eddie\n:password: eddie"
-          @test.read_config_file("filename").class.should == Hash
-        end
-        it "should parse the yaml file into the proper hash" do
-          @test.read_config_file("filename").should == {:username => "eddie", :password => "eddie"}
-        end
-      end
-    end
-  end
-end

data/spec/lib/poolparty/poolparty_spec.rb

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module TestMonitor
-  module Master      
-  end
-  module Remote
-  end    
-end
-
-describe "Application options" do
-  before(:each) do
-    stub_option_load
-  end
-  it "should be able to say that the plugin directory is the current directory" do
-    File.basename(PoolParty.plugin_dir).should == "plugins"
-  end
-  it "should not load plugins if the directory doesn't exist" do
-    File.stub!(:directory?).with(plugin_dir).and_return false
-    Dir.should_not_receive(:[])
-    PoolParty.load_plugins
-  end
-  it "should load the plugins if the directory exists" do
-    File.stub!(:directory?).with(plugin_dir).and_return true
-    Dir.should_receive(:[]).and_return %w()
-    PoolParty.load_plugins
-  end
-  describe "monitors" do
-    before(:each) do
-      PoolParty.reset!
-    end
-    it "should load a monitor and store it into the registered monitor's array" do
-      PoolParty.register_monitor TestMonitor
-      PoolParty.registered_monitors.include?(TestMonitor).should == true
-    end
-    it "should be able to ask if the monitor is a registered monitor" do
-      PoolParty.register_monitor TestMonitor
-      PoolParty.registered_monitor?(TestMonitor).should == true
-    end
-    it "should not register a monitor more than once" do
-      PoolParty::Monitors.should_receive(:extend).once
-      PoolParty.register_monitor TestMonitor
-      PoolParty.register_monitor TestMonitor
-    end
-    it "should try to load from the user directory before the root lib directory" do
-      File.should_receive_at_least_once(:directory?).with("#{user_dir}/monitors").and_return true
-      Dir.should_receive(:[]).with("#{user_dir}/monitors/*").and_return([])
-      PoolParty.load_app
-    end
-    it "should try to load from the root directory if the user directory monitors don't exist" do
-      File.should_receive_at_least_once(:directory?).with("#{user_dir}/monitors").and_return false
-      Dir.should_receive(:[]).with("#{Application.root_dir}/lib/poolparty/monitors/*").and_return([])
-      PoolParty.load_app
-    end
-    it "should load the monitors and the plugins" do
-      PoolParty.should_receive(:load_plugins)
-      PoolParty.should_receive(:load_monitors)
-      PoolParty.load_app
-    end
-  end
-end

data/spec/lib/poolparty/provider_spec.rb

@@ -1,74 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../helpers/ec2_mock'
-
-describe "Provider" do
-  before(:each) do
-    stub_option_load
-    Sprinkle::Script.stub!(:sprinkle).and_return true
-    @ips = ["127.0.0.1"]
-    Master.stub!(:cloud_ips).and_return @ips
-  end
-  it "should load the packages in the package directory" do
-    Dir.should_receive(:[]).and_return []
-    Provider.new.load_packages
-  end
-  it "should load the packages defined in the user directory" 
-  describe "running" do
-    describe "server packages" do
-      before(:each) do
-        @provider = Provider.new
-        @str = "new"
-        @str.stub!(:process).and_return true
-        @provider.stub!(:set_start_with_sprinkle).and_return @str
-        Provider.stub!(:new).and_return @provider
-        Master.stub!(:cloud_ips).and_return ["127.0.0.1"]
-      end
-      it "should use the loaded packages to install" do
-        @provider.should_receive(:load_packages).and_return []
-        @provider.install_poolparty
-      end
-      it "should load the install script when installing" do
-        @provider.should_receive(:set_start_with_sprinkle).and_return true
-        @provider.install_poolparty
-      end
-      describe "user packages" do
-        describe "defining" do
-          before(:each) do
-            @stdout = nil
-            Provider.define_custom_package(:sprinkle) do
-              package :sprinkle, :provides => :package do
-                description 'Sprinkle'
-                apt %w( sprinkle )
-              end
-            end
-          end
-          it "should be able to define user packages with blocks and pass those into the user_packages" do
-            Provider.user_packages.size.should == 1
-          end
-          it "should define the user packages as Sprinkle::Package::Package" do
-            Provider.user_packages.first.class.should == Sprinkle::Package::Package
-          end
-        end
-        describe "defining custom packages" do
-          before(:each) do
-            Provider.reset!
-            @provider.stub!(:set_start_with_sprinkle).and_return true
-            @provider.stub!(:process).and_return true
-            @proc = lambda {package :custom do;description 'custom packages';end}
-            Provider.define_custom_package(:custom)
-          end
-          it "should be able to define a custom package with a name" do
-            Provider.user_packages.size.should > 1
-          end
-          it "should have the name of the custom package built in" do
-            Provider.user_install_packages.sort {|a,b| a.to_s <=> b.to_s }.should == [:custom, :sprinkle]
-          end
-        end
-        it "should not run the installer if we are in testing mode" do
-          @provider.should_not_receive(:process)
-          hide_output { Provider.install_poolparty(true) }
-        end
-      end
-    end
-  end
-end

data/spec/lib/poolparty/remote_instance_spec.rb

@@ -1,178 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../helpers/ec2_mock'
-
-class RemoteInstance
-  def scp(src="", dest="", opts={})
-    "true"
-  end
-  # Ssh into the instance or run a command, if the cmd is set
-  def ssh(cmd="")
-    "true"
-  end
-end
-describe "remote instance" do
-  before(:each) do
-    stub_option_load
-    @instance = RemoteInstance.new({:ip => "127.0.0.1", :instance_id => "i-abcdef1"})
-    @instance.stub!(:ssh).and_return true
-    @instance.stub!(:scp).and_return true
-    Kernel.stub!(:system).and_return true
-    
-    @master = Master.new
-  end
-    
-  describe "in general" do
-    it "should set the ip upon creation" do
-      @instance.ip.should == "127.0.0.1"
-    end
-    it "should be able to tell if it is the master" do
-      @instance.master?.should == true
-    end
-    it "should be able to say that it isn't secondary?" do
-      @instance.secondary?.should_not be_true
-    end
-    it "should be able to build itself a haproxy_resources_entry" do
-      @instance.haproxy_resources_entry.should =~ /node0/
-    end
-    it "should be able to build a list of the heartbeat nodes" do
-      @instance.node_entry.should =~ /node0/
-    end
-    it "should be able to build a hosts_entry for self" do
-      @instance.hosts_entry.should =~ /node0/
-    end
-    it "should be able to have local_hosts_entry with 127.0.0.01" do
-      @instance.local_hosts_entry.should =~ /127\.0\.0\.1/
-    end
-    it "should have a heartbeat_entry" do
-      @instance.heartbeat_entry.should =~ /127\.0\.0\.1/
-      @instance.heartbeat_entry.should =~ /#{Application.managed_services}/
-    end
-    it "should be able to build a haproxy_entry" do
-      @instance.haproxy_entry.should =~ /server/
-    end
-  end
-    describe "new configuration style (build scripts)" do
-      before(:each) do
-        @tempfile = Tempfile.new("/tmp")
-        Kernel.stub!(:system).and_return true
-        stub_option_load
-      end
-      describe "configure tasks" do
-        it "should move_hostfile" do
-          @instance.should_receive(:change_hostname).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should configure_master" do
-          @instance.should_receive(:configure_master).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should move_config_file" do
-          @instance.should_receive(:move_config_file).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should mount_s3_drive" do
-          @instance.should_receive(:mount_s3_drive).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should update_plugin_string" do
-          @instance.should_receive(:update_plugin_string).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should setup_pems" do
-          @instance.should_receive(:setup_pems).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should configure_authkeys" do
-          @instance.should_receive(:configure_authkeys).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should configure_resource_d" do
-          @instance.should_receive(:configure_resource_d).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should setup_haproxy" do
-          @instance.should_receive(:setup_haproxy).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should configure_heartbeat" do
-          @instance.should_receive(:configure_heartbeat).once.and_return ""
-          @instance.configure_tasks
-        end
-        it "should run user_tasks" do
-          @instance.should_receive(:user_tasks).once.and_return ""
-          @instance.configure_tasks
-        end
-      end      
-      describe "with a public ip" do
-        before(:each) do
-          Application.stub!(:public_ip).and_return "127.0.0.1"
-          Master.stub!(:new).and_return @master
-          @master.stub!(:nodes).and_return [@instance]
-        end
-        it "should call configure on the instances after configure_cloud" do
-          @instance.should_receive(:configure).and_return true
-          @master.configure_cloud
-        end
-        it "should run associate_address if there is a public_ip set in the Application.options" do
-          @instance.should_receive(:associate_address_with).with(Application.public_ip, @instance.instance_id).at_least(1).and_return true
-          @master.configure_cloud
-        end
-        it "should not run associate_address_with if the public_ip is empty" do
-          Application.stub!(:public_ip).and_return ""
-          @instance.should_not_receive(:associate_address_with)
-          @master.configure_cloud
-        end
-        it "should untar and move plugin directories around" do
-          dir = File.basename Application.plugin_dir
-          @instance.update_plugin_string.should == "if [ -f ~/tmp/plugins.tar.gz ]; then mkdir -p plugins && tar -zxf ~/tmp/plugins.tar.gz -C plugins; fi"          
-        end
-    end
-  end  
-  describe "in failover" do
-    before(:each) do
-      Master.stub!(:new).and_return @master
-    end
-    it "should be able to become master " do
-      @instance.stub!(:configure).and_return true
-      @instance.number = 1
-      @instance.become_master
-      @instance.number.should == 0
-    end
-    it "should reconfigure after becoming master" do      
-      @master.should_receive(:configure_cloud).and_return true
-      @instance.should_receive(:configure).and_return true
-      @instance.become_master
-    end
-    it "should say that it is the master after becoming master" do
-      @instance.stub!(:configure).and_return true
-      @instance.become_master
-      @instance.master?.should == true
-    end
-    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the server is the master" do
-      @instance.is_not_master_and_master_is_not_running?.should == false
-    end
-    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the master server is responding" do
-      Master.stub!(:is_master_responding?).and_return true
-      @instance.is_not_master_and_master_is_not_running?.should == false
-    end
-    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the master server is responding" do
-      @instance.stub!(:master?).and_return false
-      Master.stub!(:is_master_responding?).and_return false
-      @instance.is_not_master_and_master_is_not_running?.should == true
-    end
-    
-    describe "when installing the poolparty software" do
-      before(:each) do
-        @instance.stub!(:run).and_return false
-      end
-      it "should be able to detect if the stack_installed? == false" do
-        @instance.stack_installed?.should == false
-      end
-      it "should set the stack_installed? once installed" do
-        @instance.install
-        @instance.stack_installed?.should == true
-      end
-    end
-    
-  end
-end