droplet_kit 2.8.0 → 2.9.0

data/spec/fixtures/volumes/create.json

@@ -1,34 +0,0 @@
-{
-  "volume": {
-    "id": "7724db7c-e098-11e5-b522-000f53304e51",
-    "region": {
-      "name": "New York 1",
-      "slug": "nyc1",
-      "sizes": [
-        "512mb",
-        "1gb",
-        "2gb",
-        "4gb",
-        "8gb",
-        "16gb",
-        "32gb",
-        "48gb",
-        "64gb"
-      ],
-      "features": [
-        "private_networking",
-        "backups",
-        "ipv6",
-        "metadata"
-      ],
-      "available": true
-    },
-    "droplet_ids": [
-
-    ],
-    "name": "Example",
-    "description": "Block store for examples",
-    "size_gigabytes": 10,
-    "created_at": "2016-03-02T17:00:49Z"
-  }
-}

data/spec/fixtures/volumes/create_snapshot.json

@@ -1,14 +0,0 @@
-{
-  "snapshot": {
-    "id": "7724db7c-e098-11e5-b522-000f53304e51",
-    "name": "Ubuntu Foo",
-    "regions": [
-      "nyc1"
-    ],
-    "created_at": "2014-07-29T14:35:40Z",
-    "resource_type": "volume",
-    "resource_id": "7724db7c-e098-11e5-b522-000f53304e51",
-    "min_disk_size": 10,
-    "size_gigabytes": 0.4
-  }
-}

data/spec/fixtures/volumes/find.json

@@ -1,34 +0,0 @@
-{
-  "volume": {
-    "id": "7724db7c-e098-11e5-b522-000f53304e51",
-    "region": {
-      "name": "New York 1",
-      "slug": "nyc1",
-      "sizes": [
-        "512mb",
-        "1gb",
-        "2gb",
-        "4gb",
-        "8gb",
-        "16gb",
-        "32gb",
-        "48gb",
-        "64gb"
-      ],
-      "features": [
-        "private_networking",
-        "backups",
-        "ipv6",
-        "metadata"
-      ],
-      "available": true
-    },
-    "droplet_ids": [
-
-    ],
-    "name": "Example",
-    "description": "Block store for examples",
-    "size_gigabytes": 10,
-    "created_at": "2016-03-02T17:00:49Z"
-  }
-}

data/spec/lib/droplet_kit/client_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::Client do
-  subject(:client) { DropletKit::Client.new(access_token: 'bunk') }
-
-  describe '#initialize' do
-    it 'initializes with an access token' do
-      client = DropletKit::Client.new(access_token: 'my-token')
-      expect(client.access_token).to eq('my-token')
-    end
-
-    it 'allows string option keys for the client' do
-      client = DropletKit::Client.new('access_token' => 'my-token')
-      expect(client.access_token).to eq('my-token')
-    end
-
-    it 'has default open_timeout for faraday' do
-      client = DropletKit::Client.new('access_token' => 'my-token')
-      expect(client.open_timeout).to eq(DropletKit::Client::DEFAULT_OPEN_TIMEOUT)
-    end
-
-    it 'allows open_timeout to be set' do
-      open_timeout = 10
-      client = DropletKit::Client.new(
-        'access_token' => 'my-token',
-        'open_timeout' => open_timeout
-      )
-
-      expect(client.open_timeout).to eq(open_timeout)
-    end
-
-    it 'has default timeout' do
-      client = DropletKit::Client.new('access_token' => 'my-token')
-      expect(client.timeout).to eq(DropletKit::Client::DEFAULT_TIMEOUT)
-    end
-
-    it 'allows timeout to be set' do
-      timeout = 10
-      client = DropletKit::Client.new(
-        'access_token' => 'my-token',
-        'timeout' => timeout
-      )
-
-      expect(client.timeout).to eq(timeout)
-    end
-  end
-
-  describe "#method_missing" do
-    context "called with an existing method" do
-      it { expect{ client.actions}.to_not raise_error }
-    end
-
-    context "called with a missing method" do
-      it { expect{client.this_is_wrong}.to raise_error(NoMethodError) }
-    end
-  end
-
-  describe '#connection' do
-    module AcmeApp
-      class CustomLogger < Faraday::Middleware
-      end
-    end
-
-    it 'populates the authorization header correctly' do
-      expect(client.connection.headers['Authorization']).to eq("Bearer #{client.access_token}")
-    end
-
-    it 'sets the content type' do
-      expect(client.connection.headers['Content-Type']).to eq("application/json")
-    end
-
-    context 'with default user agent' do
-      it 'contains the version of DropletKit and Faraday' do
-        stub_const('DropletKit::VERSION', '1.2.3')
-        stub_const('Faraday::VERSION', '1.2.3')
-        expect(client.connection.headers['User-Agent']).to eq('DropletKit/1.2.3 Faraday/1.2.3')
-      end
-    end
-
-    context 'with user provided user agent' do
-      it 'includes their agent string as well' do
-        client = DropletKit::Client.new(access_token: 'bunk', user_agent: 'tugboat')
-        expect(client.connection.headers['User-Agent']).to include('tugboat')
-      end
-    end
-
-    it 'allows access to faraday instance' do
-      client.connection.use AcmeApp::CustomLogger
-      expect(client.connection.builder.handlers).to include(AcmeApp::CustomLogger)
-    end
-
-    it 'has open_timeout set' do
-      expect(client.connection.options.open_timeout).to eq(DropletKit::Client::DEFAULT_OPEN_TIMEOUT)
-    end
-
-    it 'has timeout set' do
-      expect(client.connection.options.timeout).to eq(DropletKit::Client::DEFAULT_TIMEOUT)
-    end
-  end
-
-end
-

data/spec/lib/droplet_kit/models/base_model_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::BaseModel do
-  subject(:resource) do
-    Class.new(DropletKit::BaseModel) do |base|
-      attribute :droplet_limit
-      def self.name
-        'SomeModel'
-      end
-    end
-  end
-
-  describe '#inspect' do
-    it 'returns the information about the current user' do
-      instance = resource.new(droplet_limit: 5)
-      expect(instance.inspect).to include("<SomeModel")
-      expect(instance.inspect).to include("@droplet_limit=>5")
-      expect(instance.inspect).to include("<SomeModel {:@droplet_limit=>5}>")
-    end
-  end
-end

data/spec/lib/droplet_kit/models/droplet_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::Droplet do
-  let(:droplet_fixture) { api_fixture('droplets/find') }
-  let(:droplet) { DropletKit::DropletMapping.extract_single(droplet_fixture, :read) }
-
-  describe '#public_ip' do
-    it 'returns the public IP for ipv4' do
-      expect(droplet.public_ip).to eq('127.0.0.19')
-    end
-
-    context 'when the droplet does not have an IP yet' do
-      it 'returns nil' do
-        droplet.networks.v4.clear
-        expect(droplet.public_ip).to be_nil
-      end
-    end
-  end
-
-  describe '#private_ip' do
-    it 'returns the public IP for ipv4' do
-      expect(droplet.private_ip).to eq('10.0.0.19')
-    end
-
-    context 'when the droplet does not have private networking enabled' do
-      it 'returns nil' do
-        droplet.networks.v4.clear
-        expect(droplet.private_ip).to be_nil
-      end
-    end
-  end
-end

data/spec/lib/droplet_kit/paginated_resource_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-RequestCounter = Struct.new(:count)
-
-RSpec.describe DropletKit::PaginatedResource do
-  let(:resource) { ResourceKit::Resource.new(connection: connection) }
-  let(:request_count) { RequestCounter.new(0) }
-
-  let(:connection) { Faraday.new {|b| b.adapter :test, stubs } }
-  let(:response_size) { 40 }
-  let(:stubs) { stub_pager_request(response_size) }
-  let(:action) { ResourceKit::Action.new(:find, :get, '/droplets') }
-
-  before do
-    action.query_keys :per_page, :page
-    action.handler(200) { |r| JSON.load(r.body)['objects'] }
-  end
-
-  describe '#initialize' do
-    it 'initializes with a action and resource' do
-      instance = DropletKit::PaginatedResource.new(action, resource)
-      expect(instance.action).to be(action)
-      expect(instance.resource).to be(resource)
-    end
-  end
-
-  describe "#total_pages" do
-    let(:instance) { DropletKit::PaginatedResource.new(action, resource) }
-    it "returns nil if no request made" do
-      expect(instance.total_pages).to be_nil
-    end
-
-    it "returns correct page count after request made" do
-      instance.take(20)
-      expect(instance.total_pages).to eq(2)
-    end
-
-    context "when results are empty" do
-      let(:stubs) { stub_pager_request(0) }
-      it "returns 0" do
-        instance.take(1)
-        expect(instance.total_pages).to eq(0)
-      end
-    end
-  end
-
-  describe '#[]' do
-    subject(:paginated) { DropletKit::PaginatedResource.new(action, resource) }
-
-    it 'returns the nth element in the collection' do
-      paginated.each_with_index do |elem, i|
-        expect(paginated[i]).to eq(elem)
-      end
-    end
-  end
-
-  describe '#each' do
-    subject(:paginated) { DropletKit::PaginatedResource.new(action, resource) }
-
-    it 'iterates over every object returned from the API' do
-      total = 0
-      paginated.each do |object|
-        total += 1
-      end
-
-      expect(total).to eq(40)
-    end
-
-    it 'called the API twice' do
-      expect {|b| paginated.each {|c| c } }.to change { request_count.count }.to(2).from(0)
-    end
-
-    it 'returns the correct objects' do
-      expect(paginated.first(3)).to eq([0,1,2])
-    end
-
-    context 'for changing size' do
-      subject(:paginated) { DropletKit::PaginatedResource.new(action, resource, per_page: 40) }
-
-      it 'only calls the API once' do
-        expect {|b| paginated.each {|c| c } }.to change { request_count.count }.to(1).from(0)
-      end
-    end
-  end
-end

data/spec/lib/droplet_kit/resources/account_resource_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::AccountResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  describe '#info' do
-    it 'returns the information about the current user' do
-      fixture = api_fixture('account/info')
-      parsed  = JSON.load(fixture)
-
-      stub_do_api('/v2/account').to_return(body: fixture)
-      account_info = resource.info
-
-      expect(account_info).to be_kind_of(DropletKit::Account)
-
-      expect(account_info.droplet_limit).to eq(parsed['account']['droplet_limit'])
-      expect(account_info.floating_ip_limit).to eq(parsed['account']['floating_ip_limit'])
-      expect(account_info.email).to eq(parsed['account']['email'])
-      expect(account_info.uuid).to eq(parsed['account']['uuid'])
-      expect(account_info.email_verified).to eq(parsed['account']['email_verified'])
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/account' }
-      let(:method) { :get }
-      let(:action) { :info }
-    end
-  end
-end

data/spec/lib/droplet_kit/resources/action_resource_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::ActionResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  describe '#all' do
-    it 'returns all actions' do
-      response = api_fixture('actions/all')
-      stub_do_api('/v2/actions', :get).to_return(body: response)
-      expected_actions = DropletKit::ActionMapping.extract_collection(response, :read)
-
-      expect(resource.all).to eq(expected_actions)
-    end
-
-    it 'returns a list of correctly mapped actions' do
-      response = api_fixture('actions/all')
-      stub_do_api('/v2/actions', :get).to_return(body: response)
-      actions = resource.all
-
-      expect(actions.first).to be_kind_of(DropletKit::Action)
-      expect(actions.first.id).to eq(1)
-      expect(actions.first.status).to eq("in-progress")
-      expect(actions.first.type).to eq("test")
-      expect(actions.first.started_at).to eq("2014-07-29T14:35:26Z")
-      expect(actions.first.completed_at).to eq(nil)
-      expect(actions.first.resource_id).to eq(nil)
-      expect(actions.first.resource_type).to eq("backend")
-
-      expect(actions.first.region).to be_kind_of(DropletKit::Region)
-      expect(actions.first.region.slug).to eq('nyc1')
-      expect(actions.first.region.name).to eq('New York')
-      expect(actions.first.region.sizes).to include('512mb')
-      expect(actions.first.region.available).to be(true)
-      expect(actions.first.region.features).to include("virtio", "private_networking", "backups", "ipv6", "metadata")
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { 'actions/all' }
-      let(:api_path) { '/v2/actions' }
-    end
-  end
-
-  describe '#find' do
-    it 'returns an action' do
-      response = api_fixture('actions/find')
-      stub_do_api('/v2/actions/123', :get).to_return(body: response)
-      expected_action = DropletKit::ActionMapping.extract_single(response, :read)
-
-      expect(resource.find(id: 123)).to eq(expected_action)
-    end
-
-    it 'returns a correctly mapped action' do
-      response = api_fixture('actions/find')
-      stub_do_api('/v2/actions/123', :get).to_return(body: response)
-      action = resource.find(id: 123)
-
-      expect(action).to be_kind_of(DropletKit::Action)
-      expect(action.id).to eq(2)
-      expect(action.status).to eq("in-progress")
-      expect(action.type).to eq("test")
-      expect(action.started_at).to eq("2014-07-29T14:35:27Z")
-      expect(action.completed_at).to eq(nil)
-      expect(action.resource_id).to eq(nil)
-      expect(action.resource_type).to eq("backend")
-      expect(action.region_slug).to eq("nyc1")
-
-      expect(action.region).to be_kind_of(DropletKit::Region)
-      expect(action.region.slug).to eq('nyc1')
-      expect(action.region.name).to eq('New York')
-      expect(action.region.sizes).to include('512mb')
-      expect(action.region.available).to be(true)
-      expect(action.region.features).to include("virtio", "private_networking", "backups", "ipv6", "metadata")
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/actions/123' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { id: 123 } }
-    end
-  end
-end

data/spec/lib/droplet_kit/resources/cdn_resource_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::CDNResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  let(:id) { '7724db7c-e098-11e5-b522-000f53304e51' }
-  let(:origin) { 'my-space-cdn.nyc3.digitaloceanspaces.com' }
-  let(:endpoint) { 'my-space-cdn.nyc3.cdn.digitaloceanspaces.com' }
-  let(:ttl) { 3600 }
-  let(:created_at) { '2016-03-02T17:00:49Z' }
-
-  let(:path) { '/v2/cdn/endpoints' }
-  let(:path_with_id) { "#{path}/#{id}" }
-
-  RSpec::Matchers.define :match_cdn_fixture do
-    match do |cdn|
-      expect(cdn).to be_kind_of(DropletKit::CDN)
-
-      expect(cdn.id).to eq(id)
-      expect(cdn.origin).to eq(origin)
-      expect(cdn.endpoint).to eq(endpoint)
-      expect(cdn.ttl).to eq(ttl)
-      expect(cdn.created_at).to eq(created_at)
-    end
-  end
-
-  describe '#all' do
-    it 'returns all of the cdns' do
-      stub_do_api(path, :get).to_return(body: api_fixture('cdns/all'))
-      cdns = resource.all
-
-      expect(cdns).to all(be_kind_of(DropletKit::CDN))
-      expect(cdns.first).to match_cdn_fixture
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { 'cdns/all' }
-      let(:api_path) { '/v2/cdn/endpoints' }
-    end
-  end
-
-  describe '#find' do
-    it 'returns a singular cdn' do
-      stub_do_api(path_with_id, :get).to_return(body: api_fixture('cdns/find'))
-      cdn = resource.find(id: id)
-
-      expect(cdn).to match_cdn_fixture
-    end
-  end
-
-  describe '#create' do
-    it 'returns the created cdn' do
-      cdn = DropletKit::CDN.new(
-        origin: origin,
-        ttl: ttl
-      )
-
-      as_string = DropletKit::CDNMapping.representation_for(:create, cdn)
-      stub_do_api(path, :post).with(body: as_string).to_return(body: api_fixture('cdns/create'), status: 201)
-      created_cdn = resource.create(cdn)
-
-      expect(created_cdn).to match_cdn_fixture
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::CDN.new }
-    end
-  end
-
-  describe '#update_ttl' do
-    let(:exception) { DropletKit::FailedUpdate }
-
-    it 'returns the updated cdn' do
-      as_string = { ttl: 60 }.to_json
-      stub_do_api(path_with_id, :put).with(body: as_string).to_return(body: api_fixture('cdns/update_ttl'))
-      updated_cdn = resource.update_ttl(id: id, ttl: 60)
-
-      expect(updated_cdn).to be_kind_of(DropletKit::CDN)
-
-      expect(updated_cdn.id).to eq(id)
-      expect(updated_cdn.ttl).to eq(60)
-    end
-
-    it "fails if ttl is invalid" do
-      as_string = { ttl: 0 }.to_json
-      response_body = { id: :unprocessable_entity, message: 'invalid ttl' }
-      stub_do_api(path_with_id, :put).with(body: as_string).to_return(body: response_body.to_json, status: 422)
-
-      expect { resource.update_ttl(id: id, ttl: 0) }.to raise_exception(exception).with_message(response_body[:message])
-    end
-  end
-
-  describe '#flush_cache' do
-    let(:cache_path) { "/v2/cdn/endpoints/#{id}/cache" }
-    let(:exception) { DropletKit::FailedUpdate }
-
-    it 'sends a delete request to cdn cache' do
-      as_string = { files: ["*"] }.to_json
-      request = stub_do_api(cache_path, :delete).with(body: as_string)
-      resource.flush_cache(id: id, files: ["*"])
-
-      expect(request).to have_been_made
-    end
-
-    it "fails if files are not passed in" do
-      as_string = { files: [] }.to_json
-      response_body = { id: :unprocessable_entity, message: 'invalid request body' }
-      stub_do_api(cache_path, :delete).with(body: as_string).to_return(body: response_body.to_json, status: 422)
-
-      expect { resource.flush_cache(id: id, files: []) }.to raise_exception(exception).with_message(response_body[:message])
-    end
-  end
-
-  describe '#delete' do
-    it 'sends a delete request for the cdn' do
-      request = stub_do_api(path_with_id, :delete)
-      resource.delete(id: id)
-
-      expect(request).to have_been_made
-    end
-  end
-end