fog-ifeel 2.2.0

data/tests/glesys/requests/compute/server_tests.rb

@@ -0,0 +1,142 @@
+Shindo.tests('Fog::Compute[:glesys] | server requests', ['glesys']) do
+
+    @serverid = nil
+    @hostname = "fog-#{Time.now.to_i}"
+
+    @create = ":hostname => #@hostname, :rootpassword => 'pw#{Time.now.to_i}', "+
+    ":datacenter => 'Falkenberg', :platform => 'VMware', :templatename => 'Debian 7.0 64-bit', "+
+    ":disksize => '10', :memorysize => '512', :cpucores => '1', :transfer => '500', :bandwidth => '10'"
+
+    @create_vz = ":hostname => #@hostname, :rootpassword => 'pw#{Time.now.to_i}', "+
+    ":datacenter => 'Stockholm', :platform => 'OpenVZ', :templatename => 'Debian 7.0 64-bit', "+
+    ":disksize => '10', :memorysize => '256', :cpucores => '2', :transfer => '500', :bandwidth => '10'"
+
+  tests('success') do
+
+    tests("#list_servers()").formats(Glesys::Compute::Formats::Servers::LIST) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].list_servers.body['response']
+    end
+
+    tests("#create(#{@create})").formats(Glesys::Compute::Formats::Servers::CREATE) do
+      pending if Fog.mocking?
+      vm =  Fog::Compute[:glesys].create(
+              :hostname     => @hostname,
+              :description  => "Fog test server",
+              :rootpassword => "pw#{Time.now.to_i}",
+              :datacenter   => "Falkenberg",
+              :platform     => "VMware",
+              :templatename => "Debian 7.0 64-bit",
+              :disksize     => "10",
+              :memorysize   => "512",
+              :cpucores     => "1",
+              :transfer     => "500",
+              :bandwidth    => "10"
+            )
+
+      @serverid = vm.body['response']['server']['serverid']
+      vm.body['response']
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].servers.get(@serverid).wait_for { ready? }
+    end
+
+    tests("#server_details(#{@serverid})").formats(Glesys::Compute::Formats::Servers::DETAILS) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].server_details(@serverid).body['response']
+    end
+
+    tests("#server_status(#{@serverid})").formats(Glesys::Compute::Formats::Servers::STATUS) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].server_status(@serverid).body['response']
+    end
+
+    tests("#stop(:serverid => #{@serverid})").formats(Glesys::Compute::Formats::Servers::STOP) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].stop(:serverid => @serverid).body['response']
+    end
+
+    # Wait for stopped
+    unless Fog.mocking?
+      pending if Fog.mocking?
+      s = Fog::Compute[:glesys].servers.get(@serverid)
+      s.wait_for { s.state == 'stopped' }
+    end
+
+    tests("#start(:serverid => #{@serverid})").formats(Glesys::Compute::Formats::Servers::DETAILS) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].start(:serverid => @serverid).body['response']
+    end
+
+    # Wait for started
+    unless Fog.mocking?
+      Fog::Compute[:glesys].servers.get(@serverid).wait_for { ready? }
+    end
+
+    tests("#destroy(:serverid => #{@serverid})").formats(Glesys::Compute::Formats::Servers::DESTROY) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].destroy(:serverid => @serverid).body['response']
+    end
+
+    # Test of OpenVZ
+    tests("#create(#{@create_vz})").formats(Glesys::Compute::Formats::Servers::CREATE) do
+      pending if Fog.mocking?
+      vm =  Fog::Compute[:glesys].create(
+              :hostname     => @hostname,
+              :rootpassword => "pw#{Time.now.to_i}",
+              :datacenter   => "Stockholm",
+              :platform     => "OpenVZ",
+              :templatename => "Debian 7.0 64-bit",
+              :disksize     => "10",
+              :memorysize   => "256",
+              :cpucores     => "2",
+              :transfer     => "500",
+              :bandwidth    => "10"
+            )
+      @serverid = vm.body['response']['server']['serverid']
+      vm.body['response']
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].servers.get(@serverid).wait_for { ready? }
+    end
+
+    tests("#edit #{@serverid}").formats(Glesys::Compute::Formats::Servers::EDIT) do
+      pending if Fog.mocking?
+      vm = Fog::Compute[:glesys].edit(
+        :serverid => @serverid,
+        :disksize => "10",
+        :memorysize => "512",
+        :cpucores => "1",
+        :bandwidth => "10"
+      )
+      vm.body['response']
+    end
+
+    tests("#server_details(#{@serverid})").formats(Glesys::Compute::Formats::Servers::DETAILS) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].server_details(@serverid).body['response']
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].servers.get(@serverid).wait_for { ready? }
+    end
+
+    tests("#destroy(:serverid => #{@serverid})").formats(Glesys::Compute::Formats::Servers::DESTROY) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].destroy(:serverid => @serverid).body['response']
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#create(:hostname => 0)").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].create(:hostname => 0)
+    end
+
+  end
+
+end

data/tests/glesys/requests/compute/ssh_key_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests("Fog::Compute[:glesys] | ssh_key requests", ["glesys", "compute"]) do
+  @testdescription = "My test key to be removed"
+  @testdata = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDv+r/dCIDv+YazWsyc1WCixR+iOeaswTx1U45h6vh4/ fog-unittest@GleSYS"
+  @testdata_malformed = "ssh-rot13 AAAAthis_is_not_an_ssh_key fog-unittest@GleSYS"
+
+  tests("success") do
+    tests("#ssh_key_add").formats(Glesys::Compute::Formats::SshKeys::ADD) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_add(:description => @testdescription, :sshkey => @testdata)
+      @resp.body["response"]
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].ssh_keys.destroy(@resp.body["response"]["sshkey"]["id"])
+      @key = Fog::Compute[:glesys].ssh_keys.create(:description => @testdescription, :data => @testdata)
+    end
+
+    tests("#ssh_key_list").formats(Glesys::Compute::Formats::SshKeys::LIST) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_list
+      @resp.body["response"]
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].ssh_keys.destroy(@key.id)
+      @key = Fog::Compute[:glesys].ssh_keys.create(:description => @testdescription, :data => @testdata)
+    end
+
+    tests("#ssh_key_remove").formats(Glesys::Compute::Formats::SshKeys::REMOVE) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_remove(:sshkeyids => @key.id)
+      @resp.body["response"]
+    end
+  end
+
+  tests("failure") do
+    tests("#ssh_key_add with malformed key data").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].ssh_key_add(:description => @testdescription, :data => @testdata_malformed)
+    end
+
+    tests("#ssh_key_remove with nonexistent/invalid key id").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].ssh_key_remove(:id => -1)
+    end
+  end
+end

data/tests/glesys/requests/compute/template_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::Compute[:glesys] | template requests', ['glesys']) do
+
+  tests('success') do
+
+    tests("#template_list()").formats(Glesys::Compute::Formats::Templates::LIST) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].template_list.body['response']
+    end
+
+  end
+
+end

data/tests/helper.rb

@@ -0,0 +1,52 @@
+ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
+ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+
+require 'fog'
+require 'fog/bin' # for available_providers and registered_providers
+require 'ostruct'
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+if Fog.mocking?
+  FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
+  Fog.timeout = 2000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+
+  # These sets of tests do not behave nicely when running mocked tests
+  Thread.current[:tags] << '-xenserver'
+  Thread.current[:tags] << '-joyent'
+  Thread.current[:tags] << '-dreamhost'
+else
+  FOG_TESTING_TIMEOUT = Fog.timeout
+end
+
+def lorem_file
+  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+end
+
+def array_differences(array_a, array_b)
+  (array_a - array_b) | (array_b - array_a)
+end
+
+# check to see which credentials are available and add others to the skipped tags list
+all_providers = Fog.registered_providers.map {|provider| provider.downcase}
+
+# Manually remove these providers since they are local applications, not lacking credentials
+all_providers = all_providers - ["openvz"]
+
+available_providers = Fog.available_providers.map {|provider| provider.downcase}
+
+unavailable_providers = all_providers - available_providers
+
+if !ENV['PROVIDER'].nil? && unavailable_providers.include?(ENV['PROVIDER'])
+  Fog::Formatador.display_line("[red]Requested provider #{ENV['PROVIDER']} is not available.[/]" +
+                          "[red]Check if .fog file has correct configuration (see '#{Fog.credentials_path}')[/]")
+  exit(0)
+end
+
+for provider in unavailable_providers
+  Fog::Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '#{Fog.credentials_path}' to run them)[/]")
+end

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,91 @@
+def collection_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#new(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.new(params)
+    end
+
+    tests("#create(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance = collection.create(params)
+    end
+    # FIXME: work around for timing issue on AWS describe_instances mocks
+
+    if Fog.mocking? && @instance.respond_to?(:ready?)
+      @instance.wait_for { ready? }
+    end
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @instance.identity
+    end
+
+    tests("#get(#{@identity})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+    tests('Enumerable') do
+      pending if Fog.mocking? && !mocks_implemented
+
+      methods = [
+        'all?', 'any?', 'find',  'detect', 'collect', 'map',
+        'find_index', 'flat_map', 'collect_concat', 'group_by',
+        'none?', 'one?'
+      ]
+
+      methods.each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true }
+            block_called
+          end
+        end
+      end
+
+      [
+        'max_by','min_by'
+      ].each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true; 0 }
+            block_called
+          end
+        end
+
+      end
+
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.destroy
+    end
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @identity.to_s
+      @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) }
+      @identity = @identity.gsub(/\d/)       { Fog::Mock.random_numbers(1) }
+      @identity
+    end
+
+    tests("#get('#{@identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+  end
+end

data/tests/helpers/compute/flavors_helper.rb

@@ -0,0 +1,32 @@
+def flavors_tests(connection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = connection.flavors.first.identity
+    end
+
+    tests("#get('#{@identity}')").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(@identity)
+    end
+
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      invalid_flavor_identity = connection.flavors.first.identity.to_s.gsub(/\w/, '0')
+    end
+
+    tests("#get('#{invalid_flavor_identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(invalid_flavor_identity)
+    end
+
+  end
+end

data/tests/helpers/compute/server_helper.rb

@@ -0,0 +1,25 @@
+def server_tests(connection, params = {}, mocks_implemented = true)
+  model_tests(connection.servers, params, mocks_implemented) do
+
+    tests('#reload').returns(true) do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.wait_for { ready? }
+      identity = @instance.identity
+      !identity.nil? && identity == @instance.reload.identity
+    end
+
+    responds_to([:ready?, :state])
+    yield if block_given?
+
+    tests('#reboot').succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.wait_for { ready? }
+      @instance.reboot
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+  end
+end

data/tests/helpers/compute/servers_helper.rb

@@ -0,0 +1,10 @@
+def servers_tests(connection, params = {}, mocks_implemented = true)
+  collection_tests(connection.servers, params, mocks_implemented) do
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+      yield if block_given?
+    end
+
+  end
+end

data/tests/helpers/formats_helper.rb

@@ -0,0 +1,98 @@
+require "fog/schema/data_validator"
+
+# format related hackery
+# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
+# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
+module Fog
+  module Boolean; end
+  module Nullable
+    module Boolean; end
+    module Integer; end
+    module String; end
+    module Time; end
+    module Float; end
+    module Hash; end
+    module Array; end
+  end
+end
+[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
+[FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
+[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
+[NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
+[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
+[Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)}
+[Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)}
+[Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)}
+
+module Shindo
+  class Tests
+    # Generates a Shindo test that compares a hash schema to the result
+    # of the passed in block returning true if they match.
+    #
+    # The schema that is passed in is a Hash or Array of hashes that
+    # have Classes in place of values. When checking the schema the
+    # value should match the Class.
+    #
+    # Strict mode will fail if the data has additional keys. Setting
+    # +strict+ to +false+ will allow additional keys to appear.
+    #
+    # @param [Hash] schema A Hash schema
+    # @param [Hash] options Options to change validation rules
+    # @option options [Boolean] :allow_extra_keys
+    #     If +true+ does not fail when keys are in the data that are
+    #     not specified in the schema. This allows new values to
+    #     appear in API output without breaking the check.
+    # @option options [Boolean] :allow_optional_rules
+    #     If +true+ does not fail if extra keys are in the schema
+    #     that do not match the data. Not recommended!
+    # @yield Data to check with schema
+    #
+    # @example Using in a test
+    #     Shindo.tests("comparing welcome data against schema") do
+    #       data = {:welcome => "Hello" }
+    #       data_matches_schema(:welcome => String) { data }
+    #     end
+    #
+    #     comparing welcome data against schema
+    #     + data matches schema
+    #
+    # @example Example schema
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         {
+    #           "size" => Float
+    #         }
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    # @return [Boolean]
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+        else
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end