internuity-awsum 0.2 → 0.3

data/test/units/ec2/test_keypair.rb

@@ -0,0 +1,87 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class KeyPairsTest < Test::Unit::TestCase
+  context "KeyPairParser:" do
+    context "Parsing the result of a call to DescribeKeyPairs" do
+      setup {
+        ec2 = Awsum::Ec2.new('abc', 'xyz')
+        xml = load_fixture('ec2/key_pairs')
+        parser = Awsum::Ec2::KeyPairParser.new(ec2)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of key pairs" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::Ec2::KeyPair)
+      end
+
+      context ", the first key pair" do
+        setup {
+          @key_pair = @result[0]
+        }
+
+        should "have the correct name" do
+          assert_equal "gsg-keypair", @key_pair.name
+        end
+
+        should "have the correct fingerprint" do
+          assert_equal "ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab", @key_pair.fingerprint
+        end
+      end
+    end
+
+    context "Parsing the result of a call to CreateKeyPair" do
+      setup {
+        ec2 = Awsum::Ec2.new('abc', 'xyz')
+        xml = load_fixture('ec2/create_key_pair')
+        parser = Awsum::Ec2::KeyPairParser.new(ec2)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of key pairs" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::Ec2::KeyPair)
+      end
+
+      context ", the first key pair" do
+        setup {
+          @key_pair = @result[0]
+        }
+
+        should "have the correct name" do
+          assert_equal "test-keypair", @key_pair.name
+        end
+
+        should "have the correct fingerprint" do
+          assert_equal "ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab:ab", @key_pair.fingerprint
+        end
+
+        should "have the correct material" do
+          assert_equal %q{-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAqkxIjNxLV/shvaep5Kum3N2xTV6aBbXezVA4HHE371HSq3haKTcST7QYeQha
+92AmZojAm2ojqWMw9GJaeq/Q7NvXKdMgj3mKd7zY7tdC+HmKYVkAvJ9enuuVwPFxlt+5rPpZ2jS+
+kl4MWEvWh1N5U1urx5gzHq2e/k7P+dCBwFnCHsg/p1mym4j4qwEHEviaUG6SnB8Xvuggp/pxCmJg
+9Gie4cXNgbBboEyAQDRb/AmrehbBa90GOVDjDGIzB98rOcJ22FRrpLqSl2D+FQKsXWboqgbIrgKT
+ven7mzb8cgDJNrWTI/MNP8p8gNTh+L7gTwPDcGfaDBiRpn9t3FiTBwIDAQABAoIBAEmuNZmUWpjX
+U/LdjtkcF1bqKCMkchlUZfCI664KojvOOAruSHwakrafYhNDtS/gjtzAAC19z64i93RU9XatiQRh
+3YcADM9ms604rNcxlY0x8NhLjNEPVv4FScav8AhqBci8jJGnTmi/fjHZphjo2c5iFEGILV3xmp/G
+857PQsQ4nOAzoV7fQPYow4XiO/xhGh8p8o2Z9Og3GdbEGH1v/051g3O1eU7PFyQaxmOGNYmklMuM
+V/8l/LK+OKR0f9KgqcgDSlEbidqsmWM0a1/t7+I5W/mgXSZl5U4HN680DKbkzoX0kgoPN7XMbcSX
+sHNguqDfrvkBUQu1vEaXebWfpekCgYEA0qVbcFGxKniyYxmvtSrbb5bpEnh6zRCGXgSU4fX41i8P
+Xg15R7FnwGO5nuRXqGW6CSgfbA7YAVEQHunUOB0XWuJWgn6gsqvnCZvyfRnqyMJJjRhvuaUMTn/5
+ikcayflqPFHvv5Z+pB3pWNaTD6lM5imdF1In9RBYL4q5Vpt9gl0CgYEAzvb6cS6Yi0PkxU3OOEmg
+98QcdTEd1hrk3r6uXI1TOeiUPIw+dyGCKa9OqpcFDs+0FskFs6RzztRh2gpwQZTH3UOYPqsjsWd+
+AjL3jv+vmpU1OhnA0SpkyiiZtaSAV2N+Xlq8orG6fbnYFCdzHbufLFaoOpbGptmLfrwMSvnhXLMC
+gYBxRsEcbqHycAOmLUsDBvAIW0QtTaLkIe3QI3CY7viI3bfK4T4GIs3jdP1+B9dn1IStpej36Cea
+1afwp9ga8PH9Stgwxr3ON4k/7qABTG2o1mpNOQXj9HDgygs8pC4wzTKnC3z9L4Yc5YT15DYjZuzW
+nSxAPUsFi2uQ7W3ruCRPdQKBgGslsCiyb+UBpEmFa3L2o3BCRl1hrUmwKLcszsY5oFHFmCD0lk5E
+ucds6/QjNUoiu+Bj+CC1zgLRL0ubxdwd848YtJQVM+hfZPwseL++naIRBzpqJMnlAcMrW9CPNqaH
+at/cZ/ZuvtbiRPzCI7XL8a8ZugSDFJtC2xYkstSKI2NDAoGAIiwUwKRMJyB9IRXhMfpf6vsEza2t
+urHVUdJUyIwvPJSh2PfkumwrPuk+P+8v6jJjJ0hsqOS+TLQwWclIGwGey/PMNRYqQDqnSUofNmza
+XtGGfWTOD3AdDEH39RTd3Zmfirrjm1YsY/Nb54X+V5TN2uvm/yJBIbb4aLvfG74Jmoc=
+-----END RSA PRIVATE KEY-----}, @key_pair.material
+        end
+      end
+    end
+  end
+end

data/test/units/ec2/test_regions.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class RegionsTest < Test::Unit::TestCase
+  context "RegionParser:" do
+    context "Parsing the result of a call to DescribeRegions" do
+      setup {
+        ec2 = Awsum::Ec2.new('abc', 'xyz')
+        xml = load_fixture('ec2/regions')
+        parser = Awsum::Ec2::RegionParser.new(ec2)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of regions" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::Ec2::Region)
+      end
+
+      context ", the first region" do
+        setup {
+          @region = @result[0]
+        }
+
+        should "have the correct name" do
+          assert_equal "eu-west-1", @region.name
+        end
+
+        should "have the correct end point" do
+          assert_equal 'eu-west-1.ec2.amazonaws.com', @region.end_point
+        end
+      end
+    end
+  end
+end

data/test/units/ec2/test_security_group.rb

@@ -0,0 +1,105 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class SecurityGroupsTest < Test::Unit::TestCase
+  context "SecurityGroupParser:" do
+    context "Parsing the result of a call to DescribeSecurityGroups" do
+      setup {
+        ec2 = Awsum::Ec2.new('abc', 'xyz')
+        xml = load_fixture('ec2/security_groups')
+        parser = Awsum::Ec2::SecurityGroupParser.new(ec2)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of security_groups" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::Ec2::SecurityGroup)
+      end
+
+      context ", the first security_group" do
+        setup {
+          @security_group = @result[0]
+        }
+
+        should "have the correct name" do
+          assert_equal "default", @security_group.name
+        end
+
+        should "have the correct description" do
+          assert_equal "default group", @security_group.description
+        end
+
+        should "have the correct owner id" do
+          assert_equal "111111111111", @security_group.owner_id
+        end
+
+        should "have 3 group permissions" do
+          assert_equal 3, @security_group.group_permissions.size
+        end
+
+        should "have SecurityGroup::GroupPermission in the group_permissions array" do
+          @security_group.group_permissions.each do |p|
+            assert_equal Awsum::Ec2::SecurityGroup::GroupPermission, p.class
+          end
+        end
+
+        should "have 4 ip permissions" do
+          assert_equal 4, @security_group.ip_permissions.size
+        end
+
+        should "have SecurityGroup::IpPermission in the ip_permissions array" do
+          @security_group.ip_permissions.each do |p|
+            assert_equal Awsum::Ec2::SecurityGroup::IpPermission, p.class
+          end
+        end
+
+        context ", in the first group permission" do
+          setup {
+            @group_permission = @security_group.group_permissions[0]
+          }
+
+          should "have protocol of tcp" do
+            assert_equal 'tcp', @group_permission.protocol
+          end
+
+          should "have from port of 0" do
+            assert_equal 0, @group_permission.from_port
+          end
+
+          should "have to port of 65535" do
+            assert_equal 65535, @group_permission.to_port
+          end
+
+          should "have group of default" do
+            assert_equal 'default', @group_permission.group
+          end
+
+          should "have owner id of 111111111111" do
+            assert_equal '111111111111', @group_permission.user_id
+          end
+        end
+
+        context ", in the first ip permission" do
+          setup {
+            @ip_permission = @security_group.ip_permissions[0]
+          }
+
+          should "have protocol of tcp" do
+            assert_equal 'tcp', @ip_permission.protocol
+          end
+
+          should "have from port of 22" do
+            assert_equal 22, @ip_permission.from_port
+          end
+
+          should "have to port of 22" do
+            assert_equal 22, @ip_permission.to_port
+          end
+
+          should "have ip of 0.0.0.0/0" do
+            assert_equal '0.0.0.0/0', @ip_permission.ip
+          end
+        end
+      end
+    end
+  end
+end

data/test/units/s3/test_bucket.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class BucketsTest < Test::Unit::TestCase
+  context "BucketParser:" do
+    context "Parsing the result of GET" do
+      setup {
+        s3 = Awsum::S3.new('abc', 'xyz')
+        xml = load_fixture('s3/buckets')
+        parser = Awsum::S3::BucketParser.new(s3)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of buckets" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::S3::Bucket)
+      end
+
+      context ", the first bucket" do
+        setup {
+          @bucket = @result[0]
+        }
+
+        should "have the correct name" do
+          assert_equal "test-bucket", @bucket.name
+        end
+
+        should "have the correct creation date" do
+          assert_equal Time.parse("2008-12-04T16:08:03.000Z"), @bucket.creation_date
+        end
+      end
+
+      context ", the second bucket" do
+        setup {
+          @bucket = @result[1]
+        }
+
+        should "have the correct name" do
+          assert_equal "another-test-bucket", @bucket.name
+        end
+
+        should "have the correct creation date" do
+          assert_equal Time.parse("2009-01-02T08:25:27.000Z"), @bucket.creation_date
+        end
+      end
+    end
+  end
+
+  context "Bucket: " do
+    setup {
+      @s3 = Awsum::S3.new('abc', 'xyz')
+    }
+
+    should "be able to create a bucket without calling the S3 API" do
+      bucket = @s3.bucket('test-bucket')
+      assert_equal 'test-bucket', bucket.name
+    end
+  end
+end

data/test/units/s3/test_object.rb

@@ -0,0 +1,111 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class ObjectsTest < Test::Unit::TestCase
+  context "ObjectParser:" do
+    context "Parsing the result of GET" do
+      setup {
+        s3 = Awsum::S3.new('abc', 'xyz')
+        xml = load_fixture('s3/keys')
+        parser = Awsum::S3::ObjectParser.new(s3)
+        @result = parser.parse(xml)
+      }
+
+      should "return an array of objects" do
+        assert @result.is_a?(Array)
+        assert @result[0].is_a?(Awsum::S3::Object)
+      end
+
+      context ", the first object" do
+        setup {
+          @object = @result[0]
+        }
+
+        should "have the correct key" do
+          assert_equal "test/photo1.jpg", @object.key
+        end
+
+        should "have the correct last modification date" do
+          assert_equal Time.parse("2008-12-07T13:47:59.000Z"), @object.last_modified
+        end
+
+        should "have the correct etag" do
+          assert_equal "\"03bde534951a1c099724f569a53acb1e\"", @object.etag
+        end
+
+        should "have the correct size" do
+          assert_equal 203841, @object.size
+        end
+
+        should "have the correct owner id" do
+          assert_equal '1111111111111111111111111111111111111111111111111111111111111111', @object.owner['id']
+        end
+
+        should "have the correct owner name" do
+          assert_equal 'AAAAAA', @object.owner['name']
+        end
+
+        should "have the correct storage class" do
+          assert_equal 'STANDARD', @object.storage_class
+        end
+      end
+
+      context ", the second object" do
+        setup {
+          @object = @result[1]
+        }
+
+        should "have the correct key" do
+          assert_equal "test/photo2.jpg", @object.key
+        end
+
+        should "have the correct last modification date" do
+          assert_equal Time.parse("2008-12-07T13:48:13.000Z"), @object.last_modified
+        end
+      end
+    end
+  end
+
+  context "Objects: " do
+    setup {
+      @s3 = Awsum::S3.new('abc', 'xyz')
+    }
+
+    context "When retrieving object headers" do
+      setup {
+        response = mock('Response')
+        @s3.expects(:send_s3_request).returns(response)
+        @headers = @s3.object_headers('test-bucket', 'test-key')
+      }
+
+      should "be able to retrieve object headers" do
+        assert @headers
+      end
+
+      should "be of class Awsum::S3::Headers" do
+        assert @headers.is_a?(Awsum::S3::Headers)
+      end
+    end
+
+    context "when retrieving object data" do
+      should "be able to retrieve all the data" do
+        response = mock('Response', :body => 'test-data')
+        @s3.expects(:send_s3_request).yields(response)
+
+        assert_equal 'test-data', @s3.object_data('test-bucket', 'test-key')
+      end
+
+      should "be able to retrieve the data in chunks" do
+        response = mock('Response')
+        response.expects(:read_body).yields('test-data')
+        @s3.expects(:send_s3_request).yields(response)
+
+        data = ''
+        @s3.object_data('test-bucket', 'test-key') do |chunk|
+          data << chunk
+        end
+
+        assert_equal 'test-data', data
+      end
+    end
+  end
+end

data/test/units/s3/test_s3.rb

@@ -0,0 +1,298 @@
+require File.expand_path('../../helper', File.dirname(__FILE__))
+
+class S3Test < Test::Unit::TestCase
+  def setup
+    @s3 = Awsum::S3.new('abc', 'xyz')
+  end
+
+  context "Buckets: " do
+    context "naming a bucket" do
+      should "not have an ip address style name" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('192.168.2.1')
+        end
+      end
+
+      should "not start with punctuation" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('-name')
+          @s3.create_bucket('.name')
+          @s3.create_bucket('_name')
+        end
+      end
+
+      should "not end with a dash" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('name-')
+        end
+      end
+
+      should "not have a dash to the left of a period" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('name-.test')
+        end
+      end
+
+      should "not have a dash to the right of a period" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('name.-test')
+        end
+      end
+
+      should "be able to start with a number" do
+        @s3.expects(:send_s3_request)
+
+        assert_nothing_raised do
+          @s3.create_bucket('2name')
+        end
+      end
+
+      should "not be shorter than 3 characters" do
+        assert_raise ArgumentError do
+          @s3.create_bucket('ab')
+        end
+      end
+
+      should "not be longer than 63 characters" do
+        assert_raise ArgumentError do
+          @s3.create_bucket((0..63).collect{'a'}.join)
+        end
+      end
+
+      should "succeed" do
+        response = stub('Http Response', :is_a? => true)
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @s3.create_bucket('test')
+      end
+    end
+
+    context "retrieving a list of buckets" do
+      setup {
+        xml = load_fixture('s3/buckets')
+        response = stub('Http Response', :body => xml)
+        @s3.expects(:send_s3_request).returns(response)
+
+        @result = @s3.buckets
+      }
+
+      should "return an array of buckets" do
+        assert @result.is_a?(Array)
+        assert_equal Awsum::S3::Bucket, @result[0].class
+      end
+    end
+
+    context "deleting a bucket" do
+      setup {
+        response = stub('Http Response', :is_a? => true)
+        @s3.expects(:send_s3_request).returns(response)
+      }
+
+      should "succeed" do
+        assert @s3.delete_bucket('test')
+      end
+    end
+
+    context "a bucket" do
+      setup {
+        @bucket = Awsum::S3::Bucket.new(@s3, 'test', Time.now)
+      }
+
+      should "be able to delete itself" do
+        response = stub('Http Response', :is_a? => true)
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @bucket.delete
+      end
+
+      should "be able to delete itself with Object(s)" do
+        xml = load_fixture('s3/keys')
+        response = stub('Http Response', :is_a? => true, :body => xml)
+        requests = sequence('requests')
+        ['get objects', 'delete first object', 'delete second object', 'delete bucket'].each do |process_request|
+          @s3.expects(:send_s3_request).returns(response).in_sequence(requests)
+        end
+
+        assert @bucket.delete!
+      end
+    end
+  end
+
+  context "Objects: " do
+    context "creating an object" do
+      context "with a string" do
+        setup {
+          response = stub('Http Response', :is_a? => true)
+          @s3.expects(:send_s3_request).returns(response)
+        }
+
+        should "send data" do
+          assert @s3.create_object('test', 'test.txt', 'Some text')
+        end
+      end
+
+      context "with an IO object" do
+        setup {
+          response = stub('Http Response', :is_a? => true)
+          @s3.expects(:process_request).returns(response)
+
+          lstat = stub('lstat', :size => 100)
+          @data = stub('IO', :nil? => false)
+          @data.expects(:respond_to?).at_least_once.returns(true)
+          @data.expects(:lstat).returns(lstat)
+          read_sequence = sequence('read_sequence')
+          @data.expects(:read).returns((1..100).collect{|i| 'x'}.join('')).in_sequence(read_sequence)
+          @data.expects(:read).returns(nil).in_sequence(read_sequence)
+          @data.expects(:rewind).returns(0)
+        }
+
+        should "send data" do
+          assert @s3.create_object('test', 'test.txt', @data)
+        end
+      end
+    end
+
+    context "deleting an object" do
+      setup {
+        response = stub('Http Response', :is_a? => true)
+        @s3.expects(:send_s3_request).returns(response)
+      }
+
+      should "succeed" do
+        @s3.delete_object('test', 'test.txt')
+      end
+    end
+
+    context "copying an object" do
+      context "to a different bucket with same key" do
+        setup {
+          response = stub('Http Response', :is_a? => true, :body => '')
+          @s3.expects(:send_s3_request).returns(response)
+        }
+
+        should "succeed" do
+          assert @s3.copy_object('test', 'test.txt', 'test2')
+        end
+      end
+
+      context "within the same bucket with a different key" do
+        setup {
+          response = stub('Http Response', :is_a? => true, :body => '')
+          @s3.expects(:send_s3_request).returns(response)
+        }
+
+        should "succeed" do
+          assert @s3.copy_object('test', 'test.txt', nil, 'test2.txt')
+        end
+      end
+
+      context "replacing headers and meta-data" do
+        setup {
+          response = stub('Http Response', :is_a? => true, :body => '')
+          @s3.expects(:send_s3_request).returns(response)
+        }
+
+        should "succeed" do
+          assert @s3.copy_object('test', 'test.txt', nil, nil, {'New-Header' => 'two'})
+        end
+      end
+
+      context "within the same bucket, with the same object and with no changed headers" do
+        should "raise an error" do
+          assert_raise ArgumentError do
+            @s3.copy_object('test', 'test.txt')
+          end
+        end
+      end
+
+      context "with a delayed error" do
+        setup {
+          xml = load_fixture('s3/copy_failure')
+          response = stub('Http Response', :is_a? => true, :code => 200, :body => xml)
+          @s3.expects(:send_s3_request).returns(response)
+        }
+
+        should "raise an error" do
+          assert_raise Awsum::Error do
+            @s3.copy_object('test', 'test.txt', 'test2')
+          end
+        end
+      end
+    end
+
+    context "an object" do
+      setup {
+        @object = Awsum::S3::Object.new(@s3, 'test', 'test.txt', Time.now, 'XXXXX', 234, 'AAAAAA', 'STANDARD')
+      }
+
+      should "be able to delete itself" do
+        response = stub('Http Response', :is_a? => true)
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @object.delete
+      end
+
+      should "be able to copy itself to a different key" do
+        response = stub('Http Response', :is_a? => true, :body => '')
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @object.copy('test2.txt')
+      end
+
+      should "be able to rename itself" do
+        response = stub('Http Response', :is_a? => true, :body => '')
+        @s3.expects(:send_s3_request).returns(response).times(2)
+
+        assert @object.rename('test2.txt')
+      end
+
+      should "be able to move itself" do
+        response = stub('Http Response', :is_a? => true, :body => '')
+        @s3.expects(:send_s3_request).returns(response).times(2)
+
+        assert @object.move('test2.txt')
+      end
+
+      should "be able to copy itself to a new bucket" do
+        response = stub('Http Response', :is_a? => true, :body => '')
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @object.copy_to('another_bucket')
+      end
+
+      should "be able to move itself to a new bucket" do
+        response = stub('Http Response', :is_a? => true, :body => '')
+        @s3.expects(:send_s3_request).returns(response).times(2)
+
+        assert @object.move_to('another_bucket')
+      end
+
+      should "be able to return it's headers" do
+        response = stub('Http Response')
+        @s3.expects(:send_s3_request).returns(response)
+
+        assert @object.headers
+      end
+
+      should "be able to return it's data" do
+        response = stub('Http Response', :body => 'test')
+        @s3.expects(:send_s3_request).yields(response)
+
+        assert_equal 'test', @object.data
+      end
+
+      should "be able to return it's data in chunks" do
+        response = stub('Http Response')
+        response.expects(:read_body).yields('test')
+        @s3.expects(:send_s3_request).yields(response)
+
+        data = ''
+        @object.data do |chunk|
+          data << chunk
+        end
+
+        assert_equal 'test', data
+      end
+    end
+  end
+end