func TestChannelServerClose(t *testing.T) {
sm, cm := newServerAndClient()
wg := &sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
c, err := sm.Accept()
assert.NoError(t, err)
if err != nil {
return
}
b := make([]byte, 4)
_, err = c.Read(b)
assert.NoError(t, err)
err = c.Close()
assert.NoError(t, err)
}()
c, err := cm.Dial()
assert.NoError(t, err)
_, err = c.Write([]byte("PING"))
assert.NoError(t, err)
b := make([]byte, 4)
_, err = c.Read(b)
assert.Equal(t, io.EOF, err)
wg.Wait()
}
func TestBinaryEncodeComplex(t *testing.T) {
b, err := Marshal(s1v)
assert.NoError(t, err)
assert.Equal(t, svb, b)
s := &s1{}
err = Unmarshal(svb, s)
assert.NoError(t, err)
assert.Equal(t, s1v, s)
}
func TestParseTCPAddrList(t *testing.T) {
p := parserMixin{}
v := p.TCPList()
err := p.value.Set("127.0.0.1:1234")
assert.NoError(t, err)
err = p.value.Set("127.0.0.1:1235")
assert.NoError(t, err)
assert.Equal(t, "127.0.0.1:1234,127.0.0.1:1235", (*tcpAddrsValue)(v).String())
}
func TestParseTCPAddr(t *testing.T) {
p := parserMixin{}
v := p.TCP()
err := p.value.Set("127.0.0.1:1234")
assert.NoError(t, err)
expected, err := net.ResolveTCPAddr("tcp", "127.0.0.1:1234")
assert.NoError(t, err)
assert.Equal(t, *expected, **v)
}
func TestRequiredFlag(t *testing.T) {
fg := newFlagGroup()
fg.Flag("a", "").Required().Bool()
assert.NoError(t, fg.init())
tokens := Tokenize([]string{"--a"})
tokens, err := fg.parse(tokens, false)
assert.NoError(t, err)
tokens = Tokenize([]string{})
tokens, err = fg.parse(tokens, false)
assert.Error(t, err)
}
func TestTooManyArgs(t *testing.T) {
a := New("test", "test")
a.Arg("a", "").String()
assert.NoError(t, a.init())
toks := Tokenize([]string{"a", "b"})
toks, _, err := a.parse(toks)
assert.NoError(t, err)
assert.Equal(t, tokens{&token{TokenArg, "b"}}, toks)
_, err = a.Parse([]string{"a", "b"})
assert.Error(t, err)
}
func TestTooManyArgs(t *testing.T) {
a := New("test", "test")
a.Arg("a", "").String()
assert.NoError(t, a.init())
context := Tokenize([]string{"a", "b"})
_, err := a.parse(context)
assert.NoError(t, err)
assert.Equal(t, Tokens{&Token{TokenArg, "b"}}, context.Tokens)
_, err = a.Parse([]string{"a", "b"})
assert.Error(t, err)
}
func TestParseMetricBytes(t *testing.T) {
n, err := ParseMetricBytes("0B")
assert.NoError(t, err)
assert.Equal(t, 0, n)
n, err = ParseMetricBytes("1KB1B")
assert.NoError(t, err)
assert.Equal(t, 1001, n)
n, err = ParseMetricBytes("1MB1KB25B")
assert.NoError(t, err)
assert.Equal(t, 1001025, n)
n, err = ParseMetricBytes("1.5MB")
assert.NoError(t, err)
assert.Equal(t, 1500000, n)
}
func TestParseBase2Bytes(t *testing.T) {
n, err := ParseBase2Bytes("0B")
assert.NoError(t, err)
assert.Equal(t, 0, n)
n, err = ParseBase2Bytes("1KB")
assert.NoError(t, err)
assert.Equal(t, 1024, n)
n, err = ParseBase2Bytes("1MB1KB25B")
assert.NoError(t, err)
assert.Equal(t, 1049625, n)
n, err = ParseBase2Bytes("1.5MB")
assert.NoError(t, err)
assert.Equal(t, 1572864, n)
}
func TestCommander(t *testing.T) {
c := New("test", "test")
ping := c.Command("ping", "Ping an IP address.")
pingTTL := ping.Flag("ttl", "TTL for ICMP packets").Short('t').Default("5s").Duration()
selected, err := c.Parse([]string{"ping"})
assert.NoError(t, err)
assert.Equal(t, "ping", selected)
assert.Equal(t, 5*time.Second, *pingTTL)
selected, err = c.Parse([]string{"ping", "--ttl=10s"})
assert.NoError(t, err)
assert.Equal(t, "ping", selected)
assert.Equal(t, 10*time.Second, *pingTTL)
}
func TestUnmarshalStringField(t *testing.T) {
mE := MustNewMapping(&everythingComp{})
var s string
err := mE.UnmarshalField("Key", []byte("keyhere"), &s)
assert.NoError(t, err)
assert.Equal(t, s, "keyhere")
}
func TestMarshalUnMarshalTypeAliases(t *testing.T) {
type Foo int64
f := Foo(32)
b, err := Marshal(f)
assert.NoError(t, err)
assert.Equal(t, []byte{0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, b)
}
func TestTopLevelArgWorks(t *testing.T) {
c := New("test", "test")
s := c.Arg("arg", "help").String()
_, err := c.Parse([]string{"foo"})
assert.NoError(t, err)
assert.Equal(t, "foo", *s)
}
func TestUnmarshalIntField(t *testing.T) {
mE := MustNewMapping(&tagsA{})
var i int
err := mE.UnmarshalField("B", []byte{0, 0, 0, 0, 0, 0, 0, 1}, &i)
assert.NoError(t, err)
assert.Equal(t, i, 1)
}
func TestParseURL(t *testing.T) {
p := parserMixin{}
v := p.URL()
p.value.Set("http://w3.org")
u, err := url.Parse("http://w3.org")
assert.NoError(t, err)
assert.Equal(t, *u, **v)
}
func TestInvalidArgsDefaultCanBeOverridden(t *testing.T) {
a := newArgGroup()
a.Arg("a", "").Default("invalid").Bool()
assert.NoError(t, a.init())
tokens := Tokenize([]string{})
_, err := a.parse(tokens)
assert.Error(t, err)
}
func TestInvalidFlagDefaultCanBeOverridden(t *testing.T) {
fg := newFlagGroup()
f := fg.Flag("a", "").Default("invalid")
f.Bool()
assert.NoError(t, fg.init())
tokens := Tokenize([]string{})
_, err := fg.parse(tokens, false)
assert.Error(t, err)
}
func TestParseExistingFile(t *testing.T) {
p := parserMixin{}
v := p.ExistingFile()
err := p.value.Set("/etc/hosts")
assert.NoError(t, err)
assert.Equal(t, "/etc/hosts", *v)
err = p.value.Set("/etc/hostsDEFINITELYMISSING")
assert.Error(t, err)
}
func TestTupleSpaceTake(t *testing.T) {
ts := tuplespace.NewTupleSpace(store.NewMemoryStore())
defer ts.Shutdown()
ts.Send(tuplespace.Tuple{"cmd": "uname -a"}, 0)
ts.Send(tuplespace.Tuple{"cmd": "uptime"}, 0)
_, err := ts.Take(tuplespace.MustMatch(`cmd != nil`), time.Second)
assert.NoError(t, err)
assert.Equal(t, ts.Stats().Tuples, 1)
}
func TestBinaryDecodeToValueErrors(t *testing.T) {
b := []byte{1, 0, 0, 0}
var v uint32
err := Unmarshal(b, v)
assert.Error(t, err)
err = Unmarshal(b, &v)
assert.NoError(t, err)
assert.Equal(t, uint32(1), v)
}
func TestNoBool(t *testing.T) {
fg := newFlagGroup()
f := fg.Flag("b", "").Default("true")
b := f.Bool()
fg.init()
tokens := Tokenize([]string{"--no-b"})
_, err := fg.parse(tokens, false)
assert.NoError(t, err)
assert.False(t, *b)
}
func TestRequiredFlags(t *testing.T) {
c := New("test", "test")
c.Flag("a", "a").String()
c.Flag("b", "b").Required().String()
_, err := c.Parse([]string{"--a=foo"})
assert.Error(t, err)
_, err = c.Parse([]string{"--b=foo"})
assert.NoError(t, err)
}
func BenchmarkClientServer(b *testing.B) {
sm, cm := newServerAndClient()
wg := &sync.WaitGroup{}
wg.Add(1)
// Server
go func() {
buf := make([]byte, 1024)
defer wg.Done()
ch, err := sm.Accept()
assert.NoError(b, err)
if err != nil {
return
}
defer ch.Close()
for i := 0; i < b.N; i++ {
_, err := ch.Write(buf)
assert.NoError(b, err)
if err != nil {
return
}
}
}()
ch, err := cm.Dial()
assert.NoError(b, err)
buf := make([]byte, 1024)
for i := 0; i < b.N; i++ {
n, err := ch.Read(buf)
assert.NoError(b, err)
if err != nil {
b.FailNow()
}
assert.Equal(b, 1024, n)
}
sm.Close()
cm.Close()
wg.Wait()
}
func TestTupleSpaceReadAll(t *testing.T) {
ts := tuplespace.NewTupleSpace(store.NewMemoryStore())
defer ts.Shutdown()
ts.Send(tuplespace.Tuple{"cmd": "uname -a"}, 0)
ts.Send(tuplespace.Tuple{"cmd": "uptime"}, 0)
time.Sleep(time.Millisecond * 100)
tuples, err := ts.ReadAll(tuplespace.MustMatch(`cmd != nil`), time.Second)
assert.NoError(t, err)
assert.Equal(t, tuples, []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}, tuplespace.Tuple{"cmd": "uptime"}})
assert.Equal(t, ts.Stats().Tuples, 2)
}
func TestDispatchCallbackIsCalled(t *testing.T) {
dispatched := false
c := New("test", "")
c.Command("cmd", "").Dispatch(func(*ParseContext) error {
dispatched = true
return nil
})
_, err := c.Parse([]string{"cmd"})
assert.NoError(t, err)
assert.True(t, dispatched)
}
func TestNestedCommandsWithArgs(t *testing.T) {
app := New("app", "")
cmd := app.Command("a", "").Command("b", "")
a := cmd.Arg("a", "").String()
b := cmd.Arg("b", "").String()
context := Tokenize([]string{"a", "b", "c", "d"})
selected, err := app.parse(context)
assert.NoError(t, err)
assert.Equal(t, 0, len(context.Tokens))
assert.Equal(t, "a b", selected)
assert.Equal(t, "c", *a)
assert.Equal(t, "d", *b)
}
func TestArgMultipleRequired(t *testing.T) {
a := newArgGroup()
a.Arg("a", "").Required().String()
a.Arg("b", "").Required().String()
a.init()
_, err := a.parse(Tokenize([]string{}))
assert.Error(t, err)
_, err = a.parse(Tokenize([]string{"A"}))
assert.Error(t, err)
_, err = a.parse(Tokenize([]string{"A", "B"}))
assert.NoError(t, err)
}
func TestMapStatic(t *testing.T) {
codecService := new(codecservices.WebCodecService)
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) {
}
}
// https://github.com/stretchrcom/goweb/issues/20
func TestWriteResponseObject_ContentNegotiation_AcceptHeader(t *testing.T) {
http := new(GowebHTTPResponder)
codecService := new(codecservices.WebCodecService)
API := NewGowebAPIResponder(codecService, http)
ctx := context_test.MakeTestContext()
ctx.HttpRequest().Header.Set("Accept", "application/x-msgpack")
data := map[string]interface{}{"name": "Mat"}
API.WriteResponseObject(ctx, 200, data)
// get the expected output
codec, codecErr := codecService.GetCodec("application/x-msgpack")
if assert.NoError(t, codecErr) {
expectedOutput, marshalErr := codec.Marshal(data, nil)
if assert.NoError(t, marshalErr) {
assert.Equal(t, []byte(context_test.TestResponseWriter.Output), expectedOutput)
}
}
}
func TestTupleSpaceProcessNewEntriesAlwaysRespondsToReaders(t *testing.T) {
rts := tuplespace.NewRawTupleSpace(store.NewMemoryStore())
take := rts.ReadOperation(tuplespace.MustMatch("cmd"), 0, tuplespace.ActionOne|tuplespace.ActionTake)
read := rts.ReadOperation(tuplespace.MustMatch("cmd"), 0, tuplespace.ActionOne)
go func() {
time.Sleep(time.Second * 1)
take.Cancel()
read.Cancel()
}()
tuples := []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}}
expected := []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}}
assert.NoError(t, rts.ProcessNewEntries(tuples, time.Now()))
assert.Equal(t, <-take.Get(), expected)
assert.Equal(t, <-read.Get(), expected)
}
