awsum 0.5

data/spec/lib/awsum/ec2/availability_zones_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2 do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+
+    describe "retrieving a list of availability zones" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeAvailabilityZones|, :body => fixture('ec2/availability_zones'), :status => 200)
+      end
+
+      let(:result) { ec2.availability_zones }
+
+      it "should return an array of availability zones" do
+        result.first.should be_a(Awsum::Ec2::AvailabilityZone)
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/image_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2 do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+
+    describe "retrieving a list of images" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeImages|, :body => fixture('ec2/images'), :status => 200)
+      end
+
+      let(:result) { ec2.images }
+
+      it "should return an array of images" do
+        result.first.should be_a(Awsum::Ec2::Image)
+      end
+    end
+
+    describe "retrieving a list of owned images" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeImages.*Owner.1=self|, :body => fixture('ec2/images'), :status => 200)
+      end
+
+      let(:result) { ec2.my_images }
+
+      it "should return an array of images" do
+        result.first.should be_a(Awsum::Ec2::Image)
+      end
+    end
+
+    describe "retrieving an image by id" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeImages.*ImageId.1=ari-f9c22690|, :body => fixture('ec2/image'), :status => 200)
+      end
+
+      let(:result) { ec2.image('ari-f9c22690') }
+
+      it "should return the image" do
+        result.should be_a(Awsum::Ec2::Image)
+      end
+    end
+
+    describe "registering an image" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=RegisterImage.*ImageLocation=s3.bucket.location|, :body => fixture('ec2/register_image'), :status => 200)
+      end
+
+      it "should be able to create an image" do
+        image_id = ec2.register_image('s3.bucket.location')
+
+        image_id.should == 'ami-4782652e'
+      end
+    end
+
+    describe "deregistering an image" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DeregisterImage.*ImageId=ami-4782652e|, :body => fixture('ec2/deregister_image'), :status => 200)
+      end
+
+      it "should return true" do
+        ec2.deregister_image('ami-4782652e').should be_true
+      end
+    end
+
+    describe "an image" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeImages.*ImageId.1=ari-f9c22690|, :body => fixture('ec2/image'), :status => 200)
+      end
+
+      let(:image) { ec2.image('ari-f9c22690') }
+
+      it "should be able to create an image" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=RunInstances.*ImageId=ari-f9c22690|, :body => fixture('ec2/instance'), :status => 200)
+        result = image.run
+        result.first.should be_a(Awsum::Ec2::Instance)
+      end
+
+      it "should be able to deregister itself" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DeregisterImage.*ImageId=ari-f9c22690|, :body => fixture('ec2/deregister_image'), :status => 200)
+        image.deregister.should be_true
+      end
+
+      it "should be able reregister itself" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DeregisterImage.*ImageId=ari-f9c22690|, :body => fixture('ec2/deregister_image'), :status => 200)
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=RegisterImage.*ImageLocation=s3.bucket.location|, :body => fixture('ec2/register_image'), :status => 200)
+        image.reregister.should be_true
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/instance_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2 do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+
+    describe "running an instance" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=RunInstances.*ImageId=ari-f9c22690|, :body => fixture('ec2/run_instances'), :status => 200)
+      end
+
+      let(:result) { ec2.run_instances 'ari-f9c22690' }
+
+      it "should return an array of instances" do
+        result.first.should be_a(Awsum::Ec2::Instance)
+      end
+    end
+
+    describe "retrieving a list of instances" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeInstances|, :body => fixture('ec2/run_instances'), :status => 200)
+      end
+
+      let(:result) { ec2.instances }
+
+      it "should return an array of instances" do
+        result.first.should be_a(Awsum::Ec2::Instance)
+      end
+    end
+
+    describe "retrieving a single instance" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeInstances.*InstanceId.1=i-3f1cc856|, :body => fixture('ec2/instance'), :status => 200)
+      end
+
+      let(:result) { ec2.instance 'i-3f1cc856' }
+
+      it "should return an instance" do
+        result.should be_a(Awsum::Ec2::Instance)
+      end
+    end
+
+    describe "terminating an instance" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=TerminateInstances.*InstanceId.1=i-3f1cc856|, :body => fixture('ec2/terminate_instances'), :status => 200)
+      end
+
+      it "should return an instance" do
+        ec2.terminate_instances('i-3f1cc856').should be_true
+      end
+    end
+
+    describe "an instance" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeInstances.*InstanceId.1=i-3f1cc856|, :body => fixture('ec2/instance'), :status => 200)
+      end
+
+      let(:instance) { ec2.instance 'i-3f1cc856' }
+
+      it "should be able to terminate" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=TerminateInstances.*InstanceId.1=i-3f1cc856|, :body => fixture('ec2/terminate_instances'), :status => 200)
+
+        instance.terminate.should be_true
+      end
+
+      it "should be able to list it's volumes" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeVolumes|, :body => fixture('ec2/volumes'), :status => 200)
+
+        volumes = instance.volumes
+        volumes.first.should be_a(Awsum::Ec2::Volume)
+        volumes.first.instance_id.should == instance.id
+      end
+
+      it "should be able to attach a volume" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeVolumes|, :body => fixture('ec2/volumes'), :status => 200)
+
+        volume = ec2.volumes.last
+
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=AttachVolume.*InstanceId=i-3f1cc856.*VolumeId=vol-44d6322d|, :body => fixture('ec2/attach_volume'), :status => 200)
+
+        instance.attach(volume).should be_true
+      end
+
+      it "should be able to create a volume" do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=CreateVolume|, :body => fixture('ec2/create_volume'), :status => 200)
+
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeVolumes.*VolumeId.1=vol-44d6322d|, :body => fixture('ec2/available_volume'), :status => 200)
+
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=AttachVolume.*InstanceId=i-3f1cc856.*VolumeId=vol-44d6322d|, :body => fixture('ec2/attach_volume'), :status => 200)
+
+        instance.create_volume(10)
+      end
+    end
+
+    describe "on a running instance" do
+      it "should be able to retrieve an instance of itself" do
+        FakeWeb.register_uri(:get, 'http://169.254.169.254/latest/meta-data/instance-id', :body => 'i-3f1cc856', :status => 200)
+
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeInstances.*InstanceId.1=i-3f1cc856|, :body => fixture('ec2/instance'), :status => 200)
+
+        ec2.me.should be_a(Awsum::Ec2::Instance)
+      end
+
+      it "should return nil if not a running instance" do
+        FakeWeb.register_uri(:get, 'http://169.254.169.254/latest/meta-data/instance-id', :body => '', :status => 404)
+
+        ec2.me.should be_nil
+      end
+
+      it "should be able to retrieve the user data" do
+        FakeWeb.register_uri(:get, 'http://169.254.169.254/latest/user-data', :body => 'This is the user data', :status => 200)
+
+        ec2.user_data.should == 'This is the user data'
+      end
+
+      it "should return nil if there's no user data" do
+        FakeWeb.register_uri(:get, 'http://169.254.169.254/latest/user-data', :body => '', :status => 404)
+
+        ec2.user_data.should be_nil
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/keypair_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2 do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+
+    describe "retrieving a list of key pairs" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeKeyPairs|, :body => fixture('ec2/key_pairs'), :status => 200)
+      end
+
+      let(:result) { ec2.key_pairs }
+
+      it "should return an array of key pairs" do
+        result.first.should be_a(Awsum::Ec2::KeyPair)
+      end
+    end
+
+    describe "retrieving a single key pair by name" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DescribeKeyPairs.*KeyName.1=gsg_keypair|, :body => fixture('ec2/key_pairs'), :status => 200)
+      end
+
+      let(:result) { ec2.key_pair 'gsg_keypair' }
+
+      it "should return a key pair" do
+        result.should be_a(Awsum::Ec2::KeyPair)
+      end
+    end
+
+    describe "creating a key pair" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=CreateKeyPair.*KeyName=test-keypair|, :body => fixture('ec2/key_pairs'), :status => 200)
+      end
+
+      let(:result) { ec2.create_key_pair('test-keypair') }
+
+      it "should return a key pair" do
+        result.should be_a(Awsum::Ec2::KeyPair)
+      end
+    end
+
+    describe "deleting a key pair" do
+      before do
+        FakeWeb.register_uri(:get, %r|https://ec2\.amazonaws\.com/?.*Action=DeleteKeyPair.*KeyName=test-keypair|, :body => fixture('ec2/key_pairs'), :status => 200)
+      end
+
+      it "should return a key pair" do
+        ec2.delete_key_pair('test-keypair').should be_true
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/parsers/address_parser_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2::AddressParser do
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+    let(:parser) { Awsum::Ec2::AddressParser.new(ec2) }
+
+    describe "parsing the result of a call to DescribeAddresses" do
+      let(:result) { parser.parse(fixture('ec2/addresses')) }
+
+      it "should return an array of addresses" do
+        result.should be_a(Array)
+      end
+
+      context "the first address" do
+        let(:address) { result.first }
+
+        {
+          :public_ip    =>  '127.0.0.1',
+          :instance_id  =>  'i-3f1cc856'
+        }.each do |key, value|
+          it "should have the correct #{key}" do
+            address.send(key).should == value
+          end
+        end
+      end
+    end
+
+    describe "parsing the result of a call to AllocateAddress" do
+      let(:result) { parser.parse(fixture('ec2/allocate_address')) }
+
+      it "should return an array of addresses" do
+        result.should be_a(Array)
+      end
+
+      context "the address" do
+        let(:address) { result.first }
+
+        {
+          :public_ip    =>  '127.0.0.1',
+          :instance_id  =>  nil
+        }.each do |key, value|
+          it "should have the correct #{key}" do
+            address.send(key).should == value
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/parsers/availability_zone_parser_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2::AvailabilityZoneParser do
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+    let(:parser) { Awsum::Ec2::AvailabilityZoneParser.new(ec2) }
+    let(:result) { parser.parse(fixture('ec2/availability_zones')) }
+
+    it "should return an array of availability zones" do
+      result.should be_a(Array)
+    end
+
+    context "the first availability zone" do
+      let(:availability_zone) { result.first }
+
+      {
+        :name        =>  'eu-west-1a',
+        :state       =>  'available',
+        :region_name => 'eu-west-1'
+      }.each do |key, value|
+        it "should have the correct #{key}" do
+          availability_zone.send(key).should == value
+        end
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/parsers/image_parser_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2::ImageParser do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+    let(:parser) { Awsum::Ec2::ImageParser.new(ec2) }
+    let(:result) { parser.parse(fixture('ec2/images')) }
+
+    it "should return an array of images" do
+      result.should be_a(Array)
+    end
+
+    context "the first image" do
+      let(:image) { result.first }
+
+      {
+        :id           => 'aki-0d9f7b64',
+        :location     => 'oracle_linux_kernels/2.6.18-53.1.13.9.1.el5xen/vmlinuz-2.6.18-53.1.13.9.1.el5xen.manifest.xml',
+        :state        => 'available',
+        :owner        => '725966715235',
+        :architecture => 'x86_64',
+        :type         => 'kernel'
+      }.each do |key, value|
+        it "should have the correct #{key}" do
+          image.send(key).should == value
+        end
+      end
+
+      it "should be marked as public" do
+        image.should be_public
+      end
+    end
+
+    context "the second image" do
+      let(:image) { result[1] }
+
+      it "should have the correct id" do
+        image.id.should == 'aki-25de3b4c'
+      end
+
+      it "should have an array of product codes" do
+        image.product_codes.should be_a(Array)
+      end
+
+      it "should have the correct product codes" do
+        image.product_codes.first.should == '54DBF944'
+      end
+    end
+
+    context "the third image" do
+      let(:image) { result[2] }
+
+      {
+        :id          => 'ami-005db969',
+        :kernel_id   => 'aki-b51cf9dc',
+        :ramdisk_id  => 'ari-b31cf9da'
+      }.each do |key, value|
+        it "should have the correct #{key}" do
+          image.send(key).should == value
+        end
+      end
+    end
+  end
+end

data/spec/lib/awsum/ec2/parsers/instance_parser_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Awsum
+  describe Ec2::InstanceParser do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+    let(:parser) { Awsum::Ec2::InstanceParser.new(ec2) }
+    let(:result) { parser.parse(fixture('ec2/instances')) }
+
+    it "should return an array of instances" do
+      result.should be_a(Array)
+    end
+
+    context "the first instance" do
+      let(:instance) { result.first }
+
+      {
+        :id                 => 'i-3f1cc856',
+        :private_dns_name   => 'ip-10-255-255-255.ec2.internal',
+        :dns_name           => 'ec2-75-255-255-255.compute-1.amazonaws.com',
+        :key_name           => 'gsg-keypair',
+        :launch_index       => 0,
+        :type               => 'm1.small',
+        :availability_zone  => 'us-east-1b',
+        :launch_time        => Time.parse('2008-06-18T12:51:52.000Z'),
+        :state              => {:code => 0, :name => 'pending'}
+      }.each do |key, value|
+        it "should have the correct #{key}" do
+          instance.send(key).should == value
+        end
+      end
+    end
+
+    context "the second instance" do
+      let(:instance) { result[1] }
+
+      it "should have the correct state" do
+        instance.state.should == {:code => 16, :name => 'running'}
+      end
+    end
+  end
+
+  describe "Ec2::InstanceParser with the result of RunInstances" do
+
+    subject { Ec2.new('abc', 'xyz') }
+    let(:ec2) { subject }
+    let(:parser) { Awsum::Ec2::InstanceParser.new(ec2) }
+    let(:result) { parser.parse(fixture('ec2/run_instances')) }
+
+    it "should return an array of instances" do
+      result.should be_a(Array)
+    end
+
+    context "the first instance" do
+      let(:instance) { result.first }
+
+      {
+        :id                 => 'i-f92fa890',
+        :private_dns_name   => nil,
+        :dns_name           => nil,
+        :key_name           => nil,
+        :launch_index       => 0,
+        :type               => 'm1.small',
+        :availability_zone  => 'us-east-1b',
+        :launch_time        => Time.parse('2009-01-11T13:09:01.000Z'),
+        :state              => {:code => 0, :name => 'pending'}
+      }.each do |key, value|
+        it "should have the correct #{key}" do
+          instance.send(key).should == value
+        end
+      end
+    end
+  end
+end