phpfog-fog 0.4.1

data/spec/vcloud/terremark/ecloud/requests/power_on_spec.rb

@@ -0,0 +1,34 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :power_on }
+
+    describe :power_on, :type => :vcloud_request do
+      context "with a valid vapp uri" do
+        before { @mock_vm.power_off!; @power_on = @vcloud.power_on(@mock_vm.href(:power_on)) }
+        subject { @power_on }
+
+        it_should_behave_like "all responses"
+        #it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
+
+        specify { @mock_vm.status.should == 4 }
+
+        describe :body do
+          subject { @power_on.body }
+
+          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
+        end
+      end
+
+      context "with a vapp uri that doesn't exist" do
+        subject { lambda { @vcloud.power_on(URI.parse('https://www.fakey.com/api/v0.8/vapp/9999')) } }
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
+    end
+  end
+else
+end
+

data/spec/vcloud/vcloud_spec.rb

@@ -0,0 +1,18 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "https://fakey.com/api/versions") }
+
+    it { should be_an_instance_of Fog::Vcloud::Mock }
+
+    it { should respond_to :default_organization_uri }
+
+    it { should respond_to :supported_versions }
+
+    it { should have_at_least(1).supported_versions }
+
+    its(:default_organization_uri) { should == @mock_organization.href }
+
+  end
+end

data/tests/aws/requests/iam/access_key_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('AWS::IAM | access key requests', ['aws']) do
+
+  unless Fog.mocking?
+    AWS[:iam].create_user('fog_access_key_tests')
+  end
+
+  tests('success') do
+
+    @access_key_format = {
+      'AccessKey' => {
+        'AccessKeyId'     => String,
+        'UserName'        => String,
+        'SecretAccessKey' => String,
+        'Status'          => String
+      },
+      'RequestId' => String
+    }
+
+    tests("#create_access_key('UserName' => 'fog_access_key_tests')").formats(@access_key_format) do
+      pending if Fog.mocking?
+      data = AWS[:iam].create_access_key('UserName' => 'fog_access_key_tests').body
+      @access_key_id = data['AccessKey']['AccessKeyId']
+      data
+    end
+
+    @access_keys_format = {
+      'AccessKeys' => [{
+        'AccessKeyId' => String,
+        'Status'      => String
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_access_keys('Username' => 'fog_access_key_tests')").formats(@access_keys_format) do
+      pending if Fog.mocking?
+      AWS[:iam].list_access_keys('UserName' => 'fog_access_key_tests').body
+    end
+
+    tests("#update_access_key('#{@access_key_id}', 'Inactive', 'UserName' => 'fog_access_key_tests')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].update_access_key(@access_key_id, 'Inactive', 'UserName' => 'fog_access_key_tests').body
+    end
+
+    tests("#delete_access_key('#{@access_key_id}', 'UserName' => 'fog_access_key_tests)").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].delete_access_key(@access_key_id, 'UserName' => 'fog_access_key_tests').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  unless Fog.mocking?
+    AWS[:iam].delete_user('fog_access_key_tests')
+  end
+
+end

data/tests/aws/requests/iam/group_policy_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('AWS::IAM | group policy requests', ['aws']) do
+
+  unless Fog.mocking?
+    AWS[:iam].create_group('fog_group_policy_tests')
+  end
+
+  tests('success') do
+
+    @policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+    tests("#put_group_policy('fog_group_policy_tests', 'fog_policy', #{@policy.inspect})").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].put_group_policy('fog_group_policy_tests', 'fog_policy', @policy).body
+    end
+
+    @group_policies_format = {
+      'IsTruncated' => Fog::Boolean,
+      'PolicyNames' => [String],
+      'RequestId'   => String
+    }
+
+    tests("list_group_policies('fog_group_policy_tests')").formats(@group_policies_format) do
+      pending if Fog.mocking?
+      AWS[:iam].list_group_policies('fog_group_policy_tests').body
+    end
+
+    tests("#delete_group_policy('fog_group_policy_tests', 'fog_policy')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].delete_group_policy('fog_group_policy_tests', 'fog_policy').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  unless Fog.mocking?
+    AWS[:iam].delete_group('fog_group_policy_tests')
+  end
+
+end

data/tests/aws/requests/iam/group_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests('AWS::IAM | group requests', ['aws']) do
+
+  tests('success') do
+
+    @group_format = {
+      'Group' => {
+        'Arn'       => String,
+        'GroupId'   => String,
+        'GroupName' => String,
+        'Path'      => String
+      },
+      'RequestId' => String
+    }
+
+    tests("#create_group('fog_group')").formats(@group_format) do
+      pending if Fog.mocking?
+      AWS[:iam].create_group('fog_group').body
+    end
+
+    @groups_format = {
+      'Groups' => [{
+        'Arn'       => String,
+        'GroupId'   => String,
+        'GroupName' => String,
+        'Path'      => String
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_groups").formats(@groups_format) do
+      pending if Fog.mocking?
+      AWS[:iam].list_groups.body
+    end
+
+    tests("#delete_group('fog_group')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].delete_group('fog_group').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+end

data/tests/aws/requests/iam/helper.rb

@@ -0,0 +1,15 @@
+class AWS
+
+  module IAM
+
+    module Formats
+
+      BASIC = {
+        'RequestId' => String
+      }
+
+    end
+
+  end
+
+end

data/tests/aws/requests/iam/user_policy_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
+
+  unless Fog.mocking?
+    AWS[:iam].create_user('fog_user_policy_tests')
+  end
+
+  tests('success') do
+
+    @policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+    tests("#put_user_policy('fog_user_policy_tests', 'fog_policy', #{@policy.inspect})").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].put_user_policy('fog_user_policy_tests', 'fog_policy', @policy).body
+    end
+
+    @user_policies_format = {
+      'IsTruncated' => Fog::Boolean,
+      'PolicyNames' => [String],
+      'RequestId'   => String
+    }
+
+    tests("list_user_policies('fog_user_policy_tests')").formats(@user_policies_format) do
+      pending if Fog.mocking?
+      AWS[:iam].list_user_policies('fog_user_policy_tests').body
+    end
+
+    tests("#delete_user_policy('fog_user_policy_tests', 'fog_policy')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].delete_user_policy('fog_user_policy_tests', 'fog_policy').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  unless Fog.mocking?
+    AWS[:iam].delete_user('fog_user_policy_tests')
+  end
+
+end

data/tests/aws/requests/iam/user_tests.rb

@@ -0,0 +1,65 @@
+Shindo.tests('AWS::IAM | user requests', ['aws']) do
+
+  unless Fog.mocking?
+    AWS[:iam].create_group('fog_user_tests')
+  end
+
+  tests('success') do
+
+    @user_format = {
+      'User' => {
+        'Arn'       => String,
+        'Path'      => String,
+        'UserId'    => String,
+        'UserName'  => String
+      },
+      'RequestId' => String
+    }
+
+    tests("#create_user('fog_user')").formats(@user_format) do
+      pending if Fog.mocking?
+      AWS[:iam].create_user('fog_user').body
+    end
+
+    @users_format = {
+      'Users' => [{
+        'Arn'       => String,
+        'Path'      => String,
+        'UserId'    => String,
+        'UserName'  => String
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_users").formats(@users_format) do
+      pending if Fog.mocking?
+      AWS[:iam].list_users.body
+    end
+
+    tests("#add_user_to_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].add_user_to_group('fog_user_tests', 'fog_user').body
+    end
+
+    tests("#remove_user_from_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].remove_user_from_group('fog_user_tests', 'fog_user').body
+    end
+
+    tests("#delete_user('fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      pending if Fog.mocking?
+      AWS[:iam].delete_user('fog_user').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  unless Fog.mocking?
+    AWS[:iam].delete_group('fog_user_tests')
+  end
+
+end

data/tests/aws/requests/simpledb/attributes_tests.rb

@@ -0,0 +1,75 @@
+Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
+
+  @domain_name = "fog_domain_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  AWS[:sdb].create_domain(@domain_name)
+
+  tests('success') do
+
+    tests("#batch_put_attributes('#{@domain_name}', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'a').body['Attributes']").returns({'b' => ['c']}) do
+      attributes = {}
+      Fog.wait_for {
+        attributes = AWS[:sdb].get_attributes(@domain_name, 'a').body['Attributes']
+        attributes != {}
+      }
+      attributes
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'notanattribute')").succeeds do
+      AWS[:sdb].get_attributes(@domain_name, 'notanattribute')
+    end
+
+    tests("#select('select * from #{@domain_name}').body['Items']").returns({ 'a' => { 'b' => ['c'] }, 'x' => { 'y' => ['z'] } }) do
+      pending if Fog.mocking?
+      AWS[:sdb].select("select * from #{@domain_name}").body['Items']
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '1' }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '1' }).body
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body
+    end
+
+    tests("#delete_attributes('#{@domain_name}', 'a').body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].delete_attributes(@domain_name, 'a').body
+    end
+
+    tests("#delete_attributes('#{@domain_name}', 'a').body").succeeds do
+      AWS[:sdb].delete_attributes(@domain_name, 'a').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+    end
+
+    tests("#get_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].get_attributes('notadomain', 'a')
+    end
+
+    tests("#put_attributes('notadomain', 'conditional', { 'version' => '1' })").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].put_attributes('notadomain', 'foo', { 'version' => '1' })
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])").raises(Excon::Errors::Conflict) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])
+    end
+
+    tests("#delete_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].delete_attributes('notadomain', 'a')
+    end
+
+  end
+
+  AWS[:sdb].delete_domain(@domain_name)
+
+end

data/tests/aws/requests/simpledb/domain_tests.rb

@@ -0,0 +1,51 @@
+Shindo.tests('AWS::SimpleDB | domain requests', ['aws']) do
+
+  @domain_metadata_format = AWS::SimpleDB::Formats::BASIC.merge({
+    'AttributeNameCount'        => Integer,
+    'AttributeNamesSizeBytes'   => Integer,
+    'AttributeValueCount'       => Integer,
+    'AttributeValuesSizeBytes'  => Integer,
+    'ItemCount'                 => Integer,
+    'ItemNamesSizeBytes'        => Integer,
+    'Timestamp'                 => Time
+  })
+
+  @domain_name = "fog_domain_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  tests('success') do
+
+    tests("#create_domain(#{@domain_name})").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].create_domain(@domain_name).body
+    end
+
+    tests("#create_domain(#{@domain_name})").succeeds do
+      AWS[:sdb].create_domain(@domain_name)
+    end
+
+    tests("#domain_metadata(#{@domain_name})").formats(@domain_metadata_format) do
+      AWS[:sdb].domain_metadata(@domain_name).body
+    end
+
+    tests("#list_domains").formats(AWS::SimpleDB::Formats::BASIC.merge('Domains' => [String])) do
+      AWS[:sdb].list_domains.body
+    end
+
+    tests("#delete_domain(#{@domain_name})").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].delete_domain(@domain_name).body
+    end
+
+    tests("#delete_domain(#{@domain_name})").succeeds do
+      AWS[:sdb].delete_domain(@domain_name)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#domain_metadata('notadomain')").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].domain_metadata('notadomain')
+    end
+
+  end
+
+end

data/tests/aws/requests/simpledb/helper.rb

@@ -0,0 +1,16 @@
+class AWS
+
+  module SimpleDB
+
+    module Formats
+
+      BASIC = {
+        'BoxUsage'  => Float,
+        'RequestId' => String
+      }
+
+    end
+
+  end
+
+end

data/tests/compute/helper.rb

@@ -0,0 +1,36 @@
+def compute_providers
+  {
+    AWS       => {
+      :server_attributes => {
+        :image_id => 'ami-1a837773' # image ami-1a837773 = Ubuntu
+      },
+      :mocked => true
+    },
+    Bluebox   => {
+      :server_attributes => {
+        :image_id => 'a00baa8f-b5d0-4815-8238-b471c4c4bf72' # Ubuntu 9.10 64bit
+      },
+      :mocked => false
+    },
+    Brightbox => {
+      :server_attributes => {
+        :image_id => 'img-9vxqi' # image img-9vxqi = Ubuntu Maverick 10.10 server
+      },
+      :mocked => false
+    },
+    Rackspace => {
+      :server_attributes => {
+        :image_id => 49, # image 49 = Ubuntu 10.04 LTS (lucid)
+        :name     => "fog_#{Time.now.to_i}"
+      },
+      :mocked => true
+    },
+    Slicehost => {
+      :server_attributes => {
+        :image_id => 49, # image 49 = Ubuntu 10.04 LTS (lucid)
+        :name     => "fog_#{Time.now.to_i}"
+      },
+      :mocked => false
+    }
+  }
+end

data/tests/compute/models/flavors_tests.rb

@@ -0,0 +1,9 @@
+for provider, config in compute_providers
+
+  Shindo.tests("#{provider}::Compute | flavors", [provider.to_s.downcase]) do
+
+    flavors_tests(provider[:compute], (config[:flavors_attributes] || {}), config[:mocked])
+
+  end
+
+end

data/tests/compute/models/server_tests.rb

@@ -0,0 +1,9 @@
+for provider, config in compute_providers
+
+  Shindo.tests("#{provider}::Compute | server", [provider.to_s.downcase]) do
+
+    server_tests(provider[:compute], (config[:server_attributes] || {}), config[:mocked])
+
+  end
+
+end

data/tests/compute/models/servers_tests.rb

@@ -0,0 +1,9 @@
+for provider, config in compute_providers
+
+  Shindo.tests("#{provider}::Compute | servers", [provider.to_s.downcase]) do
+
+    servers_tests(provider[:compute], (config[:server_attributes] || {}), config[:mocked])
+
+  end
+
+end

data/tests/compute/requests/aws/address_tests.rb

@@ -0,0 +1,76 @@
+Shindo.tests('AWS::Compute | address requests', ['aws']) do
+
+  @addresses_format = {
+    'addressesSet' => [{
+      'instanceId'  => NilClass,
+      'publicIp'    => String
+    }],
+    'requestId' => String
+  }
+
+  @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
+  @server.wait_for { ready? }
+  @ip_address = @server.ip_address
+
+  tests('success') do
+
+    @public_ip = nil
+
+    tests('#allocate_address').formats({'publicIp' => String, 'requestId' => String}) do
+      data = AWS[:compute].allocate_address.body
+      @public_ip = data['publicIp']
+      data
+    end
+
+    tests('#describe_addresses').formats(@addresses_format) do
+      AWS[:compute].describe_addresses.body
+    end
+
+    tests("#describe_addresses('public-ip' => #{@public_Ip}')").formats(@addresses_format) do
+      AWS[:compute].describe_addresses('public-ip' => @public_ip).body
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '#{@public_Ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].associate_address(@server.identity, @public_ip).body
+    end
+
+    tests("#dissassociate_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].disassociate_address(@public_ip).body
+    end
+
+    tests("#release_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].release_address(@public_ip).body
+    end
+
+  end
+  tests ('failure') do
+
+    @address = AWS[:compute].addresses.create
+
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].associate_address('i-00000000', @address.identity)
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].associate_address(@server.identity, '127.0.0.1')
+    end
+
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].associate_address('i-00000000', '127.0.0.1')
+    end
+
+    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].disassociate_address('127.0.0.1')
+    end
+
+    tests("#release_address('127.0.0.1')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].release_address('127.0.0.1')
+    end
+
+    @address.destroy
+
+  end
+
+  @server.destroy
+
+end

data/tests/compute/requests/aws/availability_zone_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('AWS::Compute | availability zone requests', ['aws']) do
+
+  @availability_zones_format = {
+    'availabilityZoneInfo'  => [{
+      'messageSet'  => [],
+      'regionName'  => String,
+      'zoneName'    => String,
+      'zoneState'   => String
+    }],
+    'requestId'             => String
+  }
+
+  tests('success') do
+
+    tests('#describe_availability_zones').formats(@availability_zones_format) do
+      AWS[:compute].describe_availability_zones.body
+    end
+
+    tests("#describe_availability_zones('zone-name' => 'us-east-1a')").formats(@availability_zones_format) do
+      AWS[:compute].describe_availability_zones('zone-name' => 'us-east-1a').body
+    end
+
+  end
+
+end

data/tests/compute/requests/aws/helper.rb

@@ -0,0 +1,20 @@
+class AWS
+
+  module Compute
+
+    module Formats
+
+      BASIC = {
+        'requestId' => String,
+        'return'    => ::Fog::Boolean
+      }
+
+    end
+
+  end
+
+end
+
+unless defined?(GENTOO_AMI)
+  GENTOO_AMI = 'ami-5ee70037'
+end