From a8748fc3e88bdb3d032835ecb6c0e189778805f1 Mon Sep 17 00:00:00 2001 From: Vinay <143587840+vshanthe@users.noreply.github.com> Date: Wed, 22 Jan 2025 10:54:38 +0530 Subject: [PATCH] Add unit test coverage for Stackscripts, Database and Region related methods/functions (#652) * unit_tests * add_test * database_tests --- test/unit/.DS_Store | Bin 0 -> 8196 bytes test/unit/database_test.go | 153 ++++++++++++++++++ test/unit/fixtures/database_engine_get.json | 6 + .../fixtures/database_maintenance_window.json | 7 + test/unit/fixtures/database_types_list.json | 22 +++ test/unit/fixtures/database_unmarshal.json | 13 ++ test/unit/fixtures/databases_list.json | 19 +++ .../fixtures/region_availability_get.json | 5 + test/unit/fixtures/region_get.json | 17 ++ .../fixtures/regions_availability_list.json | 13 ++ test/unit/fixtures/regions_list.json | 25 +++ test/unit/fixtures/stackscript_get.json | 18 +++ test/unit/fixtures/stackscript_revision.json | 5 + test/unit/fixtures/stackscripts_list.json | 37 +++++ test/unit/region_test.go | 130 +++++++++++++++ test/unit/stackscripts_test.go | 122 ++++++++++++++ 16 files changed, 592 insertions(+) create mode 100644 test/unit/.DS_Store create mode 100644 test/unit/database_test.go create mode 100644 test/unit/fixtures/database_engine_get.json create mode 100644 test/unit/fixtures/database_maintenance_window.json create mode 100644 test/unit/fixtures/database_types_list.json create mode 100644 test/unit/fixtures/database_unmarshal.json create mode 100644 test/unit/fixtures/databases_list.json create mode 100644 test/unit/fixtures/region_availability_get.json create mode 100644 test/unit/fixtures/region_get.json create mode 100644 test/unit/fixtures/regions_availability_list.json create mode 100644 test/unit/fixtures/regions_list.json create mode 100644 test/unit/fixtures/stackscript_get.json create mode 100644 test/unit/fixtures/stackscript_revision.json create mode 100644 test/unit/fixtures/stackscripts_list.json create mode 100644 test/unit/region_test.go create mode 100644 test/unit/stackscripts_test.go diff --git a/test/unit/.DS_Store b/test/unit/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..971e41dd9b256f317be89d8097b0242b84ec9fd8 GIT binary patch literal 8196 zcmeHMU2GIp6u#fI&>1?=DHN#V78X_|Vk70Rr69PpMgD2+wzL#vJG(Q$gy~G#ncbqb zu`w~I_!Ef_#=pcTjYguzAEJ*c{zQFH)L@JcsEL{wP4vaYM9-Z&OQ0?B#Tdo8$=oyd zoO|xwbME)e^h_CJXe*k_8LMZE$#ik4RZ}-b<92>cYEq=BBnk3otjG$?Vt#JKAD%Qj zR>T>IGZ1GW&On@jI0OHN4A489H~A9pePNCJI0JD8{+Aix&xa&kT&5#AE@b%Vpe`%{ zNb(XOY;;d`KaU^Y9-f(z^Soa5!lb}BdQ*nZH|^ckdz%4yT9s+6kg zs#`LLypc>`1Vz8iDD35<9?x@f<$EKy+qOosT3x&628Qigh0wt^Et;~g&vs33q|Gb3 zrXTudgh5ecC9Bnsj;?HOX-uwK)jZai9Bp0EME9*L#>NzRZfe=O?(AV_$o1|Op&)u3 zu$dD=J3duhj$djQaaF7?$Mr=Nm#oaFR%hxxy}SGR)vPwVL;-XT2e#+>yRCvxGON}2 z6zJBx=XMn=Ztu%`PI1Wfvs!K5aPmdR2&|2cld*5JNLS_X}Y*p*}wwt!?I#Z+7 z&Yn}Jssof!H?R-bR-t#qHiJWZ3_owVrtKc=E7`uCbF3cM7_w^7s3@UV{S~_2U(DG@ zigs|TmXhUA+ps`a_nEZ!PS514nc6F|n7?>|uJ7fR_JT#d897|DL|1!!3Q{woiPtr% zYR_Rha?OvnYFe)9y^fKy9L-e3KC7Emy{{zltZk2!YwJ|KKkp3HkxJ_!)&d# zM(@(QW$j}*t7*1dvI*vNd;;xqDt+SN@Dx(%rQ$SFnh?U?GxNgr#UfE7oEiI?#oi(T%+r zL=JhF7(xL7iYVa@+=XMf8~5M@9>wE$0#D*;ynq++65hc3_y8Z`BYci?_!{5fNBki% z3DOLyPMRytlNL%zX|a@&nxz&gEp3&$r9Np;{B)^Is)2H7k=`IV>0v>n8WyCIPEJj# z#O5tqw{8FLkm~F#L8H0z<|jF~)~w%n9)<$9WvE_AfDrW;aV123h>8h_Jws%>GSQ$e zEOT)pM|+7b)=`zlQ7pqsvL>FzE7%ow-m5C_YbTMp9TrU$fH7Ojb%M&XVBA`|w zhK-39Mb;n&Yt}U2n;d~b6pdL%m zgf-ZJE!c%lLUsnd*pDm>!Z$~^i(wprkJ~Xu2p`9tIF9@903O6cg!0D-=N#qF;8{F} z=kY3D!zsLuH}Muu;~l(5xc>xS;#>THUnZb==f!BouT!D9lqtB5=N=?mnFSZST}Gn{ z5lcO<|2JLw`~PJWaU4pVfj9#bGl0sDOh+4OFZIOZwRV!OLArS3^Tve?U8oDoagt#< qPV)Re4Cy{eQ@Kw%lH)>>hT1>=A>gn7sE*(N@%ukSW(d&BwEGiJA7F6+ literal 0 HcmV?d00001 diff --git a/test/unit/database_test.go b/test/unit/database_test.go new file mode 100644 index 000000000..b65bd22b7 --- /dev/null +++ b/test/unit/database_test.go @@ -0,0 +1,153 @@ +package unit + +import ( + "context" + "encoding/json" + "fmt" + "slices" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" +) + +func TestListDatabases(t *testing.T) { + fixtureData, err := fixtures.GetFixture("databases_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("databases/instances", fixtureData) + databases, err := base.Client.ListDatabases(context.Background(), &linodego.ListOptions{}) + assert.NoError(t, err) + assert.NotEmpty(t, databases, "Expected non-empty database list") +} + +func TestGetDatabaseEngine(t *testing.T) { + fixtureData, err := fixtures.GetFixture("database_engine_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + engineID := "mysql-8" + base.MockGet(fmt.Sprintf("databases/engines/%s", engineID), fixtureData) + databaseEngine, err := base.Client.GetDatabaseEngine(context.Background(), &linodego.ListOptions{}, engineID) + assert.NoError(t, err) + assert.NotNil(t, databaseEngine, "Expected database engine object to be returned") + assert.Equal(t, engineID, databaseEngine.ID, "Expected correct database engine ID") + assert.Equal(t, "mysql", databaseEngine.Engine, "Expected MySQL engine") + assert.Equal(t, "8.0", databaseEngine.Version, "Expected MySQL 8.0 version") +} + +func TestListDatabaseTypes(t *testing.T) { + fixtureData, err := fixtures.GetFixture("database_types_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("databases/types", fixtureData) + databaseTypes, err := base.Client.ListDatabaseTypes(context.Background(), &linodego.ListOptions{}) + assert.NoError(t, err) + assert.NotEmpty(t, databaseTypes, "Expected non-empty database types list") +} + +func TestUnmarshalDatabase(t *testing.T) { + fixtureData, err := fixtures.GetFixture("database_unmarshal") + assert.NoError(t, err) + + var data []byte + switch v := fixtureData.(type) { + case []byte: + data = v + case string: + data = []byte(v) + case map[string]interface{}: + data, err = json.Marshal(v) // Convert map to JSON string + assert.NoError(t, err, "Failed to marshal fixtureData") + default: + assert.Fail(t, "Unexpected fixtureData type") + } + + var db linodego.Database + err = json.Unmarshal(data, &db) + assert.NoError(t, err) + assert.Equal(t, 123, db.ID, "Expected correct database ID") + assert.Equal(t, "active", string(db.Status), "Expected active status") + assert.Equal(t, "mysql", db.Engine, "Expected MySQL engine") + assert.Equal(t, 3, db.ClusterSize, "Expected cluster size 3") + assert.NotNil(t, db.Created, "Expected Created timestamp to be set") +} + +func TestDatabaseMaintenanceWindowUnmarshal(t *testing.T) { + fixtureData, err := fixtures.GetFixture("database_maintenance_window") + assert.NoError(t, err) + + var data []byte + switch v := fixtureData.(type) { + case []byte: + data = v + case string: + data = []byte(v) + case map[string]interface{}: + data, err = json.Marshal(v) + assert.NoError(t, err, "Failed to marshal fixtureData") + default: + assert.Fail(t, "Unexpected fixtureData type") + } + + var window linodego.DatabaseMaintenanceWindow + err = json.Unmarshal(data, &window) + assert.NoError(t, err) + assert.Equal(t, linodego.DatabaseMaintenanceDayMonday, window.DayOfWeek, "Expected Monday as maintenance day") + assert.Equal(t, 2, window.Duration, "Expected 2-hour maintenance window") + assert.Equal(t, linodego.DatabaseMaintenanceFrequencyWeekly, window.Frequency, "Expected weekly frequency") + assert.Equal(t, 3, window.HourOfDay, "Expected maintenance at 3 AM") +} + +func TestDatabaseStatusAssertions(t *testing.T) { + expectedStatuses := []string{ + "provisioning", "active", "deleting", "deleted", + "suspending", "suspended", "resuming", "restoring", + "failed", "degraded", "updating", "backing_up", + } + + statuses := []linodego.DatabaseStatus{ + linodego.DatabaseStatusProvisioning, linodego.DatabaseStatusActive, linodego.DatabaseStatusDeleting, + linodego.DatabaseStatusDeleted, linodego.DatabaseStatusSuspending, linodego.DatabaseStatusSuspended, + linodego.DatabaseStatusResuming, linodego.DatabaseStatusRestoring, linodego.DatabaseStatusFailed, + linodego.DatabaseStatusDegraded, linodego.DatabaseStatusUpdating, linodego.DatabaseStatusBackingUp, + } + + for _, status := range statuses { + t.Run(string(status), func(t *testing.T) { + exists := slices.ContainsFunc(expectedStatuses, func(s string) bool { + return s == string(status) + }) + assert.True(t, exists, fmt.Sprintf("Expected status %s to exist", status)) + }) + } +} + +func TestDatabaseMaintenanceFrequencyAssertions(t *testing.T) { + expectedFrequencies := []string{"weekly", "monthly"} + + frequencies := []linodego.DatabaseMaintenanceFrequency{ + linodego.DatabaseMaintenanceFrequencyWeekly, + linodego.DatabaseMaintenanceFrequencyMonthly, + } + + for _, freq := range frequencies { + t.Run(string(freq), func(t *testing.T) { + exists := slices.ContainsFunc(expectedFrequencies, func(f string) bool { + return f == string(freq) + }) + assert.True(t, exists, fmt.Sprintf("Expected frequency %s to exist", freq)) + }) + } +} diff --git a/test/unit/fixtures/database_engine_get.json b/test/unit/fixtures/database_engine_get.json new file mode 100644 index 000000000..028c39043 --- /dev/null +++ b/test/unit/fixtures/database_engine_get.json @@ -0,0 +1,6 @@ +{ + "id": "mysql-8", + "engine": "mysql", + "version": "8.0", + "supported_versions": ["5.7", "8.0"] +} diff --git a/test/unit/fixtures/database_maintenance_window.json b/test/unit/fixtures/database_maintenance_window.json new file mode 100644 index 000000000..e547a7921 --- /dev/null +++ b/test/unit/fixtures/database_maintenance_window.json @@ -0,0 +1,7 @@ +{ + "day_of_week": 1, + "duration": 2, + "frequency": "weekly", + "hour_of_day": 3 +} + \ No newline at end of file diff --git a/test/unit/fixtures/database_types_list.json b/test/unit/fixtures/database_types_list.json new file mode 100644 index 000000000..8c5369741 --- /dev/null +++ b/test/unit/fixtures/database_types_list.json @@ -0,0 +1,22 @@ +{ + "data": [ + { + "id": "g6-standard-1", + "label": "Standard Plan", + "memory": 4096, + "vcpus": 2, + "disk": 80 + }, + { + "id": "g6-standard-2", + "label": "High Performance Plan", + "memory": 8192, + "vcpus": 4, + "disk": 160 + } + ], + "page": 1, + "pages": 1, + "results": 2 +} + \ No newline at end of file diff --git a/test/unit/fixtures/database_unmarshal.json b/test/unit/fixtures/database_unmarshal.json new file mode 100644 index 000000000..7742bf7f5 --- /dev/null +++ b/test/unit/fixtures/database_unmarshal.json @@ -0,0 +1,13 @@ +{ + "id": 123, + "status": "active", + "label": "test-db", + "region": "us-east", + "type": "g6-standard-1", + "engine": "mysql", + "version": "8.0", + "cluster_size": 3, + "platform": "rdbms-default", + "created": "2023-01-01T12:00:00" +} + \ No newline at end of file diff --git a/test/unit/fixtures/databases_list.json b/test/unit/fixtures/databases_list.json new file mode 100644 index 000000000..062475ae8 --- /dev/null +++ b/test/unit/fixtures/databases_list.json @@ -0,0 +1,19 @@ +{ + "data": [ + { + "id": 123, + "status": "active", + "label": "test-db", + "region": "us-east", + "type": "g6-standard-1", + "engine": "mysql", + "version": "8.0", + "cluster_size": 3, + "platform": "rdbms-default", + "created": "2023-01-01T12:00:00" + } + ], + "page": 1, + "pages": 1, + "results": 1 +} diff --git a/test/unit/fixtures/region_availability_get.json b/test/unit/fixtures/region_availability_get.json new file mode 100644 index 000000000..4cfd01eed --- /dev/null +++ b/test/unit/fixtures/region_availability_get.json @@ -0,0 +1,5 @@ +{ + "region": "us-east", + "available": true, + "plan": "Linode 2GB" +} diff --git a/test/unit/fixtures/region_get.json b/test/unit/fixtures/region_get.json new file mode 100644 index 000000000..518949140 --- /dev/null +++ b/test/unit/fixtures/region_get.json @@ -0,0 +1,17 @@ +{ + "id": "us-east", + "country": "US", + "capabilities": ["Linodes", "Block Storage", "Object Storage"], + "status": "ok", + "label": "Newark, NJ", + "site_type": "standard", + "resolvers": { + "ipv4": "8.8.8.8", + "ipv6": "2001:4860:4860::8888" + }, + "placement_group_limits": { + "maximum_pgs_per_customer": 5, + "maximum_linodes_per_pg": 10 + } + } + \ No newline at end of file diff --git a/test/unit/fixtures/regions_availability_list.json b/test/unit/fixtures/regions_availability_list.json new file mode 100644 index 000000000..12232d681 --- /dev/null +++ b/test/unit/fixtures/regions_availability_list.json @@ -0,0 +1,13 @@ +{ + "data": [ + { + "region": "us-east", + "available": true, + "plan": "Linode 2GB" + } + ], + "page": 1, + "pages": 1, + "results": 1 + } + \ No newline at end of file diff --git a/test/unit/fixtures/regions_list.json b/test/unit/fixtures/regions_list.json new file mode 100644 index 000000000..c323ee91b --- /dev/null +++ b/test/unit/fixtures/regions_list.json @@ -0,0 +1,25 @@ +{ + "data": [ + { + "id": "us-east", + "country": "US", + "capabilities": ["Linodes", "Block Storage", "Object Storage"], + "status": "ok", + "label": "US East", + "site_type": "standard", + "resolvers": { + "ipv4": "8.8.8.8", + "ipv6": "2001:4860:4860::8888" + }, + "placement_group_limits": { + "maximum_pgs_per_customer": 10, + "maximum_linodes_per_pg": 5 + } + } + ], + "page": 1, + "pages": 1, + "results": 1 +} + + \ No newline at end of file diff --git a/test/unit/fixtures/stackscript_get.json b/test/unit/fixtures/stackscript_get.json new file mode 100644 index 000000000..d701e304f --- /dev/null +++ b/test/unit/fixtures/stackscript_get.json @@ -0,0 +1,18 @@ +{ + "id": 123, + "username": "testuser", + "label": "new-stackscript", + "description": "Test Description", + "ordinal": 1, + "logo_url": "https://example.com/logo.png", + "images": ["linode/ubuntu20.04"], + "deployments_total": 10, + "deployments_active": 5, + "is_public": true, + "mine": true, + "rev_note": "Initial revision", + "script": "#!/bin/bash\necho Hello", + "user_defined_fields": [], + "user_gravatar_id": "abcdef123456" +} + \ No newline at end of file diff --git a/test/unit/fixtures/stackscript_revision.json b/test/unit/fixtures/stackscript_revision.json new file mode 100644 index 000000000..2eb355bb1 --- /dev/null +++ b/test/unit/fixtures/stackscript_revision.json @@ -0,0 +1,5 @@ +{ + "id": 123, + "label": "Updated Stackscript", + "rev_note": "Updated revision" +} diff --git a/test/unit/fixtures/stackscripts_list.json b/test/unit/fixtures/stackscripts_list.json new file mode 100644 index 000000000..c3fe809d4 --- /dev/null +++ b/test/unit/fixtures/stackscripts_list.json @@ -0,0 +1,37 @@ +{ + "data": [ + { + "id": 123, + "username": "testuser", + "label": "Test Stackscript", + "description": "A test Stackscript", + "images": ["linode/ubuntu20.04"], + "deployments_total": 10, + "deployments_active": 5, + "is_public": true, + "mine": true, + "rev_note": "Initial version", + "script": "#!/bin/bash\necho Hello", + "user_defined_fields": [], + "user_gravatar_id": "abc123" + }, + { + "id": 456, + "username": "anotheruser", + "label": "Another Stackscript", + "description": "Another test Stackscript", + "images": ["linode/debian10"], + "deployments_total": 3, + "deployments_active": 1, + "is_public": false, + "mine": false, + "rev_note": "Another version", + "script": "#!/bin/bash\necho Another", + "user_defined_fields": [], + "user_gravatar_id": "xyz456" + } + ], + "page": 1, + "pages": 1, + "results": 2 +} diff --git a/test/unit/region_test.go b/test/unit/region_test.go new file mode 100644 index 000000000..25969ac11 --- /dev/null +++ b/test/unit/region_test.go @@ -0,0 +1,130 @@ +package unit + +import ( + "context" + "fmt" + "testing" + + "github.com/linode/linodego" + "github.com/stretchr/testify/assert" + "golang.org/x/exp/slices" +) + +func TestListRegions(t *testing.T) { + // Load the fixture data for regions + fixtureData, err := fixtures.GetFixture("regions_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("regions", fixtureData) + + regions, err := base.Client.ListRegions(context.Background(), &linodego.ListOptions{}) + assert.NoError(t, err) + assert.NotEmpty(t, regions, "Expected non-empty region list") + + // Validate a specific region using slices.ContainsFunc + exists := slices.ContainsFunc(regions, func(region linodego.Region) bool { + return region.ID == "us-east" + }) + assert.True(t, exists, "Expected region list to contain 'us-east'") + + // Additional assertions + for _, region := range regions { + assert.NotEmpty(t, region.Country, "Expected region country to be set") + assert.NotEmpty(t, region.Capabilities, "Expected region capabilities to be set") + assert.NotEmpty(t, region.Status, "Expected region status to be set") + assert.NotEmpty(t, region.Label, "Expected region label to be set") + assert.NotEmpty(t, region.SiteType, "Expected region site type to be set") + assert.NotNil(t, region.Resolvers, "Expected region resolvers to be set") + assert.NotEmpty(t, region.Resolvers.IPv4, "Expected IPv4 resolver to be set") + assert.NotEmpty(t, region.Resolvers.IPv6, "Expected IPv6 resolver to be set") + assert.NotNil(t, region.PlacementGroupLimits, "Expected placement group limits to be set") + if region.PlacementGroupLimits != nil { + assert.Greater(t, region.PlacementGroupLimits.MaximumPGsPerCustomer, 0, "Expected MaximumPGsPerCustomer to be greater than 0") + assert.Greater(t, region.PlacementGroupLimits.MaximumLinodesPerPG, 0, "Expected MaximumLinodesPerPG to be greater than 0") + } + assert.Contains(t, region.Capabilities, linodego.CapabilityLinodes, "Expected region to support Linodes") + } +} + +func TestGetRegion(t *testing.T) { + // Load the fixture data for a specific region + fixtureData, err := fixtures.GetFixture("region_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + regionID := "us-east" + base.MockGet(fmt.Sprintf("regions/%s", regionID), fixtureData) + + region, err := base.Client.GetRegion(context.Background(), regionID) + assert.NoError(t, err) + assert.NotNil(t, region, "Expected region object to be returned") + assert.Equal(t, "us-east", region.ID, "Expected region ID to be 'us-east'") + assert.NotEmpty(t, region.Country, "Expected Country field to be populated") + assert.NotEmpty(t, region.Capabilities, "Expected Capabilities field to be populated") + assert.NotEmpty(t, region.Status, "Expected Status field to be populated") + assert.NotEmpty(t, region.Label, "Expected Label field to be populated") + assert.NotEmpty(t, region.SiteType, "Expected SiteType field to be populated") + assert.NotNil(t, region.Resolvers, "Expected Resolvers field to be populated") + assert.NotEmpty(t, region.Resolvers.IPv4, "Expected IPv4 resolver to be set") + assert.NotEmpty(t, region.Resolvers.IPv6, "Expected IPv6 resolver to be set") + assert.NotNil(t, region.PlacementGroupLimits, "Expected PlacementGroupLimits field to be set") + if region.PlacementGroupLimits != nil { + assert.Greater(t, region.PlacementGroupLimits.MaximumPGsPerCustomer, 0, "Expected MaximumPGsPerCustomer to be greater than 0") + assert.Greater(t, region.PlacementGroupLimits.MaximumLinodesPerPG, 0, "Expected MaximumLinodesPerPG to be greater than 0") + } + assert.Contains(t, region.Capabilities, linodego.CapabilityLinodes, "Expected region to support Linodes") +} + +func TestListRegionsAvailability(t *testing.T) { + // Load the fixture data for region availability + fixtureData, err := fixtures.GetFixture("regions_availability_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockGet("regions/availability", fixtureData) + + availability, err := base.Client.ListRegionsAvailability(context.Background(), &linodego.ListOptions{}) + assert.NoError(t, err) + assert.NotEmpty(t, availability, "Expected non-empty region availability list") + + // Check if a specific region availability exists using slices.ContainsFunc + exists := slices.ContainsFunc(availability, func(a linodego.RegionAvailability) bool { + return a.Region == "us-east" && a.Available + }) + assert.True(t, exists, "Expected region availability list to contain 'us-east' with available status") + + // Additional assertions + for _, avail := range availability { + assert.NotEmpty(t, avail.Plan, "Expected plan to be set") + } +} + +func TestGetRegionAvailability(t *testing.T) { + // Load the fixture data for a specific region availability + fixtureData, err := fixtures.GetFixture("region_availability_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + regionID := "us-east" + base.MockGet(fmt.Sprintf("regions/%s/availability", regionID), fixtureData) + + availability, err := base.Client.GetRegionAvailability(context.Background(), regionID) + assert.NoError(t, err) + assert.NotNil(t, availability, "Expected region availability object to be returned") + assert.Equal(t, "us-east", availability.Region, "Expected region ID to be 'us-east'") + assert.True(t, availability.Available, "Expected region to be available") + assert.NotEmpty(t, availability.Plan, "Expected plan to be set") +} diff --git a/test/unit/stackscripts_test.go b/test/unit/stackscripts_test.go new file mode 100644 index 000000000..b6202350b --- /dev/null +++ b/test/unit/stackscripts_test.go @@ -0,0 +1,122 @@ +package unit + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/linode/linodego" + "golang.org/x/exp/slices" +) + +func TestListStackscripts(t *testing.T) { + // Mock the API response to match the expected structure for a paginated response + fixtureData, err := fixtures.GetFixture("stackscripts_list") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + // Mock the request with a correct paginated structure + base.MockGet("linode/stackscripts", fixtureData) + + stackscripts, err := base.Client.ListStackscripts(context.Background(), &linodego.ListOptions{}) + assert.NoError(t, err) + + assert.NotEmpty(t, stackscripts, "Expected non-empty stackscripts list") + + // Check if a specific stackscript exists using slices.ContainsFunc + exists := slices.ContainsFunc(stackscripts, func(stackscript linodego.Stackscript) bool { + return stackscript.Label == "Test Stackscript" + }) + + assert.True(t, exists, "Expected stackscripts list to contain 'Test Stackscript'") +} + +func TestCreateStackscript(t *testing.T) { + // Load the fixture data for stackscript creation + fixtureData, err := fixtures.GetFixture("stackscript_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + base.MockPost("linode/stackscripts", fixtureData) + + opts := linodego.StackscriptCreateOptions{ + Label: "new-stackscript", + Description: "A new stackscript", + Images: []string{"linode/ubuntu20.04"}, + IsPublic: true, + RevNote: "Initial revision", + Script: "#!/bin/bash\necho Hello", + } + + stackscript, err := base.Client.CreateStackscript(context.Background(), opts) + assert.NoError(t, err, "Expected no error when creating stackscript") + + // Verify the created stackscript's label + assert.Equal(t, "new-stackscript", stackscript.Label, "Expected created stackscript label to match input") +} + +func TestDeleteStackscript(t *testing.T) { + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + stackscriptID := 123 + base.MockDelete(fmt.Sprintf("linode/stackscripts/%d", stackscriptID), nil) + + err := base.Client.DeleteStackscript(context.Background(), stackscriptID) + assert.NoError(t, err, "Expected no error when deleting stackscript") +} + +func TestGetStackscript(t *testing.T) { + // Load the fixture data for a single stackscript + fixtureData, err := fixtures.GetFixture("stackscript_get") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + stackscriptID := 123 + base.MockGet(fmt.Sprintf("linode/stackscripts/%d", stackscriptID), fixtureData) + + stackscript, err := base.Client.GetStackscript(context.Background(), stackscriptID) + assert.NoError(t, err) + + // Verify the stackscript's label + assert.Equal(t, "new-stackscript", stackscript.Label, "Expected stackscript label to match fixture") +} + +func TestUpdateStackscript(t *testing.T) { + // Load the fixture data for stackscript update + fixtureData, err := fixtures.GetFixture("stackscript_revision") + assert.NoError(t, err) + + var base ClientBaseCase + base.SetUp(t) + defer base.TearDown(t) + + stackscriptID := 123 + base.MockPut(fmt.Sprintf("linode/stackscripts/%d", stackscriptID), fixtureData) + + opts := linodego.StackscriptUpdateOptions{ + Label: "Updated Stackscript", + Description: "Updated description", + Images: []string{"linode/ubuntu20.04"}, + IsPublic: false, + RevNote: "Updated revision", + Script: "#!/bin/bash\necho Hello Updated", + } + + updatedStackscript, err := base.Client.UpdateStackscript(context.Background(), stackscriptID, opts) + assert.NoError(t, err) + + // Verify the updated stackscript's label + assert.Equal(t, "Updated Stackscript", updatedStackscript.Label, "Expected updated stackscript label to match input") +}