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

     1  package rpc
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/hashicorp/packer/packer"
     8  )
     9  
    10  var testBuilderArtifact = &packer.MockArtifact{}
    11  
    12  func TestBuilderPrepare(t *testing.T) {
    13  	b := new(packer.MockBuilder)
    14  	client, server := testClientServer(t)
    15  	defer client.Close()
    16  	defer server.Close()
    17  	server.RegisterBuilder(b)
    18  	bClient := client.Builder()
    19  
    20  	// Test Prepare
    21  	config := 42
    22  	warnings, err := bClient.Prepare(config)
    23  	if err != nil {
    24  		t.Fatalf("bad: %s", err)
    25  	}
    26  	if len(warnings) > 0 {
    27  		t.Fatalf("bad: %#v", warnings)
    28  	}
    29  
    30  	if !b.PrepareCalled {
    31  		t.Fatal("should be called")
    32  	}
    33  
    34  	expected := []interface{}{int64(42)}
    35  	if !reflect.DeepEqual(b.PrepareConfig, expected) {
    36  		t.Fatalf("bad: %#v != %#v", b.PrepareConfig, expected)
    37  	}
    38  }
    39  
    40  func TestBuilderPrepare_Warnings(t *testing.T) {
    41  	b := new(packer.MockBuilder)
    42  	client, server := testClientServer(t)
    43  	defer client.Close()
    44  	defer server.Close()
    45  	server.RegisterBuilder(b)
    46  	bClient := client.Builder()
    47  
    48  	expected := []string{"foo"}
    49  	b.PrepareWarnings = expected
    50  
    51  	// Test Prepare
    52  	warnings, err := bClient.Prepare(nil)
    53  	if err != nil {
    54  		t.Fatalf("bad: %s", err)
    55  	}
    56  	if !reflect.DeepEqual(warnings, expected) {
    57  		t.Fatalf("bad: %#v", warnings)
    58  	}
    59  }
    60  
    61  func TestBuilderRun(t *testing.T) {
    62  	b := new(packer.MockBuilder)
    63  	client, server := testClientServer(t)
    64  	defer client.Close()
    65  	defer server.Close()
    66  	server.RegisterBuilder(b)
    67  	bClient := client.Builder()
    68  
    69  	// Test Run
    70  	cache := new(testCache)
    71  	hook := &packer.MockHook{}
    72  	ui := &testUi{}
    73  	artifact, err := bClient.Run(ui, hook, cache)
    74  	if err != nil {
    75  		t.Fatalf("err: %s", err)
    76  	}
    77  
    78  	if !b.RunCalled {
    79  		t.Fatal("run should be called")
    80  	}
    81  
    82  	if artifact.Id() != testBuilderArtifact.Id() {
    83  		t.Fatalf("bad: %s", artifact.Id())
    84  	}
    85  }
    86  
    87  func TestBuilderRun_nilResult(t *testing.T) {
    88  	b := new(packer.MockBuilder)
    89  	b.RunNilResult = true
    90  
    91  	client, server := testClientServer(t)
    92  	defer client.Close()
    93  	defer server.Close()
    94  	server.RegisterBuilder(b)
    95  	bClient := client.Builder()
    96  
    97  	cache := new(testCache)
    98  	hook := &packer.MockHook{}
    99  	ui := &testUi{}
   100  	artifact, err := bClient.Run(ui, hook, cache)
   101  	if artifact != nil {
   102  		t.Fatalf("bad: %#v", artifact)
   103  	}
   104  	if err != nil {
   105  		t.Fatalf("bad: %#v", err)
   106  	}
   107  }
   108  
   109  func TestBuilderRun_ErrResult(t *testing.T) {
   110  	b := new(packer.MockBuilder)
   111  	client, server := testClientServer(t)
   112  	defer client.Close()
   113  	defer server.Close()
   114  	server.RegisterBuilder(b)
   115  	bClient := client.Builder()
   116  
   117  	b.RunErrResult = true
   118  
   119  	cache := new(testCache)
   120  	hook := &packer.MockHook{}
   121  	ui := &testUi{}
   122  	artifact, err := bClient.Run(ui, hook, cache)
   123  	if artifact != nil {
   124  		t.Fatalf("bad: %#v", artifact)
   125  	}
   126  	if err == nil {
   127  		t.Fatal("should have error")
   128  	}
   129  }
   130  
   131  func TestBuilderCancel(t *testing.T) {
   132  	b := new(packer.MockBuilder)
   133  	client, server := testClientServer(t)
   134  	defer client.Close()
   135  	defer server.Close()
   136  	server.RegisterBuilder(b)
   137  	bClient := client.Builder()
   138  
   139  	bClient.Cancel()
   140  	if !b.CancelCalled {
   141  		t.Fatal("cancel should be called")
   142  	}
   143  }
   144  
   145  func TestBuilder_ImplementsBuilder(t *testing.T) {
   146  	var _ packer.Builder = new(builder)
   147  }