fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

data/tests/digitalocean/models/compute/servers_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Compute[:digitalocean] | servers collection', ['digitalocean']) do
+  service = Fog::Compute[:digitalocean]
+
+  options = {
+    :name => "#{fog_server_name}-#{Time.now.to_i.to_s}"
+  }.merge fog_test_server_attributes
+
+  collection_tests(service.servers, options, true) do
+    @instance.wait_for { ready? }
+  end
+
+  tests("#bootstrap").succeeds do
+    pending if Fog.mocking?
+    @server = service.servers.bootstrap({
+      :public_key_path => File.join(File.dirname(__FILE__), '../../fixtures/id_rsa.pub'),
+      :private_key_path => File.join(File.dirname(__FILE__), '../../fixtures/id_rsa')
+    }.merge(options))
+  end
+
+  @server.destroy if @server
+end

data/tests/digitalocean/models/compute/ssh_key_tests.rb

@@ -0,0 +1,44 @@
+Shindo.tests("Fog::Compute[:digitalocean] | ssh_key model", ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('The ssh_key model should') do
+
+    test('#save') do
+      @key = service.ssh_keys.create :name => 'fookey',
+                                     :ssh_pub_key => 'fookey'
+      @key.is_a? Fog::Compute::DigitalOcean::SshKey
+    end
+
+    tests('have the action') do
+      test('reload') { @key.respond_to? 'reload' }
+      %w{
+        save
+        destroy
+      }.each do |action|
+        test(action) { @key.respond_to? action }
+      end
+    end
+
+    tests('have attributes') do
+      attributes = [
+        :id,
+        :name,
+        :ssh_pub_key
+      ]
+
+      tests("The key model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { @key.respond_to? attribute }
+        end
+      end
+    end
+
+    test('#destroy') do
+      @key.destroy
+    end
+
+  end
+
+end
+

data/tests/digitalocean/models/compute/ssh_keys_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests('Fog::Compute[:digitalocean] | ssh_keys collection', ['digitalocean']) do
+
+  service =  Fog::Compute[:digitalocean]
+
+  tests('The ssh_keys collection') do
+    key = service.ssh_keys.create :name => 'fookey',
+                                  :ssh_pub_key => 'fookey'
+    [:all, :get].each do |method|
+      test("should respond to #{method}") do
+        service.ssh_keys.respond_to? method
+      end
+    end
+
+    tests('should have Fog::Compute::DigitalOcean::SshKey inside') do
+      service.ssh_keys.each do |s|
+        test { s.kind_of? Fog::Compute::DigitalOcean::SshKey }
+      end
+    end
+
+    tests('should be able to get a model') do
+      test('by instance id') do
+        retrieved_key = service.ssh_keys.get(key.id)
+        test { retrieved_key.kind_of? Fog::Compute::DigitalOcean::SshKey }
+        test { retrieved_key.name == key.name }
+      end
+    end
+
+    key.destroy
+
+  end
+
+end

data/tests/digitalocean/requests/compute/create_server_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:digitalocean] | create_server request', ['digitalocean', 'compute']) do
+
+  @server_format = {
+    'id'             => Integer,
+    'name'           => String,
+    'image_id'       => Integer,
+    'size_id'        => Integer,
+    'event_id'       => Integer
+  }
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('success') do
+
+    tests('#create_server').formats({'status' => 'OK', 'droplet' => @server_format}) do
+      image = service.images.find { |img| img.name == 'Ubuntu 12.04 x64' }
+      flavor = service.flavors.find { |f| f.name == '512MB' }
+      data = Fog::Compute[:digitalocean].create_server fog_server_name,
+                                                       flavor.id,
+                                                       image.id,
+                                                       service.regions.first.id
+      data.body
+    end
+  end
+end

data/tests/digitalocean/requests/compute/create_ssh_key_tests.rb

@@ -0,0 +1,22 @@
+Shindo.tests('Fog::Compute[:digitalocean] | create_ssh_key request', ['digitalocean', 'compute']) do
+
+  @key_format = {
+    'id'             => Integer,
+    'name'           => String,
+    'ssh_pub_key'    => String
+  }
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('success') do
+
+    tests('#create_ssh_key').formats({'status' => 'OK', 'ssh_key' => @key_format}) do
+      @key = Fog::Compute[:digitalocean].create_ssh_key 'fookey', 'fookey'
+      @key.body
+    end
+    
+  end
+
+  service.destroy_ssh_key @key.body['ssh_key']['id']
+
+end

data/tests/digitalocean/requests/compute/destroy_server_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:digitalocean] | destroy_server request', ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+  server = fog_test_server
+
+  tests('success') do
+
+    test('#destroy_server') do
+      service.destroy_server(server.id).body['status'] == 'OK'
+      service.servers.get(server.id) == nil
+    end
+
+  end
+end

data/tests/digitalocean/requests/compute/destroy_ssh_key_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Compute[:digitalocean] | destroy_ssh_key request', ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('success') do
+
+    test('#destroy_ssh_key') do
+      key = service.create_ssh_key 'fookey', 'fookey'
+      service.destroy_ssh_key(key.body['ssh_key']['id']).body['status'] == 'OK'
+    end
+    
+  end
+
+  tests('failures') do
+    test 'delete invalid key' do
+      # DigitalOcean API returns 500 with this sometimes
+      # so mark it as pending in real mode
+      pending unless Fog.mocking?
+      service.destroy_ssh_key('00000000000').body['status'] == 'ERROR'
+    end
+  end 
+
+end

data/tests/digitalocean/requests/compute/get_server_details_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:digitalocean] | get_server_details request', ['digitalocean', 'compute']) do
+
+  tests('success') do
+
+    test('#get_server_details') do
+      server = fog_test_server
+      body = Fog::Compute[:digitalocean].get_server_details(server.id).body
+      body['droplet']['name'] == fog_server_name
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/get_ssh_key_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:digitalocean] | get_ssh_keys request', ['digitalocean', 'compute']) do
+
+  @ssh_key_format = {
+    'id'             => Integer,
+    'name'           => String,
+    'ssh_pub_key'    => String,
+  }
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('success') do
+
+    tests('#get_ssh_key') do
+      key = service.create_ssh_key 'fookey', 'ssh-dss FOO'
+
+      tests('format').data_matches_schema(@ssh_key_format) do
+        service.get_ssh_key(key.body['ssh_key']['id']).body['ssh_key']
+      end
+
+      service.destroy_ssh_key(key.body['ssh_key']['id'])
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/list_flavors_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Compute[:digitalocean] | list_flavors request', ['digitalocean', 'compute']) do
+
+  # {"id":2,"name":"Amsterdam 1"}
+  @flavor_format = {
+    'id'           => Integer,
+    'name'         => String,
+  }
+
+  tests('success') do
+
+    tests('#list_flavor') do
+      flavors = Fog::Compute[:digitalocean].list_flavors.body
+      test 'returns a Hash' do
+        flavors.is_a? Hash
+      end
+      tests('flavor').formats(@flavor_format, false) do
+        flavors['sizes'].first
+      end
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/list_images_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute[:digitalocean] | list_images request', ['digitalocean', 'compute']) do
+
+  # {"id"=>1601, "name"=>"CentOS 5.8 x64", "distribution"=>"CentOS"}
+  @image_format = {
+    'id'           => Integer,
+    'name'         => String,
+    'distribution' => String
+  }
+
+  tests('success') do
+
+    tests('#list_images') do
+      images = Fog::Compute[:digitalocean].list_images.body
+      test 'returns a Hash' do
+        images.is_a? Hash
+      end
+      tests('image').formats(@image_format, false) do
+        images['images'].first
+      end
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/list_regions_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Compute[:digitalocean] | list_regions request', ['digitalocean', 'compute']) do
+
+  # {"id":2,"name":"Amsterdam 1"}
+  @region_format = {
+    'id'           => Integer,
+    'name'         => String,
+  }
+
+  tests('success') do
+
+    tests('#list_regions') do
+      regions = Fog::Compute[:digitalocean].list_regions.body
+      test 'returns a Hash' do
+        regions.is_a? Hash
+      end
+      tests('region').formats(@region_format, false) do
+        regions['regions'].first
+      end
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/list_servers_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Compute[:digitalocean] | list_servers request', ['digitalocean', 'compute']) do
+  
+  @server_format = {
+    'id'             => Integer,
+    'name'           => String,
+    'image_id'       => Integer,
+    'size_id'        => Integer,
+    'region_id'      => Integer,
+    'backups_active' => Fog::Nullable::Boolean,
+    'ip_address'     => Fog::Nullable::String,
+    'status'         => String
+  }
+
+  tests('success') do
+
+    tests('#list_servers') do
+      Fog::Compute[:digitalocean].list_servers.body['droplets'].each do |server|
+        tests('format').data_matches_schema(@server_format) do
+          server
+        end
+      end
+    end
+
+  end
+
+end

data/tests/digitalocean/requests/compute/list_ssh_keys_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute[:digitalocean] | list_ssh_keys request', ['digitalocean', 'compute']) do
+
+  @ssh_key_format = {
+    'id'           => Integer,
+    'name'         => String
+  }
+
+  tests('success') do
+
+    ssh_key = service.create_ssh_key 'fookey', 'ssh-dss FOO'
+
+    tests('#list_ssh_keys') do
+      service.list_ssh_keys.body['ssh_keys'].each do |key|
+        tests('format').data_matches_schema(@ssh_key_format) do
+          key
+        end
+      end
+    end
+
+    service.destroy_ssh_key(ssh_key.body['ssh_key']['id'])
+
+  end
+
+end

data/tests/digitalocean/requests/compute/power_cycle_server_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute[:digitalocean] | power_cycle_server request', ['digitalocean', 'compute']) do
+
+  server = fog_test_server
+
+  tests('success') do
+
+    tests('#power_cycle_server') do
+      test('returns 200') do
+        service.power_cycle_server(server.id).status == 200
+      end
+      test('state is off') do
+        server.wait_for { server.state == 'off' }
+        server.state == 'off'
+      end
+    end
+    
+  end
+      
+
+end

data/tests/digitalocean/requests/compute/power_state_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:digitalocean] | power on/off/shutdown requests', 
+             ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+  server = fog_test_server
+
+  tests('success') do
+
+    test('#power_off_server') do
+      service.power_off_server(server.id).body['status'] == 'OK'
+    end
+
+    test('#power_on_server') do
+      service.power_on_server(server.id).body['status'] == 'OK'
+    end
+    
+    test('#shutdown_server') do
+      service.shutdown_server(server.id).body['status'] == 'OK'
+    end
+    
+    server.start
+
+  end
+
+end

data/tests/digitalocean/requests/compute/reboot_server_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:digitalocean] | reboot_server request', ['digitalocean', 'compute']) do
+
+  server = fog_test_server
+
+  tests('success') do
+
+    tests('#reboot_server').succeeds do
+      service.reboot_server(server.id).body['status'] == 'OK'
+    end
+    
+  end
+      
+
+end

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

@@ -1,13 +1,11 @@
 Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
 
-  @domain = ''
+  @domain = nil
   @domain_count = 0
 
   tests("success") do
 
     test("get current domain count") do
-      pending if Fog.mocking?
-
       response = Fog::DNS[:dnsimple].list_domains()
       if response.status == 200
         @domain_count = response.body.size
@@ -17,8 +15,6 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
     end
 
     test("create domain") do
-      pending if Fog.mocking?
-
       domain = generate_unique_domain
       response = Fog::DNS[:dnsimple].create_domain(domain)
       if response.status == 201
@@ -29,15 +25,11 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
     end
 
     test("get domain by id") do
-      pending if Fog.mocking?
-
       response = Fog::DNS[:dnsimple].get_domain(@domain["id"])
       response.status == 200
     end
 
     test("create an A resource record") do
-      pending if Fog.mocking?
-
       domain = @domain["name"]
       name = "www"
       type = "A"
@@ -53,48 +45,65 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
     end
 
     test("create a MX record") do
-      pending if Fog.mocking?
-
       domain = @domain["name"]
       name = ""
       type = "MX"
       content = "mail.#{domain}"
-      options = { :ttl => 60, :prio => 10 }
+      options = { "ttl" => 60, "prio" => 10 }
       response = Fog::DNS[:dnsimple].create_record(domain, name, type, content, options)
 
-      response.status == 201
+      test "MX record creation returns 201" do
+        response.status == 201
+      end
+
+      options.each do |key, value|
+        test("MX record has option #{key}") { value == response.body["record"][key.to_s] }
+      end
+
+      test "MX record is correct type" do
+        response.body["record"]["record_type"] == "MX"
+      end
     end
 
-    test("update a record") do
-      pending if Fog.mocking?
+    test("get a record") do
+      domain = @domain["name"]
+      record_id = @record["id"]
+
+      response = Fog::DNS[:dnsimple].get_record(domain, record_id)
+
+      (response.status == 200) and (@record == response.body["record"])
+    end
 
+    test("update a record") do
       domain = @domain["name"]
       record_id = @record["id"]
-      options = { :content => "2.3.4.5", :ttl => 600 }
+      options = { "content" => "2.3.4.5", "ttl" => 600 }
       response = Fog::DNS[:dnsimple].update_record(domain, record_id, options)
       response.status == 200
     end
 
     test("list records") do
-      pending if Fog.mocking?
-
       response = Fog::DNS[:dnsimple].list_records(@domain["name"])
 
       if response.status == 200
         @records = response.body
       end
 
-      (response.status == 200) and (response.body.size == 2)
+      test "list records returns all records for domain" do
+        @records.reject { |record| record["record"]["system_record"] }.size == 2
+      end
+
+      response.status == 200
     end
 
     test("delete records") do
-      pending if Fog.mocking?
       domain = @domain["name"]
 
       result = true
       @records.each do |record|
+        next if record["record"]["system_record"]
         response = Fog::DNS[:dnsimple].delete_record(domain, record["record"]["id"])
-        if(response.status != 200)
+        if response.status != 200
           result = false
           break
         end
@@ -104,15 +113,10 @@ Shindo.tests('Fog::DNS[:dnsimple] | DNS requests', ['dnsimple', 'dns']) do
     end
 
     test("delete domain") do
-      pending if Fog.mocking?
-
       response = Fog::DNS[:dnsimple].delete_domain(@domain["name"])
       response.status == 200
     end
 
   end
 
-  tests( 'failure') do
-  end
-
 end