rudy 0.8.5 → 0.9.0

data/tryouts/25_ec2/10_keypairs_tryouts.rb

@@ -0,0 +1,54 @@
+
+group "EC2"
+library :rudy, 'lib'
+
+
+tryouts "Keypairs" do
+  set :global, Rudy::Huxtable.global
+  set :keypair_name, 'key-' << Rudy::Utils.strand
+  
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+  end
+  
+  drill "no existing keypairs", false do
+    Rudy::AWS::EC2::Keypairs.any?
+  end
+  
+  dream [Rudy::AWS::EC2::Keypair, false]
+  drill "create keypair" do
+    k = Rudy::AWS::EC2::Keypairs.create keypair_name
+    [k.class, k.private_key.nil?]
+  end
+  
+  drill "get keypair", :class, Rudy::AWS::EC2::Keypair do
+    Rudy::AWS::EC2::Keypairs.get keypair_name
+  end
+  
+  drill "has fingerprint", :empty?, false do
+    k = Rudy::AWS::EC2::Keypairs.get keypair_name
+    k.fingerprint
+  end
+  
+  drill "private key is not available later", nil do
+    k = Rudy::AWS::EC2::Keypairs.get keypair_name
+    k.private_key
+  end
+  
+  dream :class, Array
+  dream :empty?, false
+  drill "list keypairs" do
+    Rudy::AWS::EC2::Keypairs.list
+  end
+  
+  drill "destroy keypairs", nil do
+    keypairs = Rudy::AWS::EC2::Keypairs.list
+    keypairs.each do |kp|
+      Rudy::AWS::EC2::Keypairs.destroy kp.name
+    end
+    Rudy::AWS::EC2::Keypairs.list
+  end
+  
+end
+

data/tryouts/25_ec2/20_groups_tryouts.rb

@@ -0,0 +1,56 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Groups" do
+  set :global, Rudy::Huxtable.global
+  set :group_name, 'grp-' << Rudy::Utils.strand
+  set :group_desc, 'desc-' << group_name
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+  end
+  
+  dream :class, Rudy::AWS::EC2::Group
+  dream :name, group_name
+  dream :description, "Security Group #{group_name}"
+  drill "create group with name" do
+    Rudy::AWS::EC2::Groups.create group_name
+  end
+  
+  dream :class, Rudy::AWS::EC2::Group
+  dream :name, "#{group_name}2"
+  dream :description, group_desc
+  drill "create group with name and description" do
+    Rudy::AWS::EC2::Groups.create "#{group_name}2", group_desc
+  end
+  
+  drill "list as Array", :class, Array do
+    Rudy::AWS::EC2::Groups.list
+  end
+  
+  drill "list as Hash", :class, Hash do
+    Rudy::AWS::EC2::Groups.list_as_hash
+  end
+  
+  dream :size, 1  # will equal 2 if test fails
+  drill "list returns Group objects" do
+    list = Rudy::AWS::EC2::Groups.list
+    list.collect! do |group|
+      group.is_a?(Rudy::AWS::EC2::Group)
+    end
+    list.uniq
+  end
+  
+  dream :class, Array
+  dream :size, 1
+  drill "destroy groups" do
+    list = Rudy::AWS::EC2::Groups.list
+    list.collect! do |group|
+      next if group.name == "default" # can't delete this default group
+      Rudy::AWS::EC2::Groups.destroy group.name
+    end
+    Rudy::AWS::EC2::Groups.list
+  end
+end
+
+

data/tryouts/25_ec2/21_groups_authorize_address_tryouts.rb

@@ -0,0 +1,53 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Groups Authorize Address" do
+  set :global, Rudy::Huxtable.global
+  set :group_name, 'grp-' << Rudy::Utils.strand
+  set :protocols, ['tcp', 'udp']
+  set :external_ip, Rudy::Utils::external_ip_address || '192.168.0.1/32'
+  set :addresses, [external_ip]
+  set :ports, [[3100,3150],[3200,3250]]
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+    Rudy::AWS::EC2::Groups.create group_name
+  end
+  clean do 
+    Rudy::AWS::EC2::Groups.destroy group_name
+  end
+  
+  drill "authorize group rules returns true", true do
+    Rudy::AWS::EC2::Groups.authorize group_name, addresses, ports, protocols
+  end
+  
+    dream :proc, lambda { |group|
+      group.addresses.each_pair do |address,rules|
+        return false unless rules.is_a? Array
+        return false unless rules.size == 7
+      end
+      true
+    }
+  drill "group (#{group_name}) contains new rules" do
+    stash :group, Rudy::AWS::EC2::Groups.get(group_name)
+  end
+    
+  drill "revoke group rules returns true", true do
+    Rudy::AWS::EC2::Groups.revoke(group_name, addresses, ports, protocols)
+  end
+  
+    dream :proc, lambda { |group|
+      group.addresses.each_pair do |address,rules|
+        return false unless rules.is_a? Array
+        return false unless rules.size == 3
+      end
+      true
+    }
+  drill "group does not contain new rules" do
+    group = Rudy::AWS::EC2::Groups.get(group_name)
+    stash :group, group 
+    group
+  end
+  
+  
+end

data/tryouts/25_ec2/22_groups_authorize_account_tryouts.rb

@@ -0,0 +1,54 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Groups Authorize/Revoke Account" do
+  set :global, Rudy::Huxtable.global
+  set :group_name, 'grp-' << Rudy::Utils.strand
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+    Rudy::AWS::EC2::Groups.create group_name
+  end
+  clean do 
+    Rudy::AWS::EC2::Groups.destroy group_name
+  end
+  
+  dream :class, String
+  dream :empty?, false
+  drill "has account num" do
+    Rudy::Huxtable.config.accounts.aws.accountnum
+  end
+  
+  drill "authorize group rules returns true", true do
+    accountnum = Rudy::Huxtable.config.accounts.aws.accountnum
+    Rudy::AWS::EC2::Groups.authorize_group group_name, group_name, accountnum
+  end
+  
+    dream :class, Rudy::AWS::EC2::Group
+    dream :proc, lambda { |group|
+      accountnum = Rudy::Huxtable.config.accounts.aws.accountnum
+      should_have = "#{accountnum}:#{group_name}"
+      return false unless group.groups.is_a?(Hash)
+      group.groups.has_key?(should_have) == true
+    }
+  drill "group (#{group_name}) contains new rules" do
+    stash :group, Rudy::AWS::EC2::Groups.get(group_name)
+  end
+  
+  drill "revoke group rules returns true", true do
+    accountnum = Rudy::Huxtable.config.accounts.aws.accountnum
+    Rudy::AWS::EC2::Groups.revoke_group group_name, group_name, accountnum
+  end
+  
+    dream :proc, lambda { |group| 
+      accountnum = Rudy::Huxtable.config.accounts.aws.accountnum
+      should_have = "#{accountnum}:#{group_name}"
+      return false unless group.groups.is_a?(Hash)
+      group.groups.has_key?(should_have) == false
+    }
+    drill "group (#{group_name}) does not contain new rules" do
+    stash :group, Rudy::AWS::EC2::Groups.get(group_name)
+  end
+
+  
+end

data/tryouts/25_ec2/30_addresses_tryouts.rb

@@ -0,0 +1,42 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Addresses" do
+  set :global, Rudy::Huxtable.global
+  set :group_name, 'grp-' << Rudy::Utils.strand
+  set :group_desc, 'desc-' << group_name
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+  end
+  
+  drill "should not be existing addresses", false do
+    Rudy::AWS::EC2::Addresses.any?
+  end
+  
+  dream :class, Rudy::AWS::EC2::Address
+  dream :proc, lambda { |a| a.ipaddress.size > 0 }
+  drill "create address" do
+    Rudy::AWS::EC2::Addresses.create
+  end
+  
+  dream :class, Array
+  dream :empty?, false
+  drill "list addresses" do
+    stash :address, Rudy::AWS::EC2::Addresses.list
+  end
+  
+  dream :class, Hash
+  dream :empty?, false
+  drill "list addresses as Hash" do
+    Rudy::AWS::EC2::Addresses.list_as_hash
+  end
+  
+  drill "destroy all addresses", true do
+    Rudy::AWS::EC2::Addresses.list.each do |a|
+      Rudy::AWS::EC2::Addresses.destroy a
+    end
+    Rudy::AWS::EC2::Addresses.list.nil?
+  end
+  
+end

data/tryouts/25_ec2/40_volumes_tryouts.rb

@@ -0,0 +1,53 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Volumes" do
+  set :global, Rudy::Huxtable.global
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+  end
+  
+  drill "no existing volumes", false do
+    Rudy::AWS::EC2::Volumes.any? :available
+  end
+  
+  dream :class, Rudy::AWS::EC2::Volume
+  dream :size, 2
+  dream(:zone) { Rudy::Huxtable.global.zone }
+  dream :proc, lambda { |v| !v.awsid.nil? }
+  drill "create a 2GB volume" do
+    Rudy::AWS::EC2::Volumes.create 2, Rudy::Huxtable.global.zone
+  end
+  
+  dream :class, Array
+  dream :empty?, false
+  drill "list available volumes" do
+    Rudy::AWS::EC2::Volumes.list :available
+  end
+  
+  dream :class, Hash
+  dream :empty?, false
+  drill "list available volumes as hash" do
+    Rudy::AWS::EC2::Volumes.list_as_hash :available
+  end
+  
+  dream :class, Rudy::AWS::EC2::Volume
+  dream :size, 2
+  dream :available?, true
+  drill "get a specific volume" do
+    volid = Rudy::AWS::EC2::Volumes.list(:available).first.awsid
+    Rudy::AWS::EC2::Volumes.get volid
+  end
+  
+  drill "destroy all volumes", false do
+    volumes = Rudy::AWS::EC2::Volumes.list
+    volumes.each do |vol|
+      next unless vol.available?
+      Rudy::AWS::EC2::Volumes.destroy(vol.awsid)
+    end
+    Rudy::AWS::EC2::Volumes.any? :available
+  end
+  
+  
+end

data/tryouts/25_ec2/50_snapshots_tryouts.rb

@@ -0,0 +1,75 @@
+group "EC2"
+library :rudy, 'lib'
+
+tryouts "Snapshots" do
+  set :global, Rudy::Huxtable.global
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+    Rudy::AWS::EC2::Volumes.create 3, global.zone
+  end
+  clean do
+    Rudy::AWS::EC2::Volumes.list(:available) do |v|
+      Rudy::AWS::EC2::Volumes.destroy v
+    end
+  end
+  
+  drill "no existing snapshots", false do
+    Rudy::AWS::EC2::Snapshots.any?
+  end
+  
+    dream :class, Rudy::AWS::EC2::Snapshot
+  drill "create snapshot" do
+    vol = Rudy::AWS::EC2::Volumes.list(:available).first
+    Rudy::AWS::EC2::Snapshots.create vol.awsid
+  end
+  
+    dream :class, Array
+    dream :empty?, false
+  drill "list snapshots as Array" do
+    Rudy::AWS::EC2::Snapshots.list
+  end
+
+    dream :class, Hash
+    dream :empty?, false
+  drill "list snapshots as Hash" do
+    Rudy::AWS::EC2::Snapshots.list_as_hash
+  end
+  
+    dream :class, Rudy::AWS::EC2::Snapshot
+  drill "get snapshot from id" do
+    snap = Rudy::AWS::EC2::Snapshots.list.first
+    Rudy::AWS::EC2::Snapshots.get snap.awsid
+  end
+  
+    dream :class, Rudy::AWS::EC2::Volume
+    dream :size, 3
+    dream :proc, lambda { |v| v.creating? || v.available? }
+    dream :proc, lambda { |v|
+      snap = Rudy::AWS::EC2::Snapshots.list.first
+      v.snapid == snap.awsid
+    }
+  drill "create volume from snapshot" do
+    snap = Rudy::AWS::EC2::Snapshots.list.first
+    Rudy::AWS::EC2::Volumes.create 3, global.zone, snap.awsid
+  end
+  
+  drill "destroy snapshots", false do
+    Rudy::AWS::EC2::Snapshots.list.each do |snap|
+      Rudy::AWS::EC2::Snapshots.destroy snap.awsid
+    end
+    Rudy::AWS::EC2::Snapshots.any?
+  end
+end
+
+__END__
+
+ 
+ should "(90) destroy snapshots" do
+   assert @ec2snap.any?, "No snapshots"
+   snap_list = @ec2snap.list
+   snap_list.each do |snap|
+     next unless snap.completed?
+     assert @ec2snap.destroy(snap.awsid), "Not destroyed (#{snap.awsid})"
+   end
+ end

data/tryouts/26_ec2_instances/10_instance_tryouts.rb

@@ -0,0 +1,107 @@
+group "EC2 Instances"
+library :rudy, 'lib'
+
+tryouts "Instances" do
+  set :global, Rudy::Huxtable.global
+  set :config, Rudy::Huxtable.config
+  setup do
+    Rudy::Huxtable.update_config
+    Rudy::AWS::EC2.connect global.accesskey, global.secretkey, global.region
+    @ami = config.machines.find(global.region, :ami)
+  end
+  clean do
+    Rudy::AWS::EC2::Addresses.list.each do |add|
+      Rudy::AWS::EC2::Addresses.destroy add.ipaddress
+    end
+  end
+  
+  dream :class, String
+  dream :empty?, false
+  drill("has ami") { @ami }
+  
+  drill "no machines running", false do
+    Rudy::AWS::EC2::Instances.any? :running
+  end
+  
+  dream :class, Rudy::AWS::EC2::Instance
+  dream :running?, true
+  drill "create instance" do
+    list = Rudy::AWS::EC2::Instances.create :ami => @ami, :group => "default"
+    list.each do |instance|
+      Rudy::Utils.waiter {
+        Rudy::AWS::EC2::Instances.running?(instance) 
+      }
+    end
+    Rudy::AWS::EC2::Instances.get list.first.awsid
+  end
+  
+  dream :class, Array
+  dream [:running, :pending, :shutting_down, :terminated, :degraded]
+  drill "have known states" do
+    Rudy::AWS::EC2::Instances::KNOWN_STATES
+  end
+  
+    dream :class, Array
+    dream :empty?, false
+  drill "list instances as Array" do
+    Rudy::AWS::EC2::Instances.list :running
+  end
+
+    dream :class, Hash
+    dream :empty?, false
+  drill "list instances as Hash" do
+    Rudy::AWS::EC2::Instances.list_as_hash :running
+  end
+  
+  # NOTE: This drill will probably fail b/c console output takes 
+  # a few minutes to become available. 
+  dream :class, String
+  dream :empty?, false
+  xdrill "have console output" do
+    inst = Rudy::AWS::EC2::Instances.list(:running).first
+    Rudy::AWS::EC2::Instances.console inst.awsid
+  end
+  
+  dream true
+  
+  drill "assign IP address to instance", true do
+    address = Rudy::AWS::EC2::Addresses.create
+    instance = Rudy::AWS::EC2::Instances.list(:running).first
+    Rudy::AWS::EC2::Addresses.associate(address, instance)
+    instance = Rudy::AWS::EC2::Instances.get instance.awsid
+    stash :address, address.ipaddress
+    stash :instance_ip, instance.dns_public
+    address.ipaddress == IPSocket.getaddress(instance.dns_public)
+  end
+  
+  xdrill "can unassign an IP address (TODO)" do
+    
+  end
+  
+  # NOTE: Restart is generally disabled until it checks that it's
+  # unavailable and then comes available (there's no restart status)
+  xdrill "restart instance (TODO)", true do
+    instance = Rudy::AWS::EC2::Instances.list(:running).first
+    Rudy::AWS::EC2::Instances.restart instance
+  end
+  
+  dream :class, Rudy::AWS::EC2::Instance
+  dream :shutting_down?, true
+  drill "destroy instance" do
+    instance = Rudy::AWS::EC2::Instances.list(:running).first
+    Rudy::AWS::EC2::Instances.destroy instance
+    instance = Rudy::AWS::EC2::Instances.get instance.awsid
+  end
+  
+end
+
+__END__
+
+should "(99) destroy instance" do
+  assert @ec2inst.any?(:running), "No instances running"
+  instances = @ec2inst.list(:running) 
+  return skip("No running instances") unless instances
+  instances.each do |instance|
+    assert @ec2inst.destroy(instance), "Did not destroy"
+  end
+end