From b47f1e746f6005c2ca6c843c8d1f1b78551df08c Mon Sep 17 00:00:00 2001 From: vshanthe Date: Wed, 5 Feb 2025 11:01:24 +0530 Subject: [PATCH] network tests --- .../unit/fixtures/network_ip_address_get.json | 5 + .../fixtures/network_ip_addresses_list.json | 16 +++ .../unit/fixtures/network_ipv6_pools_get.json | 8 ++ .../fixtures/network_ipv6_pools_list.json | 15 +++ .../fixtures/network_ipv6_ranges_create.json | 8 ++ .../fixtures/network_ipv6_ranges_get.json | 8 ++ .../fixtures/network_ipv6_ranges_list.json | 15 +++ test/unit/fixtures/network_reserved_ips.json | 9 ++ .../fixtures/network_reserved_ips_get.json | 9 ++ .../fixtures/network_reserved_ips_list.json | 23 ++++ test/unit/network_ips_test.go | 88 ++++++++++++++ test/unit/network_ipv6_pools_test.go | 71 +++++++++++ test/unit/network_ranges_test.go | 113 +++++++++++++++++ test/unit/network_reserved_ips_test.go | 115 ++++++++++++++++++ 14 files changed, 503 insertions(+) create mode 100644 test/unit/fixtures/network_ip_address_get.json create mode 100644 test/unit/fixtures/network_ip_addresses_list.json create mode 100644 test/unit/fixtures/network_ipv6_pools_get.json create mode 100644 test/unit/fixtures/network_ipv6_pools_list.json create mode 100644 test/unit/fixtures/network_ipv6_ranges_create.json create mode 100644 test/unit/fixtures/network_ipv6_ranges_get.json create mode 100644 test/unit/fixtures/network_ipv6_ranges_list.json create mode 100644 test/unit/fixtures/network_reserved_ips.json create mode 100644 test/unit/fixtures/network_reserved_ips_get.json create mode 100644 test/unit/fixtures/network_reserved_ips_list.json create mode 100644 test/unit/network_ips_test.go create mode 100644 test/unit/network_ipv6_pools_test.go create mode 100644 test/unit/network_ranges_test.go create mode 100644 test/unit/network_reserved_ips_test.go diff --git a/test/unit/fixtures/network_ip_address_get.json b/test/unit/fixtures/network_ip_address_get.json new file mode 100644 index 000000000..cc4beded2 --- /dev/null +++ b/test/unit/fixtures/network_ip_address_get.json @@ -0,0 +1,5 @@ +{ + "address": "192.168.1.1", + "linode_id": 12345, + "reserved": false +} diff --git a/test/unit/fixtures/network_ip_addresses_list.json b/test/unit/fixtures/network_ip_addresses_list.json new file mode 100644 index 000000000..0579d1e8a --- /dev/null +++ b/test/unit/fixtures/network_ip_addresses_list.json @@ -0,0 +1,16 @@ +{ + "data": [ + { + "address": "192.168.1.1", + "linode_id": 12345, + "reserved": false + }, + { + "address": "192.168.1.2", + "linode_id": 67890, + "reserved": true + } + ], + "pages": 1, + "results": 2 +} diff --git a/test/unit/fixtures/network_ipv6_pools_get.json b/test/unit/fixtures/network_ipv6_pools_get.json new file mode 100644 index 000000000..98ae4b99e --- /dev/null +++ b/test/unit/fixtures/network_ipv6_pools_get.json @@ -0,0 +1,8 @@ +{ + "range": "2600:3c00::/64", + "region": "us-east", + "prefix": 64, + "route_target": "2600:3c00::1", + "is_bgp": false, + "linodes": [54321] +} \ No newline at end of file diff --git a/test/unit/fixtures/network_ipv6_pools_list.json b/test/unit/fixtures/network_ipv6_pools_list.json new file mode 100644 index 000000000..3bc30955e --- /dev/null +++ b/test/unit/fixtures/network_ipv6_pools_list.json @@ -0,0 +1,15 @@ +{ + "data": [ + { + "range": "2600:3c00::/64", + "region": "us-east", + "prefix": 64, + "route_target": "2600:3c00::1", + "is_bgp": true, + "linodes": [12345, 67890] + } + ], + "pages": 1, + "page": 1, + "results": 1 +} \ No newline at end of file diff --git a/test/unit/fixtures/network_ipv6_ranges_create.json b/test/unit/fixtures/network_ipv6_ranges_create.json new file mode 100644 index 000000000..433a908b3 --- /dev/null +++ b/test/unit/fixtures/network_ipv6_ranges_create.json @@ -0,0 +1,8 @@ +{ + "range": "2600:3c00::/64", + "region": "us-east", + "prefix": 64, + "route_target": "2600:3c00::1", + "is_bgp": false, + "linodes": [12345] +} \ No newline at end of file diff --git a/test/unit/fixtures/network_ipv6_ranges_get.json b/test/unit/fixtures/network_ipv6_ranges_get.json new file mode 100644 index 000000000..9e5070971 --- /dev/null +++ b/test/unit/fixtures/network_ipv6_ranges_get.json @@ -0,0 +1,8 @@ +{ + "range": "2600:3c00::/64", + "region": "us-east", + "prefix": 64, + "route_target": "2600:3c00::1", + "is_bgp": false, + "linodes": [54321] +} \ No newline at end of file diff --git a/test/unit/fixtures/network_ipv6_ranges_list.json b/test/unit/fixtures/network_ipv6_ranges_list.json new file mode 100644 index 000000000..b5773dac9 --- /dev/null +++ b/test/unit/fixtures/network_ipv6_ranges_list.json @@ -0,0 +1,15 @@ +{ + "data": [ + { + "range": "2600:3c00::/64", + "region": "us-east", + "prefix": 64, + "route_target": "2600:3c00::1", + "is_bgp": true, + "linodes": [12345, 67890] + } + ], + "pages": 1, + "results": 1 +} + \ No newline at end of file diff --git a/test/unit/fixtures/network_reserved_ips.json b/test/unit/fixtures/network_reserved_ips.json new file mode 100644 index 000000000..7f111de9f --- /dev/null +++ b/test/unit/fixtures/network_reserved_ips.json @@ -0,0 +1,9 @@ +{ + "address": "192.168.1.30", + "region": "us-west", + "linode_id": 13579, + "label": "test-ip-3", + "created": "2025-02-03T12:00:00", + "status": "reserved" +} + \ No newline at end of file diff --git a/test/unit/fixtures/network_reserved_ips_get.json b/test/unit/fixtures/network_reserved_ips_get.json new file mode 100644 index 000000000..7bfb54e56 --- /dev/null +++ b/test/unit/fixtures/network_reserved_ips_get.json @@ -0,0 +1,9 @@ +{ + "address": "192.168.1.10", + "region": "us-east", + "linode_id": 12345, + "label": "test-ip-1", + "created": "2025-02-03T12:00:00", + "status": "reserved" +} + \ No newline at end of file diff --git a/test/unit/fixtures/network_reserved_ips_list.json b/test/unit/fixtures/network_reserved_ips_list.json new file mode 100644 index 000000000..79112fe65 --- /dev/null +++ b/test/unit/fixtures/network_reserved_ips_list.json @@ -0,0 +1,23 @@ +{ + "data": [ + { + "address": "192.168.1.10", + "region": "us-east", + "linode_id": 12345, + "label": "test-ip-1", + "created": "2025-02-03T12:00:00", + "status": "reserved" + }, + { + "address": "192.168.1.20", + "region": "us-west", + "linode_id": 67890, + "label": "test-ip-2", + "created": "2025-02-03T12:00:00", + "status": "reserved" + } + ], + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/network_ips_test.go b/test/unit/network_ips_test.go new file mode 100644 index 000000000..e7e7994d6 --- /dev/null +++ b/test/unit/network_ips_test.go @@ -0,0 +1,88 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/linode/linodego" +) + +func TestIPUpdateAddressV2(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + ip := "192.168.1.1" + + // Mock API response + base.MockPut("networking/ips/"+ip, linodego.InstanceIP{ + Address: ip, + Reserved: true, + }) + + updatedIP, err := base.Client.UpdateIPAddressV2(context.Background(), ip, linodego.IPAddressUpdateOptionsV2{ + Reserved: linodego.Pointer(true), + }) + assert.NoError(t, err, "Expected no error when updating IP address") + assert.NotNil(t, updatedIP, "Expected non-nil updated IP address") + assert.Equal(t, ip, updatedIP.Address, "Expected updated IP address to match") + assert.True(t, updatedIP.Reserved, "Expected Reserved to be true") +} + +func TestIPAllocateReserve(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock API response + base.MockPost("networking/ips", linodego.InstanceIP{ + Address: "192.168.1.3", + Region: "us-east", + Public: true, + }) + + ip, err := base.Client.AllocateReserveIP(context.Background(), linodego.AllocateReserveIPOptions{ + Type: "ipv4", + Public: true, + Region: "us-east", + LinodeID: 12345, + }) + assert.NoError(t, err, "Expected no error when allocating reserve IP") + assert.NotNil(t, ip, "Expected non-nil allocated IP") + assert.Equal(t, "192.168.1.3", ip.Address, "Expected allocated IP address to match") + assert.Equal(t, "us-east", ip.Region, "Expected Region to match") + assert.True(t, ip.Public, "Expected Public to be true") +} + +func TestIPAssignInstances(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock API response + base.MockPost("networking/ips/assign", nil) + + err := base.Client.InstancesAssignIPs(context.Background(), linodego.LinodesAssignIPsOptions{ + Region: "us-east", + Assignments: []linodego.LinodeIPAssignment{ + {Address: "192.168.1.10", LinodeID: 123}, + }, + }) + assert.NoError(t, err, "Expected no error when assigning IPs to instances") +} + +func TestIPShareAddresses(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock API response + base.MockPost("networking/ips/share", nil) + + err := base.Client.ShareIPAddresses(context.Background(), linodego.IPAddressesShareOptions{ + IPs: []string{"192.168.1.20"}, + LinodeID: 456, + }) + assert.NoError(t, err, "Expected no error when sharing IP addresses") +} diff --git a/test/unit/network_ipv6_pools_test.go b/test/unit/network_ipv6_pools_test.go new file mode 100644 index 000000000..1cf4ff080 --- /dev/null +++ b/test/unit/network_ipv6_pools_test.go @@ -0,0 +1,71 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/linode/linodego" +) + +func TestIPListIPv6Pools(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + mockResponse := struct { + Data []linodego.IPv6Range `json:"data"` + }{ + Data: []linodego.IPv6Range{ + { + Range: "2600:3c00::/64", + Region: "us-east", + Prefix: 64, + RouteTarget: "2600:3c00::1", + IsBGP: true, + Linodes: []int{12345, 67890}, + }, + }, + } + + base.MockGet("networking/ipv6/pools", mockResponse) + + pools, err := base.Client.ListIPv6Pools(context.Background(), nil) + + assert.NoError(t, err, "Expected no error when listing IPv6 pools") + assert.NotNil(t, pools, "Expected non-nil IPv6 pools response") + assert.Len(t, pools, 1, "Expected one IPv6 pool in response") + assert.Equal(t, "2600:3c00::/64", pools[0].Range, "Expected matching IPv6 range") + assert.Equal(t, "us-east", pools[0].Region, "Expected matching region") + assert.Equal(t, 64, pools[0].Prefix, "Expected matching prefix length") + assert.Equal(t, "2600:3c00::1", pools[0].RouteTarget, "Expected matching route target") + assert.True(t, pools[0].IsBGP, "Expected IsBGP to be true") + assert.ElementsMatch(t, []int{12345, 67890}, pools[0].Linodes, "Expected matching Linodes list") +} + +func TestIPGetIPv6Pool(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + id := "1" + mockResponse := linodego.IPv6Range{ + Range: "2600:3c00::/64", + Region: "us-east", + Prefix: 64, + RouteTarget: "2600:3c00::1", + IsBGP: false, + Linodes: []int{54321}, + } + base.MockGet("networking/ipv6/pools/"+id, mockResponse) + + pool, err := base.Client.GetIPv6Pool(context.Background(), id) + assert.NoError(t, err, "Expected no error when getting IPv6 pool") + assert.NotNil(t, pool, "Expected non-nil IPv6 pool response") + assert.Equal(t, "2600:3c00::/64", pool.Range, "Expected matching IPv6 range") + assert.Equal(t, "us-east", pool.Region, "Expected matching region") + assert.Equal(t, 64, pool.Prefix, "Expected matching prefix length") + assert.Equal(t, "2600:3c00::1", pool.RouteTarget, "Expected matching route target") + assert.False(t, pool.IsBGP, "Expected IsBGP to be false") + assert.ElementsMatch(t, []int{54321}, pool.Linodes, "Expected matching Linodes list") +} diff --git a/test/unit/network_ranges_test.go b/test/unit/network_ranges_test.go new file mode 100644 index 000000000..e64f0624d --- /dev/null +++ b/test/unit/network_ranges_test.go @@ -0,0 +1,113 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/linode/linodego" +) + +func TestIPListIPv6Ranges(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock response for the GET request + mockResponse := struct { + Data []linodego.IPv6Range `json:"data"` + }{ + Data: []linodego.IPv6Range{ + { + Range: "2600:3c00::/64", + Region: "us-east", + Prefix: 64, + RouteTarget: "2600:3c00::1", + IsBGP: true, + Linodes: []int{12345, 67890}, + }, + }, + } + + base.MockGet("networking/ipv6/ranges", mockResponse) + + ranges, err := base.Client.ListIPv6Ranges(context.Background(), nil) + + assert.NoError(t, err, "Expected no error when listing IPv6 ranges") + assert.NotNil(t, ranges, "Expected non-nil IPv6 ranges response") + assert.Len(t, ranges, 1, "Expected one IPv6 range in response") + assert.Equal(t, "2600:3c00::/64", ranges[0].Range, "Expected matching IPv6 range") +} +func TestIPGetIPv6Range(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + id := "2600:3c00::/64" + + // Mock response for the GET request + mockResponse := struct { + Range string `json:"range"` + Region string `json:"region"` + Prefix int `json:"prefix"` + RouteTarget string `json:"route_target"` + IsBGP bool `json:"is_bgp"` + Linodes []int `json:"linodes"` + }{ + Range: id, + Region: "us-east", + Prefix: 64, + RouteTarget: "2600:3c00::1", + IsBGP: false, + Linodes: []int{54321}, + } + + base.MockGet("networking/ipv6/ranges/2600:3c00::%2F64", mockResponse) + + rangeObj, err := base.Client.GetIPv6Range(context.Background(), id) + + assert.NoError(t, err, "Expected no error when getting IPv6 range") + assert.NotNil(t, rangeObj, "Expected non-nil IPv6 range response") + assert.Equal(t, id, rangeObj.Range, "Expected matching IPv6 range") + assert.Equal(t, "us-east", rangeObj.Region, "Expected matching region") + assert.Equal(t, 64, rangeObj.Prefix, "Expected matching prefix length") + assert.Equal(t, "2600:3c00::1", rangeObj.RouteTarget, "Expected matching route target") + assert.False(t, rangeObj.IsBGP, "Expected IsBGP to be false") + assert.ElementsMatch(t, []int{54321}, rangeObj.Linodes, "Expected matching Linodes list") +} + + +func TestIPCreateIPv6Range(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOpts := linodego.IPv6RangeCreateOptions{ + LinodeID: 12345, + PrefixLength: 64, + RouteTarget: "2600:3c00::1", + } + + // Mock the POST request + base.MockPost("networking/ipv6/ranges", createOpts) + + createdRange, err := base.Client.CreateIPv6Range(context.Background(), createOpts) + + assert.NoError(t, err, "Expected no error when creating IPv6 range") + assert.NotNil(t, createdRange, "Expected non-nil IPv6 range response") + assert.Equal(t, createOpts.RouteTarget, createdRange.RouteTarget, "Expected matching route target") +} + +func TestIPDeleteIPv6Range(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + id := "2600:3c00::/64" + + base.MockDelete("networking/ipv6/ranges/2600:3c00::%2F64", nil) + + err := base.Client.DeleteIPv6Range(context.Background(), id) + + assert.NoError(t, err, "Expected no error when deleting IPv6 range") +} diff --git a/test/unit/network_reserved_ips_test.go b/test/unit/network_reserved_ips_test.go new file mode 100644 index 000000000..e323a4d6c --- /dev/null +++ b/test/unit/network_reserved_ips_test.go @@ -0,0 +1,115 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/linode/linodego" +) + +func TestIPListReservedIPAddresses(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock API response with additional attributes + mockResponse := struct { + Data []linodego.InstanceIP `json:"data"` + }{ + Data: []linodego.InstanceIP{ + { + Address: "192.168.1.10", + Region: "us-east", + LinodeID: 12345, + Reserved: true, + }, + { + Address: "192.168.1.20", + Region: "us-west", + LinodeID: 67890, + Reserved: true, + }, + }, + } + + base.MockGet("networking/reserved/ips", mockResponse) + + reservedIPs, err := base.Client.ListReservedIPAddresses(context.Background(), nil) + + assert.NoError(t, err, "Expected no error when listing reserved IP addresses") + assert.NotNil(t, reservedIPs, "Expected non-nil reserved IP addresses") + assert.Len(t, reservedIPs, 2, "Expected two reserved IP addresses") + assert.Equal(t, "192.168.1.10", reservedIPs[0].Address, "Expected first reserved IP address to match") + assert.Equal(t, "us-east", reservedIPs[0].Region, "Expected region to match") + assert.Equal(t, 12345, reservedIPs[0].LinodeID, "Expected Linode ID to match") +} + +func TestIPGetReservedIPAddress(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + ip := "192.168.1.10" + + // Mock response with necessary attributes + mockResponse := linodego.InstanceIP{ + Address: ip, + Region: "us-east", + LinodeID: 12345, + Reserved: true, + } + + base.MockGet("networking/reserved/ips/"+ip, mockResponse) + + reservedIP, err := base.Client.GetReservedIPAddress(context.Background(), ip) + + assert.NoError(t, err, "Expected no error when getting reserved IP address") + assert.NotNil(t, reservedIP, "Expected non-nil reserved IP address") + assert.Equal(t, ip, reservedIP.Address, "Expected reserved IP address to match") + assert.Equal(t, "us-east", reservedIP.Region, "Expected region to match") + assert.Equal(t, 12345, reservedIP.LinodeID, "Expected Linode ID to match") +} + +func TestIPReserveIPAddress(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOpts := linodego.ReserveIPOptions{ + Region: "us-west", + } + + // Mock the POST request for reserving an IP + mockResponse := linodego.InstanceIP{ + Address: "192.168.1.30", + Region: "us-west", + LinodeID: 13579, + Reserved: true, + } + + base.MockPost("networking/reserved/ips", mockResponse) + + reservedIP, err := base.Client.ReserveIPAddress(context.Background(), createOpts) + + assert.NoError(t, err, "Expected no error when reserving IP address") + assert.NotNil(t, reservedIP, "Expected non-nil reserved IP address") + assert.Equal(t, "192.168.1.30", reservedIP.Address, "Expected reserved IP address to match") + assert.Equal(t, "us-west", reservedIP.Region, "Expected region to match") + assert.Equal(t, 13579, reservedIP.LinodeID, "Expected Linode ID to match") +} + +func TestIPDeleteReservedIPAddress(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + ip := "192.168.1.10" + + // Mock the DELETE request for deleting the reserved IP + base.MockDelete("networking/reserved/ips/"+ip, nil) + + err := base.Client.DeleteReservedIPAddress(context.Background(), ip) + + assert.NoError(t, err, "Expected no error when deleting reserved IP address") +}