func runPushTests(appName, appUrl string, testConfig *smoke.Config) { if testConfig.SkipSSLValidation { Expect(runner.Curl("-k", appUrl).Wait(CF_TIMEOUT_IN_SECONDS)).To(Say("It just needed to be restarted!")) } else { Expect(runner.Curl(appUrl).Wait(CF_TIMEOUT_IN_SECONDS)).To(Say("It just needed to be restarted!")) } instances := 2 maxAttempts := 30 ExpectAppToScale(appName, instances) ExpectAllAppInstancesToStart(appName, instances, maxAttempts) ExpectAllAppInstancesToBeReachable(appUrl, instances, maxAttempts) if testConfig.Cleanup { Expect(cf.Cf("delete", appName, "-f", "-r").Wait(CF_TIMEOUT_IN_SECONDS)).To(Exit(0)) Eventually(func() *Session { appStatusSession := cf.Cf("app", appName) Expect(appStatusSession.Wait(CF_TIMEOUT_IN_SECONDS)).To(Exit(1)) return appStatusSession }, 5).Should(Say("not found")) Eventually(func() *Session { if testConfig.SkipSSLValidation { return runner.Curl("-k", appUrl).Wait(CF_TIMEOUT_IN_SECONDS) } else { return runner.Curl(appUrl).Wait(CF_TIMEOUT_IN_SECONDS) } }, 5).Should(Say("404")) } }
func AuthenticateUser(authorizationEndpoint string, username string, password string) (cookie string) { loginCsrfUri := fmt.Sprintf("%v/login", authorizationEndpoint) cookieFile, err := ioutil.TempFile("", "cats-csrf-cookie"+generator.RandomName()) Expect(err).ToNot(HaveOccurred()) cookiePath := cookieFile.Name() defer func() { cookieFile.Close() os.Remove(cookiePath) }() curl := runner.Curl(loginCsrfUri, `--insecure`, `-i`, `-v`, `-c`, cookiePath).Wait(DEFAULT_TIMEOUT) apiResponse := string(curl.Out.Contents()) csrfRegEx, _ := regexp.Compile(`name="X-Uaa-Csrf" value="(.*)"`) csrfToken := csrfRegEx.FindStringSubmatch(apiResponse)[1] loginUri := fmt.Sprintf("%v/login.do", authorizationEndpoint) usernameEncoded := url.QueryEscape(username) passwordEncoded := url.QueryEscape(password) csrfTokenEncoded := url.QueryEscape(csrfToken) loginCredentials := fmt.Sprintf("username=%v&password=%v&X-Uaa-Csrf=%v", usernameEncoded, passwordEncoded, csrfTokenEncoded) curl = runner.Curl(loginUri, `--data`, loginCredentials, `--insecure`, `-i`, `-v`, `-b`, cookiePath).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse = string(curl.Out.Contents()) jsessionRegEx, _ := regexp.Compile(`JSESSIONID([^;]*)`) vcapidRegEx, _ := regexp.Compile(`__VCAP_ID__([^;]*)`) sessionId := jsessionRegEx.FindString(apiResponse) vcapId := vcapidRegEx.FindString(apiResponse) cookie = fmt.Sprintf("%v;%v", sessionId, vcapId) return }
// Curls an app's endpoint and exit successfully before the specified timeout func CurlAppWithTimeout(appName, path string, timeout time.Duration) string { config := LoadConfig() uri := AppUri(appName, path) var curlCmd *gexec.Session if config.SkipSSLValidation { curlCmd = runner.Curl("-k", uri) } else { curlCmd = runner.Curl(uri) } runner.NewCmdRunner(curlCmd, timeout).Run() Expect(string(curlCmd.Err.Contents())).To(HaveLen(0)) return string(curlCmd.Out.Contents()) }
// Curls an app's endpoint and exit successfully before the specified timeout func CurlAppWithTimeout(appName, path string, timeout time.Duration) string { uri := AppUri(appName, path) curlCmd := runner.Curl(uri) runner.NewCmdRunner(curlCmd, timeout).Run() Expect(string(curlCmd.Err.Contents())).To(HaveLen(0)) return string(curlCmd.Out.Contents()) }
// Curls an app's endpoint and exit successfully before the specified timeout func CurlAppWithTimeout(appName, path string, timeout time.Duration) string { uri := AppUri(appName, path) curl := runner.Curl(uri).Wait(timeout) Expect(curl).To(Exit(0)) Expect(string(curl.Err.Contents())).To(HaveLen(0)) return string(curl.Out.Contents()) }
func SetOauthEndpoints(apiEndpoint string, config *OAuthConfig) { url := fmt.Sprintf("%v/info", apiEndpoint) curl := runner.Curl(url).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 AuthorizeScopes(cookie string, config OAuthConfig) (authCode string) { authorizedScopes := `scope.0=scope.openid&scope.1=scope.cloud_controller.read&scope.2=scope.cloud_controller.write&user_oauth_approval=true` authorizeScopesUri := fmt.Sprintf("%v/oauth/authorize", config.AuthorizationEndpoint) curl := runner.Curl(authorizeScopesUri, `-i`, `--data`, authorizedScopes, `--cookie`, cookie, `--insecure`, `-v`).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse := string(curl.Out.Contents()) pattern := fmt.Sprintf(`%v\?code=([a-zA-Z0-9]+)`, regexp.QuoteMeta(config.RedirectUri)) regEx, _ := regexp.Compile(pattern) authCode = regEx.FindStringSubmatch(apiResponse)[1] return }
// Curls the appUrl (up to maxAttempts) until all instances have been seen func ExpectAllAppInstancesToBeReachable(appUrl string, instances int, maxAttempts int) { matcher := regexp.MustCompile(`instance[ _]index["]{0,1}:[ ]{0,1}(\d+)`) branchesSeen := make([]bool, instances) var sawAll bool var testConfig = smoke.GetConfig() var session *Session for i := 0; i < maxAttempts; i++ { if testConfig.SkipSSLValidation { session = runner.Curl("-k", appUrl) } else { session = runner.Curl(appUrl) } Expect(session.Wait(CF_TIMEOUT_IN_SECONDS)).To(Exit(0)) output := string(session.Out.Contents()) matches := matcher.FindStringSubmatch(output) if matches == nil { Fail("Expected app curl output to include an instance_index; got " + output) } indexString := matches[1] index, err := strconv.Atoi(indexString) if err != nil { Fail("Failed to parse instance index value " + indexString) } branchesSeen[index] = true if allTrue(branchesSeen) { sawAll = true break } } Expect(sawAll).To(BeTrue(), fmt.Sprintf("Expected to hit all %d app instances in %d attempts, but didn't", instances, maxAttempts)) }
func GetAccessToken(authCode string, config OAuthConfig) (accessToken string) { clientCredentials := []byte(fmt.Sprintf("%v:%v", config.ClientId, config.ClientSecret)) encodedClientCredentials := base64.StdEncoding.EncodeToString(clientCredentials) authHeader := fmt.Sprintf("Authorization: Basic %v", encodedClientCredentials) requestTokenUri := fmt.Sprintf("%v/oauth/token", config.TokenEndpoint) requestTokenData := fmt.Sprintf("scope=%v&code=%v&grant_type=authorization_code&redirect_uri=%v", config.RequestedScopes, authCode, config.RedirectUri) curl := runner.Curl(requestTokenUri, `-H`, authHeader, `--data`, requestTokenData, `--insecure`, `-v`).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse := curl.Out.Contents() jsonResult := ParseJsonResponse(apiResponse) accessToken = fmt.Sprintf("%v", jsonResult[`access_token`]) return }
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 curlApexDomainUrl() textproto.MIMEHeader { appsDomain := config.AppsDomain apexDomainUrl := config.Protocol() + appsDomain + "/" curlCmd := runner.Curl(apexDomainUrl, "-I").Wait(helpers.CURL_TIMEOUT) Expect(curlCmd).To(Exit(0)) Expect(string(curlCmd.Err.Contents())).To(HaveLen(0)) curlResponse := string(curlCmd.Out.Contents()) reader := textproto.NewReader(bufio.NewReader(bytes.NewBufferString(curlResponse))) reader.ReadLine() m, err := reader.ReadMIMEHeader() Expect(err).ShouldNot(HaveOccurred()) return m }
func AuthenticateUser(authorizationEndpoint string, username string, password string) (cookie string) { loginUri := fmt.Sprintf("%v/login.do", authorizationEndpoint) usernameEncoded := url.QueryEscape(username) passwordEncoded := url.QueryEscape(password) loginCredentials := fmt.Sprintf("username=%v&password=%v", usernameEncoded, passwordEncoded) curl := runner.Curl(loginUri, `--data`, loginCredentials, `--insecure`, `-i`, `-v`).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse := string(curl.Out.Contents()) jsessionRegEx, _ := regexp.Compile(`JSESSIONID([^;]*)`) vcapidRegEx, _ := regexp.Compile(`__VCAP_ID__([^;]*)`) sessionId := jsessionRegEx.FindString(apiResponse) vcapId := vcapidRegEx.FindString(apiResponse) cookie = fmt.Sprintf("%v;%v", sessionId, vcapId) return }
func QueryServiceInstancePermissionEndpoint(apiEndpoint string, accessToken string, serviceInstanceGuid string) (canManage string, httpCode string) { canManage = `not populated` authHeader := fmt.Sprintf("Authorization: bearer %v", accessToken) permissionsUri := fmt.Sprintf("%v/v2/service_instances/%v/permissions", apiEndpoint, serviceInstanceGuid) curl := runner.Curl(permissionsUri, `-H`, authHeader, `-w`, `:TestReponseCode:%{http_code}`, `--insecure`, `-v`).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse := string(curl.Out.Contents()) resultMap := strings.Split(apiResponse, `:TestReponseCode:`) resultText := resultMap[0] httpCode = resultMap[1] if httpCode == `200` { jsonResult := ParseJsonResponse([]byte(resultText)) canManage = fmt.Sprintf("%v", jsonResult[`manage`]) } return }
func RequestScopes(cookie string, config OAuthConfig) (authCode string, httpCode string) { authCode = `initialized` requestScopesUri := fmt.Sprintf("%v/oauth/authorize?client_id=%v&response_type=code+id_token&redirect_uri=%v&scope=%v", config.AuthorizationEndpoint, url.QueryEscape(config.ClientId), config.RedirectUri, config.RequestedScopes) curl := runner.Curl(requestScopesUri, `-L`, `--cookie`, cookie, `--insecure`, `-w`, `:TestReponseCode:%{http_code}`, `-v`).Wait(DEFAULT_TIMEOUT) Expect(curl).To(Exit(0)) apiResponse := string(curl.Out.Contents()) resultMap := strings.Split(apiResponse, `:TestReponseCode:`) httpCode = resultMap[1] if httpCode == `200` { authCode = AuthorizeScopes(cookie, config) } return }
createServiceStdout := createServiceSession.Out select { case <-createServiceStdout.Detect("FAILED"): Eventually(createServiceSession, config.ScaledTimeout(timeout)).Should(Say("instance limit for this service has been reached")) Eventually(createServiceSession, config.ScaledTimeout(timeout)).Should(Exit(1)) fmt.Println("No Plan Instances available for testing plan:", planName) case <-createServiceStdout.Detect("OK"): Eventually(createServiceSession, config.ScaledTimeout(timeout)).Should(Exit(0)) Eventually(cf.Cf("bind-service", appName, serviceInstanceName), config.ScaledTimeout(timeout)).Should(Exit(0)) Eventually(cf.Cf("start", appName), config.ScaledTimeout(5*time.Minute)).Should(Exit(0)) uri := appUri(appName) + "/store" fmt.Println("Posting to url: ", uri) Eventually(runner.Curl("-d", "myvalue", "-X", "POST", uri, "-k", "-f"), config.ScaledTimeout(timeout), retryInterval).Should(Exit(0)) fmt.Println("\n") fmt.Println("Getting from url: ", uri) Eventually(runner.Curl(uri, "-k"), config.ScaledTimeout(timeout), retryInterval).Should(Say("myvalue")) fmt.Println("\n") Eventually(cf.Cf("unbind-service", appName, serviceInstanceName), config.ScaledTimeout(timeout)).Should(Exit(0)) Eventually(cf.Cf("delete-service", "-f", serviceInstanceName), config.ScaledTimeout(timeout)).Should(Exit(0)) } createServiceStdout.CancelDetects() }) } Context("for each plan", func() {
//Beginning of the test function. var _ = Describe("RDPG Service Broker", func() { var timeout = time.Second * 60 var retryInterval = time.Second / 2 var appPath = "../assets/postgres-test-app" var appName string randomServiceName := func() string { return uuid.NewRandom().String() } assertAppIsRunning := func(appName string) { pingUri := appUri(appName) + "/ping" fmt.Println("Checking that the app is responding at url: ", pingUri) Eventually(runner.Curl(pingUri, "-k"), config.ScaledTimeout(timeout), retryInterval).Should(Say("SUCCESS")) fmt.Println("\n") } getLocalBackups := func(location, dbname string) []map[string]string { uri := rdpgUri(location) + "/backup/list/local" resp, err := httpClient.PostForm(uri, url.Values{"dbname": {dbname}}) Ω(err).ShouldNot(HaveOccurred()) Ω(resp.StatusCode).Should(Equal(http.StatusOK)) backupsMap := make(map[string]interface{}) backupsJSON, err := ioutil.ReadAll(resp.Body) fmt.Printf("backupsJSON:\n%s", backupsJSON) Ω(err).ShouldNot(HaveOccurred()) fmt.Println("\n--Unmarshaling JSON") err = json.Unmarshal(backupsJSON, &backupsMap) Ω(err).ShouldNot(HaveOccurred())
) const cmdTimeout = 30 * time.Second var _ = Describe("Run", func() { It("runs the given command in a cmdtest Session", func() { session := runner.Run("bash", "-c", "echo hi out; echo hi err 1>&2; exit 42").Wait(cmdTimeout) Expect(session).To(Exit(42)) Expect(session.Out).To(Say("hi out")) Expect(session.Err).To(Say("hi err")) }) }) var _ = Describe("Curl", func() { It("outputs the body of the given URL", func() { session := runner.Curl("-I", "http://example.com").Wait(cmdTimeout) Expect(session).To(Exit(0)) Expect(session.Out).To(Say("HTTP/1.1 200 OK")) }) }) var _ = Describe("cmdRunner", func() { Describe("Run with defaults", func() { It("does nothing when the command succeeds before the timeout", func() { failures := InterceptGomegaFailures(func() { session := runner.Run("bash", "-c", "echo hi out; echo hi err 1>&2; exit 0") runner.NewCmdRunner(session, cmdTimeout).Run() }) Expect(failures).To(BeEmpty()) })
func assertReadFromDB(key, value, uri string) { curlURI := fmt.Sprintf("%s/%s", uri, key) runner.NewCmdRunner(runner.Curl("-k", curlURI), helpers.TestContext.ShortTimeout()).WithOutput(value).Run() }
func assertAppIsRunning(appName string) { pingURI := helpers.TestConfig.AppURI(appName) + "/ping" runner.NewCmdRunner(runner.Curl("-k", pingURI), helpers.TestContext.ShortTimeout()).WithOutput("OK").Run() }
) const ( // The quota enforcer sleeps for one second between iterations, // so sleeping for 20 seconds is sufficient for it have enforced all quotas quotaEnforcerSleepTime = 20 * time.Second ) var _ = Describe("P-MySQL Service", func() { var sinatraPath = "../../assets/sinatra_app" assertAppIsRunning := func(appName string) { pingURI := helpers.TestConfig.AppURI(appName) + "/ping" fmt.Println("\n*** Checking that the app is responding at url: ", pingURI) runner.NewCmdRunner(runner.Curl("-k", pingURI), helpers.TestContext.ShortTimeout()).WithAttempts(3).WithOutput("OK").Run() } Describe("Enforcing MySQL storage and connection quota", func() { var appName string var serviceInstanceName string var serviceURI string var plan helpers.Plan BeforeEach(func() { appName = RandomName() serviceInstanceName = RandomName() plan = helpers.TestConfig.Plans[0] serviceURI = fmt.Sprintf("%s/service/mysql/%s", helpers.TestConfig.AppURI(appName), serviceInstanceName) runner.NewCmdRunner(Cf("push", appName, "-m", "256M", "-p", sinatraPath, "-b", "ruby_buildpack", "-no-start"), helpers.TestContext.LongTimeout()).Run()
func curlAppWithCookies(appName, path string, cookieStorePath string) string { uri := helpers.AppUri(appName, path) curlCmd := runner.Curl(uri, "-b", cookieStorePath, "-c", cookieStorePath) runner.NewCmdRunner(curlCmd, helpers.CURL_TIMEOUT).Run() return string(curlCmd.Out.Contents()) }
"github.com/cloudfoundry/cf-acceptance-tests/helpers/assets" ) var _ = Describe("Wildcard Routes", func() { var appNameDora string var appNameSimple string var domainName string var orgName string var spaceName string curlRoute := func(hostName string, path string) string { uri := config.Protocol() + hostName + "." + domainName + path var curlCmd *Session if config.SkipSSLValidation { curlCmd = runner.Curl("-k", uri) } else { 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() {
"github.com/cloudfoundry-incubator/cf-test-helpers/generator" "github.com/cloudfoundry-incubator/cf-test-helpers/helpers" "github.com/cloudfoundry-incubator/cf-test-helpers/runner" "github.com/cloudfoundry/cf-acceptance-tests/helpers/assets" ) var _ = Describe("Wildcard Routes", func() { var appNameDora string var appNameSimple string var domainName string var orgName string 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)) })
appMQTTPath = "../assets/cf-rabbitmq-example-mqtt-app" appSTOMPPath = "../assets/cf-rabbitmq-example-stomp-app" ) randomName := func() string { return uuid.NewRandom().String() } appUri := func(appName string) string { return "https://" + appName + "." + config.AppsDomain } assertAppIsRunning := func(appName string) { pingUri := appUri(appName) + "/ping" fmt.Println("Checking that the app is responding at url: ", pingUri) Eventually(runner.Curl(pingUri, "-k"), config.ScaledTimeout(timeout), retryInterval).Should(Say("OK")) fmt.Println("\n") } BeforeSuite(func() { config.TimeoutScale = 30 context = services.NewContext(config.Config, "rabbitmq-smoke-test") context.Setup() }) AfterSuite(func() { context.Teardown() }) AssertLifeCycleMQTTBehavior := func(planName, appPath string) { var serviceInstanceName string
var appPath = "../assets/cf-redis-example-app" var appName string randomName := func() string { return uuid.NewRandom().String() } appUri := func(appName string) string { return "https://" + appName + "." + config.AppsDomain } assertAppIsRunning := func(appName string) { pingUri := appUri(appName) + "/ping" fmt.Println("Checking that the app is responding at url: ", pingUri) Eventually(runner.Curl(pingUri, "-k"), context_setup.ScaledTimeout(timeout), retryInterval).Should(Say("key not present")) fmt.Println("\n") } BeforeEach(func() { appName = randomName() Eventually(cf.Cf("push", appName, "-m", "256M", "-p", appPath, "-s", "cflinuxfs2", "-no-start"), context_setup.ScaledTimeout(timeout)).Should(Exit(0)) }) AfterEach(func() { Eventually(cf.Cf("delete", appName, "-f"), context_setup.ScaledTimeout(timeout)).Should(Exit(0)) }) AssertLifeCycleBehavior := func(planName string) { It("can create, bind to, write to, read from, unbind, and destroy a service instance using the "+planName+" plan", func() { serviceInstanceName := randomName()
AfterEach(func() { app_helpers.AppReport(appName, DEFAULT_TIMEOUT) cf.AsUser(context.AdminUserContext(), DEFAULT_TIMEOUT, func() { Expect(cf.Cf("delete-buildpack", buildpackName, "-f").Wait(DEFAULT_TIMEOUT)).To(Exit(0)) }) DeleteApp(appGuid) }) It("Stages with a user specified admin buildpack", func() { StagePackage(packageGuid, fmt.Sprintf(`{"lifecycle":{ "type": "buildpack", "data": { "buildpack": "%s" } }}`, buildpackName)) logUrl := fmt.Sprintf("loggregator.%s/recent?app=%s", config.AppsDomain, appGuid) Eventually(func() *Session { session := runner.Curl(logUrl, "-H", fmt.Sprintf("Authorization: %s", token)) Expect(session.Wait(DEFAULT_TIMEOUT)).To(Exit(0)) return session }, 1*time.Minute, 10*time.Second).Should(Say("STAGED WITH CUSTOM BUILDPACK")) }) It("Stages with a user specified github buildpack", func() { StagePackage(packageGuid, `{"lifecycle":{ "type": "buildpack", "data": { "buildpack": "http://github.com/cloudfoundry/go-buildpack" } }`) logUrl := fmt.Sprintf("loggregator.%s/recent?app=%s", config.AppsDomain, appGuid) Eventually(func() *Session { session := runner.Curl(logUrl, "-H", fmt.Sprintf("Authorization: %s", token)) Expect(session.Wait(DEFAULT_TIMEOUT)).To(Exit(0)) return session }, 3*time.Minute, 10*time.Second).Should(Say("Godeps")) })
import ( "time" "github.com/cloudfoundry-incubator/cf-test-helpers/runner" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/onsi/gomega/gbytes" . "github.com/onsi/gomega/gexec" ) const CMD_TIMEOUT = 10 * time.Second var _ = Describe("Run", func() { It("runs the given command in a cmdtest Session", func() { session := runner.Run("bash", "-c", "echo hi out; echo hi err 1>&2; exit 42").Wait(CMD_TIMEOUT) Expect(session).To(Exit(42)) Expect(session.Out).To(Say("hi out")) Expect(session.Err).To(Say("hi err")) }) }) var _ = Describe("Curl", func() { It("outputs the body of the given URL", func() { session := runner.Curl("-I", "http://example.com").Wait(CMD_TIMEOUT) Expect(session).To(Exit(0)) Expect(session.Out).To(Say("HTTP/1.1 200 OK")) }) })
package broker_test import ( "fmt" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/onsi/gomega/gbytes" "github.com/cloudfoundry-incubator/cf-mysql-acceptance-tests/helpers" "github.com/cloudfoundry-incubator/cf-test-helpers/runner" ) var _ = Describe("P-MySQL Service broker", func() { It("Registers a route", func() { uri := fmt.Sprintf("%s://%s/v2/catalog", helpers.TestConfig.BrokerProtocol, helpers.TestConfig.BrokerHost) fmt.Printf("\n*** Curling url: %s\n", uri) curlCmd := runner.NewCmdRunner(runner.Curl("-k", uri), helpers.TestContext.ShortTimeout()).Run() Expect(curlCmd).To(Say("HTTP Basic: Access denied.")) fmt.Println("Expected failure occured") }) })
func (b ServiceBroker) Configure() { Expect(runner.Curl(helpers.AppUri(b.Name, "/config"), "-d", b.ToJSON()).Wait(DEFAULT_TIMEOUT)).To(Exit(0)) }
. "github.com/onsi/gomega/gbytes" "github.com/cloudfoundry-incubator/cf-mysql-acceptance-tests/helpers" . "github.com/cloudfoundry-incubator/cf-test-helpers/cf" . "github.com/cloudfoundry-incubator/cf-test-helpers/generator" "github.com/cloudfoundry-incubator/cf-test-helpers/runner" ) var _ = Describe("P-MySQL Lifecycle Tests", func() { var sinatraPath = "../../assets/sinatra_app" assertAppIsRunning := func(appName string) { pingURI := helpers.TestConfig.AppURI(appName) + "/ping" fmt.Println("\n*** Checking that the app is responding at url: ", pingURI) runner.NewCmdRunner(runner.Curl("-k", pingURI), helpers.TestContext.ShortTimeout()).WithAttempts(3).WithOutput("OK").Run() } It("Allows users to create, bind, write to, read from, unbind, and destroy a service instance for the each plan", func() { for _, plan := range helpers.TestConfig.Plans { // skip if plan is private if plan.Private { continue } appName := RandomName() pushCmd := runner.NewCmdRunner(Cf("push", appName, "-m", "256M", "-p", sinatraPath, "-b", "ruby_buildpack", "-no-start"), helpers.TestContext.LongTimeout()).Run() Expect(pushCmd).To(Say("OK")) serviceInstanceName := RandomName()