fog-digitalocean 0.1.0

data/spec/fog/support_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Fog::Support do
+  Fog::Support.providers.each do |provider|
+    describe "when #{provider} is passed with no available credentials" do
+      it "returns ArgumentError" do
+        # Stub credentials so you still see errors where the tester really has credentials
+        Fog.stub :credentials, {} do
+          assert_raises(ArgumentError) { Fog::Support[provider] }
+        end
+      end
+    end
+  end
+end

data/spec/fog/volume_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Fog::Volume do
+  Fog::Volume.providers.each do |provider|
+    describe "when #{provider} is passed with no available credentials" do
+      it "returns ArgumentError" do
+        # Stub credentials so you still see errors where the tester really has credentials
+        Fog.stub :credentials, {} do
+          assert_raises(ArgumentError) { Fog::Volume[provider] }
+        end
+      end
+    end
+  end
+end

data/spec/fog/vpn_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Fog::VPN do
+  Fog::VPN.providers.each do |provider|
+    describe "when #{provider} is passed with no available credentials" do
+      it "returns ArgumentError" do
+        # Stub credentials so you still see errors where the tester really has credentials
+        Fog.stub :credentials, {} do
+          assert_raises(ArgumentError) { Fog::VPN[provider] }
+        end
+      end
+    end
+  end
+end

data/spec/fog/xml/connection_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+# @note This is going to be part of fog-xml eventually
+describe Fog::XML::Connection do
+  before do
+    @connection = Fog::XML::Connection.new("http://localhost")
+  end
+
+  after do
+    Excon.stubs.clear
+  end
+
+  it "responds to #request" do
+    assert_respond_to @connection, :request
+  end
+
+  describe "when request is passed a parser" do
+    it "returns the body after parsing" do
+      @parser = Fog::ToHashDocument.new
+      Excon.stub({}, { :status => 200, :body => "<xml></xml>" })
+      response = @connection.request(:parser => @parser, :mock => true)
+      assert_equal({ :xml => "" }, response.body)
+    end
+  end
+
+  describe "when request excludes a parser" do
+    it "returns the response body without change" do
+      Excon.stub({}, { :status => 200, :body => "<xml></xml>" })
+      response = @connection.request(:mock => true)
+      assert_equal("<xml></xml>", response.body)
+    end
+  end
+end

data/spec/helpers/bin.rb

@@ -0,0 +1,34 @@
+module Fog
+  module BinSpec
+    extend Minitest::Spec::DSL
+
+    it "responds to available?" do
+      assert_respond_to subject, :available?
+    end
+
+    it "responds to class_for" do
+      assert_respond_to subject, :class_for
+    end
+
+    it "#class_for raises ArgumentError for unknown services" do
+      assert_raises(ArgumentError) { subject.class_for(:unknown) }
+    end
+
+    it "responds to collections" do
+      skip if subject == ::Google
+      assert_respond_to subject, :collections
+    end
+
+    it "responds to []" do
+      assert_respond_to subject, :[]
+    end
+
+    it "#[] when unknown service is passed raises ArgumentError" do
+      assert_raises(ArgumentError) { subject[:bad_service] }
+    end
+
+    it "responds to services" do
+      assert_respond_to subject, :services
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'coveralls'
+Coveralls.wear!
+
+if ENV["COVERAGE"]
+  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/digitalocean"

data/tests/digitalocean/helper.rb

@@ -0,0 +1,56 @@
+
+# Shortcut for Fog::Compute[:digitalocean]
+def service
+  Fog::Compute[:digitalocean]
+end
+
+def fog_test_server_attributes
+  # Hard coding numbers because requests from tests are sometimes failing.
+  # TODO: Mock properly instead
+  image = service.images.find { |i| i.name == 'Ubuntu 13.10 x64' }
+  image_id = image.nil? ? 1505447 : image.id
+  region = service.regions.find { |r| r.name == 'New York 1' }
+  region_id = region.nil? ? 4 : region.id
+  flavor = service.flavors.find { |r| r.name == '512MB' }
+  flavor_id = flavor.nil? ? 66 : flavor.id
+
+  {
+    :image_id  => image_id,
+    :region_id => region_id,
+    :flavor_id => flavor_id
+  }
+end
+
+def fog_server_name
+  "fog-server-test"
+end
+
+# Create a long lived server for the tests
+def fog_test_server
+  server = service.servers.find { |s| s.name == fog_server_name }
+  unless server
+    server = service.servers.create({
+      :name => fog_server_name
+    }.merge(fog_test_server_attributes))
+    server.wait_for { ready? }
+  end
+  server
+end
+
+# Destroy the long lived server
+def fog_test_server_destroy
+  server = service.servers.find { |s| s.name == fog_server_name }
+  server.destroy if server
+end
+
+at_exit do
+  unless Fog.mocking? || Fog.credentials[:digitalocean_api_key].nil?
+    server = service.servers.find { |s| s.name == fog_server_name }
+    if server
+      server.wait_for(120) do
+        reload rescue nil; ready?
+      end
+    end
+    fog_test_server_destroy
+  end
+end

data/tests/digitalocean/requests/compute/list_flavors_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute::DigitalOcean | list_flavors request', ['digitalocean', 'compute']) do
+  service = Fog::Compute.new(:provider => 'DigitalOcean')
+
+  size_format = {
+    'slug' => String,
+    'memory' => Integer,
+    'vcpus' => Integer,
+    'disk' => Integer,
+    'transfer' => Float,
+    'price_monthly' => Float,
+    'price_hourly' => Float,
+    'regions' => Array,
+    'available' => Fog::Boolean,
+  }
+
+  tests('success') do
+    tests('#list_flavors') do
+      service.list_flavors.body['sizes'].each do |size|
+        tests('format').data_matches_schema(size_format) do
+          size
+        end
+      end
+    end
+  end
+end

data/tests/digitalocean/requests/compute/list_images_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute::DigitalOcean | list_images request', ['digitalocean', 'compute']) do
+  service = Fog::Compute.new(:provider => 'DigitalOcean')
+
+  image_format = {
+    'id' => Integer,
+    'name' => String,
+    'type' => String,
+    'distribution' => String,
+    'slug' => Fog::Nullable::String,
+    'public' => Fog::Boolean,
+    'regions' => Array,
+    'min_disk_size' => Fog::Nullable::Integer,
+    'created_at' => String,
+  }
+
+  tests('success') do
+    tests('#list_images') do
+      service.list_images.body['images'].each do |image|
+        tests('format').data_matches_schema(image_format) do
+          image
+        end
+      end
+    end
+  end
+end

data/tests/digitalocean/requests/compute/list_regions_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Compute::DigitalOcean | list_regions request', ['digitalocean', 'compute']) do
+  service = Fog::Compute.new(:provider => 'DigitalOcean')
+
+  region_format = {
+    'slug' => String,
+    'name' => String,
+    'sizes' => Array,
+    'available' => Fog::Boolean,
+    'features' => Array,
+  }
+
+  tests('success') do
+    tests('#list_regions') do
+      service.list_regions.body['regions'].each do |region|
+        tests('format').data_matches_schema(region_format) do
+          region
+        end
+      end
+    end
+  end
+end

data/tests/digitalocean/requests/compute/server_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('Fog::Compute::DigitalOcean | create_server request', ['digitalocean', 'compute']) do
+  service = Fog::Compute.new(:provider => 'DigitalOcean')
+
+  server_format = {
+    'id'         => Integer,
+    'name'       => String,
+    'memory'     => Integer,
+    'vcpus'      => Integer,
+    'disk'       => Integer,
+    'locked'     => Fog::Boolean,
+    'created_at' => String,
+  }
+
+  create_server_format = {
+    'droplet' => {
+      'id'           => Integer,
+      'name'         => String,
+      'memory'       => Integer,
+      'vcpus'        => Integer,
+      'disk'         => Integer,
+      'locked'       => Fog::Boolean,
+      'status'       => String,
+      'kernel'       => Hash,
+      "created_at"   => String,
+      "features"     => Array,
+      "backup_ids"   => Array,
+      "snapshot_ids" => Array,
+      "image"        => Hash,
+      "size"         => Hash,
+      "size_slug"    => String,
+      "networks"     => Hash,
+      "region"       => Hash,
+    },
+
+    'links'   => {
+      "actions" => Array,
+    }
+
+  }
+
+  tests('success') do
+
+    server_id   = nil
+    server_name = "fog-#{Time.now.to_i.to_s}"
+    image       = "ubuntu-14-04-x64"
+    region      = "nyc3"
+    size        = "512mb"
+
+    tests("#create_server(#{server_name}, #{size}, #{image}, #{region})").formats(create_server_format) do
+      body      = service.create_server(server_name, size, image, region).body
+      server_id = body['droplet']['id']
+      body
+    end
+
+    test('#get_server_details can retrieve by id') do
+      body = service.get_server_details(server_id).body
+      tests('format').data_matches_schema(server_format) do
+        body['droplet']
+      end
+    end
+
+    server = service.servers.get(server_id)
+    server.wait_for { ready? }
+
+    tests('#delete_server').succeeds do
+      server.delete
+    end
+
+    tests('#list_servers') do
+      service.list_servers.body['droplets'].each do |droplet|
+        tests('format').data_matches_schema(server_format) do
+          droplet
+        end
+      end
+    end
+  end
+end

data/tests/digitalocean/requests/compute_v2/list_ssh_keys_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute::DigitalOceanV2 | list_ssh_keys request', ['digitalocean', 'compute']) do
+  service = Fog::Compute.new(:provider => 'DigitalOcean', :version => 'V2')
+
+  ssh_key_format = {
+    'id' => Integer,
+    'fingerprint' => String,
+    'public_key' => String,
+    'name' => String,
+  }
+
+  tests('success') do
+    tests('#list_ssh_keys') do
+      service.list_ssh_keys.body['ssh_keys'].each do |ssh_key|
+        tests('format').data_matches_schema(ssh_key_format) do
+          ssh_key
+        end
+      end
+    end
+  end
+end

data/tests/helper.rb

@@ -0,0 +1,25 @@
+require 'coveralls'
+Coveralls.wear!
+
+require File.expand_path('../../lib/fog/digitalocean', __FILE__)
+
+Bundler.require(:test)
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'format_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+unless Fog.mocking?
+  Fog.timeout = ENV['FOG_TEST_TIMEOUT'] || 2_000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+end
+
+def lorem_file
+  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+end
+
+def array_differences(array_a, array_b)
+  (array_a - array_b) | (array_b - array_a)
+end

data/tests/helpers/format_helper.rb

@@ -0,0 +1,100 @@
+### Taken from https://github.com/fog/fog/blob/master/tests/helpers/formats_helper.rb
+
+require "fog/schema/data_validator"
+
+# 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
+    # Generates a Shindo test that compares a hash schema to the result
+    # of the passed in block returning true if they match.
+    #
+    # The schema that is passed in is a Hash or Array of hashes that
+    # have Classes in place of values. When checking the schema the
+    # value should match the Class.
+    #
+    # Strict mode will fail if the data has additional keys. Setting
+    # +strict+ to +false+ will allow additional keys to appear.
+    #
+    # @param [Hash] schema A Hash schema
+    # @param [Hash] options Options to change validation rules
+    # @option options [Boolean] :allow_extra_keys
+    #     If +true+ does not fail when keys are in the data that are
+    #     not specified in the schema. This allows new values to
+    #     appear in API output without breaking the check.
+    # @option options [Boolean] :allow_optional_rules
+    #     If +true+ does not fail if extra keys are in the schema
+    #     that do not match the data. Not recommended!
+    # @yield Data to check with schema
+    #
+    # @example Using in a test
+    #     Shindo.tests("comparing welcome data against schema") do
+    #       data = {:welcome => "Hello" }
+    #       data_matches_schema(:welcome => String) { data }
+    #     end
+    #
+    #     comparing welcome data against schema
+    #     + data matches schema
+    #
+    # @example Example schema
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         {
+    #           "size" => Float
+    #         }
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    # @return [Boolean]
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+        else
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end