diff --git a/test/unit/fixtures/instance_backups_get.json b/test/unit/fixtures/instance_backups_get.json new file mode 100644 index 000000000..99c0f8a12 --- /dev/null +++ b/test/unit/fixtures/instance_backups_get.json @@ -0,0 +1,28 @@ +{ + "automatic": [ + { + "id": 3, + "label": "auto-backup-1", + "status": "successful", + "created": "2025-02-05T08:00:00", + "available": true + }, + { + "id": 4, + "label": "auto-backup-2", + "status": "successful", + "created": "2025-02-06T08:00:00", + "available": true + } + ], + "snapshot": { + "current": { + "id": 5, + "label": "snapshot-current", + "status": "running", + "available": false + }, + "in_progress": null + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_clone.json b/test/unit/fixtures/instance_clone.json new file mode 100644 index 000000000..409956f15 --- /dev/null +++ b/test/unit/fixtures/instance_clone.json @@ -0,0 +1,8 @@ +{ + "id": 126, + "label": "cloned-instance", + "region": "us-east", + "type": "g6-standard-1", + "status": "provisioning" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_create.json b/test/unit/fixtures/instance_config_create.json new file mode 100644 index 000000000..5c0cafda2 --- /dev/null +++ b/test/unit/fixtures/instance_config_create.json @@ -0,0 +1,7 @@ +{ + "id": 3, + "label": "new-config", + "kernel": "linode/latest-64bit", + "root_device": "/dev/sda" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_get.json b/test/unit/fixtures/instance_config_get.json new file mode 100644 index 000000000..2b97e8b23 --- /dev/null +++ b/test/unit/fixtures/instance_config_get.json @@ -0,0 +1,7 @@ +{ + "id": 1, + "label": "config-1", + "kernel": "linode/latest-64bit", + "root_device": "/dev/sda" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_interface_create.json b/test/unit/fixtures/instance_config_interface_create.json new file mode 100644 index 000000000..708e03a64 --- /dev/null +++ b/test/unit/fixtures/instance_config_interface_create.json @@ -0,0 +1,16 @@ +{ + "id": 1, + "ipam_address": "192.168.1.2", + "label": "eth0", + "purpose": "vpc", + "primary": true, + "active": true, + "vpc_id": 100, + "subnet_id": 123, + "ipv4": { + "vpc": "10.0.0.1", + "nat_1_1": "192.168.1.1" + }, + "ip_ranges": ["192.168.1.0/24"] +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_interface_get.json b/test/unit/fixtures/instance_config_interface_get.json new file mode 100644 index 000000000..e981695b2 --- /dev/null +++ b/test/unit/fixtures/instance_config_interface_get.json @@ -0,0 +1,16 @@ +{ + "id": 1, + "ipam_address": "192.168.1.10", + "label": "eth0", + "purpose": "public", + "primary": true, + "active": true, + "vpc_id": 101, + "subnet_id": 202, + "ipv4": { + "vpc": "vpc-1", + "nat_1_1": "203.0.113.1" + }, + "ip_ranges": ["192.168.1.0/24"] +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_interface_list.json b/test/unit/fixtures/instance_config_interface_list.json new file mode 100644 index 000000000..ac94f3512 --- /dev/null +++ b/test/unit/fixtures/instance_config_interface_list.json @@ -0,0 +1,26 @@ +[ + { + "id": 1, + "ipam_address": "192.168.1.2", + "label": "eth0", + "purpose": "vpc", + "primary": true, + "active": true, + "vpc_id": 100, + "subnet_id": 123, + "ipv4": { + "vpc": "10.0.0.1", + "nat_1_1": "192.168.1.1" + }, + "ip_ranges": ["192.168.1.0/24"] + }, + { + "id": 2, + "ipam_address": "192.168.1.3", + "label": "eth1", + "purpose": "public", + "primary": false, + "active": true + } +] + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_interface_update.json b/test/unit/fixtures/instance_config_interface_update.json new file mode 100644 index 000000000..dadbbd229 --- /dev/null +++ b/test/unit/fixtures/instance_config_interface_update.json @@ -0,0 +1,16 @@ +{ + "id": 1, + "ipam_address": "192.168.1.10", + "label": "eth0", + "purpose": "public", + "primary": true, + "active": true, + "vpc_id": 101, + "subnet_id": 202, + "ipv4": { + "vpc": "vpc-2", + "nat_1_1": "203.0.113.3" + }, + "ip_ranges": ["192.168.1.0/24"] +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_list.json b/test/unit/fixtures/instance_config_list.json new file mode 100644 index 000000000..326654bc6 --- /dev/null +++ b/test/unit/fixtures/instance_config_list.json @@ -0,0 +1,20 @@ +{ + "data": [ + { + "id": 1, + "label": "config-1", + "kernel": "linode/latest-64bit", + "root_device": "/dev/sda" + }, + { + "id": 2, + "label": "config-2", + "kernel": "linode/latest-64bit", + "root_device": "/dev/sdb" + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_config_update.json b/test/unit/fixtures/instance_config_update.json new file mode 100644 index 000000000..943deb8af --- /dev/null +++ b/test/unit/fixtures/instance_config_update.json @@ -0,0 +1,7 @@ +{ + "id": 1, + "label": "updated-config", + "kernel": "linode/latest-64bit", + "root_device": "/dev/sdb" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_create.json b/test/unit/fixtures/instance_create.json new file mode 100644 index 000000000..96016819d --- /dev/null +++ b/test/unit/fixtures/instance_create.json @@ -0,0 +1,8 @@ +{ + "id": 125, + "label": "new-instance", + "region": "us-east", + "type": "g6-standard-1", + "status": "provisioning" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_disk_create.json b/test/unit/fixtures/instance_disk_create.json new file mode 100644 index 000000000..0ba8d48b7 --- /dev/null +++ b/test/unit/fixtures/instance_disk_create.json @@ -0,0 +1,10 @@ +{ + "id": 3, + "label": "New Disk", + "status": "ready", + "size": 20480, + "filesystem": "ext4", + "created": "2024-02-01T12:00:00", + "updated": "2024-02-01T12:00:00" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_disk_get.json b/test/unit/fixtures/instance_disk_get.json new file mode 100644 index 000000000..fba263aa6 --- /dev/null +++ b/test/unit/fixtures/instance_disk_get.json @@ -0,0 +1,10 @@ +{ + "id": 1, + "label": "Disk 1", + "status": "ready", + "size": 20480, + "filesystem": "ext4", + "created": "2024-01-01T12:00:00", + "updated": "2024-01-02T12:00:00" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_disk_list.json b/test/unit/fixtures/instance_disk_list.json new file mode 100644 index 000000000..22e3cc5ef --- /dev/null +++ b/test/unit/fixtures/instance_disk_list.json @@ -0,0 +1,26 @@ +{ + "data": [ + { + "id": 1, + "label": "Disk 1", + "status": "ready", + "size": 20480, + "filesystem": "ext4", + "created": "2024-01-01T12:00:00", + "updated": "2024-01-02T12:00:00" + }, + { + "id": 2, + "label": "Disk 2", + "status": "not ready", + "size": 10240, + "filesystem": "swap", + "created": "2024-01-03T12:00:00", + "updated": "2024-01-04T12:00:00" + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_disk_update.json b/test/unit/fixtures/instance_disk_update.json new file mode 100644 index 000000000..be62939fd --- /dev/null +++ b/test/unit/fixtures/instance_disk_update.json @@ -0,0 +1,10 @@ +{ + "id": 1, + "label": "Updated Disk", + "status": "ready", + "size": 20480, + "filesystem": "ext4", + "created": "2024-01-01T12:00:00", + "updated": "2024-02-10T12:00:00" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_firewall_list.json b/test/unit/fixtures/instance_firewall_list.json new file mode 100644 index 000000000..77fb61373 --- /dev/null +++ b/test/unit/fixtures/instance_firewall_list.json @@ -0,0 +1,26 @@ +{ + "data": [ + { + "id": 456, + "label": "firewall-1", + "status": "enabled", + "rules": { + "inbound": [], + "outbound": [] + } + }, + { + "id": 789, + "label": "firewall-2", + "status": "disabled", + "rules": { + "inbound": [], + "outbound": [] + } + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_get.json b/test/unit/fixtures/instance_get.json new file mode 100644 index 000000000..608a2ffb2 --- /dev/null +++ b/test/unit/fixtures/instance_get.json @@ -0,0 +1,21 @@ +{ + "id": 123, + "label": "linode123", + "status": "running", + "region": "us-east", + "type": "g6-standard-1", + "ipv4": ["203.0.113.1"], + "specs": { + "memory": 4096, + "cpus": 2, + "disk": 80000, + "transfer": 2000 + }, + "backups": { + "last_successful": "2018-01-01T00:01:01" + }, + "placement_group": { + "migrating_to": "2468" + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_ip_add.json b/test/unit/fixtures/instance_ip_add.json new file mode 100644 index 000000000..6f0932e72 --- /dev/null +++ b/test/unit/fixtures/instance_ip_add.json @@ -0,0 +1,11 @@ +{ + "address": "198.51.100.1", + "gateway": "198.51.100.254", + "subnet_mask": "255.255.255.0", + "prefix": 24, + "type": "ipv4", + "public": true, + "linode_id": 123, + "region": "us-west" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_ip_get.json b/test/unit/fixtures/instance_ip_get.json new file mode 100644 index 000000000..7832ce5d1 --- /dev/null +++ b/test/unit/fixtures/instance_ip_get.json @@ -0,0 +1,12 @@ +{ + "address": "192.0.2.1", + "gateway": "192.0.2.254", + "subnet_mask": "255.255.255.0", + "prefix": 24, + "type": "ipv4", + "public": true, + "rdns": "example.com", + "linode_id": 123, + "region": "us-east" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_ip_list.json b/test/unit/fixtures/instance_ip_list.json new file mode 100644 index 000000000..1deac52f9 --- /dev/null +++ b/test/unit/fixtures/instance_ip_list.json @@ -0,0 +1,35 @@ +{ + "ipv4": { + "public": [ + { + "address": "192.0.2.1", + "gateway": "192.0.2.254", + "subnet_mask": "255.255.255.0", + "prefix": 24, + "type": "ipv4", + "public": true, + "rdns": "example.com", + "linode_id": 123, + "region": "us-east" + } + ], + "private": [], + "shared": [], + "reserved": [], + "vpc": [] + }, + "ipv6": { + "link_local": { + "address": "fe80::1", + "gateway": "fe80::ff", + "prefix": 64 + }, + "slaac": { + "address": "2001:db8::1", + "gateway": "2001:db8::ff", + "prefix": 64 + }, + "global": [] + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_ip_reserved.json b/test/unit/fixtures/instance_ip_reserved.json new file mode 100644 index 000000000..a14521af4 --- /dev/null +++ b/test/unit/fixtures/instance_ip_reserved.json @@ -0,0 +1,11 @@ +{ + "address": "203.0.113.1", + "gateway": "203.0.113.254", + "subnet_mask": "255.255.255.0", + "prefix": 24, + "type": "ipv4", + "public": false, + "linode_id": 123, + "region": "us-central" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_ip_update.json b/test/unit/fixtures/instance_ip_update.json new file mode 100644 index 000000000..1fb0e540c --- /dev/null +++ b/test/unit/fixtures/instance_ip_update.json @@ -0,0 +1,12 @@ +{ + "address": "192.0.2.1", + "gateway": "192.0.2.254", + "subnet_mask": "255.255.255.0", + "prefix": 24, + "type": "ipv4", + "public": true, + "rdns": "custom.reverse.dns", + "linode_id": 123, + "region": "us-east" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_rebuild.json b/test/unit/fixtures/instance_rebuild.json new file mode 100644 index 000000000..d69c24067 --- /dev/null +++ b/test/unit/fixtures/instance_rebuild.json @@ -0,0 +1,5 @@ +{ + "id": 123, + "image": "linode/ubuntu22.04" +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_snapshot_create.json b/test/unit/fixtures/instance_snapshot_create.json new file mode 100644 index 000000000..260a6c786 --- /dev/null +++ b/test/unit/fixtures/instance_snapshot_create.json @@ -0,0 +1,17 @@ +{ + "id": 2, + "label": "new-snapshot", + "status": "pending", + "type": "manual", + "created": "2025-02-10T15:00:00", + "configs": ["config-1"], + "disks": [ + { + "label": "disk-1", + "size": 5120, + "filesystem": "ext4" + } + ], + "available": false +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_snapshot_get.json b/test/unit/fixtures/instance_snapshot_get.json new file mode 100644 index 000000000..d4dda6244 --- /dev/null +++ b/test/unit/fixtures/instance_snapshot_get.json @@ -0,0 +1,19 @@ +{ + "id": 1, + "label": "snapshot-1", + "status": "successful", + "type": "manual", + "created": "2025-02-01T10:00:00", + "updated": "2025-02-02T12:00:00", + "finished": "2025-02-02T12:30:00", + "configs": ["config-1", "config-2"], + "disks": [ + { + "label": "disk-1", + "size": 10240, + "filesystem": "ext4" + } + ], + "available": true +} + \ No newline at end of file diff --git a/test/unit/fixtures/instance_update.json b/test/unit/fixtures/instance_update.json new file mode 100644 index 000000000..433445e8d --- /dev/null +++ b/test/unit/fixtures/instance_update.json @@ -0,0 +1,4 @@ +{ + "id": 123, + "label": "updated-instance" +} diff --git a/test/unit/fixtures/instance_volume_list.json b/test/unit/fixtures/instance_volume_list.json new file mode 100644 index 000000000..67b13769b --- /dev/null +++ b/test/unit/fixtures/instance_volume_list.json @@ -0,0 +1,20 @@ +{ + "data": [ + { + "id": 1001, + "label": "volume-1", + "size": 50, + "status": "available" + }, + { + "id": 1002, + "label": "volume-2", + "size": 100, + "status": "resizing" + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/instance_backup_test.go b/test/unit/instance_backup_test.go new file mode 100644 index 000000000..827d3c3c9 --- /dev/null +++ b/test/unit/instance_backup_test.go @@ -0,0 +1,100 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestInstanceSnapshot_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_snapshot_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/backups/1", fixtureData) + + snapshot, err := base.Client.GetInstanceSnapshot(context.Background(), 123, 1) + assert.NoError(t, err) + assert.Equal(t, 1, snapshot.ID) + assert.Equal(t, "snapshot-1", snapshot.Label) + assert.Equal(t, linodego.SnapshotSuccessful, snapshot.Status) + assert.True(t, snapshot.Available) + assert.Len(t, snapshot.Configs, 2) +} + +func TestInstanceSnapshot_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_snapshot_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/backups", fixtureData) + + snapshot, err := base.Client.CreateInstanceSnapshot(context.Background(), 123, "new-snapshot") + assert.NoError(t, err) + assert.Equal(t, "new-snapshot", snapshot.Label) + assert.Equal(t, linodego.SnapshotPending, snapshot.Status) +} + +func TestInstanceBackups_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_backups_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/backups", fixtureData) + + backups, err := base.Client.GetInstanceBackups(context.Background(), 123) + assert.NoError(t, err) + assert.NotNil(t, backups) + assert.Len(t, backups.Automatic, 2) + assert.NotNil(t, backups.Snapshot) + assert.Equal(t, "auto-backup-1", backups.Automatic[0].Label) +} + +func TestInstanceBackups_Enable(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/backups/enable", nil) + + err := base.Client.EnableInstanceBackups(context.Background(), 123) + assert.NoError(t, err) +} + +func TestInstanceBackups_Cancel(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/backups/cancel", nil) + + err := base.Client.CancelInstanceBackups(context.Background(), 123) + assert.NoError(t, err) +} + +func TestInstanceBackup_Restore(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + restoreOptions := linodego.RestoreInstanceOptions{ + LinodeID: 456, + Overwrite: true, + } + + base.MockPost("linode/instances/123/backups/1/restore", nil) + + err := base.Client.RestoreInstanceBackup(context.Background(), 123, 1, restoreOptions) + assert.NoError(t, err) +} diff --git a/test/unit/instance_config_interfaces_test.go b/test/unit/instance_config_interfaces_test.go new file mode 100644 index 000000000..eb37e0862 --- /dev/null +++ b/test/unit/instance_config_interfaces_test.go @@ -0,0 +1,125 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestInstanceConfigInterface_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_interface_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/configs/456/interfaces", fixtureData) + + interfaces, err := base.Client.ListInstanceConfigInterfaces(context.Background(), 123, 456) + assert.NoError(t, err) + assert.Len(t, interfaces, 2) + + assert.Equal(t, 1, interfaces[0].ID) + assert.Equal(t, "eth0", interfaces[0].Label) +} + +func TestInstanceConfigInterface_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_interface_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/configs/456/interfaces/1", fixtureData) + + iface, err := base.Client.GetInstanceConfigInterface(context.Background(), 123, 456, 1) + assert.NoError(t, err) + assert.Equal(t, 1, iface.ID) + assert.Equal(t, "eth0", iface.Label) +} + +func TestInstanceConfigInterface_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_interface_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + subnetID := 123 + nat1to1 := "192.168.1.1" + + createOptions := linodego.InstanceConfigInterfaceCreateOptions{ + Label: "eth0", + Purpose: linodego.InterfacePurposeVPC, + Primary: true, + SubnetID: &subnetID, + IPv4: &linodego.VPCIPv4{ + NAT1To1: &nat1to1, + }, + IPRanges: []string{"192.168.1.0/24"}, + } + + base.MockPost("linode/instances/123/configs/456/interfaces", fixtureData) + + iface, err := base.Client.AppendInstanceConfigInterface(context.Background(), 123, 456, createOptions) + assert.NoError(t, err) + assert.Equal(t, "eth0", iface.Label) + assert.True(t, iface.Primary) +} + +func TestInstanceConfigInterface_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_interface_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + nat1to1 := "192.168.1.1" + ipRanges := []string{"192.168.1.0/24"} + + updateOptions := linodego.InstanceConfigInterfaceUpdateOptions{ + Primary: true, + IPv4: &linodego.VPCIPv4{ + NAT1To1: &nat1to1, + }, + IPRanges: &ipRanges, + } + + base.MockPut("linode/instances/123/configs/456/interfaces/1", fixtureData) + + iface, err := base.Client.UpdateInstanceConfigInterface(context.Background(), 123, 456, 1, updateOptions) + assert.NoError(t, err) + assert.True(t, iface.Primary) +} + +func TestInstanceConfigInterface_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("linode/instances/123/configs/456/interfaces/1", nil) + + err := base.Client.DeleteInstanceConfigInterface(context.Background(), 123, 456, 1) + assert.NoError(t, err) +} + +func TestInstanceConfigInterface_Reorder(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + reorderOptions := linodego.InstanceConfigInterfacesReorderOptions{ + IDs: []int{3, 1, 2}, + } + + base.MockPost("linode/instances/123/configs/456/interfaces/order", nil) + + err := base.Client.ReorderInstanceConfigInterfaces(context.Background(), 123, 456, reorderOptions) + assert.NoError(t, err) +} diff --git a/test/unit/instance_config_test.go b/test/unit/instance_config_test.go new file mode 100644 index 000000000..524130986 --- /dev/null +++ b/test/unit/instance_config_test.go @@ -0,0 +1,97 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestInstanceConfig_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/configs", fixtureData) + + configs, err := base.Client.ListInstanceConfigs(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, configs, 2) + + assert.Equal(t, 1, configs[0].ID) + assert.Equal(t, "config-1", configs[0].Label) +} + +func TestInstanceConfig_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/configs/1", fixtureData) + + config, err := base.Client.GetInstanceConfig(context.Background(), 123, 1) + assert.NoError(t, err) + assert.Equal(t, 1, config.ID) + assert.Equal(t, "config-1", config.Label) +} + +func TestInstanceConfig_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + rootDevice := "/dev/sda" + + createOptions := linodego.InstanceConfigCreateOptions{ + Label: "new-config", + Kernel: "linode/latest-64bit", + RootDevice: &rootDevice, + } + + base.MockPost("linode/instances/123/configs", fixtureData) + + config, err := base.Client.CreateInstanceConfig(context.Background(), 123, createOptions) + assert.NoError(t, err) + assert.Equal(t, "new-config", config.Label) +} + +func TestInstanceConfig_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_config_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.InstanceConfigUpdateOptions{ + Label: "updated-config", + RootDevice: "/dev/sdb", + } + + base.MockPut("linode/instances/123/configs/1", fixtureData) + + config, err := base.Client.UpdateInstanceConfig(context.Background(), 123, 1, updateOptions) + assert.NoError(t, err) + assert.Equal(t, "updated-config", config.Label) +} + +func TestInstanceConfig_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("linode/instances/123/configs/1", nil) + + err := base.Client.DeleteInstanceConfig(context.Background(), 123, 1) + assert.NoError(t, err) +} diff --git a/test/unit/instance_disks_test.go b/test/unit/instance_disks_test.go index 2363a5592..d960e5471 100644 --- a/test/unit/instance_disks_test.go +++ b/test/unit/instance_disks_test.go @@ -29,3 +29,133 @@ func TestInstance_Disks_Clone(t *testing.T) { assert.Equal(t, 48640, disk.Size) assert.Equal(t, linodego.DiskStatus("ready"), disk.Status) } + +func TestInstanceDisk_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_disk_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/disks", fixtureData) + + disks, err := base.Client.ListInstanceDisks(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, disks, 2) + + assert.Equal(t, 1, disks[0].ID) + assert.Equal(t, "Disk 1", disks[0].Label) + assert.Equal(t, linodego.DiskReady, disks[0].Status) + assert.Equal(t, 20480, disks[0].Size) + assert.Equal(t, linodego.FilesystemExt4, disks[0].Filesystem) +} + +func TestInstanceDisk_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_disk_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/disks/1", fixtureData) + + disk, err := base.Client.GetInstanceDisk(context.Background(), 123, 1) + assert.NoError(t, err) + + assert.Equal(t, 1, disk.ID) + assert.Equal(t, "Disk 1", disk.Label) + assert.Equal(t, linodego.DiskReady, disk.Status) + assert.Equal(t, 20480, disk.Size) + assert.Equal(t, linodego.FilesystemExt4, disk.Filesystem) + assert.NotNil(t, disk.Created) + assert.NotNil(t, disk.Updated) +} + +func TestInstanceDisk_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_disk_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.InstanceDiskCreateOptions{ + Label: "New Disk", + Size: 20480, + Filesystem: "ext4", + } + + base.MockPost("linode/instances/123/disks", fixtureData) + + disk, err := base.Client.CreateInstanceDisk(context.Background(), 123, createOptions) + assert.NoError(t, err) + + assert.Equal(t, 3, disk.ID) + assert.Equal(t, "New Disk", disk.Label) + assert.Equal(t, linodego.DiskReady, disk.Status) + assert.Equal(t, 20480, disk.Size) + assert.Equal(t, linodego.FilesystemExt4, disk.Filesystem) + assert.NotNil(t, disk.Created) + assert.NotNil(t, disk.Updated) +} + +func TestInstanceDisk_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_disk_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.InstanceDiskUpdateOptions{ + Label: "Updated Disk", + } + + base.MockPut("linode/instances/123/disks/1", fixtureData) + + disk, err := base.Client.UpdateInstanceDisk(context.Background(), 123, 1, updateOptions) + assert.NoError(t, err) + + assert.Equal(t, 1, disk.ID) + assert.Equal(t, "Updated Disk", disk.Label) + assert.Equal(t, linodego.DiskReady, disk.Status) + assert.Equal(t, 20480, disk.Size) + assert.Equal(t, linodego.FilesystemExt4, disk.Filesystem) + assert.NotNil(t, disk.Created) + assert.NotNil(t, disk.Updated) +} + +func TestInstanceDisk_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("linode/instances/123/disks/1", nil) + + err := base.Client.DeleteInstanceDisk(context.Background(), 123, 1) + assert.NoError(t, err) +} + +func TestInstanceDisk_Resize(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/disks/1/resize", nil) + + err := base.Client.ResizeInstanceDisk(context.Background(), 123, 1, 40960) + assert.NoError(t, err) +} + +func TestInstanceDisk_PasswordReset(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/disks/1/password", nil) + + err := base.Client.PasswordResetInstanceDisk(context.Background(), 123, 1, "new-password") + assert.NoError(t, err) +} diff --git a/test/unit/instance_firewall_test.go b/test/unit/instance_firewall_test.go new file mode 100644 index 000000000..82881e43b --- /dev/null +++ b/test/unit/instance_firewall_test.go @@ -0,0 +1,29 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInstanceFirewalls_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_firewall_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/firewalls", fixtureData) + + firewalls, err := base.Client.ListInstanceFirewalls(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, firewalls, 2) + + assert.Equal(t, 456, firewalls[0].ID) + assert.Equal(t, "firewall-1", firewalls[0].Label) + + assert.Equal(t, 789, firewalls[1].ID) + assert.Equal(t, "firewall-2", firewalls[1].Label) +} diff --git a/test/unit/instance_ip_test.go b/test/unit/instance_ip_test.go new file mode 100644 index 000000000..fd169a62b --- /dev/null +++ b/test/unit/instance_ip_test.go @@ -0,0 +1,125 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestInstanceIPAddresses_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_ip_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/ips", fixtureData) + + ips, err := base.Client.GetInstanceIPAddresses(context.Background(), 123) + assert.NoError(t, err) + assert.NotNil(t, ips) + assert.NotNil(t, ips.IPv4) + assert.NotNil(t, ips.IPv6) + + // IPv4 Assertions + assert.Len(t, ips.IPv4.Public, 1) + assert.Equal(t, "192.0.2.1", ips.IPv4.Public[0].Address) + + // IPv6 Assertions + assert.NotNil(t, ips.IPv6.SLAAC) + assert.Equal(t, "2001:db8::1", ips.IPv6.SLAAC.Address) +} + +func TestInstanceIPAddress_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_ip_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/ips/192.0.2.1", fixtureData) + + ip, err := base.Client.GetInstanceIPAddress(context.Background(), 123, "192.0.2.1") + assert.NoError(t, err) + assert.NotNil(t, ip) + assert.Equal(t, "192.0.2.1", ip.Address) + assert.Equal(t, "192.0.2.254", ip.Gateway) + assert.Equal(t, 24, ip.Prefix) + assert.True(t, ip.Public) +} + +func TestInstanceIPAddress_Add(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_ip_add") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/ips", fixtureData) + + ip, err := base.Client.AddInstanceIPAddress(context.Background(), 123, true) + assert.NoError(t, err) + assert.NotNil(t, ip) + assert.Equal(t, "198.51.100.1", ip.Address) + assert.True(t, ip.Public) +} + +func TestInstanceIPAddress_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_ip_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + rdns := "custom.reverse.dns" + updateOpts := linodego.IPAddressUpdateOptions{ + RDNS: &rdns, + } + + base.MockPut("linode/instances/123/ips/192.0.2.1", fixtureData) + + ip, err := base.Client.UpdateInstanceIPAddress(context.Background(), 123, "192.0.2.1", updateOpts) + assert.NoError(t, err) + assert.NotNil(t, ip) + assert.Equal(t, "custom.reverse.dns", ip.RDNS) +} + +func TestInstanceIPAddress_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("linode/instances/123/ips/192.0.2.1", nil) + + err := base.Client.DeleteInstanceIPAddress(context.Background(), 123, "192.0.2.1") + assert.NoError(t, err) +} + +func TestInstanceReservedIP_Assign(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_ip_reserved") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + opts := linodego.InstanceReserveIPOptions{ + Type: "ipv4", + Public: false, + Address: "203.0.113.1", + } + + base.MockPost("linode/instances/123/ips", fixtureData) + + ip, err := base.Client.AssignInstanceReservedIP(context.Background(), 123, opts) + assert.NoError(t, err) + assert.NotNil(t, ip) + assert.Equal(t, "203.0.113.1", ip.Address) + assert.False(t, ip.Public) +} diff --git a/test/unit/instance_test.go b/test/unit/instance_test.go index c04e19e55..2cfb334da 100644 --- a/test/unit/instance_test.go +++ b/test/unit/instance_test.go @@ -2,6 +2,7 @@ package unit import ( "context" + "fmt" "testing" "github.com/jarcoal/httpmock" @@ -10,7 +11,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestListInstances(t *testing.T) { +func TestInstances_List(t *testing.T) { fixtures := NewTestFixtures() fixtureData, err := fixtures.GetFixture("linodes_list") @@ -42,6 +43,37 @@ func TestListInstances(t *testing.T) { assert.Equal(t, "2468", linode.PlacementGroup.MigratingTo) } +func TestInstance_Get(t *testing.T) { + fixtures := NewTestFixtures() + + fixtureData, err := fixtures.GetFixture("instance_get") + if err != nil { + t.Fatalf("Failed to load fixture: %v", err) + } + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + instanceID := 123 + base.MockGet(fmt.Sprintf("linode/instances/%d", instanceID), fixtureData) + + instance, err := base.Client.GetInstance(context.Background(), instanceID) + if err != nil { + t.Fatalf("Error fetching instance: %v", err) + } + + assert.Equal(t, 123, instance.ID) + assert.Equal(t, "linode123", instance.Label) + assert.Equal(t, "running", string(instance.Status)) + assert.Equal(t, "203.0.113.1", instance.IPv4[0].String()) + assert.Equal(t, "g6-standard-1", instance.Type) + assert.Equal(t, "us-east", instance.Region) + assert.Equal(t, 4096, instance.Specs.Memory) + assert.Equal(t, "2018-01-01 00:01:01 +0000 UTC", instance.Backups.LastSuccessful.String()) + assert.Equal(t, "2468", instance.PlacementGroup.MigratingTo) +} + func TestInstance_Migrate(t *testing.T) { client := createMockClient(t) @@ -106,3 +138,146 @@ func TestInstance_Upgrade(t *testing.T) { }) assert.NoError(t, err) } + +func TestInstance_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.InstanceCreateOptions{ + Region: "us-east", + Type: "g6-standard-1", + Label: "new-instance", + Image: "linode/ubuntu22.04", + RootPass: "securepassword", + } + + base.MockPost("linode/instances", fixtureData) + + instance, err := base.Client.CreateInstance(context.Background(), createOptions) + assert.NoError(t, err) + assert.Equal(t, "new-instance", instance.Label) +} + +func TestInstance_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.InstanceUpdateOptions{ + Label: "updated-instance", + } + + base.MockPut("linode/instances/123", fixtureData) + + instance, err := base.Client.UpdateInstance(context.Background(), 123, updateOptions) + assert.NoError(t, err) + assert.Equal(t, "updated-instance", instance.Label) +} + +func TestInstance_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("linode/instances/123", nil) + + err := base.Client.DeleteInstance(context.Background(), 123) + assert.NoError(t, err) +} + +func TestInstance_Boot(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/boot", nil) + + err := base.Client.BootInstance(context.Background(), 123, 0) + assert.NoError(t, err) +} + +func TestInstance_Reboot(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/instances/123/reboot", nil) + + err := base.Client.RebootInstance(context.Background(), 123, 0) + assert.NoError(t, err) +} + +func TestInstance_Clone(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_clone") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + cloneOptions := linodego.InstanceCloneOptions{ + Region: "us-east", + Type: "g6-standard-1", + Label: "cloned-instance", + } + + base.MockPost("linode/instances/123/clone", fixtureData) + + instance, err := base.Client.CloneInstance(context.Background(), 123, cloneOptions) + assert.NoError(t, err) + assert.Equal(t, "cloned-instance", instance.Label) +} + +func TestInstance_Resize(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + resizeOptions := linodego.InstanceResizeOptions{ + Type: "g6-standard-2", + } + + base.MockPost("linode/instances/123/resize", "{}") + + err := base.Client.ResizeInstance(context.Background(), 123, resizeOptions) + assert.NoError(t, err) +} + +func TestInstance_Rescue(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + rescueOptions := linodego.InstanceRescueOptions{} + + base.MockPost("linode/instances/123/rescue", nil) + + err := base.Client.RescueInstance(context.Background(), 123, rescueOptions) + assert.NoError(t, err) +} + +func TestInstance_Rebuild(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_rebuild") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + rebuildOptions := linodego.InstanceRebuildOptions{ + Image: "linode/ubuntu22.04", + } + + base.MockPost("linode/instances/123/rebuild", fixtureData) + + instance, err := base.Client.RebuildInstance(context.Background(), 123, rebuildOptions) + assert.NoError(t, err) + assert.Equal(t, "linode/ubuntu22.04", instance.Image) +} diff --git a/test/unit/instance_volume_test.go b/test/unit/instance_volume_test.go new file mode 100644 index 000000000..ded1963fe --- /dev/null +++ b/test/unit/instance_volume_test.go @@ -0,0 +1,36 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestInstanceVolumes_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("instance_volume_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("linode/instances/123/volumes", fixtureData) + + volumes, err := base.Client.ListInstanceVolumes(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, volumes, 2) + + // Validate first volume + assert.Equal(t, 1001, volumes[0].ID) + assert.Equal(t, "volume-1", volumes[0].Label) + assert.Equal(t, 50, volumes[0].Size) + assert.Equal(t, linodego.VolumeStatus("available"), volumes[0].Status) + + // Validate second volume + assert.Equal(t, 1002, volumes[1].ID) + assert.Equal(t, "volume-2", volumes[1].Label) + assert.Equal(t, 100, volumes[1].Size) + assert.Equal(t, linodego.VolumeStatus("resizing"), volumes[1].Status) +}