github.com/kikitux/packer@v0.10.1-0.20160322154024-6237df566f9f/packer/provisioner_test.go (about)

     1  package packer
     2  
     3  import (
     4  	"sync"
     5  	"testing"
     6  	"time"
     7  )
     8  
     9  func TestProvisionHook_Impl(t *testing.T) {
    10  	var raw interface{}
    11  	raw = &ProvisionHook{}
    12  	if _, ok := raw.(Hook); !ok {
    13  		t.Fatalf("must be a Hook")
    14  	}
    15  }
    16  
    17  func TestProvisionHook(t *testing.T) {
    18  	pA := &MockProvisioner{}
    19  	pB := &MockProvisioner{}
    20  
    21  	ui := testUi()
    22  	var comm Communicator = new(MockCommunicator)
    23  	var data interface{} = nil
    24  
    25  	hook := &ProvisionHook{
    26  		Provisioners: []Provisioner{pA, pB},
    27  	}
    28  
    29  	hook.Run("foo", ui, comm, data)
    30  
    31  	if !pA.ProvCalled {
    32  		t.Error("provision should be called on pA")
    33  	}
    34  
    35  	if !pB.ProvCalled {
    36  		t.Error("provision should be called on pB")
    37  	}
    38  }
    39  
    40  func TestProvisionHook_nilComm(t *testing.T) {
    41  	pA := &MockProvisioner{}
    42  	pB := &MockProvisioner{}
    43  
    44  	ui := testUi()
    45  	var comm Communicator = nil
    46  	var data interface{} = nil
    47  
    48  	hook := &ProvisionHook{
    49  		Provisioners: []Provisioner{pA, pB},
    50  	}
    51  
    52  	err := hook.Run("foo", ui, comm, data)
    53  	if err == nil {
    54  		t.Fatal("should error")
    55  	}
    56  }
    57  
    58  func TestProvisionHook_cancel(t *testing.T) {
    59  	var lock sync.Mutex
    60  	order := make([]string, 0, 2)
    61  
    62  	p := &MockProvisioner{
    63  		ProvFunc: func() error {
    64  			time.Sleep(50 * time.Millisecond)
    65  
    66  			lock.Lock()
    67  			defer lock.Unlock()
    68  			order = append(order, "prov")
    69  
    70  			return nil
    71  		},
    72  	}
    73  
    74  	hook := &ProvisionHook{
    75  		Provisioners: []Provisioner{p},
    76  	}
    77  
    78  	finished := make(chan struct{})
    79  	go func() {
    80  		hook.Run("foo", nil, new(MockCommunicator), nil)
    81  		close(finished)
    82  	}()
    83  
    84  	// Cancel it while it is running
    85  	time.Sleep(10 * time.Millisecond)
    86  	hook.Cancel()
    87  	lock.Lock()
    88  	order = append(order, "cancel")
    89  	lock.Unlock()
    90  
    91  	// Wait
    92  	<-finished
    93  
    94  	// Verify order
    95  	if len(order) != 2 || order[0] != "cancel" || order[1] != "prov" {
    96  		t.Fatalf("bad: %#v", order)
    97  	}
    98  }
    99  
   100  // TODO(mitchellh): Test that they're run in the proper order
   101  
   102  func TestPausedProvisioner_impl(t *testing.T) {
   103  	var _ Provisioner = new(PausedProvisioner)
   104  }
   105  
   106  func TestPausedProvisionerPrepare(t *testing.T) {
   107  	mock := new(MockProvisioner)
   108  	prov := &PausedProvisioner{
   109  		Provisioner: mock,
   110  	}
   111  
   112  	prov.Prepare(42)
   113  	if !mock.PrepCalled {
   114  		t.Fatal("prepare should be called")
   115  	}
   116  	if mock.PrepConfigs[0] != 42 {
   117  		t.Fatal("should have proper configs")
   118  	}
   119  }
   120  
   121  func TestPausedProvisionerProvision(t *testing.T) {
   122  	mock := new(MockProvisioner)
   123  	prov := &PausedProvisioner{
   124  		Provisioner: mock,
   125  	}
   126  
   127  	ui := testUi()
   128  	comm := new(MockCommunicator)
   129  	prov.Provision(ui, comm)
   130  	if !mock.ProvCalled {
   131  		t.Fatal("prov should be called")
   132  	}
   133  	if mock.ProvUi != ui {
   134  		t.Fatal("should have proper ui")
   135  	}
   136  	if mock.ProvCommunicator != comm {
   137  		t.Fatal("should have proper comm")
   138  	}
   139  }
   140  
   141  func TestPausedProvisionerProvision_waits(t *testing.T) {
   142  	mock := new(MockProvisioner)
   143  	prov := &PausedProvisioner{
   144  		PauseBefore: 50 * time.Millisecond,
   145  		Provisioner: mock,
   146  	}
   147  
   148  	dataCh := make(chan struct{})
   149  	mock.ProvFunc = func() error {
   150  		close(dataCh)
   151  		return nil
   152  	}
   153  
   154  	go prov.Provision(testUi(), new(MockCommunicator))
   155  
   156  	select {
   157  	case <-time.After(10 * time.Millisecond):
   158  	case <-dataCh:
   159  		t.Fatal("should not be called")
   160  	}
   161  
   162  	select {
   163  	case <-time.After(100 * time.Millisecond):
   164  		t.Fatal("never called")
   165  	case <-dataCh:
   166  	}
   167  }
   168  
   169  func TestPausedProvisionerCancel(t *testing.T) {
   170  	mock := new(MockProvisioner)
   171  	prov := &PausedProvisioner{
   172  		Provisioner: mock,
   173  	}
   174  
   175  	provCh := make(chan struct{})
   176  	mock.ProvFunc = func() error {
   177  		close(provCh)
   178  		time.Sleep(10 * time.Millisecond)
   179  		return nil
   180  	}
   181  
   182  	// Start provisioning and wait for it to start
   183  	go prov.Provision(testUi(), new(MockCommunicator))
   184  	<-provCh
   185  
   186  	// Cancel it
   187  	prov.Cancel()
   188  	if !mock.CancelCalled {
   189  		t.Fatal("cancel should be called")
   190  	}
   191  }