fog-core 2.4.0 → 2.6.0

data/spec/compute_spec.rb

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

data/spec/connection_spec.rb

@@ -1,107 +0,0 @@
-require "spec_helper"
-
-describe Fog::Core::Connection do
-  it "raises ArgumentError when no arguments given" do
-    assert_raises(ArgumentError) do
-      Fog::Core::Connection.new
-    end
-  end
-
-  [:request, :reset].each do |method|
-    it "responds to #{method}" do
-      connection = Fog::Core::Connection.new("http://example.com")
-      assert connection.respond_to?(method)
-    end
-  end
-
-  it "adds custom user-agents to Fog requests" do
-    Fog::VERSION = "Version".freeze
-    Fog::Core::Connection.add_user_agent("my-app/1.2")
-
-    connection = Fog::Core::Connection.new("http://example.com")
-    assert_equal "my-app/1.2 fog/Version fog-core/#{Fog::Core::VERSION}",
-                 connection.instance_variable_get(:@excon).data[:headers]["User-Agent"]
-
-    Fog.send(:remove_const, :VERSION)
-  end
-
-  it "doesn't error when persistence is enabled" do
-    Fog::Core::Connection.new("http://example.com", true)
-  end
-
-  it "doesn't error when persistence is enabled and debug_response is disabled" do
-    options = {
-      debug_response: false
-    }
-    Fog::Core::Connection.new("http://example.com", true, options)
-  end
-
-  describe ":path_prefix" do
-    it "does not emit a warning when provided this argument in the initializer" do
-      $stderr = StringIO.new
-
-      Fog::Core::Connection.new("http://example.com", false, path_prefix: "foo")
-
-      assert_empty($stderr.string)
-    end
-
-    it "raises when the 'path' arg is present and this arg is supplied" do
-      assert_raises(ArgumentError) do
-        Fog::Core::Connection.new("http://example.com", false, path_prefix: "foo", path: "bar")
-      end
-    end
-  end
-
-  describe "#request" do
-    describe "default behavior" do
-      it "supplies the 'path' arg directly to Excon" do
-        spy = Object.new
-        spy.instance_eval do
-          def params
-            @params
-          end
-
-          def new(_, params)
-            @params = params
-          end
-        end
-
-        Object.stub_const("Excon", spy) do
-          Fog::Core::Connection.new("http://example.com", false, path: "bar")
-          assert_equal("bar", spy.params[:path])
-        end
-      end
-    end
-
-    describe "with path_prefix supplied to the initializer" do
-      let(:spy) do
-        Object.new.tap do |spy|
-          spy.instance_eval do
-            def new(*_args); self; end
-            def params; @params; end
-
-            def request(params)
-              @params = params
-            end
-          end
-        end
-      end
-
-      it "uses the initializer-supplied :path_prefix arg with #request :arg to formulate a path to send to Excon.request" do
-        Object.stub_const("Excon", spy) do
-          c = Fog::Core::Connection.new("http://example.com", false, path_prefix: "foo")
-          c.request(path: "bar")
-          assert_equal("foo/bar", spy.params[:path])
-        end
-      end
-
-      it "does not introduce consecutive '/'s into the path if 'path' starts with a '/'" do
-        Object.stub_const("Excon", spy) do
-          c = Fog::Core::Connection.new("http://example.com", false, path_prefix: "foo")
-          c.request(path: "/bar")
-          assert_equal("foo/bar", spy.params[:path])
-        end
-      end
-    end
-  end
-end

data/spec/core/cache_spec.rb

@@ -1,227 +0,0 @@
-require "spec_helper"
-require "securerandom"
-
-module Fog
-  class SubFogTestModel < Fog::Model
-    identity  :id
-
-    attribute :config
-    attribute :subconfig
-
-    def initialize(new_attributes = {})
-      super
-
-      # This way we make YAML to use aliases
-      self.config = {
-        "users" => [
-          { "user1" => "user1@email" },
-          { "user2" => "user2@email" }
-        ]
-      }
-      self.subconfig = config["users"][0]
-    end
-  end
-end
-
-module Fog
-  class SubFogTestCollection < Fog::Collection
-    model Fog::SubFogTestModel
-
-    attribute :spec_attribute
-  end
-end
-
-module Fog
-  class SubFogTestService < Fog::Service
-
-    class Mock
-      attr_reader :options
-
-      def initialize(opts = {})
-        @options = opts
-      end
-    end
-  end
-end
-
-describe Fog::Cache do
-  before(:each) do
-    Fog.mock!
-    @service = Fog::SubFogTestService.new
-    Fog::Cache.namespace_prefix = "test-dir"
-  end
-
-  it "has a namespace_prefix configurable" do
-    Fog::Cache.namespace_prefix = "for-service-user-region-foo"
-
-    # Expand path does not downcase. case insensitive platform tests.
-    example_cache = File.expand_path(Fog::Cache.namespace(Fog::SubFogTestModel, @service)).downcase
-    expected_namespace = File.expand_path("~/.fog-cache/for-service-user-region-foo").downcase
-
-    assert_equal example_cache.include?(expected_namespace), true
-  end
-
-  it "has metadata associated to the namespace that you can save to" do
-    Fog::Cache.clean!
-    Fog::Cache.namespace_prefix = "for-service-user-region-foo"
-    # nothing exists, nothing comes back
-    assert_equal Fog::Cache.metadata, {}
-    # write/read
-    Fog::Cache.write_metadata({last_dumped: "Tuesday, November 8, 2016"})
-    assert_equal Fog::Cache.metadata[:last_dumped], "Tuesday, November 8, 2016"
-
-    # diff namespace, diff metadata
-    Fog::Cache.namespace_prefix = "different-namespace"
-    assert_nil Fog::Cache.metadata[:last_dumped]
-    # still accessible per namespace
-    Fog::Cache.namespace_prefix = "for-service-user-region-foo"
-    assert_equal Fog::Cache.metadata[:last_dumped], "Tuesday, November 8, 2016"
-    # can overwrite
-    Fog::Cache.write_metadata({last_dumped: "Diff date"})
-    assert_equal Fog::Cache.metadata[:last_dumped], "Diff date"
-
-    # can't write a non-hash/data entry.
-    assert_raises Fog::Cache::CacheDir do
-      Fog::Cache.write_metadata("boo")
-    end
-
-    # namespace must be set as well.
-    assert_raises Fog::Cache::CacheDir do
-      Fog::Cache.namespace_prefix = nil
-      Fog::Cache.write_metadata({a: "b"})
-    end
-  end
-
-  it "can load cache data from disk" do
-    path = File.expand_path("~/.fog-cache-test-#{Time.now.to_i}.yml")
-    data = "--- ok\n...\n"
-    File.open(path, "w") { |f|
-      f.write(data)
-    }
-
-    assert_equal "ok", Fog::Cache.load_cache(path)
-  end
-
-  it "load bad cache data - empty file, from disk" do
-    path = File.expand_path("~/.fog-cache-test-2-#{Time.now.to_i}.yml")
-    data = ""
-    File.open(path, "w") { |f|
-      f.write(data)
-    }
-
-    assert !Fog::Cache.load_cache(path)
-  end
-
-  it "must have a namespace_prefix configurable" do
-    Fog::Cache.namespace_prefix = nil
-    assert_raises Fog::Cache::CacheDir do
-      Fog::Cache.load(Fog::SubFogTestModel, @service)
-    end
-  end
-
-  it "can create a namespace" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-    assert_equal File.exist?(Fog::Cache.namespace(Fog::SubFogTestModel, @service)), false
-
-    Fog::Cache.create_namespace(Fog::SubFogTestModel, @service)
-    assert_equal File.exist?(Fog::Cache.namespace(Fog::SubFogTestModel, @service)), true
-  end
-
-  it "will raise if no cache data found" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-
-    assert_raises Fog::Cache::CacheNotFound do
-      Fog::Cache.load(Fog::SubFogTestModel, @service)
-    end
-  end
-
-  it "Fog cache ignores bad cache data - empty file, from disk" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-    id = SecureRandom.hex
-    a = Fog::SubFogTestModel.new(id: id, service: @service)
-    a.cache.dump
-
-    # input bad data
-    path_dir = File.expand_path(Fog::Cache.namespace(Fog::SubFogTestModel, @service))
-    path = File.join(path_dir, "foo.yml")
-    data = ""
-    File.open(path, "w") { |f|
-      f.write(data)
-    }
-
-    assert_equal 1, Fog::Cache.load(Fog::SubFogTestModel, @service).size
-  end
-
-  it "can be dumped and reloaded back in" do
-
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-
-    id = SecureRandom.hex
-    a = Fog::SubFogTestModel.new(id: id, service: @service)
-
-    assert_equal File.exist?(Fog::Cache.namespace(Fog::SubFogTestModel, @service)), false
-    a.cache.dump
-    assert_equal File.exist?(Fog::Cache.namespace(Fog::SubFogTestModel, @service)), true
-
-    instances = Fog::Cache.load(Fog::SubFogTestModel, @service)
-
-    assert_equal instances.first.id, a.id
-    assert_equal instances.first.class, a.class
-  end
-
-  it "dumping two models that have a duplicate identity" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-
-    id = SecureRandom.hex
-
-    # security groups on aws for eg can have the same identity group name 'default'.
-    # there are no restrictions on `identity` fog attributes to be uniq.
-    a = Fog::SubFogTestModel.new(id: id, service: @service, bar: "bar")
-    b = Fog::SubFogTestModel.new(id: id, service: @service, foo: "foo")
-
-    a.cache.dump
-    b.cache.dump
-
-    instances = Fog::Cache.load(Fog::SubFogTestModel, @service)
-
-    assert_equal instances.size, 2
-  end
-
-  it "dumping two models that have a duplicate identity twice" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-
-    id = SecureRandom.hex
-
-    # security groups on aws for eg can have the same identity group name 'default'.
-    # there are no restrictions on `identity` fog attributes to be uniq.
-    a = Fog::SubFogTestModel.new(id: id, service: @service, bar: "bar")
-    b = Fog::SubFogTestModel.new(id: id, service: @service, foo: "foo")
-
-    a.cache.dump
-    b.cache.dump
-
-    # and then again, w/out expiring cache
-    a.cache.dump
-    b.cache.dump
-
-    instances = Fog::Cache.load(Fog::SubFogTestModel, @service)
-
-    # unique-ify based on the attributes...
-    assert_equal instances.size, 2
-  end
-
-  it "dumps model with collection attributes and reloads them" do
-    Fog::Cache.expire_cache!(Fog::SubFogTestModel, @service)
-
-    c = Fog::SubFogTestCollection.new(service: @service, spec_attribute: 42)
-
-    id = SecureRandom.hex
-    a = Fog::SubFogTestModel.new(id: id, service: @service, collection: c)
-
-    a.cache.dump
-
-    instances = Fog::Cache.load(Fog::SubFogTestModel, @service)
-    assert_equal instances.first.id, id
-    assert_equal instances.first.collection.spec_attribute, 42
-  end
-end

data/spec/core/collection_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-require "securerandom"
-
-class FogTestModelForCollection < Fog::Model
-  identity  :id
-end
-
-class FogTestCollection < Fog::Collection
-  model FogTestModelForCollection
-
-  def all
-    self
-  end
-end
-
-describe Fog::Collection do
-  describe "array delegation" do
-    it "delegates methods with keywords to Array" do
-      c = FogTestCollection.new
-      c << FogTestModelForCollection.new(id: SecureRandom.hex)
-      assert_equal c.sample(1, random: Random)[0], c[0]
-    end
-  end
-end

data/spec/core/model_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-require "securerandom"
-
-class FogTestModel < Fog::Model
-  identity  :id
-  attribute :value
-
-  def create
-    self.identity = SecureRandom.hex
-    self
-  end
-
-  def update
-    self.value = 42
-    self
-  end
-end
-
-describe Fog::Model do
-  describe "#==" do
-    it "is not equal if one is not a Fog::Model" do
-      a = FogTestModel.new
-      b = 2
-      refute_equal a, b
-      refute_equal b, a
-    end
-
-    it "is equal if it is the same object" do
-      a = b = FogTestModel.new
-      assert_equal a, b
-    end
-
-    it "is equal if it has the same non-nil identity and the same class" do
-      id = SecureRandom.hex
-      assert_equal FogTestModel.new(id: id), FogTestModel.new(id: id)
-    end
-
-    it "is not equal if both have nil identity, but are different objects" do
-      refute_equal FogTestModel.new, FogTestModel.new
-    end
-
-    it "is not equal if it has a different identity" do
-      refute_equal FogTestModel.new(id: SecureRandom.hex),
-                   FogTestModel.new(id: SecureRandom.hex)
-    end
-  end
-
-  describe "#save" do
-    describe "on a non persisted object" do
-      it "creates a new resource" do
-        a = FogTestModel.new
-        a.stub(:persisted?, false) do
-          a.save
-          refute_nil(a.identity)
-        end
-      end
-    end
-
-    describe "on a persisted object" do
-      it "updates resource" do
-        a = FogTestModel.new
-        a.stub(:persisted?, true) do
-          a.save
-          assert_equal(a.value, 42)
-        end
-      end
-    end
-  end
-end

data/spec/core/stringify_keys_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe "Fog::StringifyKeys" do
-  describe ".stringify" do
-    describe "when key is a Symbol" do
-      it "replaces key with String" do
-        input = { key: "value" }
-        output = Fog::StringifyKeys.stringify(input)
-        assert(output.key?("key"))
-      end
-    end
-
-    describe "when key is a String" do
-      it "keeps key as String" do
-        input = { "key" => "value" }
-        output = Fog::StringifyKeys.stringify(input)
-        assert(output.key?("key"))
-      end
-    end
-
-    describe "when Hash is empty" do
-      it "returns empty Hash" do
-        assert_equal({}, Fog::StringifyKeys.stringify({}))
-      end
-    end
-
-    describe "when keys are deeply nested" do
-      it "updates only top level key" do
-        input = { key1: { key2: { key3: nil }}}
-
-        output = Fog::StringifyKeys.stringify(input)
-
-        expected = { "key1" => { key2: { key3: nil }}}
-        assert_equal(expected, output)
-      end
-    end
-  end
-end

data/spec/core/whitelist_keys_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe "Fog::WhitelistKeys" do
-  describe ".whitelist" do
-    describe "when other keys are present" do
-      it "returns Hash with only allowed keys" do
-        input = { name: "name", type: "type", size: 80 }
-        valid_keys = %w(name size)
-
-        output = Fog::WhitelistKeys.whitelist(input, valid_keys)
-
-        expected = { "name" => "name", "size" => 80 }
-        assert_equal(expected, output)
-      end
-    end
-
-    describe "when key is a Symbol" do
-      it "returns a String" do
-        input = { name: "name" }
-        valid_keys = %w(name)
-
-        output = Fog::WhitelistKeys.whitelist(input, valid_keys)
-
-        expected = { "name" => "name" }
-        assert(expected, output)
-      end
-    end
-
-    describe "when Hash is empty" do
-      it "returns empty Hash" do
-        output = Fog::WhitelistKeys.whitelist({}, [])
-        assert_equal({}, output)
-      end
-    end
-  end
-end

data/spec/credentials_spec.rb

@@ -1,88 +0,0 @@
-require "spec_helper"
-
-describe "credentials" do
-  before do
-    @old_home = ENV["HOME"]
-    @old_rc   = ENV["FOG_RC"]
-    @old_credential = ENV["FOG_CREDENTIAL"]
-    @old_credentials = Fog.credentials
-    Fog.instance_variable_set("@credential_path", nil) # kill memoization
-    Fog.instance_variable_set("@credential", nil) # kill memoization
-  end
-
-  after do
-    ENV["HOME"] = @old_home
-    ENV["FOG_RC"] = @old_rc
-    ENV["FOG_CREDENTIAL"] = @old_credential
-    Fog.credentials = @old_credentials
-  end
-
-  describe "credential" do
-    it "returns :default for default credentials" do
-      assert_equal :default, Fog.credential
-    end
-
-    it "returns the to_sym of the assigned value" do
-      Fog.credential = "foo"
-      assert_equal :foo, Fog.credential
-    end
-
-    it "can set credentials throught the FOG_CREDENTIAL env va" do
-      ENV["FOG_CREDENTIAL"] = "bar"
-      assert_equal :bar, Fog.credential
-    end
-  end
-
-  describe "credentials_path"  do
-    it "has FOG_RC takes precedence over HOME" do
-      ENV["HOME"] = "/home/path"
-      ENV["FOG_RC"] = "/rc/path"
-
-      assert_equal "/rc/path", Fog.credentials_path
-    end
-
-    it "properly expands paths" do
-      ENV["FOG_RC"] = "/expanded/subdirectory/../path"
-      assert_equal "/expanded/path", Fog.credentials_path
-    end
-
-    it "falls back to home path if FOG_RC not set" do
-      ENV.delete("FOG_RC")
-      assert_equal File.join(ENV["HOME"], ".fog"), Fog.credentials_path
-    end
-
-    it "ignores home path if it does not exist" do
-      ENV.delete("FOG_RC")
-      ENV["HOME"] = "/no/such/path"
-      assert_nil Fog.credentials_path
-    end
-
-    it "File.expand_path raises because of non-absolute path" do
-      ENV.delete("FOG_RC")
-      ENV["HOME"] = "."
-
-      if RUBY_PLATFORM == "java"
-        Fog::Logger.warning("Stubbing out non-absolute path credentials test due to JRuby bug: https://github.com/jruby/jruby/issues/1163")
-      else
-        assert_nil Fog.credentials_path
-      end
-    end
-
-    it "returns nil when neither FOG_RC or HOME are set" do
-      ENV.delete("HOME")
-      ENV.delete("FOG_RC")
-      assert_nil Fog.credentials_path
-    end
-  end
-
-  describe "symbolize_credential?" do
-    it "returns false if the value is :headers" do
-      refute Fog.symbolize_credential?(:headers)
-    end
-
-    it "returns true if the value is not :headers" do
-      assert Fog.symbolize_credential?(:foo)
-      assert Fog.symbolize_credential?(:liberate_me_ex_inheris)
-    end
-  end
-end