github.com/homburg/packer@v0.6.1-0.20140528012651-1dcaf1716848/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 = nil
    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_cancel(t *testing.T) {
    41  	var lock sync.Mutex
    42  	order := make([]string, 0, 2)
    43  
    44  	p := &MockProvisioner{
    45  		ProvFunc: func() error {
    46  			time.Sleep(50 * time.Millisecond)
    47  
    48  			lock.Lock()
    49  			defer lock.Unlock()
    50  			order = append(order, "prov")
    51  
    52  			return nil
    53  		},
    54  	}
    55  
    56  	hook := &ProvisionHook{
    57  		Provisioners: []Provisioner{p},
    58  	}
    59  
    60  	finished := make(chan struct{})
    61  	go func() {
    62  		hook.Run("foo", nil, nil, nil)
    63  		close(finished)
    64  	}()
    65  
    66  	// Cancel it while it is running
    67  	time.Sleep(10 * time.Millisecond)
    68  	hook.Cancel()
    69  	lock.Lock()
    70  	order = append(order, "cancel")
    71  	lock.Unlock()
    72  
    73  	// Wait
    74  	<-finished
    75  
    76  	// Verify order
    77  	if order[0] != "cancel" || order[1] != "prov" {
    78  		t.Fatalf("bad: %#v", order)
    79  	}
    80  }
    81  
    82  // TODO(mitchellh): Test that they're run in the proper order
    83  
    84  func TestPausedProvisioner_impl(t *testing.T) {
    85  	var _ Provisioner = new(PausedProvisioner)
    86  }
    87  
    88  func TestPausedProvisionerPrepare(t *testing.T) {
    89  	mock := new(MockProvisioner)
    90  	prov := &PausedProvisioner{
    91  		Provisioner: mock,
    92  	}
    93  
    94  	prov.Prepare(42)
    95  	if !mock.PrepCalled {
    96  		t.Fatal("prepare should be called")
    97  	}
    98  	if mock.PrepConfigs[0] != 42 {
    99  		t.Fatal("should have proper configs")
   100  	}
   101  }
   102  
   103  func TestPausedProvisionerProvision(t *testing.T) {
   104  	mock := new(MockProvisioner)
   105  	prov := &PausedProvisioner{
   106  		Provisioner: mock,
   107  	}
   108  
   109  	ui := testUi()
   110  	comm := new(MockCommunicator)
   111  	prov.Provision(ui, comm)
   112  	if !mock.ProvCalled {
   113  		t.Fatal("prov should be called")
   114  	}
   115  	if mock.ProvUi != ui {
   116  		t.Fatal("should have proper ui")
   117  	}
   118  	if mock.ProvCommunicator != comm {
   119  		t.Fatal("should have proper comm")
   120  	}
   121  }
   122  
   123  func TestPausedProvisionerProvision_waits(t *testing.T) {
   124  	mock := new(MockProvisioner)
   125  	prov := &PausedProvisioner{
   126  		PauseBefore: 50 * time.Millisecond,
   127  		Provisioner: mock,
   128  	}
   129  
   130  	dataCh := make(chan struct{})
   131  	mock.ProvFunc = func() error {
   132  		close(dataCh)
   133  		return nil
   134  	}
   135  
   136  	go prov.Provision(testUi(), new(MockCommunicator))
   137  
   138  	select {
   139  	case <-time.After(10 * time.Millisecond):
   140  	case <-dataCh:
   141  		t.Fatal("should not be called")
   142  	}
   143  
   144  	select {
   145  	case <-time.After(100 * time.Millisecond):
   146  		t.Fatal("never called")
   147  	case <-dataCh:
   148  	}
   149  }
   150  
   151  func TestPausedProvisionerCancel(t *testing.T) {
   152  	mock := new(MockProvisioner)
   153  	prov := &PausedProvisioner{
   154  		Provisioner: mock,
   155  	}
   156  
   157  	provCh := make(chan struct{})
   158  	mock.ProvFunc = func() error {
   159  		close(provCh)
   160  		time.Sleep(10 * time.Millisecond)
   161  		return nil
   162  	}
   163  
   164  	// Start provisioning and wait for it to start
   165  	go prov.Provision(testUi(), new(MockCommunicator))
   166  	<-provCh
   167  
   168  	// Cancel it
   169  	prov.Cancel()
   170  	if !mock.CancelCalled {
   171  		t.Fatal("cancel should be called")
   172  	}
   173  }