github.com/jbronn/packer@v0.1.6-0.20140120165540-8a1364dbd817/packer/rpc/builder_test.go (about)

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