func TestCanSupportStructWithNestedPointers(t *testing.T) { assert := assert.New(t) data := struct{ A *struct{ B int } }{} result, err := Search("A.B", data) assert.Nil(err) assert.Nil(result) }
func TestWithFieldsShouldAllowAssignments(t *testing.T) { var buffer bytes.Buffer var fields Fields logger := New() logger.Out = &buffer logger.Formatter = new(JSONFormatter) localLog := logger.WithFields(Fields{ "key1": "value1", }) localLog.WithField("key2", "value2").Info("test") err := json.Unmarshal(buffer.Bytes(), &fields) assert.Nil(t, err) assert.Equal(t, "value2", fields["key2"]) assert.Equal(t, "value1", fields["key1"]) buffer = bytes.Buffer{} fields = Fields{} localLog.Info("test") err = json.Unmarshal(buffer.Bytes(), &fields) assert.Nil(t, err) _, ok := fields["key2"] assert.Equal(t, false, ok) assert.Equal(t, "value1", fields["key1"]) }
func TestOutputService4ProtocolTestListsCase2(t *testing.T) { sess := session.New() svc := NewOutputService4ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [\"a\", null], \"ListMemberMap\": [{}, null, null, {}], \"ListMemberStruct\": [{}, null, null, {}]}")) req, out := svc.OutputService4TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response jsonrpc.UnmarshalMeta(req) jsonrpc.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "a", *out.ListMember[0]) assert.Nil(t, out.ListMember[1]) assert.Nil(t, out.ListMemberMap[1]) assert.Nil(t, out.ListMemberMap[2]) assert.Nil(t, out.ListMemberStruct[1]) assert.Nil(t, out.ListMemberStruct[2]) }
func TestValidPrecompiledExpressionSearches(t *testing.T) { assert := assert.New(t) data := make(map[string]interface{}) data["foo"] = "bar" precompiled, err := Compile("foo") assert.Nil(err) result, err := precompiled.Search(data) assert.Nil(err) assert.Equal("bar", result) }
// Use DynamoDB methods for simplicity func TestPagination(t *testing.T) { db := dynamodb.New(unit.Session) tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false reqNum := 0 resps := []*dynamodb.ListTablesOutput{ {TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")}, {TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")}, {TableNames: []*string{aws.String("Table5")}}, } db.Handlers.Send.Clear() // mock sending db.Handlers.Unmarshal.Clear() db.Handlers.UnmarshalMeta.Clear() db.Handlers.ValidateResponse.Clear() db.Handlers.Build.PushBack(func(r *request.Request) { in := r.Params.(*dynamodb.ListTablesInput) if in == nil { tokens = append(tokens, "") } else if in.ExclusiveStartTableName != nil { tokens = append(tokens, *in.ExclusiveStartTableName) } }) db.Handlers.Unmarshal.PushBack(func(r *request.Request) { r.Data = resps[reqNum] reqNum++ }) params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)} err := db.ListTablesPages(params, func(p *dynamodb.ListTablesOutput, last bool) bool { numPages++ for _, t := range p.TableNames { pages = append(pages, *t) } if last { if gotToEnd { assert.Fail(t, "last=true happened twice") } gotToEnd = true } return true }) assert.Equal(t, []string{"Table2", "Table4"}, tokens) assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages) assert.Equal(t, 3, numPages) assert.True(t, gotToEnd) assert.Nil(t, err) assert.Nil(t, params.ExclusiveStartTableName) }
func TestCanSupportStructWithSlice(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{scalars{"f1", "b1"}, scalars{"correct", "b2"}}} result, err := Search("B[-1].Foo", data) assert.Nil(err) assert.Equal("correct", result) }
func TestManifestInvalid(t *testing.T) { manifest, err := LoadManifest("invalid-manifest") assert.Nil(t, manifest) assert.NotNil(t, err) assert.Regexp(t, "^invalid manifest: ", err.Error()) }
// 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 TestCanSupportUserDefinedStructsRef(t *testing.T) { assert := assert.New(t) s := scalars{Foo: "one", Bar: "bar"} result, err := Search("Foo", &s) assert.Nil(err) assert.Equal("one", result) }
func TestCanSupportStructWithFilterProjection(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{scalars{"f1", "b1"}, scalars{"correct", "b2"}}} result, err := Search("B[? `true` ].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"f1", "correct"}, result) }
func TestEC2RoleProviderExpiryWindowIsExpired(t *testing.T) { server := initTestServer("2014-12-16T01:51:37Z", false) defer server.Close() p := &ec2rolecreds.EC2RoleProvider{ Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}), ExpiryWindow: time.Hour * 1, } p.CurrentTime = func() time.Time { return time.Date(2014, 12, 15, 0, 51, 37, 0, time.UTC) } assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.") _, err := p.Retrieve() assert.Nil(t, err, "Expect no error, %v", err) assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.") p.CurrentTime = func() time.Time { return time.Date(2014, 12, 16, 0, 55, 37, 0, time.UTC) } assert.True(t, p.IsExpired(), "Expect creds to be expired.") }
func TestCanSupportStructWithOrExpressions(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", C: nil} result, err := Search("C || A", data) assert.Nil(err) assert.Equal("foo", result) }
func TestDoubleLoggingDoesntPrefixPreviousFields(t *testing.T) { var buffer bytes.Buffer var fields Fields logger := New() logger.Out = &buffer logger.Formatter = new(JSONFormatter) llog := logger.WithField("context", "eating raw fish") llog.Info("looks delicious") err := json.Unmarshal(buffer.Bytes(), &fields) assert.NoError(t, err, "should have decoded first message") assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields") assert.Equal(t, fields["msg"], "looks delicious") assert.Equal(t, fields["context"], "eating raw fish") buffer.Reset() llog.Warn("omg it is!") err = json.Unmarshal(buffer.Bytes(), &fields) assert.NoError(t, err, "should have decoded second message") assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields") assert.Equal(t, fields["msg"], "omg it is!") assert.Equal(t, fields["context"], "eating raw fish") assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry") }
func TestCanSupportEmptyInterface(t *testing.T) { assert := assert.New(t) data := make(map[string]interface{}) data["foo"] = "bar" result, err := Search("foo", data) assert.Nil(err) assert.Equal("bar", result) }
func TestParseLevel(t *testing.T) { l, err := ParseLevel("panic") assert.Nil(t, err) assert.Equal(t, PanicLevel, l) l, err = ParseLevel("fatal") assert.Nil(t, err) assert.Equal(t, FatalLevel, l) l, err = ParseLevel("error") assert.Nil(t, err) assert.Equal(t, ErrorLevel, l) l, err = ParseLevel("warn") assert.Nil(t, err) assert.Equal(t, WarnLevel, l) l, err = ParseLevel("warning") assert.Nil(t, err) assert.Equal(t, WarnLevel, l) l, err = ParseLevel("info") assert.Nil(t, err) assert.Equal(t, InfoLevel, l) l, err = ParseLevel("debug") assert.Nil(t, err) assert.Equal(t, DebugLevel, l) l, err = ParseLevel("invalid") assert.Equal(t, "not a valid logrus Level: \"invalid\"", err.Error()) }
func TestCanSupportProjectionsWithStructs(t *testing.T) { assert := assert.New(t) data := nestedSlice{A: []sliceType{ {A: "first"}, {A: "second"}, {A: "third"}, }} result, err := Search("A[*].A", data) assert.Nil(err) assert.Equal([]interface{}{"first", "second", "third"}, result) }
func TestCanSupportFlattenNestedEmptySlice(t *testing.T) { assert := assert.New(t) data := nestedSlice{A: []sliceType{ {}, {B: []scalars{{Foo: "a"}}}, }} result, err := Search("A[].B[].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"a"}, result) }
func (er ExecRun) Test(t *testing.T) { stdout, stderr, code, err := er.exec() assert.Nil(t, err, "should be nil") assert.Equal(t, er.Exit, code, "exit code should be equal") assert.Equal(t, er.Stdout, stdout, "stdout should be equal") assert.Contains(t, stderr, er.Stderr, fmt.Sprintf("stderr should contain %q", stderr)) }
func TestResolve(t *testing.T) { vs := Versions{ Version{ Version: "1", Published: true, Required: false, }, Version{ Version: "2", Published: false, Required: false, }, Version{ Version: "3", Published: true, Required: false, }, Version{ Version: "4", Published: false, Required: false, }, Version{ Version: "5", Published: false, Required: false, }, } resolved, err := vs.Resolve("latest") if assert.Nil(t, err) { assert.Equal(t, "3", resolved.Version) } resolved, err = vs.Resolve("stable") if assert.Nil(t, err) { assert.Equal(t, "3", resolved.Version) } resolved, err = vs.Resolve("edge") if assert.Nil(t, err) { assert.Equal(t, "5", resolved.Version) } }
// Use S3 for simplicity func TestPaginationTruncation(t *testing.T) { client := s3.New(unit.Session) reqNum := 0 resps := []*s3.ListObjectsOutput{ {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key1")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key2")}}}, {IsTruncated: aws.Bool(false), Contents: []*s3.Object{{Key: aws.String("Key3")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key4")}}}, } client.Handlers.Send.Clear() // mock sending client.Handlers.Unmarshal.Clear() client.Handlers.UnmarshalMeta.Clear() client.Handlers.ValidateResponse.Clear() client.Handlers.Unmarshal.PushBack(func(r *request.Request) { r.Data = resps[reqNum] reqNum++ }) params := &s3.ListObjectsInput{Bucket: aws.String("bucket")} results := []string{} err := client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2", "Key3"}, results) assert.Nil(t, err) // Try again without truncation token at all reqNum = 0 resps[1].IsTruncated = nil resps[2].IsTruncated = aws.Bool(true) results = []string{} err = client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2"}, results) assert.Nil(t, err) }
func TestWillAutomaticallyCapitalizeFieldNames(t *testing.T) { assert := assert.New(t) s := scalars{Foo: "one", Bar: "bar"} // Note that there's a lower cased "foo" instead of "Foo", // but it should still correspond to the Foo field in the // scalars struct result, err := Search("foo", &s) assert.Nil(err) assert.Equal("one", result) }
func TestCopyDifferentStructs(t *testing.T) { type SrcFoo struct { A int B []*string C map[string]*int SrcUnique string SameNameDiffType int unexportedPtr *int ExportedPtr *int } type DstFoo struct { A int B []*string C map[string]*int DstUnique int SameNameDiffType string unexportedPtr *int ExportedPtr *int } // Create the initial value str1 := "hello" str2 := "bye bye" int1 := 1 int2 := 2 f1 := &SrcFoo{ A: 1, B: []*string{&str1, &str2}, C: map[string]*int{ "A": &int1, "B": &int2, }, SrcUnique: "unique", SameNameDiffType: 1, unexportedPtr: &int1, ExportedPtr: &int2, } // Do the copy var f2 DstFoo awsutil.Copy(&f2, f1) // Values are equal assert.Equal(t, f2.A, f1.A) assert.Equal(t, f2.B, f1.B) assert.Equal(t, f2.C, f1.C) assert.Equal(t, "unique", f1.SrcUnique) assert.Equal(t, 1, f1.SameNameDiffType) assert.Equal(t, 0, f2.DstUnique) assert.Equal(t, "", f2.SameNameDiffType) assert.Equal(t, int1, *f1.unexportedPtr) assert.Nil(t, f2.unexportedPtr) assert.Equal(t, int2, *f1.ExportedPtr) assert.Equal(t, int2, *f2.ExportedPtr) }
func TestSharedCredentialsProvider(t *testing.T) { os.Clearenv() p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""} creds, err := p.Retrieve() assert.Nil(t, err, "Expect no error") assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match") assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match") assert.Equal(t, "token", creds.SessionToken, "Expect session token to match") }
func TestGetProcessesWithDeployments(t *testing.T) { os.Setenv("RACK", "convox-test") os.Setenv("CLUSTER", "convox-test-cluster") aws := test.StubAws( test.DescribeAppStackCycle("convox-test-myapp-staging"), test.DescribeAppStackCycle("convox-test-myapp-staging"), test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"), test.ListContainerInstancesCycle("convox-test-cluster"), test.DescribeContainerInstancesCycle("convox-test-cluster"), test.DescribeInstancesCycle(), test.ListTasksCycle("convox-test-cluster", "convox-test-myapp-staging-worker-SCELGCIYSKF"), test.DescribeTasksCycle("convox-test-cluster"), test.ListTasksOneoffEmptyCycle("convox-test-cluster"), test.DescribeTaskDefinitionCycle("convox-test-cluster"), test.DescribeAppStackResourcesCycle("convox-test-myapp-staging"), test.DescribeServicesWithDeploymentsCycle("convox-test-cluster"), test.DescribeTaskDefinition3Cycle("convox-test-cluster"), test.DescribeTaskDefinition1Cycle("convox-test-cluster"), ) defer aws.Close() docker := test.StubDocker( // query for every ECS task to get docker id, command, created test.ListECSContainersCycle(), // query every instance for one-off containers test.ListOneoffContainersEmptyCycle(), test.ListOneoffContainersEmptyCycle(), test.ListOneoffContainersEmptyCycle(), // query for every container to get CPU and Memory stats test.StatsCycle(), ) defer docker.Close() v := url.Values{} v.Add("stats", "true") body := test.HTTPBody("GET", "http://convox/apps/myapp-staging/processes", v) var resp client.Processes err := json.Unmarshal([]byte(body), &resp) if assert.Nil(t, err) { assert.Equal(t, 2, len(resp)) assert.Equal(t, "8dfafdbc3a40", resp[0].Id) assert.Equal(t, 0.0974, resp[0].Memory) assert.Equal(t, "pending", resp[1].Id) assert.EqualValues(t, 0, resp[1].Memory) } }
func TestSharedCredentialsProviderIsExpired(t *testing.T) { os.Clearenv() p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""} assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve") _, err := p.Retrieve() assert.Nil(t, err, "Expect no error") assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve") }
func TestSharedCredentialsProviderWithAWS_SHARED_CREDENTIALS_FILE(t *testing.T) { os.Clearenv() os.Setenv("AWS_SHARED_CREDENTIALS_FILE", "example.ini") p := SharedCredentialsProvider{} creds, err := p.Retrieve() assert.Nil(t, err, "Expect no error") assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match") assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match") assert.Equal(t, "token", creds.SessionToken, "Expect session token to match") }
func TestPopulateLocationConstraint(t *testing.T) { s := s3.New(unit.Session) in := &s3.CreateBucketInput{ Bucket: aws.String("bucket"), } req, _ := s.CreateBucketRequest(in) err := req.Build() assert.NoError(t, err) v, _ := awsutil.ValuesAtPath(req.Params, "CreateBucketConfiguration.LocationConstraint") assert.Equal(t, "mock-region", *(v[0].(*string))) assert.Nil(t, in.CreateBucketConfiguration) // don't modify original params }
func TestSlicePositiveStep(t *testing.T) { assert := assert.New(t) input := make([]interface{}, 5) input[0] = 0 input[1] = 1 input[2] = 2 input[3] = 3 input[4] = 4 result, err := slice(input, []sliceParam{sliceParam{0, true}, sliceParam{3, true}, sliceParam{1, true}}) assert.Nil(err) assert.Equal(input[:3], result) }
func TestEnvProviderAlternateNames(t *testing.T) { os.Clearenv() os.Setenv("AWS_ACCESS_KEY", "access") os.Setenv("AWS_SECRET_KEY", "secret") e := EnvProvider{} creds, err := e.Retrieve() assert.Nil(t, err, "Expect no error") assert.Equal(t, "access", creds.AccessKeyID, "Expected access key ID") assert.Equal(t, "secret", creds.SecretAccessKey, "Expected secret access key") assert.Empty(t, creds.SessionToken, "Expected no token") }
func TestEnvProviderRetrieve(t *testing.T) { os.Clearenv() os.Setenv("AWS_ACCESS_KEY_ID", "access") os.Setenv("AWS_SECRET_ACCESS_KEY", "secret") os.Setenv("AWS_SESSION_TOKEN", "token") e := EnvProvider{} creds, err := e.Retrieve() assert.Nil(t, err, "Expect no error") assert.Equal(t, "access", creds.AccessKeyID, "Expect access key ID to match") assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match") assert.Equal(t, "token", creds.SessionToken, "Expect session token to match") }