github.com/graywolf-at-work-2/terraform-vendor@v1.4.5/internal/legacy/terraform/provisioner_mock.go (about)

     1  package terraform
     2  
     3  import (
     4  	"sync"
     5  
     6  	"github.com/hashicorp/terraform/internal/provisioners"
     7  )
     8  
     9  var _ provisioners.Interface = (*MockProvisioner)(nil)
    10  
    11  // MockProvisioner implements provisioners.Interface but mocks out all the
    12  // calls for testing purposes.
    13  type MockProvisioner struct {
    14  	sync.Mutex
    15  	// Anything you want, in case you need to store extra data with the mock.
    16  	Meta interface{}
    17  
    18  	GetSchemaCalled   bool
    19  	GetSchemaResponse provisioners.GetSchemaResponse
    20  
    21  	ValidateProvisionerConfigCalled   bool
    22  	ValidateProvisionerConfigRequest  provisioners.ValidateProvisionerConfigRequest
    23  	ValidateProvisionerConfigResponse provisioners.ValidateProvisionerConfigResponse
    24  	ValidateProvisionerConfigFn       func(provisioners.ValidateProvisionerConfigRequest) provisioners.ValidateProvisionerConfigResponse
    25  
    26  	ProvisionResourceCalled   bool
    27  	ProvisionResourceRequest  provisioners.ProvisionResourceRequest
    28  	ProvisionResourceResponse provisioners.ProvisionResourceResponse
    29  	ProvisionResourceFn       func(provisioners.ProvisionResourceRequest) provisioners.ProvisionResourceResponse
    30  
    31  	StopCalled   bool
    32  	StopResponse error
    33  	StopFn       func() error
    34  
    35  	CloseCalled   bool
    36  	CloseResponse error
    37  	CloseFn       func() error
    38  }
    39  
    40  func (p *MockProvisioner) GetSchema() provisioners.GetSchemaResponse {
    41  	p.Lock()
    42  	defer p.Unlock()
    43  
    44  	p.GetSchemaCalled = true
    45  	return p.getSchema()
    46  }
    47  
    48  // getSchema is the implementation of GetSchema, which can be called from other
    49  // methods on MockProvisioner that may already be holding the lock.
    50  func (p *MockProvisioner) getSchema() provisioners.GetSchemaResponse {
    51  	return p.GetSchemaResponse
    52  }
    53  
    54  func (p *MockProvisioner) ValidateProvisionerConfig(r provisioners.ValidateProvisionerConfigRequest) provisioners.ValidateProvisionerConfigResponse {
    55  	p.Lock()
    56  	defer p.Unlock()
    57  
    58  	p.ValidateProvisionerConfigCalled = true
    59  	p.ValidateProvisionerConfigRequest = r
    60  	if p.ValidateProvisionerConfigFn != nil {
    61  		return p.ValidateProvisionerConfigFn(r)
    62  	}
    63  	return p.ValidateProvisionerConfigResponse
    64  }
    65  
    66  func (p *MockProvisioner) ProvisionResource(r provisioners.ProvisionResourceRequest) provisioners.ProvisionResourceResponse {
    67  	p.Lock()
    68  	defer p.Unlock()
    69  
    70  	p.ProvisionResourceCalled = true
    71  	p.ProvisionResourceRequest = r
    72  	if p.ProvisionResourceFn != nil {
    73  		fn := p.ProvisionResourceFn
    74  		return fn(r)
    75  	}
    76  
    77  	return p.ProvisionResourceResponse
    78  }
    79  
    80  func (p *MockProvisioner) Stop() error {
    81  	// We intentionally don't lock in this one because the whole point of this
    82  	// method is to be called concurrently with another operation that can
    83  	// be cancelled. The provisioner itself is responsible for handling
    84  	// any concurrency concerns in this case.
    85  
    86  	p.StopCalled = true
    87  	if p.StopFn != nil {
    88  		return p.StopFn()
    89  	}
    90  
    91  	return p.StopResponse
    92  }
    93  
    94  func (p *MockProvisioner) Close() error {
    95  	p.Lock()
    96  	defer p.Unlock()
    97  
    98  	p.CloseCalled = true
    99  	if p.CloseFn != nil {
   100  		return p.CloseFn()
   101  	}
   102  
   103  	return p.CloseResponse
   104  }