|  | 
|  | 1 | +package unit | 
|  | 2 | + | 
|  | 3 | +import ( | 
|  | 4 | +	"context" | 
|  | 5 | +	"encoding/json" | 
|  | 6 | +	"fmt" | 
|  | 7 | +	"slices" | 
|  | 8 | +	"testing" | 
|  | 9 | + | 
|  | 10 | +	"github.com/linode/linodego" | 
|  | 11 | +	"github.com/stretchr/testify/assert" | 
|  | 12 | +) | 
|  | 13 | + | 
|  | 14 | +func TestListDatabases(t *testing.T) { | 
|  | 15 | +	fixtureData, err := fixtures.GetFixture("databases_list") | 
|  | 16 | +	assert.NoError(t, err) | 
|  | 17 | + | 
|  | 18 | +	var base ClientBaseCase | 
|  | 19 | +	base.SetUp(t) | 
|  | 20 | +	defer base.TearDown(t) | 
|  | 21 | + | 
|  | 22 | +	base.MockGet("databases/instances", fixtureData) | 
|  | 23 | +	databases, err := base.Client.ListDatabases(context.Background(), &linodego.ListOptions{}) | 
|  | 24 | +	assert.NoError(t, err) | 
|  | 25 | +	assert.NotEmpty(t, databases, "Expected non-empty database list") | 
|  | 26 | +} | 
|  | 27 | + | 
|  | 28 | +func TestGetDatabaseEngine(t *testing.T) { | 
|  | 29 | +	fixtureData, err := fixtures.GetFixture("database_engine_get") | 
|  | 30 | +	assert.NoError(t, err) | 
|  | 31 | + | 
|  | 32 | +	var base ClientBaseCase | 
|  | 33 | +	base.SetUp(t) | 
|  | 34 | +	defer base.TearDown(t) | 
|  | 35 | + | 
|  | 36 | +	engineID := "mysql-8" | 
|  | 37 | +	base.MockGet(fmt.Sprintf("databases/engines/%s", engineID), fixtureData) | 
|  | 38 | +	databaseEngine, err := base.Client.GetDatabaseEngine(context.Background(), &linodego.ListOptions{}, engineID) | 
|  | 39 | +	assert.NoError(t, err) | 
|  | 40 | +	assert.NotNil(t, databaseEngine, "Expected database engine object to be returned") | 
|  | 41 | +	assert.Equal(t, engineID, databaseEngine.ID, "Expected correct database engine ID") | 
|  | 42 | +	assert.Equal(t, "mysql", databaseEngine.Engine, "Expected MySQL engine") | 
|  | 43 | +	assert.Equal(t, "8.0", databaseEngine.Version, "Expected MySQL 8.0 version") | 
|  | 44 | +} | 
|  | 45 | + | 
|  | 46 | +func TestListDatabaseTypes(t *testing.T) { | 
|  | 47 | +	fixtureData, err := fixtures.GetFixture("database_types_list") | 
|  | 48 | +	assert.NoError(t, err) | 
|  | 49 | + | 
|  | 50 | +	var base ClientBaseCase | 
|  | 51 | +	base.SetUp(t) | 
|  | 52 | +	defer base.TearDown(t) | 
|  | 53 | + | 
|  | 54 | +	base.MockGet("databases/types", fixtureData) | 
|  | 55 | +	databaseTypes, err := base.Client.ListDatabaseTypes(context.Background(), &linodego.ListOptions{}) | 
|  | 56 | +	assert.NoError(t, err) | 
|  | 57 | +	assert.NotEmpty(t, databaseTypes, "Expected non-empty database types list") | 
|  | 58 | +} | 
|  | 59 | + | 
|  | 60 | +func TestUnmarshalDatabase(t *testing.T) { | 
|  | 61 | +	fixtureData, err := fixtures.GetFixture("database_unmarshal") | 
|  | 62 | +	assert.NoError(t, err) | 
|  | 63 | + | 
|  | 64 | +	var data []byte | 
|  | 65 | +	switch v := fixtureData.(type) { | 
|  | 66 | +	case []byte: | 
|  | 67 | +		data = v | 
|  | 68 | +	case string: | 
|  | 69 | +		data = []byte(v) | 
|  | 70 | +	case map[string]interface{}: | 
|  | 71 | +		data, err = json.Marshal(v) // Convert map to JSON string | 
|  | 72 | +		assert.NoError(t, err, "Failed to marshal fixtureData") | 
|  | 73 | +	default: | 
|  | 74 | +		assert.Fail(t, "Unexpected fixtureData type") | 
|  | 75 | +	} | 
|  | 76 | + | 
|  | 77 | +	var db linodego.Database | 
|  | 78 | +	err = json.Unmarshal(data, &db) | 
|  | 79 | +	assert.NoError(t, err) | 
|  | 80 | +	assert.Equal(t, 123, db.ID, "Expected correct database ID") | 
|  | 81 | +	assert.Equal(t, "active", string(db.Status), "Expected active status") | 
|  | 82 | +	assert.Equal(t, "mysql", db.Engine, "Expected MySQL engine") | 
|  | 83 | +	assert.Equal(t, 3, db.ClusterSize, "Expected cluster size 3") | 
|  | 84 | +	assert.NotNil(t, db.Created, "Expected Created timestamp to be set") | 
|  | 85 | +} | 
|  | 86 | + | 
|  | 87 | +func TestDatabaseMaintenanceWindowUnmarshal(t *testing.T) { | 
|  | 88 | +	fixtureData, err := fixtures.GetFixture("database_maintenance_window") | 
|  | 89 | +	assert.NoError(t, err) | 
|  | 90 | + | 
|  | 91 | +	var data []byte | 
|  | 92 | +	switch v := fixtureData.(type) { | 
|  | 93 | +	case []byte: | 
|  | 94 | +		data = v | 
|  | 95 | +	case string: | 
|  | 96 | +		data = []byte(v) | 
|  | 97 | +	case map[string]interface{}: | 
|  | 98 | +		data, err = json.Marshal(v) | 
|  | 99 | +		assert.NoError(t, err, "Failed to marshal fixtureData") | 
|  | 100 | +	default: | 
|  | 101 | +		assert.Fail(t, "Unexpected fixtureData type") | 
|  | 102 | +	} | 
|  | 103 | + | 
|  | 104 | +	var window linodego.DatabaseMaintenanceWindow | 
|  | 105 | +	err = json.Unmarshal(data, &window) | 
|  | 106 | +	assert.NoError(t, err) | 
|  | 107 | +	assert.Equal(t, linodego.DatabaseMaintenanceDayMonday, window.DayOfWeek, "Expected Monday as maintenance day") | 
|  | 108 | +	assert.Equal(t, 2, window.Duration, "Expected 2-hour maintenance window") | 
|  | 109 | +	assert.Equal(t, linodego.DatabaseMaintenanceFrequencyWeekly, window.Frequency, "Expected weekly frequency") | 
|  | 110 | +	assert.Equal(t, 3, window.HourOfDay, "Expected maintenance at 3 AM") | 
|  | 111 | +} | 
|  | 112 | + | 
|  | 113 | +func TestDatabaseStatusAssertions(t *testing.T) { | 
|  | 114 | +	expectedStatuses := []string{ | 
|  | 115 | +		"provisioning", "active", "deleting", "deleted", | 
|  | 116 | +		"suspending", "suspended", "resuming", "restoring", | 
|  | 117 | +		"failed", "degraded", "updating", "backing_up", | 
|  | 118 | +	} | 
|  | 119 | + | 
|  | 120 | +	statuses := []linodego.DatabaseStatus{ | 
|  | 121 | +		linodego.DatabaseStatusProvisioning, linodego.DatabaseStatusActive, linodego.DatabaseStatusDeleting, | 
|  | 122 | +		linodego.DatabaseStatusDeleted, linodego.DatabaseStatusSuspending, linodego.DatabaseStatusSuspended, | 
|  | 123 | +		linodego.DatabaseStatusResuming, linodego.DatabaseStatusRestoring, linodego.DatabaseStatusFailed, | 
|  | 124 | +		linodego.DatabaseStatusDegraded, linodego.DatabaseStatusUpdating, linodego.DatabaseStatusBackingUp, | 
|  | 125 | +	} | 
|  | 126 | + | 
|  | 127 | +	for _, status := range statuses { | 
|  | 128 | +		t.Run(string(status), func(t *testing.T) { | 
|  | 129 | +			exists := slices.ContainsFunc(expectedStatuses, func(s string) bool { | 
|  | 130 | +				return s == string(status) | 
|  | 131 | +			}) | 
|  | 132 | +			assert.True(t, exists, fmt.Sprintf("Expected status %s to exist", status)) | 
|  | 133 | +		}) | 
|  | 134 | +	} | 
|  | 135 | +} | 
|  | 136 | + | 
|  | 137 | +func TestDatabaseMaintenanceFrequencyAssertions(t *testing.T) { | 
|  | 138 | +	expectedFrequencies := []string{"weekly", "monthly"} | 
|  | 139 | + | 
|  | 140 | +	frequencies := []linodego.DatabaseMaintenanceFrequency{ | 
|  | 141 | +		linodego.DatabaseMaintenanceFrequencyWeekly, | 
|  | 142 | +		linodego.DatabaseMaintenanceFrequencyMonthly, | 
|  | 143 | +	} | 
|  | 144 | + | 
|  | 145 | +	for _, freq := range frequencies { | 
|  | 146 | +		t.Run(string(freq), func(t *testing.T) { | 
|  | 147 | +			exists := slices.ContainsFunc(expectedFrequencies, func(f string) bool { | 
|  | 148 | +				return f == string(freq) | 
|  | 149 | +			}) | 
|  | 150 | +			assert.True(t, exists, fmt.Sprintf("Expected frequency %s to exist", freq)) | 
|  | 151 | +		}) | 
|  | 152 | +	} | 
|  | 153 | +} | 
0 commit comments