func TestDefaultServiceResolverURLNotFoundInServiceCatalogError(t *testing.T) {
apiServer := testVersionList(t)
defer apiServer.Close()
url, err := defaultGetVersionURLFilterByVersion("t", nil, []service{}, "image", "region1", "1")
testUtil.Equals(t, "", url)
testUtil.Assert(t, err != nil, "Expected an error")
testUtil.Equals(t, "ServiceCatalog does not contain serviceType 'image'", err.Error())
}
func TestDefaultServiceURLFoundInCatalogErrorsNotFoundInVersionList(t *testing.T) {
apiServer := testVersionList(t)
defer apiServer.Close()
sc := []service{createService("image", "glance", endpoint{Region: "region1", PublicURL: apiServer.URL + "/publicurl", VersionList: apiServer.URL + "/versionlist"})}
url, err := defaultGetVersionURLFilterByVersion("t", nil, sc, "image", "region1", "2")
testUtil.Equals(t, "", url)
testUtil.Assert(t, err != nil, "Expected an error")
testUtil.Equals(t, "Found serviceType 'image' in the ServiceCatalog but cannot find an endpoint with the specified region 'region1' and version '2'", err.Error())
}
func TestGetVolumeTypes(t *testing.T) {
apiServer := testUtil.CreateGetJSONTestRequestServerVerifyStatusAndURL(t, tokn, 200, sampleVolumeTypesJson, "/types")
defer apiServer.Close()
service := CreateVolumeService(apiServer.URL)
volumes, err := service.VolumeTypes()
testUtil.IsNil(t, err)
testUtil.Assert(t, len(volumes) == 1, "Expected 1 volume")
testUtil.Equals(t, volumeTypeSample, volumes[0])
}
func TestSecurityGroupScenarios(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
authenticator, err := identity.AuthenticateFromEnvVars()
if err != nil {
t.Fatal("Cannot authenticate from env vars:", err)
}
computeService := compute.NewService(authenticator)
sampleSecurityGroup := compute.CreateSecurityGroupParameters{
Description: "Description",
Name: "NewCustomSecurityGroup",
}
securityGroup, err := computeService.CreateSecurityGroup(sampleSecurityGroup)
if err != nil {
t.Fatal("Cannot create security group:", err)
}
tcp := compute.TCP
cidr := "0.0.0.0/0"
sampleRule := compute.CreateSecurityGroupRuleParameters{
FromPort: 80,
ToPort: 80,
IPProtocol: tcp,
CIDR: &cidr,
ParentGroupID: securityGroup.ID,
}
securityGroupRule, err := computeService.CreateSecurityGroupRule(sampleRule)
if err != nil {
t.Fatal("Cannot create security group rule:", err)
}
queriedSecurityGroup, err := computeService.SecurityGroup(securityGroup.ID)
if err != nil {
t.Fatal("Cannot requery security group:", err)
}
testUtil.Assert(t, len(queriedSecurityGroup.Rules) > 0, "Expected Security group to have a rule")
err = computeService.DeleteSecurityGroupRule(securityGroupRule.ID)
if err != nil {
t.Fatal("Cannot delete security group rule:", err)
}
err = computeService.DeleteSecurityGroup(queriedSecurityGroup.ID)
if err != nil {
t.Fatal("Cannot delete security group:", err)
}
}
func authenticate(t *testing.T) (string, common.Authenticator, common.AuthenticationParameters) {
ap := getAuthenticationParameters(t)
authenticator := identity.Authenticate(ap)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
tokenID, err := authenticator.GetToken()
testUtil.IsNil(t, err)
testUtil.Assert(t, tokenID != "", "No tokenID was found.")
return tokenID, &authenticator, ap
}
func TestQueryServersDetail(t *testing.T) {
apiServer := testUtil.CreateGetJSONTestRequestServerVerifyURL(t, tokn, serversDetailJSONPayload, "/servers/detail?limit=21&name=foo")
defer apiServer.Close()
computeService := CreateComputeService(apiServer.URL)
queryParameters := ServerDetailQueryParameters{Name: "foo"}
servers, err := computeService.QueryServersDetail(queryParameters)
testUtil.IsNil(t, err)
testUtil.Assert(t, len(servers) == 1, "Expected 1 server.")
testUtil.Equals(t, serverDetail, servers[0])
}
func getServiceURLInitialize(t *testing.T, serviceType string) (string, string, common.AuthenticationParameters, common.Authenticator) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
version, ok := currentRunningMap[serviceType]
if !ok {
t.Skip("skipping test as the service type is not in the map specifying the version to use.")
}
tokenID, authenticator, ap := authenticate(t)
serviceURL, err := authenticator.GetServiceURL(serviceType, version)
testUtil.IsNil(t, err)
testUtil.Assert(t, serviceURL != "", "No service URL was found.")
return tokenID, serviceURL, ap, authenticator
}
func TestFromFromEnvVarsShouldErrorWithNoAuthURLUserNameAndPassword(t *testing.T) {
savedParams, _ := common.FromEnvVars()
if savedParams.AuthURL != "" {
t.Skip("Skipping testing as open stack environments are set.")
}
os.Setenv("OS_AUTH_URL", "")
os.Setenv("OS_TENANT_ID", "")
os.Setenv("OS_TENANT_NAME", "")
os.Setenv("OS_USERNAME", "")
os.Setenv("OS_PASSWORD", "")
os.Setenv("OS_REGION_NAME", "")
_, err := common.FromEnvVars()
testUtil.Assert(t, err != nil, "Expected an error")
testUtil.Equals(t, "No value provided for env variable 'OS_AUTH_URL'\nNo value provided for env variable 'OS_REGION_NAME'\nEither AuthToken or Username-Password should be provided", err.Error())
applyParameter(savedParams)
}
// Image examples.
func TestDatabaseServiceScenarios(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
if os.Getenv("OS_AUTH_URL") == "" {
t.Skip("Cannot run integration test as the Openstack env vars aren't set.")
}
authenticator, err := identity.AuthenticateFromEnvVars()
authenticator.(requester.Manager).SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
if err != nil {
t.Fatal("Cannot authenticate from env vars:", err)
}
databaseService := database.NewService(authenticator)
user := database.UserParameter{Name: "User1", Password: "******"}
db := database.CreateDatabaseParameters{Name: "newDb"}
createInstanceParams := database.CreateInstanceParameters{
Databases: []database.CreateDatabaseParameters{db},
FlavorRef: "1001",
Name: "Instance1",
Users: []database.UserParameter{user},
}
instance, err := databaseService.CreateInstance(createInstanceParams)
if err != nil {
t.Fatal("Cannot create instance:", err)
}
WaitUntilActiveOrError(t, databaseService, instance.ID)
foundInstance := false
instances, err := databaseService.Instances()
if err != nil {
t.Fatal("Cannot query Instances:", err)
}
for _, i := range instances {
if i.ID == instance.ID {
foundInstance = true
break
}
}
if !foundInstance {
t.Fatal("Cannot find new instance")
}
err = databaseService.CreateUser(instance.ID, database.UserParameter{Name: "username", Password: "******"})
if err != nil {
t.Fatal("Cannot create user", err)
}
err = databaseService.DeleteUser(instance.ID, "username")
if err != nil {
t.Fatal("Cannot delete user", err)
}
pwd, err := databaseService.EnableRoot(instance.ID)
if err != nil {
t.Fatal("Cannot enable root", err)
}
testUtil.Assert(t, pwd.Name != "", "No Name")
backup, err := databaseService.CreateBackup(database.CreateBackupParameters{Name: "NewBackup", InstanceID: instance.ID, Description: "Test Description"})
if err != nil {
t.Fatal("Cannot make backup", err)
}
WaitUntilActiveOrError(t, databaseService, instance.ID)
err = databaseService.DeleteInstance(instance.ID)
if err != nil {
t.Fatal("Delete instance didn't work:", err)
}
newInstance, err := databaseService.RestoreBackupInstance(database.RestoreBackupParameters{Name: "Instance1", RestorePoint: database.RestorePoint{BackupRef: backup.ID}, FlavorRef: "1001"})
if err != nil {
t.Fatal("Cannot restore a backup", err)
}
WaitUntilActiveOrError(t, databaseService, newInstance.ID)
err = databaseService.DeleteBackup(backup.ID)
if err != nil {
t.Fatal("Cannot delete backup", err)
}
err = databaseService.DeleteInstance(newInstance.ID)
if err != nil {
t.Fatal("Delete instance didn't work:", err)
}
}
// Added this test to ensure that its understood that
// only one specific format is supported at this time.
func TestUnmarshalInvalidDateTimeFormatTimeTest(t *testing.T) {
val := timeTest{}
err := json.Unmarshal([]byte("2014-09-29T14:44"), &val)
testUtil.Assert(t, err != nil, "expected an error")
}
func TestUnmarshalInvalidDataFormatTimeTest(t *testing.T) {
val := timeTest{}
err := json.Unmarshal([]byte("something other than date time"), &val)
testUtil.Assert(t, err != nil, "expected an error")
}
func TestServiceURLNetworkErrorsWhenNonExistant(t *testing.T) {
url, err := getAppendVersionServiceURL("t", nil, []service{}, "network", "region1", "3")
testUtil.Equals(t, "", url)
testUtil.Assert(t, err != nil, "Expected an error")
testUtil.Equals(t, "ServiceCatalog does not contain serviceType 'network'", err.Error())
}
func TestServiceURLComputeErrorsWhenNonExistant(t *testing.T) {
url, err := getComputeServiceURL("t", nil, []service{}, "compute", "region1", "3")
testUtil.Equals(t, "", url)
testUtil.Assert(t, err != nil, "Expected an error")
testUtil.Equals(t, "ServiceCatalog does not contain serviceType 'computev3'", err.Error())
}
func TestEqualIsTrue(t *testing.T) {
isEqual := misc.NewDateTime(testTime).Equal(misc.NewDateTime(testTime))
testUtil.Assert(t, isEqual, "expected values to be equal")
}
func TestAfterThanIsTrue(t *testing.T) {
timeAfterOriginal := testTime.Add(duration250ms)
isAfter := misc.NewDateTime(timeAfterOriginal).After(misc.NewDateTime(testTime))
testUtil.Assert(t, isAfter, "expected value to be after")
}
func TestBeforeThanIsTrue(t *testing.T) {
newTime := testTime.Add(duration250ms)
isBefore := misc.NewDateTime(testTime).Before(misc.NewDateTime(newTime))
testUtil.Assert(t, isBefore, "expected value to be before")
}