vultr 2.1.1 → 2.1.2

data/test/vultr/resources/iso_test.rb

@@ -1,58 +0,0 @@
-require "test_helper"
-
-class IsoResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("iso", response: stub_response(fixture: "isos/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    iso = client.iso.list
-
-    keys = [:id, :date_created, :filename, :size, :md5sum, :sha512sum, :status]
-    assert_equal Vultr::Collection, iso.class
-    assert_equal Vultr::Iso, iso.data.first.class
-    assert_equal keys, iso.data.first.to_h.keys
-    assert_equal 1, iso.total
-  end
-
-  def test_create
-    body = {url: "http://example.com/my-iso.iso"}
-    stub = stub_request("iso", method: :post, body: body, response: stub_response(fixture: "isos/create", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    iso = client.iso.create(**body)
-
-    assert_equal "cb676a46-66fd-4dfb-b839-443f2e6c0b60", iso.id
-    assert_equal Time.parse("2020-10-10T01:56:20+00:00"), iso.date_created
-    assert_equal "my-iso.iso", iso.filename
-    assert_equal "pending", iso.status
-  end
-
-  def test_retrieve
-    iso_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b604"
-    stub = stub_request("iso/#{iso_id}", response: stub_response(fixture: "isos/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    iso = client.iso.retrieve(iso_id: iso_id)
-
-    keys = [:id, :date_created, :filename, :size, :md5sum, :sha512sum, :status]
-    assert_equal Vultr::Iso, iso.class
-    assert_equal keys, iso.to_h.keys
-  end
-
-  def test_delete
-    iso_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b604"
-    stub = stub_request("iso/#{iso_id}", method: :delete, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-
-    assert client.iso.delete(iso_id: iso_id)
-  end
-
-  def test_list_public
-    stub = stub_request("iso-public", response: stub_response(fixture: "isos/list_public"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    iso = client.iso.list_public
-
-    keys = [:id, :name, :description, :md5sum]
-    assert_equal Vultr::Collection, iso.class
-    assert_equal Vultr::Iso, iso.data.first.class
-    assert_equal keys, iso.data.first.to_h.keys
-    assert_equal 1, iso.total
-  end
-end

data/test/vultr/resources/kubernetes_test.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class KubernetesResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("kubernetes/clusters", response: stub_response(fixture: "kubernetes/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    kubernetes = client.kubernetes.list
-
-    assert_equal Vultr::Collection, kubernetes.class
-    assert_equal Vultr::KubernetesCluster, kubernetes.data.first.class
-    assert_equal 2, kubernetes.total
-    assert_equal "next", kubernetes.next_cursor
-    assert_equal "prev", kubernetes.prev_cursor
-  end
-
-  def test_create
-    body = {label: "vke", region: "lax", version: "v1.20.0+1", node_pools: [{node_quantity: 2, label: "my-label", plan: "vc2-1c-2gb"}]}
-    stub = stub_request("kubernetes/clusters", method: :post, body: body, response: stub_response(fixture: "kubernetes/create", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    kubernetes = client.kubernetes.create(**body)
-
-    assert_equal kubernetes.id, "455dcd32-e621-48ee-a10e-0cb5f754e13e"
-    assert_equal kubernetes.label, "vke"
-    assert_equal kubernetes.date_created, Time.parse("2021-07-07T22:57:01+00:00")
-    assert_equal kubernetes.cluster_subnet, "10.244.0.0/16"
-    assert_equal kubernetes.service_subnet, "10.96.0.0/12"
-    assert_equal kubernetes.ip, "0.0.0.0"
-    assert_equal kubernetes.endpoint, "455dcd32-e621-48ee-a10e-0cb5f754e13e.vultr-k8s.com"
-    assert_equal kubernetes.version, "v1.20.0+1"
-    assert_equal kubernetes.region, "lax"
-    assert_equal kubernetes.status, "pending"
-    assert_equal kubernetes.node_pools.class, Array
-  end
-
-  def test_retrieve
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("kubernetes/clusters/#{vke_id}", response: stub_response(fixture: "kubernetes/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    vke_cluster = client.kubernetes.retrieve(vke_id: vke_id)
-
-    assert_equal vke_cluster.id, "455dcd32-e621-48ee-a10e-0cb5f754e13e"
-    assert_equal vke_cluster.label, "vke"
-    assert_equal vke_cluster.date_created, Time.parse("2021-07-07T22:57:01+00:00")
-    assert_equal vke_cluster.cluster_subnet, "10.244.0.0/16"
-    assert_equal vke_cluster.service_subnet, "10.96.0.0/12"
-    assert_equal vke_cluster.ip, "207.246.109.187"
-    assert_equal vke_cluster.endpoint, "455dcd32-e621-48ee-a10e-0cb5f754e13e.vultr-k8s.com"
-    assert_equal vke_cluster.version, "v1.20.0+1"
-    assert_equal vke_cluster.region, "lax"
-    assert_equal vke_cluster.status, "active"
-    assert_equal vke_cluster.node_pools.class, Array
-  end
-
-  def test_update
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {label: "My New Label"}
-    stub = stub_request("kubernetes/clusters/#{vke_id}", method: :put, body: body, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.kubernetes.update(vke_id: vke_id, **body)
-  end
-
-  def test_delete
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("kubernetes/clusters/#{vke_id}", method: :delete, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-
-    assert client.kubernetes.delete(vke_id: vke_id)
-  end
-
-  def test_config
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/config", response: stub_response(fixture: "kubernetes/config"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    vke_cluster = client.kubernetes.config(vke_id: vke_id)
-
-    assert_equal vke_cluster.kube_config, "kube_config"
-  end
-
-  def test_list_resources
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/resources", response: stub_response(fixture: "kubernetes/list_resources"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    vke_cluster = client.kubernetes.list_resources(vke_id: vke_id)
-
-    assert_equal vke_cluster.block_storage.class, Array
-    assert_equal vke_cluster.load_balancer.class, Array
-  end
-
-  def test_list_node_pools
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools", response: stub_response(fixture: "kubernetes/list_node_pools"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    node_pools = client.kubernetes.list_node_pools(vke_id: vke_id)
-
-    assert_equal Vultr::Collection, node_pools.class
-    assert_equal Vultr::Object, node_pools.data.first.class
-    assert_equal 2, node_pools.total
-    assert_equal "next", node_pools.next_cursor
-    assert_equal "prev", node_pools.prev_cursor
-  end
-
-  def test_retrieve_node_pool
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    nodepool_id = "e97bdee9-2781-4f31-be03-60fc75f399ae"
-
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}", response: stub_response(fixture: "kubernetes/retrieve_node_pool"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    node_pool = client.kubernetes.retrieve_node_pool(vke_id: vke_id, nodepool_id: nodepool_id)
-
-    assert_equal node_pool.id, "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    assert_equal node_pool.date_created, Time.parse("2021-07-07T23:27:08+00:00")
-    assert_equal node_pool.date_updated, Time.parse("2021-07-08T12:12:44+00:00")
-    assert_equal node_pool.label, "my-label-48770703"
-    assert_equal node_pool.plan_id, "vc2-1c-2gb"
-    assert_equal node_pool.status, "active"
-    assert_equal node_pool.count, 2
-    assert_equal node_pool.nodes.class, Array
-  end
-
-  def test_create_node_pool
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {node_quantity: 2, label: "nodepool", paln: "vc2-lc-2gb"}
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools", method: :post, body: body, response: stub_response(fixture: "kubernetes/create_node_pool"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    node_pool = client.kubernetes.create_node_pool(vke_id: vke_id, **body)
-
-    assert_equal node_pool.id, "4130764b-5276-4552-546f-32513239732b"
-    assert_equal node_pool.date_created, Time.parse("2021-07-07T23:29:18+00:00")
-    assert_equal node_pool.date_updated, Time.parse("2021-07-08T23:29:18+00:00")
-    assert_equal node_pool.label, "nodepool-48770716"
-    assert_equal node_pool.plan_id, "vc2-1c-2gb"
-    assert_equal node_pool.status, "pending"
-    assert_equal node_pool.count, 2
-    assert_equal node_pool.nodes.class, Array
-  end
-
-  def test_update_node_pool
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    nodepool_id = "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    body = {node_quantity: 1}
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}", method: :patch, body: body, response: stub_response(fixture: "kubernetes/update_node_pool"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    node_pool = client.kubernetes.update_node_pool(vke_id: vke_id, nodepool_id: nodepool_id, **body)
-
-    assert_equal node_pool.id, "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    assert_equal node_pool.date_created, Time.parse("2021-07-07T23:27:08+00:00")
-    assert_equal node_pool.date_updated, Time.parse("2021-07-08T12:12:44+00:00")
-    assert_equal node_pool.label, "my-label-48770703"
-    assert_equal node_pool.plan_id, "vc2-1c-2gb"
-    assert_equal node_pool.status, "active"
-    assert_equal node_pool.count, 1
-    assert_equal node_pool.nodes.class, Array
-  end
-
-  def test_delete_node_pool
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    nodepool_id = "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}", method: :delete, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-
-    assert client.kubernetes.delete_node_pool(vke_id: vke_id, nodepool_id: nodepool_id)
-  end
-
-  def test_delete_node_pool_instance
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    nodepool_id = "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    node_id = "ab809b79-1358-4c59-8c8e-b73add699bf9"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}/nodes/#{node_id}", method: :delete, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-
-    assert client.kubernetes.delete_node_pool_instance(vke_id: vke_id, nodepool_id: nodepool_id, node_id: node_id)
-  end
-
-  def test_recycle_node_pool_instance
-    vke_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    nodepool_id = "e97bdee9-2781-4f31-be03-60fc75f399ae"
-    node_id = "ab809b79-1358-4c59-8c8e-b73add699bf9"
-    stub = stub_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}/nodes/#{node_id}/recycle", method: :post, response: {})
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-
-    assert client.kubernetes.recycle_node_pool_instance(vke_id: vke_id, nodepool_id: nodepool_id, node_id: node_id)
-  end
-end

data/test/vultr/resources/load_balancers_test.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class LoadBalancersResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("load-balancers", response: stub_response(fixture: "load_balancers/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    load_balancers = client.load_balancers.list
-
-    assert_equal Vultr::Collection, load_balancers.class
-    assert_equal Vultr::LoadBalancer, load_balancers.data.first.class
-    assert_equal 1, load_balancers.total
-  end
-
-  def test_create
-    body = {region: "ewr", balancing_algorithm: "roundrobin", label: "Example Load Balancer"}
-    stub = stub_request("load-balancers", method: :post, body: body, response: stub_response(fixture: "load_balancers/create"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    load_balancer = client.load_balancers.create(**body)
-
-    assert_equal Vultr::LoadBalancer, load_balancer.class
-    assert_equal "Example Load Balancer", load_balancer.label
-  end
-
-  def test_retrieve
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}", response: stub_response(fixture: "load_balancers/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    load_balancer = client.load_balancers.retrieve(load_balancer_id: load_balancer_id)
-
-    assert_equal Vultr::LoadBalancer, load_balancer.class
-    assert_equal "Example Load Balancer", load_balancer.label
-  end
-
-  def test_update
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {balancing_algorithm: "Changed"}
-    stub = stub_request("load-balancers/#{load_balancer_id}", method: :patch, body: body, response: stub_response(fixture: "load_balancers/update"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.load_balancers.update(load_balancer_id: load_balancer_id, **body)
-  end
-
-  def test_delete
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}", method: :delete, response: stub_response(fixture: "load_balancers/delete"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.load_balancers.delete(load_balancer_id: load_balancer_id)
-  end
-
-  def test_list_forwarding_rules
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}/forwarding-rules", response: stub_response(fixture: "load_balancers/list_forwarding_rules"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    forwarding_rules = client.load_balancers.list_forwarding_rules(load_balancer_id: load_balancer_id)
-
-    assert Vultr::Collection, forwarding_rules.class
-    assert Vultr::Object, forwarding_rules.data.first.class
-    assert 1, forwarding_rules.total
-  end
-
-  def test_create_forwarding_rule
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {frontend_protocol: "http", frontend_port: 8080, backend_protocol: "http", backend_port: 80}
-    stub = stub_request("load-balancers/#{load_balancer_id}/forwarding-rules", method: :post, body: body, response: stub_response(fixture: "load_balancers/create_forwarding_rule"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.load_balancers.create_forwarding_rule(load_balancer_id: load_balancer_id, **body)
-  end
-
-  def test_retrieve_forwarding_rule
-    load_balancer_id = "load-balancer-id"
-    forwarding_rule_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}/forwarding-rules/#{forwarding_rule_id}", response: stub_response(fixture: "load_balancers/retrieve_forwarding_rule"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    forwarding_rule = client.load_balancers.retrieve_forwarding_rule(load_balancer_id: load_balancer_id, forwarding_rule_id: forwarding_rule_id)
-
-    assert Vultr::Object, forwarding_rule.class
-    assert "http", forwarding_rule.frontend_protocol
-  end
-
-  def test_delete_forwarding_rule
-    load_balancer_id = "load-balancer-id"
-    forwarding_rule_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}/forwarding-rules/#{forwarding_rule_id}", method: :delete, response: stub_response(fixture: "load_balancers/delete_forwarding_rule"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.load_balancers.delete_forwarding_rule(load_balancer_id: load_balancer_id, forwarding_rule_id: forwarding_rule_id)
-  end
-
-  def test_list_firewall_rules
-    load_balancer_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}/firewall-rules", response: stub_response(fixture: "load_balancers/list_firewall_rules"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    firewall_rules = client.load_balancers.list_firewall_rules(load_balancer_id: load_balancer_id)
-
-    assert Vultr::Collection, firewall_rules.class
-    assert Vultr::Object, firewall_rules.data.first.class
-    assert 1, firewall_rules.total
-  end
-
-  def test_retrieve_firewall_rule
-    load_balancer_id = "load-balancer-id"
-    firewall_rule_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("load-balancers/#{load_balancer_id}/firewall-rules/#{firewall_rule_id}", response: stub_response(fixture: "load_balancers/retrieve_firewall_rule"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    firewall_rule = client.load_balancers.retrieve_firewall_rule(load_balancer_id: load_balancer_id, firewall_rule_id: firewall_rule_id)
-
-    assert Vultr::Object, firewall_rule
-    assert 80, firewall_rule.port
-  end
-end

data/test/vultr/resources/object_storage_test.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ObjectStorageResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("object-storage", response: stub_response(fixture: "object_storage/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    object_storage = client.object_storage.list
-
-    assert_equal Vultr::Collection, object_storage.class
-    assert_equal Vultr::ObjectStorage, object_storage.data.first.class
-    assert_equal 1, object_storage.total
-  end
-
-  def test_create
-    body = {label: "Example Object Storage", cluster_id: 2}
-    stub = stub_request("object-storage", method: :post, body: body, response: stub_response(fixture: "object_storage/create"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    object_storage = client.object_storage.create(**body)
-
-    assert_equal Vultr::ObjectStorage, object_storage.class
-    assert_equal "Example Object Storage", object_storage.label
-  end
-
-  def test_retrieve
-    object_storage_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("object-storage/#{object_storage_id}", response: stub_response(fixture: "object_storage/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    object_storage = client.object_storage.retrieve(object_storage_id: object_storage_id)
-
-    assert_equal Vultr::ObjectStorage, object_storage.class
-    assert_equal "Example Object Storage", object_storage.label
-  end
-
-  def test_update
-    object_storage_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {label: "Updated Object Storage Label"}
-    stub = stub_request("object-storage/#{object_storage_id}", method: :put, body: body, response: stub_response(fixture: "object_storage/create"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.object_storage.update(object_storage_id: object_storage_id, **body)
-  end
-
-  def test_delete
-    object_storage_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("object-storage/#{object_storage_id}", method: :delete, response: stub_response(fixture: "object_storage/delete"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.object_storage.delete(object_storage_id: object_storage_id)
-  end
-
-  def test_regenerate_keys
-    object_storage_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("object-storage/#{object_storage_id}/regenerate-keys", method: :post, response: stub_response(fixture: "object_storage/regenerate_keys", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    object_storage_keys = client.object_storage.regenerate_keys(object_storage_id: object_storage_id)
-
-    assert_equal "ewr1.vultrobjects.com", object_storage_keys.dig("s3_credentials", "s3_hostname")
-    assert_equal "00example11223344", object_storage_keys.dig("s3_credentials", "s3_access_key")
-    assert_equal "00example1122334455667788990011", object_storage_keys.dig("s3_credentials", "s3_secret_key")
-  end
-
-  def test_list_clusters
-    stub = stub_request("object-storage/clusters", response: stub_response(fixture: "object_storage/list_clusters"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    clusters = client.object_storage.list_clusters
-
-    assert_equal Vultr::Collection, clusters.class
-    assert_equal Vultr::Object, clusters.data.first.class
-    assert_equal 1, clusters.total
-  end
-end

data/test/vultr/resources/operating_systems_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class OperatingSystemsResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("os", response: stub_response(fixture: "operating_systems/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    operating_systems = client.operating_systems.list
-
-    assert_equal Vultr::Collection, operating_systems.class
-    assert_equal Vultr::OperatingSystem, operating_systems.data.first.class
-    assert_equal 1, operating_systems.total
-  end
-end

data/test/vultr/resources/plans_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class PlansResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("plans", response: stub_response(fixture: "plans/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    plans = client.plans.list
-
-    assert_equal Vultr::Collection, plans.class
-    assert_equal Vultr::Plan, plans.data.first.class
-    assert_equal 1, plans.total
-  end
-
-  def test_list_metal
-    stub = stub_request("plans-metal", response: stub_response(fixture: "plans/list_metal"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    plans = client.plans.list_metal
-
-    assert_equal Vultr::Collection, plans.class
-    assert_equal Vultr::Plan, plans.data.first.class
-    assert_equal 1, plans.total
-  end
-end

data/test/vultr/resources/private_networks_test.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class PrivateNetworksResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("private-networks", response: stub_response(fixture: "private_networks/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    private_networks = client.private_networks.list
-
-    assert_equal Vultr::Collection, private_networks.class
-    assert_equal Vultr::PrivateNetwork, private_networks.data.first.class
-    assert_equal 1, private_networks.total
-  end
-
-  def test_create
-    body = {region: "ewr", description: "Example Private Network", v4_subnet: "10.99.0.0", v4_subnet_mask: 24}
-    stub = stub_request("private-networks", method: :post, body: body, response: stub_response(fixture: "private_networks/create", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    private_network = client.private_networks.create(**body)
-
-    assert_equal Vultr::PrivateNetwork, private_network.class
-    assert_equal "Example Private Network", private_network.description
-  end
-
-  def test_retrieve
-    private_network_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("private-networks/#{private_network_id}", response: stub_response(fixture: "private_networks/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    private_network = client.private_networks.retrieve(network_id: private_network_id)
-
-    assert_equal Vultr::PrivateNetwork, private_network.class
-    assert_equal "Example Network Description", private_network.description
-  end
-
-  def test_update
-    private_network_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {description: "Example Private Network"}
-    stub = stub_request("private-networks/#{private_network_id}", method: :put, body: body, response: stub_response(fixture: "private_networks/update"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.private_networks.update(network_id: private_network_id, **body)
-  end
-
-  def test_delete
-    private_network_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("private-networks/#{private_network_id}", method: :delete, response: stub_response(fixture: "private_networks/delete"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.private_networks.delete(network_id: private_network_id)
-  end
-end

data/test/vultr/resources/regions_test.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class RegionsResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("regions", response: stub_response(fixture: "regions/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    regions = client.regions.list
-
-    assert_equal Vultr::Collection, regions.class
-    assert_equal Vultr::Region, regions.data.first.class
-    assert_equal 1, regions.total
-  end
-
-  def test_list_availability
-    region_id = "all"
-    stub = stub_request("regions/#{region_id}/availability", response: stub_response(fixture: "regions/list_availability"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    availabilities = client.regions.list_availability(region_id: region_id)
-
-    assert_equal Vultr::Object, availabilities.class
-    assert_equal availabilities.available_plans.first, "vc2-1c-1gb"
-    assert_equal availabilities.available_plans.size, 20
-  end
-end

data/test/vultr/resources/reserved_ips_test.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ReservedIpsResourceTest < Minitest::Test
-  def test_list
-    stub = stub_request("reserved-ips", response: stub_response(fixture: "reserved_ips/list"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    reserved_ips = client.reserved_ips.list
-
-    assert_equal Vultr::Collection, reserved_ips.class
-    assert_equal Vultr::ReservedIp, reserved_ips.data.first.class
-    assert_equal 2, reserved_ips.total
-  end
-
-  def test_create
-    body = {region: "ewr", ip_type: "v4", label: "Example Reserved IPv4"}
-    stub = stub_request("reserved-ips", method: :post, body: body, response: stub_response(fixture: "reserved_ips/create", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    reserved_ip = client.reserved_ips.create(**body)
-
-    assert_equal Vultr::ReservedIp, reserved_ip.class
-    assert_equal "Example Reserved IPv4", reserved_ip.label
-  end
-
-  def test_retrieve
-    reserved_ip_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("reserved-ips/#{reserved_ip_id}", response: stub_response(fixture: "reserved_ips/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    reserved_ip = client.reserved_ips.retrieve(reserved_ip: reserved_ip_id)
-
-    assert_equal Vultr::ReservedIp, reserved_ip.class
-    assert_equal "Example Reserved IPv4", reserved_ip.label
-  end
-
-  def test_delete
-    reserved_ip_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("reserved-ips/#{reserved_ip_id}", method: :delete, response: stub_response(fixture: "reserved_ips/retrieve"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.reserved_ips.delete(reserved_ip: reserved_ip_id)
-  end
-
-  def test_attach
-    reserved_ip_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    body = {instance_id: "3f26dfe9-6a18-4f3d-a543-0cbca7a3e496"}
-    stub = stub_request("reserved-ips/#{reserved_ip_id}/attach", method: :post, body: body, response: stub_response(fixture: "reserved_ips/attach"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.reserved_ips.attach(reserved_ip: reserved_ip_id, instance_id: body[:instance_id])
-  end
-
-  def test_detach
-    reserved_ip_id = "cb676a46-66fd-4dfb-b839-443f2e6c0b60"
-    stub = stub_request("reserved-ips/#{reserved_ip_id}/detach", method: :post, response: stub_response(fixture: "reserved_ips/attach"))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    assert client.reserved_ips.detach(reserved_ip: reserved_ip_id)
-  end
-
-  def test_convert
-    body = {ip_address: "192.0.2.123", label: "Example Reserved IPv4"}
-    stub = stub_request("reserved-ips/convert", method: :post, body: body, response: stub_response(fixture: "reserved_ips/convert", status: 201))
-    client = Vultr::Client.new(api_key: "fake", adapter: :test, stubs: stub)
-    reserved_ip = client.reserved_ips.convert(**body)
-
-    assert Vultr::ReservedIp, reserved_ip.class
-    assert "Example Resreved IPv4", reserved_ip.label
-  end
-end