github.com/sap/cf-mta-plugin@v2.6.3+incompatible/clients/mtaclient_v2/fakes/fake_mta_v2_client_operations.go (about)

     1  package fakes
     2  
     3  import (
     4  	"sync"
     5  
     6  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/models"
     7  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/mtaclient_v2"
     8  )
     9  
    10  type FakeMtaV2ClientOperations struct {
    11  	GetMtasStub        func(name, namespace *string, spaceGuid string) ([]*models.Mta, error)
    12  	getMtasMutex       sync.RWMutex
    13  	getMtasArgsForCall []struct {
    14  		name      *string
    15  		namespace *string
    16  		spaceGuid string
    17  	}
    18  	getMtasReturns struct {
    19  		result1 []*models.Mta
    20  		result2 error
    21  	}
    22  	getMtasReturnsOnCall map[int]struct {
    23  		result1 []*models.Mta
    24  		result2 error
    25  	}
    26  
    27  	GetMtasForThisSpaceStub        func(name, namespace *string) ([]*models.Mta, error)
    28  	getMtasForThisSpaceMutex       sync.RWMutex
    29  	getMtasForThisSpaceArgsForCall []struct {
    30  		name      *string
    31  		namespace *string
    32  	}
    33  	getMtasForThisSpaceReturns struct {
    34  		result1 []*models.Mta
    35  		result2 error
    36  	}
    37  	getMtasForThisSpaceReturnsOnCall map[int]struct {
    38  		result1 []*models.Mta
    39  		result2 error
    40  	}
    41  
    42  	invocations      map[string][][]interface{}
    43  	invocationsMutex sync.RWMutex
    44  }
    45  
    46  func (fake FakeMtaV2ClientOperations) GetMtas(name, namespace *string, spaceGuid string) ([]*models.Mta, error) {
    47  	fake.getMtasMutex.Lock()
    48  	ret, specificReturn := fake.getMtasReturnsOnCall[len(fake.getMtasArgsForCall)]
    49  	fake.getMtasArgsForCall = append(fake.getMtasArgsForCall, struct {
    50  		name      *string
    51  		namespace *string
    52  		spaceGuid string
    53  	}{name, namespace, spaceGuid})
    54  	fake.recordInvocation("GetMtas", []interface{}{name, namespace, spaceGuid})
    55  	fake.getMtasMutex.Unlock()
    56  	if fake.GetMtasStub != nil {
    57  		return fake.GetMtasStub(name, namespace, spaceGuid)
    58  	}
    59  	if specificReturn {
    60  		return ret.result1, ret.result2
    61  	}
    62  	return fake.getMtasReturns.result1, fake.getMtasReturns.result2
    63  }
    64  
    65  func (fake *FakeMtaV2ClientOperations) GetMtasCallCount() int {
    66  	fake.getMtasMutex.RLock()
    67  	defer fake.getMtasMutex.RUnlock()
    68  	return len(fake.getMtasArgsForCall)
    69  }
    70  
    71  func (fake *FakeMtaV2ClientOperations) GetMtasArgsForCall(i int) (*string, *string, string) {
    72  	fake.getMtasMutex.RLock()
    73  	defer fake.getMtasMutex.RUnlock()
    74  	return fake.getMtasArgsForCall[i].name, fake.getMtasArgsForCall[i].namespace, fake.getMtasArgsForCall[i].spaceGuid
    75  }
    76  
    77  func (fake *FakeMtaV2ClientOperations) GetMtasReturns(result1 []*models.Mta, result2 error) {
    78  	fake.GetMtasStub = nil
    79  	fake.getMtasReturns = struct {
    80  		result1 []*models.Mta
    81  		result2 error
    82  	}{result1, result2}
    83  }
    84  
    85  func (fake *FakeMtaV2ClientOperations) GetMtasReturnsOnCall(i int, result1 []*models.Mta, result2 error) {
    86  	fake.GetMtasStub = nil
    87  	if fake.getMtasReturnsOnCall == nil {
    88  		fake.getMtasReturnsOnCall = make(map[int]struct {
    89  			result1 []*models.Mta
    90  			result2 error
    91  		})
    92  	}
    93  	fake.getMtasReturnsOnCall[i] = struct {
    94  		result1 []*models.Mta
    95  		result2 error
    96  	}{result1, result2}
    97  }
    98  
    99  func (fake FakeMtaV2ClientOperations) GetMtasForThisSpace(name, namespace *string) ([]*models.Mta, error) {
   100  	fake.getMtasForThisSpaceMutex.Lock()
   101  	ret, specificReturn := fake.getMtasForThisSpaceReturnsOnCall[len(fake.getMtasForThisSpaceArgsForCall)]
   102  	fake.getMtasForThisSpaceArgsForCall = append(fake.getMtasForThisSpaceArgsForCall, struct {
   103  		name      *string
   104  		namespace *string
   105  	}{name, namespace})
   106  	fake.recordInvocation("GetMtasForThisSpace", []interface{}{name, namespace})
   107  	fake.getMtasForThisSpaceMutex.Unlock()
   108  	if fake.GetMtasForThisSpaceStub != nil {
   109  		return fake.GetMtasForThisSpaceStub(name, namespace)
   110  	}
   111  	if specificReturn {
   112  		return ret.result1, ret.result2
   113  	}
   114  	return fake.getMtasForThisSpaceReturns.result1, fake.getMtasForThisSpaceReturns.result2
   115  }
   116  
   117  func (fake *FakeMtaV2ClientOperations) GetMtasForThisSpaceCallCount() int {
   118  	fake.getMtasForThisSpaceMutex.RLock()
   119  	defer fake.getMtasForThisSpaceMutex.RUnlock()
   120  	return len(fake.getMtasForThisSpaceArgsForCall)
   121  }
   122  
   123  func (fake *FakeMtaV2ClientOperations) GetMtasForThisSpaceArgsForCall(i int) (*string, *string) {
   124  	fake.getMtasForThisSpaceMutex.RLock()
   125  	defer fake.getMtasForThisSpaceMutex.RUnlock()
   126  	return fake.getMtasForThisSpaceArgsForCall[i].name, fake.getMtasForThisSpaceArgsForCall[i].namespace
   127  }
   128  
   129  func (fake *FakeMtaV2ClientOperations) GetMtasForThisSpaceReturns(result1 []*models.Mta, result2 error) {
   130  	fake.GetMtasForThisSpaceStub = nil
   131  	fake.getMtasForThisSpaceReturns = struct {
   132  		result1 []*models.Mta
   133  		result2 error
   134  	}{result1, result2}
   135  }
   136  
   137  func (fake *FakeMtaV2ClientOperations) GetMtasForThisSpaceReturnsOnCall(i int, result1 []*models.Mta, result2 error) {
   138  	fake.GetMtasForThisSpaceStub = nil
   139  	if fake.getMtasForThisSpaceReturnsOnCall == nil {
   140  		fake.getMtasForThisSpaceReturnsOnCall = make(map[int]struct {
   141  			result1 []*models.Mta
   142  			result2 error
   143  		})
   144  	}
   145  	fake.getMtasForThisSpaceReturnsOnCall[i] = struct {
   146  		result1 []*models.Mta
   147  		result2 error
   148  	}{result1, result2}
   149  }
   150  
   151  func (fake *FakeMtaV2ClientOperations) Invocations() map[string][][]interface{} {
   152  	fake.invocationsMutex.RLock()
   153  	defer fake.invocationsMutex.RUnlock()
   154  	fake.getMtasMutex.RLock()
   155  	defer fake.getMtasMutex.RUnlock()
   156  	fake.getMtasForThisSpaceMutex.RLock()
   157  	defer fake.getMtasForThisSpaceMutex.RUnlock()
   158  	copiedInvocations := map[string][][]interface{}{}
   159  	for key, value := range fake.invocations {
   160  		copiedInvocations[key] = value
   161  	}
   162  	return copiedInvocations
   163  }
   164  
   165  func (fake *FakeMtaV2ClientOperations) recordInvocation(key string, args []interface{}) {
   166  	fake.invocationsMutex.Lock()
   167  	defer fake.invocationsMutex.Unlock()
   168  	if fake.invocations == nil {
   169  		fake.invocations = map[string][][]interface{}{}
   170  	}
   171  	if fake.invocations[key] == nil {
   172  		fake.invocations[key] = [][]interface{}{}
   173  	}
   174  	fake.invocations[key] = append(fake.invocations[key], args)
   175  }
   176  
   177  var _ mtaclient_v2.MtaV2ClientOperations = new(FakeMtaV2ClientOperations)