func permsCreateAppTest(t *testing.T, params, user *utils.DeisTestConfig) {
	utils.Execute(t, authLoginCmd, user, false, "")
	utils.Execute(t, permsCreateAppCmd, user, true, "403 FORBIDDEN")
	utils.Execute(t, authLoginCmd, params, false, "")
	utils.Execute(t, permsCreateAppCmd, params, false, "")
	utils.CheckList(t, permsListAppCmd, params, "test1", false)
}

func appsSetup(t *testing.T) *utils.DeisTestConfig {
	cfg := utils.GetGlobalConfig()
	cfg.AppName = "appssample"
	utils.Execute(t, authLoginCmd, cfg, false, "")
	utils.Execute(t, gitCloneCmd, cfg, false, "")
	return cfg
}

func TestPs(t *testing.T) {
	params := psSetup(t)
	psScaleTest(t, params, psScaleCmd)
	appsOpenTest(t, params)
	psListTest(t, params, false)
	psScaleTest(t, params, psRestartCmd)
	psScaleTest(t, params, psDownScaleCmd)

	// FIXME if we don't wait here, some of the routers may give us a 502 before
	// the app is removed from the config.
	// we wait 7 seconds since confd reloads every 5 seconds
	time.Sleep(time.Millisecond * 7000)

	// test for a 503 response
	utils.CurlWithFail(t, fmt.Sprintf("http://%s.%s", params.AppName, params.Domain), true, "503")

	utils.AppsDestroyTest(t, params)
	utils.Execute(t, psScaleCmd, params, true, "404 NOT FOUND")
	// ensure we can choose our preferred beverage
	utils.Execute(t, psScaleCmd, params, true, "but first, coffee!")
	if err := os.Setenv("DEIS_DRINK_OF_CHOICE", "tea"); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, psScaleCmd, params, true, "but first, tea!")
}

func TestGlobal(t *testing.T) {
	params := utils.GetGlobalConfig()
	cookieTest(t, params)
	utils.Execute(t, authRegisterCmd, params, false, "")
	utils.Execute(t, keysAddCmd, params, false, "")
	utils.Execute(t, clustersCreateCmd, params, false, "")
}

func tagsTest(t *testing.T, cfg *utils.DeisTestConfig, ver int) {
	configFleetMetadata(t, cfg)
	utils.Execute(t, tagsListCmd, cfg, false, "No tags defined")
	utils.Execute(t, tagsSetCmd, cfg, false, "test")
	utils.Execute(t, tagsListCmd, cfg, false, "test")
	utils.Execute(t, tagsUnsetCmd, cfg, false, "No tags defined")
}

func appsRunTest(t *testing.T, params *utils.DeisTestConfig) {
	cmd := appsRunCmd
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	utils.CheckList(t, cmd, params, "Hello, 世界", false)
	utils.Execute(t, "apps:run env", params, true, "GIT_SHA")
	// Fleet/systemd unit files have a limit of 2048 characters per line or else one encounters
	// problems parsing the unit.  To verify long log messages are truncated and do not crash
	// logspout (see https://github.com/deis/deis/issues/2046) we must issue a (relatively) short
	// command via `deis apps:run` that produces a LONG, but testable (predictable) log message we
	// can search for in the output of `deis logs`.
	//
	// The strategy for achieving this is to generate 1k random characters, then use that with a
	// command submitted via `deis apps:run` that will echo those 1k bytes 64x (on a single line).
	// Such a message is long enough to crash logspout if handled improperly and ALSO gives us a
	// large, distinct, and predictable string we can search for in the logs to assert success (and
	// assert that the message didn't crash logspout) WITHOUT ever needing to transmit such an
	// egregiously long command via `deis apps:run`.
	largeString := randomString(1024)
	utils.Execute(t, fmt.Sprintf("apps:run \"printf '%s%%.0s' {1..64}\"", largeString), params, false, largeString)
	// To assert the long message didn't crash logspout AND made it to the logger, we will search
	// the logs for a fragment of the long message-- specifically 2x the random string we generated.
	// This will help us ensure the actual log message made it through and not JUST the log message
	// that states the command being execured via `deis apps:run`.  We want to find the former, not
	// the latter because the latter is too short a message to have possibly crashed logspout if
	// mishandled.
	utils.Execute(t, "logs", params, false, strings.Repeat(largeString, 2))
	if err := utils.Chdir(".."); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, cmd, params, true, "Not found")
}

func configSetTest(t *testing.T, params *utils.DeisTestConfig) {
	utils.Execute(t, configSetCmd, params, false, "讲台")
	utils.CheckList(t, appsInfoCmd, params, "(v5)", false)
	utils.Execute(t, configSet2Cmd, params, false, "10")
	utils.CheckList(t, appsInfoCmd, params, "(v6)", false)
	utils.Execute(t, configSetHealthcheckCmd, params, false, "/")
	utils.CheckList(t, appsInfoCmd, params, "(v7)", false)
}

func authPasswdTest(t *testing.T, params *utils.DeisTestConfig) {
	password := "aNewPassword"
	utils.AuthPasswd(t, params, password)
	cmd := authLoginCmd
	utils.Execute(t, cmd, params, true, "400 BAD REQUEST")
	params.Password = password
	utils.Execute(t, cmd, params, false, "")
}

// buildsScaleTest ensures that we can use a Procfile-based workflow for `deis pull`.
func buildsScaleTest(t *testing.T, params *utils.DeisTestConfig) {
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, "scale worker=1 --app={{.AppName}}", params, false, "")
	utils.Execute(t, "logs --app={{.AppName}}", params, false, "hi")
	if err := utils.Chdir(".."); err != nil {
		t.Fatal(err)
	}
}

func domainsTest(t *testing.T, cfg *utils.DeisTestConfig) {
	utils.Execute(t, domainsAddCmd, cfg, false, "done")
	// ensure both the root domain and the custom domain work
	utils.CurlApp(t, *cfg)
	utils.Curl(t, fmt.Sprintf("http://%s", cfg.AppDomain))
	utils.Execute(t, domainsRemoveCmd, cfg, false, "done")
	// only the root domain should work now
	utils.CurlApp(t, *cfg)
	// TODO (bacongobbler): add test to ensure that the custom domain fails to connect
}

func appsCreateTest(t *testing.T, params *utils.DeisTestConfig) {
	wd, _ := os.Getwd()
	defer os.Chdir(wd)
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	cmd := appsCreateCmd
	utils.Execute(t, cmd, params, false, "")
	utils.Execute(t, cmd, params, true, "App with this Id already exists")
}

func appsRunTest(t *testing.T, params *utils.DeisTestConfig) {
	cmd := appsRunCmd
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, cmd, params, false, "")
	if err := utils.Chdir(".."); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, cmd, params, true, "Not found")
}

func limitsUnsetTest(t *testing.T, cfg *utils.DeisTestConfig, ver int) {
	cpuCmd, memCmd := limitsUnsetCPUCmd, limitsUnsetMemCmd
	if strings.Contains(cfg.ExampleApp, "dockerfile") {
		cpuCmd = strings.Replace(cpuCmd, "web", "cmd", 1)
		memCmd = strings.Replace(memCmd, "web", "cmd", 1)
	}
	utils.Execute(t, cpuCmd, cfg, false, "Unlimited")
	utils.Execute(t, limitsListCmd, cfg, false, "Unlimited")
	utils.Execute(t, memCmd, cfg, false, "Unlimited")
	utils.Execute(t, limitsListCmd, cfg, false, "Unlimited")
}

func appsCreateTest(t *testing.T, params *utils.DeisTestConfig) {
	wd, _ := os.Getwd()
	defer os.Chdir(wd)
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	// TODO: move --buildpack to client unit tests
	utils.Execute(t, appsCreateCmdBuildpack, params, false, "BUILDPACK_URL")
	utils.Execute(t, appsDestroyCmdNoApp, params, false, "")
	utils.Execute(t, appsCreateCmd, params, false, "")
	utils.Execute(t, appsCreateCmd, params, true, "App with this Id already exists")
}

func authPasswdTest(t *testing.T, params *utils.DeisTestConfig) {
	password := "aNewPassword"
	params.NewPassword = password
	cmd := authPasswdCmd
	utils.Execute(t, cmd, params, false, "")
	params.Password = "wrong-password"
	utils.Execute(t, cmd, params, true, "Password change failed")

	cmd = authLoginCmd
	utils.Execute(t, cmd, params, true, "400 BAD REQUEST")
	params.Password = password
	utils.Execute(t, cmd, params, false, "")
}

func authCancel(t *testing.T, params *utils.DeisTestConfig) {
	utils.Execute(t, authCancelCmd, params, false, "Account cancelled")
	user := utils.GetGlobalConfig()

	// Admins can delete other users.
	user.UserName, user.Password = "cancel-test", "test"
	utils.Execute(t, authRegisterCmd, user, false, "")
	admin := utils.GetGlobalConfig()
	utils.Execute(t, authLoginCmd, admin, false, "")
	utils.Execute(t, authCancelAdminCmd, user, false, "Account cancelled")
	// Make sure the admin is still logged in
	utils.CheckList(t, authWhoamiCmd, admin, admin.UserName, false)
}

func authCancel(t *testing.T, params *utils.DeisTestConfig) {
	utils.Execute(t, authCancelCmd, params, false, "Account cancelled")
	user := utils.GetGlobalConfig()

	// Admins can delete other users.
	user.UserName, user.Password = "cancel-test", "test"
	utils.Execute(t, authRegisterCmd, user, false, "")
	admin := utils.GetGlobalConfig()
	utils.Execute(t, authLoginCmd, admin, false, "")
	utils.Execute(t, authCancelAdminCmd, user, false, "Account cancelled")
	// Make sure the user's config was not purged after auth:cancel --username
	utils.Execute(t, authWhoamiCmd, admin, false, "You are "+admin.UserName)
}

func TestPs(t *testing.T) {
	params := psSetup(t)
	psScaleTest(t, params)
	appsOpenTest(t, params)
	psListTest(t, params, false)
	utils.AppsDestroyTest(t, params)
	utils.Execute(t, psScaleCmd, params, true, "404 NOT FOUND")
	// ensure we can choose our preferred beverage
	utils.Execute(t, psScaleCmd, params, true, "but first, coffee!")
	if err := os.Setenv("DEIS_DRINK_OF_CHOICE", "tea"); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, psScaleCmd, params, true, "but first, tea!")
}

func certsTest(t *testing.T, cfg *utils.DeisTestConfig) {
	utils.Execute(t, domainsAddCmd, cfg, false, "done")
	utils.Execute(t, certsAddCmd, cfg, false, cfg.AppDomain)
	// wait for the certs to be populated in the router; cron takes up to 1 minute
	fmt.Println("sleeping for 60 seconds until certs are generated...")
	time.Sleep(60 * time.Second)
	fmt.Println("ok")
	// ensure the custom domain's SSL endpoint works
	utils.Curl(t, fmt.Sprintf("https://%s", cfg.AppDomain))
	utils.Execute(t, certsRemoveCmd, cfg, false, "done")
	// only the root domain should work now
	utils.CurlApp(t, *cfg)
	// TODO (bacongobbler): add test to ensure that the custom domain fails to connect
}

func appsLogsTest(t *testing.T, params *utils.DeisTestConfig) {
	cmd := appsLogsCmd
	// test for application lifecycle logs
	utils.Execute(t, cmd, params, false, "204 NO CONTENT")
	if err := utils.Chdir(params.ExampleApp); err != nil {
		t.Fatal(err)
	}
	utils.Execute(t, gitPushCmd, params, false, "")
	utils.Curl(t, params)
	utils.Execute(t, cmd, params, false, "")
	if err := utils.Chdir(".."); err != nil {
		t.Fatal(err)
	}
}