github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/exec/execfakes/fake_build_step_delegate.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package execfakes
     3  
     4  import (
     5  	"context"
     6  	"io"
     7  	"sync"
     8  
     9  	"code.cloudfoundry.org/lager"
    10  	"github.com/pf-qiu/concourse/v6/atc"
    11  	"github.com/pf-qiu/concourse/v6/atc/exec"
    12  	"github.com/pf-qiu/concourse/v6/atc/worker"
    13  	"github.com/pf-qiu/concourse/v6/tracing"
    14  	"go.opentelemetry.io/otel/api/trace"
    15  )
    16  
    17  type FakeBuildStepDelegate struct {
    18  	ErroredStub        func(lager.Logger, string)
    19  	erroredMutex       sync.RWMutex
    20  	erroredArgsForCall []struct {
    21  		arg1 lager.Logger
    22  		arg2 string
    23  	}
    24  	FetchImageStub        func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error)
    25  	fetchImageMutex       sync.RWMutex
    26  	fetchImageArgsForCall []struct {
    27  		arg1 context.Context
    28  		arg2 atc.ImageResource
    29  		arg3 atc.VersionedResourceTypes
    30  		arg4 bool
    31  	}
    32  	fetchImageReturns struct {
    33  		result1 worker.ImageSpec
    34  		result2 error
    35  	}
    36  	fetchImageReturnsOnCall map[int]struct {
    37  		result1 worker.ImageSpec
    38  		result2 error
    39  	}
    40  	FinishedStub        func(lager.Logger, bool)
    41  	finishedMutex       sync.RWMutex
    42  	finishedArgsForCall []struct {
    43  		arg1 lager.Logger
    44  		arg2 bool
    45  	}
    46  	InitializingStub        func(lager.Logger)
    47  	initializingMutex       sync.RWMutex
    48  	initializingArgsForCall []struct {
    49  		arg1 lager.Logger
    50  	}
    51  	SelectedWorkerStub        func(lager.Logger, string)
    52  	selectedWorkerMutex       sync.RWMutex
    53  	selectedWorkerArgsForCall []struct {
    54  		arg1 lager.Logger
    55  		arg2 string
    56  	}
    57  	StartSpanStub        func(context.Context, string, tracing.Attrs) (context.Context, trace.Span)
    58  	startSpanMutex       sync.RWMutex
    59  	startSpanArgsForCall []struct {
    60  		arg1 context.Context
    61  		arg2 string
    62  		arg3 tracing.Attrs
    63  	}
    64  	startSpanReturns struct {
    65  		result1 context.Context
    66  		result2 trace.Span
    67  	}
    68  	startSpanReturnsOnCall map[int]struct {
    69  		result1 context.Context
    70  		result2 trace.Span
    71  	}
    72  	StartingStub        func(lager.Logger)
    73  	startingMutex       sync.RWMutex
    74  	startingArgsForCall []struct {
    75  		arg1 lager.Logger
    76  	}
    77  	StderrStub        func() io.Writer
    78  	stderrMutex       sync.RWMutex
    79  	stderrArgsForCall []struct {
    80  	}
    81  	stderrReturns struct {
    82  		result1 io.Writer
    83  	}
    84  	stderrReturnsOnCall map[int]struct {
    85  		result1 io.Writer
    86  	}
    87  	StdoutStub        func() io.Writer
    88  	stdoutMutex       sync.RWMutex
    89  	stdoutArgsForCall []struct {
    90  	}
    91  	stdoutReturns struct {
    92  		result1 io.Writer
    93  	}
    94  	stdoutReturnsOnCall map[int]struct {
    95  		result1 io.Writer
    96  	}
    97  	invocations      map[string][][]interface{}
    98  	invocationsMutex sync.RWMutex
    99  }
   100  
   101  func (fake *FakeBuildStepDelegate) Errored(arg1 lager.Logger, arg2 string) {
   102  	fake.erroredMutex.Lock()
   103  	fake.erroredArgsForCall = append(fake.erroredArgsForCall, struct {
   104  		arg1 lager.Logger
   105  		arg2 string
   106  	}{arg1, arg2})
   107  	fake.recordInvocation("Errored", []interface{}{arg1, arg2})
   108  	fake.erroredMutex.Unlock()
   109  	if fake.ErroredStub != nil {
   110  		fake.ErroredStub(arg1, arg2)
   111  	}
   112  }
   113  
   114  func (fake *FakeBuildStepDelegate) ErroredCallCount() int {
   115  	fake.erroredMutex.RLock()
   116  	defer fake.erroredMutex.RUnlock()
   117  	return len(fake.erroredArgsForCall)
   118  }
   119  
   120  func (fake *FakeBuildStepDelegate) ErroredCalls(stub func(lager.Logger, string)) {
   121  	fake.erroredMutex.Lock()
   122  	defer fake.erroredMutex.Unlock()
   123  	fake.ErroredStub = stub
   124  }
   125  
   126  func (fake *FakeBuildStepDelegate) ErroredArgsForCall(i int) (lager.Logger, string) {
   127  	fake.erroredMutex.RLock()
   128  	defer fake.erroredMutex.RUnlock()
   129  	argsForCall := fake.erroredArgsForCall[i]
   130  	return argsForCall.arg1, argsForCall.arg2
   131  }
   132  
   133  func (fake *FakeBuildStepDelegate) FetchImage(arg1 context.Context, arg2 atc.ImageResource, arg3 atc.VersionedResourceTypes, arg4 bool) (worker.ImageSpec, error) {
   134  	fake.fetchImageMutex.Lock()
   135  	ret, specificReturn := fake.fetchImageReturnsOnCall[len(fake.fetchImageArgsForCall)]
   136  	fake.fetchImageArgsForCall = append(fake.fetchImageArgsForCall, struct {
   137  		arg1 context.Context
   138  		arg2 atc.ImageResource
   139  		arg3 atc.VersionedResourceTypes
   140  		arg4 bool
   141  	}{arg1, arg2, arg3, arg4})
   142  	fake.recordInvocation("FetchImage", []interface{}{arg1, arg2, arg3, arg4})
   143  	fake.fetchImageMutex.Unlock()
   144  	if fake.FetchImageStub != nil {
   145  		return fake.FetchImageStub(arg1, arg2, arg3, arg4)
   146  	}
   147  	if specificReturn {
   148  		return ret.result1, ret.result2
   149  	}
   150  	fakeReturns := fake.fetchImageReturns
   151  	return fakeReturns.result1, fakeReturns.result2
   152  }
   153  
   154  func (fake *FakeBuildStepDelegate) FetchImageCallCount() int {
   155  	fake.fetchImageMutex.RLock()
   156  	defer fake.fetchImageMutex.RUnlock()
   157  	return len(fake.fetchImageArgsForCall)
   158  }
   159  
   160  func (fake *FakeBuildStepDelegate) FetchImageCalls(stub func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error)) {
   161  	fake.fetchImageMutex.Lock()
   162  	defer fake.fetchImageMutex.Unlock()
   163  	fake.FetchImageStub = stub
   164  }
   165  
   166  func (fake *FakeBuildStepDelegate) FetchImageArgsForCall(i int) (context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) {
   167  	fake.fetchImageMutex.RLock()
   168  	defer fake.fetchImageMutex.RUnlock()
   169  	argsForCall := fake.fetchImageArgsForCall[i]
   170  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
   171  }
   172  
   173  func (fake *FakeBuildStepDelegate) FetchImageReturns(result1 worker.ImageSpec, result2 error) {
   174  	fake.fetchImageMutex.Lock()
   175  	defer fake.fetchImageMutex.Unlock()
   176  	fake.FetchImageStub = nil
   177  	fake.fetchImageReturns = struct {
   178  		result1 worker.ImageSpec
   179  		result2 error
   180  	}{result1, result2}
   181  }
   182  
   183  func (fake *FakeBuildStepDelegate) FetchImageReturnsOnCall(i int, result1 worker.ImageSpec, result2 error) {
   184  	fake.fetchImageMutex.Lock()
   185  	defer fake.fetchImageMutex.Unlock()
   186  	fake.FetchImageStub = nil
   187  	if fake.fetchImageReturnsOnCall == nil {
   188  		fake.fetchImageReturnsOnCall = make(map[int]struct {
   189  			result1 worker.ImageSpec
   190  			result2 error
   191  		})
   192  	}
   193  	fake.fetchImageReturnsOnCall[i] = struct {
   194  		result1 worker.ImageSpec
   195  		result2 error
   196  	}{result1, result2}
   197  }
   198  
   199  func (fake *FakeBuildStepDelegate) Finished(arg1 lager.Logger, arg2 bool) {
   200  	fake.finishedMutex.Lock()
   201  	fake.finishedArgsForCall = append(fake.finishedArgsForCall, struct {
   202  		arg1 lager.Logger
   203  		arg2 bool
   204  	}{arg1, arg2})
   205  	fake.recordInvocation("Finished", []interface{}{arg1, arg2})
   206  	fake.finishedMutex.Unlock()
   207  	if fake.FinishedStub != nil {
   208  		fake.FinishedStub(arg1, arg2)
   209  	}
   210  }
   211  
   212  func (fake *FakeBuildStepDelegate) FinishedCallCount() int {
   213  	fake.finishedMutex.RLock()
   214  	defer fake.finishedMutex.RUnlock()
   215  	return len(fake.finishedArgsForCall)
   216  }
   217  
   218  func (fake *FakeBuildStepDelegate) FinishedCalls(stub func(lager.Logger, bool)) {
   219  	fake.finishedMutex.Lock()
   220  	defer fake.finishedMutex.Unlock()
   221  	fake.FinishedStub = stub
   222  }
   223  
   224  func (fake *FakeBuildStepDelegate) FinishedArgsForCall(i int) (lager.Logger, bool) {
   225  	fake.finishedMutex.RLock()
   226  	defer fake.finishedMutex.RUnlock()
   227  	argsForCall := fake.finishedArgsForCall[i]
   228  	return argsForCall.arg1, argsForCall.arg2
   229  }
   230  
   231  func (fake *FakeBuildStepDelegate) Initializing(arg1 lager.Logger) {
   232  	fake.initializingMutex.Lock()
   233  	fake.initializingArgsForCall = append(fake.initializingArgsForCall, struct {
   234  		arg1 lager.Logger
   235  	}{arg1})
   236  	fake.recordInvocation("Initializing", []interface{}{arg1})
   237  	fake.initializingMutex.Unlock()
   238  	if fake.InitializingStub != nil {
   239  		fake.InitializingStub(arg1)
   240  	}
   241  }
   242  
   243  func (fake *FakeBuildStepDelegate) InitializingCallCount() int {
   244  	fake.initializingMutex.RLock()
   245  	defer fake.initializingMutex.RUnlock()
   246  	return len(fake.initializingArgsForCall)
   247  }
   248  
   249  func (fake *FakeBuildStepDelegate) InitializingCalls(stub func(lager.Logger)) {
   250  	fake.initializingMutex.Lock()
   251  	defer fake.initializingMutex.Unlock()
   252  	fake.InitializingStub = stub
   253  }
   254  
   255  func (fake *FakeBuildStepDelegate) InitializingArgsForCall(i int) lager.Logger {
   256  	fake.initializingMutex.RLock()
   257  	defer fake.initializingMutex.RUnlock()
   258  	argsForCall := fake.initializingArgsForCall[i]
   259  	return argsForCall.arg1
   260  }
   261  
   262  func (fake *FakeBuildStepDelegate) SelectedWorker(arg1 lager.Logger, arg2 string) {
   263  	fake.selectedWorkerMutex.Lock()
   264  	fake.selectedWorkerArgsForCall = append(fake.selectedWorkerArgsForCall, struct {
   265  		arg1 lager.Logger
   266  		arg2 string
   267  	}{arg1, arg2})
   268  	fake.recordInvocation("SelectedWorker", []interface{}{arg1, arg2})
   269  	fake.selectedWorkerMutex.Unlock()
   270  	if fake.SelectedWorkerStub != nil {
   271  		fake.SelectedWorkerStub(arg1, arg2)
   272  	}
   273  }
   274  
   275  func (fake *FakeBuildStepDelegate) SelectedWorkerCallCount() int {
   276  	fake.selectedWorkerMutex.RLock()
   277  	defer fake.selectedWorkerMutex.RUnlock()
   278  	return len(fake.selectedWorkerArgsForCall)
   279  }
   280  
   281  func (fake *FakeBuildStepDelegate) SelectedWorkerCalls(stub func(lager.Logger, string)) {
   282  	fake.selectedWorkerMutex.Lock()
   283  	defer fake.selectedWorkerMutex.Unlock()
   284  	fake.SelectedWorkerStub = stub
   285  }
   286  
   287  func (fake *FakeBuildStepDelegate) SelectedWorkerArgsForCall(i int) (lager.Logger, string) {
   288  	fake.selectedWorkerMutex.RLock()
   289  	defer fake.selectedWorkerMutex.RUnlock()
   290  	argsForCall := fake.selectedWorkerArgsForCall[i]
   291  	return argsForCall.arg1, argsForCall.arg2
   292  }
   293  
   294  func (fake *FakeBuildStepDelegate) StartSpan(arg1 context.Context, arg2 string, arg3 tracing.Attrs) (context.Context, trace.Span) {
   295  	fake.startSpanMutex.Lock()
   296  	ret, specificReturn := fake.startSpanReturnsOnCall[len(fake.startSpanArgsForCall)]
   297  	fake.startSpanArgsForCall = append(fake.startSpanArgsForCall, struct {
   298  		arg1 context.Context
   299  		arg2 string
   300  		arg3 tracing.Attrs
   301  	}{arg1, arg2, arg3})
   302  	fake.recordInvocation("StartSpan", []interface{}{arg1, arg2, arg3})
   303  	fake.startSpanMutex.Unlock()
   304  	if fake.StartSpanStub != nil {
   305  		return fake.StartSpanStub(arg1, arg2, arg3)
   306  	}
   307  	if specificReturn {
   308  		return ret.result1, ret.result2
   309  	}
   310  	fakeReturns := fake.startSpanReturns
   311  	return fakeReturns.result1, fakeReturns.result2
   312  }
   313  
   314  func (fake *FakeBuildStepDelegate) StartSpanCallCount() int {
   315  	fake.startSpanMutex.RLock()
   316  	defer fake.startSpanMutex.RUnlock()
   317  	return len(fake.startSpanArgsForCall)
   318  }
   319  
   320  func (fake *FakeBuildStepDelegate) StartSpanCalls(stub func(context.Context, string, tracing.Attrs) (context.Context, trace.Span)) {
   321  	fake.startSpanMutex.Lock()
   322  	defer fake.startSpanMutex.Unlock()
   323  	fake.StartSpanStub = stub
   324  }
   325  
   326  func (fake *FakeBuildStepDelegate) StartSpanArgsForCall(i int) (context.Context, string, tracing.Attrs) {
   327  	fake.startSpanMutex.RLock()
   328  	defer fake.startSpanMutex.RUnlock()
   329  	argsForCall := fake.startSpanArgsForCall[i]
   330  	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
   331  }
   332  
   333  func (fake *FakeBuildStepDelegate) StartSpanReturns(result1 context.Context, result2 trace.Span) {
   334  	fake.startSpanMutex.Lock()
   335  	defer fake.startSpanMutex.Unlock()
   336  	fake.StartSpanStub = nil
   337  	fake.startSpanReturns = struct {
   338  		result1 context.Context
   339  		result2 trace.Span
   340  	}{result1, result2}
   341  }
   342  
   343  func (fake *FakeBuildStepDelegate) StartSpanReturnsOnCall(i int, result1 context.Context, result2 trace.Span) {
   344  	fake.startSpanMutex.Lock()
   345  	defer fake.startSpanMutex.Unlock()
   346  	fake.StartSpanStub = nil
   347  	if fake.startSpanReturnsOnCall == nil {
   348  		fake.startSpanReturnsOnCall = make(map[int]struct {
   349  			result1 context.Context
   350  			result2 trace.Span
   351  		})
   352  	}
   353  	fake.startSpanReturnsOnCall[i] = struct {
   354  		result1 context.Context
   355  		result2 trace.Span
   356  	}{result1, result2}
   357  }
   358  
   359  func (fake *FakeBuildStepDelegate) Starting(arg1 lager.Logger) {
   360  	fake.startingMutex.Lock()
   361  	fake.startingArgsForCall = append(fake.startingArgsForCall, struct {
   362  		arg1 lager.Logger
   363  	}{arg1})
   364  	fake.recordInvocation("Starting", []interface{}{arg1})
   365  	fake.startingMutex.Unlock()
   366  	if fake.StartingStub != nil {
   367  		fake.StartingStub(arg1)
   368  	}
   369  }
   370  
   371  func (fake *FakeBuildStepDelegate) StartingCallCount() int {
   372  	fake.startingMutex.RLock()
   373  	defer fake.startingMutex.RUnlock()
   374  	return len(fake.startingArgsForCall)
   375  }
   376  
   377  func (fake *FakeBuildStepDelegate) StartingCalls(stub func(lager.Logger)) {
   378  	fake.startingMutex.Lock()
   379  	defer fake.startingMutex.Unlock()
   380  	fake.StartingStub = stub
   381  }
   382  
   383  func (fake *FakeBuildStepDelegate) StartingArgsForCall(i int) lager.Logger {
   384  	fake.startingMutex.RLock()
   385  	defer fake.startingMutex.RUnlock()
   386  	argsForCall := fake.startingArgsForCall[i]
   387  	return argsForCall.arg1
   388  }
   389  
   390  func (fake *FakeBuildStepDelegate) Stderr() io.Writer {
   391  	fake.stderrMutex.Lock()
   392  	ret, specificReturn := fake.stderrReturnsOnCall[len(fake.stderrArgsForCall)]
   393  	fake.stderrArgsForCall = append(fake.stderrArgsForCall, struct {
   394  	}{})
   395  	fake.recordInvocation("Stderr", []interface{}{})
   396  	fake.stderrMutex.Unlock()
   397  	if fake.StderrStub != nil {
   398  		return fake.StderrStub()
   399  	}
   400  	if specificReturn {
   401  		return ret.result1
   402  	}
   403  	fakeReturns := fake.stderrReturns
   404  	return fakeReturns.result1
   405  }
   406  
   407  func (fake *FakeBuildStepDelegate) StderrCallCount() int {
   408  	fake.stderrMutex.RLock()
   409  	defer fake.stderrMutex.RUnlock()
   410  	return len(fake.stderrArgsForCall)
   411  }
   412  
   413  func (fake *FakeBuildStepDelegate) StderrCalls(stub func() io.Writer) {
   414  	fake.stderrMutex.Lock()
   415  	defer fake.stderrMutex.Unlock()
   416  	fake.StderrStub = stub
   417  }
   418  
   419  func (fake *FakeBuildStepDelegate) StderrReturns(result1 io.Writer) {
   420  	fake.stderrMutex.Lock()
   421  	defer fake.stderrMutex.Unlock()
   422  	fake.StderrStub = nil
   423  	fake.stderrReturns = struct {
   424  		result1 io.Writer
   425  	}{result1}
   426  }
   427  
   428  func (fake *FakeBuildStepDelegate) StderrReturnsOnCall(i int, result1 io.Writer) {
   429  	fake.stderrMutex.Lock()
   430  	defer fake.stderrMutex.Unlock()
   431  	fake.StderrStub = nil
   432  	if fake.stderrReturnsOnCall == nil {
   433  		fake.stderrReturnsOnCall = make(map[int]struct {
   434  			result1 io.Writer
   435  		})
   436  	}
   437  	fake.stderrReturnsOnCall[i] = struct {
   438  		result1 io.Writer
   439  	}{result1}
   440  }
   441  
   442  func (fake *FakeBuildStepDelegate) Stdout() io.Writer {
   443  	fake.stdoutMutex.Lock()
   444  	ret, specificReturn := fake.stdoutReturnsOnCall[len(fake.stdoutArgsForCall)]
   445  	fake.stdoutArgsForCall = append(fake.stdoutArgsForCall, struct {
   446  	}{})
   447  	fake.recordInvocation("Stdout", []interface{}{})
   448  	fake.stdoutMutex.Unlock()
   449  	if fake.StdoutStub != nil {
   450  		return fake.StdoutStub()
   451  	}
   452  	if specificReturn {
   453  		return ret.result1
   454  	}
   455  	fakeReturns := fake.stdoutReturns
   456  	return fakeReturns.result1
   457  }
   458  
   459  func (fake *FakeBuildStepDelegate) StdoutCallCount() int {
   460  	fake.stdoutMutex.RLock()
   461  	defer fake.stdoutMutex.RUnlock()
   462  	return len(fake.stdoutArgsForCall)
   463  }
   464  
   465  func (fake *FakeBuildStepDelegate) StdoutCalls(stub func() io.Writer) {
   466  	fake.stdoutMutex.Lock()
   467  	defer fake.stdoutMutex.Unlock()
   468  	fake.StdoutStub = stub
   469  }
   470  
   471  func (fake *FakeBuildStepDelegate) StdoutReturns(result1 io.Writer) {
   472  	fake.stdoutMutex.Lock()
   473  	defer fake.stdoutMutex.Unlock()
   474  	fake.StdoutStub = nil
   475  	fake.stdoutReturns = struct {
   476  		result1 io.Writer
   477  	}{result1}
   478  }
   479  
   480  func (fake *FakeBuildStepDelegate) StdoutReturnsOnCall(i int, result1 io.Writer) {
   481  	fake.stdoutMutex.Lock()
   482  	defer fake.stdoutMutex.Unlock()
   483  	fake.StdoutStub = nil
   484  	if fake.stdoutReturnsOnCall == nil {
   485  		fake.stdoutReturnsOnCall = make(map[int]struct {
   486  			result1 io.Writer
   487  		})
   488  	}
   489  	fake.stdoutReturnsOnCall[i] = struct {
   490  		result1 io.Writer
   491  	}{result1}
   492  }
   493  
   494  func (fake *FakeBuildStepDelegate) Invocations() map[string][][]interface{} {
   495  	fake.invocationsMutex.RLock()
   496  	defer fake.invocationsMutex.RUnlock()
   497  	fake.erroredMutex.RLock()
   498  	defer fake.erroredMutex.RUnlock()
   499  	fake.fetchImageMutex.RLock()
   500  	defer fake.fetchImageMutex.RUnlock()
   501  	fake.finishedMutex.RLock()
   502  	defer fake.finishedMutex.RUnlock()
   503  	fake.initializingMutex.RLock()
   504  	defer fake.initializingMutex.RUnlock()
   505  	fake.selectedWorkerMutex.RLock()
   506  	defer fake.selectedWorkerMutex.RUnlock()
   507  	fake.startSpanMutex.RLock()
   508  	defer fake.startSpanMutex.RUnlock()
   509  	fake.startingMutex.RLock()
   510  	defer fake.startingMutex.RUnlock()
   511  	fake.stderrMutex.RLock()
   512  	defer fake.stderrMutex.RUnlock()
   513  	fake.stdoutMutex.RLock()
   514  	defer fake.stdoutMutex.RUnlock()
   515  	copiedInvocations := map[string][][]interface{}{}
   516  	for key, value := range fake.invocations {
   517  		copiedInvocations[key] = value
   518  	}
   519  	return copiedInvocations
   520  }
   521  
   522  func (fake *FakeBuildStepDelegate) recordInvocation(key string, args []interface{}) {
   523  	fake.invocationsMutex.Lock()
   524  	defer fake.invocationsMutex.Unlock()
   525  	if fake.invocations == nil {
   526  		fake.invocations = map[string][][]interface{}{}
   527  	}
   528  	if fake.invocations[key] == nil {
   529  		fake.invocations[key] = [][]interface{}{}
   530  	}
   531  	fake.invocations[key] = append(fake.invocations[key], args)
   532  }
   533  
   534  var _ exec.BuildStepDelegate = new(FakeBuildStepDelegate)