droplet_kit 2.8.0 → 2.9.0

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

@@ -1,340 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::DropletResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  # There's a lot to check
-  def check_droplet(droplet, tags = [], overrides = {})
-    attrs = {
-      id: 19,
-      name: 'test.example.com',
-      memory: 1024,
-      vcpus: 2,
-      disk: 20,
-      locked: false,
-      status: 'active'
-    }.merge(overrides)
-
-    attrs.each do |attr, val|
-      expect(droplet.send(attr)).to eq attrs[attr]
-    end
-
-    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')
-    tags.each do |tag|
-      expect(droplet.tags).to include(tag)
-    end
-
-    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_slug).to eq("1024mb")
-
-    expect(droplet.networks).to be_kind_of(DropletKit::NetworkHash)
-    private_v4_network = droplet.networks.v4.first
-    expect(private_v4_network.ip_address).to eq('10.0.0.19')
-    expect(private_v4_network.netmask).to eq("255.255.0.0")
-    expect(private_v4_network.gateway).to eq("10.0.0.1")
-    expect(private_v4_network.type).to eq("private")
-
-    public_v4_network = droplet.networks.v4.last
-    expect(public_v4_network.ip_address).to eq('127.0.0.19')
-    expect(public_v4_network.netmask).to eq("255.255.255.0")
-    expect(public_v4_network.gateway).to eq("127.0.0.20")
-    expect(public_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, ['tag-1', 'tag-2'])
-    end
-
-    it 'returns an empty array of droplets' do
-      stub_do_api('/v2/droplets', :get).to_return(body: api_fixture('droplets/all_empty'))
-      droplets = resource.all.map(&:id)
-      expect(droplets).to be_empty
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { 'droplets/all' }
-      let(:api_path) { '/v2/droplets' }
-    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, ['tag-1', 'tag-2'])
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/droplets/123' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { id: 123 } }
-    end
-  end
-
-  describe '#create' do
-    let(:path) { '/v2/droplets' }
-
-    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,
-          monitoring: true,
-          ipv6: true,
-          private_networking: true,
-          user_data: "#cloud-config\nruncmd\n\t- echo 'Hello!'",
-          tags: ['one', 'two']
-        )
-
-        as_hash = DropletKit::DropletMapping.hash_for(:create, droplet)
-        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['monitoring']).to eq(droplet.monitoring)
-        expect(as_hash['ipv6']).to eq(droplet.ipv6)
-        expect(as_hash['private_networking']).to eq(droplet.private_networking)
-        expect(as_hash['user_data']).to eq(droplet.user_data)
-        expect(as_hash['tags']).to eq(droplet.tags)
-
-        as_string = DropletKit::DropletMapping.representation_for(:create, droplet)
-        stub_do_api(path, :post).with(body: as_string).to_return(body: api_fixture('droplets/create'), status: 202)
-        created_droplet = resource.create(droplet)
-        check_droplet(created_droplet)
-      end
-
-      it 'reuses the same object' do
-        droplet = DropletKit::Droplet.new(
-          name: 'test.example.com',
-          region: 'nyc1',
-          size: '512mb',
-          image: 'ubuntu-14-04-x86'
-        )
-
-        json = DropletKit::DropletMapping.representation_for(:create, droplet)
-        stub_do_api(path, :post).with(body: json).to_return(body: api_fixture('droplets/create'), status: 202)
-        created_droplet = resource.create(droplet)
-        expect(created_droplet).to be droplet
-      end
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::Droplet.new }
-    end
-  end
-
-  describe '#create_multiple' do
-    let(:path) { '/v2/droplets' }
-
-    context 'for a successful multiple create' do
-      it 'returns the created droplets' do
-        droplet = DropletKit::Droplet.new(
-          names: ['test-01.example.com', 'test-02.example.com'],
-          region: 'nyc1',
-          size: '512mb',
-          image: 'ubuntu-14-04-x86',
-          ssh_keys: [123],
-          backups: true,
-          ipv6: true,
-          private_networking: true,
-          user_data: "#cloud-config\nruncmd\n\t- echo 'Hello!'",
-          tags: ['one', 'two']
-        )
-
-        as_hash = DropletKit::DropletMapping.hash_for(:create, droplet)
-        expect(as_hash['names']).to eq(droplet.names)
-        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)
-        expect(as_hash['private_networking']).to eq(droplet.private_networking)
-        expect(as_hash['user_data']).to eq(droplet.user_data)
-        expect(as_hash['tags']).to eq(droplet.tags)
-
-        as_string = DropletKit::DropletMapping.representation_for(:create, droplet)
-        stub_do_api(path, :post).with(body: as_string).to_return(body: api_fixture('droplets/create_multiple'), status: 202)
-
-        created_droplets = resource.create_multiple(droplet)
-        check_droplet(created_droplets[0], [], name: 'test-01.example.com')
-        check_droplet(created_droplets[1], [], id: 20, name: 'test-02.example.com')
-      end
-
-      it 'reuses the same object' do
-        droplet = DropletKit::Droplet.new(
-          names: ['test-01.example.com', 'test-02.example.com'],
-          region: 'nyc1',
-          size: '512mb',
-          image: 'ubuntu-14-04-x86'
-        )
-
-        json = DropletKit::DropletMapping.representation_for(:create, droplet)
-        stub_do_api(path, :post).with(body: json).to_return(body: api_fixture('droplets/create_multiple'), status: 202)
-        created_droplets = resource.create_multiple(droplet)
-        check_droplet(created_droplets[0], [], name: 'test-01.example.com')
-        check_droplet(created_droplets[1], [], id: 20, name: 'test-02.example.com')
-      end
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::Droplet.new }
-    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).take(20)
-
-      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
-
-    it 'returns a paginated resource' do
-      stub_do_api('/v2/droplets/1066/kernels', :get).to_return(body: api_fixture('droplets/list_kernels'))
-      kernels = resource.kernels(id: 1066, page: 1, per_page: 1)
-      expect(kernels).to be_kind_of(DropletKit::PaginatedResource)
-    end
-  end
-
-  describe '#snapshots' do
-    it 'returns a list of image snapshots 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).take(20)
-
-      expect(snapshots).to all(be_kind_of(DropletKit::Image))
-      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"])
-    end
-
-    it 'returns a paginated resource' do
-      stub_do_api('/v2/droplets/1066/snapshots', :get).to_return(body: api_fixture('droplets/list_snapshots'))
-      snapshots = resource.snapshots(id: 1066, page: 1, per_page: 1)
-      expect(snapshots).to be_kind_of(DropletKit::PaginatedResource)
-    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).take(20)
-
-      expect(backups).to all(be_kind_of(DropletKit::Image))
-      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"])
-    end
-
-    it 'returns a paginated resource' do
-      stub_do_api('/v2/droplets/1066/backups', :get).to_return(body: api_fixture('droplets/list_backups'))
-      backups = resource.backups(id: 1066, page: 1, per_page: 1)
-      expect(backups).to be_kind_of(DropletKit::PaginatedResource)
-    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).take(20)
-
-      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 be_kind_of(DropletKit::Region)
-      expect(actions[0].region.slug).to eq('nyc1')
-      expect(actions[0].region.name).to eq('New York')
-      expect(actions[0].region.sizes).to include('512mb')
-      expect(actions[0].region.available).to be(true)
-      expect(actions[0].region.features).to include("virtio", "private_networking", "backups", "ipv6", "metadata")
-    end
-
-    it 'returns a paginated resource' do
-      stub_do_api('/v2/droplets/1066/actions', :get).to_return(body: api_fixture('droplets/list_actions'))
-      actions = resource.actions(id: 1066, page: 1, per_page: 1)
-      expect(actions).to be_kind_of(DropletKit::PaginatedResource)
-    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
-
-  describe '#delete_tagged' do
-    it 'sends a delete request for the tagged droplet' do
-      request = stub_do_api('/v2/droplets?tag_name=testing-1', :delete)
-      resource.delete_for_tag(tag_name: 'testing-1')
-
-      expect(request).to have_been_made
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::DropletUpgradeResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  describe '#all' do
-    it 'returns a collection of Droplet upgrades' do
-      body = api_fixture('droplet_upgrades/all')
-      stub_do_api('/v2/droplet_upgrades').to_return(body: body)
-      expected = DropletKit::DropletUpgradeMapping.extract_collection(body, :read)
-
-      expect(resource.all).to eq(expected)
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/droplet_upgrades' }
-      let(:method) { :get }
-      let(:action) { :all }
-    end
-  end
-end

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

@@ -1,265 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::FirewallResource do
-  include_context 'resources'
-
-  let(:firewall_fixture_path) { 'firewalls/find' }
-  let(:base_path) { '/v2/firewalls' }
-  let(:firewall_id) { '11d87802-df17-4f8f-a691-58e408570c12' }
-  let(:firewall) do
-    DropletKit::Firewall.new(
-      name: 'firewall',
-      inbound_rules: [
-        DropletKit::FirewallInboundRule.new(
-          protocol: 'icmp',
-          ports: '0',
-          sources: {
-            tags: ['backend'],
-            load_balancer_uids: ['d2d3920a-9d45-41b0-b018-d15e18ec60a4']
-          }
-        ),
-        DropletKit::FirewallInboundRule.new(
-          protocol: 'tcp',
-          ports: '8000-9000',
-          sources: {
-            addresses: ['0.0.0.0/0']
-          }
-        )
-      ],
-      outbound_rules: [
-        DropletKit::FirewallOutboundRule.new(
-          protocol: 'icmp',
-          ports: '0',
-          destinations: {
-            tags: ['backend']
-          }
-        ),
-        DropletKit::FirewallOutboundRule.new(
-          protocol: 'tcp',
-          ports: '8000-9000',
-          destinations: {
-            addresses: ['127.0.0.0']
-          }
-        )
-      ],
-      droplet_ids: [123],
-      tags: ['backend'])
-  end
-
-  subject(:resource) { described_class.new(connection: connection) }
-
-  RSpec::Matchers.define :match_firewall_fixture do
-    match do |firewall|
-      expect(firewall.id).to eq('11d87802-df17-4f8f-a691-58e408570c12')
-      expect(firewall.name).to eq('firewall')
-      expect(firewall.status).to eq('succeeded')
-      expect(firewall.created_at).to eq('2017-05-30T16:25:21Z')
-      expect(firewall.inbound_rules.count).to eq(2)
-      expect(firewall.inbound_rules.first.attributes)
-        .to match(a_hash_including(protocol: 'icmp', ports: '0',
-                                   sources: { 'load_balancer_uids' => ['d2d3920a-9d45-41b0-b018-d15e18ec60a4'],
-                                              'tags' => ['backend'] }))
-      expect(firewall.inbound_rules.last.attributes)
-        .to match(a_hash_including(protocol: 'tcp', ports: '8000-9000',
-                                   sources: { 'addresses' => ['0.0.0.0/0'] }))
-      expect(firewall.outbound_rules.count).to eq(2)
-      expect(firewall.outbound_rules.first.attributes)
-        .to match(a_hash_including(protocol: 'icmp', ports: '0',
-                                   destinations: { 'tags' => ['backend'] }))
-      expect(firewall.outbound_rules.last.attributes)
-        .to match(a_hash_including(protocol: 'tcp', ports: '8000-9000',
-                                   destinations: { 'addresses' => ['127.0.0.0'],
-                                                   'droplet_ids' => [345] }))
-      expect(firewall.droplet_ids).to match_array([123])
-      expect(firewall.tags).to match_array(['backend'])
-      expect(firewall.pending_changes).to be_empty
-    end
-  end
-
-  describe '#find' do
-    it 'returns firewall' do
-      stub_do_api(File.join(base_path, firewall_id), :get).to_return(body: api_fixture(firewall_fixture_path))
-      firewall = resource.find(id: firewall_id)
-
-      expect(firewall).to match_firewall_fixture
-    end
-  end
-
-  describe '#create' do
-    let(:path) { base_path }
-
-    it 'returns created firewall' do
-      json_body = DropletKit::FirewallMapping.representation_for(:create, firewall)
-      stub_do_api(path, :post).with(body: json_body).to_return(body: api_fixture(firewall_fixture_path), status: 202)
-
-      expect(resource.create(firewall)).to match_firewall_fixture
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::Firewall.new }
-    end
-  end
-
-  describe '#update' do
-    let(:path) { base_path }
-
-    it 'returns updated firewall' do
-      json_body = DropletKit::FirewallMapping.representation_for(:update, firewall)
-      stub_do_api(File.join(base_path, firewall_id), :put).with(body: json_body).to_return(body: api_fixture(firewall_fixture_path), status: 200)
-
-      expect(resource.update(firewall, id: firewall_id)).to match_firewall_fixture
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:verb) { :put }
-      let(:exception) { DropletKit::FailedUpdate }
-      let(:action) { 'update' }
-      let(:arguments) { DropletKit::Firewall.new }
-    end
-  end
-
-  describe '#all' do
-    let(:firewalls_fixture_path) { 'firewalls/all' }
-
-    it 'returns all firewalls' do
-      stub_do_api(base_path, :get).to_return(body: api_fixture(firewalls_fixture_path))
-      firewalls = resource.all
-
-      expect(firewalls).to all(be_kind_of(DropletKit::Firewall))
-      expect(firewalls.first).to match_firewall_fixture
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { firewalls_fixture_path }
-      let(:api_path) { base_path }
-    end
-  end
-
-  describe '#all_by_droplet' do
-    let(:droplet_id) { 123 }
-    let(:all_by_droplet_path) { "/v2/droplets/#{droplet_id}/firewalls" }
-    let(:firewalls_fixture_path) { 'firewalls/all' }
-
-    it 'returns all firewalls for a provided droplet' do
-      stub_do_api(all_by_droplet_path, :get).to_return(body: api_fixture(firewalls_fixture_path))
-      firewalls = resource.all_by_droplet(droplet_id: droplet_id)
-
-      expect(firewalls).to all(be_kind_of(DropletKit::Firewall))
-      expect(firewalls.first).to match_firewall_fixture
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { firewalls_fixture_path }
-      let(:action) { :all_by_droplet }
-      let(:parameters) { { droplet_id: droplet_id } }
-      let(:api_path) { all_by_droplet_path }
-    end
-  end
-
-  describe '#delete' do
-    it 'sends request to delete given firewall' do
-      request = stub_do_api(File.join(base_path, firewall_id), :delete)
-      resource.delete(id: firewall_id)
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context 'droplets' do
-    let(:droplet_id_1) { 1 }
-    let(:droplet_id_2) { 2 }
-
-    describe '#add_droplets' do
-      it 'sends request to add droplets for a given firewall' do
-        request = stub_do_api(File.join(base_path, firewall_id, 'droplets'), :post).with(body: { droplet_ids: [droplet_id_1, droplet_id_2] }.to_json)
-        resource.add_droplets([droplet_id_1, droplet_id_2], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-
-    describe '#remove_droplets' do
-      it 'sends request to remove droplets from a given firewall' do
-        request = stub_do_api(File.join(base_path, firewall_id, 'droplets'), :delete).with(body: { droplet_ids: [droplet_id_1, droplet_id_2]}.to_json)
-        resource.remove_droplets([droplet_id_1, droplet_id_2], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-  end
-
-  context 'tags' do
-    let(:frontend_tag) { 'frontend' }
-    let(:backend_tag) { 'backend' }
-
-    describe '#add_tags' do
-      it 'sends request to add tags for a given firewall' do
-        request = stub_do_api(File.join(base_path, firewall_id, 'tags'), :post).with(body: { tags: [frontend_tag, backend_tag] }.to_json)
-        resource.add_tags([frontend_tag, backend_tag], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-
-    describe '#remove_tags' do
-      it 'sends request to remove tags from a given firewall' do
-        request = stub_do_api(File.join(base_path, firewall_id, 'tags'), :delete).with(body: { tags: [frontend_tag, backend_tag]}.to_json)
-        resource.remove_tags([frontend_tag, backend_tag], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-  end
-
-  context 'rules' do
-    let(:inbound_rule) do
-      DropletKit::FirewallInboundRule.new(
-        protocol: 'tcp',
-        ports: '22',
-        sources: {
-          addresses: ['127.0.0.0'],
-          tags: ['frontend', 'backend']
-        }
-      )
-    end
-
-    let(:outbound_rule) do
-      DropletKit::FirewallOutboundRule.new(
-        protocol: 'tcp',
-        ports: '8080',
-        destinations: {
-          droplet_ids: [123, 456],
-          load_balancer_uids: ['lb-uuid']
-        }
-      )
-    end
-
-    let(:rules) do
-      DropletKit::FirewallRule.new(
-        inbound_rules: [inbound_rule],
-        outbound_rules: [outbound_rule]
-      )
-    end
-
-    describe '#add_rules' do
-      it 'sends request to add rules for a given firewall' do
-        json_body = DropletKit::FirewallRuleMapping.representation_for(:create, rules)
-        request = stub_do_api(File.join(base_path, firewall_id, 'rules'), :post).with(body: json_body)
-        resource.add_rules(inbound_rules: [inbound_rule], outbound_rules: [outbound_rule], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-
-    describe '#remove_rules' do
-      it 'sends request to remove rules from a given firewall' do
-        json_body = DropletKit::FirewallRuleMapping.representation_for(:update, rules)
-        request = stub_do_api(File.join(base_path, firewall_id, 'rules'), :delete).with(body: json_body)
-        resource.remove_rules(inbound_rules: [inbound_rule], outbound_rules: [outbound_rule], id: firewall_id)
-
-        expect(request).to have_been_made
-      end
-    end
-  end
-end