github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/db/encryption/encryptionfakes/fake_strategy.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package encryptionfakes 3 4 import ( 5 "sync" 6 7 "github.com/pf-qiu/concourse/v6/atc/db/encryption" 8 ) 9 10 type FakeStrategy struct { 11 DecryptStub func(string, *string) ([]byte, error) 12 decryptMutex sync.RWMutex 13 decryptArgsForCall []struct { 14 arg1 string 15 arg2 *string 16 } 17 decryptReturns struct { 18 result1 []byte 19 result2 error 20 } 21 decryptReturnsOnCall map[int]struct { 22 result1 []byte 23 result2 error 24 } 25 EncryptStub func([]byte) (string, *string, error) 26 encryptMutex sync.RWMutex 27 encryptArgsForCall []struct { 28 arg1 []byte 29 } 30 encryptReturns struct { 31 result1 string 32 result2 *string 33 result3 error 34 } 35 encryptReturnsOnCall map[int]struct { 36 result1 string 37 result2 *string 38 result3 error 39 } 40 invocations map[string][][]interface{} 41 invocationsMutex sync.RWMutex 42 } 43 44 func (fake *FakeStrategy) Decrypt(arg1 string, arg2 *string) ([]byte, error) { 45 fake.decryptMutex.Lock() 46 ret, specificReturn := fake.decryptReturnsOnCall[len(fake.decryptArgsForCall)] 47 fake.decryptArgsForCall = append(fake.decryptArgsForCall, struct { 48 arg1 string 49 arg2 *string 50 }{arg1, arg2}) 51 fake.recordInvocation("Decrypt", []interface{}{arg1, arg2}) 52 fake.decryptMutex.Unlock() 53 if fake.DecryptStub != nil { 54 return fake.DecryptStub(arg1, arg2) 55 } 56 if specificReturn { 57 return ret.result1, ret.result2 58 } 59 fakeReturns := fake.decryptReturns 60 return fakeReturns.result1, fakeReturns.result2 61 } 62 63 func (fake *FakeStrategy) DecryptCallCount() int { 64 fake.decryptMutex.RLock() 65 defer fake.decryptMutex.RUnlock() 66 return len(fake.decryptArgsForCall) 67 } 68 69 func (fake *FakeStrategy) DecryptCalls(stub func(string, *string) ([]byte, error)) { 70 fake.decryptMutex.Lock() 71 defer fake.decryptMutex.Unlock() 72 fake.DecryptStub = stub 73 } 74 75 func (fake *FakeStrategy) DecryptArgsForCall(i int) (string, *string) { 76 fake.decryptMutex.RLock() 77 defer fake.decryptMutex.RUnlock() 78 argsForCall := fake.decryptArgsForCall[i] 79 return argsForCall.arg1, argsForCall.arg2 80 } 81 82 func (fake *FakeStrategy) DecryptReturns(result1 []byte, result2 error) { 83 fake.decryptMutex.Lock() 84 defer fake.decryptMutex.Unlock() 85 fake.DecryptStub = nil 86 fake.decryptReturns = struct { 87 result1 []byte 88 result2 error 89 }{result1, result2} 90 } 91 92 func (fake *FakeStrategy) DecryptReturnsOnCall(i int, result1 []byte, result2 error) { 93 fake.decryptMutex.Lock() 94 defer fake.decryptMutex.Unlock() 95 fake.DecryptStub = nil 96 if fake.decryptReturnsOnCall == nil { 97 fake.decryptReturnsOnCall = make(map[int]struct { 98 result1 []byte 99 result2 error 100 }) 101 } 102 fake.decryptReturnsOnCall[i] = struct { 103 result1 []byte 104 result2 error 105 }{result1, result2} 106 } 107 108 func (fake *FakeStrategy) Encrypt(arg1 []byte) (string, *string, error) { 109 var arg1Copy []byte 110 if arg1 != nil { 111 arg1Copy = make([]byte, len(arg1)) 112 copy(arg1Copy, arg1) 113 } 114 fake.encryptMutex.Lock() 115 ret, specificReturn := fake.encryptReturnsOnCall[len(fake.encryptArgsForCall)] 116 fake.encryptArgsForCall = append(fake.encryptArgsForCall, struct { 117 arg1 []byte 118 }{arg1Copy}) 119 fake.recordInvocation("Encrypt", []interface{}{arg1Copy}) 120 fake.encryptMutex.Unlock() 121 if fake.EncryptStub != nil { 122 return fake.EncryptStub(arg1) 123 } 124 if specificReturn { 125 return ret.result1, ret.result2, ret.result3 126 } 127 fakeReturns := fake.encryptReturns 128 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 129 } 130 131 func (fake *FakeStrategy) EncryptCallCount() int { 132 fake.encryptMutex.RLock() 133 defer fake.encryptMutex.RUnlock() 134 return len(fake.encryptArgsForCall) 135 } 136 137 func (fake *FakeStrategy) EncryptCalls(stub func([]byte) (string, *string, error)) { 138 fake.encryptMutex.Lock() 139 defer fake.encryptMutex.Unlock() 140 fake.EncryptStub = stub 141 } 142 143 func (fake *FakeStrategy) EncryptArgsForCall(i int) []byte { 144 fake.encryptMutex.RLock() 145 defer fake.encryptMutex.RUnlock() 146 argsForCall := fake.encryptArgsForCall[i] 147 return argsForCall.arg1 148 } 149 150 func (fake *FakeStrategy) EncryptReturns(result1 string, result2 *string, result3 error) { 151 fake.encryptMutex.Lock() 152 defer fake.encryptMutex.Unlock() 153 fake.EncryptStub = nil 154 fake.encryptReturns = struct { 155 result1 string 156 result2 *string 157 result3 error 158 }{result1, result2, result3} 159 } 160 161 func (fake *FakeStrategy) EncryptReturnsOnCall(i int, result1 string, result2 *string, result3 error) { 162 fake.encryptMutex.Lock() 163 defer fake.encryptMutex.Unlock() 164 fake.EncryptStub = nil 165 if fake.encryptReturnsOnCall == nil { 166 fake.encryptReturnsOnCall = make(map[int]struct { 167 result1 string 168 result2 *string 169 result3 error 170 }) 171 } 172 fake.encryptReturnsOnCall[i] = struct { 173 result1 string 174 result2 *string 175 result3 error 176 }{result1, result2, result3} 177 } 178 179 func (fake *FakeStrategy) Invocations() map[string][][]interface{} { 180 fake.invocationsMutex.RLock() 181 defer fake.invocationsMutex.RUnlock() 182 fake.decryptMutex.RLock() 183 defer fake.decryptMutex.RUnlock() 184 fake.encryptMutex.RLock() 185 defer fake.encryptMutex.RUnlock() 186 copiedInvocations := map[string][][]interface{}{} 187 for key, value := range fake.invocations { 188 copiedInvocations[key] = value 189 } 190 return copiedInvocations 191 } 192 193 func (fake *FakeStrategy) recordInvocation(key string, args []interface{}) { 194 fake.invocationsMutex.Lock() 195 defer fake.invocationsMutex.Unlock() 196 if fake.invocations == nil { 197 fake.invocations = map[string][][]interface{}{} 198 } 199 if fake.invocations[key] == nil { 200 fake.invocations[key] = [][]interface{}{} 201 } 202 fake.invocations[key] = append(fake.invocations[key], args) 203 } 204 205 var _ encryption.Strategy = new(FakeStrategy)