func TestHandlerCancelsAfterGivenTimeWindow(t *testing.T) { ca := cache.NewCache() h := NewHandler(window, ca) ctx, _ := context.WithCancel(context.Background()) c, s := net.Pipe() returned := make(chan struct{}) go func() { err := h(ctx, s) if err != io.ErrClosedPipe { t.Errorf("expected ErrClosedPipe but got %s", err) } close(returned) }() data := string(parser.Send) + "name\n5\nhel" c.Write([]byte(data)) select { case <-returned: case <-time.After(2 * window): t.Error("expected parser to timeout") } }
func TestHandlerCanHandleSubscribeAndReceive(t *testing.T) { ca := cache.NewCache() h := NewHandler(window, ca) ctx, cancel := context.WithCancel(context.Background()) c, s := net.Pipe() returned := make(chan struct{}) go func() { err := h(ctx, s) if err != nil { t.Error(err) } close(returned) }() data := string(parser.Subscribe) + "name\n" c.Write([]byte(data)) // Make sure handler got the subscribe command. var got cache.Sub select { case got = <-ca.Subscribe: case <-time.After(time.Second): t.Error("send not received in time") } if got.Channel != "name" { t.Error("expected channel name") } // Reply on the receive channel. got.Receive <- writer.Response{writer.Send, "name", []byte("hello")} // Check if client received the message. expected := string(writer.Send) + "name\n5\nhello" buf := make([]byte, len(expected)) _, err := c.Read(buf) if err != nil { t.Error(err) } if string(buf) != expected { t.Errorf("got %s but expected %s", string(buf), expected) } cancel() select { case <-returned: case <-time.After(time.Second): t.Error("handler did not return on context cancel") } }
func TestHandlerCanHandleSendCommands(t *testing.T) { ca := cache.NewCache() h := NewHandler(window, ca) ctx, cancel := context.WithCancel(context.Background()) c, s := net.Pipe() returned := make(chan struct{}) go func() { err := h(ctx, s) if err != nil { t.Error(err) } close(returned) }() data := string(parser.Send) + "name\n5\nhello" c.Write([]byte(data)) // Make sure handler got the command. var got cache.Message select { case got = <-ca.Send: case <-time.After(time.Second): t.Error("send not received in time") } if got.Channel != "name" { t.Error("expected channel name") } else if string(got.Message) != "hello" { t.Error("expected message hello") } cancel() select { case <-returned: case <-time.After(time.Second): t.Error("handler did not return on context cancel") } }
func TestHandlerCanHandleSubUnsub(t *testing.T) { ca := cache.NewCache() h := NewHandler(window, ca) ctx, cancel := context.WithCancel(context.Background()) c, s := net.Pipe() returned := make(chan struct{}) go func() { err := h(ctx, s) if err != nil { t.Error(err) } close(returned) }() // This should only trigger one subscribe and one unsubscribe. firstUnsub := string(parser.Unsubscribe) + "name\n" thenSub := string(parser.Subscribe) + "name\n" thenSubAgain := string(parser.Subscribe) + "name\n" thenUnsub := string(parser.Unsubscribe) + "name\n" c.Write([]byte(firstUnsub + thenSub + thenSubAgain + thenUnsub)) var sub cache.Sub var unsub cache.Unsub // Check for the subscribe. select { case sub = <-ca.Subscribe: case <-time.After(time.Second): t.Error("send not received in time") } if sub.Channel != "name" { t.Error("expected channel name") } // Check for the unsubscribe. select { case unsub = <-ca.Unsubscribe: case <-time.After(time.Second): t.Error("send not received in time") } if unsub.Channel != "name" { t.Error("expected channel name") } // Make sure there are no extra messages. select { case <-ca.Subscribe: t.Error("only expected one subscribe message") case <-ca.Unsubscribe: t.Error("only expected one unsubscribe message") default: } cancel() select { case <-returned: case <-time.After(time.Second): t.Error("handler did not return on context cancel") } }