phpfog-fog 0.4.1

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,19 @@
+def server_tests(connection, params = {}, mocks_implemented = true)
+
+  model_tests(connection.servers, params, mocks_implemented) do
+
+    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,70 @@
+# 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 Integer; end
+    module String; end
+  end
+end
+[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
+[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
+[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
+
+module Shindo
+  class Tests
+
+    def formats(format)
+      raise ArgumentError, 'format is nil' unless format
+
+      test('has proper format') do
+        formats_kernel(instance_eval(&Proc.new), format)
+      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
+        datum = data.delete(key)
+        format.delete(key)
+        case value
+        when 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)
+              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

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,43 @@
+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
+
+    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
+
+    end
+
+  end
+
+end

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,33 @@
+# 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.instance_variable_set(:@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',
+    :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',
+    :linode_api_key                   => 'linode_api_key',
+    :new_servers_password             => 'new_servers_password',
+    :new_servers_username             => 'new_servers_username',
+#    :public_key_path                  => '~/.ssh/id_rsa.pub',
+#    :private_key_path                 => '~/.ssh/id_rsa',
+    :rackspace_api_key                => 'rackspace_api_key',
+    :rackspace_username               => 'rackspace_username',
+    :slicehost_password               => 'slicehost_password',
+    :zerigo_email                     => 'zerigo_email',
+    :zerigo_token                     => 'zerigo_token'
+  })
+end

data/tests/helpers/model_helper.rb

@@ -0,0 +1,28 @@
+def model_tests(collection, params = {}, mocks_implemented = true)
+
+  tests('success') do
+
+    if !Fog.mocking? || mocks_implemented
+      @instance = collection.new(params)
+    end
+
+    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

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})").succeeds 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/lorem.txt

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/tests/storage/helper.rb

@@ -0,0 +1,16 @@
+def storage_providers
+  {
+    AWS       => {
+      :mocked => true
+    },
+    Google    => {
+      :mocked => true
+    },
+    Local     => {
+      :mocked => true
+    },
+    Rackspace => {
+      :mocked => false
+    }
+  }
+end

data/tests/storage/models/directories_tests.rb

@@ -0,0 +1,13 @@
+for provider, config in storage_providers
+
+  Shindo.tests("#{provider}::Storage | directories", [provider.to_s.downcase]) do
+
+    directory_attributes = {
+      :key => 'fogdirectoriestests',
+    }.merge!(config[:directory_attributes] || {})
+
+    collection_tests(provider[:storage].directories, directory_attributes, config[:mocked])
+
+  end
+
+end

data/tests/storage/models/directory_test.rb

@@ -0,0 +1,24 @@
+for provider, config in storage_providers
+
+  Shindo.tests("#{provider}::Storage | directory", [provider.to_s.downcase]) do
+
+    directory_attributes = {
+      :key => 'fogdirectorytests'
+    }.merge!(config[:directory_attributes] || {})
+
+    model_tests(provider[:storage].directory, directory_attributes, config[:mocked]) do
+
+      tests("#public=(true)").succeeds do
+        pending if Fog.mocking? && !config[:mocked]
+        @instance.public=(true)
+      end
+
+      if !Fog.mocking? || config[:mocked]
+        @instance.responds_to(:public_url)
+      end
+
+    end
+
+  end
+
+end

data/tests/storage/models/file_tests.rb

@@ -0,0 +1,41 @@
+for provider, config in storage_providers
+
+  Shindo.tests("#{provider}::Storage | file", [provider.to_s.downcase]) do
+
+    file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+    }.merge!(config[:file_attributes] || {})
+
+    if !Fog.mocking? || config[:mocked]
+
+      directory_attributes = {
+        :key => 'fogfilestests'
+      }.merge!(config[:directory_attributes] || {})
+
+      @directory = provider[:storage].directories.create(directory_attributes)
+
+      model_tests(@directory.files, file_attributes, config[:mocked]) do
+
+        responds_to(:public_url)
+
+        tests("#public=(true)").succeeds do
+          pending if Fog.mocking? && !config[:mocked]
+          @instance.public=(true)
+        end
+
+        test("@instance.public_url.nil? || Excon.get(@instance.public_url).body == lorem_file.read") do
+          pending if Fog.mocking?
+          @instance.public_url.nil? || Excon.get(@instance.public_url).body == lorem_file.read
+        end
+
+      end
+
+      @directory.destroy
+
+    end
+
+  end
+
+end

data/tests/storage/models/files_tests.rb

@@ -0,0 +1,26 @@
+for provider, config in storage_providers
+
+  Shindo.tests("#{provider}::Storage | files", [provider.to_s.downcase]) do
+
+    file_attributes = {
+      :key => 'fog_files_tests',
+      :body => lorem_file
+    }.merge!(config[:file_attributes] || {})
+
+    if !Fog.mocking? || config[:mocked]
+
+      directory_attributes = {
+        :key => 'fogfilestests'
+      }.merge!(config[:directory_attributes] || {})
+
+      @directory = provider.directories.create(directory_attributes)
+
+      collection_tests(@directory.files, file_attributes, config[:mocked])
+
+      @directory.destroy
+
+    end
+
+  end
+
+end

data/tests/storage/requests/aws/bucket_tests.rb

@@ -0,0 +1,104 @@
+Shindo.tests('AWS::Storage | bucket requests', ['aws']) do
+
+  tests('success') do
+
+    @bucket_format = {
+      'CommonPrefixes'  => [],
+      'IsTruncated'     => Fog::Boolean,
+      'Marker'          => NilClass,
+      'MaxKeys'         => Integer,
+      'Name'            => String,
+      'Prefix'          => NilClass,
+      'Contents'    => [{
+        'ETag'          => String,
+        'Key'           => String,
+        'LastModified'  => Time,
+        'Owner' => {
+          'DisplayName' => String,
+          'ID'          => String
+        },
+        'Size' => Integer,
+        'StorageClass' => String
+      }]
+    }
+
+    @service_format = {
+      'Buckets' => [{
+        'CreationDate'  => Time,
+        'Name'          => String,
+      }],
+      'Owner'   => {
+        'DisplayName' => String,
+        'ID'          => String
+      }
+    }
+
+    tests("#put_bucket('fogbuckettests')").succeeds do
+      AWS[:storage].put_bucket('fogbuckettests')
+    end
+
+    tests("#get_service").formats(@service_format) do
+      AWS[:storage].get_service.body
+    end
+
+    file = AWS[:storage].directories.get('fogbuckettests').files.create(:body => 'y', :key => 'x')
+
+    tests("#get_bucket('fogbuckettests)").formats(@bucket_format) do
+      AWS[:storage].get_bucket('fogbuckettests').body
+    end
+
+    file.destroy
+
+    tests("#get_bucket_location('fogbuckettests)").formats('LocationConstraint' => NilClass) do
+      AWS[:storage].get_bucket_location('fogbuckettests').body
+    end
+
+    tests("#get_request_payment('fogbuckettests')").formats('Payer' => String) do
+      AWS[:storage].get_request_payment('fogbuckettests').body
+    end
+
+    tests("#put_request_payment('fogbuckettests', 'Requester')").succeeds do
+      AWS[:storage].put_request_payment('fogbuckettests', 'Requester')
+    end
+
+    tests("#delete_bucket('fogbuckettests')").succeeds do
+      AWS[:storage].delete_bucket('fogbuckettests')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#delete_bucket('fognonbucket')").raises(Excon::Errors::NotFound) do
+      AWS[:storage].delete_bucket('fognonbucket')
+    end
+
+    @bucket = AWS[:storage].directories.create(:key => 'fognonempty')
+    @file = @bucket.files.create(:key => 'foo', :body => 'bar')
+
+    tests("#delete_bucket('fognonempty')").raises(Excon::Errors::Conflict) do
+      AWS[:storage].delete_bucket('fognonempty')
+    end
+
+    @file.destroy
+    @bucket.destroy
+
+    tests("#get_bucket('fognonbucket')").raises(Excon::Errors::NotFound) do
+      AWS[:storage].get_bucket('fognonbucket')
+    end
+
+    tests("#get_bucket_location('fognonbucket')").raises(Excon::Errors::NotFound) do
+      AWS[:storage].get_bucket_location('fognonbucket')
+    end
+
+    tests("#get_request_payment('fognonbucket')").raises(Excon::Errors::NotFound) do
+      AWS[:storage].get_request_payment('fognonbucket')
+    end
+
+    tests("#put_request_payment('fognonbucket', 'Requester')").raises(Excon::Errors::NotFound) do
+      AWS[:storage].put_request_payment('fognonbucket', 'Requester')
+    end
+
+  end
+
+end

data/tests/storage/requests/aws/multipart_upload_tests.rb

@@ -0,0 +1,135 @@
+Shindo.tests('AWS::Storage | object requests', ['aws']) do
+
+  @directory = AWS[:storage].directories.create(:key => 'fogmultipartuploadtests')
+
+  tests('success') do
+
+    @initiate_multipart_upload_format = {
+      'Bucket'    => String,
+      'Key'       => String,
+      'UploadId'  => String
+    }
+
+    tests("#initiate_multipart_upload('#{@directory.identity}')", 'fog_multipart_upload').formats(@initiate_multipart_upload_format) do
+      pending if Fog.mocking?
+      data = AWS[:storage].initiate_multipart_upload(@directory.identity, 'fog_multipart_upload').body
+      @upload_id = data['UploadId']
+      data
+    end
+
+    @list_multipart_uploads_format = {
+      'Bucket'              => String,
+      'IsTruncated'         => Fog::Boolean,
+      'MaxUploads'          => Integer,
+      'KeyMarker'           => NilClass,
+      'NextKeyMarker'       => String,
+      'NextUploadIdMarker'  => String,
+      'Upload' => [{
+        'Initiated'     => Time,
+        'Initiator' => {
+          'DisplayName' => String,
+          'ID'          => String
+        },
+        'Key'           => String,
+        'Owner' => {
+          'DisplayName' => String,
+          'ID'          => String
+        },
+        'StorageClass'      => String,
+        'UploadId'          => String
+      }],
+      'UploadIdMarker'      => NilClass,
+    }
+
+    tests("#list_multipart_uploads('#{@directory.identity})").formats(@list_multipart_uploads_format) do
+      pending if Fog.mocking?
+      AWS[:storage].list_multipart_uploads(@directory.identity).body
+    end
+
+    @parts = []
+
+    tests("#upload_part('#{@directory.identity}', 'fog_multipart_upload', '#{@upload_id}', 1, ('x' * 6 * 1024 * 1024))").succeeds do
+      pending if Fog.mocking?
+      data = AWS[:storage].upload_part(@directory.identity, 'fog_multipart_upload', @upload_id, 1, ('x' * 6 * 1024 * 1024))
+      @parts << data.headers['ETag']
+    end
+
+    @list_parts_format = {
+      'Bucket'            => String,
+      'Initiator' => {
+        'DisplayName'     => String,
+        'ID'              => String
+      },
+      'IsTruncated'       => Fog::Boolean,
+      'Key'               => String,
+      'MaxParts'          => Integer,
+      'NextPartNumberMarker' => String,
+      'Part' => [{
+        'ETag'            => String,
+        'LastModified'    => Time,
+        'PartNumber'      => Integer,
+        'Size'            => Integer
+      }],
+      'PartNumberMarker'  => String,
+      'StorageClass'      => String,
+      'UploadId'          => String
+    }
+
+    tests("#list_parts('#{@directory.identity}', 'fog_multipart_upload', '#{@upload_id}')").formats(@list_parts_format) do
+      pending if Fog.mocking?
+      AWS[:storage].list_parts(@directory.identity, 'fog_multipart_upload', @upload_id).body
+    end
+
+    if !Fog.mocking?
+      @parts << AWS[:storage].upload_part(@directory.identity, 'fog_multipart_upload', @upload_id, 2, ('x' * 4 * 1024 * 1024)).headers['ETag']
+    end
+
+    @complete_multipart_upload_format = {
+      'Bucket'    => String,
+      'ETag'      => String,
+      'Key'       => String,
+      'Location'  => String
+    }
+
+    tests("#complete_multipart_upload('#{@directory.identity}', 'fog_multipart_upload', '#{@upload_id}', #{@parts.inspect})").formats(@complete_multipart_upload_format) do
+      pending if Fog.mocking?
+      AWS[:storage].complete_multipart_upload(@directory.identity, 'fog_multipart_upload', @upload_id, @parts).body
+    end
+
+    tests("#get_object('#{@directory.identity}', 'fog_multipart_upload').body").succeeds do
+      pending if Fog.mocking?
+      data = AWS[:storage].get_object(@directory.identity, 'fog_multipart_upload').body
+      unless data == ('x' * 10 * 1024 * 1024)
+        raise 'content mismatch'
+      end
+    end
+
+    if !Fog.mocking?
+      @directory.files.new(:key => 'fog_multipart_upload').destroy
+    end
+
+    if !Fog.mocking?
+      @upload_id = AWS[:storage].initiate_multipart_upload(@directory.identity, 'fog_multipart_abort').body['UploadId']
+    end
+
+    tests("#abort_multipart_upload('#{@directory.identity}', 'fog_multipart_abort', '#{@upload_id}')").succeeds do
+      pending if Fog.mocking?
+      AWS[:storage].abort_multipart_upload(@directory.identity, 'fog_multipart_abort', @upload_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("initiate_multipart_upload")
+    tests("list_multipart_uploads")
+    tests("upload_part")
+    tests("list_parts")
+    tests("complete_multipart_upload")
+    tests("abort_multipart_upload")
+
+  end
+
+  @directory.destroy
+
+end