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") }