blob: 9fc142b7c81d9d3a85b72711e18a97b8ee668beb [file] [log] [blame] [edit]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package test
import (
"io"
"testing"
"time"
"v.io/v23"
"v.io/v23/context"
"v.io/v23/rpc"
"v.io/x/ref/test"
)
type simple struct {
done <-chan struct{}
}
func (s *simple) Sleep(*context.T, rpc.ServerCall) error {
select {
case <-s.done:
case <-time.After(time.Hour):
}
return nil
}
func (s *simple) Ping(_ *context.T, _ rpc.ServerCall) (string, error) {
return "pong", nil
}
func (s *simple) Echo(_ *context.T, _ rpc.ServerCall, arg string) (string, error) {
return arg, nil
}
func (s *simple) Source(_ *context.T, call rpc.StreamServerCall, start int) error {
i := start
backoff := 25 * time.Millisecond
for {
select {
case <-s.done:
return nil
case <-time.After(backoff):
call.Send(i)
i++
}
backoff *= 2
}
}
func (s *simple) Sink(_ *context.T, call rpc.StreamServerCall) (int, error) {
i := 0
for {
if err := call.Recv(&i); err != nil {
if err == io.EOF {
return i, nil
}
return 0, err
}
}
}
func (s *simple) Inc(_ *context.T, call rpc.StreamServerCall, inc int) (int, error) {
i := 0
for {
if err := call.Recv(&i); err != nil {
if err == io.EOF {
return i, nil
}
return 0, err
}
call.Send(i + inc)
}
}
func startSimpleServer(t *testing.T, ctx *context.T) (string, func()) {
done := make(chan struct{})
ctx, server, err := v23.WithNewServer(ctx, "", &simple{done}, nil)
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
return server.Status().Endpoints[0].Name(), func() { close(done) }
}
func TestSimpleRPC(t *testing.T) {
ctx, shutdown := test.V23InitWithMounttable()
defer shutdown()
name, fn := startSimpleServer(t, ctx)
defer fn()
client := v23.GetClient(ctx)
call, err := client.StartCall(ctx, name, "Ping", nil)
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
response := ""
if err := call.Finish(&response); err != nil {
t.Fatalf("unexpected error: %s", err)
}
if got, want := response, "pong"; got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestSimpleStreaming(t *testing.T) {
ctx, shutdown := test.V23InitWithMounttable()
defer shutdown()
name, fn := startSimpleServer(t, ctx)
defer fn()
inc := 1
call, err := v23.GetClient(ctx).StartCall(ctx, name, "Inc", []interface{}{inc})
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
want := 10
for i := 0; i <= want; i++ {
if err := call.Send(i); err != nil {
t.Fatalf("unexpected error: %s", err)
}
got := -1
if err = call.Recv(&got); err != nil {
t.Fatalf("unexpected error: %s", err)
}
if want := i + inc; got != want {
t.Fatalf("got %d, want %d", got, want)
}
}
call.CloseSend()
final := -1
err = call.Finish(&final)
if err != nil {
t.Errorf("unexpected error: %#v", err)
}
if got := final; got != want {
t.Fatalf("got %d, want %d", got, want)
}
}