fog-digitalocean 0.1.0

data/lib/fog/digitalocean/requests/compute/shutdown.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Real
+        def shutdown(id)
+          body = { :type => "shutdown" }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def shutdown(id)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "shutdown",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute/snapshot.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Real
+        def snapshot(id, name)
+          body = { :type => "snapshot", :name => name }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def snapshot(id, name)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "snapshot",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute/transfer_image.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Real
+        def transfer_image(id, region)
+          body = { :type => 'transfer', :region => region }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/images/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def transfer_image(id, name)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id' => 36805527,
+              'status' => 'in-progress',
+              'type' => 'transfer',
+              'started_at' => '2014-11-14T16:42:45Z',
+              'completed_at' => null,
+              'resource_id' => 7938269,
+              'resource_type' => 'image',
+              'region' => 'nyc3',
+              'region_slug' => 'nyc3'
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute/update_ssh_key.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      # noinspection RubyStringKeysInHashInspection
+      class Real
+
+        def update_ssh_key(key_id, name)
+          update_options = {
+            :name       => name,
+          }
+
+          encoded_body = Fog::JSON.encode(update_options)
+
+          request(
+            :expects => [200],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'PUT',
+            :path    => "/v2/account/keys/#{key_id}",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      # noinspection RubyStringKeysInHashInspection
+      class Mock
+        def update_ssh_key(key_id, name)
+          response        = Excon::Response.new
+          response.status = 200
+
+          response.body ={
+            'ssh_key' => {
+              'id'          => 512190,
+              'fingerprint' => "3b:16:bf:e4:8b:00:8b:b8:59:8c:a9:d3:f0:19:45:fa",
+              'public_key'  => "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAQQDDHr/jh2Jy4yALcK4JyWbVkPRaWmhck3IgCoeOO3z1e2dBowLh64QAM+Qb72pxekALga2oi4GvT+TlWNhzPH4V example",
+              'name'        => "My SSH Public Key"
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute/upgrade.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Real
+        def upgrade(id)
+          body = { :type => "upgrade" }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def upgrade(id)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "upgrade",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/service.rb

@@ -0,0 +1,51 @@
+module Fog
+  module DigitalOcean
+    class Service
+
+      def request(params, parse_json = true)
+        first_attempt = true
+        begin
+          response = @connection.request(request_params(params))
+        rescue Excon::Errors::Unauthorized => error
+          raise error unless first_attempt
+          first_attempt = false
+          authenticate
+          retry
+        end
+
+        process_response(response) if parse_json
+        response
+      end
+
+      private
+
+      def process_response(response)
+        if response &&
+          response.body &&
+          response.body.is_a?(String) &&
+          !response.body.strip.empty?
+          begin
+            response.body = Fog::JSON.decode(response.body)
+          rescue Fog::JSON::DecodeError => e
+            Fog::Logger.warning("Error Parsing response json - #{e}")
+            response.body = {}
+          end
+        end
+      end
+
+      def headers(options={})
+        {'Content-Type' => 'application/json',
+         'Accept'       => 'application/json',
+        }.merge(options[:headers] || {})
+      end
+
+      def request_params(params)
+        params.merge({
+                       :headers => headers(params),
+                       :path    => "#{params[:path]}"
+                     })
+      end
+
+    end
+  end
+end

data/lib/fog/digitalocean/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Digitalocean
+    VERSION = "0.1.0"
+  end
+end

data/spec/fog/account_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Fog::Account do
+  Fog::Account.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::Account[provider] }
+        end
+      end
+    end
+  end
+end

data/spec/fog/billing_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Fog::Billing do
+  Fog::Billing.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::Billing[provider] }
+        end
+      end
+    end
+  end
+end

data/spec/fog/bin/atmos_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "fog/bin"
+require "helpers/bin"
+
+describe Atmos do
+  include Fog::BinSpec
+
+  let(:subject) { Atmos }
+
+  describe "#services" do
+    it "includes all services" do
+      assert_includes Atmos.services, :storage
+    end
+  end
+
+  describe "#class_for" do
+    describe "when requesting storage service" do
+      it "returns correct class" do
+        assert_equal Fog::Storage::Atmos, Atmos.class_for(:storage)
+      end
+    end
+  end
+
+  describe "#[]" do
+    describe "when requesting storage service" do
+      it "returns instance" do
+        Fog::Storage::Atmos.stub(:new, "instance") do
+          assert_equal "instance", Atmos[:storage]
+        end
+      end
+    end
+  end
+end

data/spec/fog/bin/aws_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+require "fog/bin"
+require "helpers/bin"
+
+describe AWS do
+  include Fog::BinSpec
+
+  let(:subject) { AWS }
+
+  KEY_CLASS_MAPPING = {
+    :auto_scaling => Fog::AWS::AutoScaling,
+    :beanstalk => Fog::AWS::ElasticBeanstalk,
+    :cdn => Fog::CDN::AWS,
+    :cloud_formation => Fog::AWS::CloudFormation,
+    :cloud_watch => Fog::AWS::CloudWatch,
+    :compute => Fog::Compute::AWS,
+    :data_pipeline => Fog::AWS::DataPipeline,
+    :ddb => Fog::AWS::DynamoDB,
+    :dynamodb => Fog::AWS::DynamoDB,
+    :dns => Fog::DNS::AWS,
+    :elasticache => Fog::AWS::Elasticache,
+    :elb => Fog::AWS::ELB,
+    :emr => Fog::AWS::EMR,
+    :glacier => Fog::AWS::Glacier,
+    :iam => Fog::AWS::IAM,
+    :redshift => Fog::AWS::Redshift,
+    :sdb => Fog::AWS::SimpleDB,
+    :simpledb => Fog::AWS::SimpleDB,
+    :ses => Fog::AWS::SES,
+    :sqs => Fog::AWS::SQS,
+    :eu_storage => Fog::Storage::AWS,
+    :storage => Fog::Storage::AWS,
+    :rds => Fog::AWS::RDS,
+    :sns => Fog::AWS::SNS,
+    :sts => Fog::AWS::STS
+  }
+
+  describe "#services" do
+    it "includes all services" do
+      assert_includes AWS.services, :auto_scaling
+      assert_includes AWS.services, :beanstalk
+      assert_includes AWS.services, :cdn
+      assert_includes AWS.services, :cloud_formation
+      assert_includes AWS.services, :cloud_watch
+      assert_includes AWS.services, :compute
+      assert_includes AWS.services, :data_pipeline
+      assert_includes AWS.services, :dynamodb
+      assert_includes AWS.services, :dns
+      assert_includes AWS.services, :elasticache
+      assert_includes AWS.services, :elb
+      assert_includes AWS.services, :emr
+      assert_includes AWS.services, :glacier
+      assert_includes AWS.services, :iam
+      assert_includes AWS.services, :redshift
+      assert_includes AWS.services, :rds
+      assert_includes AWS.services, :simpledb
+      assert_includes AWS.services, :ses
+      assert_includes AWS.services, :sqs
+      assert_includes AWS.services, :storage
+      assert_includes AWS.services, :sns
+      assert_includes AWS.services, :sts
+    end
+  end
+
+  describe "#class_for" do
+    describe "when key exists" do
+      it "maps to correct class" do
+        KEY_CLASS_MAPPING.each do |key, klass|
+          assert_equal klass, AWS.class_for(key)
+        end
+      end
+    end
+
+    describe "when key does not exist" do
+      it "raises ArgumentError" do
+        assert_raises(ArgumentError) { AWS.class_for(:bad_key) }
+      end
+    end
+  end
+
+  describe "#[]" do
+    describe "when service is recognised" do
+      it "returns correct instance" do
+        KEY_CLASS_MAPPING.each do |key, klass|
+          klass.stub(:new, "#{klass} instance") do
+            assert_equal "#{klass} instance", AWS[key]
+          end
+        end
+      end
+    end
+
+    describe "when service is not recognised" do
+      it "raises ArgumentError" do
+        assert_raises(ArgumentError) { AWS[:bad_service] }
+      end
+    end
+  end
+end