Function TestETLSBug

rpc/mux/server_test.go:222–270

(t *testing.T)

}

func TestETLSBug(t *testing.T) {
	defer utils.RemoveAll(PubKeyStorePath + "*")
	log.SetLevel(log.FatalLevel)
	addr := "127.0.0.1:0"
	masterKey := []byte("abc")
	server, err := NewServerWithService(ServiceMap{"Test": NewTestService()})
	if err != nil {
		log.Fatal(err)
	}

	_, _ = route.NewDHTService(PubKeyStorePath, new(consistent.KMSStorage), true)
	_ = server.InitRPCServer(addr, "../keys/test.key", masterKey)
	go server.Serve()
	defer server.Stop()

	// This should not block listener
	var rawConn net.Conn
	rawConn, err = net.Dial("tcp", server.Listener.Addr().String())
	if err != nil {
		log.Fatal(err)
	}
	defer func() { _ = rawConn.Close() }()

	publicKey, err := kms.GetLocalPublicKey()
	nonce := asymmetric.GetPubKeyNonce(publicKey, 10, 100*time.Millisecond, nil)
	serverNodeID := proto.NodeID(nonce.Hash.String())
	_ = kms.SetPublicKey(serverNodeID, nonce.Nonce, publicKey)
	kms.SetLocalNodeIDNonce(nonce.Hash.CloneBytes(), &nonce.Nonce)
	_ = route.SetNodeAddrCache(&proto.RawNodeID{Hash: nonce.Hash}, server.Listener.Addr().String())

	cryptoConn, err := rpc.Dial(serverNodeID)
	if err != nil {
		log.Fatal(err)
	}
	stream, err := NewOneOffMuxConn(cryptoConn)
	if err != nil {
		log.Fatal(err)
	}
	_ = stream.SetDeadline(time.Now().Add(3 * time.Second))
	client := rpc.NewClient(stream)
	defer func() { _ = client.Close() }()

	repSimple := new(int32)
	err = client.Call("Test.IncCounterSimpleArgs", 10, repSimple)
	if err != nil {
		log.Fatal(err)
	}
	CheckNum(*repSimple, 10, t)
}

func TestEncPingFindNeighbor(t *testing.T) {
	utils.RemoveAll(PubKeyStorePath + "*")