vendor/github.com/hashicorp/terraform/terraform/provisioner_mock.go

   1 package terraform
   2
   3 import (
   4         "fmt"
   5         "sync"
   6
   7         "github.com/zclconf/go-cty/cty"
   8         "github.com/zclconf/go-cty/cty/convert"
   9
  10         "github.com/hashicorp/terraform/provisioners"
  11 )
  12
  13 var _ provisioners.Interface = (*MockProvisioner)(nil)
  14
  15 // MockProvisioner implements provisioners.Interface but mocks out all the
  16 // calls for testing purposes.
  17 type MockProvisioner struct {
  18         sync.Mutex
  19         // Anything you want, in case you need to store extra data with the mock.
  20         Meta interface{}
  21
  22         GetSchemaCalled   bool
  23         GetSchemaResponse provisioners.GetSchemaResponse
  24
  25         ValidateProvisionerConfigCalled   bool
  26         ValidateProvisionerConfigRequest  provisioners.ValidateProvisionerConfigRequest
  27         ValidateProvisionerConfigResponse provisioners.ValidateProvisionerConfigResponse
  28         ValidateProvisionerConfigFn       func(provisioners.ValidateProvisionerConfigRequest) provisioners.ValidateProvisionerConfigResponse
  29
  30         ProvisionResourceCalled   bool
  31         ProvisionResourceRequest  provisioners.ProvisionResourceRequest
  32         ProvisionResourceResponse provisioners.ProvisionResourceResponse
  33         ProvisionResourceFn       func(provisioners.ProvisionResourceRequest) provisioners.ProvisionResourceResponse
  34
  35         StopCalled   bool
  36         StopResponse error
  37         StopFn       func() error
  38
  39         CloseCalled   bool
  40         CloseResponse error
  41         CloseFn       func() error
  42
  43         // Legacy callbacks: if these are set, we will shim incoming calls for
  44         // new-style methods to these old-fashioned terraform.ResourceProvider
  45         // mock callbacks, for the benefit of older tests that were written against
  46         // the old mock API.
  47         ApplyFn func(rs *InstanceState, c *ResourceConfig) error
  48 }
  49
  50 func (p *MockProvisioner) GetSchema() provisioners.GetSchemaResponse {
  51         p.Lock()
  52         defer p.Unlock()
  53
  54         p.GetSchemaCalled = true
  55         return p.getSchema()
  56 }
  57
  58 // getSchema is the implementation of GetSchema, which can be called from other
  59 // methods on MockProvisioner that may already be holding the lock.
  60 func (p *MockProvisioner) getSchema() provisioners.GetSchemaResponse {
  61         return p.GetSchemaResponse
  62 }
  63
  64 func (p *MockProvisioner) ValidateProvisionerConfig(r provisioners.ValidateProvisionerConfigRequest) provisioners.ValidateProvisionerConfigResponse {
  65         p.Lock()
  66         defer p.Unlock()
  67
  68         p.ValidateProvisionerConfigCalled = true
  69         p.ValidateProvisionerConfigRequest = r
  70         if p.ValidateProvisionerConfigFn != nil {
  71                 return p.ValidateProvisionerConfigFn(r)
  72         }
  73         return p.ValidateProvisionerConfigResponse
  74 }
  75
  76 func (p *MockProvisioner) ProvisionResource(r provisioners.ProvisionResourceRequest) provisioners.ProvisionResourceResponse {
  77         p.Lock()
  78         defer p.Unlock()
  79
  80         p.ProvisionResourceCalled = true
  81         p.ProvisionResourceRequest = r
  82         if p.ApplyFn != nil {
  83                 if !r.Config.IsKnown() {
  84                         panic(fmt.Sprintf("cannot provision with unknown value: %#v", r.Config))
  85                 }
  86
  87                 schema := p.getSchema()
  88                 rc := NewResourceConfigShimmed(r.Config, schema.Provisioner)
  89                 connVal := r.Connection
  90                 connMap := map[string]string{}
  91
  92                 if !connVal.IsNull() && connVal.IsKnown() {
  93                         for it := connVal.ElementIterator(); it.Next(); {
  94                                 ak, av := it.Element()
  95                                 name := ak.AsString()
  96
  97                                 if !av.IsKnown() || av.IsNull() {
  98                                         continue
  99                                 }
 100
 101                                 av, _ = convert.Convert(av, cty.String)
 102                                 connMap[name] = av.AsString()
 103                         }
 104                 }
 105
 106                 // We no longer pass the full instance state to a provisioner, so we'll
 107                 // construct a partial one that should be good enough for what existing
 108                 // test mocks need.
 109                 is := &InstanceState{
 110                         Ephemeral: EphemeralState{
 111                                 ConnInfo: connMap,
 112                         },
 113                 }
 114                 var resp provisioners.ProvisionResourceResponse
 115                 err := p.ApplyFn(is, rc)
 116                 if err != nil {
 117                         resp.Diagnostics = resp.Diagnostics.Append(err)
 118                 }
 119                 return resp
 120         }
 121         if p.ProvisionResourceFn != nil {
 122                 fn := p.ProvisionResourceFn
 123                 p.Unlock()
 124                 return fn(r)
 125         }
 126
 127         return p.ProvisionResourceResponse
 128 }
 129
 130 func (p *MockProvisioner) Stop() error {
 131         // We intentionally don't lock in this one because the whole point of this
 132         // method is to be called concurrently with another operation that can
 133         // be cancelled. The provisioner itself is responsible for handling
 134         // any concurrency concerns in this case.
 135
 136         p.StopCalled = true
 137         if p.StopFn != nil {
 138                 return p.StopFn()
 139         }
 140
 141         return p.StopResponse
 142 }
 143
 144 func (p *MockProvisioner) Close() error {
 145         p.Lock()
 146         defer p.Unlock()
 147
 148         p.CloseCalled = true
 149         if p.CloseFn != nil {
 150                 return p.CloseFn()
 151         }
 152
 153         return p.CloseResponse
 154 }