diff --git a/test/unit/fixtures/lke_cluster_apl.json b/test/unit/fixtures/lke_cluster_apl.json new file mode 100644 index 000000000..d7e773f3a --- /dev/null +++ b/test/unit/fixtures/lke_cluster_apl.json @@ -0,0 +1,10 @@ +{ + "id": 123, + "label": "test-cluster", + "region": "us-east", + "status": "ready", + "apl_enabled": true, + "created": "2025-01-23T00:00:00", + "updated": "2025-01-23T00:00:00" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_control_plane_acl_get.json b/test/unit/fixtures/lke_cluster_control_plane_acl_get.json new file mode 100644 index 000000000..eab98af0b --- /dev/null +++ b/test/unit/fixtures/lke_cluster_control_plane_acl_get.json @@ -0,0 +1,10 @@ +{ + "acl": { + "enabled": true, + "addresses": { + "ipv4": ["192.168.1.1/32"], + "ipv6": ["2001:db8::/32"] + }, + "revision_id": "rev-abc123" + } +} diff --git a/test/unit/fixtures/lke_cluster_control_plane_acl_update.json b/test/unit/fixtures/lke_cluster_control_plane_acl_update.json new file mode 100644 index 000000000..8f3b844ea --- /dev/null +++ b/test/unit/fixtures/lke_cluster_control_plane_acl_update.json @@ -0,0 +1,10 @@ +{ + "acl": { + "enabled": true, + "addresses": { + "ipv4": ["10.0.0.1/32"], + "ipv6": ["2001:db8::/64"] + }, + "revision_id": "rev-abc124" + } +} diff --git a/test/unit/fixtures/lke_cluster_create.json b/test/unit/fixtures/lke_cluster_create.json new file mode 100644 index 000000000..c83f388d2 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_create.json @@ -0,0 +1,7 @@ +{ + "id": 125, + "label": "new-cluster", + "region": "us-west", + "status": "ready" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_dashboard.json b/test/unit/fixtures/lke_cluster_dashboard.json new file mode 100644 index 000000000..7a5ed5e42 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_dashboard.json @@ -0,0 +1,4 @@ +{ + "url": "https://dashboard.example.com" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_get.json b/test/unit/fixtures/lke_cluster_get.json new file mode 100644 index 000000000..fd67f74d8 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_get.json @@ -0,0 +1,7 @@ +{ + "id": 123, + "label": "test-cluster", + "region": "us-east", + "status": "ready" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_kubeconfig.json b/test/unit/fixtures/lke_cluster_kubeconfig.json new file mode 100644 index 000000000..f2af0dc85 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_kubeconfig.json @@ -0,0 +1,4 @@ +{ + "kubeconfig": "base64-encoded-kubeconfig" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_list.json b/test/unit/fixtures/lke_cluster_list.json new file mode 100644 index 000000000..f8ab363b4 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_list.json @@ -0,0 +1,18 @@ +{ + "data": [ + { + "id": 123, + "label": "test-cluster", + "region": "us-east", + "status": "ready" + }, + { + "id": 124, + "label": "second-cluster", + "region": "us-west", + "status": "not_ready" + } + ], + "pages": 1, + "results": 2 +} diff --git a/test/unit/fixtures/lke_cluster_pool_create.json b/test/unit/fixtures/lke_cluster_pool_create.json new file mode 100644 index 000000000..7f2f34602 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_pool_create.json @@ -0,0 +1,6 @@ +{ + "id": 3, + "type": "g6-standard-2", + "count": 3 +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_pool_get.json b/test/unit/fixtures/lke_cluster_pool_get.json new file mode 100644 index 000000000..55c6ead91 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_pool_get.json @@ -0,0 +1,7 @@ +{ + "id": 1, + "type": "pool-1", + "count": 3, + "autoscaler": {"enabled": true, "min": 1, "max": 5} +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_pool_list.json b/test/unit/fixtures/lke_cluster_pool_list.json new file mode 100644 index 000000000..c70ee4b6e --- /dev/null +++ b/test/unit/fixtures/lke_cluster_pool_list.json @@ -0,0 +1,19 @@ +{ + "data": [ + { + "id": 1, + "type": "pool-1", + "count": 3, + "autoscaler": {"enabled": true, "min": 1, "max": 5} + }, + { + "id": 2, + "type": "pool-2", + "count": 2, + "autoscaler": {"enabled": false} + } + ], + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_pool_update.json b/test/unit/fixtures/lke_cluster_pool_update.json new file mode 100644 index 000000000..235943ef0 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_pool_update.json @@ -0,0 +1,6 @@ +{ + "id": 1, + "type": "pool-1", + "count": 5 +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_regenerate.json b/test/unit/fixtures/lke_cluster_regenerate.json new file mode 100644 index 000000000..3d06e3ab2 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_regenerate.json @@ -0,0 +1,6 @@ +{ + "id": 123, + "label": "test-cluster", + "region": "us-east" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_cluster_update.json b/test/unit/fixtures/lke_cluster_update.json new file mode 100644 index 000000000..84b4d3137 --- /dev/null +++ b/test/unit/fixtures/lke_cluster_update.json @@ -0,0 +1,7 @@ +{ + "id": 123, + "label": "updated-cluster", + "region": "us-east", + "status": "ready" +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_node_pool_create.json b/test/unit/fixtures/lke_node_pool_create.json new file mode 100644 index 000000000..40c330ae7 --- /dev/null +++ b/test/unit/fixtures/lke_node_pool_create.json @@ -0,0 +1,20 @@ +{ + "id": 789, + "count": 2, + "type": "g6-standard-2", + "tags": ["tag1"], + "labels": {"env": "dev"}, + "taints": [ + { + "key": "taintKey", + "value": "taintValue", + "effect": "NoSchedule" + } + ], + "autoscaler": { + "enabled": true, + "min": 1, + "max": 5 + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_node_pool_get.json b/test/unit/fixtures/lke_node_pool_get.json new file mode 100644 index 000000000..fca17440e --- /dev/null +++ b/test/unit/fixtures/lke_node_pool_get.json @@ -0,0 +1,13 @@ +{ + "id": 456, + "count": 3, + "type": "g6-standard-2", + "tags": ["tag1", "tag2"], + "labels": {"env": "staging"}, + "autoscaler": { + "enabled": true, + "min": 1, + "max": 5 + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_node_pool_list.json b/test/unit/fixtures/lke_node_pool_list.json new file mode 100644 index 000000000..5bb78aada --- /dev/null +++ b/test/unit/fixtures/lke_node_pool_list.json @@ -0,0 +1,23 @@ +{ + "data": [ + { + "id": 456, + "count": 3, + "type": "g6-standard-2", + "tags": ["tag1"], + "labels": {"env": "staging"}, + "autoscaler": {"enabled": true, "min": 1, "max": 5} + }, + { + "id": 789, + "count": 2, + "type": "g6-standard-4", + "tags": ["tag2"], + "labels": {"env": "prod"}, + "autoscaler": {"enabled": false, "min": 0, "max": 0} + } + ], + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_node_pool_update.json b/test/unit/fixtures/lke_node_pool_update.json new file mode 100644 index 000000000..75f8ad7f4 --- /dev/null +++ b/test/unit/fixtures/lke_node_pool_update.json @@ -0,0 +1,13 @@ +{ + "id": 456, + "count": 5, + "type": "g6-standard-2", + "tags": ["updated-tag"], + "labels": {"env": "prod"}, + "autoscaler": { + "enabled": true, + "min": 2, + "max": 8 + } +} + \ No newline at end of file diff --git a/test/unit/fixtures/lke_types_list.json b/test/unit/fixtures/lke_types_list.json new file mode 100644 index 000000000..d32bfa6f9 --- /dev/null +++ b/test/unit/fixtures/lke_types_list.json @@ -0,0 +1,43 @@ +{ + "data": [ + { + "id": "g6-standard-1", + "label": "Standard 1GB", + "price": { + "hourly": 0.0075, + "monthly": 5.00 + }, + "region_prices": [ + { + "hourly": 0.0074, + "monthly": 4.99 + }, + { + "hourly": 0.0076, + "monthly": 5.01 + } + ] + }, + { + "id": "g6-standard-2", + "label": "Standard 2GB", + "price": { + "hourly": 0.015, + "monthly": 10.00 + }, + "region_prices": [ + { + "hourly": 0.0148, + "monthly": 9.90 + }, + { + "hourly": 0.0152, + "monthly": 10.10 + } + ] + } + ], + "pages": 1, + "results": 2 + } + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_access_get.json b/test/unit/fixtures/object_storage_bucket_access_get.json new file mode 100644 index 000000000..6856494da --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_access_get.json @@ -0,0 +1,5 @@ +{ + "acl": "public-read", + "cors_enabled": true +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_cert.json b/test/unit/fixtures/object_storage_bucket_cert.json new file mode 100644 index 000000000..fe1bb9ad1 --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_cert.json @@ -0,0 +1,4 @@ +{ + "ssl": true +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_contents.json b/test/unit/fixtures/object_storage_bucket_contents.json new file mode 100644 index 000000000..777b0b221 --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_contents.json @@ -0,0 +1,14 @@ +{ + "data": [ + { + "etag": "12345abcde", + "last_modified": "2023-01-01T12:00:00Z", + "name": "example-file.txt", + "owner": "user123", + "size": 1024 + } + ], + "is_truncated": true, + "next_marker": "next-file-marker" +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_create.json b/test/unit/fixtures/object_storage_bucket_create.json new file mode 100644 index 000000000..cadb5e53a --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_create.json @@ -0,0 +1,10 @@ +{ + "label": "new-bucket", + "region": "us-east", + "s3_endpoint": "https://s3.us-east.linodeobjects.com", + "endpoint_type": "public", + "hostname": "new-bucket.us-east.linodeobjects.com", + "objects": 0, + "size": 0 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_get.json b/test/unit/fixtures/object_storage_bucket_get.json new file mode 100644 index 000000000..223f31dcd --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_get.json @@ -0,0 +1,10 @@ +{ + "label": "my-bucket", + "region": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "public", + "hostname": "my-bucket.us-east-1.linodeobjects.com", + "objects": 10, + "size": 20480 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_bucket_list.json b/test/unit/fixtures/object_storage_bucket_list.json new file mode 100644 index 000000000..5e25c83d3 --- /dev/null +++ b/test/unit/fixtures/object_storage_bucket_list.json @@ -0,0 +1,17 @@ +{ + "data": [ + { + "label": "my-bucket", + "region": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "public", + "hostname": "my-bucket.us-east-1.linodeobjects.com", + "objects": 5, + "size": 10240 + } + ], + "page": 1, + "pages": 1, + "results": 1 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_cluster_get.json b/test/unit/fixtures/object_storage_cluster_get.json new file mode 100644 index 000000000..3f932e613 --- /dev/null +++ b/test/unit/fixtures/object_storage_cluster_get.json @@ -0,0 +1,7 @@ +{ + "id": "my-cluster-id", + "domain": "example.com", + "status": "active", + "region": "us-east-1", + "static_site_domain": "static.example.com" +} diff --git a/test/unit/fixtures/object_storage_cluster_list.json b/test/unit/fixtures/object_storage_cluster_list.json new file mode 100644 index 000000000..714737876 --- /dev/null +++ b/test/unit/fixtures/object_storage_cluster_list.json @@ -0,0 +1,15 @@ +{ + "data": [ + { + "id": "my-cluster-id", + "domain": "example.com", + "status": "active", + "region": "us-east-1", + "static_site_domain": "static.example.com" + } + ], + "page": 1, + "pages": 1, + "results": 1 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_endpoints_list.json b/test/unit/fixtures/object_storage_endpoints_list.json new file mode 100644 index 000000000..6166c0329 --- /dev/null +++ b/test/unit/fixtures/object_storage_endpoints_list.json @@ -0,0 +1,18 @@ +{ + "data": [ + { + "region": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + }, + { + "region": "us-west-1", + "s3_endpoint": "https://s3.us-west-1.linodeobjects.com", + "endpoint_type": "E1" + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_key_create.json b/test/unit/fixtures/object_storage_key_create.json new file mode 100644 index 000000000..4a19c9806 --- /dev/null +++ b/test/unit/fixtures/object_storage_key_create.json @@ -0,0 +1,22 @@ +{ + "id": 124, + "label": "new-key", + "access_key": "new-access-key", + "secret_key": "new-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-east-1", + "bucket_name": "my-bucket", + "permissions": "read-write" + } + ], + "regions": [ + { + "id": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + } + ] +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_key_get.json b/test/unit/fixtures/object_storage_key_get.json new file mode 100644 index 000000000..22ca9bc2f --- /dev/null +++ b/test/unit/fixtures/object_storage_key_get.json @@ -0,0 +1,22 @@ +{ + "id": 123, + "label": "my-key", + "access_key": "my-access-key", + "secret_key": "my-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-east-1", + "bucket_name": "my-bucket", + "permissions": "read-write" + } + ], + "regions": [ + { + "id": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + } + ] +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_key_list.json b/test/unit/fixtures/object_storage_key_list.json new file mode 100644 index 000000000..38cea3730 --- /dev/null +++ b/test/unit/fixtures/object_storage_key_list.json @@ -0,0 +1,29 @@ +{ + "data": [ + { + "id": 123, + "label": "my-key", + "access_key": "my-access-key", + "secret_key": "my-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-east-1", + "bucket_name": "my-bucket", + "permissions": "read-write" + } + ], + "regions": [ + { + "id": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + } + ] + } + ], + "page": 1, + "pages": 1, + "results": 1 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_key_list_by_region.json b/test/unit/fixtures/object_storage_key_list_by_region.json new file mode 100644 index 000000000..8681b268f --- /dev/null +++ b/test/unit/fixtures/object_storage_key_list_by_region.json @@ -0,0 +1,50 @@ +{ + "data": [ + { + "id": 123, + "label": "my-key", + "access_key": "my-access-key", + "secret_key": "my-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-east-1", + "bucket_name": "my-bucket", + "permissions": "read-write" + } + ], + "regions": [ + { + "id": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + } + ] + }, + { + "id": 124, + "label": "my-second-key", + "access_key": "my-second-access-key", + "secret_key": "my-second-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-east-1", + "bucket_name": "my-second-bucket", + "permissions": "read-write" + } + ], + "regions": [ + { + "id": "us-east-1", + "s3_endpoint": "https://s3.us-east-1.linodeobjects.com", + "endpoint_type": "E0" + } + ] + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_key_update.json b/test/unit/fixtures/object_storage_key_update.json new file mode 100644 index 000000000..0e758a930 --- /dev/null +++ b/test/unit/fixtures/object_storage_key_update.json @@ -0,0 +1,22 @@ +{ + "id": 123, + "label": "updated-key", + "access_key": "updated-access-key", + "secret_key": "updated-secret-key", + "limited": true, + "bucket_access": [ + { + "region": "us-west-1", + "bucket_name": "updated-bucket", + "permissions": "read-only" + } + ], + "regions": [ + { + "id": "us-west-1", + "s3_endpoint": "https://s3.us-west-1.linodeobjects.com", + "endpoint_type": "E1" + } + ] +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_object_acl_get.json b/test/unit/fixtures/object_storage_object_acl_get.json new file mode 100644 index 000000000..cf9163a64 --- /dev/null +++ b/test/unit/fixtures/object_storage_object_acl_get.json @@ -0,0 +1,5 @@ +{ + "acl": "public-read", + "acl_xml": "owner-idREAD" +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_object_acl_update.json b/test/unit/fixtures/object_storage_object_acl_update.json new file mode 100644 index 000000000..f525938fc --- /dev/null +++ b/test/unit/fixtures/object_storage_object_acl_update.json @@ -0,0 +1,5 @@ +{ + "acl": "private", + "acl_xml": "owner-idNONE" +} + \ No newline at end of file diff --git a/test/unit/fixtures/object_storage_object_url_create.json b/test/unit/fixtures/object_storage_object_url_create.json new file mode 100644 index 000000000..183e6bd6b --- /dev/null +++ b/test/unit/fixtures/object_storage_object_url_create.json @@ -0,0 +1,5 @@ +{ + "url": "https://s3.example.com/my-bucket/test-object", + "exists": true +} + \ No newline at end of file diff --git a/test/unit/lke_cluster_control_plane_acl_test.go b/test/unit/lke_cluster_control_plane_acl_test.go new file mode 100644 index 000000000..06442ae29 --- /dev/null +++ b/test/unit/lke_cluster_control_plane_acl_test.go @@ -0,0 +1,71 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func BoolToPtr(b bool) *bool { + return &b +} + +func TestLKEClusterControlPlaneACL_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_control_plane_acl_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/control_plane_acl", fixtureData) + + acl, err := base.Client.GetLKEClusterControlPlaneACL(context.Background(), 123) + assert.NoError(t, err) + assert.True(t, acl.ACL.Enabled) + assert.Equal(t, "rev-abc123", acl.ACL.RevisionID) + assert.Equal(t, []string{"192.168.1.1/32"}, acl.ACL.Addresses.IPv4) + assert.Equal(t, []string{"2001:db8::/32"}, acl.ACL.Addresses.IPv6) +} + +func TestLKEClusterControlPlaneACL_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_control_plane_acl_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.LKEClusterControlPlaneACLUpdateOptions{ + ACL: linodego.LKEClusterControlPlaneACLOptions{ + Enabled: BoolToPtr(true), + RevisionID: "rev-abc123", + Addresses: &linodego.LKEClusterControlPlaneACLAddressesOptions{ + IPv4: &[]string{"10.0.0.1/32"}, + IPv6: &[]string{"2001:db8::/64"}, + }, + }, + } + + base.MockPut("lke/clusters/123/control_plane_acl", fixtureData) + + acl, err := base.Client.UpdateLKEClusterControlPlaneACL(context.Background(), 123, updateOptions) + assert.NoError(t, err) + assert.True(t, acl.ACL.Enabled) + assert.Equal(t, "rev-abc124", acl.ACL.RevisionID) + assert.Equal(t, []string{"10.0.0.1/32"}, acl.ACL.Addresses.IPv4) + assert.Equal(t, []string{"2001:db8::/64"}, acl.ACL.Addresses.IPv6) +} + +func TestLKEClusterControlPlaneACL_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/control_plane_acl", nil) + + err := base.Client.DeleteLKEClusterControlPlaneACL(context.Background(), 123) + assert.NoError(t, err) +} diff --git a/test/unit/lke_cluster_pool_test.go b/test/unit/lke_cluster_pool_test.go new file mode 100644 index 000000000..c89cb81de --- /dev/null +++ b/test/unit/lke_cluster_pool_test.go @@ -0,0 +1,105 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestLKEClusterPool_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_pool_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/pools", fixtureData) + + pools, err := base.Client.ListLKEClusterPools(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, pools, 2) + + assert.Equal(t, 1, pools[0].ID) + assert.Equal(t, "pool-1", pools[0].Type) +} + +func TestLKEClusterPool_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_pool_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/pools/1", fixtureData) + + pool, err := base.Client.GetLKEClusterPool(context.Background(), 123, 1) + assert.NoError(t, err) + assert.Equal(t, 1, pool.ID) + assert.Equal(t, "pool-1", pool.Type) +} + +func TestLKEClusterPool_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_pool_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.LKEClusterPoolCreateOptions{ + Type: "g6-standard-2", + Count: 3, + } + + base.MockPost("lke/clusters/123/pools", fixtureData) + + pool, err := base.Client.CreateLKEClusterPool(context.Background(), 123, createOptions) + assert.NoError(t, err) + assert.Equal(t, "g6-standard-2", pool.Type) + assert.Equal(t, 3, pool.Count) +} + +func TestLKEClusterPool_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_pool_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.LKEClusterPoolUpdateOptions{ + Count: 5, + } + + base.MockPut("lke/clusters/123/pools/1", fixtureData) + + pool, err := base.Client.UpdateLKEClusterPool(context.Background(), 123, 1, updateOptions) + assert.NoError(t, err) + assert.Equal(t, 5, pool.Count) +} + +func TestLKEClusterPool_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/pools/1", nil) + + err := base.Client.DeleteLKEClusterPool(context.Background(), 123, 1) + assert.NoError(t, err) +} + +func TestLKEClusterPool_DeleteNode(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/nodes/abc123", nil) + + err := base.Client.DeleteLKEClusterPoolNode(context.Background(), 123, "abc123") + assert.NoError(t, err) +} diff --git a/test/unit/lke_clusters_test.go b/test/unit/lke_clusters_test.go index 3f0f11935..3303a6204 100644 --- a/test/unit/lke_clusters_test.go +++ b/test/unit/lke_clusters_test.go @@ -6,6 +6,7 @@ import ( "github.com/jarcoal/httpmock" "github.com/linode/linodego" + "github.com/stretchr/testify/assert" ) func TestLKECluster_Regenerate(t *testing.T) { @@ -43,3 +44,163 @@ func TestLKECluster_KubeconfigDelete(t *testing.T) { t.Fatal(err) } } + +func TestLKECluster_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters", fixtureData) + + clusters, err := base.Client.ListLKEClusters(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, clusters, 2) + + assert.Equal(t, 123, clusters[0].ID) + assert.Equal(t, "test-cluster", clusters[0].Label) + assert.Equal(t, "us-east", clusters[0].Region) +} + +func TestLKECluster_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123", fixtureData) + + cluster, err := base.Client.GetLKECluster(context.Background(), 123) + assert.NoError(t, err) + assert.Equal(t, 123, cluster.ID) + assert.Equal(t, "test-cluster", cluster.Label) +} + +func TestLKECluster_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.LKEClusterCreateOptions{ + Label: "new-cluster", + Region: "us-west", + K8sVersion: "1.22", + Tags: []string{"tag1"}, + } + + base.MockPost("lke/clusters", fixtureData) + + cluster, err := base.Client.CreateLKECluster(context.Background(), createOptions) + assert.NoError(t, err) + assert.Equal(t, "new-cluster", cluster.Label) + assert.Equal(t, "us-west", cluster.Region) +} + +func TestLKECluster_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.LKEClusterUpdateOptions{ + Label: "updated-cluster", + Tags: &[]string{"new-tag"}, + } + + base.MockPut("lke/clusters/123", fixtureData) + + cluster, err := base.Client.UpdateLKECluster(context.Background(), 123, updateOptions) + assert.NoError(t, err) + assert.Equal(t, "updated-cluster", cluster.Label) +} + +func TestLKECluster_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123", nil) + + err := base.Client.DeleteLKECluster(context.Background(), 123) + assert.NoError(t, err) +} + +func TestLKECluster_GetKubeconfig(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_kubeconfig") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/kubeconfig", fixtureData) + + kubeconfig, err := base.Client.GetLKEClusterKubeconfig(context.Background(), 123) + assert.NoError(t, err) + assert.NotEmpty(t, kubeconfig.KubeConfig) +} + +func TestLKECluster_DeleteKubeconfig(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/kubeconfig", nil) + + err := base.Client.DeleteLKEClusterKubeconfig(context.Background(), 123) + assert.NoError(t, err) +} + +func TestLKECluster_GetDashboard(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_dashboard") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/dashboard", fixtureData) + + dashboard, err := base.Client.GetLKEClusterDashboard(context.Background(), 123) + assert.NoError(t, err) + assert.Equal(t, "https://dashboard.example.com", dashboard.URL) +} + +func TestLKECluster_GetAPLConsoleURL(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_apl") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123", fixtureData) + + url, err := base.Client.GetLKEClusterAPLConsoleURL(context.Background(), 123) + assert.NoError(t, err) + assert.Equal(t, "https://console.lke123.akamai-apl.net", url) +} + +func TestLKECluster_GetAPLHealthCheckURL(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_cluster_apl") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123", fixtureData) + + url, err := base.Client.GetLKEClusterAPLHealthCheckURL(context.Background(), 123) + assert.NoError(t, err) + assert.Equal(t, "https://auth.lke123.akamai-apl.net/ready", url) +} diff --git a/test/unit/lke_node_pools_test.go b/test/unit/lke_node_pools_test.go index 18514b8b5..f4af5840c 100644 --- a/test/unit/lke_node_pools_test.go +++ b/test/unit/lke_node_pools_test.go @@ -10,6 +10,10 @@ import ( "github.com/jarcoal/httpmock" ) +func Ptr[T any](v T) *T { + return &v +} + func TestLKENodePool_Recycle(t *testing.T) { client := createMockClient(t) @@ -53,3 +57,124 @@ func TestLKENodePoolNode_Get(t *testing.T) { assert.Equal(t, 123456, node.InstanceID) assert.Equal(t, linodego.LKELinodeStatus("ready"), node.Status) } + +func TestLKENodePool_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_node_pool_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/pools/456", fixtureData) + + nodePool, err := base.Client.GetLKENodePool(context.Background(), 123, 456) + assert.NoError(t, err) + assert.Equal(t, 456, nodePool.ID) + assert.Equal(t, "g6-standard-2", nodePool.Type) + assert.Equal(t, 3, nodePool.Count) + assert.Equal(t, []string{"tag1", "tag2"}, nodePool.Tags) +} + +func TestLKENodePool_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_node_pool_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.LKENodePoolCreateOptions{ + Count: 2, + Type: "g6-standard-2", + Tags: []string{"tag1"}, + Labels: map[string]string{"env": "dev"}, + Taints: []linodego.LKENodePoolTaint{ + {Key: "taintKey", Value: "taintValue", Effect: linodego.LKENodePoolTaintEffectNoSchedule}, + }, + Autoscaler: &linodego.LKENodePoolAutoscaler{ + Enabled: true, + Min: 1, + Max: 5, + }, + } + + base.MockPost("lke/clusters/123/pools", fixtureData) + + nodePool, err := base.Client.CreateLKENodePool(context.Background(), 123, createOptions) + assert.NoError(t, err) + assert.Equal(t, "g6-standard-2", nodePool.Type) + assert.Equal(t, 2, nodePool.Count) + assert.True(t, nodePool.Autoscaler.Enabled) + assert.Equal(t, 1, nodePool.Autoscaler.Min) + assert.Equal(t, 5, nodePool.Autoscaler.Max) +} + +func TestLKENodePool_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_node_pool_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.LKENodePoolUpdateOptions{ + Count: 5, + Tags: &[]string{"updated-tag"}, + Labels: Ptr(linodego.LKENodePoolLabels{"env": "prod"}), + Autoscaler: &linodego.LKENodePoolAutoscaler{ + Enabled: true, + Min: 2, + Max: 8, + }, + } + + base.MockPut("lke/clusters/123/pools/456", fixtureData) + + nodePool, err := base.Client.UpdateLKENodePool(context.Background(), 123, 456, updateOptions) + assert.NoError(t, err) + assert.Equal(t, 5, nodePool.Count) + assert.Equal(t, []string{"updated-tag"}, nodePool.Tags) + assert.True(t, nodePool.Autoscaler.Enabled) + assert.Equal(t, 2, nodePool.Autoscaler.Min) + assert.Equal(t, 8, nodePool.Autoscaler.Max) +} + +func TestLKENodePool_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/pools/456", nil) + + err := base.Client.DeleteLKENodePool(context.Background(), 123, 456) + assert.NoError(t, err) +} + +func TestLKENodePool_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_node_pool_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/clusters/123/pools", fixtureData) + + nodePools, err := base.Client.ListLKENodePools(context.Background(), 123, nil) + assert.NoError(t, err) + assert.Len(t, nodePools, 2) + assert.Equal(t, 456, nodePools[0].ID) + assert.Equal(t, 789, nodePools[1].ID) +} + +func TestLKENodePoolNode_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("lke/clusters/123/nodes/abc123", nil) + + err := base.Client.DeleteLKENodePoolNode(context.Background(), 123, "abc123") + assert.NoError(t, err) +} diff --git a/test/unit/lke_types_test.go b/test/unit/lke_types_test.go new file mode 100644 index 000000000..54d772fc1 --- /dev/null +++ b/test/unit/lke_types_test.go @@ -0,0 +1,51 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestLKETypes_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("lke_types_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("lke/types", fixtureData) + + types, err := base.Client.ListLKETypes(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, types, 2) + + // Validate first LKE type + lkeType1 := types[0] + assert.Equal(t, "g6-standard-1", lkeType1.ID) + assert.Equal(t, "Standard 1GB", lkeType1.Label) + + assert.Equal(t, 0.0075, lkeType1.Price.Hourly) + assert.Equal(t, 5.00, lkeType1.Price.Monthly) + + assert.Len(t, lkeType1.RegionPrices, 2) + assert.Equal(t, 0.0074, lkeType1.RegionPrices[0].Hourly) + assert.Equal(t, 4.99, lkeType1.RegionPrices[0].Monthly) + assert.Equal(t, 0.0076, lkeType1.RegionPrices[1].Hourly) + assert.Equal(t, 5.01, lkeType1.RegionPrices[1].Monthly) + + // Validate second LKE type + lkeType2 := types[1] + assert.Equal(t, "g6-standard-2", lkeType2.ID) + assert.Equal(t, "Standard 2GB", lkeType2.Label) + + assert.Equal(t, 0.015, lkeType2.Price.Hourly) + assert.Equal(t, 10.00, lkeType2.Price.Monthly) + + assert.Len(t, lkeType2.RegionPrices, 2) + assert.Equal(t, 0.0148, lkeType2.RegionPrices[0].Hourly) + assert.Equal(t, 9.90, lkeType2.RegionPrices[0].Monthly) + assert.Equal(t, 0.0152, lkeType2.RegionPrices[1].Hourly) + assert.Equal(t, 10.10, lkeType2.RegionPrices[1].Monthly) +} diff --git a/test/unit/object_storage_bucket_cert_test.go b/test/unit/object_storage_bucket_cert_test.go new file mode 100644 index 000000000..137bed11f --- /dev/null +++ b/test/unit/object_storage_bucket_cert_test.go @@ -0,0 +1,111 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageBucketCert_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_cert") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketName := "my-bucket" + + base.MockGet("object-storage/buckets/"+clusterID+"/"+bucketName+"/ssl", fixtureData) + + cert, err := base.Client.GetObjectStorageBucketCert(context.Background(), clusterID, bucketName) + assert.NoError(t, err) + assert.NotNil(t, cert) + assert.True(t, cert.SSL) +} + +func TestObjectStorageBucketCert_Upload(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_cert") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketName := "my-bucket" + + uploadOpts := linodego.ObjectStorageBucketCertUploadOptions{ + Certificate: "mock-cert", + PrivateKey: "mock-key", + } + + base.MockPost("object-storage/buckets/"+clusterID+"/"+bucketName+"/ssl", fixtureData) + + uploadedCert, err := base.Client.UploadObjectStorageBucketCert(context.Background(), clusterID, bucketName, uploadOpts) + assert.NoError(t, err) + assert.NotNil(t, uploadedCert) + assert.True(t, uploadedCert.SSL) +} + +func TestObjectStorageBucketCertV2_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_cert") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketName := "my-bucket" + + base.MockGet("object-storage/buckets/"+clusterID+"/"+bucketName+"/ssl", fixtureData) + + cert, err := base.Client.GetObjectStorageBucketCertV2(context.Background(), clusterID, bucketName) + assert.NoError(t, err) + assert.NotNil(t, cert) + assert.NotNil(t, cert.SSL) + assert.True(t, *cert.SSL) +} + +func TestObjectStorageBucketCertV2_Upload(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_cert") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketName := "my-bucket" + + uploadOpts := linodego.ObjectStorageBucketCertUploadOptions{ + Certificate: "mock-cert", + PrivateKey: "mock-key", + } + + base.MockPost("object-storage/buckets/"+clusterID+"/"+bucketName+"/ssl", fixtureData) + + uploadedCert, err := base.Client.UploadObjectStorageBucketCertV2(context.Background(), clusterID, bucketName, uploadOpts) + assert.NoError(t, err) + assert.NotNil(t, uploadedCert) + assert.NotNil(t, uploadedCert.SSL) + assert.True(t, *uploadedCert.SSL) +} + +func TestObjectStorageBucketCert_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketName := "my-bucket" + + base.MockDelete("object-storage/buckets/"+clusterID+"/"+bucketName+"/ssl", nil) + + err := base.Client.DeleteObjectStorageBucketCert(context.Background(), clusterID, bucketName) + assert.NoError(t, err) +} diff --git a/test/unit/object_storage_bucket_test.go b/test/unit/object_storage_bucket_test.go new file mode 100644 index 000000000..9e807d312 --- /dev/null +++ b/test/unit/object_storage_bucket_test.go @@ -0,0 +1,158 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageBucket_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/buckets", fixtureData) + + buckets, err := base.Client.ListObjectStorageBuckets(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, buckets, 1) + + assert.Equal(t, "my-bucket", buckets[0].Label) + assert.Equal(t, "us-east-1", buckets[0].Region) + assert.Equal(t, "https://s3.us-east-1.linodeobjects.com", buckets[0].S3Endpoint) + assert.Equal(t, linodego.ObjectStorageEndpointType("public"), buckets[0].EndpointType) + assert.Equal(t, "my-bucket.us-east-1.linodeobjects.com", buckets[0].Hostname) + assert.Equal(t, 5, buckets[0].Objects) + assert.Equal(t, 10240, buckets[0].Size) +} + +func TestObjectStorageBucket_ListInCluster(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + base.MockGet("object-storage/buckets/"+clusterID, fixtureData) + + buckets, err := base.Client.ListObjectStorageBucketsInCluster(context.Background(), nil, clusterID) + assert.NoError(t, err) + assert.NotEmpty(t, buckets) +} + +func TestObjectStorageBucket_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketLabel := "my-bucket" + + base.MockGet("object-storage/buckets/"+clusterID+"/"+bucketLabel, fixtureData) + + bucket, err := base.Client.GetObjectStorageBucket(context.Background(), clusterID, bucketLabel) + assert.NoError(t, err) + assert.NotNil(t, bucket) + assert.Equal(t, bucketLabel, bucket.Label) +} + +func TestObjectStorageBucket_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOpts := linodego.ObjectStorageBucketCreateOptions{ + Region: "us-east", + Label: "new-bucket", + } + + base.MockPost("object-storage/buckets", fixtureData) + + bucket, err := base.Client.CreateObjectStorageBucket(context.Background(), createOpts) + assert.NoError(t, err) + assert.NotNil(t, bucket) + assert.Equal(t, createOpts.Label, bucket.Label) +} + +func TestObjectStorageBucket_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketLabel := "my-bucket" + + base.MockDelete("object-storage/buckets/"+clusterID+"/"+bucketLabel, nil) + + err := base.Client.DeleteObjectStorageBucket(context.Background(), clusterID, bucketLabel) + assert.NoError(t, err) +} + +func TestObjectStorageBucket_GetAccess(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_access_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketLabel := "my-bucket" + + base.MockGet("object-storage/buckets/"+clusterID+"/"+bucketLabel+"/access", fixtureData) + + access, err := base.Client.GetObjectStorageBucketAccess(context.Background(), clusterID, bucketLabel) + assert.NoError(t, err) + assert.NotNil(t, access) + assert.Equal(t, linodego.ACLPublicRead, access.ACL) +} + +func TestObjectStorageBucket_UpdateAccess(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketLabel := "my-bucket" + + updateOpts := linodego.ObjectStorageBucketUpdateAccessOptions{ + ACL: linodego.ACLPrivate, + } + + base.MockPost("object-storage/buckets/"+clusterID+"/"+bucketLabel+"/access", nil) + + err := base.Client.UpdateObjectStorageBucketAccess(context.Background(), clusterID, bucketLabel, updateOpts) + assert.NoError(t, err) +} + +func TestObjectStorageBucket_ListContents(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_bucket_contents") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + clusterID := "us-east-1" + bucketLabel := "my-bucket" + + base.MockGet("object-storage/buckets/"+clusterID+"/"+bucketLabel+"/object-list", fixtureData) + + contents, err := base.Client.ListObjectStorageBucketContents(context.Background(), clusterID, bucketLabel, nil) + assert.NoError(t, err) + assert.NotNil(t, contents) + assert.True(t, contents.IsTruncated) +} diff --git a/test/unit/object_storage_cluster_test.go b/test/unit/object_storage_cluster_test.go new file mode 100644 index 000000000..25aaf549d --- /dev/null +++ b/test/unit/object_storage_cluster_test.go @@ -0,0 +1,50 @@ +package unit + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageCluster_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_cluster_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/clusters", fixtureData) + + clusters, err := base.Client.ListObjectStorageClusters(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, clusters, 1) + + assert.Equal(t, "us-east-1", clusters[0].Region) + assert.Equal(t, "active", clusters[0].Status) + assert.Equal(t, "my-cluster-id", clusters[0].ID) + assert.Equal(t, "example.com", clusters[0].Domain) + assert.Equal(t, "static.example.com", clusters[0].StaticSiteDomain) +} + +func TestObjectStorageCluster_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_cluster_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/clusters/my-cluster-id", fixtureData) + + cluster, err := base.Client.GetObjectStorageCluster(context.Background(), "my-cluster-id") + assert.NoError(t, err) + assert.NotNil(t, cluster) + + assert.Equal(t, "us-east-1", cluster.Region) + assert.Equal(t, "active", cluster.Status) + assert.Equal(t, "my-cluster-id", cluster.ID) + assert.Equal(t, "example.com", cluster.Domain) + assert.Equal(t, "static.example.com", cluster.StaticSiteDomain) +} diff --git a/test/unit/object_storage_endpoint_test.go b/test/unit/object_storage_endpoint_test.go new file mode 100644 index 000000000..1322e5c3a --- /dev/null +++ b/test/unit/object_storage_endpoint_test.go @@ -0,0 +1,30 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageEndpoint_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_endpoints_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/endpoints", fixtureData) + + endpoints, err := base.Client.ListObjectStorageEndpoints(context.Background(), nil) + if err != nil { + t.Fatalf("Error getting endpoints: %v", err) + } + + assert.Equal(t, 2, len(endpoints)) + assert.Equal(t, "us-east-1", endpoints[0].Region) + assert.Equal(t, "https://s3.us-east-1.linodeobjects.com", *endpoints[0].S3Endpoint) + assert.Equal(t, linodego.ObjectStorageEndpointE0, endpoints[0].EndpointType) +} diff --git a/test/unit/object_storage_key_test.go b/test/unit/object_storage_key_test.go new file mode 100644 index 000000000..9012536ee --- /dev/null +++ b/test/unit/object_storage_key_test.go @@ -0,0 +1,127 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageKey_List(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_key_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/keys", fixtureData) + + keys, err := base.Client.ListObjectStorageKeys(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, keys, 1) + + assert.Equal(t, "my-key", keys[0].Label) + assert.Equal(t, "my-access-key", keys[0].AccessKey) + assert.Equal(t, "my-secret-key", keys[0].SecretKey) + assert.True(t, keys[0].Limited) +} + +func TestObjectStorageKey_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_key_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.ObjectStorageKeyCreateOptions{ + Label: "new-key", + Regions: []string{"us-east-1"}, + } + + base.MockPost("object-storage/keys", fixtureData) + + key, err := base.Client.CreateObjectStorageKey(context.Background(), createOptions) + assert.NoError(t, err) + assert.Equal(t, "new-key", key.Label) + assert.Equal(t, "new-access-key", key.AccessKey) + assert.Equal(t, "new-secret-key", key.SecretKey) +} + +func TestObjectStorageKey_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_key_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/keys/123", fixtureData) + + key, err := base.Client.GetObjectStorageKey(context.Background(), 123) + assert.NoError(t, err) + assert.Equal(t, "my-key", key.Label) + assert.Equal(t, "my-access-key", key.AccessKey) + assert.Equal(t, "my-secret-key", key.SecretKey) +} + +func TestObjectStorageKey_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_key_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.ObjectStorageKeyUpdateOptions{ + Label: "updated-key", + Regions: []string{"us-west-1"}, + } + + base.MockPut("object-storage/keys/123", fixtureData) + + key, err := base.Client.UpdateObjectStorageKey(context.Background(), 123, updateOptions) + assert.NoError(t, err) + assert.Equal(t, "updated-key", key.Label) + assert.Equal(t, "updated-access-key", key.AccessKey) +} + +func TestObjectStorageKey_Delete(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockDelete("object-storage/keys/123", nil) + + err := base.Client.DeleteObjectStorageKey(context.Background(), 123) + assert.NoError(t, err) +} + +func TestObjectStorageKey_ListByRegion(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_key_list_by_region") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/keys", fixtureData) + + keys, err := base.Client.ListObjectStorageKeys(context.Background(), nil) + assert.NoError(t, err) + assert.Len(t, keys, 2) + + var filteredKeys []linodego.ObjectStorageKey + for _, key := range keys { + for _, region := range key.Regions { + if region.ID == "us-east-1" { + filteredKeys = append(filteredKeys, key) + } + } + } + + assert.Len(t, filteredKeys, 2) + assert.Equal(t, "us-east-1", filteredKeys[0].Regions[0].ID) +} diff --git a/test/unit/object_storage_object_test.go b/test/unit/object_storage_object_test.go new file mode 100644 index 000000000..35da889ee --- /dev/null +++ b/test/unit/object_storage_object_test.go @@ -0,0 +1,69 @@ +package unit + +import ( + "context" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestObjectStorageObjectURL_Create(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_object_url_create") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + createOptions := linodego.ObjectStorageObjectURLCreateOptions{ + Name: "test-object", + Method: "GET", + ExpiresIn: nil, + ContentType: "application/json", + } + + base.MockPost("object-storage/buckets/my-bucket/test-label/object-url", fixtureData) + + urlResponse, err := base.Client.CreateObjectStorageObjectURL(context.Background(), "my-bucket", "test-label", createOptions) + assert.NoError(t, err) + assert.Equal(t, "https://s3.example.com/my-bucket/test-object", urlResponse.URL) + assert.True(t, urlResponse.Exists) +} + +func TestObjectStorageObjectACLConfigV2_Get(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_object_acl_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("object-storage/buckets/my-bucket/test-label/object-acl?name=test-object", fixtureData) + + aclConfig, err := base.Client.GetObjectStorageObjectACLConfigV2(context.Background(), "my-bucket", "test-label", "test-object") + assert.NoError(t, err) + assert.NotNil(t, aclConfig.ACL) + assert.Equal(t, "public-read", *aclConfig.ACL) +} + +func TestObjectStorageObjectACLConfigV2_Update(t *testing.T) { + fixtureData, err := fixtures.GetFixture("object_storage_object_acl_update") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + updateOptions := linodego.ObjectStorageObjectACLConfigUpdateOptions{ + Name: "test-object", + ACL: "private", + } + + base.MockPut("object-storage/buckets/my-bucket/test-label/object-acl", fixtureData) + + updatedACLConfig, err := base.Client.UpdateObjectStorageObjectACLConfigV2(context.Background(), "my-bucket", "test-label", updateOptions) + assert.NoError(t, err) + assert.NotNil(t, updatedACLConfig.ACL) + assert.Equal(t, "private", *updatedACLConfig.ACL) +}