github.com/opentofu/opentofu@v1.7.1/internal/legacy/tofu/resource_provider_mock.go (about)

     1  // Copyright (c) The OpenTofu Authors
     2  // SPDX-License-Identifier: MPL-2.0
     3  // Copyright (c) 2023 HashiCorp, Inc.
     4  // SPDX-License-Identifier: MPL-2.0
     5  
     6  package tofu
     7  
     8  import (
     9  	"sync"
    10  )
    11  
    12  // MockResourceProvider implements ResourceProvider but mocks out all the
    13  // calls for testing purposes.
    14  type MockResourceProvider struct {
    15  	sync.Mutex
    16  
    17  	// Anything you want, in case you need to store extra data with the mock.
    18  	Meta interface{}
    19  
    20  	CloseCalled                    bool
    21  	CloseError                     error
    22  	GetSchemaCalled                bool
    23  	GetSchemaRequest               *ProviderSchemaRequest
    24  	GetSchemaReturn                *ProviderSchema
    25  	GetSchemaReturnError           error
    26  	InputCalled                    bool
    27  	InputInput                     UIInput
    28  	InputConfig                    *ResourceConfig
    29  	InputReturnConfig              *ResourceConfig
    30  	InputReturnError               error
    31  	InputFn                        func(UIInput, *ResourceConfig) (*ResourceConfig, error)
    32  	ApplyCalled                    bool
    33  	ApplyInfo                      *InstanceInfo
    34  	ApplyState                     *InstanceState
    35  	ApplyDiff                      *InstanceDiff
    36  	ApplyFn                        func(*InstanceInfo, *InstanceState, *InstanceDiff) (*InstanceState, error)
    37  	ApplyReturn                    *InstanceState
    38  	ApplyReturnError               error
    39  	ConfigureCalled                bool
    40  	ConfigureConfig                *ResourceConfig
    41  	ConfigureProviderFn            func(*ResourceConfig) error
    42  	ConfigureReturnError           error
    43  	DiffCalled                     bool
    44  	DiffInfo                       *InstanceInfo
    45  	DiffState                      *InstanceState
    46  	DiffDesired                    *ResourceConfig
    47  	DiffFn                         func(*InstanceInfo, *InstanceState, *ResourceConfig) (*InstanceDiff, error)
    48  	DiffReturn                     *InstanceDiff
    49  	DiffReturnError                error
    50  	RefreshCalled                  bool
    51  	RefreshInfo                    *InstanceInfo
    52  	RefreshState                   *InstanceState
    53  	RefreshFn                      func(*InstanceInfo, *InstanceState) (*InstanceState, error)
    54  	RefreshReturn                  *InstanceState
    55  	RefreshReturnError             error
    56  	ResourcesCalled                bool
    57  	ResourcesReturn                []ResourceType
    58  	ReadDataApplyCalled            bool
    59  	ReadDataApplyInfo              *InstanceInfo
    60  	ReadDataApplyDiff              *InstanceDiff
    61  	ReadDataApplyFn                func(*InstanceInfo, *InstanceDiff) (*InstanceState, error)
    62  	ReadDataApplyReturn            *InstanceState
    63  	ReadDataApplyReturnError       error
    64  	ReadDataDiffCalled             bool
    65  	ReadDataDiffInfo               *InstanceInfo
    66  	ReadDataDiffDesired            *ResourceConfig
    67  	ReadDataDiffFn                 func(*InstanceInfo, *ResourceConfig) (*InstanceDiff, error)
    68  	ReadDataDiffReturn             *InstanceDiff
    69  	ReadDataDiffReturnError        error
    70  	StopCalled                     bool
    71  	StopFn                         func() error
    72  	StopReturnError                error
    73  	DataSourcesCalled              bool
    74  	DataSourcesReturn              []DataSource
    75  	ValidateCalled                 bool
    76  	ValidateConfig                 *ResourceConfig
    77  	ValidateFn                     func(*ResourceConfig) ([]string, []error)
    78  	ValidateReturnWarns            []string
    79  	ValidateReturnErrors           []error
    80  	ValidateResourceFn             func(string, *ResourceConfig) ([]string, []error)
    81  	ValidateResourceCalled         bool
    82  	ValidateResourceType           string
    83  	ValidateResourceConfig         *ResourceConfig
    84  	ValidateResourceReturnWarns    []string
    85  	ValidateResourceReturnErrors   []error
    86  	ValidateDataSourceFn           func(string, *ResourceConfig) ([]string, []error)
    87  	ValidateDataSourceCalled       bool
    88  	ValidateDataSourceType         string
    89  	ValidateDataSourceConfig       *ResourceConfig
    90  	ValidateDataSourceReturnWarns  []string
    91  	ValidateDataSourceReturnErrors []error
    92  
    93  	ImportStateCalled      bool
    94  	ImportStateInfo        *InstanceInfo
    95  	ImportStateID          string
    96  	ImportStateReturn      []*InstanceState
    97  	ImportStateReturnError error
    98  	ImportStateFn          func(*InstanceInfo, string) ([]*InstanceState, error)
    99  }
   100  
   101  func (p *MockResourceProvider) Close() error {
   102  	p.CloseCalled = true
   103  	return p.CloseError
   104  }
   105  
   106  func (p *MockResourceProvider) GetSchema(req *ProviderSchemaRequest) (*ProviderSchema, error) {
   107  	p.Lock()
   108  	defer p.Unlock()
   109  
   110  	p.GetSchemaCalled = true
   111  	p.GetSchemaRequest = req
   112  	return p.GetSchemaReturn, p.GetSchemaReturnError
   113  }
   114  
   115  func (p *MockResourceProvider) Input(
   116  	input UIInput, c *ResourceConfig) (*ResourceConfig, error) {
   117  	p.Lock()
   118  	defer p.Unlock()
   119  	p.InputCalled = true
   120  	p.InputInput = input
   121  	p.InputConfig = c
   122  	if p.InputFn != nil {
   123  		return p.InputFn(input, c)
   124  	}
   125  	return p.InputReturnConfig, p.InputReturnError
   126  }
   127  
   128  func (p *MockResourceProvider) Validate(c *ResourceConfig) ([]string, []error) {
   129  	p.Lock()
   130  	defer p.Unlock()
   131  
   132  	p.ValidateCalled = true
   133  	p.ValidateConfig = c
   134  	if p.ValidateFn != nil {
   135  		return p.ValidateFn(c)
   136  	}
   137  	return p.ValidateReturnWarns, p.ValidateReturnErrors
   138  }
   139  
   140  func (p *MockResourceProvider) ValidateResource(t string, c *ResourceConfig) ([]string, []error) {
   141  	p.Lock()
   142  	defer p.Unlock()
   143  
   144  	p.ValidateResourceCalled = true
   145  	p.ValidateResourceType = t
   146  	p.ValidateResourceConfig = c
   147  
   148  	if p.ValidateResourceFn != nil {
   149  		return p.ValidateResourceFn(t, c)
   150  	}
   151  
   152  	return p.ValidateResourceReturnWarns, p.ValidateResourceReturnErrors
   153  }
   154  
   155  func (p *MockResourceProvider) Configure(c *ResourceConfig) error {
   156  	p.Lock()
   157  	defer p.Unlock()
   158  
   159  	p.ConfigureCalled = true
   160  	p.ConfigureConfig = c
   161  
   162  	if p.ConfigureProviderFn != nil {
   163  		return p.ConfigureProviderFn(c)
   164  	}
   165  
   166  	return p.ConfigureReturnError
   167  }
   168  
   169  func (p *MockResourceProvider) Stop() error {
   170  	p.Lock()
   171  	defer p.Unlock()
   172  
   173  	p.StopCalled = true
   174  	if p.StopFn != nil {
   175  		return p.StopFn()
   176  	}
   177  
   178  	return p.StopReturnError
   179  }
   180  
   181  func (p *MockResourceProvider) Apply(
   182  	info *InstanceInfo,
   183  	state *InstanceState,
   184  	diff *InstanceDiff) (*InstanceState, error) {
   185  	// We only lock while writing data. Reading is fine
   186  	p.Lock()
   187  	p.ApplyCalled = true
   188  	p.ApplyInfo = info
   189  	p.ApplyState = state
   190  	p.ApplyDiff = diff
   191  	p.Unlock()
   192  
   193  	if p.ApplyFn != nil {
   194  		return p.ApplyFn(info, state, diff)
   195  	}
   196  
   197  	return p.ApplyReturn.DeepCopy(), p.ApplyReturnError
   198  }
   199  
   200  func (p *MockResourceProvider) Diff(
   201  	info *InstanceInfo,
   202  	state *InstanceState,
   203  	desired *ResourceConfig) (*InstanceDiff, error) {
   204  	p.Lock()
   205  	defer p.Unlock()
   206  
   207  	p.DiffCalled = true
   208  	p.DiffInfo = info
   209  	p.DiffState = state
   210  	p.DiffDesired = desired
   211  
   212  	if p.DiffFn != nil {
   213  		return p.DiffFn(info, state, desired)
   214  	}
   215  
   216  	return p.DiffReturn.DeepCopy(), p.DiffReturnError
   217  }
   218  
   219  func (p *MockResourceProvider) Refresh(
   220  	info *InstanceInfo,
   221  	s *InstanceState) (*InstanceState, error) {
   222  	p.Lock()
   223  	defer p.Unlock()
   224  
   225  	p.RefreshCalled = true
   226  	p.RefreshInfo = info
   227  	p.RefreshState = s
   228  
   229  	if p.RefreshFn != nil {
   230  		return p.RefreshFn(info, s)
   231  	}
   232  
   233  	return p.RefreshReturn.DeepCopy(), p.RefreshReturnError
   234  }
   235  
   236  func (p *MockResourceProvider) Resources() []ResourceType {
   237  	p.Lock()
   238  	defer p.Unlock()
   239  
   240  	p.ResourcesCalled = true
   241  	return p.ResourcesReturn
   242  }
   243  
   244  func (p *MockResourceProvider) ImportState(info *InstanceInfo, id string) ([]*InstanceState, error) {
   245  	p.Lock()
   246  	defer p.Unlock()
   247  
   248  	p.ImportStateCalled = true
   249  	p.ImportStateInfo = info
   250  	p.ImportStateID = id
   251  	if p.ImportStateFn != nil {
   252  		return p.ImportStateFn(info, id)
   253  	}
   254  
   255  	var result []*InstanceState
   256  	if p.ImportStateReturn != nil {
   257  		result = make([]*InstanceState, len(p.ImportStateReturn))
   258  		for i, v := range p.ImportStateReturn {
   259  			result[i] = v.DeepCopy()
   260  		}
   261  	}
   262  
   263  	return result, p.ImportStateReturnError
   264  }
   265  
   266  func (p *MockResourceProvider) ValidateDataSource(t string, c *ResourceConfig) ([]string, []error) {
   267  	p.Lock()
   268  	defer p.Unlock()
   269  
   270  	p.ValidateDataSourceCalled = true
   271  	p.ValidateDataSourceType = t
   272  	p.ValidateDataSourceConfig = c
   273  
   274  	if p.ValidateDataSourceFn != nil {
   275  		return p.ValidateDataSourceFn(t, c)
   276  	}
   277  
   278  	return p.ValidateDataSourceReturnWarns, p.ValidateDataSourceReturnErrors
   279  }
   280  
   281  func (p *MockResourceProvider) ReadDataDiff(
   282  	info *InstanceInfo,
   283  	desired *ResourceConfig) (*InstanceDiff, error) {
   284  	p.Lock()
   285  	defer p.Unlock()
   286  
   287  	p.ReadDataDiffCalled = true
   288  	p.ReadDataDiffInfo = info
   289  	p.ReadDataDiffDesired = desired
   290  	if p.ReadDataDiffFn != nil {
   291  		return p.ReadDataDiffFn(info, desired)
   292  	}
   293  
   294  	return p.ReadDataDiffReturn.DeepCopy(), p.ReadDataDiffReturnError
   295  }
   296  
   297  func (p *MockResourceProvider) ReadDataApply(
   298  	info *InstanceInfo,
   299  	d *InstanceDiff) (*InstanceState, error) {
   300  	p.Lock()
   301  	defer p.Unlock()
   302  
   303  	p.ReadDataApplyCalled = true
   304  	p.ReadDataApplyInfo = info
   305  	p.ReadDataApplyDiff = d
   306  
   307  	if p.ReadDataApplyFn != nil {
   308  		return p.ReadDataApplyFn(info, d)
   309  	}
   310  
   311  	return p.ReadDataApplyReturn.DeepCopy(), p.ReadDataApplyReturnError
   312  }
   313  
   314  func (p *MockResourceProvider) DataSources() []DataSource {
   315  	p.Lock()
   316  	defer p.Unlock()
   317  
   318  	p.DataSourcesCalled = true
   319  	return p.DataSourcesReturn
   320  }