fog-maestrodev 1.7.0.20121114190951

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,59 @@
+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
+
+    if block_given?
+      yield
+    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,34 @@
+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,26 @@
+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])
+
+    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,11 @@
+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? }
+    end
+
+  end
+
+end

data/tests/helpers/formats_helper.rb

@@ -0,0 +1,86 @@
+# 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
+
+    def formats(format, strict=true)
+      raise ArgumentError, 'format is nil' unless format
+
+      test('has proper format') do
+        formats_kernel(instance_eval(&Proc.new), format, true, strict)
+      end
+    end
+
+    private
+
+    def formats_kernel(original_data, original_format, original = true, strict = 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
+        datum = data.delete(key)
+        format.delete(key)
+        case value
+        when Array
+          p("#{key.inspect} not Array: #{datum.inspect}") unless datum.is_a?(Array)
+          valid &&= datum.is_a?(Array)
+          if datum.is_a?(Array) && !value.empty?
+            for element in datum
+              type = value.first
+              if type.is_a?(Hash)
+                valid &&= formats_kernel({:element => element}, {:element => type}, false, strict)
+              else
+                valid &&= element.is_a?(type)
+              end
+            end
+          end
+        when Hash
+          p("#{key.inspect} not Hash: #{datum.inspect}") unless datum.is_a?(Hash)
+          valid &&= datum.is_a?(Hash)
+          valid &&= formats_kernel(datum, value, false, strict)
+        else
+          p "#{key.inspect} not #{value.inspect}: #{datum.inspect}" unless datum.is_a?(value)
+          valid &&= datum.is_a?(value)
+        end
+      end
+      p data unless data.empty?
+      p format unless format.empty?
+      if strict
+        valid &&= data.empty? && format.empty?
+      else
+        valid &&= format.empty?
+      end
+      if !valid && original
+        @message = "#{original_data.inspect} does not match #{original_format.inspect}"
+      end
+      valid
+    end
+
+  end
+end

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('test_helper', 'meta') do
+
+  tests('#formats_kernel') do
+
+    tests('returns true') do
+
+      test('when format of value matches') do
+        formats_kernel({:a => :b}, {:a => Symbol})
+      end
+
+      test('when format of nested array elements matches') do
+        formats_kernel({:a => [:b, :c]}, {:a => [Symbol]})
+      end
+
+      test('when format of nested hash matches') do
+        formats_kernel({:a => {:b => :c}}, {:a => {:b => Symbol}})
+      end
+
+      test('when format of an array') do
+        formats_kernel([{:a => :b}], [{:a => Symbol}])
+      end
+
+      test('non strict extra data') do
+        formats_kernel({:a => :b, :b => :c}, {:a => Symbol}, true, false)
+      end
+
+    end
+
+    tests('returns false') do
+
+      test('when format of value does not match') do
+        !formats_kernel({:a => :b}, {:a => String})
+      end
+
+      test('when not all keys are checked') do
+        !formats_kernel({:a => :b}, {})
+      end
+
+      test('when some keys do not appear') do
+        !formats_kernel({}, {:a => String})
+      end
+
+      test('when an array is expected but another data type is found') do
+        !formats_kernel({:a => 'not an array'}, {:a => []})
+      end
+
+      test('when a hash is expected but another data type is found') do
+        !formats_kernel({:a => 'not a hash'}, {:a => {}}, true, false)
+      end
+
+
+      test('non strict extra data') do
+        !formats_kernel({:a => :b, :b => :c}, {:z => Symbol}, true, false)
+      end
+
+    end
+
+  end
+
+end

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,89 @@
+# Use so you can run in mock mode from the command line
+#
+# FOG_MOCK=true fog
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+# if in mocked mode, fill in some fake credentials for us
+if Fog.mock?
+  Fog.credentials = {
+    :aws_access_key_id                => 'aws_access_key_id',
+    :aws_secret_access_key            => 'aws_secret_access_key',
+    :atmos_storage_token              => 'atmos_token',
+    :atmos_storage_secret             => 'atmos_secret',
+    :atmos_storage_endpoint           => 'http://atmos.is.cool:1000/test1.0',
+    :bluebox_api_key                  => 'bluebox_api_key',
+    :bluebox_customer_id              => 'bluebox_customer_id',
+    :brightbox_client_id              => 'brightbox_client_id',
+    :brightbox_secret                 => 'brightbox_secret',
+    :cloudstack_disk_offering_id      => '',
+    :cloudstack_host                  => 'http://cloudstack.example.org',
+    :cloudstack_network_ids           => '',
+    :cloudstack_service_offering_id   => '4437ac6c-9fe3-477a-57ec-60a5a45896a4',
+    :cloudstack_template_id           => '8a31cf9c-f248-0588-256e-9dbf58785216',
+    :cloudstack_zone_id               => 'c554c592-e09c-9df5-7688-4a32754a4305',
+    :clodo_api_key                    => 'clodo_api_key',
+    :clodo_username                   => 'clodo_username',
+    :dnsimple_email                   => 'dnsimple_email',
+    :dnsimple_password                => 'dnsimple_password',
+    :dnsmadeeasy_api_key              => 'dnsmadeeasy_api_key',
+    :dnsmadeeasy_secret_key           => 'dnsmadeeasy_secret_key',
+    :ecloud_username                  => 'ecloud_username',
+    :ecloud_password                  => 'ecloud_password',
+    :ecloud_versions_uri              => 'http://ecloud.versions.uri',
+    :glesys_username                  => 'glesys_username',
+    :glesys_api_key                   => 'glesys_api_key',
+    :go_grid_api_key                  => 'go_grid_api_key',
+    :go_grid_shared_secret            => 'go_grid_shared_secret',
+    :google_storage_access_key_id     => 'google_storage_access_key_id',
+    :google_storage_secret_access_key => 'google_storage_secret_access_key',
+    :hp_account_id                    => 'hp_account_id',
+    :hp_secret_key                    => 'hp_secret_key',
+    :hp_tenant_id                     => 'hp_tenant_id',
+    :ibm_username                     => 'ibm_username',
+    :ibm_password                     => 'ibm_password',
+    :joyent_username                  => "joyentuser",
+    :joyent_password                  => "joyentpass",
+    :linode_api_key                   => 'linode_api_key',
+    :local_root                       => '~/.fog',
+    :bare_metal_cloud_password        => 'bare_metal_cloud_password',
+    :bare_metal_cloud_username        => 'bare_metal_cloud_username',
+    :ninefold_compute_key             => 'ninefold_compute_key',
+    :ninefold_compute_secret          => 'ninefold_compute_secret',
+    :ninefold_storage_secret          => 'ninefold_storage_secret',
+    :ninefold_storage_token           => 'ninefold_storage_token',
+#    :public_key_path                  => '~/.ssh/id_rsa.pub',
+#    :private_key_path                 => '~/.ssh/id_rsa',
+    :openstack_api_key                => 'openstack_api_key',
+    :openstack_username               => 'openstack_username',
+    :openstack_tenant                 => 'openstack_tenant',
+    :openstack_auth_url               => 'http://openstack:35357/v2.0/tokens',
+    :ovirt_url                        => 'http://ovirt:8080/api',
+    :ovirt_username                   => 'admin@internal',
+    :ovirt_password                   => '123123',
+    :libvirt_uri                      => 'qemu://libvirt/system',
+    :rackspace_api_key                => 'rackspace_api_key',
+    :rackspace_username               => 'rackspace_username',
+    :storm_on_demand_username         => 'storm_on_demand_username',
+    :storm_on_demand_password         => 'storm_on_demand_password',
+    :vcloud_host                      => 'vcloud_host',
+    :vcloud_password                  => 'vcloud_password',
+    :vcloud_username                  => 'vcloud_username',
+    :voxel_api_key                    => 'voxel_api_key',
+    :voxel_api_secret                 => 'voxel_api_secret',
+    :zerigo_email                     => 'zerigo_email',
+    :zerigo_token                     => 'zerigo_token',
+    :dynect_customer                  => 'dynect_customer',
+    :dynect_username                  => 'dynect_username',
+    :dynect_password                  => 'dynect_password',
+    :vsphere_server                   => 'virtualcenter.lan',
+    :vsphere_username                 => 'apiuser',
+    :vsphere_password                 => 'apipassword',
+    :vsphere_expected_pubkey_hash     => 'abcdef1234567890',
+    :libvirt_uri                      => 'qemu:///system',
+    :libvirt_username                 => 'root',
+    :libvirt_password                 => 'password'
+  }.merge(Fog.credentials)
+end

data/tests/helpers/model_helper.rb

@@ -0,0 +1,35 @@
+def model_tests(collection, params = {}, mocks_implemented = true)
+
+  tests('success') do
+
+    @instance = collection.new(params)
+
+    tests("#save").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.save
+    end
+
+    if block_given?
+      yield
+    end
+
+    tests("#destroy").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.destroy
+    end
+
+  end
+
+end
+
+# Generates a unique identifier with a random differentiator.
+# Useful when rapidly re-running tests, so we don't have to wait
+# serveral minutes for deleted objects to disappear from the API
+# E.g. 'fog-test-1234'
+def uniq_id(base_name = 'fog-test')
+  # random_differentiator
+  suffix = rand(65536).to_s(16).rjust(4, '0')
+  [base_name, suffix] * '-'
+end
+
+

data/tests/helpers/responds_to_helper.rb

@@ -0,0 +1,13 @@
+module Shindo
+  class Tests
+
+    def responds_to(method_names)
+      for method_name in [*method_names]
+        tests("#respond_to?(:#{method_name})").returns(true) do
+          @instance.respond_to?(method_name)
+        end
+      end
+    end
+
+  end
+end

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,11 @@
+module Shindo
+  class Tests
+
+    def succeeds
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+
+  end
+end

data/tests/hp/models/compute/address_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests("Fog::Compute[:hp] | address", ["hp"]) do
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  model_tests(Fog::Compute[:hp].addresses, {}, true) do
+
+    @server = Fog::Compute[:hp].servers.create(:name => "fogservertests", :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+
+    tests('#server=').succeeds do
+      @instance.server = @server
+    end
+
+    @server.destroy
+
+  end
+
+end

data/tests/hp/models/compute/addresses_tests.rb

@@ -0,0 +1,5 @@
+Shindo.tests("Fog::Compute[:hp] | addresses", ["hp"]) do
+
+  collection_tests(Fog::Compute[:hp].addresses, {}, true)
+
+end

data/tests/hp/models/compute/key_pair_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests("Fog::Compute[:hp] | key_pair", ["hp"]) do
+
+  model_tests(Fog::Compute[:hp].key_pairs, {:name => 'fogkeyname'}, true)
+
+  after do
+    @keypair.destroy
+  end
+
+  tests("new keypair") do
+    @keypair = Fog::Compute[:hp].key_pairs.create(:name => 'testkey')
+
+    test ("writable?") do
+      @keypair.writable? == true
+    end
+  end
+
+  tests("existing keypair") do
+    Fog::Compute[:hp].key_pairs.create(:name => 'testkey')
+    @keypair = Fog::Compute[:hp].key_pairs.get('testkey')
+
+    test("writable?") do
+      @keypair.writable? == false
+    end
+  end
+
+
+end

data/tests/hp/models/compute/key_pairs_tests.rb

@@ -0,0 +1,5 @@
+Shindo.tests("Fog::Compute[:hp] | key_pairs", ["hp"]) do
+
+  collection_tests(Fog::Compute[:hp].key_pairs, {:name => 'fogkeyname'}, true)
+
+end

data/tests/hp/models/compute/security_group_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests("Fog::Compute[:hp] | security_group", ["hp"]) do
+
+  model_tests(Fog::Compute[:hp].security_groups, {:name => 'foggroupname', :description => 'foggroupdescription'}, true)
+
+  tests("a group with trailing whitespace") do
+    @group = Fog::Compute[:hp].security_groups.create(:name => "   foggroup with spaces   ", :description => "   fog group desc   ")
+
+    test("all spaces are removed from name") do
+      @group.name == "   foggroup with spaces   ".strip!
+    end
+
+    test("all spaces are removed from description") do
+      @group.description == "   fog group desc   ".strip!
+    end
+
+    @other_group = Fog::Compute[:hp].security_groups.create(:name => 'other group', :description => 'another group')
+
+    test("authorize access by another security group") do
+      sgrule = @group.create_rule(80..80, "tcp", nil, @other_group.id)
+      @sg_rule_id = sgrule.body['security_group_rule']['id']
+      @group.reload
+      s = @group.rules.select {|r| r['id'] == @sg_rule_id unless r.nil?}
+      s[0]['id'] == @sg_rule_id
+    end
+
+    test("revoke access from another security group") do
+      @group.delete_rule(@sg_rule_id)
+      @group.reload
+      s = @group.rules.select {|r| r['id'] == @sg_rule_id unless r.nil?}
+      s.empty?
+    end
+
+    @other_group.destroy
+    @group.destroy
+  end
+end

data/tests/hp/models/compute/security_groups_tests.rb

@@ -0,0 +1,5 @@
+Shindo.tests("Fog::Compute[:hp] | security_groups", ["hp"]) do
+
+  collection_tests(Fog::Compute[:hp].security_groups, {:name => 'foggroupname', :description => 'foggroupdescription'}, true)
+
+end

data/tests/hp/requests/cdn/container_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests('Fog::CDN[:hp] | container requests', ["hp"]) do
+
+  @cdn_containers_format = [{
+    'x-cdn-ssl-uri' => String,
+    'cdn_enabled'   => Fog::Boolean,
+    'name'          => String,
+    'x-cdn-uri'     => String,
+    'ttl'           => Integer,
+    'log_retention' => Fog::Boolean
+  }]
+
+  tests('success') do
+
+    tests("#put_container('fogcdncontainertests')").succeeds do
+      Fog::CDN[:hp].put_container('fogcdncontainertests')
+    end
+
+    tests("duplicate #put_container('fogcdncontainertests')").succeeds do
+      Fog::CDN[:hp].put_container('fogcdncontainertests')
+    end
+
+    tests("#get_containers").formats(@cdn_containers_format) do
+      Fog::CDN[:hp].get_containers.body
+    end
+
+    tests("#post_container('fogcdncontainertests', {'x-ttl' => 3200})").succeeds do
+      Fog::CDN[:hp].post_container('fogcdncontainertests', {'x-ttl' => 3200})
+    end
+
+    tests("#head_container('fogcdncontainertests')").succeeds do
+      Fog::CDN[:hp].head_container('fogcdncontainertests')
+    end
+
+    tests("#delete_container('fogcdncontainertests')").succeeds do
+      Fog::CDN[:hp].delete_container('fogcdncontainertests')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#post_container('fognoncdncontainer', {'x-ttl' => 3200})").raises(Fog::CDN::HP::NotFound) do
+      Fog::CDN[:hp].post_container('fogcdnnoncontainer', {'x-ttl' => 3200})
+    end
+
+    tests("#head_container('fognoncdncontainer')").raises(Fog::CDN::HP::NotFound) do
+      Fog::CDN[:hp].head_container('fognoncdncontainer')
+    end
+
+    tests("#delete_container('fognoncdncontainer')").raises(Fog::CDN::HP::NotFound) do
+      Fog::CDN[:hp].delete_container('fognoncdncontainer')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,73 @@
+Shindo.tests('Fog::Compute[:hp] | address requests', ["hp"]) do
+
+  @floating_ips_format = {
+    'instance_id' => Fog::Nullable::Integer,
+    'ip'          => Fog::Nullable::String,
+    'fixed_ip'    => Fog::Nullable::String,
+    'id'          => Integer
+  }
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  tests('success') do
+
+    tests("#list_addresses").formats({'floating_ips' => [@floating_ips_format]}) do
+      Fog::Compute[:hp].list_addresses.body
+    end
+
+    tests("#allocate_address").formats(@floating_ips_format) do
+      data = Fog::Compute[:hp].allocate_address.body['floating_ip']
+      @address_id = data['id']
+      @ip_address = data['ip']
+      data
+    end
+
+    tests("#get_address('#{@address_id}')").formats(@floating_ips_format) do
+      Fog::Compute[:hp].get_address(@address_id).body['floating_ip']
+    end
+
+    @server = Fog::Compute[:hp].servers.create(:name => 'fogaddresstests', :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+
+    tests("#associate_address('#{@server.id}', '#{@ip_address}')").succeeds do
+      result = Fog::Compute[:hp].associate_address(@server.id, @ip_address)
+      tests("#get_address").returns(@server.id, "associated to valid instance id") do
+        pending if Fog.mocking?
+        Fog::Compute[:hp].get_address(@address_id).body['floating_ip']['instance_id']
+      end
+      result
+    end
+
+    tests("#disassociate_address('#{@server.id}', '#{@ip_address}')").succeeds do
+      Fog::Compute[:hp].disassociate_address(@server.id, @ip_address)
+    end
+
+    @server.destroy
+
+    tests("#release_address('#{@address_id}')").succeeds do
+      Fog::Compute[:hp].release_address(@address_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_address('invalidaddress', 'invalidip')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].get_address('invalidaddress')
+    end
+
+    tests("#associate_address('invalidserver', 'invalidip')").raises(Excon::Errors::InternalServerError) do
+      Fog::Compute[:hp].associate_address('invalidserver', 'invalidip')
+    end
+
+    tests("#disassociate_address('invalidserver', 'invalidip')").raises(Excon::Errors::InternalServerError) do
+      Fog::Compute[:hp].disassociate_address('invalidserver', 'invalidip')
+    end
+
+    tests("#release_address('invalidaddress')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].release_address('invalidaddress')
+    end
+
+  end
+
+end