github.com/zignig/go-ipfs@v0.0.0-20141111235910-c9e5fdf55a52/net/service/service_test.go (about)

     1  package service
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"time"
     7  
     8  	msg "github.com/jbenet/go-ipfs/net/message"
     9  	peer "github.com/jbenet/go-ipfs/peer"
    10  
    11  	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
    12  	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
    13  )
    14  
    15  // ReverseHandler reverses all Data it receives and sends it back.
    16  type ReverseHandler struct{}
    17  
    18  func (t *ReverseHandler) HandleMessage(ctx context.Context, m msg.NetMessage) msg.NetMessage {
    19  
    20  	d := m.Data()
    21  	for i, j := 0, len(d)-1; i < j; i, j = i+1, j-1 {
    22  		d[i], d[j] = d[j], d[i]
    23  	}
    24  
    25  	return msg.New(m.Peer(), d)
    26  }
    27  
    28  func newPeer(t *testing.T, id string) peer.Peer {
    29  	mh, err := mh.FromHexString(id)
    30  	if err != nil {
    31  		t.Error(err)
    32  		return nil
    33  	}
    34  
    35  	return peer.WithID(peer.ID(mh))
    36  }
    37  
    38  func TestServiceHandler(t *testing.T) {
    39  	ctx := context.Background()
    40  	h := &ReverseHandler{}
    41  	s := NewService(ctx, h)
    42  	peer1 := newPeer(t, "11140beec7b5ea3f0fdbc95d0dd47f3c5bc275aaaaaa")
    43  
    44  	d, err := wrapData([]byte("beep"), nil)
    45  	if err != nil {
    46  		t.Error(err)
    47  	}
    48  
    49  	m1 := msg.New(peer1, d)
    50  	s.GetPipe().Incoming <- m1
    51  	m2 := <-s.GetPipe().Outgoing
    52  
    53  	d, rid, err := unwrapData(m2.Data())
    54  	if err != nil {
    55  		t.Error(err)
    56  	}
    57  
    58  	if rid != nil {
    59  		t.Error("RequestID should be nil")
    60  	}
    61  
    62  	if !bytes.Equal(d, []byte("peeb")) {
    63  		t.Errorf("service handler data incorrect: %v != %v", d, "oof")
    64  	}
    65  }
    66  
    67  func TestServiceRequest(t *testing.T) {
    68  	ctx := context.Background()
    69  	s1 := NewService(ctx, &ReverseHandler{})
    70  	s2 := NewService(ctx, &ReverseHandler{})
    71  
    72  	peer1 := newPeer(t, "11140beec7b5ea3f0fdbc95d0dd47f3c5bc275aaaaaa")
    73  
    74  	// patch services together
    75  	go func() {
    76  		for {
    77  			select {
    78  			case m := <-s1.GetPipe().Outgoing:
    79  				s2.GetPipe().Incoming <- m
    80  			case m := <-s2.GetPipe().Outgoing:
    81  				s1.GetPipe().Incoming <- m
    82  			case <-ctx.Done():
    83  				return
    84  			}
    85  		}
    86  	}()
    87  
    88  	m1 := msg.New(peer1, []byte("beep"))
    89  	m2, err := s1.SendRequest(ctx, m1)
    90  	if err != nil {
    91  		t.Error(err)
    92  	}
    93  
    94  	if !bytes.Equal(m2.Data(), []byte("peeb")) {
    95  		t.Errorf("service handler data incorrect: %v != %v", m2.Data(), "oof")
    96  	}
    97  }
    98  
    99  func TestServiceRequestTimeout(t *testing.T) {
   100  	ctx, _ := context.WithTimeout(context.Background(), time.Millisecond)
   101  	s1 := NewService(ctx, &ReverseHandler{})
   102  	s2 := NewService(ctx, &ReverseHandler{})
   103  	peer1 := newPeer(t, "11140beec7b5ea3f0fdbc95d0dd47f3c5bc275aaaaaa")
   104  
   105  	// patch services together
   106  	go func() {
   107  		for {
   108  			<-time.After(time.Millisecond)
   109  			select {
   110  			case m := <-s1.GetPipe().Outgoing:
   111  				s2.GetPipe().Incoming <- m
   112  			case m := <-s2.GetPipe().Outgoing:
   113  				s1.GetPipe().Incoming <- m
   114  			case <-ctx.Done():
   115  				return
   116  			}
   117  		}
   118  	}()
   119  
   120  	m1 := msg.New(peer1, []byte("beep"))
   121  	m2, err := s1.SendRequest(ctx, m1)
   122  	if err == nil || m2 != nil {
   123  		t.Error("should've timed out")
   124  	}
   125  }
   126  
   127  func TestServiceClose(t *testing.T) {
   128  	ctx := context.Background()
   129  	s1 := NewService(ctx, &ReverseHandler{})
   130  	s2 := NewService(ctx, &ReverseHandler{})
   131  
   132  	peer1 := newPeer(t, "11140beec7b5ea3f0fdbc95d0dd47f3c5bc275aaaaaa")
   133  
   134  	// patch services together
   135  	go func() {
   136  		for {
   137  			select {
   138  			case m := <-s1.GetPipe().Outgoing:
   139  				s2.GetPipe().Incoming <- m
   140  			case m := <-s2.GetPipe().Outgoing:
   141  				s1.GetPipe().Incoming <- m
   142  			case <-ctx.Done():
   143  				return
   144  			}
   145  		}
   146  	}()
   147  
   148  	m1 := msg.New(peer1, []byte("beep"))
   149  	m2, err := s1.SendRequest(ctx, m1)
   150  	if err != nil {
   151  		t.Error(err)
   152  	}
   153  
   154  	if !bytes.Equal(m2.Data(), []byte("peeb")) {
   155  		t.Errorf("service handler data incorrect: %v != %v", m2.Data(), "oof")
   156  	}
   157  
   158  	s1.Close()
   159  	s2.Close()
   160  
   161  	<-s1.Closed()
   162  	<-s2.Closed()
   163  }