vultr 0.4.3 → 2.0.0

data/test/vultr/resources/iso_test.rb

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,185 @@
+# 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

@@ -0,0 +1,110 @@
+# 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

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,67 @@
+# 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