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 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 TestElasticsearchService(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
}
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
environment.Setup()
})
AfterSuite(func() {
//environment.Teardown()
})
RunSpecs(t, "Elasticsearch Service")
}
func TestSuite(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()
})
RunSpecs(t, "Performance tests")
}
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 deleteServiceBroker(brokerName string) {
config = helpers.LoadConfig()
context := helpers.NewContext(config)
cf.AsUser(context.AdminUserContext(), context.ShortTimeout(), func() {
responseBuffer := cf.Cf("delete-service-broker", brokerName, "-f")
Expect(responseBuffer.Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
}
func SetBackend(appName string) {
config := helpers.LoadConfig()
if config.Backend == "diego" {
EnableDiego(appName)
} else if config.Backend == "dea" {
DisableDiego(appName)
}
}
func SetBackend(appName string) {
config := helpers.LoadConfig()
if config.Backend == "diego" {
guid := guidForAppName(appName)
Eventually(cf.Cf("curl", "/v2/apps/"+guid, "-X", "PUT", "-d", `{"diego": true}`), DEFAULT_TIMEOUT).Should(Exit(0))
} else if config.Backend == "dea" {
guid := guidForAppName(appName)
Eventually(cf.Cf("curl", "/v2/apps/"+guid, "-X", "PUT", "-d", `{"diego": false}`), DEFAULT_TIMEOUT).Should(Exit(0))
}
}
func (b ServiceBroker) Push() {
Expect(cf.Cf("push", b.Name, "-p", b.Path, "--no-start").Wait(BROKER_START_TIMEOUT)).To(Exit(0))
if helpers.LoadConfig().UseDiego {
appGuid := strings.TrimSpace(string(cf.Cf("app", b.Name, "--guid").Wait(DEFAULT_TIMEOUT).Out.Contents()))
cf.Cf("curl",
fmt.Sprintf("/v2/apps/%s", appGuid),
"-X", "PUT",
"-d", "{\"diego\": true}",
).Wait(DEFAULT_TIMEOUT)
}
Expect(cf.Cf("start", b.Name).Wait(BROKER_START_TIMEOUT)).To(Exit(0))
}
func (b ServiceBroker) Push() {
config := helpers.LoadConfig()
Expect(cf.Cf(
"push", b.Name,
"--no-start",
"-b", config.RubyBuildpackName,
"-m", DEFAULT_MEMORY_LIMIT,
"-p", b.Path,
"-d", config.AppsDomain,
).Wait(BROKER_START_TIMEOUT)).To(Exit(0))
app_helpers.SetBackend(b.Name)
Expect(cf.Cf("start", b.Name).Wait(BROKER_START_TIMEOUT)).To(Exit(0))
}
func SetOauthEndpoints(apiEndpoint string, config *OAuthConfig) {
args := []string{}
if helpers.LoadConfig().SkipSSLValidation {
args = append(args, "--insecure")
}
args = append(args, fmt.Sprintf("%v/info", apiEndpoint))
curl := runner.Curl(args...).Wait(DEFAULT_TIMEOUT)
Expect(curl).To(Exit(0))
apiResponse := curl.Out.Contents()
jsonResult := ParseJsonResponse(apiResponse)
config.TokenEndpoint = fmt.Sprintf("%v", jsonResult[`token_endpoint`])
config.AuthorizationEndpoint = fmt.Sprintf("%v", jsonResult[`authorization_endpoint`])
return
}
func TestLats(t *testing.T) {
RegisterFailHandler(Fail)
var environment *helpers.Environment
BeforeSuite(func() {
config = helpers.LoadConfig()
context := helpers.NewContext(config)
environment = helpers.NewEnvironment(context)
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
RunSpecs(t, "Lats Suite")
}
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 createServiceBroker() (string, string, string) {
serviceBrokerAsset := assets.NewAssets().ServiceBroker
serviceBrokerAppName := PushApp(serviceBrokerAsset, config.RubyBuildpackName)
serviceName := initiateBrokerConfig(serviceBrokerAppName)
brokerName := generator.PrefixedRandomName("RATS-BROKER-")
brokerUrl := helpers.AppUri(serviceBrokerAppName, "")
config = helpers.LoadConfig()
context := helpers.NewContext(config)
cf.AsUser(context.AdminUserContext(), context.ShortTimeout(), func() {
session := cf.Cf("create-service-broker", brokerName, "user", "password", brokerUrl)
Expect(session.Wait(DEFAULT_TIMEOUT)).To(Exit(0))
session = cf.Cf("enable-service-access", serviceName)
Expect(session.Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
return brokerName, serviceBrokerAppName, serviceName
}
func TestSuite(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
}
httpClient = &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: config.SkipSSLValidation},
},
}
context = helpers.NewContext(config)
environment := helpers.NewEnvironment(context)
BeforeSuite(func() {
environment.Setup()
})
AfterSuite(func() {
environment.Teardown()
})
componentName := "Custom-Acceptance-Tests"
if config.ArtifactsDirectory != "" {
helpers.EnableCFTrace(config, componentName)
}
RunSpecs(t, componentName)
}
"fmt"
"github.com/cloudfoundry-incubator/cf-test-helpers/cf"
"github.com/cloudfoundry-incubator/cf-test-helpers/generator"
"github.com/cloudfoundry-incubator/cf-test-helpers/helpers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gexec"
)
var _ = Describe("Docker Application Lifecycle", func() {
var appName string
var createDockerAppPayload string
domain := helpers.LoadConfig().AppsDomain
BeforeEach(func() {
appName = generator.RandomName()
createDockerAppPayload = `{
"name": "%s",
"memory": 512,
"instances": 1,
"disk_quota": 1024,
"space_guid": "%s",
"docker_image": "cloudfoundry/diego-docker-app-custom:latest",
"command": "/myapp/dockerapp",
"diego": true
}`
})
pushAndStartNora(appName)
Eventually(helpers.CurlingAppRoot(appName)).Should(ContainSubstring("hello i am nora"))
})
AfterEach(func() {
Eventually(cf.Cf("logs", appName, "--recent")).Should(Exit())
Eventually(cf.Cf("delete", appName, "-f")).Should(Exit(0))
})
It("should be able to add and remove routes", func() {
secondHost := generator.RandomName()
By("changing the environment")
Eventually(cf.Cf("set-env", appName, "WHY", "force-app-update")).Should(Exit(0))
By("adding a route")
Eventually(cf.Cf("map-route", appName, helpers.LoadConfig().AppsDomain, "-n", secondHost)).Should(Exit(0))
Eventually(helpers.CurlingAppRoot(appName)).Should(ContainSubstring("hello i am nora"))
Eventually(helpers.CurlingAppRoot(secondHost)).Should(ContainSubstring("hello i am nora"))
By("removing a route")
Eventually(cf.Cf("unmap-route", appName, helpers.LoadConfig().AppsDomain, "-n", secondHost)).Should(Exit(0))
Eventually(helpers.CurlingAppRoot(secondHost)).Should(ContainSubstring("404"))
Eventually(helpers.CurlingAppRoot(appName)).Should(ContainSubstring("hello i am nora"))
By("deleting the original route")
Eventually(cf.Cf("delete-route", helpers.LoadConfig().AppsDomain, "-n", appName, "-f")).Should(Exit(0))
Eventually(helpers.CurlingAppRoot(appName)).Should(ContainSubstring("404"))
})
})
WaitForDropletToStage(dropletGuid)
AssignDropletToApp(appGuid, dropletGuid)
var webProcess Process
var workerProcess Process
processes := getProcess(appGuid, appName)
for _, process := range processes {
if process.Type == "web" {
webProcess = process
} else if process.Type == "worker" {
workerProcess = process
}
}
CreateAndMapRoute(appGuid, context.RegularUserContext().Space, helpers.LoadConfig().AppsDomain, webProcess.Name)
StartApp(appGuid)
Eventually(func() string {
return helpers.CurlAppRoot(webProcess.Name)
}, DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
output := helpers.CurlApp(webProcess.Name, "/env")
Expect(output).To(ContainSubstring(fmt.Sprintf("application_name\\\":\\\"%s", appName)))
Expect(output).To(ContainSubstring(appCreationEnvironmentVariables))
Expect(cf.Cf("apps").Wait(DEFAULT_TIMEOUT)).To(Say(fmt.Sprintf("%s\\s+started", webProcess.Name)))
Expect(cf.Cf("apps").Wait(DEFAULT_TIMEOUT)).To(Say(fmt.Sprintf("%s\\s+started", workerProcess.Name)))
usageEvents := lastPageUsageEvents(appName)
It("makes loggregator buffer and dump log messages", func() {
Eventually(func() string {
return helpers.CurlApp(appName, fmt.Sprintf("/log/sleep/%d", hundredthOfOneSecond))
}, DEFAULT_TIMEOUT).Should(ContainSubstring("Muahaha"))
Eventually(func() *Session {
appLogsSession := cf.Cf("logs", "--recent", appName)
Expect(appLogsSession.Wait(DEFAULT_TIMEOUT)).To(Exit(0))
return appLogsSession
}, DEFAULT_TIMEOUT).Should(Say("Muahaha"))
})
})
Context("firehose data", func() {
It("shows logs and metrics", func() {
config := helpers.LoadConfig()
noaaConnection := noaa.NewConsumer(getDopplerEndpoint(), &tls.Config{InsecureSkipVerify: config.SkipSSLValidation}, nil)
msgChan := make(chan *events.Envelope, 100000)
errorChan := make(chan error)
stopchan := make(chan struct{})
go noaaConnection.Firehose(generator.RandomName(), getAdminUserAccessToken(), msgChan, errorChan, stopchan)
defer close(stopchan)
Eventually(func() string {
return helpers.CurlApp(appName, fmt.Sprintf("/log/sleep/%d", hundredthOfOneSecond))
}, DEFAULT_TIMEOUT).Should(ContainSubstring("Muahaha"))
timeout := time.After(5 * time.Second)
messages := make([]*events.Envelope, 0, 100000)
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)
}
var spaceName string
curlRoute := func(hostName string, path string) string {
uri := config.Protocol() + hostName + "." + domainName + path
curlCmd := runner.Curl(uri)
runner.NewCmdRunner(curlCmd, DEFAULT_TIMEOUT).Run()
Expect(string(curlCmd.Err.Contents())).To(HaveLen(0))
return string(curlCmd.Out.Contents())
}
BeforeEach(func() {
orgName = context.RegularUserContext().Org
spaceName = context.RegularUserContext().Space
domainName = generator.RandomName() + "." + helpers.LoadConfig().AppsDomain
cf.AsUser(context.AdminUserContext(), DEFAULT_TIMEOUT, func() {
Expect(cf.Cf("create-shared-domain", domainName).Wait(CF_PUSH_TIMEOUT)).To(Exit(0))
})
appNameDora = generator.PrefixedRandomName("CATS-APP-")
Expect(cf.Cf("push", appNameDora, "-m", "128M", "-p", assets.NewAssets().Dora, "-d", config.AppsDomain).Wait(CF_PUSH_TIMEOUT)).To(Exit(0))
appNameSimple = generator.PrefixedRandomName("CATS-APP-")
Expect(cf.Cf("push", appNameSimple, "-m", "128M", "-p", assets.NewAssets().HelloWorld, "-d", config.AppsDomain).Wait(CF_PUSH_TIMEOUT)).To(Exit(0))
})
AfterEach(func() {
cf.AsUser(context.AdminUserContext(), DEFAULT_TIMEOUT, func() {
Expect(cf.Cf("target", "-o", orgName).Wait(DEFAULT_TIMEOUT)).To(Exit(0))
Expect(cf.Cf("delete-shared-domain", domainName, "-f").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
appUpdatePath := fmt.Sprintf("/v3/apps/%s/current_droplet", appGuid)
appUpdateBody := fmt.Sprintf(`{"droplet_guid":"%s"}`, dropletGuid)
Expect(cf.Cf("curl", appUpdatePath, "-X", "PUT", "-d", appUpdateBody).Wait(DEFAULT_TIMEOUT)).To(Exit(0))
var webProcess Process
var workerProcess Process
processes := getProcess(appGuid, appName)
for _, process := range processes {
if process.Type == "web" {
webProcess = process
} else if process.Type == "worker" {
workerProcess = process
}
}
Expect(cf.Cf("create-route", context.RegularUserContext().Space, helpers.LoadConfig().AppsDomain, "-n", webProcess.Name).Wait(DEFAULT_TIMEOUT)).To(Exit(0))
getRoutePath := fmt.Sprintf("/v2/routes?q=host:%s", webProcess.Name)
routeBody := cf.Cf("curl", getRoutePath).Wait(DEFAULT_TIMEOUT).Out.Contents()
routeJSON := struct {
Resources []struct {
Metadata struct {
Guid string `json:"guid"`
} `json:"metadata"`
} `json:"resources"`
}{}
json.Unmarshal([]byte(routeBody), &routeJSON)
routeGuid := routeJSON.Resources[0].Metadata.Guid
addRoutePath := fmt.Sprintf("/v3/apps/%s/routes", appGuid)
addRouteBody := fmt.Sprintf(`{"route_guid":"%s"}`, routeGuid)
Expect(cf.Cf("curl", addRoutePath, "-X", "PUT", "-d", addRouteBody).Wait(DEFAULT_TIMEOUT)).To(Exit(0))
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)
}
. "github.com/onsi/gomega/gexec"
"github.com/cloudfoundry-incubator/cf-test-helpers/cf"
"github.com/cloudfoundry-incubator/cf-test-helpers/generator"
"github.com/cloudfoundry-incubator/cf-test-helpers/helpers"
"github.com/cloudfoundry/cf-acceptance-tests/helpers/assets"
)
var _ = Describe("Delete Route", func() {
var appName string
BeforeEach(func() {
appName = generator.PrefixedRandomName("CATS-APP-")
Expect(cf.Cf("push", appName, "-p", assets.NewAssets().Dora).Wait(CF_PUSH_TIMEOUT)).To(Exit(0))
Eventually(func() string {
return helpers.CurlAppRoot(appName)
}, DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
})
AfterEach(func() {
Expect(cf.Cf("delete", appName, "-f").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
Describe("delete the route", func() {
It("completes successfully", func() {
Expect(cf.Cf("delete-route", helpers.LoadConfig().AppsDomain, "-n", appName, "-f").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
})
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gexec"
"github.com/cloudfoundry-incubator/cf-test-helpers/cf"
"github.com/cloudfoundry-incubator/cf-test-helpers/generator"
"github.com/cloudfoundry-incubator/cf-test-helpers/helpers"
"github.com/cloudfoundry/cf-acceptance-tests/helpers/assets"
. "github.com/cloudfoundry/cf-acceptance-tests/helpers/services"
)
var _ = Describe("SSO Lifecycle", func() {
var broker ServiceBroker
var config OAuthConfig
var redirectUri string
var apiEndpoint = helpers.LoadConfig().ApiEndpoint
Describe("For service clients (provided in catalog)", func() {
BeforeEach(func() {
redirectUri = `http://www.purple.com`
broker = NewServiceBroker(generator.RandomName(), assets.NewAssets().ServiceBroker, context, true)
broker.Push()
broker.Service.DashboardClient.RedirectUri = redirectUri
broker.Configure()
config = OAuthConfig{}
config.ClientId = broker.Service.DashboardClient.ID
config.ClientSecret = broker.Service.DashboardClient.Secret
config.RedirectUri = redirectUri
// this test assumes the default running security groups block access to the DEAs
// the test takes advantage of the fact that the DEA ip address and internal container ip address
// are discoverable via the cc api and dora's myip endpoint
It("allows traffic and then blocks traffic", func() {
By("pushing it")
Eventually(cf.Cf("push", appName, "-p", assets.NewAssets().Dora, "--no-start", "-b", "ruby_buildpack"), CF_PUSH_TIMEOUT).Should(Exit(0))
By("staging and running it on Diego")
enableDiego(appName)
Eventually(cf.Cf("start", appName), CF_PUSH_TIMEOUT).Should(Exit(0))
By("verifying it's up")
Eventually(helpers.CurlingAppRoot(appName)).Should(ContainSubstring("Hi, I'm Dora!"))
secureAddress := helpers.LoadConfig().SecureAddress
secureHost, securePort, err := net.SplitHostPort(secureAddress)
Expect(err).NotTo(HaveOccurred())
// test app egress rules
var doraCurlResponse DoraCurlResponse
curlResponse := helpers.CurlApp(appName, fmt.Sprintf("/curl/%s/%s", secureHost, securePort))
json.Unmarshal([]byte(curlResponse), &doraCurlResponse)
Expect(doraCurlResponse.ReturnCode).NotTo(Equal(0))
firstCurlError := doraCurlResponse.ReturnCode
// apply security group
rules := fmt.Sprintf(`[{"destination":"%s","ports":"%s","protocol":"tcp"}]`, secureHost, securePort)
file, _ := ioutil.TempFile(os.TempDir(), "DATS-sg-rules")
defer os.Remove(file.Name())
return helpers.CurlAppRoot(appName)
}, DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
})
AfterEach(func() {
app_helpers.AppReport(appName, DEFAULT_TIMEOUT)
Expect(cf.Cf("delete", appName, "-f", "-r").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
Describe("Removing the route", func() {
It("Should be able to remove and delete the route", func() {
secondHost := generator.RandomName()
By("adding a route")
Eventually(cf.Cf("map-route", appName, helpers.LoadConfig().AppsDomain, "-n", secondHost), DEFAULT_TIMEOUT).Should(Exit(0))
Eventually(helpers.CurlingAppRoot(appName), DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
Eventually(helpers.CurlingAppRoot(secondHost), DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
By("removing a route")
Eventually(cf.Cf("unmap-route", appName, helpers.LoadConfig().AppsDomain, "-n", secondHost), DEFAULT_TIMEOUT).Should(Exit(0))
Eventually(helpers.CurlingAppRoot(secondHost), DEFAULT_TIMEOUT).Should(ContainSubstring("404"))
Eventually(helpers.CurlingAppRoot(appName), DEFAULT_TIMEOUT).Should(ContainSubstring("Hi, I'm Dora!"))
By("deleting the original route")
Expect(cf.Cf("delete-route", helpers.LoadConfig().AppsDomain, "-n", appName, "-f").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
Eventually(helpers.CurlingAppRoot(appName), DEFAULT_TIMEOUT).Should(ContainSubstring("404"))
})
})
})
AfterEach(func() {
app_helpers.AppReport(appName, DEFAULT_TIMEOUT)
Expect(cf.Cf("delete", appName, "-f", "-r").Wait(DEFAULT_TIMEOUT)).To(Exit(0))
})
Context("by using the command flag", func() {
BeforeEach(func() {
Expect(cf.Cf(
"push", appName,
"--no-start",
"-b", config.RubyBuildpackName,
"-m", DEFAULT_MEMORY_LIMIT,
"-p", assets.NewAssets().Dora,
"-d", helpers.LoadConfig().AppsDomain,
"-c", "FOO=foo bundle exec rackup config.ru -p $PORT",
).Wait(DEFAULT_TIMEOUT)).To(Exit(0))
app_helpers.SetBackend(appName)
Expect(cf.Cf("start", appName).Wait(CF_PUSH_TIMEOUT)).To(Exit(0))
})
It("takes effect after a restart, not requiring a push", func() {
Eventually(func() string {
return helpers.CurlApp(appName, "/env/FOO")
}, DEFAULT_TIMEOUT).Should(ContainSubstring("foo"))
var response cf.QueryResponse
cf.ApiRequest("GET", "/v2/apps?q=name:"+appName, &response, DEFAULT_TIMEOUT)
package apps
import (
"github.com/cloudfoundry-incubator/cf-test-helpers/cf"
"github.com/cloudfoundry-incubator/cf-test-helpers/generator"
"github.com/cloudfoundry-incubator/cf-test-helpers/helpers"
"github.com/cloudfoundry/cf-acceptance-tests/helpers/app_helpers"
"github.com/cloudfoundry/cf-acceptance-tests/helpers/assets"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gexec"
)
var _ = Describe("User services", func() {
var testConfig = helpers.LoadConfig()
var appName string
Describe("When a user-defined service is bound", func() {
var serviceName string
BeforeEach(func() {
appName = generator.PrefixedRandomName("CATS-APP-")
serviceName = generator.PrefixedRandomName("CUPS-")
Eventually(cf.Cf(
"push",
appName,
"--no-start",
"-b", testConfig.RubyBuildpackName,
"-m", DEFAULT_MEMORY_LIMIT,
