fog-core 2.3.0 → 2.5.0

data/spec/compute/models/server_spec.rb

@@ -1,229 +0,0 @@
-require "spec_helper"
-require "fog/compute/models/server"
-
-describe Fog::Compute::Server do
-  before do
-    @server = Fog::Compute::Server.new
-  end
-
-  describe "#sshable?" do
-    describe "when the server is not ready" do
-      it "is false" do
-        @server.stub(:ready?, false) do
-          refute @server.sshable?
-        end
-      end
-    end
-
-    describe "when the server is ready" do
-      describe "when the ssh_ip_address is nil" do
-        it "is false" do
-          @server.stub(:ready?, true) do
-            @server.stub(:ssh_ip_address, nil) do
-              refute @server.sshable?
-            end
-          end
-        end
-      end
-
-
-      describe "when the ssh_ip_address exists" do
-        # Define these constants which would be imported by net-ssh once loaded
-        module Net
-          module SSH
-            class AuthenticationFailed  < RuntimeError
-            end
-            class Disconnect < RuntimeError
-            end
-          end
-        end
-
-        describe "and ssh times out" do
-          it "is false" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raises_timeout = lambda { |_time| raise Timeout::Error.new }
-                Timeout.stub(:timeout, raises_timeout) do
-                  refute @server.sshable?
-                end
-              end
-            end
-          end
-        end
-
-        describe "and it raises Net::SSH::AuthenticationFailed" do
-          it "is false" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise Net::SSH::AuthenticationFailed.new }
-                @server.stub(:ssh, raise_error) do
-                  refute @server.sshable?
-                end
-              end
-            end
-          end
-
-          it "resets SSH timeout" do
-            @server.instance_variable_set(:@sshable_timeout, 8)
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise Net::SSH::AuthenticationFailed.new }
-                @server.stub(:ssh, raise_error) do
-                  @server.sshable?
-                  assert_nil @server.instance_variable_get(:@sshable_timeout), nil
-                end
-              end
-            end
-          end
-        end
-
-        describe "and it raises Net::SSH::Disconnect" do
-          it "is false" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise Net::SSH::Disconnect.new }
-                @server.stub(:ssh, raise_error) do
-                  refute @server.sshable?
-                end
-              end
-            end
-          end
-
-          it "resets SSH timeout" do
-            @server.instance_variable_set(:@sshable_timeout, 8)
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise Net::SSH::Disconnect.new }
-                @server.stub(:ssh, raise_error) do
-                  @server.sshable?
-                  assert_nil @server.instance_variable_get(:@sshable_timeout), nil
-                end
-              end
-            end
-          end
-        end
-
-        describe "and it raises SystemCallError" do
-          it "is false" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise SystemCallError.new("message, 0") }
-                @server.stub(:ssh, raise_error) do
-                  refute @server.sshable?
-                end
-              end
-            end
-          end
-
-          it "does not increase SSH timeout" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                raise_error = lambda { |_cmd, _options| raise SystemCallError.new("message, 0") }
-                @server.stub(:ssh, raise_error) do
-                  @server.sshable?
-                  assert_equal @server.instance_variable_get(:@sshable_timeout), 8
-                end
-              end
-            end
-          end
-        end
-
-        describe "and ssh completes within the designated timeout" do
-          it "is true" do
-            @server.stub(:ready?, true) do
-              @server.stub(:ssh_ip_address, "10.0.0.1") do
-                @server.stub(:ssh, "datum") do
-                  assert @server.sshable?
-                end
-              end
-            end
-          end
-        end
-
-        describe "when called successively" do
-          describe "and ssh times out" do
-            it "increases the timeout factor by 1.5" do
-              @server.stub(:ready?, true) do
-                @server.stub(:ssh_ip_address, "10.0.0.1") do
-                  raises_timeout = lambda do |time|
-                    assert(time == 8)
-                    raise Timeout::Error.new
-                  end
-                  Timeout.stub(:timeout, raises_timeout) do
-                    refute @server.sshable?
-                  end
-
-                  raises_timeout = lambda do |time|
-                    assert_equal(12, time)
-                    raise Timeout::Error.new
-                  end
-                  Timeout.stub(:timeout, raises_timeout) do
-                    refute @server.sshable?
-                  end
-                end
-              end
-            end
-
-            it "does not increase timeout beyond 60s" do
-              @server.stub(:ready?, true) do
-                @server.stub(:ssh_ip_address, "10.0.0.1") do
-                  raises_timeout = lambda { |_time| raise Timeout::Error.new }
-                  Timeout.stub(:timeout, raises_timeout) do
-                    5.times { refute @server.sshable? }
-                  end
-
-                  raises_timeout = lambda do |time|
-                    assert_equal(60, time)
-                    raise Timeout::Error.new
-                  end
-                  Timeout.stub(:timeout, raises_timeout) do
-                    refute @server.sshable?
-                  end
-
-                  raises_timeout = lambda do |time|
-                    assert_equal(60, time)
-                    raise Timeout::Error.new
-                  end
-                  Timeout.stub(:timeout, raises_timeout) do
-                    refute @server.sshable?
-                  end
-                end
-              end
-            end
-
-            describe "when ssh eventually succeeds" do
-              it "resets the timeout to the initial value" do
-                @server.stub(:ready?, true) do
-                  @server.stub(:ssh_ip_address, "10.0.0.1") do
-                    raises_timeout = lambda do |time|
-                      assert(time == 8)
-                      raise Timeout::Error.new
-                    end
-                    Timeout.stub(:timeout, raises_timeout) do
-                      refute @server.sshable?
-                    end
-
-                    @server.stub(:ssh, "datum") do
-                      assert @server.sshable?
-                    end
-
-                    raises_timeout = lambda do |time|
-                      assert_equal(8, time)
-                      raise Timeout::Error.new
-                    end
-                    Timeout.stub(:timeout, raises_timeout) do
-                      refute @server.sshable?
-                    end
-                  end
-                end
-              end
-            end
-
-          end
-        end
-
-      end
-    end
-
-  end
-end

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,105 +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'
-    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,191 +0,0 @@
-require "spec_helper"
-require "securerandom"
-require "tmpdir"
-
-module Fog
-  class SubFogTestModel < Fog::Model
-    identity  :id
-  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
-end

data/spec/core/model_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "securerandom"
-
-class FogTestModel < Fog::Model
-  identity  :id
-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
-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