amp_test.go

package amp

import (
  "errors"
  // "fmt"
  "io"
  // "io/ioutil"
  "net"
  "net/rpc"
  "testing"
)

type Args struct {
  A, B int
}

type Reply struct {
  C int
}

type Arith int

func (t *Arith) Add(args *Args, reply *Reply) error {
  reply.C = args.A + args.B
  return nil
}

func (t *Arith) Mul(args *Args, reply *Reply) error {
  reply.C = args.A * args.B
  return nil
}

func (t *Arith) Div(args *Args, reply *Reply) error {
  if args.B == 0 {
    return errors.New("divide by zero")
  }
  reply.C = args.A / args.B
  return nil
}

func (t *Arith) Error(args *Args, reply *Reply) error {
  panic("ERROR")
}

func init() {
  rpc.RegisterName("AMP", new(Arith))
}

func TestServerNoParams(t *testing.T) {
  cli, srv := net.Pipe()
  defer cli.Close()
  go ServeConn(srv)
  req := Box{"_ask": "123", "_command": "Add"}
  repr, err := req.Serialize()
  if err != nil {
    t.Fatalf("unable to serialize box: %v", err)
  }

  cli.Write(repr)
  _, err = Decode(cli)
  if err != nil {
    t.Fatalf("Decode after no params: %s", err)
  }
}

// func TestServerEmptyMessage(t *testing.T) {
//   cli, srv := net.Pipe()
//   defer cli.Close()
//   go ServeConn(srv)
//   dec := json.NewDecoder(cli)

//   fmt.Fprintf(cli, "{}")
//   var resp ArithAddResp
//   if err := dec.Decode(&resp); err != nil {
//     t.Fatalf("Decode after empty: %s", err)
//   }
//   if resp.Error == nil {
//     t.Fatalf("Expected error, got nil")
//   }
// }

// func TestServer(t *testing.T) {
//   cli, srv := net.Pipe()
//   defer cli.Close()
//   go ServeConn(srv)
//   dec := json.NewDecoder(cli)

//   // Send hand-coded requests to server, parse responses.
//   for i := 0; i < 10; i++ {
//     fmt.Fprintf(cli, `{"method": "Arith.Add", "id": "\u%04d", "params": [{"A": %d, "B": %d}]}`, i, i, i+1)
//     var resp ArithAddResp
//     err := dec.Decode(&resp)
//     if err != nil {
//       t.Fatalf("Decode: %s", err)
//     }
//     if resp.Error != nil {
//       t.Fatalf("resp.Error: %s", resp.Error)
//     }
//     if resp.Id.(string) != string(i) {
//       t.Fatalf("resp: bad id %q want %q", resp.Id.(string), string(i))
//     }
//     if resp.Result.C != 2*i+1 {
//       t.Fatalf("resp: bad result: %d+%d=%d", i, i+1, resp.Result.C)
//     }
//   }
// }

// func TestClient(t *testing.T) {
//   // Assume server is okay (TestServer is above).
//   // Test client against server.
//   cli, srv := net.Pipe()
//   go ServeConn(srv)

//   client := NewClient(cli)
//   defer client.Close()

//   // Synchronous calls
//   args := &Args{7, 8}
//   reply := new(Reply)
//   err := client.Call("Arith.Add", args, reply)
//   if err != nil {
//     t.Errorf("Add: expected no error but got string %q", err.Error())
//   }
//   if reply.C != args.A+args.B {
//     t.Errorf("Add: got %d expected %d", reply.C, args.A+args.B)
//   }

//   args = &Args{7, 8}
//   reply = new(Reply)
//   err = client.Call("Arith.Mul", args, reply)
//   if err != nil {
//     t.Errorf("Mul: expected no error but got string %q", err.Error())
//   }
//   if reply.C != args.A*args.B {
//     t.Errorf("Mul: got %d expected %d", reply.C, args.A*args.B)
//   }

//   // Out of order.
//   args = &Args{7, 8}
//   mulReply := new(Reply)
//   mulCall := client.Go("Arith.Mul", args, mulReply, nil)
//   addReply := new(Reply)
//   addCall := client.Go("Arith.Add", args, addReply, nil)

//   addCall = <-addCall.Done
//   if addCall.Error != nil {
//     t.Errorf("Add: expected no error but got string %q", addCall.Error.Error())
//   }
//   if addReply.C != args.A+args.B {
//     t.Errorf("Add: got %d expected %d", addReply.C, args.A+args.B)
//   }

//   mulCall = <-mulCall.Done
//   if mulCall.Error != nil {
//     t.Errorf("Mul: expected no error but got string %q", mulCall.Error.Error())
//   }
//   if mulReply.C != args.A*args.B {
//     t.Errorf("Mul: got %d expected %d", mulReply.C, args.A*args.B)
//   }

//   // Error test
//   args = &Args{7, 0}
//   reply = new(Reply)
//   err = client.Call("Arith.Div", args, reply)
//   // expect an error: zero divide
//   if err == nil {
//     t.Error("Div: expected error")
//   } else if err.Error() != "divide by zero" {
//     t.Error("Div: expected divide by zero error; got", err)
//   }
// }

// func TestMalformedInput(t *testing.T) {
//   cli, srv := net.Pipe()
//   go cli.Write([]byte(`{id:1}`)) // invalid json
//   ServeConn(srv)                 // must return, not loop
// }

// func TestMalformedOutput(t *testing.T) {
//   cli, srv := net.Pipe()
//   go srv.Write([]byte(`{"id":0,"result":null,"error":null}`))
//   go ioutil.ReadAll(srv)

//   client := NewClient(cli)
//   defer client.Close()

//   args := &Args{7, 8}
//   reply := new(Reply)
//   err := client.Call("Arith.Add", args, reply)
//   if err == nil {
//     t.Error("expected error")
//   }
// }

// func TestUnexpectedError(t *testing.T) {
//   cli, srv := myPipe()
//   go cli.PipeWriter.CloseWithError(errors.New("unexpected error!")) // reader will get this error
//   ServeConn(srv)                                                    // must return, not loop
// }

// Copied from package net.
func myPipe() (*pipe, *pipe) {
  r1, w1 := io.Pipe()
  r2, w2 := io.Pipe()

  return &pipe{r1, w2}, &pipe{r2, w1}
}

type pipe struct {
  *io.PipeReader
  *io.PipeWriter
}

type pipeAddr int

func (pipeAddr) Network() string {
  return "pipe"
}

func (pipeAddr) String() string {
  return "pipe"
}

func (p *pipe) Close() error {
  err := p.PipeReader.Close()
  err1 := p.PipeWriter.Close()
  if err == nil {
    err = err1
  }
  return err
}

func (p *pipe) LocalAddr() net.Addr {
  return pipeAddr(0)
}

func (p *pipe) RemoteAddr() net.Addr {
  return pipeAddr(0)
}

func (p *pipe) SetTimeout(nsec int64) error {
  return errors.New("net.Pipe does not support timeouts")
}

func (p *pipe) SetReadTimeout(nsec int64) error {
  return errors.New("net.Pipe does not support timeouts")
}

func (p *pipe) SetWriteTimeout(nsec int64) error {
  return errors.New("net.Pipe does not support timeouts")
}