droplet_kit 1.0.0

data/spec/lib/droplet_kit/paginated_resource_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'addressable/uri'
+
+RequestCounter = Struct.new(:count)
+
+RSpec.describe DropletKit::PaginatedResource do
+  let(:request_count) { RequestCounter.new(0) }
+
+  let(:connection) { Faraday.new {|b| b.adapter :test, stubs } }
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/droplets') do |env|
+        request_count.count += 1
+        uri = Addressable::URI.parse(env[:url].to_s)
+        page = (uri.query_values['page'] || 1).to_i
+        per_page = (uri.query_values['per_page'] || 20).to_i
+        range = (0...per_page).map do |num|
+          num + ((page - 1) * per_page)
+        end
+
+        [200, {}, { objects: range, meta: { total: 40 } }.to_json ]
+      end
+    end
+  end
+  let(:action) { ResourceKit::Action.new(:find, :get, '/droplets') }
+  let(:action_connection) { ResourceKit::ActionConnection.new(action, connection) }
+
+  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 connection struct' do
+      instance = DropletKit::PaginatedResource.new(action_connection)
+      expect(instance.action).to be(action)
+      expect(instance.connection).to be(connection)
+    end
+  end
+
+  describe '#each' do
+    subject(:paginated) { DropletKit::PaginatedResource.new(action_connection) }
+
+    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_connection, 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/action_resource_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe DropletKit::ActionResource do
+  subject(:resource) { described_class.new(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
+  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
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+RSpec.describe DropletKit::DomainRecordResource do
+  subject(:resource) { described_class.new(connection) }
+  include_context 'resources'
+
+  describe '#all' do
+    it 'returns all of the domain records for a domain' do
+      response = api_fixture('domain_records/all')
+      stub_do_api('/v2/domains/example.com/records', :get).to_return(body: response)
+
+      expected_records = DropletKit::DomainRecordMapping.extract_collection(response, :read)
+      returned_records = resource.all(for_domain: 'example.com')
+
+      expect(returned_records).to all(be_kind_of(DropletKit::DomainRecord))
+      expect(returned_records).to eq(expected_records)
+    end
+  end
+
+  describe '#create' do
+    it 'creates a domain record' do
+      response = api_fixture('domain_records/create')
+
+      domain_record = DropletKit::DomainRecord.new(
+        type: 'CNAME',
+        name: 'www',
+        data: '@'
+      )
+      as_hash = DropletKit::DomainRecordMapping.representation_for(:create, domain_record, NullHashLoad)
+      expect(as_hash[:type]).to eq('CNAME')
+      expect(as_hash[:name]).to eq('www')
+      expect(as_hash[:data]).to eq('@')
+
+      as_json = DropletKit::DomainRecordMapping.representation_for(:create, domain_record)
+      stub_do_api('/v2/domains/example.com/records', :post).with(body: as_json).to_return(body: response, status: 201)
+
+      created_domain_record = resource.create(domain_record, for_domain: 'example.com')
+      expect(created_domain_record.id).to eq(16)
+      expect(created_domain_record.name).to eq('www')
+      expect(created_domain_record.type).to eq('CNAME')
+      expect(created_domain_record.data).to eq('@')
+    end
+  end
+
+  describe '#find' do
+    it 'returns a domain record' do
+      response = api_fixture('domain_records/find')
+      stub_do_api('/v2/domains/example.com/records/12', :get).to_return(body: response)
+
+      expected_record = DropletKit::DomainRecordMapping.extract_single(response, :read)
+      expect(resource.find(id: 12, for_domain: 'example.com')).to eq(expected_record)
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes the domain record for an id and domain name' do
+      request = stub_do_api('/v2/domains/example.com/records/12', :delete)
+      resource.delete(for_domain: 'example.com', id: 12)
+
+      expect(request).to have_been_made
+    end
+  end
+
+  describe '#update' do
+    it 'updates a record' do
+      response = api_fixture('domain_records/update')
+
+      domain_record = DropletKit::DomainRecord.new(name: 'lol')
+      as_hash = DropletKit::DomainRecordMapping.representation_for(:update, domain_record, NullHashLoad)
+      expect(as_hash[:name]).to eq('lol')
+
+      as_json = DropletKit::DomainRecordMapping.representation_for(:update, domain_record)
+      request = stub_do_api('/v2/domains/example.com/records/1066', :put).with(body: as_json).to_return(body: response, status: 200)
+      updated_domain_record = resource.update(domain_record, for_domain: 'example.com', id: 1066)
+
+      expect(request).to have_been_made
+      expect(updated_domain_record.id).to eq(1066)
+      expect(updated_domain_record.name).to eq('lol')
+      expect(updated_domain_record.type).to eq('CNAME')
+      expect(updated_domain_record.data).to eq('@')
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe DropletKit::DomainResource do
+  subject(:resource) { described_class.new(connection) }
+  include_context 'resources'
+
+  describe '#all' do
+    it 'returns all of the domains' do
+      response = api_fixture('domains/all')
+      stub_do_api('/v2/domains', :get).to_return(body: response)
+      expected_domains = DropletKit::DomainMapping.extract_collection(response, :read)
+
+      expect(resource.all).to eq(expected_domains)
+    end
+  end
+
+  describe '#create' do
+    it 'send a POST request to create a domain' do
+      response = api_fixture('domains/create')
+
+      domain = DropletKit::Domain.new(ip_address: '1.1.1.1', name: 'example.com')
+      as_hash = DropletKit::DomainMapping.representation_for(:create, domain, NullHashLoad)
+      expect(as_hash[:ip_address]).to eq('1.1.1.1')
+      expect(as_hash[:name]).to eq('example.com')
+
+      as_json = DropletKit::DomainMapping.representation_for(:create, domain)
+      stub_do_api('/v2/domains', :post).with(body: as_json).to_return(body: response, status: 201)
+
+      created_domain = resource.create(domain)
+      expect(created_domain.name).to eq('example.com')
+      expect(created_domain.ttl).to eq(1800)
+      expect(created_domain.zone_file).to eq(nil)
+    end
+  end
+
+  describe '#find' do
+    it 'returns a single domain' do
+      response = api_fixture('domains/find')
+      stub_do_api('/v2/domains/example.com', :get).to_return(body: response)
+      expected_domain = DropletKit::DomainMapping.extract_single(response, :read)
+
+      expect(resource.find(name: 'example.com')).to eq(expected_domain)
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes a single domain' do
+      request = stub_do_api('/v2/domains/example.com', :delete)
+      resource.delete(name: 'example.com')
+      expect(request).to have_been_made
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+RSpec.describe DropletKit::DropletActionResource do
+  subject(:resource) { described_class.new(connection) }
+  let(:droplet_id) { 1066 }
+  def json
+    {
+      "action" => {
+        "id" => 2,
+        "status" => "in-progress",
+        "type" => action,
+        "started_at" => "2014-07-29T14:35:27Z",
+        "completed_at" => nil,
+        "resource_id" => 12,
+        "resource_type" => "droplet",
+        "region" => "nyc1"
+      }
+    }.to_json
+  end
+
+  include_context 'resources'
+
+  ACTIONS_WITHOUT_INPUT = %w(reboot power_cycle shutdown power_off
+    power_on password_reset enable_ipv6 disable_backups enable_private_networking)
+
+  ACTIONS_WITHOUT_INPUT.each do |action_name|
+    describe "Action #{action_name}" do
+      let(:action) { action_name }
+
+      it 'performs the action' do
+        request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+          body: { type: action_name }.to_json
+        ).to_return(body: json, status: 201)
+
+        returned_action = resource.send(action_name, droplet_id: droplet_id)
+
+        expect(request).to have_been_made
+        expect(returned_action.type).to eq(action_name)
+      end
+    end
+  end
+
+  describe "Action snapshot" do
+    let(:action) { 'snapshot' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, name: 'Dwight' }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, name: 'Dwight')
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe "Action kernel" do
+    let(:action) { 'kernel' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, kernel: 1556 }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, kernel: 1556)
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe "Action rename" do
+    let(:action) { 'rename' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, name: 'newname.com' }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, name: 'newname.com')
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe "Action rebuild" do
+    let(:action) { 'rebuild' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, image: 'ubuntu-14-04-x86' }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, image: 'ubuntu-14-04-x86')
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe "Action restore" do
+    let(:action) { 'restore' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, image: 'ubuntu-14-04-x86' }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, image: 'ubuntu-14-04-x86')
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe "Action resize" do
+    let(:action) { 'resize' }
+
+    it 'performs the action' do
+      request = stub_do_api("/v2/droplets/#{droplet_id}/actions", :post).with(
+        body: { type: action, size: '1gb' }.to_json
+      ).to_return(body: json, status: 201)
+
+      returned_action = resource.send(action, droplet_id: droplet_id, size: '1gb')
+
+      expect(request).to have_been_made
+      expect(returned_action.type).to eq(action)
+    end
+  end
+
+  describe '#find' do
+    it 'returns an action' do
+      request = stub_do_api("/v2/droplets/1066/actions/123", :get).to_return(
+        body: api_fixture('actions/find')
+      )
+
+      returned_action = resource.find(droplet_id: 1066, id: 123)
+      expect(request).to have_been_made
+
+      expect(returned_action.type).to eq('test')
+      expect(returned_action.started_at).to eq("2014-07-29T14:35:27Z")
+      expect(returned_action.completed_at).to eq(nil)
+      expect(returned_action.resource_id).to eq(nil)
+      expect(returned_action.resource_type).to eq("backend")
+      expect(returned_action.region).to eq("nyc1")
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+RSpec.describe DropletKit::DropletResource do
+  subject(:resource) { described_class.new(connection) }
+  include_context 'resources'
+
+  # Theres a lot to check
+  def check_droplet(droplet)
+    expect(droplet.id).to eq(19)
+    expect(droplet.name).to eq('test.example.com')
+    expect(droplet.memory).to eq(1024)
+    expect(droplet.vcpus).to eq(2)
+    expect(droplet.disk).to eq(20)
+    expect(droplet.locked).to eq(false)
+    expect(droplet.status).to eq('active')
+    expect(droplet.created_at).to be_present
+    expect(droplet.backup_ids).to include(449676382)
+    expect(droplet.snapshot_ids).to include(449676383)
+    expect(droplet.action_ids).to be_empty
+    expect(droplet.features).to include('ipv6')
+
+    expect(droplet.region).to be_kind_of(DropletKit::Region)
+    expect(droplet.region.slug).to eq('nyc1')
+    expect(droplet.region.name).to eq('New York')
+    expect(droplet.region.sizes).to include('1024mb', '512mb')
+    expect(droplet.region.available).to be(true)
+    expect(droplet.region.features).to include("virtio", "private_networking", "backups", "ipv6")
+
+    expect(droplet.image).to be_kind_of(DropletKit::Image)
+    expect(droplet.image.id).to eq(119192817)
+    expect(droplet.image.name).to eq("Ubuntu 13.04")
+    expect(droplet.image.distribution).to eq("ubuntu")
+    expect(droplet.image.slug).to eq("ubuntu1304")
+    expect(droplet.image.public).to eq(true)
+    expect(droplet.image.regions).to include('nyc1')
+
+    expect(droplet.size).to be_kind_of(DropletKit::Size)
+    expect(droplet.size.slug).to eq("1024mb")
+    expect(droplet.size.transfer).to eq(2)
+    expect(droplet.size.price_monthly).to eq(10.0)
+    expect(droplet.size.price_hourly).to eq(0.01488)
+
+    expect(droplet.networks).to be_kind_of(DropletKit::NetworkHash)
+    v4_network = droplet.networks.v4.first
+    expect(v4_network.ip_address).to eq('127.0.0.19')
+    expect(v4_network.netmask).to eq("255.255.255.0")
+    expect(v4_network.gateway).to eq("127.0.0.20")
+    expect(v4_network.type).to eq("public")
+
+    v6_network = droplet.networks.v6.first
+    expect(v6_network.ip_address).to eq('2001::13')
+    expect(v6_network.gateway).to eq("2400:6180:0000:00D0:0000:0000:0009:7000")
+    expect(v6_network.cidr).to eq(124)
+    expect(v6_network.type).to eq("public")
+
+    expect(droplet.kernel).to be_kind_of(DropletKit::Kernel)
+    expect(droplet.kernel.id).to eq(485432985)
+    expect(droplet.kernel.name).to eq("DO-recovery-static-fsck")
+    expect(droplet.kernel.version).to eq("3.8.0-25-generic")
+  end
+
+  describe '#all' do
+    it 'returns all of the droplets' do
+      stub_do_api('/v2/droplets', :get).to_return(body: api_fixture('droplets/all'))
+      droplets = resource.all
+      expect(droplets).to all(be_kind_of(DropletKit::Droplet))
+
+      check_droplet(droplets.first)
+    end
+  end
+
+  describe '#find' do
+    it 'returns a singular droplet' do
+      stub_do_api('/v2/droplets/20', :get).to_return(body: api_fixture('droplets/find'))
+      droplet = resource.find(id: 20)
+      expect(droplet).to be_kind_of(DropletKit::Droplet)
+      check_droplet(droplet)
+    end
+  end
+
+  describe '#create' do
+    context 'for a successful create' do
+      it 'returns the created droplet' do
+        droplet = DropletKit::Droplet.new(
+          name: 'test.example.com',
+          region: 'nyc1',
+          size: '512mb',
+          image: 'ubuntu-14-04-x86',
+          ssh_keys: [123],
+          backups: true,
+          ipv6: true
+        )
+
+        as_hash = DropletKit::DropletMapping.representation_for(:create, droplet, NullHashLoad)
+        expect(as_hash[:name]).to eq(droplet.name)
+        expect(as_hash[:region]).to eq(droplet.region)
+        expect(as_hash[:size]).to eq(droplet.size)
+        expect(as_hash[:image]).to eq(droplet.image)
+        expect(as_hash[:ssh_keys]).to eq(droplet.ssh_keys)
+        expect(as_hash[:backups]).to eq(droplet.backups)
+        expect(as_hash[:ipv6]).to eq(droplet.ipv6)
+
+        as_string = DropletKit::DropletMapping.representation_for(:create, droplet)
+        stub_do_api('/v2/droplets', :post).with(body: as_string).to_return(body: api_fixture('droplets/create'), status: 202)
+        created_droplet = resource.create(droplet)
+        check_droplet(created_droplet)
+      end
+    end
+
+    context 'for an unsuccessful create' do
+      it 'raises a FailedCreate exception with the message attached' do
+        response_body = { id: :unprocessable_entity, message: 'Something is not right' }
+        stub_do_api('/v2/droplets', :post).to_return(body: response_body.to_json, status: 422)
+
+        expect { resource.create(DropletKit::Droplet.new) }.to raise_exception(DropletKit::FailedCreate).with_message(response_body[:message])
+      end
+    end
+  end
+
+  describe '#kernels' do
+    it 'returns a list of kernels for a droplet' do
+      stub_do_api('/v2/droplets/1066/kernels', :get).to_return(body: api_fixture('droplets/list_kernels'))
+      kernels = resource.kernels(id: 1066)
+
+      expect(kernels).to all(be_kind_of(DropletKit::Kernel))
+      expect(kernels[0].id).to eq(61833229)
+      expect(kernels[0].name).to eq('Ubuntu 14.04 x32 vmlinuz-3.13.0-24-generic')
+      expect(kernels[0].version).to eq('3.13.0-24-generic')
+
+      expect(kernels[1].id).to eq(485432972)
+      expect(kernels[1].name).to eq('Ubuntu 14.04 x64 vmlinuz-3.13.0-24-generic (1221)')
+      expect(kernels[1].version).to eq('3.13.0-24-generic')
+    end
+  end
+
+  describe '#snapshots' do
+    it 'returns a list of kernels for a droplet' do
+      stub_do_api('/v2/droplets/1066/snapshots', :get).to_return(body: api_fixture('droplets/list_snapshots'))
+      snapshots = resource.snapshots(id: 1066)
+
+      expect(snapshots).to all(be_kind_of(DropletKit::Snapshot))
+      expect(snapshots[0].id).to eq(449676387)
+      expect(snapshots[0].name).to eq("Ubuntu 13.04")
+      expect(snapshots[0].distribution).to eq("ubuntu")
+      expect(snapshots[0].slug).to eq(nil)
+      expect(snapshots[0].public).to eq(false)
+      expect(snapshots[0].regions).to eq(["nyc1"])
+      expect(snapshots[0].created_at).to eq("2014-07-29T14:35:38Z")
+    end
+  end
+
+  describe '#backups' do
+    it 'returns a list of backups for a droplet' do
+      stub_do_api('/v2/droplets/1066/backups', :get).to_return(body: api_fixture('droplets/list_backups'))
+      backups = resource.backups(id: 1066)
+
+      expect(backups).to all(be_kind_of(DropletKit::Backup))
+      expect(backups[0].id).to eq(449676388)
+      expect(backups[0].name).to eq("Ubuntu 13.04")
+      expect(backups[0].distribution).to eq("ubuntu")
+      expect(backups[0].slug).to eq(nil)
+      expect(backups[0].public).to eq(false)
+      expect(backups[0].regions).to eq(["nyc1"])
+      expect(backups[0].created_at).to eq("2014-07-29T14:35:38Z")
+    end
+  end
+
+  describe '#actions' do
+    it 'returns a list of actions for the droplet' do
+      stub_do_api('/v2/droplets/1066/actions', :get).to_return(body: api_fixture('droplets/list_actions'))
+      actions = resource.actions(id: 1066)
+
+      expect(actions).to all(be_kind_of(DropletKit::Action))
+
+      expect(actions[0].id).to eq(19)
+      expect(actions[0].status).to eq("in-progress")
+      expect(actions[0].type).to eq("create")
+      expect(actions[0].started_at).to eq("2014-07-29T14:35:39Z")
+      expect(actions[0].completed_at).to eq(nil)
+      expect(actions[0].resource_id).to eq(24)
+      expect(actions[0].resource_type).to eq("droplet")
+      expect(actions[0].region).to eq("nyc1")
+    end
+  end
+
+  describe '#delete' do
+    it 'sends a delete request for the droplet' do
+      request = stub_do_api('/v2/droplets/1066', :delete)
+      resource.delete(id: 1066)
+
+      expect(request).to have_been_made
+    end
+  end
+end