http_test.go

package rpc25519

import (
	"strings"

	cv "github.com/glycerine/goconvey/convey"
	"testing"
)

// Same as 006 in cli_test.go but sets cfg.HTTPConnectRequired = true
func Test024_RoundTrip_Using_NetRPC_API_TCP_and_http_CONNECT(t *testing.T) {

	cv.Convey("http CONNECT + tcp hijack => basic TCP with rpc25519 using the net/rpc API: register a callback on the server, and have the client call it.", t, func() {

		for i := 0; i < 2; i++ {

			cfg := NewConfig()
			cfg.HTTPConnectRequired = true

			switch i {
			case 0:
				cfg.TCPonly_no_TLS = true
			case 1:
				cfg.TCPonly_no_TLS = false
			}

			path := GetPrivateCertificateAuthDir() + sep + "psk.binary"
			panicOn(setupPSK(path))
			cfg.PreSharedKeyPath = path
			//cfg.ReadTimeout = 2 * time.Second
			//cfg.WriteTimeout = 2 * time.Second

			cfg.ServerAddr = "127.0.0.1:0"
			srv := NewServer("srv_test024", cfg)

			serverAddr, err := srv.Start()
			panicOn(err)
			defer srv.Close()

			vv("server Start() returned serverAddr = '%v'", serverAddr)

			// net/rpc API on server
			srv.Register(new(Arith))
			srv.Register(new(Embed))
			srv.RegisterName("net.rpc.Arith", new(Arith))
			srv.Register(BuiltinTypes{})

			cfg.ClientDialToHostPort = serverAddr.String()
			client, err := NewClient("test024", cfg)
			panicOn(err)
			err = client.Start()
			panicOn(err)
			defer client.Close()

			// net/rpc API on client, ported from attic/net_server_test.go
			var args *Args
			_ = args
			var reply *Reply

			// Synchronous calls
			args = &Args{7, 8}
			reply = new(Reply)
			err = client.Call("Arith.Add", args, reply, nil)
			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: expected %d got %d", reply.C, args.A+args.B)
			}
			vv("good 024, got back reply '%#v'", reply)

			// Methods exported from unexported embedded structs
			args = &Args{7, 0}
			reply = new(Reply)
			err = client.Call("Embed.Exported", args, reply, nil)
			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: expected %d got %d", reply.C, args.A+args.B)
			}

			// Nonexistent method
			args = &Args{7, 0}
			reply = new(Reply)
			err = client.Call("Arith.BadOperation", args, reply, nil)
			// expect an error
			if err == nil {
				t.Error("BadOperation: expected error")
			} else if !strings.HasPrefix(err.Error(), "rpc: can't find method ") {
				t.Errorf("BadOperation: expected can't find method error; got %q", err)
			}
			vv("good 024: past nonexistent method")

			// Unknown service
			args = &Args{7, 8}
			reply = new(Reply)
			err = client.Call("Arith.Unknown", args, reply, nil)
			if err == nil {
				t.Error("expected error calling unknown service")
			} else if !strings.Contains(err.Error(), "method") {
				t.Error("expected error about method; got", err)
			}
			vv("good 024: past unknown service")

			// Out of order.
			args = &Args{7, 8}
			mulReply := new(Reply)
			mulCall := client.Go("Arith.Mul", args, mulReply, nil, nil)
			addReply := new(Reply)
			addCall := client.Go("Arith.Add", args, addReply, nil, 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: expected %d got %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: expected %d got %d", mulReply.C, args.A*args.B)
			}
			vv("good 024: past out of order")

			// Error test
			args = &Args{7, 0}
			reply = new(Reply)
			err = client.Call("Arith.Div", args, reply, nil)
			// 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)
			}
			vv("good 024: past error test")

			args = &Args{7, 8}
			reply = new(Reply)
			err = client.Call("Arith.Mul", args, reply, nil)
			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: expected %d got %d", reply.C, args.A*args.B)
			}
			vv("good 024: past Arith.Mul test")

			// ServiceName contain "." character
			args = &Args{7, 8}
			reply = new(Reply)
			err = client.Call("net.rpc.Arith.Add", args, reply, nil)
			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: expected %d got %d", reply.C, args.A+args.B)
			}
			vv("good 024: past ServiceName with dot . test")

			cv.So(true, cv.ShouldBeTrue)
		}
	})
}