tools/serial/server_test.go - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can
 // found in the LICENSE file.

 package serial

 import (
 	"bytes"
 	"context"
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
 	"io"
 	"net"
 	"os"
 	"path/filepath"
 	"syscall"
 	"testing"
 )

 const (
 	writeBufferSize = 1024
 )

 // Creates a "serial connection" in terms of its host- and device-side
 // descriptors. They are implemented with synchronous in-memory pipes, so
 // associated writes and reads will be one-to-one (with the usual caveats of
 // io.Pipe).
 func serialAndDevice() (io.ReadWriteCloser, io.ReadWriteCloser) {
 	rs, wd := io.Pipe()
 	rd, ws := io.Pipe()
 	serial := &joinedPipeEnds{rs, ws}
 	device := &joinedPipeEnds{rd, wd}
 	return serial, device
 }

 func socketPath() string {
 	// We randomly construct a socket path that is highly improbable to collide with anything.
 	randBytes := make([]byte, 16)
 	rand.Read(randBytes)
 	return filepath.Join(os.TempDir(), "serial"+hex.EncodeToString(randBytes)+".sock")
 }

 func TestServer(t *testing.T) {
 	serial, device := serialAndDevice()

 	defer func() {
 		serial.Close()
 		device.Close()
 	}()

 	s := NewServer(serial, ServerOptions{
 		WriteBufferSize: writeBufferSize,
 	})

 	path := socketPath()
 	addr := &net.UnixAddr{Name: path, Net: "unix"}
 	l, err := net.ListenUnix("unix", addr)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer l.Close()

 	ctx, cancel := context.WithCancel(context.Background())

 	// Run the server in the main routine and the tests in a separate routine so
 	// that we can actually test the shutdown functionality of the server (by the
 	// termination of this program).
 	go testServer(t, s, device, path, nil, cancel)
 	if err := s.Run(ctx, l); err != nil {
 		t.Fatalf("server encountered shutdown error: %v", err)
 	}
 }

 func TestServerWithAuxOutput(t *testing.T) {
 	serial, device := serialAndDevice()
 	auxOutputReader, auxOutput := io.Pipe()

 	defer func() {
 		serial.Close()
 		device.Close()
 		auxOutput.Close()
 		auxOutputReader.Close()
 	}()

 	s := NewServer(serial, ServerOptions{
 		WriteBufferSize: writeBufferSize,
 		AuxiliaryOutput: auxOutput,
 	})

 	path := socketPath()
 	addr := &net.UnixAddr{Name: path, Net: "unix"}
 	l, err := net.ListenUnix("unix", addr)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer l.Close()

 	ctx, cancel := context.WithCancel(context.Background())

 	// Run the server in the main routine and the tests in a separate routine so
 	// that we can actually test the shutdown functionality of the server (by the
 	// termination of this program).
 	go testServer(t, s, device, path, auxOutputReader, cancel)
 	if err := s.Run(ctx, l); err != nil {
 		t.Fatalf("server encountered shutdown error: %v", err)
 	}
 }

 func testServer(t *testing.T, s *Server, device io.ReadWriter, socketPath string, auxOutputReader io.Reader, cancel context.CancelFunc) {
 	t.Helper()

 	var socket net.Conn
 	for {
 		var err error
 		socket, err = net.Dial("unix", socketPath)
 		if err != nil {
 			t.Logf("failed to open client socket connection: %v", err)
 			continue
 		}
 		break
 	}
 	defer socket.Close()

 	//
 	// X -> device -> serial -> socket -> Y
 	//
 	// Make the device "write to serial" on its side. This should unblock the
 	// reads being made from serial on the host side and forwarded to the
 	// socket. Reads from the socket are in turn blocking, so we should be able
 	// to reliably verify that X == Y.
 	//
 	t.Run("writes to serial can be read from socket", func(t *testing.T) {
 		input := []byte("written to serial!")
 		if _, err := device.Write(input); err != nil {
 			t.Fatalf("failed to write to device: %v", err)
 		}

 		if auxOutputReader != nil {
 			// Read first from the auxiliary output, as the teeing logic from serial should
 			// block until we read from the other end of the pipe.
 			readAndCheckBytes(t, auxOutputReader, "teed output", input)
 		}
 		readAndCheckBytes(t, socket, "socket", input)
 	})

 	//
 	// X -> socket -> serial -> device -> Y
 	//
 	// Have the device "read from serial" on its side after bytes have been
 	// written to the socket. This read will block until the bytes have been
 	// forwarded from the server socket to serial on the host side, which will
 	// in turn unblock the initial read. This is all to say that this case too
 	// should be a reliable verification that X == Y.
 	//
 	t.Run("writes to socket can be read from serial", func(t *testing.T) {
 		input := []byte("written to the socket!")
 		if _, err := socket.Write(input); err != nil {
 			t.Fatalf("failed to write to socket: %v", err)
 		}
 		readAndCheckBytes(t, device, "serial", input)
 	})

 	t.Run("server shuts down", func(t *testing.T) {
 		cancel()
 	})
 }

 func readAndCheckBytes(t *testing.T, r io.Reader, readerName string, expected []byte) {
 	t.Helper()
 	p := make([]byte, writeBufferSize)
 	n, err := r.Read(p)
 	if (err != nil && err != io.EOF) || n == 0 {
 		t.Fatalf("failed to read from %s: %v", readerName, err)
 	}
 	actual := p[0:n]
 	if bytes.Compare(expected, actual) != 0 {
 		t.Errorf("unexpected bytes read from %s:\nexpected: %q\nactual: %q", readerName, expected, actual)
 	}
 }

 type joinedPipeEnds struct {
 	r *io.PipeReader
 	w *io.PipeWriter
 }

 func (pe *joinedPipeEnds) Read(p []byte) (int, error) {
 	return pe.r.Read(p)
 }

 func (pe *joinedPipeEnds) Write(p []byte) (int, error) {
 	return pe.w.Write(p)
 }

 func (pe *joinedPipeEnds) Close() error {
 	if err := pe.r.Close(); err != nil {
 		pe.w.Close()
 		return err
 	}
 	return pe.w.Close()
 }

 func TestErrorSanitization(t *testing.T) {
 	compare := func(actual, expected error) {
 		if actual != expected {
 			t.Errorf("expected: %v\nactual: %v", expected, actual)
 		}
 	}

 	t.Run("context canceled -> nil", func(t *testing.T) {
 		ctx, cancel := context.WithCancel(context.Background())
 		cancel()
 		compare(sanitizeError(ctx, fmt.Errorf("real error")), nil)
 	})

 	testCases := []struct {
 		name     string
 		input    error
 		expected error
 	}{
 		{
 			name:     "nil -> nil",
 			input:    nil,
 			expected: nil,
 		},
 		{
 			name: "EPIPE read -> nil",
 			input: &net.OpError{
 				Err: &os.SyscallError{
 					Syscall: "read",
 					Err:     syscall.EPIPE,
 				},
 			},
 			expected: nil,
 		},
 		{
 			name: "EPIPE write -> nil",
 			input: &net.OpError{
 				Err: &os.SyscallError{
 					Syscall: "write",
 					Err:     syscall.EPIPE,
 				},
 			},
 			expected: nil,
 		},
 		{
 			name: "ECONNRESET read -> nil",
 			input: &net.OpError{
 				Err: &os.SyscallError{
 					Syscall: "read",
 					Err:     syscall.ECONNRESET,
 				},
 			},
 			expected: nil,
 		},
 		{
 			name: "ECONNRESET write -> nil",
 			input: &net.OpError{
 				Err: &os.SyscallError{
 					Syscall: "write",
 					Err:     syscall.ECONNRESET,
 				},
 			},
 			expected: nil,
 		},
 		{
 			name:     "other error -> itself",
 			input:    os.ErrNotExist,
 			expected: os.ErrNotExist,
 		},
 	}

 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			actual := sanitizeError(context.Background(), tc.input)
 			compare(actual, tc.expected)
 		})
 	}
 }
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can
	// found in the LICENSE file.

	package serial

	import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"io"
	"net"
	"os"
	"path/filepath"
	"syscall"
	"testing"
	)

	const (
	writeBufferSize = 1024
	)

	// Creates a "serial connection" in terms of its host- and device-side
	// descriptors. They are implemented with synchronous in-memory pipes, so
	// associated writes and reads will be one-to-one (with the usual caveats of
	// io.Pipe).
	func serialAndDevice() (io.ReadWriteCloser, io.ReadWriteCloser) {
	rs, wd := io.Pipe()
	rd, ws := io.Pipe()
	serial := &joinedPipeEnds{rs, ws}
	device := &joinedPipeEnds{rd, wd}
	return serial, device
	}

	func socketPath() string {
	// We randomly construct a socket path that is highly improbable to collide with anything.
	randBytes := make([]byte, 16)
	rand.Read(randBytes)
	return filepath.Join(os.TempDir(), "serial"+hex.EncodeToString(randBytes)+".sock")
	}

	func TestServer(t *testing.T) {
	serial, device := serialAndDevice()

	defer func() {
	serial.Close()
	device.Close()
	}()

	s := NewServer(serial, ServerOptions{
	WriteBufferSize: writeBufferSize,
	})

	path := socketPath()
	addr := &net.UnixAddr{Name: path, Net: "unix"}
	l, err := net.ListenUnix("unix", addr)
	if err != nil {
	t.Fatal(err)
	}
	defer l.Close()

	ctx, cancel := context.WithCancel(context.Background())

	// Run the server in the main routine and the tests in a separate routine so
	// that we can actually test the shutdown functionality of the server (by the
	// termination of this program).
	go testServer(t, s, device, path, nil, cancel)
	if err := s.Run(ctx, l); err != nil {
	t.Fatalf("server encountered shutdown error: %v", err)
	}
	}

	func TestServerWithAuxOutput(t *testing.T) {
	serial, device := serialAndDevice()
	auxOutputReader, auxOutput := io.Pipe()

	defer func() {
	serial.Close()
	device.Close()
	auxOutput.Close()
	auxOutputReader.Close()
	}()

	s := NewServer(serial, ServerOptions{
	WriteBufferSize: writeBufferSize,
	AuxiliaryOutput: auxOutput,
	})

	path := socketPath()
	addr := &net.UnixAddr{Name: path, Net: "unix"}
	l, err := net.ListenUnix("unix", addr)
	if err != nil {
	t.Fatal(err)
	}
	defer l.Close()

	ctx, cancel := context.WithCancel(context.Background())

	// Run the server in the main routine and the tests in a separate routine so
	// that we can actually test the shutdown functionality of the server (by the
	// termination of this program).
	go testServer(t, s, device, path, auxOutputReader, cancel)
	if err := s.Run(ctx, l); err != nil {
	t.Fatalf("server encountered shutdown error: %v", err)
	}
	}

	func testServer(t testing.T, s Server, device io.ReadWriter, socketPath string, auxOutputReader io.Reader, cancel context.CancelFunc) {
	t.Helper()

	var socket net.Conn
	for {
	var err error
	socket, err = net.Dial("unix", socketPath)
	if err != nil {
	t.Logf("failed to open client socket connection: %v", err)
	continue
	}
	break
	}
	defer socket.Close()

	//
	// X -> device -> serial -> socket -> Y
	//
	// Make the device "write to serial" on its side. This should unblock the
	// reads being made from serial on the host side and forwarded to the
	// socket. Reads from the socket are in turn blocking, so we should be able
	// to reliably verify that X == Y.
	//
	t.Run("writes to serial can be read from socket", func(t *testing.T) {
	input := []byte("written to serial!")
	if _, err := device.Write(input); err != nil {
	t.Fatalf("failed to write to device: %v", err)
	}

	if auxOutputReader != nil {
	// Read first from the auxiliary output, as the teeing logic from serial should
	// block until we read from the other end of the pipe.
	readAndCheckBytes(t, auxOutputReader, "teed output", input)
	}
	readAndCheckBytes(t, socket, "socket", input)
	})

	//
	// X -> socket -> serial -> device -> Y
	//
	// Have the device "read from serial" on its side after bytes have been
	// written to the socket. This read will block until the bytes have been
	// forwarded from the server socket to serial on the host side, which will
	// in turn unblock the initial read. This is all to say that this case too
	// should be a reliable verification that X == Y.
	//
	t.Run("writes to socket can be read from serial", func(t *testing.T) {
	input := []byte("written to the socket!")
	if _, err := socket.Write(input); err != nil {
	t.Fatalf("failed to write to socket: %v", err)
	}
	readAndCheckBytes(t, device, "serial", input)
	})

	t.Run("server shuts down", func(t *testing.T) {
	cancel()
	})
	}

	func readAndCheckBytes(t *testing.T, r io.Reader, readerName string, expected []byte) {
	t.Helper()
	p := make([]byte, writeBufferSize)
	n, err := r.Read(p)
	if (err != nil && err != io.EOF) \|\| n == 0 {
	t.Fatalf("failed to read from %s: %v", readerName, err)
	}
	actual := p[0:n]
	if bytes.Compare(expected, actual) != 0 {
	t.Errorf("unexpected bytes read from %s:\nexpected: %q\nactual: %q", readerName, expected, actual)
	}
	}

	type joinedPipeEnds struct {
	r *io.PipeReader
	w *io.PipeWriter
	}

	func (pe *joinedPipeEnds) Read(p []byte) (int, error) {
	return pe.r.Read(p)
	}

	func (pe *joinedPipeEnds) Write(p []byte) (int, error) {
	return pe.w.Write(p)
	}

	func (pe *joinedPipeEnds) Close() error {
	if err := pe.r.Close(); err != nil {
	pe.w.Close()
	return err
	}
	return pe.w.Close()
	}

	func TestErrorSanitization(t *testing.T) {
	compare := func(actual, expected error) {
	if actual != expected {
	t.Errorf("expected: %v\nactual: %v", expected, actual)
	}
	}

	t.Run("context canceled -> nil", func(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	compare(sanitizeError(ctx, fmt.Errorf("real error")), nil)
	})

	testCases := []struct {
	name string
	input error
	expected error
	}{
	{
	name: "nil -> nil",
	input: nil,
	expected: nil,
	},
	{
	name: "EPIPE read -> nil",
	input: &net.OpError{
	Err: &os.SyscallError{
	Syscall: "read",
	Err: syscall.EPIPE,
	},
	},
	expected: nil,
	},
	{
	name: "EPIPE write -> nil",
	input: &net.OpError{
	Err: &os.SyscallError{
	Syscall: "write",
	Err: syscall.EPIPE,
	},
	},
	expected: nil,
	},
	{
	name: "ECONNRESET read -> nil",
	input: &net.OpError{
	Err: &os.SyscallError{
	Syscall: "read",
	Err: syscall.ECONNRESET,
	},
	},
	expected: nil,
	},
	{
	name: "ECONNRESET write -> nil",
	input: &net.OpError{
	Err: &os.SyscallError{
	Syscall: "write",
	Err: syscall.ECONNRESET,
	},
	},
	expected: nil,
	},
	{
	name: "other error -> itself",
	input: os.ErrNotExist,
	expected: os.ErrNotExist,
	},
	}

	for _, tc := range testCases {
	t.Run(tc.name, func(t *testing.T) {
	actual := sanitizeError(context.Background(), tc.input)
	compare(actual, tc.expected)
	})
	}
	}