func TestJsonSerializer(t *testing.T) {
node := n.Node{Host: "localhost", Port: 13123}
msg := m.Hello{
Id: m.NewId(),
From: node,
Details: map[string]interface{}{"foo": "bar"},
}
s := &JsonSerializer{}
data, err := s.Serialize(msg)
if err != nil {
t.Error("Unexpected error serializing ", err)
}
var rcvMessage m.Message
rcvMessage, err = s.Deserialize(data)
if err != nil {
t.Error("Unexpected error deserializing ", err)
}
switch rcvMessage.(type) {
case *m.Hello:
h := rcvMessage.(*m.Hello)
if msg.Id != h.Id {
t.Error("Message Ids don't match", msg.Id, h.Id)
}
if "bar" != h.Details["foo"] {
t.Error("Message Payload don't match")
}
default:
t.Error("Wrong type")
}
}
func (p *Peer) SayHello() (u message.ID, err error) {
msg := message.Hello{
Id: message.NewId(),
From: p.from,
Details: map[string]interface{}{"foo": "bar"},
}
p.Commit(msg)
return msg.Id, err
}
func TestBasicNopPeerTest(t *testing.T) {
ch := make(chan message.Message, 10)
fkc := &NopPeer{"localhost", 9000, ch}
msg := message.Hello{
Id: message.NewId(),
From: node.Node{"localhost", 9000},
Details: map[string]interface{}{"foo": "bar"},
}
fkc.Send(msg)
rcvMsg := <-fkc.ReceiveChan()
if !reflect.DeepEqual(msg, rcvMsg) {
t.Errorf("Expected %s, got %s", msg, rcvMsg)
}
}
func TestBasicLinksOnServerClient(t *testing.T) {
go startTestServer()
time.Sleep(time.Second * 1)
conn, err := net.Dial("tcp", "localhost:8002")
if err != nil {
fmt.Println("dial error:", err)
return
}
defer conn.Close()
linkA := NewJSONSocketLink(conn)
id := message.NewId()
msg := message.Hello{
Id: id,
Details: map[string]interface{}{"foo": "bar"},
}
linkA.Send(msg)
msgA, err := linkA.Receive()
if err != nil {
t.Error("Error on received Hello Message ", err)
}
fmt.Println("Message is ", msgA, "err", err)
if msgA.MessageType() != 0 {
t.Error("Error on received Hello Message ", msgA)
}
newMsg := msgA.(*message.Hello)
if newMsg.Id != id {
t.Error("Error on received Hello Message ", msgA)
}
if newMsg.Details["foo"].(string) != "bar" {
t.Error("Error on received Hello Message ", msgA)
}
}
func (ph *testLinkHandler) handleLink(p *SocketLink, from node.Node) {
defer func() {
ph.outChan <- ph.lastMsg
}()
for {
select {
case <-ph.exit:
return
default:
msg, err := p.Receive()
if err != nil {
fmt.Println("Error Receiving on server, err ", err)
return
}
if msg.MessageType() != 0 {
fmt.Println("Error on received Hello Message ", msg)
return
}
newMsg := msg.(*message.Hello)
if newMsg.Details["foo"].(string) == "PONG" {
newMsg.Details["foo"] = "PING"
} else {
newMsg.Details["foo"] = "PONG"
}
newMsg.Id = message.NewId()
newMsg.From = from
err = p.Send(newMsg)
if err != nil {
//fmt.Println("Error sending: ", err)
return
}
ph.lastMsg = newMsg
}
}
}
func TestLinksOnPipes(t *testing.T) {
a, b := net.Pipe()
linkA := NewJSONSocketLink(a)
linkB := NewJSONSocketLink(b)
defer linkA.Conn.Close()
defer linkB.Conn.Close()
tp := &testLinkHandler{
outChan: make(chan *message.Hello, 1),
exit: make(chan bool, 1),
}
go tp.handleLink(linkA, node.Node{Host: "localhost", Port: 5000})
go tp.handleLink(linkB, node.Node{Host: "localhost", Port: 5005})
id := message.NewId()
//first message
msg := message.Hello{
Id: id,
From: node.Node{Host: "localhost", Port: 5000},
Details: map[string]interface{}{"foo": "bar"},
}
linkA.Send(msg)
time.Sleep(time.Millisecond * 300)
tp.exit <- true
lastMessage := <-tp.outChan
fmt.Println("lastMessage A", lastMessage)
if lastMessage.Id == id {
t.Error("LastMessage must be bigger ")
}
if lastMessage.Details["foo"].(string) != "PING" && lastMessage.Details["foo"].(string) != "PONG" {
t.Error("LastMessageDetails has not changed! ")
}
}
func TestPeerMessagingUnderPipes(t *testing.T) {
a, b := net.Pipe()
c1 := &Peer{
Link: NewJSONSocketLink(a),
from: node.Node{Host: "foo"},
to: node.Node{Host: "bar"},
dataChan: make(chan message.Message, 10),
sendChan: make(chan message.Message, 10),
messageChan: make(chan message.Message, 10),
exitChan: make(chan bool),
doneChan: make(chan bool),
rstWatchChan: make(chan bool, 100),
mode: "pipe",
}
go c1.Run()
c1Mirror := &Peer{
Link: NewJSONSocketLink(b),
from: node.Node{Host: "bar"},
to: node.Node{Host: "foo"},
dataChan: make(chan message.Message, 10),
sendChan: make(chan message.Message, 10),
messageChan: make(chan message.Message, 10),
exitChan: make(chan bool),
doneChan: make(chan bool),
rstWatchChan: make(chan bool, 100),
mode: "pipe",
}
go c1Mirror.Run()
var wg sync.WaitGroup
resChan := make(chan message.Message, 2)
doneChan := make(chan struct{})
wg.Add(1)
go func() {
for {
select {
case r := <-c1.ReceiveChan():
msg := r.(*message.Hello)
msg.Id = message.NewId()
resChan <- msg
case r := <-c1Mirror.ReceiveChan():
msg := r.(*message.Hello)
msg.Id = message.NewId()
resChan <- msg
case <-c1.ResetWatcherChan():
continue
case <-c1Mirror.ResetWatcherChan():
continue
case <-doneChan:
close(resChan)
wg.Done()
return
}
}
return
}()
c1.SayHello()
c1Mirror.SayHello()
time.Sleep(time.Millisecond * 100)
close(doneChan)
wg.Wait()
r := make([]message.Message, 0)
for k := range resChan {
r = append(r, k)
}
if len(r) != 2 {
t.Error("Unexpected response size", r)
t.Fail()
}
h1, ok := r[0].(*message.Hello)
if !ok {
t.Error("Error Casting to Hello ", h1)
}
h2, ok := r[1].(*message.Hello)
if !ok {
t.Error("Error Casting to Hello ", h2)
}
c1.Exit()
c1Mirror.Exit()
}
func TestBasicFlowOnCoordinator(t *testing.T) {
c := Start()
c.Send(&message.Hello{Id: message.NewId()})
c.Send(&message.Welcome{Id: message.NewId()})
c.Send(&message.Abort{Id: message.NewId()})
}
func TestRouterAccept(t *testing.T) {
r := &defaultRouter{
handlers: make(map[message.MsgType]handler.Handler),
exit: make(chan bool, 1),
requestListener: watch.NewRequestListener(),
}
hello := &message.Hello{}
ping := &message.Ping{}
r.RegisterHandler(hello.MessageType(), fakeHelloHandler)
r.RegisterHandler(ping.MessageType(), fakePingHandler)
nodeA := node.Node{Host: "A", Port: 1}
nodeB := node.Node{Host: "B", Port: 2}
a, b := net.Pipe()
c1 := peer.NewAcceptor(a, nodeA)
c1.Identify(nodeB)
go c1.Run()
c1Mirror := peer.NewAcceptor(b, nodeB)
c1Mirror.Identify(nodeA)
go c1Mirror.Run()
go func() {
for {
select {
case <-c1.ResetWatcherChan():
continue
case <-c1Mirror.ResetWatcherChan():
continue
}
}
}()
r.Accept(c1)
c1Mirror.SayHello()
result := <-c1Mirror.ReceiveChan()
if result.MessageType() != 1 {
t.Error("Unexpected response type, expected 1 got", result.MessageType())
}
id := message.NewId()
msg := message.Ping{
Id: id,
From: nodeA,
To: nodeB,
}
c1Mirror.Send(msg)
result = <-c1Mirror.ReceiveChan()
if result.MessageType() != 4 {
t.Error("Unexpected response type, expected 1 got", result.MessageType())
}
pong := result.(*message.Pong)
if pong.Id != id {
t.Error("Unexpected result Id")
}
if pong.From != nodeB {
t.Error("Unexpected result From")
}
r.Exit()
c1.Exit()
c1Mirror.Exit()
}