github.com/HashDataInc/packer@v1.3.2/packer/rpc/communicator_test.go (about)

     1  package rpc
     2  
     3  import (
     4  	"bufio"
     5  	"io"
     6  	"reflect"
     7  	"testing"
     8  
     9  	"github.com/hashicorp/packer/packer"
    10  )
    11  
    12  func TestCommunicatorRPC(t *testing.T) {
    13  	// Create the interface to test
    14  	c := new(packer.MockCommunicator)
    15  
    16  	// Start the server
    17  	client, server := testClientServer(t)
    18  	defer client.Close()
    19  	defer server.Close()
    20  	server.RegisterCommunicator(c)
    21  	remote := client.Communicator()
    22  
    23  	// The remote command we'll use
    24  	stdin_r, stdin_w := io.Pipe()
    25  	stdout_r, stdout_w := io.Pipe()
    26  	stderr_r, stderr_w := io.Pipe()
    27  
    28  	var cmd packer.RemoteCmd
    29  	cmd.Command = "foo"
    30  	cmd.Stdin = stdin_r
    31  	cmd.Stdout = stdout_w
    32  	cmd.Stderr = stderr_w
    33  
    34  	// Send some data on stdout and stderr from the mock
    35  	c.StartStdout = "outfoo\n"
    36  	c.StartStderr = "errfoo\n"
    37  	c.StartExitStatus = 42
    38  
    39  	// Test Start
    40  	err := remote.Start(&cmd)
    41  	if err != nil {
    42  		t.Fatalf("err: %s", err)
    43  	}
    44  
    45  	// Test that we can read from stdout
    46  	bufOut := bufio.NewReader(stdout_r)
    47  	data, err := bufOut.ReadString('\n')
    48  	if err != nil {
    49  		t.Fatalf("err: %s", err)
    50  	}
    51  
    52  	if data != "outfoo\n" {
    53  		t.Fatalf("bad data: %s", data)
    54  	}
    55  
    56  	// Test that we can read from stderr
    57  	bufErr := bufio.NewReader(stderr_r)
    58  	data, err = bufErr.ReadString('\n')
    59  	if err != nil {
    60  		t.Fatalf("err: %s", err)
    61  	}
    62  
    63  	if data != "errfoo\n" {
    64  		t.Fatalf("bad data: %s", data)
    65  	}
    66  
    67  	// Test that we can write to stdin
    68  	stdin_w.Write([]byte("info\n"))
    69  	stdin_w.Close()
    70  	cmd.Wait()
    71  	if c.StartStdin != "info\n" {
    72  		t.Fatalf("bad data: %s", c.StartStdin)
    73  	}
    74  
    75  	// Test that we can get the exit status properly
    76  	if cmd.ExitStatus != 42 {
    77  		t.Fatalf("bad exit: %d", cmd.ExitStatus)
    78  	}
    79  
    80  	// Test that we can upload things
    81  	uploadR, uploadW := io.Pipe()
    82  	go func() {
    83  		defer uploadW.Close()
    84  		uploadW.Write([]byte("uploadfoo\n"))
    85  	}()
    86  	err = remote.Upload("foo", uploadR, nil)
    87  	if err != nil {
    88  		t.Fatalf("err: %s", err)
    89  	}
    90  
    91  	if !c.UploadCalled {
    92  		t.Fatal("should have uploaded")
    93  	}
    94  
    95  	if c.UploadPath != "foo" {
    96  		t.Fatalf("path: %s", c.UploadPath)
    97  	}
    98  
    99  	if c.UploadData != "uploadfoo\n" {
   100  		t.Fatalf("bad: %s", c.UploadData)
   101  	}
   102  
   103  	// Test that we can upload directories
   104  	dirDst := "foo"
   105  	dirSrc := "bar"
   106  	dirExcl := []string{"foo"}
   107  	err = remote.UploadDir(dirDst, dirSrc, dirExcl)
   108  	if err != nil {
   109  		t.Fatalf("err: %s", err)
   110  	}
   111  
   112  	if c.UploadDirDst != dirDst {
   113  		t.Fatalf("bad: %s", c.UploadDirDst)
   114  	}
   115  
   116  	if c.UploadDirSrc != dirSrc {
   117  		t.Fatalf("bad: %s", c.UploadDirSrc)
   118  	}
   119  
   120  	if !reflect.DeepEqual(c.UploadDirExclude, dirExcl) {
   121  		t.Fatalf("bad: %#v", c.UploadDirExclude)
   122  	}
   123  
   124  	// Test that we can download things
   125  	downloadR, downloadW := io.Pipe()
   126  	downloadDone := make(chan bool)
   127  	var downloadData string
   128  	var downloadErr error
   129  
   130  	go func() {
   131  		bufDownR := bufio.NewReader(downloadR)
   132  		downloadData, downloadErr = bufDownR.ReadString('\n')
   133  		downloadDone <- true
   134  	}()
   135  
   136  	c.DownloadData = "download\n"
   137  	err = remote.Download("bar", downloadW)
   138  	if err != nil {
   139  		t.Fatalf("err: %s", err)
   140  	}
   141  
   142  	if !c.DownloadCalled {
   143  		t.Fatal("download should be called")
   144  	}
   145  
   146  	if c.DownloadPath != "bar" {
   147  		t.Fatalf("bad: %s", c.DownloadPath)
   148  	}
   149  
   150  	<-downloadDone
   151  	if downloadErr != nil {
   152  		t.Fatalf("err: %s", downloadErr)
   153  	}
   154  
   155  	if downloadData != "download\n" {
   156  		t.Fatalf("bad: %s", downloadData)
   157  	}
   158  }
   159  
   160  func TestCommunicator_ImplementsCommunicator(t *testing.T) {
   161  	var raw interface{}
   162  	raw = Communicator(nil)
   163  	if _, ok := raw.(packer.Communicator); !ok {
   164  		t.Fatal("should be a Communicator")
   165  	}
   166  }