ktheory-fog 1.1.2

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,84 @@
+# 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
+          valid &&= datum.is_a?(Array) || p("#{key.inspect} not Array: #{datum.inspect}")
+          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
+          valid &&= datum.is_a?(Hash) || p("#{key.inspect} not Hash: #{datum.inspect}")
+          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,51 @@
+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('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,72 @@
+# 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',
+    :bluebox_api_key                  => 'bluebox_api_key',
+    :bluebox_customer_id              => 'bluebox_customer_id',
+    :brightbox_client_id              => 'brightbox_client_id',
+    :brightbox_secret                 => 'brightbox_secret',
+    :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',
+    :joyent_username                  => "joyentuser",
+    :joyent_password                  => "joyentpass",
+    :linode_api_key                   => 'linode_api_key',
+    :local_root                       => '~/.fog',
+    :new_servers_password             => 'new_servers_password',
+    :new_servers_username             => 'new_servers_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               => 'openstack_auth_url',
+    :ovirt_url                        => 'http://ovirt:8080/api',
+    :ovirt_username                   => 'admin@internal',
+    :ovirt_password                   => '123123',
+    :rackspace_api_key                => 'rackspace_api_key',
+    :rackspace_username               => 'rackspace_username',
+    :slicehost_password               => 'slicehost_password',
+    :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'
+  }
+end

data/tests/helpers/model_helper.rb

@@ -0,0 +1,38 @@
+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
+
+  tests('failure') do
+  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,12 @@
+module Shindo
+  class Tests
+
+    def succeeds
+      test('succeeds') do
+        instance_eval(&Proc.new)
+        true
+      end
+    end
+
+  end
+end

data/tests/joyent/requests/compute/datasets_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests("Fog::Compute[:joyent] | dataset requests", ["joyent"]) do
+  @dataset_format = {
+    "description" => String,
+    "requirements" => {},
+    "name" => String,
+    "version" => String,
+    "os" => String,
+    "id" => String,
+    "urn" => String,
+    "default" => Fog::Boolean,
+    "type" => String,
+    "created" => Time,
+  }
+
+  if Fog.mock?
+    Fog::Compute[:joyent].data[:datasets] = {
+      "33904834-1f01-49d3-bed3-b642e158c375" => {
+        "id" => "33904834-1f01-49d3-bed3-b642e158c375",
+        "urn" => "sdc:sdc:zeus-simple-lb-200mbps:1.1.1",
+        "name" => "zeus-simple-lb-200mbps",
+        "os" => "smartos",
+        "type" => "smartmachine",
+        "description" => "Zeus Simple Load Balancer 200 Mbps SmartMachine",
+        "default" => false,
+        "requirements" => {},
+        "version" => "1.1.1",
+        "created" => Time.parse("2011-09-15T07:39:13+00:00")
+      },
+      "3fcf35d2-dd79-11e0-bdcd-b3c7ac8aeea6" => {
+        "id" => "3fcf35d2-dd79-11e0-bdcd-b3c7ac8aeea6",
+        "urn" => "sdc:sdc:mysql:1.4.1",
+        "name" => "mysql",
+        "os" => "smartos",
+        "type" => "smartmachine",
+        "description" => "MySQL SmartMachine",
+        "default" => false,
+        "requirements" => {},
+        "version" => "1.4.1",
+        "created" => Time.parse("2011-09-15T05:01:34+00:00")
+      }
+    }
+  end
+
+  tests("#list_datasets") do
+    formats(@dataset_format) do
+      Fog::Compute[:joyent].list_datasets.body.first
+    end
+  end
+end

data/tests/joyent/requests/compute/keys_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests("Fog::Compute[:joyent] | key requests", ['joyent']) do
+
+  @key_format = {
+    "name" => String,
+    "key" => String,
+    "created" => Time,
+    "updated" => Time
+  }
+
+  before do
+    #
+    # Clear out all the test keys on the account in prep for test
+    #
+    Fog::Compute[:joyent].list_keys.body.each do |key|
+      if key["name"] =~ /^fog-test/
+        Fog::Compute[:joyent].delete_key(key["name"])
+      end
+    end
+
+    @test_key_name = "fog-test-#{Time.now.utc.to_i}"
+
+    Fog::Compute[:joyent].create_key(
+      :name => @test_key_name,
+      :key => "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDWxSNYngOTeu0pYd+2tpfYGISuMfMUNGyAIh4yRprAbacVddRq4Nyr12vDklzaRTzgd9PgX/82JMb4RARbVTtUKXJXmaBLvg2epGM+ScanZIitzL53whJrlGx+7nT+TnRdkB1XG7uIf2EpTQBaKrT4iG0magCXh5bmOqCyWte2gV8fArMg5bZclUT1p2E7qEW0htaLOiMSyGkjBlxb6vYQCA/Pa8VWETHehIF46S942gCj0aaL81gTocfyTm5/F+AgvUAsjHzRVkB/Dlhwq7Q7sK+4iAhlKPYMflkKC8r+nF0/LL9S3lllLZvbkEWJfEqlMCAbgmjTpYlBzQEqf/eN"
+    )
+  end
+
+  tests("#list_keys").formats(@key_format) do
+    Fog::Compute[:joyent].list_keys.body.first
+  end
+
+  tests("#get_key").formats(@key_format) do
+    Fog::Compute[:joyent].get_key(@test_key_name).body
+  end
+
+  tests("#delete_key") do
+    returns(204 , "returns status code 204") do
+      Fog::Compute[:joyent].delete_key(@test_key_name).status
+    end
+
+    raises(Excon::Errors::NotFound, "when a key no longer exists") do
+      Fog::Compute[:joyent].delete_key(@test_key_name)
+      Fog::Compute[:joyent].delete_key(@test_key_name)
+    end
+  end
+
+end