fog-core 2.1.0 → 2.6.0

data/spec/identity_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-module Fog
-  module Identity
-    def self.require(*_args); end
-  end
-end
-
-describe "Fog::Identity" do
-  describe "#new" do
-    module Fog
-      module TheRightWay
-        extend Provider
-        service(:identity, "Identity")
-      end
-    end
-
-    module Fog
-      module Identity
-        class TheRightWay
-          def initialize(_args); end
-        end
-      end
-    end
-
-    it "instantiates an instance of Fog::Identity::<Provider> from the :provider keyword arg" do
-      identity = Fog::Identity.new(:provider => :therightway)
-      assert_instance_of(Fog::Identity::TheRightWay, identity)
-    end
-
-    module Fog
-      module Rackspace
-        extend Provider
-        service(:identity, "Identity")
-      end
-    end
-
-    module Fog
-      module Rackspace
-        class Identity
-          def initialize(_args); end
-        end
-      end
-    end
-
-    it "instantiates an instance of Fog::<Provider>::Identity from the :provider keyword arg" do
-      identity = Fog::Identity.new(:provider => :rackspace)
-      assert_instance_of(Fog::Rackspace::Identity, identity)
-    end
-
-    module Fog
-      module BothWays
-        extend Provider
-        service(:identity, "Identity")
-      end
-    end
-
-    module Fog
-      module BothWays
-        class Identity
-          def initialize(_args); end
-        end
-      end
-    end
-
-    module Fog
-      module Identity
-        class BothWays
-          attr_reader :args
-          def initialize(args)
-            @args = args
-          end
-        end
-      end
-    end
-
-    describe "when both Fog::Identity::<Provider> and Fog::<Provider>::Identity exist" do
-      it "prefers Fog::Identity::<Provider>" do
-        identity = Fog::Identity.new(:provider => :bothways)
-        assert_instance_of(Fog::Identity::BothWays, identity)
-      end
-    end
-
-    it "passes the supplied keyword args less :provider to Fog::Identity::<Provider>#new" do
-      identity = Fog::Identity.new(:provider => :bothways, :extra => :stuff)
-      assert_equal({ :extra => :stuff }, identity.args)
-    end
-
-    it "raises ArgumentError when given a :provider where a Fog::Identity::Provider that does not exist" do
-      assert_raises(ArgumentError) do
-        Fog::Identity.new(:provider => :wat)
-      end
-    end
-  end
-end

data/spec/mocking_spec.rb

@@ -1,84 +0,0 @@
-require "spec_helper"
-
-describe "Fog mocking" do
-  before do
-    @fog_was_mocked = Fog.mock?
-    Fog.unmock! if @fog_was_mocked
-  end
-
-  after do
-    Fog.mock! if @fog_was_mocked
-  end
-
-  describe "Fog.mock!" do
-    it "Fog.mock! returns true" do
-      assert_equal true, Fog.mock!
-    end
-
-    it "Fog.mock? without Fog.mock! returns false" do
-      assert_equal false, Fog.mock?
-    end
-
-    it "Fog.mock? with Fog.mock!" do
-      Fog.mock!
-      assert_equal true, Fog.mock?
-    end
-
-    it "Fog.mocking? without Fog.mock!" do
-      assert_equal false, Fog.mocking?
-    end
-
-    it "Fog.mocking? with Fog.mock!" do
-      Fog.mock!
-      assert_equal true, Fog.mocking?
-    end
-  end
-
-  describe "Fog::Mock.delay" do
-    it "Fog::Mock.delay defaults to 0" do
-      assert_equal 1, Fog::Mock.delay
-    end
-
-    it "handles reassignment" do
-      Fog::Mock.delay = 2
-      assert_equal 2, Fog::Mock.delay
-
-      Fog::Mock.delay = 1
-      assert_equal 1, Fog::Mock.delay
-    end
-
-    it "raises when given an illegal delay" do
-      assert_raises(ArgumentError) do
-        Fog::Mock.delay = -1
-      end
-    end
-  end
-
-  describe "Fog::Mock.random_ip" do
-    it "defaults to ipv4" do
-      assert IPAddr.new(Fog::Mock.random_ip).ipv4?
-    end
-
-    it "supports explicit request for v4" do
-      assert IPAddr.new(Fog::Mock.random_ip(:version => :v4)).ipv4?
-    end
-
-    it "supports explicit request for v6" do
-      assert IPAddr.new(Fog::Mock.random_ip(:version => :v6)).ipv6?
-    end
-
-    it "raises when supplied an illegal IP version" do
-      assert_raises(ArgumentError) do
-        IPAddr.new(Fog::Mock.random_ip(:version => :v5)).ipv4?
-      end
-    end
-  end
-
-  describe "Fog::Mock.not_implemented" do
-    it "raises MockNotImplemented when called" do
-      assert_raises(Fog::Errors::MockNotImplemented) do
-        Fog::Mock.not_implemented
-      end
-    end
-  end
-end

data/spec/service_spec.rb

@@ -1,201 +0,0 @@
-require "spec_helper"
-
-describe Fog::Service do
-  class TestService < Fog::Service
-    requires :generic_api_key
-    recognizes :generic_user
-
-    class Real
-      attr_reader :options
-
-      def initialize(opts = {})
-        @options = opts
-      end
-    end
-
-    class Mock
-      attr_reader :options
-
-      def initialize(opts = {})
-        @options = opts
-      end
-    end
-  end
-
-  class ChildOfTestService < TestService
-    class Real; def initialize(*_args); end; end
-    class Mock; def initialize(*_args); end; end
-  end
-
-  it "properly passes headers" do
-    user_agent_hash = {
-      "User-Agent" => "Generic Fog Client"
-    }
-    params = {
-      :generic_user => "bob",
-      :generic_api_key => "1234",
-      :connection_options => {
-        :headers => user_agent_hash
-      }
-    }
-    service = TestService.new(params)
-
-    assert_equal user_agent_hash, service.options[:connection_options][:headers]
-  end
-
-  describe "when created with a Hash" do
-    it "raises for required argument that are missing" do
-      assert_raises(ArgumentError) { TestService.new({}) }
-    end
-
-    it "converts String keys to be Symbols" do
-      service = TestService.new "generic_api_key" => "abc"
-      assert_includes service.options.keys, :generic_api_key
-    end
-
-    it "removes keys with `nil` values" do
-      service = TestService.new :generic_api_key => "abc", :generic_user => nil
-      refute_includes service.options.keys, :generic_user
-    end
-
-    it "converts number String values with to_i" do
-      service = TestService.new :generic_api_key => "3421"
-      assert_equal 3421, service.options[:generic_api_key]
-    end
-
-    it "converts 'true' String values to TrueClass" do
-      service = TestService.new :generic_api_key => "true"
-      assert_equal true, service.options[:generic_api_key]
-    end
-
-    it "converts 'false' String values to FalseClass" do
-      service = TestService.new :generic_api_key => "false"
-      assert_equal false, service.options[:generic_api_key]
-    end
-
-    it "warns for unrecognised options" do
-      bad_options = { :generic_api_key => "abc", :bad_option => "bad value" }
-      logger = Minitest::Mock.new
-      logger.expect :warning, nil, ["Unrecognized arguments: bad_option"]
-      Fog.stub_const :Logger, logger do
-        TestService.new(bad_options)
-      end
-      logger.verify
-    end
-  end
-
-  describe "when creating and mocking is disabled" do
-    it "returns the real service" do
-      Fog.stub :mocking?, false do
-        service = TestService.new(:generic_api_key => "abc")
-        service.must_be_instance_of TestService::Real
-      end
-    end
-
-    it "TestService::Real has TestService::Collections mixed into the mocked service" do
-      Fog.stub :mocking?, false do
-        service = TestService.new(:generic_api_key => "abc")
-        assert_includes(service.class.ancestors, TestService::Collections)
-        assert_includes(service.class.ancestors, Fog::Service::Collections)
-        refute_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end
-    end
-
-    it "ChildOfTestService::Real has ChildOfTestService::Collections and TestService::Collections mixed in" do
-      Fog.stub :mocking?, true do
-        service = ChildOfTestService.new
-        assert_includes(service.class.ancestors, Fog::Service::Collections)
-        assert_includes(service.class.ancestors, TestService::Collections)
-        assert_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end
-    end
-  end
-
-  describe "when creating and mocking is enabled" do
-    it "returns mocked service" do
-      Fog.stub :mocking?, true do
-        service = TestService.new(:generic_api_key => "abc")
-        service.must_be_instance_of TestService::Mock
-      end
-    end
-
-    it "TestService::Mock has TestService::Collections mixed into the mocked service" do
-      Fog.stub :mocking?, true do
-        service = TestService.new(:generic_api_key => "abc")
-        assert_includes(service.class.ancestors, Fog::Service::Collections)
-        assert_includes(service.class.ancestors, TestService::Collections)
-        refute_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end
-    end
-
-    it "ChildOfTestService::Mock has ChildOfTestService::Collections and TestService::Collections mixed in" do
-      Fog.stub :mocking?, true do
-        service = ChildOfTestService.new
-        assert_includes(service.class.ancestors, Fog::Service::Collections)
-        assert_includes(service.class.ancestors, TestService::Collections)
-        assert_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end
-    end
-  end
-
-  describe "when no credentials are provided" do
-    it "uses the global values" do
-      @global_credentials = {
-        :generic_user => "fog",
-        :generic_api_key => "fog"
-      }
-
-      Fog.stub :credentials, @global_credentials do
-        @service = TestService.new
-        assert_equal @service.options, @global_credentials
-      end
-    end
-  end
-
-  describe "when credentials are provided as settings" do
-    it "merges the global values into settings" do
-      @settings = {
-        :generic_user => "fog"
-      }
-      @global_credentials = {
-        :generic_user => "bob",
-        :generic_api_key => "fog"
-      }
-
-      Fog.stub :credentials, @global_credentials do
-        @service = TestService.new(@settings)
-        assert_equal @service.options[:generic_user], "fog"
-        assert_equal @service.options[:generic_api_key], "fog"
-      end
-    end
-  end
-
-  describe "when config object can configure the service itself" do
-    it "ignores the global and its values" do
-      @config = MiniTest::Mock.new
-      def @config.config_service?;  true; end
-      def @config.nil?; false; end
-      def @config.==(other); object_id == other.object_id; end
-
-      unexpected_usage = lambda { raise "Accessing global!" }
-      Fog.stub :credentials, unexpected_usage do
-        @service = TestService.new(@config)
-        assert_equal @config, @service.options
-      end
-    end
-  end
-
-  describe "#setup_requirements" do
-    before :each do
-      @service = FakeService.new
-    end
-
-    it "should require collections" do
-      assert @service.respond_to?(:collection)
-    end
-
-    it "should mock" do
-      assert_includes @service.mocked_requests, :request
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-if ENV["COVERAGE"]
-  require "coveralls"
-  require "simplecov"
-
-  SimpleCov.start do
-    add_filter "/spec/"
-  end
-end
-
-require "minitest/autorun"
-require "minitest/spec"
-require "minitest/stub_const"
-
-$LOAD_PATH.unshift "lib"
-require "fog/core"
-
-Dir["spec/fake_app/**/*.rb"].each do |file|
-  require File.join(File.dirname(__FILE__), "..", file)
-end

data/spec/storage_spec.rb

@@ -1,114 +0,0 @@
-require "spec_helper"
-
-module Fog
-  module Storage
-    def self.require(*_args); end
-  end
-end
-
-describe "Fog::Storage" do
-  describe "#new" do
-    module Fog
-      module TheRightWay
-        extend Provider
-        service(:storage, "Storage")
-      end
-    end
-
-    module Fog
-      module Storage
-        class TheRightWay
-          def initialize(_args); end
-        end
-      end
-    end
-
-    it "instantiates an instance of Fog::Storage::<Provider> from the :provider keyword arg" do
-      compute = Fog::Storage.new(:provider => :therightway)
-      assert_instance_of(Fog::Storage::TheRightWay, compute)
-    end
-
-    module Fog
-      module TheWrongWay
-        extend Provider
-        service(:storage, "Storage")
-      end
-    end
-
-    module Fog
-      module TheWrongWay
-        class Storage
-          def initialize(_args); end
-        end
-      end
-    end
-
-    it "instantiates an instance of Fog::<Provider>::Storage from the :provider keyword arg" do
-      compute = Fog::Storage.new(:provider => :thewrongway)
-      assert_instance_of(Fog::TheWrongWay::Storage, compute)
-    end
-
-    module Fog
-      module BothWays
-        extend Provider
-        service(:storage, "Storage")
-      end
-    end
-
-    module Fog
-      module BothWays
-        class Storage
-          def initialize(_args); end
-        end
-      end
-    end
-
-    module Fog
-      module Storage
-        class BothWays
-          attr_reader :args
-
-          def initialize(args)
-            @args = args
-          end
-        end
-      end
-    end
-
-    describe "when both Fog::Storage::<Provider> and Fog::<Provider>::Storage exist" do
-      it "prefers Fog::Storage::<Provider>" do
-        compute = Fog::Storage.new(:provider => :bothways)
-        assert_instance_of(Fog::Storage::BothWays, compute)
-      end
-    end
-
-    it "passes the supplied keyword args less :provider to Fog::Storage::<Provider>#new" do
-      compute = Fog::Storage.new(:provider => :bothways, :extra => :stuff)
-      assert_equal({ :extra => :stuff }, compute.args)
-    end
-
-    it "raises ArgumentError when given a :provider where a Fog::Storage::Provider that does not exist" do
-      assert_raises(ArgumentError) do
-        Fog::Storage.new(:provider => :wat)
-      end
-    end
-  end
-
-  describe ".get_body_size" do
-    it "doesn't alter the encoding of the string passed to it" do
-      body = "foo".encode("UTF-8")
-      Fog::Storage.get_body_size(body)
-
-      assert_equal("UTF-8", body.encoding.to_s)
-    end
-
-    it "respects frozen strings" do
-      if RUBY_VERSION >= "2.3.0"
-        body = "foo".freeze
-        Fog::Storage.get_body_size(body)
-      else
-        skip
-      end
-    end
-  end
-end

data/spec/test_helpers/formats_helper_spec.rb

@@ -1,121 +0,0 @@
-require "spec_helper"
-require "fog/test_helpers/formats_helper"
-require "fog/test_helpers/types_helper"
-
-module Shindo
-  class Tests
-    def test(_str, &_block)
-      yield
-    end
-  end
-end
-
-describe "formats_helper" do
-  let(:shindo) { Shindo::Tests.new }
-
-  it "comparing welcome data against schema" do
-    data = { :welcome => "Hello" }
-    assert shindo.data_matches_schema(:welcome => String) { data }
-  end
-
-  describe "#data_matches_schema" do
-    it "when value matches schema expectation" do
-      assert shindo.data_matches_schema("key" => String) { { "key" => "Value" } }
-    end
-
-    it "when values within an array all match schema expectation" do
-      assert shindo.data_matches_schema("key" => [Integer]) { { "key" => [1, 2] } }
-    end
-
-    it "when nested values match schema expectation" do
-      assert shindo.data_matches_schema("key" => { :nested_key => String }) { { "key" => { :nested_key => "Value" } } }
-    end
-
-    it "when collection of values all match schema expectation" do
-      assert shindo.data_matches_schema([{ "key" => String }]) { [{ "key" => "Value" }, { "key" => "Value" }] }
-    end
-
-    it "when collection is empty although schema covers optional members" do
-      assert shindo.data_matches_schema([{ "key" => String }], :allow_optional_rules => true) { [] }
-    end
-
-    it "when additional keys are passed and not strict" do
-      assert shindo.data_matches_schema({ "key" => String }, { :allow_extra_keys => true }) { { "key" => "Value", :extra => "Bonus" } }
-    end
-
-    it "when value is nil and schema expects NilClass" do
-      assert shindo.data_matches_schema("key" => NilClass) { { "key" => nil } }
-    end
-
-    it "when value and schema match as hashes" do
-      assert shindo.data_matches_schema({}) { {} }
-    end
-
-    it "when value and schema match as arrays" do
-      assert shindo.data_matches_schema([]) { [] }
-    end
-
-    it "when value is a Time" do
-      assert shindo.data_matches_schema("time" => Time) { { "time" => Time.now } }
-    end
-
-    it "when key is missing but value should be NilClass (#1477)" do
-      assert shindo.data_matches_schema({ "key" => NilClass }, { :allow_optional_rules => true }) { {} }
-    end
-
-    it "when key is missing but value is nullable (#1477)" do
-      assert shindo.data_matches_schema({ "key" => Fog::Nullable::String }, { :allow_optional_rules => true }) { {} }
-    end
-  end
-
-  describe "#formats backwards compatible changes" do
-
-    it "when value matches schema expectation" do
-      assert shindo.formats("key" => String) { { "key" => "Value" } }
-    end
-
-    it "when values within an array all match schema expectation" do
-      assert shindo.formats("key" => [Integer]) { { "key" => [1, 2] } }
-    end
-
-    it "when nested values match schema expectation" do
-      assert shindo.formats("key" => { :nested_key => String }) { { "key" => { :nested_key => "Value" } } }
-    end
-
-    it "when collection of values all match schema expectation" do
-      assert shindo.formats([{ "key" => String }]) { [{ "key" => "Value" }, { "key" => "Value" }] }
-    end
-
-    it "when collection is empty although schema covers optional members" do
-      assert shindo.formats([{ "key" => String }]) { [] }
-    end
-
-    it "when additional keys are passed and not strict" do
-      assert shindo.formats({ "key" => String }, false) { { "key" => "Value", :extra => "Bonus" } }
-    end
-
-    it "when value is nil and schema expects NilClass" do
-      assert shindo.formats("key" => NilClass) { { "key" => nil } }
-    end
-
-    it "when value and schema match as hashes" do
-      assert shindo.formats({}) { {} }
-    end
-
-    it "when value and schema match as arrays" do
-      assert shindo.formats([]) { [] }
-    end
-
-    it "when value is a Time" do
-      assert shindo.formats("time" => Time) { { "time" => Time.now } }
-    end
-
-    it "when key is missing but value should be NilClass (#1477)" do
-      assert shindo.formats("key" => NilClass) { {} }
-    end
-
-    it "when key is missing but value is nullable (#1477)" do
-      assert shindo.formats("key" => Fog::Nullable::String) { {} }
-    end
-  end
-end