droplet_kit 2.8.0 → 2.9.0

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

@@ -1,313 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::KubernetesClusterResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  let(:kubernetes_node_pool_attributes) { DropletKit::KubernetesNodePool.new.attributes }
-  let(:cluster_id) { "c28bf806-eba8-4a6d-a98f-8fd388740bd0" }
-  include_context 'resources'
-
-  describe '#find' do
-    it 'returns a singular cluster' do
-      stub_do_api('/v2/kubernetes/clusters/20', :get).to_return(body: api_fixture('kubernetes/clusters/find'))
-      cluster = resource.find(id: 20)
-      expect(cluster).to be_kind_of(DropletKit::KubernetesCluster)
-
-      expect(cluster.id).to eq("cluster-1-id")
-      expect(cluster.name).to eq("test-cluster")
-      expect(cluster.region).to eq("nyc1")
-      expect(cluster.version).to eq("1.12.1-do.2")
-      expect(cluster.cluster_subnet).to eq("10.244.0.0/16")
-      expect(cluster.ipv4).to eq("0.0.0.0")
-      expect(cluster.tags).to match_array(["test-k8", "k8s", "k8s:cluster-1-id"])
-      expect(cluster.node_pools.count).to eq(1)
-    end
-
-    it_behaves_like 'resource that handles common errors' do
-      let(:path) { '/v2/kubernetes/clusters/123' }
-      let(:method) { :get }
-      let(:action) { :find }
-      let(:arguments) { { id: 123 } }
-    end
-  end
-
-  describe '#update' do
-    let(:path) { '/v2/kubernetes/clusters' }
-    let(:new_attrs) do
-      {
-        "name" => "new-test-name",
-        "tags" => ["new-test"]
-      }
-    end
-
-    context 'for a successful update' do
-      it 'returns the created cluster' do
-        cluster = DropletKit::KubernetesCluster.new(new_attrs)
-
-        as_hash = DropletKit::KubernetesClusterMapping.hash_for(:update, cluster)
-        expect(as_hash['name']).to eq(cluster.name)
-        expect(as_hash['tags']).to eq(cluster.tags)
-
-
-        as_string = DropletKit::KubernetesClusterMapping.representation_for(:update, cluster)
-        stub_do_api(path, :put).with(body: as_string).to_return(body: api_fixture('kubernetes/clusters/update'), status: 202)
-
-        updated_cluster = resource.update(cluster)
-        expect(updated_cluster.name).to eq("new-test-name")
-        expect(updated_cluster.tags).to match_array(["new-test"])
-      end
-    end
-  end
-
-  describe '#all' do
-    it 'returns all of the clusters' do
-      stub_do_api('/v2/kubernetes/clusters', :get).to_return(body: api_fixture('kubernetes/all'))
-      clusters = resource.all
-      expect(clusters).to all(be_kind_of(DropletKit::KubernetesCluster))
-
-      cluster = clusters.first
-
-      expect(cluster.id).to eq("cluster-1-id")
-      expect(cluster.name).to eq("test-cluster")
-      expect(cluster.region).to eq("nyc1")
-      expect(cluster.version).to eq("1.12.1-do.2")
-      expect(cluster.cluster_subnet).to eq("10.244.0.0/16")
-      expect(cluster.ipv4).to eq("0.0.0.0")
-      expect(cluster.tags).to match_array(["test-k8", "k8s", "k8s:cluster-1-id"])
-      expect(cluster.node_pools.count).to eq(1)
-    end
-
-    it 'returns an empty array of droplets' do
-      stub_do_api('/v2/kubernetes/clusters', :get).to_return(body: api_fixture('kubernetes/all_empty'))
-      clusters = resource.all.map(&:id)
-      expect(clusters).to be_empty
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { 'kubernetes/all' }
-      let(:api_path) { '/v2/kubernetes/clusters' }
-    end
-  end
-
-  describe '#create' do
-    let(:path) { '/v2/kubernetes/clusters' }
-    let(:new_attrs) do
-      {
-        "name" => "test-cluster-01",
-        "region" => "nyc1",
-        "version" => "1.12.1-do.2",
-        "tags" => ["test"],
-        "node_pools" => [
-          {
-            "size" => "s-1vcpu-1gb",
-            "count" => 3,
-            "name" => "frontend-pool",
-            "tags" => ["frontend"]
-          },
-          {
-            "size" => "c-4",
-            "count" => 2,
-            "name" => "backend-pool"
-          }
-        ]
-      }
-    end
-
-    context 'for a successful create' do
-      it 'returns the created cluster' do
-        cluster = DropletKit::KubernetesCluster.new(new_attrs)
-
-        as_hash = DropletKit::KubernetesClusterMapping.hash_for(:create, cluster)
-        expect(as_hash['name']).to eq(cluster.name)
-        expect(as_hash['region']).to eq(cluster.region)
-        expect(as_hash['version']).to eq(cluster.version)
-        expect(as_hash['tags']).to eq(cluster.tags)
-        expect(as_hash['node_pools']).to eq(cluster.node_pools)
-
-
-        as_string = DropletKit::KubernetesClusterMapping.representation_for(:create, cluster)
-        stub_do_api(path, :post).with(body: as_string).to_return(body: api_fixture('kubernetes/clusters/create'), status: 201)
-        created_cluster = resource.create(cluster)
-        expect(cluster.id).to eq("cluster-1-id")
-        expect(cluster.name).to eq("test-cluster")
-        expect(cluster.region).to eq("nyc1")
-        expect(cluster.version).to eq("1.12.1-do.2")
-        expect(cluster.cluster_subnet).to eq("10.244.0.0/16")
-        expect(cluster.ipv4).to eq("0.0.0.0")
-        expect(cluster.tags).to match_array(["test-k8", "k8s", "k8s:cluster-1-id"])
-        expect(cluster.node_pools.count).to eq(1)
-      end
-
-      it 'reuses the same object' do
-        cluster = DropletKit::KubernetesCluster.new(new_attrs)
-
-        json = DropletKit::KubernetesClusterMapping.representation_for(:create, cluster)
-        stub_do_api(path, :post).with(body: json).to_return(body: api_fixture('kubernetes/clusters/create'), status: 201)
-        created_cluster = resource.create(cluster)
-        expect(created_cluster).to be cluster
-      end
-    end
-
-    it_behaves_like 'an action that handles invalid parameters' do
-      let(:action) { 'create' }
-      let(:arguments) { DropletKit::KubernetesCluster.new }
-    end
-  end
-
-  describe '#delete' do
-    it 'sends a delete request for a cluster' do
-      request = stub_do_api('/v2/kubernetes/clusters/23', :delete).to_return(status: 202)
-      response = resource.delete(id: 23)
-
-      expect(request).to have_been_made
-      expect(response).to eq(true)
-    end
-  end
-
-  describe '#kubeconfig' do
-    it 'returns a yaml string kubeconfig' do
-      response = Pathname.new('./spec/fixtures/kubernetes/clusters/kubeconfig.txt').read
-
-      stub_do_api('/v2/kubernetes/clusters/1/kubeconfig', :get).to_return(body: response)
-
-      kubeconfig = resource.kubeconfig(id: '1')
-
-      expect(kubeconfig).to be_kind_of(String)
-
-      parsed_config = YAML.load(kubeconfig)
-      expect(parsed_config.keys).to match_array(["apiVersion", "clusters", "contexts", "current-context", "kind", "preferences", "users"])
-    end
-  end
- 
-  describe "node_pools" do
-    it 'returns the node_pools for a cluster' do
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools", :get).to_return(body: api_fixture('kubernetes/cluster_node_pools'))
-      node_pools= resource.node_pools(id: cluster_id)
-      node_pools.each do |pool|
-        expect(pool).to be_kind_of(DropletKit::KubernetesNodePool)
-        expect(pool.attributes.keys).to eq kubernetes_node_pool_attributes.keys
-      end
-      expect(node_pools.length).to eq 1
-      expect(node_pools.first["id"]).to eq "0a209365-2fac-465e-a959-bb91f232923a"
-      expect(node_pools.first["name"]).to eq "k8s-1-12-1-do-1-nyc1-1540837045848-1"
-      expect(node_pools.first["size"]).to eq "s-4vcpu-8gb"
-      expect(node_pools.first["count"]).to eq 2
-      expect(node_pools.first["tags"]).to eq [ "omar-left-his-mark" ]
-      expect(node_pools.first["nodes"].length).to eq 2
-    end
-  end
-
-  describe "find_node_pool" do
-    it "should return a single node pool" do
-      node_pool_id = "f9f16e5a-83b8-4c9b-acf1-4f91492a6652"
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools/#{node_pool_id}", :get).to_return(body: api_fixture('kubernetes/cluster_node_pool'))
-      node_pool = resource.find_node_pool(id: cluster_id, pool_id: node_pool_id)
-
-      expect(node_pool.id).to eq node_pool_id
-      expect(node_pool.name).to eq "k8s-1-12-1-do-2-nyc1-1542638764614-1"
-      expect(node_pool.size).to eq "s-1vcpu-1gb"
-      expect(node_pool.count).to eq 1
-      expect(node_pool.tags).to eq ["k8s", "k8s:c28bf806-eba8-4a6d-a98f-8fd388740bd0", "k8s:worker"]
-      expect(node_pool.nodes.length).to eq 1
-      expect(node_pool.nodes.first.name).to eq "blissful-antonelli-3u87"
-      expect(node_pool.nodes.first.status['state']).to eq "running"
-    end
-  end
-
-  describe "create_node_pool" do
-    it 'should create a node_pool in a cluster' do
-      node_pool = DropletKit::KubernetesNodePool.new(
-        name: 'frontend',
-        size: 's-1vcpu-1gb',
-        count: 3,
-        tags: ['k8-tag']
-      )
-      as_hash = DropletKit::KubernetesNodePoolMapping.hash_for(:create, node_pool)
-      expect(as_hash['name']).to eq(node_pool.name)
-      expect(as_hash['size']).to eq(node_pool.size)
-      expect(as_hash['count']).to eq(node_pool.count)
-      expect(as_hash['tags']).to eq(node_pool.tags)
-
-      as_string = DropletKit::KubernetesNodePoolMapping.representation_for(:create, node_pool)
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools", :post).with(body: as_string).to_return(body: api_fixture('kubernetes/cluster_node_pool_create'), status: 201)
-      new_node_pool = resource.create_node_pool(node_pool, id: cluster_id)
-
-      expect(new_node_pool).to be_kind_of(DropletKit::KubernetesNodePool)
-      expect(new_node_pool.name).to eq 'frontend'
-      expect(new_node_pool.size).to eq 's-1vcpu-1gb'
-      expect(new_node_pool.count).to eq 3
-      expect(new_node_pool.tags).to eq ['k8-tag']
-      expect(new_node_pool.nodes.length).to eq 3
-      new_node_pool.nodes.each do |node|
-        expect(node['name']).to eq ""
-        expect(node['status']['state']).to eq 'provisioning'
-      end
-    end
-  end
-
-  describe "update_node_pool" do
-    it "should update an existing node_pool" do
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools", :get).to_return(body: api_fixture('kubernetes/cluster_node_pools'))
-      node_pools = resource.node_pools(id: cluster_id)
-      node_pools.each do |pool|
-        expect(pool).to be_kind_of(DropletKit::KubernetesNodePool)
-      end
-      node_pool_id = "0a209365-2fac-465e-a959-bb91f232923a"
-      expect(node_pools.length).to eq 1
-      expect(node_pools.first["id"]).to eq node_pool_id
-      expect(node_pools.first["name"]).to eq "k8s-1-12-1-do-1-nyc1-1540837045848-1"
-      expect(node_pools.first["size"]).to eq "s-4vcpu-8gb"
-      expect(node_pools.first["count"]).to eq 2
-      expect(node_pools.first["tags"]).to eq [ "omar-left-his-mark" ]
-
-      node_pool = node_pools.first
-      node_pool.name = 'backend'
-      node_pool.size = 's-1vcpu-1gb'
-      node_pool.count = 2
-      node_pool.tags = ['updated-k8-tag']
-      as_string = DropletKit::KubernetesNodePoolMapping.representation_for(:update, node_pool)
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools/#{node_pool_id}", :put).with(body: as_string).to_return(body: api_fixture('kubernetes/cluster_node_pool_update'), status: 202)
-      updated_node_pool = resource.update_node_pool(node_pool, id: cluster_id, pool_id: node_pool_id)
-
-      expect(updated_node_pool.id).to eq node_pool_id
-      expect(updated_node_pool.name).to eq 'backend'
-      expect(updated_node_pool.size).to eq 's-1vcpu-1gb'
-      expect(updated_node_pool.count).to eq 2
-      expect(updated_node_pool.tags).to eq ['backend']
-      expect(updated_node_pool.nodes.length).to eq 2
-    end
-  end
-
-  describe 'delete_node_pool' do
-    it 'should delete a clusters node_pool' do
-      node_pool_id = "f9f16e5a-83b8-4c9b-acf1-4f91492a6652"
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools/#{node_pool_id}", :delete).to_return(status: 202)
-      deleted_node_pool = resource.delete_node_pool(id: cluster_id, pool_id: node_pool_id)
-
-      expect(deleted_node_pool).to eq true
-    end
-  end
-
-  describe 'recycle_node_pool' do
-    it 'should recycle the clusters node_pool' do
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools", :get).to_return(body: api_fixture('kubernetes/cluster_node_pools'))
-      node_pools = resource.node_pools(id: cluster_id)
-      node_pools.each do |pool|
-        expect(pool).to be_kind_of(DropletKit::KubernetesNodePool)
-      end
-      node_pool_id = "0a209365-2fac-465e-a959-bb91f232923a"
-      expect(node_pools.length).to eq 1
-      expect(node_pools.first["id"]).to eq node_pool_id
-      expect(node_pools.first["name"]).to eq "k8s-1-12-1-do-1-nyc1-1540837045848-1"
-      expect(node_pools.first["count"]).to eq 2
-
-      nodes = node_pools.first.nodes
-      expect(nodes.length).to eq 2
-      node_ids = nodes.map(&:id)
-      recycle_json = { nodes: node_ids}.to_json
-      stub_do_api("/v2/kubernetes/clusters/#{cluster_id}/node_pools/#{node_pool_id}/recycle", :post).with(body: recycle_json).to_return(status: 202)
-      response = resource.recycle_node_pool(node_ids, id: cluster_id, pool_id: node_pool_id)
-
-      expect(response).to eq true
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::KubernetesOptionsResource do
-  subject(:resource) { described_class.new(connection: connection) }
-  include_context 'resources'
-
-  describe 'all' do
-    it 'should get the kubernetes options' do
-      stub_do_api("/v2/kubernetes/options", :get).to_return(body: api_fixture('kubernetes/options'))
-      options = resource.all
-      expect(options).to be_kind_of(DropletKit::KubernetesOptions)
-      expect(options.versions.length).to eq 9
-      options.versions.each do |version|
-        expect(version).to be_kind_of(DropletKit::KubernetesOptionsMapping::Version)
-        expect(version.slug).to be_present
-        expect(version.kubernetes_version).to be_present
-      end
-      expect(options.regions.length).to eq 13
-      options.regions.each do |region|
-        expect(region).to be_kind_of(DropletKit::KubernetesOptionsMapping::Region)
-        expect(region.name).to be_present
-        expect(region.slug).to be_present
-      end
-      expect(options.sizes.length).to eq 13
-      options.sizes.each do |size|
-        expect(size).to be_kind_of(DropletKit::KubernetesOptionsMapping::Size)
-        expect(size.name).to be_present
-        expect(size.slug).to be_present
-      end
-    end
-  end
-end
-

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

@@ -1,213 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DropletKit::LoadBalancerResource do
-  include_context 'resources'
-
-  let(:load_balancer_fixture_path) { 'load_balancers/find' }
-  let(:base_path) { '/v2/load_balancers'}
-  let(:load_balancer_id) { '37e6be88-01ec-4ec7-9bc6-a514d4719057' }
-
-  subject(:resource) { described_class.new(connection: connection) }
-
-  RSpec::Matchers.define :match_load_balancer_fixture do
-    match do |load_balancer|
-      expect(load_balancer.name).to eq('example-lb-01')
-      expect(load_balancer.id).to eq('4de7ac8b-495b-4884-9a69-1050c6793cd6')
-      expect(load_balancer.ip).to eq('104.131.186.241')
-      expect(load_balancer.algorithm).to eq('round_robin')
-      expect(load_balancer.status).to eq('active')
-      expect(load_balancer.created_at).to eq('2017-02-01T22:22:58Z')
-      expect(load_balancer.tag).to be_blank
-      expect(load_balancer.region).to be_kind_of(DropletKit::Region)
-      expect(load_balancer.region.attributes)
-        .to match(a_hash_including(slug: 'nyc3', name: 'New York 3',
-                                   available: true, sizes: ['512mb'], features: ['private_networking']))
-      expect(load_balancer.droplet_ids).to match_array([3164445, 3164444])
-      expect(load_balancer.sticky_sessions).to be_kind_of(DropletKit::StickySession)
-      expect(load_balancer.sticky_sessions.attributes)
-        .to match(a_hash_including(cookie_ttl_seconds: 5, cookie_name: 'DO-LB', type: 'cookies'))
-      expect(load_balancer.health_check).to be_kind_of(DropletKit::HealthCheck)
-      expect(load_balancer.health_check.attributes)
-        .to match(a_hash_including(protocol: 'http', port: 80, path: '/',
-                                   check_interval_seconds: 10, response_timeout_seconds: 5,
-                                   healthy_threshold: 5, unhealthy_threshold: 3))
-      expect(load_balancer.forwarding_rules.count).to eq(2)
-      expect(load_balancer.forwarding_rules.first.attributes)
-        .to match(a_hash_including(entry_protocol: 'http', entry_port: 80,
-                                   target_protocol: 'http', target_port: 80,
-                                   certificate_id: '', tls_passthrough: false))
-      expect(load_balancer.forwarding_rules.last.attributes)
-        .to match(a_hash_including(entry_protocol: 'https', entry_port: 444,
-                                   target_protocol: 'https', target_port: 443,
-                                   certificate_id: 'my-cert', tls_passthrough: true))
-    end
-  end
-
-  describe '#find' do
-    it 'returns load balancer' do
-      stub_do_api(File.join(base_path, load_balancer_id), :get).to_return(body: api_fixture(load_balancer_fixture_path))
-      load_balancer = resource.find(id: load_balancer_id)
-
-      expect(load_balancer).to match_load_balancer_fixture
-    end
-  end
-
-  describe '#all' do
-    let(:load_balancers_fixture_path) { 'load_balancers/all' }
-
-    it 'returns all of the load balancers' do
-      stub_do_api(base_path, :get).to_return(body: api_fixture(load_balancers_fixture_path))
-      load_balancers = resource.all
-
-      expect(load_balancers).to all(be_kind_of(DropletKit::LoadBalancer))
-      expect(load_balancers.first).to match_load_balancer_fixture
-    end
-
-    it_behaves_like 'a paginated index' do
-      let(:fixture_path) { load_balancers_fixture_path }
-      let(:api_path) { base_path }
-    end
-  end
-
-  context 'create and update' do
-    let(:load_balancer) do
-      DropletKit::LoadBalancer.new(
-        name: 'example-lb-01',
-        algorithm: 'round_robin',
-        droplet_ids: [ 3164444, 3164445],
-        redirect_http_to_https: true,
-        region: 'nyc1',
-        forwarding_rules: [
-          DropletKit::ForwardingRule.new(
-            entry_protocol: 'https',
-            entry_port: 444,
-            target_protocol: 'https',
-            target_port: 443,
-            certificate_id: 'my-cert',
-            tls_passthrough: false
-          )
-        ],
-        sticky_sessions: DropletKit::StickySession.new(
-          type: 'cookies',
-          cookie_name: 'DO-LB',
-          cookie_ttl_seconds: 5
-        ),
-        health_check: DropletKit::HealthCheck.new(
-          protocol: 'http',
-          port: 80,
-          path: 'index.html',
-          check_interval_seconds: 10,
-          response_timeout_seconds: 5,
-          healthy_threshold: 5,
-          unhealthy_threshold: 3
-        )
-      )
-    end
-
-    describe '#create' do
-      let(:path) { base_path }
-
-      it 'returns created load balancer' do
-        json_body = DropletKit::LoadBalancerMapping.representation_for(:create, load_balancer)
-        stub_do_api(path, :post).with(body: json_body).to_return(body: api_fixture(load_balancer_fixture_path), status: 202)
-
-        expect(resource.create(load_balancer)).to match_load_balancer_fixture
-      end
-
-      it_behaves_like 'an action that handles invalid parameters' do
-        let(:action) { 'create' }
-        let(:arguments) { DropletKit::LoadBalancer.new }
-      end
-    end
-
-    describe '#update' do
-      let(:path) { base_path }
-
-      it 'returns updated load balancer' do
-        json_body = DropletKit::LoadBalancerMapping.representation_for(:update, load_balancer)
-        stub_do_api(File.join(base_path, load_balancer_id), :put).with(body: json_body).to_return(body: api_fixture(load_balancer_fixture_path), status: 200)
-
-        expect(resource.update(load_balancer, id: load_balancer_id)).to match_load_balancer_fixture
-      end
-
-      it_behaves_like 'an action that handles invalid parameters' do
-        let(:action) { 'create' }
-        let(:arguments) { DropletKit::LoadBalancer.new }
-      end
-    end
-  end
-
-  describe '#delete' do
-    it 'sends a delete request for the load balancer' do
-      request = stub_do_api(File.join(base_path, load_balancer_id), :delete)
-      resource.delete(id: load_balancer_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 a post request for the load balancer to add droplets' do
-        request = stub_do_api(File.join(base_path, load_balancer_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: load_balancer_id)
-
-        expect(request).to have_been_made
-      end
-    end
-
-    describe '#remove_droplets' do
-      it 'sends a delete request for the load balancer to remove droplet' do
-        request = stub_do_api(File.join(base_path, load_balancer_id, 'droplets'), :delete).with(body: { droplet_ids: [droplet_id_1]}.to_json)
-        resource.remove_droplets([droplet_id_1], id: load_balancer_id)
-
-        expect(request).to have_been_made
-      end
-    end
-  end
-
-  context 'forwarding_rules' do
-    let(:forwarding_rule_1) do
-      DropletKit::ForwardingRule.new(
-        entry_protocol: 'tcp',
-        entry_port: 3306,
-        target_protocol: 'tcp',
-        target_port: 3306
-      )
-    end
-
-    let(:forwarding_rule_2) do
-      DropletKit::ForwardingRule.new(
-        entry_protocol: 'https',
-        entry_port: 444,
-        target_protocol: 'https',
-        target_port: 443,
-        certificate_id: '',
-        tls_passthrough: true
-      )
-    end
-
-    describe '#add_forwarding_rules' do
-      it 'sends a post request for the load balancer to add forwarding rules' do
-        json_body = DropletKit::ForwardingRuleMapping.represent_collection_for(:create, [forwarding_rule_1, forwarding_rule_2])
-        request = stub_do_api(File.join(base_path, load_balancer_id, 'forwarding_rules'), :post).with(body: json_body)
-        resource.add_forwarding_rules([forwarding_rule_1, forwarding_rule_2], id: load_balancer_id)
-
-        expect(request).to have_been_made
-      end
-    end
-
-    describe '#remove_forwarding_rules' do
-      it 'sends a delete request for the load balancer to remove forwarding rule' do
-        json_body = DropletKit::ForwardingRuleMapping.represent_collection_for(:update, [forwarding_rule_1])
-        request = stub_do_api(File.join(base_path, load_balancer_id, 'forwarding_rules'), :delete).with(body: json_body)
-        resource.remove_forwarding_rules([forwarding_rule_1], id: load_balancer_id)
-
-        expect(request).to have_been_made
-      end
-    end
-  end
-end