fog 0.3.34 → 0.4.0

data/tests/compute/requests/brightbox/load_balancer_tests.rb

@@ -0,0 +1,74 @@
+Shindo.tests('Brightbox::Compute | load balancer requests', ['brightbox']) do
+
+  tests('success') do
+
+    unless Fog.mocking?
+      @node = Brightbox[:compute].servers.create(:image_id => Brightbox::Compute::TestSupport::IMAGE_IDENTIFER)
+      node_id = @node.id
+    end
+
+    creation_args = {
+      :nodes => [{
+        :node => node_id
+      }],
+      :listeners => [{
+        :in       => 80,
+        :out      => 8080,
+        :protocol => "http"
+      }],
+      :healthcheck => {
+        :type => "http",
+        :port => 80
+      }
+    }
+
+    tests("#create_load_balancer(#{creation_args.inspect})").formats(Brightbox::Compute::Formats::Full::LOAD_BALANCER) do
+      pending if Fog.mocking?
+      data = Brightbox[:compute].create_load_balancer(creation_args)
+      @load_balancer_id = data["id"]
+      data
+    end
+
+    unless Fog.mocking?
+      Brightbox[:compute].load_balancers.get(@load_balancer_id).wait_for { ready? }
+    end
+
+    # tests("#list_load_balancers()").formats(Brightbox::Compute::Formats::Collection::LOAD_BALANCERS) do
+    #   Brightbox[:compute].list_load_balancers
+    # end
+
+    tests("#get_load_balancer('#{@load_balancer_id}')").formats(Brightbox::Compute::Formats::Full::LOAD_BALANCER) do
+      pending if Fog.mocking?
+      Brightbox[:compute].get_load_balancer(@load_balancer_id)
+    end
+
+    tests("#destroy_load_balancer('#{@load_balancer_id}')").formats(Brightbox::Compute::Formats::Full::LOAD_BALANCER) do
+      pending if Fog.mocking?
+      Brightbox[:compute].destroy_load_balancer(@load_balancer_id)
+    end
+
+    unless Fog.mocking?
+      @node.destroy
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#create_load_balancer").raises(Excon::Errors::BadRequest) do
+      pending if Fog.mocking?
+      Brightbox[:compute].create_load_balancer
+    end
+
+    tests("#get_load_balancer('lba-00000')").raises(Excon::Errors::NotFound) do
+      pending if Fog.mocking?
+      Brightbox[:compute].get_load_balancer('lba-00000')
+    end
+
+    tests("#get_load_balancer").raises(ArgumentError) do
+      pending if Fog.mocking?
+      Brightbox[:compute].get_load_balancer
+    end
+  end
+
+end

data/tests/{brightbox/requests/compute → compute/requests/brightbox}/server_tests.rb

@@ -64,6 +64,7 @@ Shindo.tests('Brightbox::Compute | server requests', ['brightbox']) do
       pending if Fog.mocking?
       Brightbox[:compute].get_server
     end
+
   end
 
 end

data/tests/{brightbox/requests/compute → compute/requests/brightbox}/server_type_tests.rb

@@ -27,6 +27,7 @@ Shindo.tests('Brightbox::Compute | server type requests', ['brightbox']) do
       pending if Fog.mocking?
       Brightbox[:compute].get_server_type
     end
+
   end
 
 end

data/tests/{brightbox/requests/compute → compute/requests/brightbox}/zone_tests.rb

@@ -27,6 +27,7 @@ Shindo.tests('Brightbox::Compute | zone requests', ['brightbox']) do
       pending if Fog.mocking?
       Brightbox[:compute].get_zone
     end
+
   end
 
 end

data/tests/{rackspace/requests/compute → compute/requests/rackspace}/image_tests.rb

@@ -1,24 +1,22 @@
 Shindo.tests('Rackspace::Compute | image requests', ['rackspace']) do
 
-  @images_format = {
+  @image_format = {
+    'created'   => Fog::Nullable::String,
     'id'        => Integer,
     'name'      => String,
+    'progress'  => Fog::Nullable::Integer,
+    'serverId'  => Fog::Nullable::Integer,
     'status'    => String,
-    'updated'   => String,
+    'updated'   => String
   }
 
-  @image_format = @images_format.merge({
-    'created'  => String,
-    'progress' => Integer,
-  })
-
   tests('success') do
 
     @server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
     @server.wait_for { ready? }
     @image_id = nil
 
-    tests("#create_image(#{@server.id})").formats(@images_format.merge('serverId' => Integer)) do
+    tests("#create_image(#{@server.id})").formats(@image_format) do
       data = Rackspace[:compute].create_image(@server.id).body['image']
       @image_id = data['id']
       data
@@ -37,7 +35,7 @@ Shindo.tests('Rackspace::Compute | image requests', ['rackspace']) do
       Rackspace[:compute].list_images.body
     end
 
-    tests('#list_images_detail').formats({'images' => [@images_format]}) do
+    tests('#list_images_detail').formats({'images' => [@image_format]}) do
       Rackspace[:compute].list_images_detail.body
     end
 

data/tests/compute/requests/rackspace/resize_tests.rb

@@ -0,0 +1,33 @@
+Shindo.tests('Rackspace::Compute | resize request', ['rackspace']) do
+
+    @confirm_server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+
+    @revert_server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+
+    @confirm_server.wait_for { ready? }
+    tests("#resize_server(#{@confirm_server.id}, 2) # to confirm").succeeds do
+      Rackspace[:compute].resize_server(@confirm_server.id, 2)
+    end
+
+    @revert_server.wait_for { ready? }
+    tests("#resize_server(#{@revert_server.id}, 2) # to revert").succeeds do
+      Rackspace[:compute].resize_server(@revert_server.id, 2)
+    end
+
+    @confirm_server.wait_for { status == 'VERIFY_RESIZE' }
+    tests("#confirm_resized_server(#{@confirm_server.id})").succeeds do
+      Rackspace[:compute].confirm_resized_server(@confirm_server.id)
+    end
+
+    @revert_server.wait_for { status == 'VERIFY_RESIZE' }
+    tests("#revert_resized_server(#{@revert_server.id})").succeeds do
+      Rackspace[:compute].revert_resized_server(@revert_server.id)
+    end
+
+    @confirm_server.wait_for { ready? }
+    @confirm_server.destroy
+
+    @revert_server.wait_for { ready? }
+    @revert_server.destroy
+
+end

data/tests/dns/helper.rb

@@ -0,0 +1,19 @@
+def dns_providers
+  {
+    AWS       => {
+      :mocked => false
+    },
+    Linode    => {
+      :mocked => false,
+      :zone_attributes => {
+        :email => 'fog@example.com'
+      }
+    },
+    Slicehost => {
+      :mocked => false
+    },
+    Zerigo    => {
+      :mocked => false
+    }
+  }
+end

data/tests/dns/models/record_tests.rb

@@ -0,0 +1,25 @@
+for provider, config in dns_providers
+
+  Shindo.tests("#{provider}::DNS | record", [provider.to_s.downcase]) do
+
+    record_attributes = {
+      :ip => '1.2.3.4',
+      :name => 'www.fogrecordtests.com',
+      :type => 'A'
+    }.merge!(config[:record_attributes] || {})
+
+    if !Fog.mocking? || config[:mocked]
+      zone_attributes = {
+        :domain => 'fogrecordtests.com'
+      }.merge(config[:zone_attributes] || {})
+
+      @zone = provider[:dns].zones.create(zone_attributes)
+
+      model_tests(@zone.records, record_attributes, config[:mocked])
+
+      @zone.destroy
+    end
+
+  end
+
+end

data/tests/dns/models/records_tests.rb

@@ -0,0 +1,25 @@
+for provider, config in dns_providers
+
+  Shindo.tests("#{provider}::DNS | records", [provider.to_s.downcase]) do
+
+    record_attributes = {
+      :ip => '1.2.3.4',
+      :name => 'www.fogrecordstests.com',
+      :type => 'A'
+    }.merge!(config[:record_attributes] || {})
+
+    if !Fog.mocking? || config[:mocked]
+      zone_attributes = {
+        :domain => 'fogrecordstests.com'
+      }.merge(config[:zone_attributes] || {})
+
+      @zone = provider[:dns].zones.create(zone_attributes)
+
+      collection_tests(@zone.records, record_attributes, config[:mocked])
+
+      @zone.destroy
+    end
+
+  end
+
+end

data/tests/dns/models/zone_tests.rb

@@ -0,0 +1,13 @@
+for provider, config in dns_providers
+
+  Shindo.tests("#{provider}::DNS | zone", [provider.to_s.downcase]) do
+
+    zone_attributes = {
+      :domain => 'fogzonetests.com'
+    }.merge!(config[:zone_attributes] || {})
+
+    model_tests(provider[:dns].zones, zone_attributes, config[:mocked])
+
+  end
+
+end

data/tests/dns/models/zones_tests.rb

@@ -0,0 +1,13 @@
+for provider, config in dns_providers
+
+  Shindo.tests("#{provider}::DNS | zones", [provider.to_s.downcase]) do
+
+    zone_attributes = {
+      :domain => 'fogzonestests.com'
+    }.merge!(config[:zone_attributes] || {})
+
+    collection_tests(provider[:dns].zones, zone_attributes, config[:mocked])
+
+  end
+
+end

data/tests/helper.rb

@@ -1,25 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', 'lib', 'fog')
 require 'fog/core/bin'
 
-__DIR__ = File.dirname(__FILE__)
-
-$LOAD_PATH.unshift __DIR__ unless
-  $LOAD_PATH.include?(__DIR__) ||
-  $LOAD_PATH.include?(File.expand_path(__DIR__))
-
-require 'helpers/collection_tests'
-require 'helpers/model_tests'
-
-require 'helpers/compute/flavors_tests'
-require 'helpers/compute/server_tests'
-require 'helpers/compute/servers_tests'
-
-require 'helpers/storage/directory_tests'
-require 'helpers/storage/directories_tests'
-require 'helpers/storage/file_tests'
-require 'helpers/storage/files_tests'
-
-# Use so you can run in mock mode from the command line:
+# Use so you can run in mock mode from the command line
 #
 # FOG_MOCK=true fog
 
@@ -35,87 +17,6 @@ for provider in (all_providers - available_providers)
   Thread.current[:tags] << ('-' << provider)
 end
 
-# Boolean hax
-module Fog
-  module Boolean
-  end
-end
-FalseClass.send(:include, Fog::Boolean)
-TrueClass.send(:include, Fog::Boolean)
-
 def lorem_file
   File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
 end
-
-module Shindo
-  class Tests
-
-    def responds_to(method_names)
-      for method_name in [*method_names]
-        tests("#respond_to?(:#{method_name})").succeeds do
-          @instance.respond_to?(method_name)
-        end
-      end
-    end
-
-    def formats(format)
-      test('has proper format') do
-        formats_kernel(instance_eval(&Proc.new), format)
-      end
-    end
-
-    def succeeds
-      test('succeeds') do
-        instance_eval(&Proc.new)
-        true
-      end
-    end
-
-    private
-
-    def formats_kernel(original_data, original_format, original = true)
-      valid = true
-      data = original_data.dup
-      format = original_format.dup
-      if format.is_a?(Array)
-        data   = {:element => data}
-        format = {:element => format}
-      end
-      for key, value in format
-        valid &&= data.has_key?(key)
-        datum = data.delete(key)
-        format.delete(key)
-        case value
-        when Array
-          valid &&= datum.is_a?(Array)
-          if datum.is_a?(Array)
-            for element in datum
-              type = value.first
-              if type.is_a?(Hash)
-                valid &&= formats_kernel({:element => element}, {:element => type}, false)
-              elsif type.nil?
-                p "#{key} => #{value}"
-              else
-                valid &&= element.is_a?(type)
-              end
-            end
-          end
-        when Hash
-          valid &&= datum.is_a?(Hash)
-          valid &&= formats_kernel(datum, value, false)
-        else
-          p "#{key} => #{value}" unless datum.is_a?(value)
-          valid &&= datum.is_a?(value)
-        end
-      end
-      p data unless data.empty?
-      p format unless format.empty?
-      valid &&= data.empty? && format.empty?
-      if !valid && original
-        @message = "#{original_data.inspect} does not match #{original_format.inspect}"
-      end
-      valid
-    end
-
-  end
-end