fog-rackspace 0.1.0

data/tests/rackspace/requests/databases/user_tests.rb

@@ -0,0 +1,37 @@
+Shindo.tests('Fog::Rackspace::Database | user_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Rackspace::Databases.new
+  instance_name = 'fog' + Time.now.to_i.to_s
+  instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
+
+  wait_for_request("Waiting for database to be created") do
+    service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
+  end
+
+  tests('success') do
+    user_name = 'fog' + Time.now.to_i.to_s
+    password = 'password1'
+
+    tests("#create_user(#{instance_id}, #{user_name}, #{password})").returns(202) do
+      service.create_user(instance_id, user_name, password).status
+    end
+
+    tests("#list_users{#{instance_id})").formats(LIST_USERS_FORMAT) do
+      service.list_users(instance_id).body
+    end
+
+    tests("#delete_user(#{instance_id}, #{user_name})").returns(202)  do
+      service.delete_user(instance_id, user_name).status
+    end
+  end
+
+  tests('failure') do
+    tests("#create_user(#{instance_id}, '', '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
+      service.create_user(instance_id, '', '')
+    end
+  end
+
+  service.delete_instance(instance_id)
+end

data/tests/rackspace/requests/dns/dns_tests.rb

@@ -0,0 +1,125 @@
+Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
+
+  pending if Fog.mocking?
+  domain_name = uniq_id + '.com'
+
+  tests('success on simple domain') do
+    domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do
+
+      tests('list_domains').formats(LIST_DOMAIN_FORMAT.reject {|key,value| key == 'links'}) do
+        Fog::DNS[:rackspace].list_domains.body
+      end
+
+      tests("list_domains :limit => 5, :offset => 10, :domain => #{@domain_details.first['name']} --> All possible attributes").formats(LIST_DOMAIN_FORMAT) do
+        Fog::DNS[:rackspace].list_domains(:limit => 5, :offset => 10, :domain => @domain_details.first['name']).body
+      end
+
+      tests("list_domain_details('#{@domain_id}')").formats(LIST_DOMAIN_DETAILS_WITH_RECORDS) do
+        Fog::DNS[:rackspace].list_domain_details(@domain_id).body
+      end
+
+      tests("modify_domain('#{@domain_id}', :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com')").succeeds do
+        response = Fog::DNS[:rackspace].modify_domain @domain_id, :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com'
+        wait_for Fog::DNS[:rackspace], response
+      end
+    end
+  end
+
+  tests('success for domain with multiple records') do
+    domain_tests(Fog::DNS[:rackspace],
+      {
+        :name => domain_name,
+        :email => 'hostmaster@' + domain_name,
+        :records =>
+          [
+            {
+              :ttl => 300,
+              :name => domain_name,
+              :type => 'A',
+              :data => '192.168.1.1'
+            },
+            {
+              :ttl => 3600,
+              :name => domain_name,
+              :type => 'MX',
+              :data => 'mx.' + domain_name,
+              :priority => 10
+            }
+          ]
+     })
+  end
+
+  tests('success for multiple domains') do
+    domain1_name = uniq_id + '-1.com'
+    domain2_name = uniq_id + '-2.com'
+
+    domains_tests(Fog::DNS[:rackspace],
+      [
+        {:name => domain1_name, :email => 'hostmaster@' + domain1_name, :records => [{:ttl => 300, :name => domain1_name, :type => 'A', :data => '192.168.1.1'}]},
+        {:name => domain2_name, :email => 'hostmaster@' + domain2_name, :records => [{:ttl => 300, :name => domain2_name, :type => 'A', :data => '192.168.1.1'}]}
+      ])
+  end
+
+  tests('success for domain with subdomain') do
+    domains_tests(Fog::DNS[:rackspace],
+      [
+        {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]},
+        {:name => 'subdomain.' + domain_name, :email => 'hostmaster@subdomain.' + domain_name, :records => [{:ttl => 300, :name =>'subdomain.' + domain_name, :type => 'A', :data => '192.168.1.1'}]}
+      ], true) do
+
+      @root_domain_id = @domain_details.find { |domain| domain['name'] == domain_name }['id']
+
+      tests("list_domain_details('#{@root_domain_id}', :show_records => false, :show_subdomains => false)") do
+        response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => false, :show_subdomains => false)
+
+        formats(LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body }
+        returns(nil) { response.body['recordsList'] }
+        returns(nil) { response.body['subdomains'] }
+      end
+
+      tests("list_domain_details('#{@root_domain_id}', :show_records => true, :show_subdomains => true)") do
+        response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => true, :show_subdomains => true)
+
+        formats(LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body }
+        returns(false) { response.body['recordsList'].nil? }
+        returns(false) { response.body['subdomains'].nil? }
+      end
+
+      tests("list_subdomains('#{@root_domain_id}')").formats(LIST_SUBDOMAINS_FORMAT) do
+        Fog::DNS[:rackspace].list_subdomains(@root_domain_id).body
+      end
+
+      tests("remove_domain('#{@root_domain_id}', :delete_subdomains => true)") do
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_domain(@root_domain_id, :delete_subdomains => true)
+
+        test('domain and subdomains were really deleted') do
+          (Fog::DNS[:rackspace].list_domains.body['domains'].map { |domain| domain['name'] } & [domain_name, 'subdomain.' + domain_name]).empty?
+        end
+      end
+    end
+  end
+
+  tests( 'failure') do
+
+    tests('create_domain(invalid)').returns('ERROR') do
+      response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].create_domains([{:name => 'badtestdomain.com', :email => '', :records => [{:ttl => 300, :name => 'badtestdomain.com', :type => 'A', :data => '192.168.1.1'}]}])
+
+      response.body['status']
+    end
+
+    tests('list_domains :limit => 5, :offset => 8').raises(Fog::Rackspace::Errors::BadRequest) do
+      Fog::DNS[:rackspace].list_domains :limit => 5, :offset => 8
+    end
+
+    tests('list_domain_details 34335353').raises(Fog::DNS::Rackspace::NotFound) do
+      Fog::DNS[:rackspace].list_domain_details 34335353
+    end
+
+    #tests('create_domains(#{domains})').raises(Fog::Rackspace::Errors::Conflict) do
+    #  wait_for Fog::DNS[:rackspace].create_domains(domains)
+    #end
+    #tests('remove_domain(34343435)').raises(Fog::DNS::Rackspace::DeleteFault) do
+    #  Fog::DNS[:rackspace].remove_domain 34343435
+    #end
+  end
+end

data/tests/rackspace/requests/dns/helper.rb

@@ -0,0 +1,124 @@
+SUBDOMAIN_FORMAT = {
+  'name' => String,
+  'id' => Integer,
+  'created' => String,
+  'updated' => String,
+  'emailAddress' => String
+}
+
+DOMAIN_FORMAT = SUBDOMAIN_FORMAT.merge({
+  'accountId' => Integer
+})
+
+LIST_SUBDOMAINS_FORMAT = {
+  'domains' => [SUBDOMAIN_FORMAT],
+  'totalEntries' => Integer
+}
+
+LIST_DOMAIN_FORMAT = {
+  'domains' => [DOMAIN_FORMAT],
+  'totalEntries' => Integer,
+  'links' => [
+    {
+      'rel' => String,
+      'href' => String
+    }
+  ]
+}
+
+RECORD_FORMAT = {
+  'name' => String,
+  'id' => String,
+  'type' => String,
+  'data' => String,
+  'updated' => String,
+  'created' => String,
+  'ttl' => Integer,
+  'priority' => Fog::Nullable::Integer
+}
+
+RECORD_LIST_FORMAT = {
+  'records' => [RECORD_FORMAT],
+  #In some cases this is returned (domain details) and in some cases it isn't (create domain).  Marking as nullable.
+  'totalEntries' => Fog::Nullable::Integer
+}
+
+NAME_SERVERS_FORMAT = [{
+  'name' => String
+}]
+
+BASIC_DOMAIN_DETAIL_FORMAT = DOMAIN_FORMAT.merge({
+  'nameservers' => NAME_SERVERS_FORMAT,
+  'ttl' => Integer
+})
+
+LIST_DOMAIN_DETAILS_WITH_RECORDS = BASIC_DOMAIN_DETAIL_FORMAT.merge({
+  'recordsList' => RECORD_LIST_FORMAT
+})
+
+LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT.merge({
+  'recordsList'     => RECORD_LIST_FORMAT,
+  'subdomains'      => {
+    'domains'   => [SUBDOMAIN_FORMAT],
+    'totalEntries'  => Integer
+  }
+})
+
+LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT
+
+CREATE_DOMAINS_FORMAT = {
+  'domains' => [
+    BASIC_DOMAIN_DETAIL_FORMAT.merge({
+      'recordsList' => RECORD_LIST_FORMAT
+    })
+  ]
+}
+
+def wait_for(service, response)
+  job_id = response.body['jobId']
+  Fog.wait_for do
+    response = service.callback(job_id)
+    response.body['status'] != 'RUNNING'
+  end
+  response
+end
+
+def domain_tests(service, domain_attributes)
+  tests("create_domains([#{domain_attributes}])").formats(CREATE_DOMAINS_FORMAT) do
+    response = wait_for service, service.create_domains([domain_attributes])
+    @domain_details = response.body['response']['domains']
+    @domain_id = @domain_details[0]['id']
+    response.body['response']
+  end
+
+  begin
+    if block_given?
+      yield
+    end
+  ensure
+    tests("remove_domain('#{@domain_id}')").succeeds do
+      wait_for service, service.remove_domain(@domain_id)
+    end
+  end
+end
+
+def domains_tests(service, domains_attributes, custom_delete = false)
+  tests("create_domains(#{domains_attributes})").formats(CREATE_DOMAINS_FORMAT) do
+    response = wait_for service, service.create_domains(domains_attributes)
+    @domain_details = response.body['response']['domains']
+    @domain_ids = @domain_details.map { |domain| domain['id'] }
+    response.body['response']
+  end
+
+  begin
+    if block_given?
+      yield
+    end
+  ensure
+    if !custom_delete
+      tests("remove_domains(#{@domain_ids})").succeeds do
+        wait_for service, service.remove_domains(@domain_ids)
+      end
+    end
+  end
+end

data/tests/rackspace/requests/dns/records_tests.rb

@@ -0,0 +1,83 @@
+Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']) do
+
+  pending if Fog.mocking?
+
+  domain_name = uniq_id + '.com'
+
+  domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do
+
+    tests('success on single record') do
+
+      tests("list_records(#{@domain_id})").formats(RECORD_LIST_FORMAT) do
+        Fog::DNS[:rackspace].list_records(@domain_id).body
+      end
+
+      tests("add_records(#{@domain_id}, [{ :name => 'test1.#{domain_name}', :type => 'A', :data => '192.168.2.1', :ttl => 550}])").formats(RECORD_LIST_FORMAT) do
+        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1', :ttl => 550}])
+        @record_id = response.body['response']['records'].first['id']
+        response.body['response']
+      end
+
+      tests("list_record_details(#{@domain_id}, #{@record_id})").formats(RECORD_FORMAT) do
+        Fog::DNS[:rackspace].list_record_details(@domain_id, @record_id).body
+      end
+
+      tests("modify_record(#{@domain_id}, #{@record_id}, { :ttl => 500, :name => 'test2.#{domain_name}', :data => '192.168.3.1' })").succeeds do
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].modify_record(@domain_id, @record_id, { :ttl => 500, :name => 'test2.' + domain_name, :data => '192.168.3.1' })
+      end
+
+      tests("remove_record(#{@domain_id}, #{@record_id})").succeeds do
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_record(@domain_id, @record_id)
+      end
+    end
+
+    tests('success on multiple records') do
+
+      records_attributes =
+        [
+          { :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1'},
+          { :name => domain_name, :type => 'MX', :priority => 10, :data => 'mx.' + domain_name}
+        ]
+
+      tests("add_records(#{@domain_id}, #{records_attributes})").formats(RECORD_LIST_FORMAT) do
+        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, records_attributes)
+        @record_ids = response.body['response']['records'].map { |record| record['id'] }
+        response.body['response']
+      end
+
+      tests("remove_records(#{@domain_id}, #{@record_ids})").succeeds do
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_records(@domain_id, @record_ids)
+      end
+    end
+
+    tests( 'failure') do
+      tests("list_records('')").raises(ArgumentError) do
+        Fog::DNS[:rackspace].list_records('')
+      end
+
+      tests("list_records('abc')").raises(Fog::DNS::Rackspace::NotFound) do
+        Fog::DNS[:rackspace].list_records('abc')
+      end
+
+      tests("list_record_details(#{@domain_id}, '')").raises(ArgumentError) do
+        Fog::DNS[:rackspace].list_record_details(@domain_id, '')
+      end
+
+      tests("list_record_details(#{@domain_id}, 'abc')").raises(Fog::DNS::Rackspace::NotFound) do
+        Fog::DNS[:rackspace].list_record_details(@domain_id, 'abc')
+      end
+
+      tests("remove_record(#{@domain_id}, '')").raises(ArgumentError) do
+        Fog::DNS[:rackspace].remove_record(@domain_id, '')
+      end
+
+      tests("remove_record(#{@domain_id}, 'abc')").raises(Fog::DNS::Rackspace::NotFound) do
+        Fog::DNS[:rackspace].remove_record(@domain_id, 'abc')
+      end
+
+      tests("add_record(#{@domain_id}, [{ :name => '', :type => '', :data => ''}])").raises(Fog::Rackspace::Errors::BadRequest) do
+        Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => '', :type => '', :data => ''}])
+      end
+    end
+  end
+end

data/tests/rackspace/requests/identity/tenants_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Rackspace::Identity | tenants', ['rackspace']) do
+
+  pending if Fog.mock?
+
+  TENANTS_FORMATS = {
+    'tenants' => [{
+      'id' => String,
+      'name' => String,
+      'description' => Fog::Nullable::String,
+      'enabled' => Fog::Nullable::Boolean
+    }]
+  }
+
+  service = Fog::Rackspace::Identity.new
+
+  tests('success') do
+    tests('#list_tenants').formats(TENANTS_FORMATS) do
+      service.list_tenants().body
+    end
+  end
+end

data/tests/rackspace/requests/identity/token_tests.rb

@@ -0,0 +1,70 @@
+Shindo.tests('Fog::Rackspace::Identity | tokens', ['rackspace']) do
+  ROLE_FORMAT = {
+    'id' => String,
+    'name' => String,
+    'description' => String
+  }
+
+  ENDPOINT_FORMAT = {
+    'tenantId' => String,
+    'publicURL' => Fog::Nullable::String,
+    'internalURL' => Fog::Nullable::String,
+    'region' => Fog::Nullable::String,
+    'versionId' => Fog::Nullable::String,
+    'versionInfo' => Fog::Nullable::String,
+    'versionList' => Fog::Nullable::String
+  }
+
+  SERVICE_FORMAT = {
+    'name' => String,
+    'type' => String,
+    'endpoints' => [ENDPOINT_FORMAT]
+  }
+
+  ACCESS_FORMAT = {
+    'access' => {
+      'token' => {
+        'id' => String,
+        'expires' => String,
+        'tenant' => {
+          'id' => String,
+          'name' => String
+        }
+      },
+      'user' => {
+        'id' => String,
+        'name' => String,
+        'roles' => [ROLE_FORMAT]
+      },
+      'serviceCatalog' => [SERVICE_FORMAT]
+    }
+  }
+
+  service = Fog::Rackspace::Identity.new
+
+  tests('success') do
+    credentials = Fog.credentials
+    username = credentials[:rackspace_username]
+    api_key = credentials[:rackspace_api_key]
+
+    tests('#create_token').formats(ACCESS_FORMAT) do
+      service.create_token(username, api_key).body
+    end
+
+    tests('uses connection options').returns(true) do
+      pending if Fog.mocking?
+      identity_service = Fog::Rackspace::Identity.new(:connection_options => { :ssl_verify_peer => true })
+
+      connection = identity_service.instance_variable_get("@connection")
+      excon = connection.instance_variable_get("@excon")
+      data = excon.instance_variable_get("@data")
+      data.key?(:ssl_verify_peer)
+    end
+  end
+
+  tests('failure') do
+    tests('#create_token(invalidname, invalidkey').raises(Excon::Errors::HTTPStatusError) do
+      service.create_token('baduser', 'badkey')
+    end
+  end
+end