// composeUp converts given json to yaml, saves to a file on the host and // uses `docker-compose up -d` to create the containers. func composeUp(d driver.DistroDriver, json map[string]interface{}) error { if len(json) == 0 { log.Println("docker-compose config not specified, noop") return nil } // Convert json to yaml yaml, err := yaml.Marshal(json) if err != nil { return fmt.Errorf("error converting to compose.yml: %v", err) } if err := os.MkdirAll(composeYmlDir, 0777); err != nil { return fmt.Errorf("failed creating %s: %v", composeYmlDir, err) } log.Printf("Using compose yaml:>>>>>\n%s\n<<<<<", string(yaml)) ymlPath := filepath.Join(composeYmlDir, composeYml) if err := ioutil.WriteFile(ymlPath, yaml, 0666); err != nil { return fmt.Errorf("error writing %s: %v", ymlPath, err) } // set timeout for docker-compose -> docker-engine interactions. // When downloading large images, docker-compose intermittently times out // (gh#docker/compose/issues/2186). os.Setenv("COMPOSE_HTTP_TIMEOUT", fmt.Sprintf("%d", composeTimeoutSecs)) // versions <= 1.4.2 os.Setenv("DOCKER_CLIENT_TIMEOUT", fmt.Sprintf("%d", composeTimeoutSecs)) // version >= 1.5.0 defer os.Unsetenv("COMPOSE_HTTP_TIMEOUT") defer os.Unsetenv("DOCKER_CLIENT_TIMEOUT") return executil.ExecPipeToFds(executil.Fds{Out: ioutil.Discard}, composeBinPath(d), "-p", composeProject, "-f", ymlPath, "up", "-d") }
func main(cfg *config.CloudConfig) error { os.Unsetenv("_LIBCONTAINER_INITPIPE") os.Unsetenv("_LIBCONTAINER_INITPID") if err := system.ParentDeathSignal(syscall.SIGKILL).Set(); err != nil { return err } if err := os.Remove("/var/run/docker.pid"); err != nil && !os.IsNotExist(err) { return err } dockerCfg := cfg.Rancher.Docker args := dockerCfg.FullArgs() log.Debugf("User Docker args: %v", args) if dockerCfg.TLS { log.Debug("Generating TLS certs if needed") if err := control.Generate(true, "/etc/docker/tls", []string{"localhost"}); err != nil { return err } } prog := findProgram("docker-init", "dockerlaunch", "docker") if strings.Contains(prog, "dockerlaunch") { args = append([]string{prog, "docker"}, args...) } else { args = append([]string{prog}, args...) } log.Infof("Running %v", args) return syscall.Exec(args[0], args, dockerCfg.AppendEnv()) }
func TestNewCliParamsFromEnvVarsWithRegionSpecifiedAsEnvVariable(t *testing.T) { globalSet := flag.NewFlagSet("ecs-cli", 0) globalContext := cli.NewContext(nil, globalSet, nil) context := cli.NewContext(nil, nil, globalContext) rdwr := &mockReadWriter{} os.Setenv("AWS_REGION", "us-west-1") os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "SECRET") defer func() { os.Unsetenv("AWS_REGION") os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() params, err := NewCliParams(context, rdwr) if err != nil { t.Errorf("Unexpected error when region is specified using environment variable AWS_REGION: ", err) } paramsRegion := aws.StringValue(params.Config.Region) if "us-west-1" != paramsRegion { t.Errorf("Unexpected region set, expected: us-west-1, got: %s", paramsRegion) } }
func (s *S) TestShellToContainerWithUnit(c *check.C) { guesser := cmdtest.FakeGuesser{Name: "myapp"} server := httptest.NewServer(buildHandler([]byte("hello my friend\nglad to see you here\n"))) defer server.Close() target := "http://" + server.Listener.Addr().String() os.Setenv("TSURU_TARGET", target) defer os.Unsetenv("TSURU_TARGET") os.Setenv("TSURU_TOKEN", "abc123") defer os.Unsetenv("TSURU_TOKEN") var stdout, stderr, stdin bytes.Buffer context := Context{ Args: []string{"containerid"}, Stdout: &stdout, Stderr: &stderr, Stdin: &stdin, } var command ShellToContainerCmd command.GuessingCommand = GuessingCommand{G: &guesser} err := command.Flags().Parse(true, []string{"-a", "myapp"}) c.Assert(err, check.IsNil) mngr := NewManager("admin", "0.1", "admin-ver", &stdout, &stderr, nil, nil) client := NewClient(http.DefaultClient, &context, mngr) err = command.Run(&context, client) c.Assert(err, check.IsNil) c.Assert(stdout.String(), check.Equals, "hello my friend\nglad to see you here\n") }
// TestRuntime tests stuff from runtime.go func TestRuntime(t *testing.T) { Convey("The Runtime configuration tests, ", t, func() { envvars := []string{"AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_STORAGE_BUCKET_NAME", "REDIS_URL"} for i := range envvars { envvar := envvars[i] Convey(fmt.Sprintf("Without %s", envvar), func() { curVal := os.Getenv(envvar) os.Unsetenv(envvar) So(func() { CheckEnvVars() }, ShouldPanic) os.Setenv(envvar, curVal) }) } Convey("Without MAX_CPUS", func() { envvar := "MAX_CPUS" curVal := os.Getenv(envvar) os.Unsetenv(envvar) So(func() { ConfigureRuntime() }, ShouldNotPanic) os.Setenv(envvar, curVal) }) invalidLogLevels := []string{"D3BUG", ""} for i := range invalidLogLevels { envvar := "LOG_LEVEL" envval := invalidLogLevels[i] Convey(fmt.Sprintf("With %s to %s", envvar, envval), func() { curVal := os.Getenv(envvar) os.Setenv(envvar, envval) So(func() { ConfigureLogger() }, ShouldNotPanic) os.Setenv(envvar, curVal) }) } }) }
func TestPopulateContext(t *testing.T) { globalSet := flag.NewFlagSet("ecs-cli", 0) globalContext := cli.NewContext(nil, globalSet, nil) cliContext := cli.NewContext(nil, nil, globalContext) ecsContext := &ecscompose.Context{} // Create a temprorary directory for the dummy ecs config tempDirName, err := ioutil.TempDir("", "test") if err != nil { t.Fatal("Error while creating the dummy ecs config directory") } defer os.Remove(tempDirName) os.Setenv("HOME", tempDirName) os.Setenv("AWS_REGION", "us-east-1") os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "secret") defer func() { os.Unsetenv("AWS_REGION") os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") os.Unsetenv("HOME") }() projectFactory := projectFactory{} err = projectFactory.populateContext(ecsContext, cliContext) if err != nil { t.Fatal("Error while populating the context") } if ecsContext.ECSParams == nil { t.Error("ECS Params was expected to be set for ecsContext but was nil") } }
// unsetEnv unsets enviornment variables for testing a "clean slate" with no // credentials in the environment func unsetEnv(t *testing.T) func() { // Grab any existing AWS keys and preserve. In some tests we'll unset these, so // we need to have them and restore them after e := getEnv() if err := os.Unsetenv("AWS_ACCESS_KEY_ID"); err != nil { t.Fatalf("Error unsetting env var AWS_ACCESS_KEY_ID: %s", err) } if err := os.Unsetenv("AWS_SECRET_ACCESS_KEY"); err != nil { t.Fatalf("Error unsetting env var AWS_SECRET_ACCESS_KEY: %s", err) } if err := os.Unsetenv("AWS_SESSION_TOKEN"); err != nil { t.Fatalf("Error unsetting env var AWS_SESSION_TOKEN: %s", err) } return func() { // re-set all the envs we unset above if err := os.Setenv("AWS_ACCESS_KEY_ID", e.Key); err != nil { t.Fatalf("Error resetting env var AWS_ACCESS_KEY_ID: %s", err) } if err := os.Setenv("AWS_SECRET_ACCESS_KEY", e.Secret); err != nil { t.Fatalf("Error resetting env var AWS_SECRET_ACCESS_KEY: %s", err) } if err := os.Setenv("AWS_SESSION_TOKEN", e.Token); err != nil { t.Fatalf("Error resetting env var AWS_SESSION_TOKEN: %s", err) } } }
// Test - Bitrise Validate workflow // Workflow contains before and after workflow, and no one contains steps, but circular wofklow dependecy exist, which should fail func Test0Steps3WorkflowsCircularDependency(t *testing.T) { require.NoError(t, os.Setenv("BITRISE_BUILD_STATUS", "0")) defer func() { require.NoError(t, os.Unsetenv("BITRISE_BUILD_STATUS")) }() require.NoError(t, os.Setenv("STEPLIB_BUILD_STATUS", "0")) defer func() { require.NoError(t, os.Unsetenv("STEPLIB_BUILD_STATUS")) }() beforeWorkflow := models.WorkflowModel{ BeforeRun: []string{"target"}, } afterWorkflow := models.WorkflowModel{} workflow := models.WorkflowModel{ BeforeRun: []string{"before"}, AfterRun: []string{"after"}, } config := models.BitriseDataModel{ FormatVersion: "1.0.0", DefaultStepLibSource: "https://github.com/bitrise-io/bitrise-steplib.git", Workflows: map[string]models.WorkflowModel{ "target": workflow, "before": beforeWorkflow, "after": afterWorkflow, }, } _, err := config.Validate() require.Error(t, err) require.Equal(t, "0", os.Getenv("BITRISE_BUILD_STATUS")) require.Equal(t, "0", os.Getenv("STEPLIB_BUILD_STATUS")) }
func TestToServiceConfigWhenUsingEnvVariables(t *testing.T) { ecsConfig := NewCliConfig(clusterName) ecsConfig.Region = region os.Setenv("AWS_ACCESS_KEY_ID", envAwsAccessKey) os.Setenv("AWS_SECRET_ACCESS_KEY", envAwsSecretKey) // Clear env variables as they persist past the individual test boundary defer func() { os.Unsetenv("AWS_ACCESS_KEY_ID") os.Unsetenv("AWS_SECRET_ACCESS_KEY") os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() awsConfig, _ := ecsConfig.ToServiceConfig() resolvedCredentials, err := awsConfig.Credentials.Get() if err != nil { t.Error("Error fetching credentials from the chain provider") } if envAwsAccessKey != resolvedCredentials.AccessKeyID { t.Errorf("Invalid access key set. Expected [%s]. Got [%s]", envAwsAccessKey, resolvedCredentials.AccessKeyID) } if envAwsSecretKey != resolvedCredentials.SecretAccessKey { t.Errorf("Invalid secret key set. Expected [%s]. Got [%s]", envAwsSecretKey, resolvedCredentials.SecretAccessKey) } }
func init() { if runtime.GOOS == "darwin" { // remove DYLD_LIBRARY_PATH and LD_LIBRARY_PATH as they break VBoxManage on OSX os.Unsetenv("DYLD_LIBRARY_PATH") os.Unsetenv("LD_LIBRARY_PATH") } }
func TestEnvVarOverride(t *testing.T) { defer func() { loadedTemplates = make(map[string]*template.Template) os.Unsetenv(defaultTemplateDirectoryEnvVar) }() // first check that we fail with the wrong directory os.Setenv(defaultTemplateDirectoryEnvVar, filepath.Join("nosuchdir")) _, err := loadPageTemplate("error") if err == nil { t.Fatalf("Load with OS env directory %v", os.Getenv(defaultTemplateDirectoryEnvVar)) } // now reset to the tests directory and try a test load os.Setenv(defaultTemplateDirectoryEnvVar, "tests") _, err = loadPageTemplate("test") if err != nil { t.Fatalf("Failed to load test template: %v", err) } // now unset the environment to use the default os.Unsetenv(defaultTemplateDirectoryEnvVar) _, err = loadPageTemplate("error") if err != nil { t.Fatalf("Failed to load error template: %v", err) } }
func TestEnv(t *testing.T) { os.Setenv("STR", "helloworld") os.Setenv("NUM", "42") os.Setenv("BOOL", "true") //config type Config struct { Str string Num int Bool bool } c := &Config{} //flag example parse if err := New(c).UseEnv().Process([]string{}); err != nil { t.Fatal(err) } os.Unsetenv("STR") os.Unsetenv("NUM") os.Unsetenv("BOOL") //check config is filled check(t, c.Str, `helloworld`) check(t, c.Num, 42) check(t, c.Bool, true) }
func TestEnvConvert(t *testing.T) { os.Setenv("TEST_PRUXY_1", "abc.com=127.0.0.1:8081,127.0.0.1:8082") os.Setenv("TEST_PRUXY_2", "abc.com/abc/123=127.0.0.1") defer os.Unsetenv("TEST_PRUXY_1") defer os.Unsetenv("TEST_PRUXY_2") p, _ := NewEnv("TEST_PRUXY_") convertFunc := p.DefaultRequestConverter() var convertTests = []struct { in string out string }{ {"http://abc.com/a/b/", "http://127.0.0.1:8081/a/b/"}, {"http://abc.com/a/b", "http://127.0.0.1:8082/a/b"}, {"http://abc.com/abc/123/456/hi", "http://127.0.0.1/456/hi"}, } for i, tt := range convertTests { in, _ := http.NewRequest("GET", tt.in, nil) out := copyRequest(in) convertFunc(in, out) if out.URL.String() != tt.out { t.Errorf("%d expected %s, got %s", i, tt.out, out.URL.String()) } } }
func (s *S) TestShellToContainerWithUnit(c *check.C) { transport := cmdtest.ConditionalTransport{ Transport: cmdtest.Transport{ Message: "", Status: http.StatusOK, }, CondFunc: func(req *http.Request) bool { return req.Method == "GET" && req.URL.Path == "/apps/myapp" }, } guesser := cmdtest.FakeGuesser{Name: "myapp"} server := httptest.NewServer(buildHandler([]byte("hello my friend\nglad to see you here\n"))) defer server.Close() target := "http://" + server.Listener.Addr().String() os.Setenv("TSURU_TARGET", target) defer os.Unsetenv("TSURU_TARGET") os.Setenv("TSURU_TOKEN", "abc123") defer os.Unsetenv("TSURU_TOKEN") var stdout, stderr, stdin bytes.Buffer context := Context{ Args: []string{"containerid"}, Stdout: &stdout, Stderr: &stderr, Stdin: &stdin, } var command ShellToContainerCmd command.GuessingCommand = GuessingCommand{G: &guesser} err := command.Flags().Parse(true, []string{"-a", "myapp"}) c.Assert(err, check.IsNil) mngr := NewManager("admin", "0.1", "admin-ver", &stdout, &stderr, nil, nil) client := NewClient(&http.Client{Transport: &transport}, &context, mngr) err = command.Run(&context, client) c.Assert(err, check.IsNil) c.Assert(stdout.String(), check.Equals, "hello my friend\nglad to see you here\n") }
func (s *S) TestShellToContainerCmdConnectionRefused(c *check.C) { var buf bytes.Buffer transport := cmdtest.ConditionalTransport{ Transport: cmdtest.Transport{ Message: "", Status: http.StatusOK, }, CondFunc: func(req *http.Request) bool { return req.Method == "GET" && req.URL.Path == "/apps/cmd" }, } server := httptest.NewServer(nil) addr := server.Listener.Addr().String() server.Close() os.Setenv("TSURU_TARGET", "http://"+addr) defer os.Unsetenv("TSURU_TARGET") os.Setenv("TSURU_TOKEN", "abc123") defer os.Unsetenv("TSURU_TOKEN") context := Context{ Args: []string{"af3332d"}, Stdout: &buf, Stderr: &buf, Stdin: &buf, } mngr := NewManager("admin", "0.1", "admin-ver", &buf, &buf, nil, nil) client := NewClient(&http.Client{Transport: &transport}, &context, mngr) var command ShellToContainerCmd err := command.Run(&context, client) c.Assert(err, check.NotNil) }
func teardown() { var dir string home := os.Getenv("PKIIO_HOME") if home != "" { dir = home os.Unsetenv("PKIIO_HOME") } else { local := os.Getenv("PKIIO_LOCAL") if local != "" { dir = local os.Unsetenv("PKIIO_LOCAL") } else { panic("No PKIIO env variables set") } } parentDir := path.Dir(dir) if strings.Contains(parentDir, "pki.io-test") { if err := os.RemoveAll(parentDir); err != nil { panic(err) } } else { panic("Directory isn't a pki.io test directory") } }
func TestClusterUpWithout2AvailabilityZones(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() mockECS := mock_ecs.NewMockECSClient(ctrl) mockCloudformation := mock_cloudformation.NewMockCloudformationClient(ctrl) vpcAZs := "us-west-2c" os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "secret") defer func() { os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() gomock.InOrder( mockCloudformation.EXPECT().Initialize(gomock.Any()), mockCloudformation.EXPECT().ValidateStackExists(stackName).Return(errors.New("error")), ) globalSet := flag.NewFlagSet("ecs-cli", 0) globalSet.String("region", "us-west-1", "") globalContext := cli.NewContext(nil, globalSet, nil) flagSet := flag.NewFlagSet("ecs-cli-up", 0) flagSet.Bool(capabilityIAMFlag, true, "") flagSet.String(keypairNameFlag, "default", "") flagSet.Bool(forceFlag, true, "") flagSet.String(vpcAzFlag, vpcAZs, "") context := cli.NewContext(nil, flagSet, globalContext) err := createCluster(context, newMockReadWriter(), mockECS, mockCloudformation, ami.NewStaticAmiIds()) if err == nil { t.Fatal("Expected error for 2 AZs") } }
func TestNewConfig(t *testing.T) { os.Setenv("AWS_ACCESS_KEY_ID", "access") os.Setenv("AWS_SECRET_ACCESS_KEY", "secret") c, err := NewConfig(false, 22375, false, true) if err != nil { t.Fatalf("Failed to create config. Error: %v", err) } if c.AWS.AccessKeyID != "access" { t.Error("AccessKeyID should be 'access': " + c.AWS.AccessKeyID) } if c.AWS.SecretAccessKey != "secret" { t.Error("SecretAccessKey should be 'secret': " + c.AWS.SecretAccessKey) } if c.Docker.Connection == "" { t.Error("config.Docker.Connection should not be empty.") } os.Unsetenv("AWS_ACCESS_KEY_ID") os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") c, err = NewConfig(false, 22375, false, true) if err == nil || err.Error() != "AWS_ACCESS_KEY_ID/AWS_ACCESS_KEY or AWS_SECRET_ACCESS_KEY/AWS_SECRET_KEY are missing." { t.Error("should return error when evn vars are not set") } c, err = NewConfig(true, 22375, false, false) if err != nil { t.Error("should not renturn an error") } }
func TestClusterUpWithClusterNameEmpty(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() mockECS := mock_ecs.NewMockECSClient(ctrl) mockCloudformation := mock_cloudformation.NewMockCloudformationClient(ctrl) os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "secret") defer func() { os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() globalSet := flag.NewFlagSet("ecs-cli", 0) globalSet.String("region", "us-west-1", "") globalContext := cli.NewContext(nil, globalSet, nil) flagSet := flag.NewFlagSet("ecs-cli-up", 0) flagSet.Bool(capabilityIAMFlag, true, "") flagSet.String(keypairNameFlag, "default", "") context := cli.NewContext(nil, flagSet, globalContext) err := createCluster(context, &mockReadWriter{clusterName: ""}, mockECS, mockCloudformation, ami.NewStaticAmiIds()) if err == nil { t.Fatal("Expected error bringing up cluster") } }
func TestNewCliParamsWhenPrefixKeysAreNotPresent(t *testing.T) { os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "SECRET") defer func() { os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() context := defaultConfig() // Prefixes are present, and values should be set to defaults rdwr := &mockReadWriter{isKeyPresentValue: false} params, err := NewCliParams(context, rdwr) if err != nil { t.Errorf("Unexpected error when getting new cli params", err) } if ecscli.ComposeProjectNamePrefixDefaultValue != params.ComposeProjectNamePrefix { t.Errorf("Compose project name prefix mismatch. Expected [%s] got [%s]", ecscli.ComposeProjectNamePrefixDefaultValue, params.ComposeProjectNamePrefix) } if ecscli.ComposeServiceNamePrefixDefaultValue != params.ComposeServiceNamePrefix { t.Errorf("Compose service name prefix mismatch. Expected [%s] got [%s]", ecscli.ComposeServiceNamePrefixDefaultValue, params.ComposeServiceNamePrefix) } if ecscli.CFNStackNamePrefixDefaultValue != params.CFNStackNamePrefix { t.Errorf("stack name name prefix mismatch. Expected [%s] got [%s]", ecscli.CFNStackNamePrefixDefaultValue, params.CFNStackNamePrefix) } }
func TestEnv(t *testing.T) { context := getContextOrFail(t) name := "ENV_TEST_NAME" testValue := "TEST_VALUE" os.Setenv(name, testValue) notExisting := "ENV_TEST_NOT_EXISTING" os.Unsetenv(notExisting) invalidName := "ENV_TEST_INVALID_NAME" os.Setenv("="+invalidName, testValue) env := context.Env() if value := env[name]; value != testValue { t.Errorf("Expected env-variable %s value '%s', found '%s'", name, testValue, value) } if value, ok := env[notExisting]; ok { t.Errorf("Expected empty env-variable %s, found '%s'", notExisting, value) } for k, v := range env { if strings.Contains(k, invalidName) { t.Errorf("Expected invalid name not to be included in Env %s, found in key '%s'", invalidName, k) } if strings.Contains(v, invalidName) { t.Errorf("Expected invalid name not be be included in Env %s, found in value '%s'", invalidName, v) } } os.Unsetenv("=" + invalidName) }
// The TestMain function creates a go command for testing purposes and // deletes it after the tests have been run. func TestMain(m *testing.M) { flag.Parse() if canRun { // We give the executable a .exe extension because Windows. out, err := exec.Command("go", "build", "-tags", "testgo", "-o", "testgo.exe").CombinedOutput() if err != nil { fmt.Fprintf(os.Stderr, "building testgo failed: %v\n%s", err, out) os.Exit(2) } } // Don't let these environment variables confuse the test. os.Unsetenv("GOBIN") os.Unsetenv("GOPATH") os.Unsetenv("GOROOT") r := m.Run() if canRun { os.Remove("testgo.exe") } os.Exit(r) }
func TestGetContainerURL(t *testing.T) { data := []struct { env string url string pass bool }{ {"tcp://172.17.0.2:8000", "http://172.17.0.2:8000", true}, {"", "", false}, {"badlyformatted", "", false}, {"tc", "", false}, } defer os.Unsetenv(ENV_KEY) for _, tt := range data { if tt.env == "" { os.Unsetenv(ENV_KEY) } else { os.Setenv(ENV_KEY, tt.env) } url, err := getContainerURLFromEnv(CONTAINER_NAME, CONTAINER_PORT) if err == nil != tt.pass { if tt.pass { t.Errorf("Expected no errors but got %q: %+v", err.Error(), tt) } else { t.Errorf("Expected an error but got none (%s): %+v", url, tt) } } if tt.pass && url != tt.url { t.Errorf("Expected url %q but got %q", tt.url, url) } } }
func TestInitPaths(t *testing.T) { // // BITRISE_SOURCE_DIR // Unset BITRISE_SOURCE_DIR -> after InitPaths BITRISE_SOURCE_DIR should be CurrentDir if os.Getenv(BitriseSourceDirEnvKey) != "" { require.Equal(t, nil, os.Unsetenv(BitriseSourceDirEnvKey)) } require.Equal(t, nil, InitPaths()) require.Equal(t, CurrentDir, os.Getenv(BitriseSourceDirEnvKey)) // Set BITRISE_SOURCE_DIR -> after InitPaths BITRISE_SOURCE_DIR should keep content require.Equal(t, nil, os.Setenv(BitriseSourceDirEnvKey, "$HOME/test")) require.Equal(t, nil, InitPaths()) require.Equal(t, "$HOME/test", os.Getenv(BitriseSourceDirEnvKey)) // // BITRISE_DEPLOY_DIR // Unset BITRISE_DEPLOY_DIR -> after InitPaths BITRISE_DEPLOY_DIR should be temp dir if os.Getenv(BitriseDeployDirEnvKey) != "" { require.Equal(t, nil, os.Unsetenv(BitriseDeployDirEnvKey)) } require.Equal(t, nil, InitPaths()) require.NotEqual(t, "", os.Getenv(BitriseDeployDirEnvKey)) // Set BITRISE_DEPLOY_DIR -> after InitPaths BITRISE_DEPLOY_DIR should keep content require.Equal(t, nil, os.Setenv(BitriseDeployDirEnvKey, "$HOME/test")) require.Equal(t, nil, InitPaths()) require.Equal(t, "$HOME/test", os.Getenv(BitriseDeployDirEnvKey)) }
func (s *RunSuite) TestInterpolationWithExtends(c *C) { os.Setenv("IMAGE", "tianon/true") os.Setenv("TEST_PORT", "8000") p := s.CreateProjectFromText(c, ` test: extends: file: ./assets/interpolation/docker-compose.yml service: base ports: - ${TEST_PORT} `) name := fmt.Sprintf("%s_%s_1", p, "test") testContainer := s.GetContainerByName(c, name) p = s.CreateProjectFromText(c, ` reference: image: tianon/true ports: - 8000 `) name = fmt.Sprintf("%s_%s_1", p, "reference") referenceContainer := s.GetContainerByName(c, name) c.Assert(testContainer, NotNil) c.Assert(referenceContainer.Image, Equals, testContainer.Image) os.Unsetenv("TEST_PORT") os.Unsetenv("IMAGE") }
func TestEnv(t *testing.T) { os.Setenv("STR", "helloworld") os.Setenv("NUM", "42") os.Setenv("BOOL", "true") //config type Config struct { Str string Num int Bool bool } c := &Config{} //flag example parse New(c).UseEnv().Parse() os.Unsetenv("STR") os.Unsetenv("NUM") os.Unsetenv("BOOL") //check config is filled check(t, c.Str, `helloworld`) check(t, c.Num, 42) check(t, c.Bool, true) }
func UnsetFixtures() { for key, _ := range Fixtures { os.Unsetenv(key) } // and others, sometimes os.Unsetenv("F_BLANK") os.Unsetenv("F_WHITESPACE") }
func TestSdWatchdogEnabled(t *testing.T) { mypid := strconv.Itoa(os.Getpid()) tests := []struct { usec string // empty => unset pid string // empty => unset unsetEnv bool // arbitrarily set across testcases werr bool wdelay time.Duration }{ // Success cases {"100", mypid, true, false, 100 * time.Microsecond}, {"50", mypid, true, false, 50 * time.Microsecond}, {"1", mypid, false, false, 1 * time.Microsecond}, {"1", "", true, false, 1 * time.Microsecond}, // No-op cases {"", mypid, true, false, 0}, // WATCHDOG_USEC not set {"1", "0", false, false, 0}, // WATCHDOG_PID doesn't match {"", "", true, false, 0}, // Both not set // Failure cases {"-1", mypid, true, true, 0}, // Negative USEC {"string", "1", false, true, 0}, // Non-integer USEC value {"1", "string", true, true, 0}, // Non-integer PID value {"stringa", "stringb", false, true, 0}, // E v e r y t h i n g {"-10239", "-eleventythree", true, true, 0}, // i s w r o n g } for i, tt := range tests { if tt.usec != "" { must(os.Setenv("WATCHDOG_USEC", tt.usec)) } else { must(os.Unsetenv("WATCHDOG_USEC")) } if tt.pid != "" { must(os.Setenv("WATCHDOG_PID", tt.pid)) } else { must(os.Unsetenv("WATCHDOG_PID")) } delay, err := SdWatchdogEnabled(tt.unsetEnv) if tt.werr && err == nil { t.Errorf("#%d: want non-nil err, got nil", i) } else if !tt.werr && err != nil { t.Errorf("#%d: want nil err, got %v", i, err) } if tt.wdelay != delay { t.Errorf("#%d: want delay=%d, got %d", i, tt.wdelay, delay) } if tt.unsetEnv && (os.Getenv("WATCHDOG_PID") != "" || os.Getenv("WATCHDOG_USEC") != "") { t.Errorf("#%d: environment variables not cleaned up", i) } } }
func TestClusterUpForImageIdInput(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() mockEcs := mock_ecs.NewMockECSClient(ctrl) mockCloudformation := mock_cloudformation.NewMockCloudformationClient(ctrl) imageId := "ami-12345" os.Setenv("AWS_ACCESS_KEY", "AKIDEXAMPLE") os.Setenv("AWS_SECRET_KEY", "secret") defer func() { os.Unsetenv("AWS_ACCESS_KEY") os.Unsetenv("AWS_SECRET_KEY") }() gomock.InOrder( mockEcs.EXPECT().Initialize(gomock.Any()), mockEcs.EXPECT().CreateCluster(gomock.Any()).Do(func(in interface{}) { if in.(string) != clusterName { t.Fatal("Expected to be called with " + clusterName + " not " + in.(string)) } }).Return(clusterName, nil), ) gomock.InOrder( mockCloudformation.EXPECT().Initialize(gomock.Any()), mockCloudformation.EXPECT().ValidateStackExists(gomock.Any()).Return(errors.New("error")), mockCloudformation.EXPECT().CreateStack(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(x, y, z interface{}) { cfnStackParams := z.(*cloudformation.CfnStackParams) param, err := cfnStackParams.GetParameter(cloudformation.ParameterKeyAmiId) if err != nil { t.Fatal("Expected image id params to be present") } if imageId != aws.StringValue(param.ParameterValue) { t.Fatalf("Expected image id to equal %s but got %s", imageId, aws.StringValue(param.ParameterValue)) } }).Return("", nil), mockCloudformation.EXPECT().WaitUntilCreateComplete(gomock.Any()).Return(nil), ) globalSet := flag.NewFlagSet("ecs-cli", 0) globalSet.String("region", "us-west-1", "") globalContext := cli.NewContext(nil, globalSet, nil) flagSet := flag.NewFlagSet("ecs-cli-up", 0) flagSet.Bool(capabilityIAMFlag, true, "") flagSet.String(keypairNameFlag, "default", "") flagSet.String(imageIdFlag, imageId, "") flagSet.String(certificateFlag, "default", "") context := cli.NewContext(nil, flagSet, globalContext) err := createCluster(context, &mockReadWriter{}, mockEcs, mockCloudformation, ami.NewStaticAmiIds()) if err != nil { t.Fatal("Error bringing up cluster: ", err) } }
func TestPbftF0(t *testing.T) { net := makeTestnet(1, func(inst *instance) { os.Setenv("OPENCHAIN_OBCPBFT_GENERAL_N", fmt.Sprintf("%d", inst.net.N)) // TODO, a little hacky, but needed for state transfer not to get upset os.Setenv("OPENCHAIN_OBCPBFT_GENERAL_F", "0") // TODO, a little hacky, but needed for state transfer not to get upset defer func() { os.Unsetenv("OPENCHAIN_OBCPBFT_GENERAL_N") os.Unsetenv("OPENCHAIN_OBCPBFT_GENERAL_F") }() config := loadConfig() inst.pbft = newPbftCore(uint64(inst.id), config, inst, inst) inst.pbft.replicaCount = inst.net.N inst.pbft.f = inst.net.f inst.deliver = func(msg []byte, senderHandle *pb.PeerID) { senderID, _ := getValidatorID(senderHandle) inst.pbft.receive(msg, senderID) } }) defer net.close() // Create a message of type: `OpenchainMessage_CHAIN_TRANSACTION` txTime := &gp.Timestamp{Seconds: 1, Nanos: 0} tx := &pb.Transaction{Type: pb.Transaction_CHAINCODE_NEW, Timestamp: txTime, Payload: []byte("TestNetwork")} txPacked, err := proto.Marshal(tx) if err != nil { t.Fatalf("Failed to marshal TX block: %s", err) } err = net.replicas[0].pbft.request(txPacked, 0) if err != nil { t.Fatalf("Request failed: %s", err) } err = net.process() if err != nil { t.Fatalf("Processing failed: %s", err) } for _, inst := range net.replicas { blockHeight, _ := inst.ledger.GetBlockchainSize() if blockHeight <= 1 { t.Errorf("Instance %d did not execute transaction", inst.id) continue } if blockHeight != 2 { t.Errorf("Instance %d executed more than one transaction", inst.id) continue } highestBlock, _ := inst.ledger.GetBlock(blockHeight - 1) if !reflect.DeepEqual(highestBlock.Transactions[0].Payload, txPacked) { t.Errorf("Instance %d executed wrong transaction, %x should be %x", inst.id, highestBlock.Transactions[0].Payload, txPacked) } } }