github.com/rakutentech/cli@v6.12.5-0.20151006231303-24468b65536e+incompatible/testhelpers/commands/fake_registry_command.go (about)

     1  // This file was generated by counterfeiter
     2  package commands
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/cloudfoundry/cli/cf/command_registry"
     8  	"github.com/cloudfoundry/cli/cf/requirements"
     9  	"github.com/cloudfoundry/cli/flags"
    10  )
    11  
    12  type FakeCommand struct {
    13  	MetaDataStub        func() command_registry.CommandMetadata
    14  	metaDataMutex       sync.RWMutex
    15  	metaDataArgsForCall []struct{}
    16  	metaDataReturns     struct {
    17  		result1 command_registry.CommandMetadata
    18  	}
    19  	SetDependencyStub        func(deps command_registry.Dependency, pluginCall bool) command_registry.Command
    20  	setDependencyMutex       sync.RWMutex
    21  	setDependencyArgsForCall []struct {
    22  		deps       command_registry.Dependency
    23  		pluginCall bool
    24  	}
    25  	setDependencyReturns struct {
    26  		result1 command_registry.Command
    27  	}
    28  	RequirementsStub        func(requirementsFactory requirements.Factory, context flags.FlagContext) (reqs []requirements.Requirement, err error)
    29  	requirementsMutex       sync.RWMutex
    30  	requirementsArgsForCall []struct {
    31  		requirementsFactory requirements.Factory
    32  		context             flags.FlagContext
    33  	}
    34  	requirementsReturns struct {
    35  		result1 []requirements.Requirement
    36  		result2 error
    37  	}
    38  	ExecuteStub        func(context flags.FlagContext)
    39  	executeMutex       sync.RWMutex
    40  	executeArgsForCall []struct {
    41  		context flags.FlagContext
    42  	}
    43  }
    44  
    45  func (fake *FakeCommand) MetaData() command_registry.CommandMetadata {
    46  	fake.metaDataMutex.Lock()
    47  	fake.metaDataArgsForCall = append(fake.metaDataArgsForCall, struct{}{})
    48  	fake.metaDataMutex.Unlock()
    49  	if fake.MetaDataStub != nil {
    50  		return fake.MetaDataStub()
    51  	} else {
    52  		return fake.metaDataReturns.result1
    53  	}
    54  }
    55  
    56  func (fake *FakeCommand) MetaDataCallCount() int {
    57  	fake.metaDataMutex.RLock()
    58  	defer fake.metaDataMutex.RUnlock()
    59  	return len(fake.metaDataArgsForCall)
    60  }
    61  
    62  func (fake *FakeCommand) MetaDataReturns(result1 command_registry.CommandMetadata) {
    63  	fake.MetaDataStub = nil
    64  	fake.metaDataReturns = struct {
    65  		result1 command_registry.CommandMetadata
    66  	}{result1}
    67  }
    68  
    69  func (fake *FakeCommand) SetDependency(deps command_registry.Dependency, pluginCall bool) command_registry.Command {
    70  	fake.setDependencyMutex.Lock()
    71  	fake.setDependencyArgsForCall = append(fake.setDependencyArgsForCall, struct {
    72  		deps       command_registry.Dependency
    73  		pluginCall bool
    74  	}{deps, pluginCall})
    75  	fake.setDependencyMutex.Unlock()
    76  	if fake.SetDependencyStub != nil {
    77  		return fake.SetDependencyStub(deps, pluginCall)
    78  	} else {
    79  		return fake.setDependencyReturns.result1
    80  	}
    81  }
    82  
    83  func (fake *FakeCommand) SetDependencyCallCount() int {
    84  	fake.setDependencyMutex.RLock()
    85  	defer fake.setDependencyMutex.RUnlock()
    86  	return len(fake.setDependencyArgsForCall)
    87  }
    88  
    89  func (fake *FakeCommand) SetDependencyArgsForCall(i int) (command_registry.Dependency, bool) {
    90  	fake.setDependencyMutex.RLock()
    91  	defer fake.setDependencyMutex.RUnlock()
    92  	return fake.setDependencyArgsForCall[i].deps, fake.setDependencyArgsForCall[i].pluginCall
    93  }
    94  
    95  func (fake *FakeCommand) SetDependencyReturns(result1 command_registry.Command) {
    96  	fake.SetDependencyStub = nil
    97  	fake.setDependencyReturns = struct {
    98  		result1 command_registry.Command
    99  	}{result1}
   100  }
   101  
   102  func (fake *FakeCommand) Requirements(requirementsFactory requirements.Factory, context flags.FlagContext) (reqs []requirements.Requirement, err error) {
   103  	fake.requirementsMutex.Lock()
   104  	fake.requirementsArgsForCall = append(fake.requirementsArgsForCall, struct {
   105  		requirementsFactory requirements.Factory
   106  		context             flags.FlagContext
   107  	}{requirementsFactory, context})
   108  	fake.requirementsMutex.Unlock()
   109  	if fake.RequirementsStub != nil {
   110  		return fake.RequirementsStub(requirementsFactory, context)
   111  	} else {
   112  		return fake.requirementsReturns.result1, fake.requirementsReturns.result2
   113  	}
   114  }
   115  
   116  func (fake *FakeCommand) RequirementsCallCount() int {
   117  	fake.requirementsMutex.RLock()
   118  	defer fake.requirementsMutex.RUnlock()
   119  	return len(fake.requirementsArgsForCall)
   120  }
   121  
   122  func (fake *FakeCommand) RequirementsArgsForCall(i int) (requirements.Factory, flags.FlagContext) {
   123  	fake.requirementsMutex.RLock()
   124  	defer fake.requirementsMutex.RUnlock()
   125  	return fake.requirementsArgsForCall[i].requirementsFactory, fake.requirementsArgsForCall[i].context
   126  }
   127  
   128  func (fake *FakeCommand) RequirementsReturns(result1 []requirements.Requirement, result2 error) {
   129  	fake.RequirementsStub = nil
   130  	fake.requirementsReturns = struct {
   131  		result1 []requirements.Requirement
   132  		result2 error
   133  	}{result1, result2}
   134  }
   135  
   136  func (fake *FakeCommand) Execute(context flags.FlagContext) {
   137  	fake.executeMutex.Lock()
   138  	fake.executeArgsForCall = append(fake.executeArgsForCall, struct {
   139  		context flags.FlagContext
   140  	}{context})
   141  	fake.executeMutex.Unlock()
   142  	if fake.ExecuteStub != nil {
   143  		fake.ExecuteStub(context)
   144  	}
   145  }
   146  
   147  func (fake *FakeCommand) ExecuteCallCount() int {
   148  	fake.executeMutex.RLock()
   149  	defer fake.executeMutex.RUnlock()
   150  	return len(fake.executeArgsForCall)
   151  }
   152  
   153  func (fake *FakeCommand) ExecuteArgsForCall(i int) flags.FlagContext {
   154  	fake.executeMutex.RLock()
   155  	defer fake.executeMutex.RUnlock()
   156  	return fake.executeArgsForCall[i].context
   157  }
   158  
   159  var _ command_registry.Command = new(FakeCommand)