func init() { // These are well known restricted IAM keys to a HashiCorp-managed bucket // in a private AWS account that only has access to the open source test // resources. os.Setenv("AWS_ACCESS_KEY", "AKIAJCTNQIOBWAYXKGZA") os.Setenv("AWS_SECRET_KEY", "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") }
func TestApplicationFooter(t *testing.T) { testcases := []footerTestcase{ {"", "", "", "", "", "[" + brandName + " local]"}, {"susen-staging-pr-30", "v29", "", "ca0fd7123f918d1b6d3e65f3de47d52db09ae068", "dev", "[susen-staging-pr-30 CI/CD]"}, {"susen-staging", "v29", "1vac4117-c29f-4312-521e-ba4d8638c1ac", "ca0fd7123f918d1b6d3e65f3de47d52db09ae068", "stg", "[susen-staging v29 <ca0fd71>]"}, {"susen-production", "v22", "1vac4117-c29f-4312-521e-ba4d8638c1ac", "ca0fd7123f918d1b6d3e65f3de47d52db09ae068", "prd", "[susen-production v22 <ca0fd71> (dyno 1vac4117-c29f-4312-521e-ba4d8638c1ac)]"}, } for i, tc := range testcases { os.Setenv(applicationNameEnvVar, tc.name) os.Setenv(applicationVersionEnvVar, tc.version) os.Setenv(applicationInstanceEnvVar, tc.instance) os.Setenv(applicationBuildEnvVar, tc.build) os.Setenv(applicationEnvEnvVar, tc.env) if footer := applicationFooter(); footer != tc.footer { t.Errorf("Case %d: got %q, expected %q", i, footer, tc.footer) } } }
func TestDriverSetFromEnvironmentVariable(t *testing.T) { databaseUrlEnvVariableKey := "DB_DRIVER" databaseUrlEnvVariableVal := "sqlite3" databaseOpenStringKey := "DATABASE_URL" databaseOpenStringVal := "db.db" os.Setenv(databaseUrlEnvVariableKey, databaseUrlEnvVariableVal) os.Setenv(databaseOpenStringKey, databaseOpenStringVal) dbconf, err := NewDBConf("../../_example", "environment_variable_config", "") if err != nil { t.Fatal(err) } got := reflect.TypeOf(dbconf.Driver.Dialect) want := reflect.TypeOf(&Sqlite3Dialect{}) if got != want { t.Errorf("Not able to read the driver type from environment variable."+ "got %v want %v", got, want) } gotOpenString := dbconf.Driver.OpenStr wantOpenString := databaseOpenStringVal if gotOpenString != wantOpenString { t.Errorf("Not able to read the open string from the environment."+ "got %v want %v", gotOpenString, wantOpenString) } }
func TestInvalidBool(t *testing.T) { os.Setenv("othervar", "should-be-a-bool") defer os.Setenv("othervar", "") cfg := Config{} assert.Error(t, env.Parse(&cfg)) }
// Test the primary path: creating an app on a `convox` rack // Return to testing against a `convox-test` rack afterwards func TestAppCreate(t *testing.T) { r := os.Getenv("RACK") os.Setenv("RACK", "convox") defer os.Setenv("RACK", r) aws := test.StubAws( test.DescribeStackNotFound("application"), test.CreateAppStackCycle("convox-application"), test.DescribeAppStackCycle("convox-application"), ) defer aws.Close() val := url.Values{"name": []string{"application"}} body := test.HTTPBody("POST", "http://convox/apps", val) if assert.NotEqual(t, "", body) { var resp map[string]string err := json.Unmarshal([]byte(body), &resp) if assert.Nil(t, err) { assert.Equal(t, "application", resp["name"]) assert.Equal(t, "running", resp["status"]) } } }
func TestNewDNSProviderRoute53ValidEnv(t *testing.T) { os.Setenv("AWS_ACCESS_KEY_ID", "123") os.Setenv("AWS_SECRET_ACCESS_KEY", "123") _, err := NewDNSProviderRoute53("", "", "us-east-1") assert.NoError(t, err) restoreRoute53Env() }
func TestConfig(t *testing.T) { wd, _ := os.Getwd() Convey("The Config Builders", t, func() { conf := DefaultConfig() Convey("ReadConfigFile", func() { ReadConfigFile(conf, fmt.Sprintf("%s/config_test.yml", wd)) So(conf.Port, ShouldEqual, 8080) So(conf.Address, ShouldEqual, "0.0.0.0") So(conf.CredentialsFile, ShouldEqual, "/tmp/secret_file") }) Convey("ReadEnvironment", func() { master := "zk://local.host:2182/mesos" dbPath := "db/eremetic.db" frameworkID := "a_framework_id" os.Setenv("MASTER", master) os.Setenv("DATABASE", dbPath) os.Setenv("FRAMEWORK_ID", frameworkID) ReadEnvironment(conf) So(conf.Master, ShouldEqual, master) So(conf.DatabasePath, ShouldEqual, dbPath) So(conf.FrameworkID, ShouldEqual, frameworkID) }) }) }
func (*CmdSuite) TestDeployCommandInit(c *C) { defer os.Setenv("JUJU_REPOSITORY", os.Getenv("JUJU_REPOSITORY")) os.Setenv("JUJU_REPOSITORY", "/path/to/repo") for _, t := range deployTests { initExpectations(t.com) com, err := initDeployCommand(t.args...) c.Assert(err, IsNil) c.Assert(com, DeepEquals, t.com) } // test relative --config path ctx := coretesting.Context(c) expected := []byte("test: data") path := ctx.AbsPath("testconfig.yaml") file, err := os.Create(path) c.Assert(err, IsNil) _, err = file.Write(expected) c.Assert(err, IsNil) file.Close() com, err := initDeployCommand("--config", "testconfig.yaml", "charm-name") c.Assert(err, IsNil) actual, err := com.Config.Read(ctx) c.Assert(err, IsNil) c.Assert(expected, DeepEquals, actual) // missing args _, err = initDeployCommand() c.Assert(err, ErrorMatches, "no charm specified") // environment tested elsewhere }
// TestEnvironmentInit tests that all commands which accept // the --environment variable initialise their // environment name correctly. func (*CmdSuite) TestEnvironmentInit(c *C) { for i, cmdFunc := range EnvironmentInitTests { c.Logf("test %d", i) com, args := cmdFunc() testInit(c, com, args, "") assertConnName(c, com, "") com, args = cmdFunc() testInit(c, com, append(args, "-e", "walthamstow"), "") assertConnName(c, com, "walthamstow") com, args = cmdFunc() testInit(c, com, append(args, "--environment", "walthamstow"), "") assertConnName(c, com, "walthamstow") // JUJU_ENV is the final place the environment can be overriden com, args = cmdFunc() oldenv := os.Getenv("JUJU_ENV") os.Setenv("JUJU_ENV", "walthamstow") testInit(c, com, args, "") os.Setenv("JUJU_ENV", oldenv) assertConnName(c, com, "walthamstow") com, args = cmdFunc() testInit(c, com, append(args, "hotdog"), "unrecognized args.*") } }
func TestAlternateVarNames(t *testing.T) { var s Specification os.Clearenv() os.Setenv("ENV_CONFIG_MULTI_WORD_VAR", "foo") os.Setenv("ENV_CONFIG_MULTI_WORD_VAR_WITH_ALT", "bar") os.Setenv("ENV_CONFIG_MULTI_WORD_VAR_WITH_LOWER_CASE_ALT", "baz") if err := Process("env_config", &s); err != nil { t.Error(err.Error()) } // Setting the alt version of the var in the environment has no effect if // the struct tag is not supplied if s.MultiWordVar != "" { t.Errorf("expected %q, got %q", "", s.MultiWordVar) } // Setting the alt version of the var in the environment correctly sets // the value if the struct tag IS supplied if s.MultiWordVarWithAlt != "bar" { t.Errorf("expected %q, got %q", "bar", s.MultiWordVarWithAlt) } // Alt value is not case sensitive and is treated as all uppercase if s.MultiWordVarWithLowerCaseAlt != "baz" { t.Errorf("expected %q, got %q", "baz", s.MultiWordVarWithLowerCaseAlt) } }
func TestProcess(t *testing.T) { var s Specification os.Clearenv() os.Setenv("ENV_CONFIG_DEBUG", "true") os.Setenv("ENV_CONFIG_PORT", "8080") os.Setenv("ENV_CONFIG_RATE", "0.5") os.Setenv("ENV_CONFIG_USER", "Kelsey") os.Setenv("SERVICE_HOST", "127.0.0.1") err := Process("env_config", &s) if err != nil { t.Error(err.Error()) } if s.NoPrefixWithAlt != "127.0.0.1" { t.Errorf("expected %v, got %v", "127.0.0.1", s.NoPrefixWithAlt) } if !s.Debug { t.Errorf("expected %v, got %v", true, s.Debug) } if s.Port != 8080 { t.Errorf("expected %d, got %v", 8080, s.Port) } if s.Rate != 0.5 { t.Errorf("expected %f, got %v", 0.5, s.Rate) } if s.User != "Kelsey" { t.Errorf("expected %s, got %s", "Kelsey", s.User) } }
func TestFindAppDir(t *testing.T) { tempDir, err := ioutil.TempDir("", "TestFindAppDir") if err != nil { t.Fatal(err) } defer os.RemoveAll(tempDir) origGOPATH := build.Default.GOPATH defer func() { build.Default.GOPATH = origGOPATH os.Setenv("GOPATH", origGOPATH) }() build.Default.GOPATH = tempDir + string(filepath.ListSeparator) + build.Default.GOPATH os.Setenv("GOPATH", build.Default.GOPATH) myappPath := filepath.Join(tempDir, "src", "path", "to", "myapp") if err := os.MkdirAll(myappPath, 0755); err != nil { t.Fatal(err) } if err := os.Chdir(myappPath); err != nil { t.Fatal(err) } actual, err := FindAppDir() if err != nil { t.Fatal(err) } expected := "path/to/myapp" if !reflect.DeepEqual(actual, expected) { t.Errorf("FindAppDir() => %q, want %q", actual, expected) } }
func TestCreateAccount(t *testing.T) { os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com") defer os.Setenv("DOCKER_INDEX_URL", "") tokenBuffer := make([]byte, 16) _, err := rand.Read(tokenBuffer) if err != nil { t.Fatal(err) } token := hex.EncodeToString(tokenBuffer)[:12] username := "******" + token authConfig := &AuthConfig{Username: username, Password: "******", Email: "docker-ut+" + token + "@example.com"} status, err := Login(authConfig, nil) if err != nil { t.Fatal(err) } expectedStatus := "Account created. Please use the confirmation link we sent" + " to your e-mail to activate it." if status != expectedStatus { t.Fatalf("Expected status: \"%s\", found \"%s\" instead.", expectedStatus, status) } status, err = Login(authConfig, nil) if err == nil { t.Fatalf("Expected error but found nil instead") } expectedError := "Login: Account is not Active" if !strings.Contains(err.Error(), expectedError) { t.Fatalf("Expected message \"%s\" but found \"%s\" instead", expectedError, err) } }
func TestNamespaceResetting(t *testing.T) { // These environment variables are necessary because *Query.Run will // call internal.FullyQualifiedAppID which checks these variables or falls // back to the Metadata service that is not available in tests. environ := []struct { key, value string }{ {"GAE_LONG_APP_ID", "my-app-id"}, {"GAE_PARTITION", "1"}, } for _, v := range environ { old := os.Getenv(v.key) os.Setenv(v.key, v.value) v.value = old } defer func() { // Restore old environment after the test completes. for _, v := range environ { if v.value == "" { os.Unsetenv(v.key) continue } os.Setenv(v.key, v.value) } }() namec := make(chan *string, 1) c0 := aetesting.FakeSingleContext(t, "datastore_v3", "RunQuery", func(req *pb.Query, res *pb.QueryResult) error { namec <- req.NameSpace return fmt.Errorf("RPC error") }) // Check that wrapping c0 in a namespace twice works correctly. c1, err := appengine.Namespace(c0, "A") if err != nil { t.Fatalf("appengine.Namespace: %v", err) } c2, err := appengine.Namespace(c1, "") // should act as the original context if err != nil { t.Fatalf("appengine.Namespace: %v", err) } q := NewQuery("SomeKind") q.Run(c0) if ns := <-namec; ns != nil { t.Errorf(`RunQuery with c0: ns = %q, want nil`, *ns) } q.Run(c1) if ns := <-namec; ns == nil { t.Error(`RunQuery with c1: ns = nil, want "A"`) } else if *ns != "A" { t.Errorf(`RunQuery with c1: ns = %q, want "A"`, *ns) } q.Run(c2) if ns := <-namec; ns != nil { t.Errorf(`RunQuery with c2: ns = %q, want nil`, *ns) } }
func TestStepTempDir_notmpdir(t *testing.T) { tempenv := "TMPDIR" if runtime.GOOS == "windows" { tempenv = "TMP" } // Verify empty TMPDIR maps to current working directory oldenv := os.Getenv(tempenv) os.Setenv(tempenv, "") defer os.Setenv(tempenv, oldenv) dir1 := testStepTempDir_impl(t) // Now set TMPDIR to current directory abspath, err := filepath.Abs(".") if err != nil { t.Fatalf("could not get current working directory") } os.Setenv(tempenv, abspath) dir2 := testStepTempDir_impl(t) if filepath.Dir(dir1) != filepath.Dir(dir2) { t.Fatalf("temp base directories do not match: %s %s", filepath.Dir(dir1), filepath.Dir(dir2)) } }
func TestClient_vaauthorize_env(t *testing.T) { os.Setenv("VCLOUDAIR_USERNAME", "username") os.Setenv("VCLOUDAIR_PASSWORD", "password") testServer.Start() var err error os.Setenv("VCLOUDAIR_ENDPOINT", "http://localhost:4444/api") client, err := NewClient() if err != nil { t.Fatalf("err: %v", err) } testServer.Response(201, authheader, vaauthorization) _, err = client.vaauthorize("", "") _ = testServer.WaitRequest() if err != nil { t.Fatalf("err: %v", err) } if client.VAToken != "012345678901234567890123456789" { t.Fatalf("VAtoken not set on client: %s", client.VAToken) } }
func TestNewDNSProviderRoute53MissingAuthErr(t *testing.T) { os.Setenv("AWS_ACCESS_KEY_ID", "") os.Setenv("AWS_SECRET_ACCESS_KEY", "") _, err := NewDNSProviderRoute53("", "", "us-east-1") assert.EqualError(t, err, "AWS credentials missing") restoreRoute53Env() }
func TestClient_vaacquireservice_env(t *testing.T) { os.Setenv("VCLOUDAIR_COMPUTEID", "CI123456-789") testServer.Start() var err error os.Setenv("VCLOUDAIR_ENDPOINT", "http://localhost:4444/api") client, err := NewClient() if err != nil { t.Fatalf("err: %v", err) } client.VAToken = "012345678901234567890123456789" testServer.Response(200, nil, vaservices) vacomputehref, err := client.vaacquireservice(*aus, "") _ = testServer.WaitRequest() if err != nil { t.Fatalf("err: %v", err) } if vacomputehref.String() != "http://localhost:4444/api/vchs/compute/00000000-0000-0000-0000-000000000000" { t.Fatalf("VAComputeHREF not set on client: %s", vacomputehref) } if client.Region != "US - Anywhere" { t.Fatalf("Region not set on client: %s", client.Region) } }
func (e *MergeEnvSuite) TestMergeEnviron(c *gc.C) { // environment does not get fully cleared on Windows // when using testing.IsolationSuite origEnv := os.Environ() extraExpected := []string{ "DUMMYVAR=foo", "DUMMYVAR2=bar", "NEWVAR=ImNew", } expectEnv := make([]string, 0, len(origEnv)+len(extraExpected)) // os.Environ prepends some garbage on Windows that we need to strip out. // All the garbage starts and ends with = (for example "=C:="). for _, v := range origEnv { if !(strings.HasPrefix(v, "=") && strings.HasSuffix(v, "=")) { expectEnv = append(expectEnv, v) } } expectEnv = append(expectEnv, extraExpected...) os.Setenv("DUMMYVAR2", "ChangeMe") os.Setenv("DUMMYVAR", "foo") newEnv := make([]string, 0, len(expectEnv)) for _, v := range runner.MergeWindowsEnvironment([]string{"dummyvar2=bar", "NEWVAR=ImNew"}, os.Environ()) { if !(strings.HasPrefix(v, "=") && strings.HasSuffix(v, "=")) { newEnv = append(newEnv, v) } } c.Assert(expectEnv, jc.SameContents, newEnv) }
func TestClient_vaacquirecompute_env(t *testing.T) { os.Setenv("VCLOUDAIR_VDCID", "VDC12345-6789") testServer.Start() var err error os.Setenv("VCLOUDAIR_ENDPOINT", "http://localhost:4444/api") client, err := NewClient() if err != nil { t.Fatalf("err: %v", err) } client.VAToken = "012345678901234567890123456789" client.Region = "US - Anywhere" testServer.Response(200, nil, vacompute) vavdchref, err := client.vaacquirecompute(*auc, "") _ = testServer.WaitRequest() if err != nil { t.Fatalf("err: %v", err) } if vavdchref.String() != "http://localhost:4444/api/vchs/compute/00000000-0000-0000-0000-000000000000/vdc/00000000-0000-0000-0000-000000000000/vcloudsession" { t.Fatalf("VAVDCHREF not set on client: %s", vavdchref) } }
func TestEnsurePharosConfig(t *testing.T) { configFile := filepath.Join("config", "test.json") config, err := models.LoadConfigFile(configFile) require.Nil(t, err) url := config.PharosURL config.PharosURL = "" err = config.EnsurePharosConfig() assert.Equal(t, "PharosUrl is missing from config file", err.Error()) config.PharosURL = url apiUser := os.Getenv("PHAROS_API_USER") os.Setenv("PHAROS_API_USER", "") err = config.EnsurePharosConfig() assert.Equal(t, "Environment variable PHAROS_API_USER is not set", err.Error()) os.Setenv("PHAROS_API_USER", "Bogus value set by config_test.go") apiKey := os.Getenv("PHAROS_API_KEY") os.Setenv("PHAROS_API_KEY", "") err = config.EnsurePharosConfig() assert.Equal(t, "Environment variable PHAROS_API_KEY is not set", err.Error()) os.Setenv("PHAROS_API_USER", apiUser) os.Setenv("PHAROS_API_KEY", apiKey) }
func TestClient_vagetbackendauth_env(t *testing.T) { os.Setenv("VCLOUDAIR_VDCID", "VDC12345-6789") testServer.Start() var err error os.Setenv("VCLOUDAIR_ENDPOINT", "http://localhost:4444/api") client, err := NewClient() if err != nil { t.Fatalf("err: %v", err) } client.VAToken = "012345678901234567890123456789" client.Region = "US - Anywhere" testServer.Response(201, nil, vabackend) err = client.vagetbackendauth(*aucs, "") _ = testServer.WaitRequest() if err != nil { t.Fatalf("err: %v", err) } if client.VCDToken != "01234567890123456789012345678901" { t.Fatalf("VCDToken not set on client: %s", client.VCDToken) } if client.VCDAuthHeader != "x-vcloud-authorization" { t.Fatalf("VCDAuthHeader not set on client: %s", client.VCDAuthHeader) } if client.VCDVDCHREF.String() != "http://localhost:4444/api/vdc/00000000-0000-0000-0000-000000000000" { t.Fatalf("VDC not set on client: %s", client.VCDVDCHREF) } }
func TestInvalidInt(t *testing.T) { os.Setenv("PORT", "should-be-an-int") defer os.Setenv("PORT", "") cfg := Config{} assert.Error(t, env.Parse(&cfg)) }
func execCmd(gopath, curPath string, args ...string) error { oldGopath := os.Getenv("GOPATH") log.Info("Setting GOPATH to %s", gopath) sep := ":" if runtime.GOOS == "windows" { sep = ";" } if err := os.Setenv("GOPATH", gopath+sep+oldGopath); err != nil { if setting.LibraryMode { return fmt.Errorf("Fail to setting GOPATH: %v", err) } log.Error("", "Fail to setting GOPATH:") log.Fatal("", "\t"+err.Error()) } if setting.HasGOPATHSetting { defer func() { log.Info("Setting GOPATH back to %s", oldGopath) os.Setenv("GOPATH", oldGopath) }() } cmd := exec.Command(args[0], args[1:]...) cmd.Dir = curPath cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr log.Info("===== application outputs start =====\n") err := cmd.Run() log.Info("====== application outputs end ======") return err }
// SetEnv stores keys as environment vars func (k *Keys) SetEnv() { err := os.Setenv("AWS_ACCESS_KEY", k.AccessKey) err = os.Setenv("AWS_SECRET_KEY", k.SecretKey) if err != nil { log.Fatalln("Failed to set environment vars") } }
func TestParse_Global(t *testing.T) { resetForTesting("") os.Setenv(envTestPrefix+"D", "EnvD") os.Setenv(envTestPrefix+"E", "true") os.Setenv(envTestPrefix+"F", "5.5") flagA := flag.Bool("a", false, "") flagB := flag.Float64("b", 0.0, "") flagC := flag.String("c", "", "") flagD := flag.String("d", "", "") flagE := flag.Bool("e", false, "") flagF := flag.Float64("f", 0.0, "") parse(t, "./testdata/global.ini", envTestPrefix) if !*flagA { t.Errorf("flagA found %v, expected true", *flagA) } if *flagB != 5.6 { t.Errorf("flagB found %v, expected 5.6", *flagB) } if *flagC != "Hello world" { t.Errorf("flagC found %v, expected 'Hello world'", *flagC) } if *flagD != "EnvD" { t.Errorf("flagD found %v, expected 'EnvD'", *flagD) } if !*flagE { t.Errorf("flagE found %v, expected true", *flagE) } if *flagF != 5.5 { t.Errorf("flagF found %v, expected 5.5", *flagF) } }
func (s *ConfigSuite) TearDownTest(c *gc.C) { utils.SetHome(s.savedHome) os.Setenv("AWS_ACCESS_KEY_ID", s.savedAccessKey) os.Setenv("AWS_SECRET_ACCESS_KEY", s.savedSecretKey) delete(aws.Regions, "configtest") s.BaseSuite.TearDownTest(c) }
func TestEnvLOGXI_FORMAT(t *testing.T) { assert := assert.New(t) oldIsTerminal := isTerminal os.Setenv("LOGXI_FORMAT", "") setDefaults(true) processEnv() assert.Equal(FormatHappy, logxiFormat, "terminal defaults to FormatHappy") setDefaults(false) processEnv() assert.Equal(FormatJSON, logxiFormat, "non terminal defaults to FormatJSON") os.Setenv("LOGXI_FORMAT", "JSON") processEnv() assert.Equal(FormatJSON, logxiFormat) os.Setenv("LOGXI_FORMAT", "json") setDefaults(true) processEnv() assert.Equal(FormatHappy, logxiFormat, "Mismatches defaults to FormatHappy") setDefaults(false) processEnv() assert.Equal(FormatJSON, logxiFormat, "Mismatches defaults to FormatJSON non terminal") isTerminal = oldIsTerminal setDefaults(isTerminal) }
func (n *Node) DownloadByGoGet(ctx *cli.Context, u *url.URL) error { baseDir := path.Join(setting.HomeDir, ".gopm/temp/goget") os.MkdirAll(baseDir, os.ModePerm) defer func() { os.RemoveAll(baseDir) }() oriGopath := os.Getenv("GOPATH") os.Setenv("GOPATH", baseDir) fmt.Println(baseDir) defer func() { os.Setenv("GOPATH", oriGopath) }() log.Debug("RUN 'go get %s'", n.RootPath) _, stderr, err := base.ExecCmdDir(baseDir, "go", "get", n.RootPath) if err != nil { log.Error("Error occurs when 'go get" + n.RootPath + "'") log.Error("\t" + stderr) return errors.New(stderr) } tmpPath := path.Join(baseDir, "src", n.RootPath) if !n.IsEmptyVal() { base.ExecCmdDir(tmpPath, "git", "checkout", n.Value) if err != nil { log.Error("Error occurs when 'git checkout" + n.Value + "'") log.Error("\t" + stderr) return errors.New(stderr) } } os.MkdirAll(path.Dir(n.InstallPath), os.ModePerm) os.Rename(tmpPath, n.InstallPath) return nil }
func TestEnsurePrereqs(t *testing.T) { pp := os.Getenv("PATH") defer os.Setenv("PATH", pp) here, _ := os.Getwd() os.Setenv("PATH", filepath.Join(here, "../testdata")+":"+pp) ensurePrereqs() }