droplet_kit 2.8.0 → 2.9.0

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

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::CertificateResource do
-  include_context 'resources'
-
-  let(:certificate_fixture_path) { 'certificates/find' }
-  let(:base_path) { '/v2/certificates'}
-  let(:certificate_id) { '892071a0-bb95-49bc-8021-3afd67a210bf' }
-  subject(:resource) { described_class.new(connection: connection) }
-
-  RSpec::Matchers.define :match_certificate_fixture do
-    match do |certificate|
-      expect(certificate.id).to eq('892071a0-bb95-49bc-8021-3afd67a210bf')
-      expect(certificate.name).to eq('web-cert-01')
-      expect(certificate.dns_names).to be_empty
-      expect(certificate.not_after).to eq('2017-02-22T00:23:00Z')
-      expect(certificate.sha1_fingerprint).to eq('dfcc9f57d86bf58e321c2c6c31c7a971be244ac7')
-      expect(certificate.created_at).to eq('2017-02-08T16:02:37Z')
-      expect(certificate.state).to eq('verified')
-      expect(certificate.type).to eq('custom')
-    end
-  end
-
-  describe '#find' do
-    let(:certificate) do
-      DropletKit::Certificate.new(
-        id: '892071a0-bb95-49bc-8021-3afd67a210bf',
-        name: 'web-cert-01',
-        dns_names: ["somedomain.com"],
-        not_after: '2017-02-22T00:23:00Z',
-        sha1_fingerprint: 'dfcc9f57d86bf58e321c2c6c31c7a971be244ac7',
-        created_at: '2017-02-08T16:02:37Z',
-        status: "verified",
-        type: "custom",
-      )
-    end
-
-    it 'returns certificate' do
-      stub_do_api(File.join(base_path, certificate_id), :get).to_return(body: api_fixture(certificate_fixture_path))
-      certificate = resource.find(id: certificate_id)
-
-      expect(certificate).to match_certificate_fixture
-    end
-  end
-
-  describe '#all' do
-    let(:certificates_fixture_path) { 'certificates/all' }
-
-    it 'returns all of the certificates' do
-      stub_do_api(base_path, :get).to_return(body: api_fixture(certificates_fixture_path))
-      certificates = resource.all
-
-      expect(certificates).to all(be_kind_of(DropletKit::Certificate))
-      expect(certificates.first).to match_certificate_fixture
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { certificates_fixture_path }
-      let(:api_path) { base_path }
-    end
-  end
-
-  describe '#create' do
-    let(:path) { base_path }
-
-    let(:certificate) do
-      DropletKit::Certificate.new(
-        name: 'web-cert-01',
-        private_key: '-----BEGIN PRIVATE KEY-----',
-        leaf_certificate: '-----BEGIN CERTIFICATE-----',
-        certificate_chain: '-----BEGIN CERTIFICATE-----'
-      )
-    end
-
-    it 'returns created certificate' do
-      json_body = DropletKit::CertificateMapping.representation_for(:create, certificate)
-      stub_do_api(path, :post).with(body: json_body).to_return(body: api_fixture(certificate_fixture_path), status: 201)
-
-      expect(resource.create(certificate)).to match_certificate_fixture
-    end
-
-    context 'lets encrypt certificate' do
-      let(:lets_encrypt_certificate) do
-        DropletKit::Certificate.new(
-          name: 'lets-encrypt-cert',
-          dns_names: ['somedomain.com', 'api.somedomain.com'],
-          type: 'lets_encrypt'
-        )
-      end
-
-      it 'returns created lets encrpyt certificate' do
-        json_body = DropletKit::CertificateMapping.representation_for(:create, lets_encrypt_certificate)
-        stub_do_api(path, :post).with(body: json_body).to_return(body: api_fixture('certificates/lets_encrypt'), status: 201)
-        parsed_json = JSON.parse(json_body)
-
-        certificate = resource.create(lets_encrypt_certificate)
-
-        expect(certificate.name).to eq(parsed_json['name'])
-        expect(certificate.type).to eq(parsed_json['type'])
-        expect(certificate.dns_names).to match_array(parsed_json['dns_names'])
-        expect(certificate.state).to eq('pending')
-      end
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::Certificate.new }
-    end
-  end
-
-  describe '#delete' do
-    it 'sends a delete request for the certificate' do
-      request = stub_do_api(File.join(base_path, certificate_id), :delete)
-      resource.delete(id: certificate_id)
-
-      expect(request).to have_been_made
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::DomainRecordResource do
-  subject(:resource) { described_class.new(connection: 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
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) {'domain_records/all'}
-      let(:api_path) {'/v2/domains/example.com/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: '@',
-        ttl: 90
-      )
-      as_hash = DropletKit::DomainRecordMapping.hash_for(:create, domain_record)
-      expect(as_hash['type']).to eq('CNAME')
-      expect(as_hash['name']).to eq('www')
-      expect(as_hash['data']).to eq('@')
-      expect(as_hash['ttl']).to eq(90)
-
-      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('@')
-      expect(created_domain_record.ttl).to eq(90)
-    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
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/domains/example.com/records/12' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { for_domain: 'example.com', id: 123 } }
-    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.hash_for(:update, domain_record)
-      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('@')
-      expect(updated_domain_record.ttl).to eq(1800)
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::DomainResource do
-  subject(:resource) { described_class.new(connection: 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
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) {'domains/all'}
-      let(:api_path) {'/v2/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.hash_for(:create, domain)
-      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
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/domains/example.com' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { name: 'example.com' } }
-    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

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::DropletActionResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  let(:droplet_id) { 1066 }
-
-  let(:fixture) { api_fixture("droplet_actions/#{action}") }
-
-  include_context 'resources'
-
-  describe '#action_for_id' do
-    let(:action) { 'event' }
-    let(:path) { "/v2/droplets/#{droplet_id}/actions" }
-    let(:fixture) { api_fixture('droplet_actions/find') }
-
-    it 'performs the action' do
-      request = stub_do_api(path, :post).with(
-        body: { type: action, param_1: 1, param_2: 2 }.to_json
-      ).to_return(body: fixture, status: 201)
-
-      resource.action_for_id(droplet_id: droplet_id, type: action, param_1: 1, param_2: 2)
-      expect(request).to have_been_made
-    end
-  end
-
-  describe '#action_for_tag' do
-    let(:action) { 'event' }
-    let(:path) { '/v2/droplets/actions' }
-    let(:fixture) { api_fixture('droplet_actions/find') }
-
-    it 'performs the action' do
-      request = stub_do_api(path, :post).with(
-        body: { tag_name: 'test-tag', type: action, param_1: 1, param_2: 2 }.to_json
-      ).to_return(body: fixture, status: 201)
-
-      resource.action_for_tag(tag_name: 'test-tag', type: action, param_1: 1, param_2: 2)
-      expect(request).to have_been_made
-    end
-  end
-
-  described_class::ACTIONS_WITHOUT_INPUT.each do |action_name|
-    describe "Action #{action_name}" do
-      let(:action) { action_name }
-      let(:path) { "/v2/droplets/#{droplet_id}/actions" }
-
-      it 'performs the action' do
-        request = stub_do_api(path, :post).with(
-          body: { type: action }.to_json
-        ).to_return(body: fixture, status: 201)
-
-        returned_action = resource.send(action, droplet_id: droplet_id)
-
-        expect(request).to have_been_made
-        expect(returned_action.type).to eq(action)
-      end
-
-      it_behaves_like 'an action that handles invalid parameters' do
-        let(:object) { DropletKit::Droplet.new }
-        let(:arguments) { { droplet_id: droplet_id } }
-      end
-    end
-  end
-
-  described_class::TAG_ACTIONS.each do |action_name|
-    describe "Batch Action #{action_name}" do
-      let(:action) { "#{action_name}_for_tag" }
-      let(:path) { "/v2/droplets/actions?tag_name=testing-1" }
-      let(:fixture) do
-        single_action = DropletKit::ActionMapping.extract_single(api_fixture("droplet_actions/#{action_name}"), :read)
-
-        DropletKit::ActionMapping.represent_collection_for(:read, [single_action])
-      end
-
-      it 'performs the action' do
-        request = stub_do_api(path, :post).with(
-          body: { type: action_name }.to_json
-        ).to_return(body: fixture, status: 201)
-
-        returned_actions = resource.send(action, tag_name: 'testing-1')
-
-        expect(request).to have_been_made
-        expect(returned_actions.first.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: fixture, 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 change_kernel" do
-    let(:action) { 'change_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: fixture, 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: fixture, 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: fixture, 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: fixture, 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', disk: nil }.to_json
-      ).to_return(body: fixture, 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 "Action resize with disk" 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', disk: true }.to_json
-      ).to_return(body: fixture, status: 201)
-
-      returned_action = resource.send(action, droplet_id: droplet_id, size: '1gb', disk: true)
-
-      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('droplet_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_slug).to eq('nyc1')
-
-      expect(returned_action.region).to be_kind_of(DropletKit::Region)
-      expect(returned_action.region.slug).to eq('nyc1')
-      expect(returned_action.region.name).to eq('New York')
-      expect(returned_action.region.sizes).to include('512mb')
-      expect(returned_action.region.available).to be(true)
-      expect(returned_action.region.features).to include("virtio", "private_networking", "backups", "ipv6", "metadata")
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/droplets/1066/actions/123' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { droplet_id: 1066, id: 123 } }
-    end
-  end
-end