func TestApplications(t *testing.T) {
RegisterFailHandler(Fail)
SetDefaultEventuallyTimeout(time.Minute)
SetDefaultEventuallyPollingInterval(time.Second)
config := helpers.LoadConfig()
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
var _ = SynchronizedBeforeSuite(func() []byte {
path, err := exec.LookPath("scp")
Expect(err).NotTo(HaveOccurred())
return []byte(path)
}, func(encodedSCPPath []byte) {
scpPath = string(encodedSCPPath)
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "SSH"
rs := []Reporter{}
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestApplications(t *testing.T) {
RegisterFailHandler(Fail)
SetDefaultEventuallyTimeout(time.Minute)
SetDefaultEventuallyPollingInterval(time.Second)
config := helpers.LoadConfig()
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "SecurityGroups"
rs := []Reporter{}
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestRouting(t *testing.T) {
RegisterFailHandler(Fail)
config = helpers.LoadConfig()
componentName := "Routing"
rs := []Reporter{}
context := helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
Expect(config.SystemDomain).ToNot(Equal(""), "Must provide a system domain for the routing suite")
Expect(config.ClientSecret).ToNot(Equal(""), "Must provide a client secret for the routing suite")
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestDetect(t *testing.T) {
RegisterFailHandler(Fail)
config = helpers.LoadConfig()
if config.DefaultTimeout > 0 {
DEFAULT_TIMEOUT = config.DefaultTimeout * time.Second
}
if config.DetectTimeout > 0 {
DETECT_TIMEOUT = config.DetectTimeout * time.Second
}
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "Buildpack Detection"
rs := []Reporter{}
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestCATS(t *testing.T) {
RegisterFailHandler(Fail)
var validationError error
Config, validationError = config.NewCatsConfig(os.Getenv("CONFIG"))
var _ = BeforeSuite(func() {
if validationError != nil {
fmt.Println("Invalid configuration. ")
fmt.Println(validationError)
Fail("Please fix the contents of $CONFIG:\n " + os.Getenv("CONFIG") + "\nbefore proceeding.")
}
TestSetup = workflowhelpers.NewTestSuiteSetup(Config)
installedVersion, err := GetInstalledCliVersionString()
Expect(err).ToNot(HaveOccurred(), "Error trying to determine CF CLI version")
Expect(ParseRawCliVersionString(installedVersion).AtLeast(ParseRawCliVersionString(minCliVersion))).To(BeTrue(), "CLI version "+minCliVersion+" is required")
if Config.GetIncludeSsh() {
ScpPath, err = exec.LookPath("scp")
Expect(err).NotTo(HaveOccurred())
SftpPath, err = exec.LookPath("sftp")
Expect(err).NotTo(HaveOccurred())
}
TestSetup.Setup()
})
AfterSuite(func() {
if TestSetup != nil {
TestSetup.Teardown()
}
})
rs := []Reporter{}
if validationError == nil {
if Config.GetArtifactsDirectory() != "" {
helpers.EnableCFTrace(Config, "CATS")
rs = append(rs, helpers.NewJUnitReporter(Config, "CATS"))
}
}
RunSpecsWithDefaultAndCustomReporters(t, "CATS", rs)
}
func TestApplications(t *testing.T) {
RegisterFailHandler(Fail)
config = helpers.LoadConfig()
if config.DefaultTimeout > 0 {
DEFAULT_TIMEOUT = config.DefaultTimeout * time.Second
}
if config.CfPushTimeout > 0 {
CF_PUSH_TIMEOUT = config.CfPushTimeout * time.Second
}
if config.LongCurlTimeout > 0 {
LONG_CURL_TIMEOUT = config.LongCurlTimeout * time.Second
}
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "Docker"
rs := []Reporter{}
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestApplications(t *testing.T) {
RegisterFailHandler(Fail)
config = helpers.LoadConfig()
if config.DefaultTimeout > 0 {
DEFAULT_TIMEOUT = config.DefaultTimeout * time.Second
}
if config.CfPushTimeout > 0 {
CF_PUSH_TIMEOUT = config.CfPushTimeout * time.Second
}
if config.LongCurlTimeout > 0 {
LONG_CURL_TIMEOUT = config.LongCurlTimeout * time.Second
}
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
type sshPaths struct {
SCP string `json:"scp"`
SFTP string `json:"sftp"`
}
var _ = SynchronizedBeforeSuite(func() []byte {
scp, err := exec.LookPath("scp")
Expect(err).NotTo(HaveOccurred())
sftp, err := exec.LookPath("sftp")
Expect(err).NotTo(HaveOccurred())
paths, err := json.Marshal(sshPaths{
SCP: scp,
SFTP: sftp,
})
Expect(err).NotTo(HaveOccurred())
return []byte(paths)
}, func(encodedSSHPaths []byte) {
var sshPaths sshPaths
err := json.Unmarshal(encodedSSHPaths, &sshPaths)
Expect(err).NotTo(HaveOccurred())
scpPath = sshPaths.SCP
sftpPath = sshPaths.SFTP
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "SSH"
rs := []Reporter{}
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
rs = append(rs, helpers.NewJUnitReporter(config, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}
func TestPersiAcceptance(t *testing.T) {
RegisterFailHandler(Fail)
cfConfig = helpers.LoadConfig()
defaults(&cfConfig)
err := getPatsSpecificConfig()
if err != nil {
panic(err)
}
brokerName = pConfig.ServiceName + "-broker"
componentName := "PATS Suite"
rs := []Reporter{}
SynchronizedBeforeSuite(func() []byte {
patsSuiteContext = helpers.NewContext(cfConfig)
cf.AsUser(patsSuiteContext.AdminUserContext(), DEFAULT_TIMEOUT, func() {
// make sure we don't have a leftover service broker from another test
deleteBroker(pConfig.BrokerUrl)
if pConfig.PushedBrokerName != "" {
// push the service broker as a cf application
Expect(pConfig.SqlServiceName).ToNot(BeEmpty())
appPath := os.Getenv("BROKER_APPLICATION_PATH")
Expect(appPath).To(BeADirectory(), "BROKER_APPLICATION_PATH environment variable should point to a CF application")
assetsPath := os.Getenv("ASSETS_PATH")
Expect(assetsPath).To(BeADirectory(), "ASSETS_PATH environment variable should be a directory")
Eventually(cf.Cf("update-security-group", "public_networks", filepath.Join(assetsPath, "security.json")), DEFAULT_TIMEOUT).Should(Exit(0))
Eventually(cf.Cf("push", pConfig.PushedBrokerName, "-p", appPath, "-f", appPath+"/manifest.yml", "--no-start"), DEFAULT_TIMEOUT).Should(Exit(0))
Eventually(cf.Cf("bind-service", pConfig.PushedBrokerName, pConfig.SqlServiceName), DEFAULT_TIMEOUT).Should(Exit(0))
Eventually(cf.Cf("start", pConfig.PushedBrokerName), DEFAULT_TIMEOUT).Should(Exit(0))
}
createServiceBroker := cf.Cf("create-service-broker", brokerName, pConfig.BrokerUser, pConfig.BrokerPassword, pConfig.BrokerUrl).Wait(DEFAULT_TIMEOUT)
Expect(createServiceBroker).To(Exit(0))
Expect(createServiceBroker).To(Say(brokerName))
})
return nil
}, func(_ []byte) {
patsTestContext = helpers.NewContext(cfConfig)
patsTestEnvironment = helpers.NewEnvironment(patsTestContext)
patsTestEnvironment.Setup()
})
SynchronizedAfterSuite(func() {
if patsTestEnvironment != nil {
patsTestEnvironment.Teardown()
}
}, func() {
cf.AsUser(patsSuiteContext.AdminUserContext(), DEFAULT_TIMEOUT, func() {
session := cf.Cf("delete-service-broker", "-f", brokerName).Wait(DEFAULT_TIMEOUT)
if session.ExitCode() != 0 {
cf.Cf("purge-service-offering", pConfig.ServiceName).Wait(DEFAULT_TIMEOUT)
Fail("pats service broker could not be cleaned up.")
}
})
})
if cfConfig.ArtifactsDirectory != "" {
helpers.EnableCFTrace(cfConfig, componentName)
rs = append(rs, helpers.NewJUnitReporter(cfConfig, componentName))
}
RunSpecsWithDefaultAndCustomReporters(t, componentName, rs)
}