func TestInstanceList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/instances", "GET", "", listInstancesResp, 200)
opts := &ListOpts{
IncludeHA: false,
IncludeReplicas: false,
}
pages := 0
err := List(fake.ServiceClient(), opts).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractInstances(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, []Instance{*expectedInstance}, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestListBackups(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL+"/backups", "GET", "", listBackupsResp, 200)
pages := 0
err := ListBackups(fake.ServiceClient(), instanceID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := backups.ExtractBackups(page)
th.AssertNoErr(t, err)
expected := []backups.Backup{
backups.Backup{
Created: timeVal,
Description: "Backup from Restored Instance",
ID: "87972694-4be2-40f5-83f8-501656e0032a",
InstanceID: "29af2cd9-0674-48ab-b87a-b160f00208e6",
LocationRef: "http://localhost/path/to/backup",
Name: "restored_backup",
ParentID: "",
Size: 0.141026,
Status: "COMPLETED",
Updated: timeVal,
Datastore: datastores.DatastorePartial{Version: "5.1", Type: "MySQL", VersionID: "20000000-0000-0000-0000-000000000002"},
},
}
th.AssertDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", getResp, 200)
instance, err := Get(fake.ServiceClient(), backupID).Extract()
th.AssertNoErr(t, err)
expected := &Backup{
Created: timeVal,
Description: "My Backup",
ID: "61f12fef-edb1-4561-8122-e7c00ef26a82",
InstanceID: "d4603f69-ec7e-4e9b-803f-600b9205576f",
LocationRef: "",
Name: "snapshot",
ParentID: "",
Size: 100,
Status: "NEW",
Updated: timeVal,
Datastore: datastores.DatastorePartial{
Version: "5.1",
Type: "MySQL",
VersionID: "20000000-0000-0000-0000-000000000002",
},
}
th.AssertDeepEquals(t, expected, instance)
}
func TestUserAccessList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _userURL+"/databases", "GET", "", listUserAccessResp, 200)
expectedDBs := []db.Database{
db.Database{Name: "databaseE"},
}
pages := 0
err := ListAccess(fake.ServiceClient(), instanceID, userName).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractDBs(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, expectedDBs, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _rootURL, "POST", createReq, createResp, 200)
opts := CreateOpts{
Name: "json_rack_instance",
FlavorRef: "1",
Databases: osDBs.BatchCreateOpts{
osDBs.CreateOpts{CharSet: "utf8", Collate: "utf8_general_ci", Name: "sampledb"},
osDBs.CreateOpts{Name: "nextround"},
},
Users: osUsers.BatchCreateOpts{
osUsers.CreateOpts{
Name: "demouser",
Password: "******",
Databases: osDBs.BatchCreateOpts{
osDBs.CreateOpts{Name: "sampledb"},
},
},
},
Size: 2,
RestorePoint: "1234567890",
}
instance, err := Create(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expectedInstance, instance)
}
func TestListInstances(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL+"/instances", "GET", "", ListInstancesJSON, 200)
expectedInstance := instances.Instance{
ID: "d4603f69-ec7e-4e9b-803f-600b9205576f",
Name: "json_rack_instance",
}
pages := 0
err := ListInstances(fake.ServiceClient(), configID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := instances.ExtractInstances(page)
if err != nil {
return false, err
}
th.AssertDeepEquals(t, actual, []instances.Instance{expectedInstance})
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestListGlobalParams(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, globalParamListURL, "GET", "", ListParamsJSON, 200)
pages := 0
err := ListGlobalParams(fake.ServiceClient(), versionID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractParams(page)
if err != nil {
return false, err
}
expected := []Param{
Param{Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer"},
Param{Max: 4294967296, Min: 0, Name: "key_buffer_size", RestartRequired: false, Type: "integer"},
Param{Max: 65535, Min: 2, Name: "connect_timeout", RestartRequired: false, Type: "integer"},
Param{Max: 4294967296, Min: 0, Name: "join_buffer_size", RestartRequired: false, Type: "integer"},
}
th.AssertDeepEquals(t, actual, expected)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestGetReplica(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", getReplicaResp, 200)
replica, err := Get(fake.ServiceClient(), instanceID).Extract()
th.AssertNoErr(t, err)
expectedReplica := &Instance{
Status: "ACTIVE",
Updated: timeVal,
Name: "t1_ALT_GUEST",
Created: timeVal,
IP: []string{
"10.0.0.2",
},
Replicas: []Instance{
Instance{ID: "3c691f06-bf9a-4618-b7ec-2817ce0cf254"},
},
ID: "8b499b45-52d6-402d-b398-f9d8f279c69a",
Volume: os.Volume{
Used: 0.54,
Size: 1,
},
Flavor: flavors.Flavor{ID: "9"},
Datastore: datastores.DatastorePartial{
Version: "5.6",
Type: "mysql",
},
}
th.AssertDeepEquals(t, replica, expectedReplica)
}
func TestDetachReplica(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "PATCH", detachReq, "", 202)
err := DetachReplica(fake.ServiceClient(), instanceID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestRevokeAccess(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _dbURL+"/{dbName}", "DELETE", "", "", 202)
err := RevokeAccess(fake.ServiceClient(), instanceID, userName, "{dbName}").ExtractErr()
th.AssertNoErr(t, err)
}
func TestAssociateWithConfigGroup(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "PUT", associateReq, associateResp, 202)
res := AssociateWithConfigGroup(fake.ServiceClient(), instanceID, "{configGroupID}")
th.AssertNoErr(t, res.Err)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "DELETE", "", "", 202)
err := Delete(fake.ServiceClient(), configID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestGetVersion(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/datastores/{dsID}/versions/{versionID}", "GET", "", GetVersionResp, 200)
ds, err := GetVersion(fake.ServiceClient(), "{dsID}", "{versionID}").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, &ExampleVersion1, ds)
}
func TestGrantAccess(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _dbURL, "PUT", grantUserAccessReq, "", 202)
opts := db.BatchCreateOpts{db.CreateOpts{Name: "databaseE"}}
err := GrantAccess(fake.ServiceClient(), instanceID, userName, opts).ExtractErr()
th.AssertNoErr(t, err)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", GetConfigJSON, 200)
config, err := Get(fake.ServiceClient(), configID).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, &ExampleConfig, config)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/datastores/{dsID}", "GET", "", os.GetDSResp, 200)
ds, err := Get(fake.ServiceClient(), "{dsID}").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, &os.ExampleDatastore, ds)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", getResp, 200)
instance, err := Get(fake.ServiceClient(), instanceID).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expectedInstance, instance)
}
func TestGetConfig(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL+"/configuration", "GET", "", getConfigResp, 200)
config, err := GetDefaultConfig(fake.ServiceClient(), instanceID).Extract()
expected := map[string]string{
"basedir": "/usr",
"connect_timeout": "15",
"datadir": "/var/lib/mysql",
"default_storage_engine": "innodb",
"innodb_buffer_pool_instances": "1",
"innodb_buffer_pool_size": "175M",
"innodb_checksum_algorithm": "crc32",
"innodb_data_file_path": "ibdata1:10M:autoextend",
"innodb_file_per_table": "1",
"innodb_io_capacity": "200",
"innodb_log_file_size": "256M",
"innodb_log_files_in_group": "2",
"innodb_open_files": "8192",
"innodb_thread_concurrency": "0",
"join_buffer_size": "1M",
"key_buffer_size": "50M",
"local-infile": "0",
"log-error": "/var/log/mysql/mysqld.log",
"max_allowed_packet": "16M",
"max_connect_errors": "10000",
"max_connections": "40",
"max_heap_table_size": "16M",
"myisam-recover": "BACKUP",
"open_files_limit": "8192",
"performance_schema": "off",
"pid_file": "/var/run/mysqld/mysqld.pid",
"port": "3306",
"query_cache_limit": "1M",
"query_cache_size": "8M",
"query_cache_type": "1",
"read_buffer_size": "256K",
"read_rnd_buffer_size": "1M",
"server_id": "1",
"skip-external-locking": "1",
"skip_name_resolve": "1",
"sort_buffer_size": "256K",
"table_open_cache": "4096",
"thread_stack": "192K",
"tmp_table_size": "16M",
"tmpdir": "/var/tmp",
"user": "******",
"wait_timeout": "3600",
}
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, config)
}
func TestChangeUserPassword(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _rootURL, "PUT", changePwdReq, "", 202)
opts := os.BatchCreateOpts{
os.CreateOpts{Name: "dbuser1", Password: "******"},
os.CreateOpts{Name: "dbuser2", Password: "******"},
}
err := ChangePassword(fake.ServiceClient(), instanceID, opts).ExtractErr()
th.AssertNoErr(t, err)
}
func TestUpdateUser(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _userURL, "PUT", updateReq, "", 202)
opts := UpdateOpts{
Name: "new_username",
Password: "******",
}
err := Update(fake.ServiceClient(), instanceID, userName, opts).ExtractErr()
th.AssertNoErr(t, err)
}
func TestReplace(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "PUT", UpdateReq, "", 202)
opts := UpdateOpts{
Values: map[string]interface{}{
"connect_timeout": 300,
},
}
err := Replace(fake.ServiceClient(), configID, opts).ExtractErr()
th.AssertNoErr(t, err)
}
func TestGetGlobalParam(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, globalParamGetURL, "GET", "", GetParamJSON, 200)
param, err := GetGlobalParam(fake.ServiceClient(), versionID, paramID).Extract()
th.AssertNoErr(t, err)
expected := &Param{
Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer",
}
th.AssertDeepEquals(t, expected, param)
}
func TestCreateReplica(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _rootURL, "POST", createReplicaReq, createReplicaResp, 200)
opts := CreateOpts{
Name: "t2s1_ALT_GUEST",
FlavorRef: "9",
Size: 1,
ReplicaOf: "6bdca2fc-418e-40bd-a595-62abda61862d",
}
replica, err := Create(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expectedReplica, replica)
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _baseURL, "GET", "", ListConfigsJSON, 200)
count := 0
err := List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractConfigs(page)
th.AssertNoErr(t, err)
expected := []Config{ExampleConfig}
th.AssertDeepEquals(t, expected, actual)
return true, nil
})
th.AssertEquals(t, 1, count)
th.AssertNoErr(t, err)
}
func TestGetUser(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _userURL, "GET", "", getResp, 200)
user, err := Get(fake.ServiceClient(), instanceID, userName).Extract()
th.AssertNoErr(t, err)
expected := &User{
Name: "exampleuser",
Host: "foo",
Databases: []db.Database{
db.Database{Name: "databaseA"},
db.Database{Name: "databaseB"},
},
}
th.AssertDeepEquals(t, expected, user)
}
func TestUserList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/instances/"+instanceID+"/users", "GET", "", listResp, 200)
expectedUsers := []User{
User{
Databases: []db.Database{
db.Database{Name: "databaseA"},
},
Name: "dbuser1",
Host: "localhost",
},
User{
Databases: []db.Database{
db.Database{Name: "databaseB"},
db.Database{Name: "databaseC"},
},
Name: "dbuser2",
Host: "localhost",
},
}
pages := 0
err := List(fake.ServiceClient(), instanceID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractUsers(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, expectedUsers, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestListReplicas(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _rootURL, "GET", "", listReplicasResp, 200)
pages := 0
err := List(fake.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractInstances(page)
if err != nil {
return false, err
}
expected := []Instance{
Instance{
Status: "ACTIVE",
Name: "t1s1_ALT_GUEST",
Links: []gophercloud.Link{
gophercloud.Link{Rel: "self", Href: "https://ord.databases.api.rackspacecloud.com/v1.0/1234/instances/3c691f06-bf9a-4618-b7ec-2817ce0cf254"},
gophercloud.Link{Rel: "bookmark", Href: "https://ord.databases.api.rackspacecloud.com/instances/3c691f06-bf9a-4618-b7ec-2817ce0cf254"},
},
ID: "3c691f06-bf9a-4618-b7ec-2817ce0cf254",
IP: []string{"10.0.0.3"},
Volume: os.Volume{Size: 1},
Flavor: flavors.Flavor{ID: "9"},
Datastore: datastores.DatastorePartial{Version: "5.6", Type: "mysql"},
ReplicaOf: &Instance{
ID: "8b499b45-52d6-402d-b398-f9d8f279c69a",
},
},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _baseURL, "POST", CreateReq, CreateConfigJSON, 200)
opts := CreateOpts{
Datastore: &DatastoreOpts{
Type: "a00000a0-00a0-0a00-00a0-000a000000aa",
Version: "b00000b0-00b0-0b00-00b0-000b000000bb",
},
Description: "example description",
Name: "example-configuration-name",
Values: map[string]interface{}{
"collation_server": "latin1_swedish_ci",
"connect_timeout": 120,
},
}
config, err := Create(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, &ExampleConfigWithValues, config)
}
func TestListVersions(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/datastores/{dsID}/versions", "GET", "", ListVersionsResp, 200)
pages := 0
err := ListVersions(fake.ServiceClient(), "{dsID}").EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractVersions(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, ExampleVersions, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, "/datastores", "GET", "", os.ListDSResp, 200)
pages := 0
err := List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := os.ExtractDatastores(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, []os.Datastore{os.ExampleDatastore}, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}