func TestTry2(t *testing.T) { assert := assert.New(t) assert.Panics(func() { Try(func() { panic(te) }) }) assert.Panics(func() { Try(func() { PanicIfError(te) }, te2) }) assert.Error(func() error { return Try(func() { PanicIfError(te) }) }()) assert.Error(func() error { return Try(func() { PanicIfError(te) }, testError{}) }()) assert.Nil(func() error { return Try(func() { PanicIfError(nil) }) }()) }
func TestDatabaseSpecs(t *testing.T) { assert := assert.New(t) badSpecs := []string{"mem:stuff", "mem:", "http:", "https:", "random:", "random:random", "http://some.com/wi::rd/path", "/file/ba:d"} for _, spec := range badSpecs { _, err := ParseDatabaseSpec(spec) assert.Error(err) } testCases := []map[string]string{ map[string]string{"spec": "http://localhost:8000", "scheme": "http", "path": "//localhost:8000"}, map[string]string{"spec": "http://localhost:8000/fff", "scheme": "http", "path": "//localhost:8000/fff"}, map[string]string{"spec": "https://local.attic.io/john/doe", "scheme": "https", "path": "//local.attic.io/john/doe"}, map[string]string{"spec": "ldb:/filesys/john/doe", "scheme": "ldb", "path": "/filesys/john/doe"}, map[string]string{"spec": "./john/doe", "scheme": "ldb", "path": "./john/doe"}, map[string]string{"spec": "john/doe", "scheme": "ldb", "path": "john/doe"}, map[string]string{"spec": "/john/doe", "scheme": "ldb", "path": "/john/doe"}, map[string]string{"spec": "mem", "scheme": "mem", "path": ""}, map[string]string{"spec": "http://server.com/john/doe?access_token=jane", "scheme": "http", "path": "//server.com/john/doe?access_token=jane", "accessToken": "jane"}, map[string]string{"spec": "https://server.com/john/doe/?arg=2&qp1=true&access_token=jane", "scheme": "https", "path": "//server.com/john/doe/?arg=2&qp1=true&access_token=jane", "accessToken": "jane"}, } for _, tc := range testCases { dbSpec, err := ParseDatabaseSpec(tc["spec"]) assert.NoError(err) assert.Equal(DatabaseSpec{Protocol: tc["scheme"], Path: tc["path"], accessToken: tc["accessToken"]}, dbSpec) } }
func TestPathSpec(t *testing.T) { assert := assert.New(t) badSpecs := []string{"mem::#", "mem::#s", "mem::#foobarbaz", "mem::#wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"} for _, bs := range badSpecs { _, err := parsePathSpec(bs) assert.Error(err) } type testCase struct { spec, scheme, dbPath, pathStr string } testCases := []testCase{ testCase{"http://local.attic.io/john/doe::#0123456789abcdefghijklmnopqrstuv", "http", "//local.attic.io/john/doe", "#0123456789abcdefghijklmnopqrstuv"}, testCase{"ldb:/filesys/john/doe::#0123456789abcdefghijklmnopqrstuv", "ldb", "/filesys/john/doe", "#0123456789abcdefghijklmnopqrstuv"}, testCase{"mem::#0123456789abcdefghijklmnopqrstuv", "mem", "", "#0123456789abcdefghijklmnopqrstuv"}, testCase{"http://local.attic.io/john/doe::#0123456789abcdefghijklmnopqrstuv", "http", "//local.attic.io/john/doe", "#0123456789abcdefghijklmnopqrstuv"}, testCase{"http://localhost:8000/john/doe/::ds1", "http", "//localhost:8000/john/doe/", "ds1"}, } for _, tc := range testCases { dbSpec := databaseSpec{Protocol: tc.scheme, Path: tc.dbPath, accessToken: ""} path, err := NewAbsolutePath(tc.pathStr) assert.NoError(err) expected := pathSpec{dbSpec, path} actual, err := parsePathSpec(tc.spec) assert.NoError(err) assert.Equal(expected, actual) } }
func TestDatabaseSpecs(t *testing.T) { assert := assert.New(t) badSpecs := []string{"mem:stuff", "mem:", "http:", "https:", "random:", "random:random", "/file/ba:d"} for _, spec := range badSpecs { _, err := parseDatabaseSpec(spec) assert.Error(err, spec) } type testCase struct { spec, scheme, path, accessToken string } testCases := []testCase{ testCase{"http://localhost:8000", "http", "//localhost:8000", ""}, testCase{"http://localhost:8000/fff", "http", "//localhost:8000/fff", ""}, testCase{"https://local.attic.io/john/doe", "https", "//local.attic.io/john/doe", ""}, testCase{"ldb:/filesys/john/doe", "ldb", "/filesys/john/doe", ""}, testCase{"./john/doe", "ldb", "./john/doe", ""}, testCase{"john/doe", "ldb", "john/doe", ""}, testCase{"/john/doe", "ldb", "/john/doe", ""}, testCase{"mem", "mem", "", ""}, testCase{"http://server.com/john/doe?access_token=jane", "http", "//server.com/john/doe?access_token=jane", "jane"}, testCase{"https://server.com/john/doe/?arg=2&qp1=true&access_token=jane", "https", "//server.com/john/doe/?arg=2&qp1=true&access_token=jane", "jane"}, } for _, tc := range testCases { dbSpec, err := parseDatabaseSpec(tc.spec) assert.NoError(err) assert.Equal(databaseSpec{Protocol: tc.scheme, Path: tc.path, accessToken: tc.accessToken}, dbSpec) } }
func TestTwoClientsWithEmptyDataset(t *testing.T) { assert := assert.New(t) id1 := "testdataset" cs := chunks.NewMemoryStore() dsx := newDS(id1, cs) dsy := newDS(id1, cs) // dsx: || -> |a| a := types.String("a") dsx, err := dsx.CommitValue(a) assert.NoError(err) assert.True(dsx.Head().Get(datas.ValueField).Equals(a)) // dsy: || -> |b| _, ok := dsy.MaybeHead() assert.False(ok) b := types.String("b") dsy, err = dsy.CommitValue(b) assert.Error(err) // Commit failed, but ds1 now has latest head, so we should be able to just try again. // dsy: |a| -> |b| dsy, err = dsy.CommitValue(b) assert.NoError(err) assert.True(dsy.Head().Get(datas.ValueField).Equals(b)) }
func TestDatasetSpecs(t *testing.T) { assert := assert.New(t) badSpecs := []string{"mem", "mem:", "mem:::ds", "http", "http:", "http://foo", "monkey", "monkey:balls", "mem:/a/bogus/path:dsname", "http://localhost:8000/one"} for _, spec := range badSpecs { _, err := parseDatasetSpec(spec) assert.Error(err, spec) } invalidDatasetNames := []string{" ", "", "$", "#", ":", "\n", "💩"} for _, s := range invalidDatasetNames { _, err := parseDatasetSpec("mem::" + s) assert.Error(err) } validDatasetNames := []string{"a", "Z", "0", "/", "-", "_"} for _, s := range validDatasetNames { _, err := parseDatasetSpec("mem::" + s) assert.NoError(err) } type testCase struct { spec, scheme, path, ds, accessToken string } testCases := []testCase{ testCase{"http://localhost:8000::ds1", "http", "//localhost:8000", "ds1", ""}, testCase{"http://localhost:8000/john/doe/::ds2", "http", "//localhost:8000/john/doe/", "ds2", ""}, testCase{"https://local.attic.io/john/doe::ds3", "https", "//local.attic.io/john/doe", "ds3", ""}, testCase{"http://local.attic.io/john/doe::ds1", "http", "//local.attic.io/john/doe", "ds1", ""}, testCase{"ldb:/filesys/john/doe::ds/one", "ldb", "/filesys/john/doe", "ds/one", ""}, testCase{"http://localhost:8000/john/doe?access_token=abc::ds/one", "http", "//localhost:8000/john/doe?access_token=abc", "ds/one", "abc"}, testCase{"https://localhost:8000?qp1=x&access_token=abc&qp2=y::ds/one", "https", "//localhost:8000?qp1=x&access_token=abc&qp2=y", "ds/one", "abc"}, } for _, tc := range testCases { dsSpec, err := parseDatasetSpec(tc.spec) assert.NoError(err) dbSpec1 := databaseSpec{Protocol: tc.scheme, Path: tc.path, accessToken: tc.accessToken} assert.Equal(datasetSpec{DbSpec: dbSpec1, DatasetName: tc.ds}, dsSpec) } }
func TestDatasetSpecs(t *testing.T) { assert := assert.New(t) badSpecs := []string{"mem", "mem:", "mem:::ds", "http", "http:", "http://foo", "monkey", "monkey:balls", "http::dsname", "mem:/a/bogus/path:dsname", "http://localhost:8000/one"} for _, spec := range badSpecs { _, err := ParseDatasetSpec(spec) assert.Error(err) } invalidDatasetNames := []string{" ", "", "$", "#", ":", "\n", "💩"} for _, s := range invalidDatasetNames { _, err := ParseDatasetSpec("mem::" + s) assert.Error(err) } validDatasetNames := []string{"a", "Z", "0", "/", "-", "_"} for _, s := range validDatasetNames { _, err := ParseDatasetSpec("mem::" + s) assert.NoError(err) } testCases := []map[string]string{ map[string]string{"spec": "http://localhost:8000::ds1", "scheme": "http", "path": "//localhost:8000", "ds": "ds1"}, map[string]string{"spec": "http://localhost:8000/john/doe/::ds2", "scheme": "http", "path": "//localhost:8000/john/doe/", "ds": "ds2"}, map[string]string{"spec": "https://local.attic.io/john/doe::ds3", "scheme": "https", "path": "//local.attic.io/john/doe", "ds": "ds3"}, map[string]string{"spec": "http://local.attic.io/john/doe::ds1", "scheme": "http", "path": "//local.attic.io/john/doe", "ds": "ds1"}, map[string]string{"spec": "ldb:/filesys/john/doe::ds/one", "scheme": "ldb", "path": "/filesys/john/doe", "ds": "ds/one"}, map[string]string{"spec": "http://localhost:8000/john/doe?access_token=abc::ds/one", "scheme": "http", "path": "//localhost:8000/john/doe?access_token=abc", "accessToken": "abc", "ds": "ds/one"}, map[string]string{"spec": "https://localhost:8000?qp1=x&access_token=abc&qp2=y::ds/one", "scheme": "https", "path": "//localhost:8000?qp1=x&access_token=abc&qp2=y", "accessToken": "abc", "ds": "ds/one"}, } for _, tc := range testCases { dsSpec, err := ParseDatasetSpec(tc["spec"]) assert.NoError(err) dbSpec1 := DatabaseSpec{Protocol: tc["scheme"], Path: tc["path"], accessToken: tc["accessToken"]} assert.Equal(DatasetSpec{DbSpec: dbSpec1, DatasetName: tc["ds"]}, dsSpec) } }
func TestTryCatch(t *testing.T) { assert := assert.New(t) assert.Panics(func() { TryCatch(func() { panic(Wrap(te)) }, func(err error) error { if !causeInTypes(err, testError2{}) { panic(err) } return Unwrap(err) }) }) assert.Panics(func() { TryCatch(func() { panic(te) }, func(err error) error { if !causeInTypes(err, testError{}) { panic(err) } return Unwrap(err) }) }) assert.IsType(wrappedError{}, func() error { return TryCatch(func() { panic(Wrap(te)) }, func(err error) error { return err }) }()) assert.Error(func() error { return TryCatch(func() { panic(Wrap(te)) }, func(err error) error { if !causeInTypes(err, testError2{}, testError{}) { panic(err) } return Unwrap(err) }) }()) }
func TestAbsolutePathParseErrors(t *testing.T) { assert := assert.New(t) test := func(path, errMsg string) { p, err := NewAbsolutePath(path) assert.Equal(AbsolutePath{}, p) assert.Error(err) assert.Equal(errMsg, err.Error()) } test("", "Empty path") test(".foo", "Invalid dataset name: .foo") test(".foo.bar.baz", "Invalid dataset name: .foo.bar.baz") test("#", "Invalid hash: ") test("#abc", "Invalid hash: abc") invHash := strings.Repeat("z", hash.StringLen) test("#"+invHash, "Invalid hash: "+invHash) }
func TestPathSpec(t *testing.T) { assert := assert.New(t) testCases := []map[string]string{ map[string]string{"spec": "http://local.attic.io/john/doe::sha1-0123456789012345678901234567890123456789", "scheme": "http", "path": "//local.attic.io/john/doe", "ref": "sha1-0123456789012345678901234567890123456789"}, map[string]string{"spec": "http://localhost:8000/john/doe/::ds1", "scheme": "http", "path": "//localhost:8000/john/doe/", "ds": "ds1"}, } for _, tc := range testCases { pathSpec, err := ParsePathSpec(tc["spec"]) assert.NoError(err) dbSpec1 := DatabaseSpec{Protocol: tc["scheme"], Path: tc["path"], accessToken: tc["accessToken"]} if tc["ref"] != "" { assert.Equal(&RefSpec{DbSpec: dbSpec1, Ref: hash.Parse(tc["ref"])}, pathSpec.(*RefSpec)) } else { assert.Equal(&DatasetSpec{DbSpec: dbSpec1, DatasetName: tc["ds"]}, pathSpec.(*DatasetSpec)) } } _, err := ParsePathSpec("http://local.attic.io") assert.Error(err) }
func TestTwoClientsWithNonEmptyDataset(t *testing.T) { assert := assert.New(t) id1 := "testdataset" cs := chunks.NewMemoryStore() a := types.String("a") { // ds1: || -> |a| ds1 := newDS(id1, cs) ds1, err := ds1.Commit(a) assert.NoError(err) assert.True(ds1.Head().Get(datas.ValueField).Equals(a)) } dsx := newDS(id1, cs) dsy := newDS(id1, cs) // dsx: |a| -> |b| assert.True(dsx.Head().Get(datas.ValueField).Equals(a)) b := types.String("b") dsx, err := dsx.Commit(b) assert.NoError(err) assert.True(dsx.Head().Get(datas.ValueField).Equals(b)) // dsy: |a| -> |c| assert.True(dsy.Head().Get(datas.ValueField).Equals(a)) c := types.String("c") dsy, err = dsy.Commit(c) assert.Error(err) assert.True(dsy.Head().Get(datas.ValueField).Equals(b)) // Commit failed, but dsy now has latest head, so we should be able to just try again. // dsy: |b| -> |c| dsy, err = dsy.Commit(c) assert.NoError(err) assert.True(dsy.Head().Get(datas.ValueField).Equals(c)) }
// Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Error(t, err, "An error was expected") { // assert.Equal(t, err, expectedError) // } // // Returns whether the assertion was successful (true) or not (false). func Error(t TestingT, err error, msgAndArgs ...interface{}) { if !assert.Error(t, err, msgAndArgs...) { t.FailNow() } }