func TestService(t *testing.T) {
	if err := services.ValidateConfig(&config.Config); err != nil {
		fatal(err)
	}

	ctx = services.NewContext(config.Config, "rabbitmq-smoke-tests")

	RegisterFailHandler(Fail)

	RunSpecs(t, "RabbitMQ Smoke Tests")
}
func PrepareAndRunTests(packageName string, t *testing.T, withContext bool) {
	var err error
	TestConfig, err = LoadConfig()
	if err != nil {
		panic("Loading config: " + err.Error())
	}

	err = ValidateConfig(&TestConfig)
	if err != nil {
		panic("Validating config: " + err.Error())
	}

	TestContext = services.NewContext(TestConfig.Config, "MySQLATS")
	if withContext {
		BeforeEach(TestContext.Setup)
		AfterEach(TestContext.Teardown)
	}

	RegisterFailHandler(Fail)
	junitReporter := reporters.NewJUnitReporter(fmt.Sprintf("junit_%d.xml", ginkgoconfig.GinkgoConfig.ParallelNode))
	RunSpecsWithDefaultAndCustomReporters(t, fmt.Sprintf("P-MySQL Acceptance Tests -- %s", packageName), []Reporter{junitReporter})
}
Beispiel #3
0
func PrepareAndRunTests(packageName string, t *testing.T, withContext bool) {
	var err error
	TestConfig, err = LoadConfig()
	if err != nil {
		panic("Loading config: " + err.Error())
	}

	err = ValidateConfig(&TestConfig)
	if err != nil {
		panic("Validating config: " + err.Error())
	}

	TestContext = services.NewContext(TestConfig.Config, "RdpgATS")

	if withContext {
		BeforeEach(TestContext.Setup)
		AfterEach(TestContext.Teardown)
	}

	fmt.Printf("Plans: %#v\n", TestConfig.Plans)

	RegisterFailHandler(Fail)
	RunSpecs(t, fmt.Sprintf("RDPG Acceptance Tests -- %s", packageName))
}
	}

	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
		appPushed := false
		serviceCreated := false
		serviceBound := false
		appIsRunning := false
		appName := randomName()
func describeContext() {
	var (
		FakeCfCalls             [][]string
		FakeCfCallback          map[string]func(args ...string) *exec.Cmd
		FakeAsUserCalls         []cf.UserContext
		FakeApiRequestCalls     []apiRequestInputs
		FakeApiRequestCallbacks []func(method, endpoint string, response interface{}, data ...string)
	)

	var FakeCf = func(args ...string) *gexec.Session {
		FakeCfCalls = append(FakeCfCalls, args)
		var cmd *exec.Cmd
		if callback, exists := FakeCfCallback[args[0]]; exists {
			cmd = callback(args...)
		} else {
			cmd = exec.Command("echo", "OK")
		}
		session, _ := gexec.Start(cmd, nil, nil)
		return session
	}

	var FakeAsUser = func(userContext cf.UserContext, timeout time.Duration, actions func()) {
		FakeAsUserCalls = append(FakeAsUserCalls, userContext)
		actions()
	}

	var FakeApiRequest = func(method, endpoint string, response interface{}, timeout time.Duration, data ...string) {
		FakeApiRequestCalls = append(FakeApiRequestCalls, apiRequestInputs{
			method:   method,
			endpoint: endpoint,
			timeout:  timeout,
			data:     data,
		})

		if len(FakeApiRequestCallbacks) > 0 {
			callback := FakeApiRequestCallbacks[0]
			FakeApiRequestCallbacks = FakeApiRequestCallbacks[1:]
			callback(method, endpoint, response, data...)
		}
	}

	BeforeEach(func() {
		FakeCfCalls = [][]string{}
		FakeCfCallback = map[string]func(args ...string) *exec.Cmd{}
		FakeAsUserCalls = []cf.UserContext{}
		FakeApiRequestCalls = []apiRequestInputs{}
		FakeApiRequestCallbacks = []func(method, endpoint string, response interface{}, data ...string){}

		cf.Cf = FakeCf
		cf.AsUser = FakeAsUser
		cf.ApiRequest = FakeApiRequest

		//TODO: TimeoutScale = float64(0.1)
	})

	Describe("Setup", func() {
		var (
			config services.Config
			prefix = "fake-prefix"

			context services.Context
		)

		BeforeEach(func() {
			config = services.Config{
				AppsDomain:        "fake-domain",
				ApiEndpoint:       "fake-endpoint",
				AdminUser:         "******",
				AdminPassword:     "******",
				SkipSSLValidation: true,
				TimeoutScale:      1,
			}
			context = services.NewContext(config, prefix)
		})

		It("executes commands as the admin user", func() {
			context.Setup()

			Expect(FakeAsUserCalls).To(Equal([]cf.UserContext{
				{
					ApiUrl:            "fake-endpoint",
					Username:          "******",
					Password:          "******",
					SkipSSLValidation: true,
				},
			}))
		})

		It("creates a new user with a unique name", func() {
			context.Setup()

			createUserCall := FakeCfCalls[0]
			Expect(createUserCall[0]).To(Equal("create-user"))
			Expect(createUserCall[1]).To(MatchRegexp("fake-prefix-USER-\\d+-.*"))
			Expect(createUserCall[2]).To(Equal("meow")) //why meow??
		})

		It("creates a new quota with a unique name", func() {
			FakeApiRequestCallbacks = append(FakeApiRequestCallbacks, func(method, endpoint string, response interface{}, data ...string) {
				genericResponse, ok := response.(*cf.GenericResource)
				if !ok {
					Fail(fmt.Sprintf("Expected response to be of type *cf.GenericResource: %#v", response))
				}
				genericResponse.Metadata.Guid = "fake-guid"
			})

			context.Setup()

			createQuotaCall := FakeApiRequestCalls[0]
			Expect(createQuotaCall.method).To(Equal("POST"))
			Expect(createQuotaCall.endpoint).To(Equal("/v2/quota_definitions"))
			Expect(createQuotaCall.data).To(HaveLen(1))

			definitionJSON := createQuotaCall.data[0]
			definition := &services.QuotaDefinition{}
			err := json.Unmarshal([]byte(definitionJSON), definition)
			Expect(err).ToNot(HaveOccurred())

			Expect(definition.Name).To(MatchRegexp("fake-prefix-QUOTA-\\d+-.*"))
			Expect(definition.TotalServices).To(Equal(100))
			Expect(definition.TotalRoutes).To(Equal(1000))
			Expect(definition.MemoryLimit).To(Equal(10240))
			Expect(definition.NonBasicServicesAllowed).To(BeTrue())
		})

		It("creates a new org with a unique name", func() {
			context.Setup()

			createOrgCall := FakeCfCalls[1]
			Expect(createOrgCall).To(HaveLen(2))
			Expect(createOrgCall[0]).To(Equal("create-org"))
			Expect(createOrgCall[1]).To(MatchRegexp("fake-prefix-ORG-\\d+-.*"))
		})

		It("set the quota on the new org", func() {
			context.Setup()

			setQuotaCall := FakeCfCalls[2]
			Expect(setQuotaCall).To(HaveLen(3))
			Expect(setQuotaCall[0]).To(Equal("set-quota"))
			Expect(setQuotaCall[1]).To(MatchRegexp("fake-prefix-ORG-\\d+-.*"))
			Expect(setQuotaCall[2]).To(MatchRegexp("fake-prefix-QUOTA-\\d+-.*"))
		})

		Context("when create-user fails", func() {
			BeforeEach(func() {
				FakeCfCallback["create-user"] = func(args ...string) *exec.Cmd {
					return exec.Command("false")
				}
			})

			It("causes gomega matcher failure with stdout & stderr", func() {
				failures := InterceptGomegaFailures(func() {
					context.Setup()
				})
				Expect(failures[0]).To(MatchRegexp(
					"Failed executing command \\(exit 1\\):\nCommand: %s\n\n\\[stdout\\]:\n%s\n\n\\[stderr\\]:\n%s",
					"false",
					"",
					"",
				))
			})
		})

		Context("when create-org fails", func() {
			BeforeEach(func() {
				FakeCfCallback["create-org"] = func(args ...string) *exec.Cmd {
					return exec.Command("false")
				}
			})

			It("causes gomega matcher failure with stdout & stderr", func() {
				failures := InterceptGomegaFailures(func() {
					context.Setup()
				})
				Expect(failures[0]).To(MatchRegexp(
					"Failed executing command \\(exit 1\\):\nCommand: %s\n\n\\[stdout\\]:\n%s\n\n\\[stderr\\]:\n%s",
					"false",
					"",
					"",
				))
			})
		})

		Context("when set-quota fails", func() {
			BeforeEach(func() {
				FakeCfCallback["set-quota"] = func(args ...string) *exec.Cmd {
					return exec.Command("false")
				}
			})

			It("causes gomega matcher failure with stdout & stderr", func() {
				failures := InterceptGomegaFailures(func() {
					context.Setup()
				})
				Expect(failures[0]).To(MatchRegexp(
					"Failed executing command \\(exit 1\\):\nCommand: %s\n\n\\[stdout\\]:\n%s\n\n\\[stderr\\]:\n%s",
					"false",
					"",
					"",
				))
			})
		})
	})

	Describe("Teardown", func() {
		var (
			config services.Config
			prefix = "fake-prefix"

			context services.Context
		)

		BeforeEach(func() {
			config = services.Config{
				AppsDomain:        "fake-domain",
				ApiEndpoint:       "fake-endpoint",
				AdminUser:         "******",
				AdminPassword:     "******",
				SkipSSLValidation: true,
				TimeoutScale:      1,
			}
			context = services.NewContext(config, prefix)

			FakeApiRequestCallbacks = append(FakeApiRequestCallbacks, func(method, endpoint string, response interface{}, data ...string) {
				genericResponse, ok := response.(*cf.GenericResource)
				if !ok {
					Fail(fmt.Sprintf("Expected response to be of type *cf.GenericResource: %#v", response))
				}
				genericResponse.Metadata.Guid = "fake-guid"
			})

			context.Setup()

			// ignore calls made by setup
			FakeCfCalls = [][]string{}
			FakeAsUserCalls = []cf.UserContext{}
			FakeApiRequestCalls = []apiRequestInputs{}
		})

		It("executes commands as the admin user", func() {
			context.Teardown()

			Expect(FakeAsUserCalls).To(Equal([]cf.UserContext{
				{
					ApiUrl:            "fake-endpoint",
					Username:          "******",
					Password:          "******",
					SkipSSLValidation: true,
				},
			}))
		})

		It("logs out to reset CF_HOME", func() {
			context.Teardown()

			logoutCall := FakeCfCalls[0]
			Expect(logoutCall[0]).To(Equal("logout"))
		})

		It("deletes the user created by Setup()", func() {
			context.Teardown()

			deleteUserCall := FakeCfCalls[1]
			Expect(deleteUserCall[0]).To(Equal("delete-user"))
			Expect(deleteUserCall[1]).To(Equal("-f"))
			Expect(deleteUserCall[2]).To(MatchRegexp("fake-prefix-USER-\\d+-.*"))
		})

		It("deletes the org created by Setup()", func() {
			context.Teardown()

			deleteOrgCall := FakeCfCalls[2]
			Expect(deleteOrgCall[0]).To(Equal("delete-org"))
			Expect(deleteOrgCall[1]).To(Equal("-f"))
			Expect(deleteOrgCall[2]).To(MatchRegexp("fake-prefix-ORG-\\d+-.*"))
		})

		It("deletes the quota created by Setup()", func() {
			context.Teardown()

			deleteQuotaCall := FakeApiRequestCalls[0]
			Expect(deleteQuotaCall.method).To(Equal("DELETE"))
			Expect(deleteQuotaCall.endpoint).To(Equal("/v2/quota_definitions/fake-guid?recursive=true"))
		})

		Context("when delete-user fails", func() {
			BeforeEach(func() {
				FakeCfCallback["delete-user"] = func(args ...string) *exec.Cmd {
					return exec.Command("false")
				}
			})

			It("causes gomega matcher failure with stdout & stderr", func() {
				failures := InterceptGomegaFailures(func() {
					context.Teardown()
				})
				Expect(failures[0]).To(MatchRegexp(
					"Failed executing command \\(exit 1\\):\nCommand: %s\n\n\\[stdout\\]:\n%s\n\n\\[stderr\\]:\n%s",
					"false",
					"",
					"",
				))
			})
		})

		Context("when delete-org fails", func() {
			BeforeEach(func() {
				FakeCfCallback["delete-org"] = func(args ...string) *exec.Cmd {
					return exec.Command("false")
				}
			})

			It("causes gomega matcher failure with stdout & stderr", func() {
				failures := InterceptGomegaFailures(func() {
					context.Teardown()
				})
				Expect(failures[0]).To(MatchRegexp(
					"Failed executing command \\(exit 1\\):\nCommand: %s\n\n\\[stdout\\]:\n%s\n\n\\[stderr\\]:\n%s",
					"false",
					"",
					"",
				))
			})
		})
	})
}
			context services.Context
		)

		Context("without OrgName", func() {

			BeforeEach(func() {
				config = services.Config{
					AppsDomain:        "fake-domain",
					ApiEndpoint:       "fake-endpoint",
					AdminUser:         "******",
					AdminPassword:     "******",
					SkipSSLValidation: true,
					TimeoutScale:      1,
				}
				context = services.NewContext(config, prefix)
			})

			It("executes commands as the admin user", func() {
				context.Setup()

				Expect(FakeAsUserCalls).To(Equal([]cf.UserContext{
					{
						ApiUrl:            "fake-endpoint",
						Username:          "******",
						Password:          "******",
						SkipSSLValidation: true,
					},
				}))
			})
		// If there were no old backups, the existance of a backup now means that one was made.
		// Otherwise, check their names, which are timestamps, and assert that the most recent one
		// in the newList is newer than that of the oldList.
		cond = len(oldList) == 0 ||
			newList[len(newList)-1]["Name"] > oldList[len(oldList)-1]["Name"]
		Ω(cond).Should(BeTrue())
		//...And that the new backup file isn't empty
		numBytes, err := strconv.Atoi(newList[len(newList)-1]["Bytes"])
		Ω(err).ShouldNot(HaveOccurred())
		cond = numBytes > 0
		Ω(cond).Should(BeTrue())
	}

	BeforeSuite(func() {
		config.TimeoutScale = 3
		services.NewContext(config.Config, "rdpg-postgres-smoke-test").Setup()
	})

	AssertBackupBehavior := func(planName string) {
		serviceInstanceName := randomServiceName()
		serviceCreated := false
		serviceBound := false
		appName = randomServiceName()

		It("Can create a service and bind an app", func() {
			Eventually(cf.Cf("push", appName, "-m", "256M", "-p", appPath, "-s", "cflinuxfs2", "--no-start"), config.ScaledTimeout(timeout)).Should(Exit(0))
			Eventually(cf.Cf("create-service", config.ServiceName, planName, serviceInstanceName), config.ScaledTimeout(timeout)).Should(Exit(0))
			serviceCreated = true
			Eventually(cf.Cf("bind-service", appName, serviceInstanceName), config.ScaledTimeout(timeout)).Should(Exit(0))
			serviceBound = true
			Eventually(cf.Cf("start", appName), config.ScaledTimeout(5*time.Minute)).Should(Exit(0))