rudy 0.8.1 → 0.8.2

data/test/01_mixins/10_hash_test.rb

@@ -1,25 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-
-  class Case_01_Mixins < Test::Unit::TestCase
-    
-    def one_level; {:empty=>1}; end
-    def two_levels; {:l1 => {:empty=>1}}; end
-    def three_levels; { :l1 => { :l2 => {:empty=>1, :empty=>1} } }; end
-    def six_levels; {:l1 => {:l2 => {:l3 => {:l4 => {:l5 => {}, :empty=>1}, :empty=>1}}}}; end
-     
-    context "#{name}_10 Hash" do
-      
-      should "(10) should calculate deepest point" do
-        assert_equal one_level.deepest_point, 1
-        assert_equal two_levels.deepest_point, 2
-        assert_equal three_levels.deepest_point, 3
-        assert_equal six_levels.deepest_point, 6
-      end
-      
-    end
-    
-  end
-  
-end

data/test/10_config/00_setup_test.rb

@@ -1,20 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-
-  class Case_10_Config < Test::Unit::TestCase
-    include Rudy::Huxtable
-    
-    @@logger = STDERR #StringIO.new
-    @@zone = @@global.zone.to_s
-    
-    context "#{name}_00 Setup" do
-      should "(00) have class variables setup" do
-        stop_test !@@global.is_a?(Rudy::Global), "We don't have global (#{@@global})"
-        stop_test !@@config.is_a?(Rudy::Config), "We don't have an instance of Rudy::Config (#{@@config})"
-      end
-    end
-    
-    
-  end
-end

data/test/10_config/30_machines_test.rb

@@ -1,69 +0,0 @@
-
-module Rudy::Test
-  class Case_10_Config
-    
-    context "#{name}_30 Machines" do
-      
-      should "(10) have accounts.aws" do
-        stop_test !@@config.accounts.is_a?(Rudy::Config::Accounts), "Not an Accounts class"
-        
-        stop_test @@config.accounts.aws.accountnum.nil?, "No account"
-        stop_test @@config.accounts.aws.accesskey.nil?, "No accesskey"
-        stop_test @@config.accounts.aws.secretkey.nil?, "No secretkey"
-      end
-      
-      should "(20) have defaults" do
-        assert @@config.defaults.is_a?(Rudy::Config::Defaults), "Not a Defaults class"
-        assert !@@config.defaults.region.nil?, "No default region"
-        assert !@@config.defaults.zone.nil?, "No default zone"
-        assert !@@config.defaults.environment.nil?, "No default environment"
-        assert !@@config.defaults.role.nil?, "No default role"
-      end
-      
-      should "(30) have machines" do
-        assert @@config.machines.is_a?(Rudy::Config::Machines), "Not a Machines class"
-        assert !@@config.machines.keys.empty?, "Nothing in machine config"
-      end
-      
-      should "(31) have 2 disks" do
-        reg, zon = @@config.defaults.region, @@config.defaults.zone 
-        env, rol = @@config.defaults.environment, @@config.defaults.role
-        
-      end
-      
-      # Disabled for 0.5.0 (routines config removed)
-      xshould "(40) have routines" do
-        assert @@config.routines.is_a?(Rudy::Config::Routines), "Not a Routines class"
-      end
-      
-      # Disabled for 0.5.0 (most machines config removed)
-      xshould "(50) be able to find and find_deferred" do
-        reg, zon = @@config.defaults.region, @@config.defaults.zone 
-        env, rol = @@config.defaults.environment, @@config.defaults.role 
-
-        #Caesars.enable_debug
-        
-        conf = @@config.machines[env][rol]
-        conf_find = @@config.machines.find(env, rol)
-        conf_find_def = @@config.machines.find_deferred(env, rol)
-        
-        assert_equal conf, conf_find, "config hash and find not equal"
-        assert_equal conf_find_def, conf_find, "find and find_deferred not equal"
-      end
-      
-      should "(51) find different config for each zone" do
-        reg, zon = @@config.defaults.region, @@config.defaults.zone 
-        env, rol = @@config.defaults.environment, @@config.defaults.role
-        
-        us_ami = @@config.machines.find(:"us-east-1b", :ami)
-        eu_ami = @@config.machines.find(:"eu-west-1b", :ami)
-        
-        assert us_ami.is_a?(String), "No ami for us-east-1b zone"
-        assert eu_ami.is_a?(String), "No ami for eu-west-1b"
-        assert us_ami != eu_ami, "EU (#{eu_ami}) and US (#{us_ami}) AMIs are the same"
-      end
-      
-    end
-    
-  end
-end

data/test/15_scm/00_setup_test.rb

@@ -1,20 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-
-  class Case_15_SCM < Test::Unit::TestCase
-    include Rudy::Huxtable
-    
-    @@logger = STDERR #StringIO.new
-    @@zone = @@global.zone.to_s
-    
-    context "#{name}_00 Setup" do
-      should "(00) have class variables setup" do
-        stop_test !@@global.is_a?(Rudy::Global), "We don't have global (#{@@global})"
-        stop_test !@@config.is_a?(Rudy::Config), "We don't have an instance of Rudy::Config (#{@@config})"
-      end
-    end
-    
-    
-  end
-end

data/test/15_scm/20_git_test.rb

@@ -1,61 +0,0 @@
-
-module Rudy::Test
-  class Case_15_SCM
-    
-    def generate_rtag(username=nil)
-      now = Time.now
-      mon = now.mon.to_s.rjust(2, '0')
-      day = now.day.to_s.rjust(2, '0')
-      rev = "01"
-      criteria = ['rel', now.year, mon, day, rev]
-      criteria.insert(-2, username) if username
-      criteria.join(Rudy::DELIM)
-    end
-    
-    context "#{name}_20 Git" do
-      setup do
-        @strand = Rudy::Utils.strand
-        @scm = Rudy::SCM::GIT.new({
-          :path => "/tmp/git-#{@strand}"
-        })
-        stop_test !Rudy::SCM::GIT.working_copy?, "Not in working directory"
-      end
-      
-      
-      should "(10) know when a tag is invalid" do
-        bad_tag = generate_rtag(@strand)
-        assert !@scm.valid_rtag?(bad_tag), "Said bad tag was valid"
-      end
-      
-      should "(20) generate release tag name" do
-        rtag_should = generate_rtag(@strand)
-        rtag = @scm.find_next_rtag(@strand)
-        assert_equal rtag_should, rtag, "Bad tag"
-      end
-      
-      should "(30) create release" do
-        rtag_should = generate_rtag(@strand)
-        rtag = @scm.create_release(@strand)
-        assert_equal rtag_should, rtag, "Bad tag"
-        assert @scm.delete_rtag(rtag), "Could not delete tag"
-      end
-      
-      should "(31) know when a tag is valid" do
-        rtag = @scm.create_release(@strand)
-        assert @scm.valid_rtag?(rtag), "Said bad tag was invalid"
-        assert @scm.delete_rtag(rtag), "Could not delete tag"
-      end
-      
-      should "(40) get remote URI" do
-        rtag = @scm.get_remote_uri
-        assert !@scm.get_remote_uri.nil? && !@scm.get_remote_uri.empty?, "No remote URI"
-      end
-      
-      xshould "(90) raises exception when deleting a nonexistent tag" do
-        
-      end
-    end
-    
-    
-  end
-end

data/test/20_sdb/00_setup_test.rb

@@ -1,16 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-  # Expects:
-  # * There to be no pre-existing keypairs, addresses, etc... (except 
-  #   the default group)
-  # * It can destroy instances, images, etc... 
-  #
-  # DO NOT RUN THIS TEST ON A PRODUCTION AWS ACCOUNT!!
-  #
-  class Case_20_AWS_SDB < Test::Unit::TestCase
-    include Rudy::Huxtable
-    
-  end
-  
-end

data/test/20_sdb/10_domains_test.rb

@@ -1,115 +0,0 @@
-module Rudy::Test
-  class Case_20_AWS_SDB
-    
-    
-    def get_domain
-
-    end
-    
-    context "#{name}_10 Domains" do
-      
-      setup do
-        @sdb = Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @domain_list = @sdb.list_domains || []
-        @domain = @domain_list.first
-      end
-      
-      should "(10) create domain" do
-        dname = 'test_' << Rudy::Utils.strand
-        assert @sdb.create_domain(dname), "Domain not created (#{dname})"
-      end
-      
-      should "(20) list domains" do
-        domain_list = @sdb.list_domains
-        assert domain_list.is_a?(Array), "Not an Array"
-        assert !domain_list.empty?, "No Domains"
-      end
-      
-      should "(30) store objects" do
-        
-        assert !@domain.nil?, "No domain"
-        
-        produce = lambda {
-          {
-            'orange' => rand(100) * 10,
-            'celery' => rand(100) * 100,
-            'grapes' => :green
-          }
-        }
-        
-        @sdb.put(@domain, 'produce1', produce.call, :replace)
-        @sdb.put(@domain, 'produce2', produce.call, :replace)
-        
-        # TODO: Need assertion here!
-        
-      end
-      
-      should "(40) get objects" do
-        assert !@domain.nil?, "No domain"
-        item = @sdb.get(@domain, 'produce1')
-        assert_equal Hash, item.class # good stuff
-        assert_equal ['green'], item['grapes']
-      end
-      
-      should "(50) query objects" do
-        
-        assert !@domain.nil?, "No domain"
-        
-        items = @sdb.query(@domain, "[ 'grapes' = 'green' ]")
-        assert items.is_a?(Array), "Not an Array"
-        assert_equal 2, items.size, "More than 2 objects"
-      end
-      
-      should "(51) query objects with attributes" do
-        
-        assert !@domain.nil?, "No domain"
-        
-        items = @sdb.query_with_attributes(@domain, "[ 'grapes' = 'green' ]")
-        assert items.is_a?(Hash), "Not a Hash"
-        assert_equal 2, items.keys.size, "More than 2 objects"
-        assert items['produce1']['celery'].first.to_i > 1000, "Celery less than 1000"
-      end
-      
-      should "(60) select objects" do
-        assert !@domain.nil?, "No domain"
-        q = "select * from #{@domain}"
-
-        items = @sdb.select(q)
-        assert items.is_a?(Hash), "Not a Hash"
-        assert_equal 2, items.keys.size, "More than 2 objects"
-        
-        # {"produce1"=>{"celery"=>["5200"], "grapes"=>["green"], "orange"=>["550"]}}
-        assert items['produce1']['celery'].first.to_i > 1000, "Celery less than 1000"
-      end
-      
-      
-      should "(70) destroy objects" do
-        assert !@domain.nil?, "No domain"
-        q = "select * from #{@domain}"
-        items = @sdb.select(q)
-        assert items.is_a?(Hash), "Not a Hash"
-        items.keys.each do |item|
-          assert @sdb.destroy(@domain, item), "Not destroyed (#{item})"
-        end
-        sleep 1 # Eventual consistency. Items may still appear. 
-        q = "select * from #{@domain}"
-        items = @sdb.select(q)
-        assert items.nil?, "Some items not destroyed (#{items})"
-      end
-      
-      should "(99) destroy domains" do
-        
-        assert !@domain.nil?, "No domain"
-        
-        @domain_list.each do |domain|
-          assert @sdb.destroy_domain(domain), "Not destroyed (#{domain})"
-        end
-        
-        domain_list = @sdb.list_domains
-        assert domain_list.empty?, "Not empty"
-      end
-      
-    end
-    
-  end
-end

data/test/25_ec2/00_setup_test.rb

@@ -1,29 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-  # Expects:
-  # * There to be no pre-existing keypairs, addresses, etc... (except 
-  #   the default group)
-  # * It can destroy instances, images, etc... 
-  #
-  # DO NOT RUN THIS TEST ON A PRODUCTION AWS ACCOUNT!!
-  #
-  class Case_25_EC2 < Test::Unit::TestCase
-    include Rudy::Huxtable
-    
-    @@zone = @@global.zone.to_s
-
-    
-    context "#{name}_00 Setup" do
-      should "(10) have class variables setup" do
-        stop_test !@@global.is_a?(Rudy::Global), "We don't have global (#{@@global})"
-        stop_test !@@config.is_a?(Rudy::Config), "We don't have an instance of Rudy::Config (#{@@config})"
-        stop_test !@@global.accountnum, "No account number"
-      end
-      should "(11) be zone" do
-        stop_test !@@zone, "No zone"
-      end
-    end
-  end
-  
-end

data/test/25_ec2/10_keypairs_test.rb

@@ -1,41 +0,0 @@
-
-module Rudy::Test
-  
-  class Case_25_EC2
-    
-    context "#{name}_10 KeyPairs" do
-      setup do
-        @@test_name ||= 'test-' << Rudy::Utils.strand
-        @ec2key = Rudy::AWS::EC2::KeyPairs.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        #@ami = @@config.machines.find(@@zone.to_sym, :ami)
-      end
-      
-      
-      should "(10) create keypair" do
-        keypair = @ec2key.create(@@test_name)
-        assert keypair.is_a?(Rudy::AWS::EC2::KeyPair), "Not a KeyPair"
-        assert !keypair.name.empty?, "No name"
-        assert !keypair.fingerprint.empty?, "No fingerprint"
-        assert !keypair.private_key.empty?, "No private key"
-      end
-      
-      should "(20) list keypairs" do
-        keypairs = @ec2key.list || []
-        assert keypairs.size > 0, "No keypairs"
-      end
-      
-      should "(21) get specific keypair" do
-        assert @ec2key.get(@@test_name).is_a?(Rudy::AWS::EC2::KeyPair), "Not a KeyPair (#{@@test_name})"
-      end
-      
-      should "(50) destroy keypairs" do
-        keypairs = @ec2key.list || []
-        assert keypairs.size > 0, "No keypairs"
-        keypairs.each do |kp|
-          @ec2key.destroy(kp.name)
-        end
-      end
-    end
-    
-  end
-end

data/test/25_ec2/20_groups_test.rb

@@ -1,131 +0,0 @@
-
-module Rudy::Test
-
-  class Case_25_EC2
-    
-    def get_groups
-      # Ruby 1.8 throws an undefined method error when this is at the 
-      # bottom of the class
-      group_list = @ec2group.list_as_hash
-      # "default" cannot be deleted so we exempt it
-      group_list.reject { |gname,group| gname == "default" }
-    end
-    
-    
-    context "#{name}_20 Groups" do
-      setup do
-        @ec2group = Rudy::AWS::EC2::Groups.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @accountnum = @@config.accounts.aws.accountnum
-      end
-      
-      should "(00) not be existing groups" do
-        
-        group_list = get_groups
-        stop_test !group_list.empty?, "Destroy the existing groups (#{group_list.keys.join(', ')})"
-        stop_test !@accountnum, "Need an account number for group authorization"
-      end
-      
-      should "(01) create group with name" do
-        group_list = get_groups
-        test_name ||= 'test-' << Rudy::Utils.strand
-        str = Rudy::Utils.strand
-        group = @ec2group.create(test_name)
-        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object (#{group.class.to_s})"
-        assert_equal group.name, test_name, "Group name not set"
-        assert_equal group.description, "Security Group #{test_name}", "Group description not 'Security Group #{test_name}'"
-        assert @ec2group.exists?(test_name), "Group #{test_name} doesn't exist"
-      end
-      
-      should "(02) create group with name and description" do
-        test_name ||= 'test-' << Rudy::Utils.strand
-        str = Rudy::Utils.strand
-        desc = "Description for #{test_name}"
-        group = @ec2group.create(test_name, desc)
-        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
-        assert_equal group.name, test_name, "Group name not set"
-        assert_equal group.description, desc, "Group description not set"
-        assert @ec2group.exists?(test_name), "Group #{test_name} doesn't exist"
-      end
-      
-      should "(10) list available groups" do
-        group_list = @ec2group.list
-        assert group_list.is_a?(Array), "Group list is not an Array"
-
-        group_list_hash = @ec2group.list_as_hash
-        assert group_list_hash.is_a?(Hash), "Group list is not an Hash"
-
-        group_list.each do |group|
-          assert group.is_a?(Rudy::AWS::EC2::Group), "Not a group"
-        end
-      end
-      
-      should "(20) authorize/revoke group rules for address" do
-        external_ip_address = Rudy::Utils::external_ip_address
-        external_ip_address ||= '192.168.0.1/32'
-
-        test_name ||= 'test-' << Rudy::Utils.strand
-
-        group = @ec2group.create(test_name)
-        protocols = ['tcp', 'udp']
-        addresses = [external_ip_address]
-        ports = [[3100,3150],[3200,3250]]
-        
-        ret = @ec2group.authorize(test_name, addresses, ports, protocols)
-        assert ret, "Authorize did not return true"
-        
-        group = @ec2group.get(test_name)
-        
-        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a group (#{group})"
-        assert group.addresses.is_a?(Hash), "Addresses is not a hash (#{group.addresses})"
-        
-        group.addresses.each_pair do |address,rules|
-          assert rules.is_a?(Array), "Not an Array"
-          assert_equal 7, rules.size, "Not 7 rules"
-          puts "TODO: Check port ranges"
-        end
-        
-        ret = @ec2group.revoke(test_name, addresses, ports, protocols)
-        assert ret, "Revoke did not return true"
-        sleep 1 # Wait for eventual consistency
-        group = @ec2group.get(test_name)
-        assert group.addresses.is_a?(Hash), "Addresses is not a hash"
-        assert group.addresses.empty?, "Some addresses not revoked #{group.addresses.to_s}"
-      end
-      
-      
-      should "(21) authorize/revoke group permissions for account/group" do
-        test_name ||= 'test-' << Rudy::Utils.strand
-        group = @ec2group.create(test_name)
-        should_have = "#{@accountnum}:#{test_name}"
-        
-        ret = @ec2group.authorize_group(test_name, test_name, @accountnum)
-        assert ret, "Authorize failed (#{should_have})"
-        group = @ec2group.get(test_name)
-        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
-        assert group.groups.is_a?(Hash), "Groups is not a Hash (#{group.groups.class})"
-        assert_equal should_have, group.groups.keys.first, "Authorized group is not #{should_have}"
-        # TODO: Check port ranges
-        
-        ret = @ec2group.revoke_group(test_name, test_name, @accountnum)
-        assert ret, "Revoke failed (#{should_have})"
-        group = @ec2group.get(test_name)
-        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
-        assert group.groups.is_a?(Hash), "Groups is not a Hash (#{group.groups.class})"
-        assert !group.groups.has_key?(should_have), "Still authorized for #{should_have}"
-      end
-      
-      
-      should "(50) destroy groups" do
-        group_list = get_groups
-        assert !group_list.empty?, "No groups"
-        group_list.each_pair do |gname,group|
-          assert @ec2group.destroy(group.name), "Not destroyed (#{group.name})"
-        end
-      end
-      
-
-    end
-    
-      
-  end
-end