func TestMapStaticFile(t *testing.T) {
codecService := codecsservices.NewWebCodecService()
h := NewHttpHandler(codecService)
h.MapStaticFile("/static-file", "/location/of/static-file")
assert.Equal(t, 1, len(h.HandlersPipe()))
staticHandler := h.HandlersPipe()[0].(*PathMatchHandler)
if assert.Equal(t, 1, len(staticHandler.HttpMethods)) {
assert.Equal(t, goweb_http.MethodGet, staticHandler.HttpMethods[0])
}
var ctx context.Context
var willHandle bool
ctx = context_test.MakeTestContextWithPath("/static-file")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("static-file")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("static-file/")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("static-file/something-else")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.False(t, willHandle, "Static handler NOT should handle")
}
func TestUnMarshal_ObjxMap(t *testing.T) {
obj1 := objx.MSI("name", "Mat", "age", 30, "language", "en")
obj2 := objx.MSI("obj", obj1)
obj3 := objx.MSI("another_obj", obj2)
csvCodec := new(CsvCodec)
bytes, _ := csvCodec.Marshal(obj3, nil)
log.Printf("bytes = %s", string(bytes))
// unmarshal it back
var obj interface{}
csvCodec.Unmarshal(bytes, &obj)
if objmap, ok := obj.(map[string]interface{}); ok {
if objmap2, ok := objmap["another_obj"].(map[string]interface{}); ok {
if objmap3, ok := objmap2["obj"].(map[string]interface{}); ok {
assert.Equal(t, "Mat", objmap3["name"])
assert.Equal(t, 30, objmap3["age"])
assert.Equal(t, "en", objmap3["language"])
} else {
assert.True(t, false, "another_obj.obj should be msi")
}
} else {
assert.True(t, false, "another_obj should be msi")
}
} else {
assert.True(t, false, "obj should be msi")
}
}
func assertPathMatchHandler(t *testing.T, handler *PathMatchHandler, path, method string, message string) bool {
if assert.NotNil(t, handler) {
ctx := context_test.MakeTestContextWithDetails(path, method)
willHandle, _ := handler.WillHandle(ctx)
if assert.True(t, willHandle, fmt.Sprintf("This handler is expected to handle it: %s", message)) {
// make sure the method is in the list
methodFound := false
for _, methodInList := range handler.HttpMethods {
if methodInList == method {
methodFound = true
break
}
}
return assert.True(t, methodFound, "Method (%s) should be in the method list (%s)", method, handler.HttpMethods)
}
}
return false
}
func TestUnMarshal_ComplexMap(t *testing.T) {
obj1 := map[string]interface{}{"name": "Mat", "age": 30, "language": "en"}
obj2 := map[string]interface{}{"obj": obj1}
obj3 := map[string]interface{}{"another_obj": obj2}
csvCodec := new(CsvCodec)
bytes, _ := csvCodec.Marshal(obj3, nil)
// unmarshal it back
var obj interface{}
csvCodec.Unmarshal(bytes, &obj)
if objmap, ok := obj.(map[string]interface{}); ok {
if objmap2, ok := objmap["another_obj"].(map[string]interface{}); ok {
if objmap3, ok := objmap2["obj"].(map[string]interface{}); ok {
assert.Equal(t, "Mat", objmap3["name"])
assert.Equal(t, 30, objmap3["age"])
assert.Equal(t, "en", objmap3["language"])
} else {
assert.True(t, false, "another_obj.obj should be msi")
}
} else {
assert.True(t, false, "another_obj should be msi")
}
} else {
assert.True(t, false, "obj should be msi")
}
}
func TestPathMatchHandler(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
var called bool = false
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
called = true
return nil
}))
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := h.WillHandle(ctx1)
assert.True(t, will)
h.Handle(ctx1)
assert.True(t, called, "Method should be called")
assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).ObjxMap().Get("id").Data())
ctx2 := context_test.MakeTestContextWithPath("/collection")
will, _ = h.WillHandle(ctx2)
assert.False(t, will)
assert.Nil(t, ctx2.Data().Get(context.DataKeyPathParameters).Data())
h.BreakCurrentPipeline = true
shouldStop, handleErr := h.Handle(ctx2)
assert.Nil(t, handleErr)
assert.True(t, shouldStop)
assert.True(t, called, "Handler func should get called")
}
func TestAcceptEntry_Specificity(t *testing.T) {
greater := &AcceptEntry{
Quality: 1.0,
specificityCount: 2,
}
lesser := &AcceptEntry{
Quality: 1.0,
specificityCount: 1,
}
assert.True(t, greater.CompareTo(lesser) > 0, "At equal quality, higher specificity should come out greater")
assert.True(t, lesser.CompareTo(greater) < 0, "Comparing in opposite direction should provide opposite result")
}
func TestAcceptEntry_Quality(t *testing.T) {
greater := &AcceptEntry{
Quality: 0.8,
specificityCount: 0,
}
lesser := &AcceptEntry{
Quality: 0.3,
specificityCount: 10,
}
assert.True(t, greater.CompareTo(lesser) > 0, "Higher quality should come out greater")
assert.True(t, lesser.CompareTo(greater) < 0, "Comparing in opposite direction should provide opposite result")
}
func Test_Mock_AssertNumberOfCalls(t *testing.T) {
var mockedService *TestExampleImplementation = new(TestExampleImplementation)
mockedService.Mock.On("Test_Mock_AssertNumberOfCalls", 1, 2, 3).Return(5, 6, 7)
mockedService.Mock.Called(1, 2, 3)
assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 1))
mockedService.Mock.Called(1, 2, 3)
assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 2))
}
func TestMapStatic(t *testing.T) {
codecService := codecsservices.NewWebCodecService()
h := NewHttpHandler(codecService)
h.MapStatic("/static", "/location/of/static")
assert.Equal(t, 1, len(h.HandlersPipe()))
staticHandler := h.HandlersPipe()[0].(*PathMatchHandler)
if assert.Equal(t, 1, len(staticHandler.HttpMethods)) {
assert.Equal(t, goweb_http.MethodGet, staticHandler.HttpMethods[0])
}
var ctx context.Context
var willHandle bool
ctx = context_test.MakeTestContextWithPath("/static/some/deep/file.dat")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("/static/../static/some/deep/file.dat")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("/static/some/../file.dat")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("/static/../file.dat")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.False(t, willHandle, "Static handler should not handle")
ctx = context_test.MakeTestContextWithPath("/static")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("/static/")
willHandle, _ = staticHandler.WillHandle(ctx)
assert.True(t, willHandle, "Static handler should handle")
ctx = context_test.MakeTestContextWithPath("/static/doc.go")
willHandle, _ = staticHandler.WillHandle(ctx)
_, staticHandleErr := staticHandler.Handle(ctx)
if assert.NoError(t, staticHandleErr) {
}
}
func TestSimpleExample(t *testing.T) {
// build a map from a JSON object
o := MustFromJSON(`{"name":"Mat","foods":["indian","chinese"], "location":{"county":"hobbiton","city":"the shire"}}`)
// Map can be used as a straight map[string]interface{}
assert.Equal(t, o["name"], "Mat")
// Get an Value object
v := o.Get("name")
assert.Equal(t, v, &Value{data: "Mat"})
// Test the contained value
assert.False(t, v.IsInt())
assert.False(t, v.IsBool())
assert.True(t, v.IsStr())
// Get the contained value
assert.Equal(t, v.Str(), "Mat")
// Get a default value if the contained value is not of the expected type or does not exist
assert.Equal(t, 1, v.Int(1))
// Get a value by using array notation
assert.Equal(t, "indian", o.Get("foods[0]").Data())
// Set a value by using array notation
o.Set("foods[0]", "italian")
assert.Equal(t, "italian", o.Get("foods[0]").Str())
// Get a value by using dot notation
assert.Equal(t, "hobbiton", o.Get("location.county").Str())
}
func Test_Arguments_Assert(t *testing.T) {
var args Arguments = []interface{}{"string", 123, true}
assert.True(t, args.Assert(t, "string", 123, true))
}
// AssertCalled asserts that the method was called.
func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool {
if !assert.True(t, m.methodWasCalled(methodName, arguments), fmt.Sprintf("The \"%s\" method should have been called with %d argument(s), but was not.", methodName, len(arguments))) {
t.Logf("%s", m.ExpectedCalls)
return false
}
return true
}
func Test_Mock_AssertCalled_WithArguments_With_Repeatability(t *testing.T) {
var mockedService *TestExampleImplementation = new(TestExampleImplementation)
mockedService.Mock.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Once()
mockedService.Mock.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4).Return(5, 6, 7).Once()
mockedService.Mock.Called(1, 2, 3)
mockedService.Mock.Called(2, 3, 4)
tt := new(testing.T)
assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3))
assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4))
assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 3, 4, 5))
}
func TestPathMatchHandler_BreakCurrentPipeline(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
return nil
}))
h.BreakCurrentPipeline = true
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
breakCurrentPipeline, _ := h.Handle(ctx1)
assert.True(t, breakCurrentPipeline)
h = NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
return nil
}))
h.BreakCurrentPipeline = false
ctx1 = context_test.MakeTestContextWithPath("/collection/123/name")
breakCurrentPipeline, _ = h.Handle(ctx1)
assert.False(t, breakCurrentPipeline)
}
func Test_Arguments_Is(t *testing.T) {
var args Arguments = []interface{}{"string", 123, true}
assert.True(t, args.Is("string", 123, true))
assert.False(t, args.Is("wrong", 456, false))
}
func TestNewPathMatchHandler(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
var called bool = false
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
called = true
return nil
}))
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := h.WillHandle(ctx1)
assert.True(t, will)
h.Handle(ctx1)
assert.True(t, called, "Method should be called")
assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).ObjxMap().Get("id").Data())
}
func TestHas(t *testing.T) {
m := New(TestMap)
assert.True(t, m.Has("name"))
assert.True(t, m.Has("address.state"))
assert.True(t, m.Has("numbers[4]"))
assert.False(t, m.Has("address.state.nope"))
assert.False(t, m.Has("address.nope"))
assert.False(t, m.Has("nope"))
assert.False(t, m.Has("numbers[5]"))
m = nil
assert.False(t, m.Has("nothing"))
}
func TestPathPattern_GetPathMatch_Extensions(t *testing.T) {
gp, _ := NewPathPattern("/people/{id}/books/{title}/chapters/{chapter}")
m := gp.GetPathMatch(NewPath("people/123/books/origin.of.species/chapters/2.json"))
assert.True(t, m.Matches)
assert.Equal(t, m.Parameters["id"], "123")
assert.Equal(t, m.Parameters["title"], "origin.of.species")
assert.Equal(t, m.Parameters["chapter"], "2")
gp, _ = NewPathPattern("/places/{ipaddress}/something")
m = gp.GetPathMatch(NewPath("places/10.0.0.1/something"))
assert.True(t, m.Matches)
assert.Equal(t, m.Parameters["ipaddress"], "10.0.0.1")
}
func TestIssue81(t *testing.T) {
p, _ := NewPathPattern("/prefix/static/***")
assert.NotPanics(t, func() {
assert.False(t, p.GetPathMatch(NewPath("/prefix/")).Matches)
})
assert.True(t, p.GetPathMatch(NewPath("/prefix/static")).Matches)
assert.False(t, p.GetPathMatch(NewPath("/static")).Matches)
}
func TestPipe_WillHandle(t *testing.T) {
p := new(Pipe)
handle, _ := p.WillHandle(nil)
assert.True(t, handle, "Pipes always will handle")
}
func TestPathPattern_GetPathMatch_Parameters(t *testing.T) {
gp, _ := NewPathPattern("/people/{id}/books/{title}/chapters/{chapter}")
m := gp.GetPathMatch(NewPath("people/123/books/origin-of-species/chapters/2"))
assert.True(t, m.Matches)
assert.Equal(t, m.Parameters["id"], "123")
assert.Equal(t, m.Parameters["title"], "origin-of-species")
assert.Equal(t, m.Parameters["chapter"], "2")
}
func TestMap_WithSpecificMethod(t *testing.T) {
codecService := codecsservices.NewWebCodecService()
handler := NewHttpHandler(codecService)
called := false
handler.Map("GET", "/people/{id}", func(c context.Context) error {
called = true
return nil
})
assert.Equal(t, 1, len(handler.HandlersPipe()))
ctx := context_test.MakeTestContextWithPath("people/123")
handler.Handlers.Handle(ctx)
assert.True(t, called)
assert.Equal(t, "GET", handler.HandlersPipe()[0].(*PathMatchHandler).HttpMethods[0])
assert.True(t, handler.HandlersPipe()[0].(*PathMatchHandler).BreakCurrentPipeline)
}
func TestWrapCodec_ContentType(t *testing.T) {
codec := new(json.JsonCodec)
testContentType := "application/vnd.stretchr.test+json"
var target interface{} = wrapCodecWithContentType(codec, testContentType)
wrappedCodec, ok := target.(codecs.Codec)
assert.True(t, ok, "A wrapped codec should still be a Codec")
if ok {
assert.Equal(t, testContentType, wrappedCodec.ContentType())
}
}
func Test_Mock_AssertCalled_WithArguments(t *testing.T) {
var mockedService *TestExampleImplementation = new(TestExampleImplementation)
mockedService.Mock.On("Test_Mock_AssertCalled_WithArguments", 1, 2, 3).Return(5, 6, 7)
mockedService.Mock.Called(1, 2, 3)
tt := new(testing.T)
assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 1, 2, 3))
assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 2, 3, 4))
}
func TestMap_CatchAllAssumption(t *testing.T) {
codecService := codecsservices.NewWebCodecService()
handler := NewHttpHandler(codecService)
called := false
handler.Map(func(c context.Context) error {
called = true
return nil
})
assert.Equal(t, 1, len(handler.HandlersPipe()))
ctx := context_test.MakeTestContextWithPath("people/123")
handler.Handlers.Handle(ctx)
assert.True(t, called)
called = false
ctx = context_test.MakeTestContextWithPath("something-else")
handler.Handlers.Handle(ctx)
assert.True(t, called)
}
func Test_Mock_AssertExpectations(t *testing.T) {
var mockedService *TestExampleImplementation = new(TestExampleImplementation)
mockedService.Mock.On("Test_Mock_AssertExpectations", 1, 2, 3).Return(5, 6, 7)
tt := new(testing.T)
assert.False(t, mockedService.AssertExpectations(tt))
// make the call now
mockedService.Mock.Called(1, 2, 3)
// now assert expectations
assert.True(t, mockedService.AssertExpectations(tt))
}
func TestParseContentType_WithParams(t *testing.T) {
contentTypeString := "application/xml; q=0.7; test=hello"
expectedMimeType := "application/xml"
expectedParams := map[string]string{
"q": "0.7",
"test": "hello",
}
contentType, err := ParseContentType(contentTypeString)
assert.NoError(t, err)
assert.Equal(t, expectedMimeType, contentType.MimeType)
for index, value := range expectedParams {
parsedValue, ok := contentType.Parameters[index]
assert.True(t, ok, "All expected values should have been parsed as params")
assert.Equal(t, parsedValue, value)
}
}
func Test_Mock_AssertExpectationsCustomType(t *testing.T) {
var mockedService *TestExampleImplementation = new(TestExampleImplementation)
mockedService.Mock.On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).Return(nil).Once()
tt := new(testing.T)
assert.False(t, mockedService.AssertExpectations(tt))
// make the call now
mockedService.TheExampleMethod3(&ExampleType{})
// now assert expectations
assert.True(t, mockedService.AssertExpectations(tt))
}
func Test_AssertExpectationsForObjects_Helper(t *testing.T) {
var mockedService1 *TestExampleImplementation = new(TestExampleImplementation)
var mockedService2 *TestExampleImplementation = new(TestExampleImplementation)
var mockedService3 *TestExampleImplementation = new(TestExampleImplementation)
mockedService1.Mock.On("Test_AssertExpectationsForObjects_Helper", 1).Return()
mockedService2.Mock.On("Test_AssertExpectationsForObjects_Helper", 2).Return()
mockedService3.Mock.On("Test_AssertExpectationsForObjects_Helper", 3).Return()
mockedService1.Called(1)
mockedService2.Called(2)
mockedService3.Called(3)
assert.True(t, AssertExpectationsForObjects(t, mockedService1.Mock, mockedService2.Mock, mockedService3.Mock))
}
func TestPathPattern_GetPathMatchCatchallPrefixSuffix_Matches(t *testing.T) {
// ***/literal/***
gp, _ := NewPathPattern("/***/books/***")
assert.True(t, gp.GetPathMatch(NewPath("/people/123/books")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("/PEOPLE/123/BOOKS")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("/People/123/Books")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("people/123/books")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("people/123/books/")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("/people/123/books/lotr/chapters/one")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("/people/123/books/hello")).Matches)
assert.True(t, gp.GetPathMatch(NewPath("/books")).Matches)
assert.False(t, gp.GetPathMatch(NewPath("people/123/[books]/")).Matches)
assert.False(t, gp.GetPathMatch(NewPath("people/123/{books}/")).Matches)
assert.False(t, gp.GetPathMatch(NewPath("/people/123/novels/lotr/chapters/one")).Matches)
assert.False(t, gp.GetPathMatch(NewPath("/people/123/novels/hello")).Matches)
}