github.com/elopio/cli@v6.21.2-0.20160902224010-ea909d1fdb2f+incompatible/cf/api/logs/logsfakes/fake_noaa_consumer.go (about)

     1  // This file was generated by counterfeiter
     2  package logsfakes
     3  
     4  import (
     5  	"sync"
     6  
     7  	"code.cloudfoundry.org/cli/cf/api/logs"
     8  	"github.com/cloudfoundry/sonde-go/events"
     9  )
    10  
    11  type FakeNoaaConsumer struct {
    12  	TailingLogsWithoutReconnectStub        func(string, string) (<-chan *events.LogMessage, <-chan error)
    13  	tailingLogsWithoutReconnectMutex       sync.RWMutex
    14  	tailingLogsWithoutReconnectArgsForCall []struct {
    15  		arg1 string
    16  		arg2 string
    17  	}
    18  	tailingLogsWithoutReconnectReturns struct {
    19  		result1 <-chan *events.LogMessage
    20  		result2 <-chan error
    21  	}
    22  	RecentLogsStub        func(appGUID string, authToken string) ([]*events.LogMessage, error)
    23  	recentLogsMutex       sync.RWMutex
    24  	recentLogsArgsForCall []struct {
    25  		appGUID   string
    26  		authToken string
    27  	}
    28  	recentLogsReturns struct {
    29  		result1 []*events.LogMessage
    30  		result2 error
    31  	}
    32  	CloseStub        func() error
    33  	closeMutex       sync.RWMutex
    34  	closeArgsForCall []struct{}
    35  	closeReturns     struct {
    36  		result1 error
    37  	}
    38  	SetOnConnectCallbackStub        func(cb func())
    39  	setOnConnectCallbackMutex       sync.RWMutex
    40  	setOnConnectCallbackArgsForCall []struct {
    41  		cb func()
    42  	}
    43  	invocations      map[string][][]interface{}
    44  	invocationsMutex sync.RWMutex
    45  }
    46  
    47  func (fake *FakeNoaaConsumer) TailingLogsWithoutReconnect(arg1 string, arg2 string) (<-chan *events.LogMessage, <-chan error) {
    48  	fake.tailingLogsWithoutReconnectMutex.Lock()
    49  	fake.tailingLogsWithoutReconnectArgsForCall = append(fake.tailingLogsWithoutReconnectArgsForCall, struct {
    50  		arg1 string
    51  		arg2 string
    52  	}{arg1, arg2})
    53  	fake.recordInvocation("TailingLogsWithoutReconnect", []interface{}{arg1, arg2})
    54  	fake.tailingLogsWithoutReconnectMutex.Unlock()
    55  	if fake.TailingLogsWithoutReconnectStub != nil {
    56  		return fake.TailingLogsWithoutReconnectStub(arg1, arg2)
    57  	} else {
    58  		return fake.tailingLogsWithoutReconnectReturns.result1, fake.tailingLogsWithoutReconnectReturns.result2
    59  	}
    60  }
    61  
    62  func (fake *FakeNoaaConsumer) TailingLogsWithoutReconnectCallCount() int {
    63  	fake.tailingLogsWithoutReconnectMutex.RLock()
    64  	defer fake.tailingLogsWithoutReconnectMutex.RUnlock()
    65  	return len(fake.tailingLogsWithoutReconnectArgsForCall)
    66  }
    67  
    68  func (fake *FakeNoaaConsumer) TailingLogsWithoutReconnectArgsForCall(i int) (string, string) {
    69  	fake.tailingLogsWithoutReconnectMutex.RLock()
    70  	defer fake.tailingLogsWithoutReconnectMutex.RUnlock()
    71  	return fake.tailingLogsWithoutReconnectArgsForCall[i].arg1, fake.tailingLogsWithoutReconnectArgsForCall[i].arg2
    72  }
    73  
    74  func (fake *FakeNoaaConsumer) TailingLogsWithoutReconnectReturns(result1 <-chan *events.LogMessage, result2 <-chan error) {
    75  	fake.TailingLogsWithoutReconnectStub = nil
    76  	fake.tailingLogsWithoutReconnectReturns = struct {
    77  		result1 <-chan *events.LogMessage
    78  		result2 <-chan error
    79  	}{result1, result2}
    80  }
    81  
    82  func (fake *FakeNoaaConsumer) RecentLogs(appGUID string, authToken string) ([]*events.LogMessage, error) {
    83  	fake.recentLogsMutex.Lock()
    84  	fake.recentLogsArgsForCall = append(fake.recentLogsArgsForCall, struct {
    85  		appGUID   string
    86  		authToken string
    87  	}{appGUID, authToken})
    88  	fake.recordInvocation("RecentLogs", []interface{}{appGUID, authToken})
    89  	fake.recentLogsMutex.Unlock()
    90  	if fake.RecentLogsStub != nil {
    91  		return fake.RecentLogsStub(appGUID, authToken)
    92  	} else {
    93  		return fake.recentLogsReturns.result1, fake.recentLogsReturns.result2
    94  	}
    95  }
    96  
    97  func (fake *FakeNoaaConsumer) RecentLogsCallCount() int {
    98  	fake.recentLogsMutex.RLock()
    99  	defer fake.recentLogsMutex.RUnlock()
   100  	return len(fake.recentLogsArgsForCall)
   101  }
   102  
   103  func (fake *FakeNoaaConsumer) RecentLogsArgsForCall(i int) (string, string) {
   104  	fake.recentLogsMutex.RLock()
   105  	defer fake.recentLogsMutex.RUnlock()
   106  	return fake.recentLogsArgsForCall[i].appGUID, fake.recentLogsArgsForCall[i].authToken
   107  }
   108  
   109  func (fake *FakeNoaaConsumer) RecentLogsReturns(result1 []*events.LogMessage, result2 error) {
   110  	fake.RecentLogsStub = nil
   111  	fake.recentLogsReturns = struct {
   112  		result1 []*events.LogMessage
   113  		result2 error
   114  	}{result1, result2}
   115  }
   116  
   117  func (fake *FakeNoaaConsumer) Close() error {
   118  	fake.closeMutex.Lock()
   119  	fake.closeArgsForCall = append(fake.closeArgsForCall, struct{}{})
   120  	fake.recordInvocation("Close", []interface{}{})
   121  	fake.closeMutex.Unlock()
   122  	if fake.CloseStub != nil {
   123  		return fake.CloseStub()
   124  	} else {
   125  		return fake.closeReturns.result1
   126  	}
   127  }
   128  
   129  func (fake *FakeNoaaConsumer) CloseCallCount() int {
   130  	fake.closeMutex.RLock()
   131  	defer fake.closeMutex.RUnlock()
   132  	return len(fake.closeArgsForCall)
   133  }
   134  
   135  func (fake *FakeNoaaConsumer) CloseReturns(result1 error) {
   136  	fake.CloseStub = nil
   137  	fake.closeReturns = struct {
   138  		result1 error
   139  	}{result1}
   140  }
   141  
   142  func (fake *FakeNoaaConsumer) SetOnConnectCallback(cb func()) {
   143  	fake.setOnConnectCallbackMutex.Lock()
   144  	fake.setOnConnectCallbackArgsForCall = append(fake.setOnConnectCallbackArgsForCall, struct {
   145  		cb func()
   146  	}{cb})
   147  	fake.recordInvocation("SetOnConnectCallback", []interface{}{cb})
   148  	fake.setOnConnectCallbackMutex.Unlock()
   149  	if fake.SetOnConnectCallbackStub != nil {
   150  		fake.SetOnConnectCallbackStub(cb)
   151  	}
   152  }
   153  
   154  func (fake *FakeNoaaConsumer) SetOnConnectCallbackCallCount() int {
   155  	fake.setOnConnectCallbackMutex.RLock()
   156  	defer fake.setOnConnectCallbackMutex.RUnlock()
   157  	return len(fake.setOnConnectCallbackArgsForCall)
   158  }
   159  
   160  func (fake *FakeNoaaConsumer) SetOnConnectCallbackArgsForCall(i int) func() {
   161  	fake.setOnConnectCallbackMutex.RLock()
   162  	defer fake.setOnConnectCallbackMutex.RUnlock()
   163  	return fake.setOnConnectCallbackArgsForCall[i].cb
   164  }
   165  
   166  func (fake *FakeNoaaConsumer) Invocations() map[string][][]interface{} {
   167  	fake.invocationsMutex.RLock()
   168  	defer fake.invocationsMutex.RUnlock()
   169  	fake.tailingLogsWithoutReconnectMutex.RLock()
   170  	defer fake.tailingLogsWithoutReconnectMutex.RUnlock()
   171  	fake.recentLogsMutex.RLock()
   172  	defer fake.recentLogsMutex.RUnlock()
   173  	fake.closeMutex.RLock()
   174  	defer fake.closeMutex.RUnlock()
   175  	fake.setOnConnectCallbackMutex.RLock()
   176  	defer fake.setOnConnectCallbackMutex.RUnlock()
   177  	return fake.invocations
   178  }
   179  
   180  func (fake *FakeNoaaConsumer) recordInvocation(key string, args []interface{}) {
   181  	fake.invocationsMutex.Lock()
   182  	defer fake.invocationsMutex.Unlock()
   183  	if fake.invocations == nil {
   184  		fake.invocations = map[string][][]interface{}{}
   185  	}
   186  	if fake.invocations[key] == nil {
   187  		fake.invocations[key] = [][]interface{}{}
   188  	}
   189  	fake.invocations[key] = append(fake.invocations[key], args)
   190  }
   191  
   192  var _ logs.NoaaConsumer = new(FakeNoaaConsumer)