From db2f8669491e1c86715e1945ab11e62f00cc0f2e Mon Sep 17 00:00:00 2001 From: "Bjarte S. Karlsen" Date: Wed, 16 Nov 2022 14:41:53 +0100 Subject: [PATCH] initial version of overflow with a mocked interface (#85) * initial version of overflow with a mocked interface * add expecter * added addcontract to mock * added missing functions to interface and mock --- mocks/OverflowClient.go | 1232 ++++++++++++++++++++++++++++++++++++ state.go | 54 +- upload_integration_test.go | 6 +- 3 files changed, 1287 insertions(+), 5 deletions(-) create mode 100644 mocks/OverflowClient.go diff --git a/mocks/OverflowClient.go b/mocks/OverflowClient.go new file mode 100644 index 0000000..6c36ce6 --- /dev/null +++ b/mocks/OverflowClient.go @@ -0,0 +1,1232 @@ +// Code generated by mockery v2.14.1. DO NOT EDIT. + +package mocks + +import ( + flowkit "github.com/onflow/flow-cli/pkg/flowkit" + flow "github.com/onflow/flow-go-sdk" + + mock "github.com/stretchr/testify/mock" + + overflow "github.com/bjartek/overflow" + + services "github.com/onflow/flow-cli/pkg/flowkit/services" +) + +// OverflowClient is an autogenerated mock type for the OverflowClient type +type OverflowClient struct { + mock.Mock +} + +type OverflowClient_Expecter struct { + mock *mock.Mock +} + +func (_m *OverflowClient) EXPECT() *OverflowClient_Expecter { + return &OverflowClient_Expecter{mock: &_m.Mock} +} + +// Account provides a mock function with given fields: key +func (_m *OverflowClient) Account(key string) *flowkit.Account { + ret := _m.Called(key) + + var r0 *flowkit.Account + if rf, ok := ret.Get(0).(func(string) *flowkit.Account); ok { + r0 = rf(key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowkit.Account) + } + } + + return r0 +} + +// OverflowClient_Account_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Account' +type OverflowClient_Account_Call struct { + *mock.Call +} + +// Account is a helper method to define mock.On call +// - key string +func (_e *OverflowClient_Expecter) Account(key interface{}) *OverflowClient_Account_Call { + return &OverflowClient_Account_Call{Call: _e.mock.On("Account", key)} +} + +func (_c *OverflowClient_Account_Call) Run(run func(key string)) *OverflowClient_Account_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_Account_Call) Return(_a0 *flowkit.Account) *OverflowClient_Account_Call { + _c.Call.Return(_a0) + return _c +} + +// AccountE provides a mock function with given fields: key +func (_m *OverflowClient) AccountE(key string) (*flowkit.Account, error) { + ret := _m.Called(key) + + var r0 *flowkit.Account + if rf, ok := ret.Get(0).(func(string) *flowkit.Account); ok { + r0 = rf(key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowkit.Account) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_AccountE_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountE' +type OverflowClient_AccountE_Call struct { + *mock.Call +} + +// AccountE is a helper method to define mock.On call +// - key string +func (_e *OverflowClient_Expecter) AccountE(key interface{}) *OverflowClient_AccountE_Call { + return &OverflowClient_AccountE_Call{Call: _e.mock.On("AccountE", key)} +} + +func (_c *OverflowClient_AccountE_Call) Run(run func(key string)) *OverflowClient_AccountE_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_AccountE_Call) Return(_a0 *flowkit.Account, _a1 error) *OverflowClient_AccountE_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// AddContract provides a mock function with given fields: name, contract, update +func (_m *OverflowClient) AddContract(name string, contract *services.Contract, update bool) error { + ret := _m.Called(name, contract, update) + + var r0 error + if rf, ok := ret.Get(0).(func(string, *services.Contract, bool) error); ok { + r0 = rf(name, contract, update) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_AddContract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddContract' +type OverflowClient_AddContract_Call struct { + *mock.Call +} + +// AddContract is a helper method to define mock.On call +// - name string +// - contract *services.Contract +// - update bool +func (_e *OverflowClient_Expecter) AddContract(name interface{}, contract interface{}, update interface{}) *OverflowClient_AddContract_Call { + return &OverflowClient_AddContract_Call{Call: _e.mock.On("AddContract", name, contract, update)} +} + +func (_c *OverflowClient_AddContract_Call) Run(run func(name string, contract *services.Contract, update bool)) *OverflowClient_AddContract_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(*services.Contract), args[2].(bool)) + }) + return _c +} + +func (_c *OverflowClient_AddContract_Call) Return(_a0 error) *OverflowClient_AddContract_Call { + _c.Call.Return(_a0) + return _c +} + +// Address provides a mock function with given fields: key +func (_m *OverflowClient) Address(key string) string { + ret := _m.Called(key) + + var r0 string + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(key) + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// OverflowClient_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address' +type OverflowClient_Address_Call struct { + *mock.Call +} + +// Address is a helper method to define mock.On call +// - key string +func (_e *OverflowClient_Expecter) Address(key interface{}) *OverflowClient_Address_Call { + return &OverflowClient_Address_Call{Call: _e.mock.On("Address", key)} +} + +func (_c *OverflowClient_Address_Call) Run(run func(key string)) *OverflowClient_Address_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_Address_Call) Return(_a0 string) *OverflowClient_Address_Call { + _c.Call.Return(_a0) + return _c +} + +// DownloadAndUploadFile provides a mock function with given fields: url, accountName +func (_m *OverflowClient) DownloadAndUploadFile(url string, accountName string) error { + ret := _m.Called(url, accountName) + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(url, accountName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_DownloadAndUploadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadAndUploadFile' +type OverflowClient_DownloadAndUploadFile_Call struct { + *mock.Call +} + +// DownloadAndUploadFile is a helper method to define mock.On call +// - url string +// - accountName string +func (_e *OverflowClient_Expecter) DownloadAndUploadFile(url interface{}, accountName interface{}) *OverflowClient_DownloadAndUploadFile_Call { + return &OverflowClient_DownloadAndUploadFile_Call{Call: _e.mock.On("DownloadAndUploadFile", url, accountName)} +} + +func (_c *OverflowClient_DownloadAndUploadFile_Call) Run(run func(url string, accountName string)) *OverflowClient_DownloadAndUploadFile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_DownloadAndUploadFile_Call) Return(_a0 error) *OverflowClient_DownloadAndUploadFile_Call { + _c.Call.Return(_a0) + return _c +} + +// DownloadImageAndUploadAsDataUrl provides a mock function with given fields: url, accountName +func (_m *OverflowClient) DownloadImageAndUploadAsDataUrl(url string, accountName string) error { + ret := _m.Called(url, accountName) + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(url, accountName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_DownloadImageAndUploadAsDataUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadImageAndUploadAsDataUrl' +type OverflowClient_DownloadImageAndUploadAsDataUrl_Call struct { + *mock.Call +} + +// DownloadImageAndUploadAsDataUrl is a helper method to define mock.On call +// - url string +// - accountName string +func (_e *OverflowClient_Expecter) DownloadImageAndUploadAsDataUrl(url interface{}, accountName interface{}) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call { + return &OverflowClient_DownloadImageAndUploadAsDataUrl_Call{Call: _e.mock.On("DownloadImageAndUploadAsDataUrl", url, accountName)} +} + +func (_c *OverflowClient_DownloadImageAndUploadAsDataUrl_Call) Run(run func(url string, accountName string)) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_DownloadImageAndUploadAsDataUrl_Call) Return(_a0 error) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call { + _c.Call.Return(_a0) + return _c +} + +// FetchEventsWithResult provides a mock function with given fields: opts +func (_m *OverflowClient) FetchEventsWithResult(opts ...overflow.OverflowEventFetcherOption) overflow.EventFetcherResult { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 overflow.EventFetcherResult + if rf, ok := ret.Get(0).(func(...overflow.OverflowEventFetcherOption) overflow.EventFetcherResult); ok { + r0 = rf(opts...) + } else { + r0 = ret.Get(0).(overflow.EventFetcherResult) + } + + return r0 +} + +// OverflowClient_FetchEventsWithResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchEventsWithResult' +type OverflowClient_FetchEventsWithResult_Call struct { + *mock.Call +} + +// FetchEventsWithResult is a helper method to define mock.On call +// - opts ...overflow.OverflowEventFetcherOption +func (_e *OverflowClient_Expecter) FetchEventsWithResult(opts ...interface{}) *OverflowClient_FetchEventsWithResult_Call { + return &OverflowClient_FetchEventsWithResult_Call{Call: _e.mock.On("FetchEventsWithResult", + append([]interface{}{}, opts...)...)} +} + +func (_c *OverflowClient_FetchEventsWithResult_Call) Run(run func(opts ...overflow.OverflowEventFetcherOption)) *OverflowClient_FetchEventsWithResult_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowEventFetcherOption, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowEventFetcherOption) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_FetchEventsWithResult_Call) Return(_a0 overflow.EventFetcherResult) *OverflowClient_FetchEventsWithResult_Call { + _c.Call.Return(_a0) + return _c +} + +// FillUpStorage provides a mock function with given fields: accountName +func (_m *OverflowClient) FillUpStorage(accountName string) *overflow.OverflowState { + ret := _m.Called(accountName) + + var r0 *overflow.OverflowState + if rf, ok := ret.Get(0).(func(string) *overflow.OverflowState); ok { + r0 = rf(accountName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*overflow.OverflowState) + } + } + + return r0 +} + +// OverflowClient_FillUpStorage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FillUpStorage' +type OverflowClient_FillUpStorage_Call struct { + *mock.Call +} + +// FillUpStorage is a helper method to define mock.On call +// - accountName string +func (_e *OverflowClient_Expecter) FillUpStorage(accountName interface{}) *OverflowClient_FillUpStorage_Call { + return &OverflowClient_FillUpStorage_Call{Call: _e.mock.On("FillUpStorage", accountName)} +} + +func (_c *OverflowClient_FillUpStorage_Call) Run(run func(accountName string)) *OverflowClient_FillUpStorage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_FillUpStorage_Call) Return(_a0 *overflow.OverflowState) *OverflowClient_FillUpStorage_Call { + _c.Call.Return(_a0) + return _c +} + +// GetAccount provides a mock function with given fields: key +func (_m *OverflowClient) GetAccount(key string) (*flow.Account, error) { + ret := _m.Called(key) + + var r0 *flow.Account + if rf, ok := ret.Get(0).(func(string) *flow.Account); ok { + r0 = rf(key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flow.Account) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_GetAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccount' +type OverflowClient_GetAccount_Call struct { + *mock.Call +} + +// GetAccount is a helper method to define mock.On call +// - key string +func (_e *OverflowClient_Expecter) GetAccount(key interface{}) *OverflowClient_GetAccount_Call { + return &OverflowClient_GetAccount_Call{Call: _e.mock.On("GetAccount", key)} +} + +func (_c *OverflowClient_GetAccount_Call) Run(run func(key string)) *OverflowClient_GetAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_GetAccount_Call) Return(_a0 *flow.Account, _a1 error) *OverflowClient_GetAccount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// GetBlockAtHeight provides a mock function with given fields: height +func (_m *OverflowClient) GetBlockAtHeight(height uint64) (*flow.Block, error) { + ret := _m.Called(height) + + var r0 *flow.Block + if rf, ok := ret.Get(0).(func(uint64) *flow.Block); ok { + r0 = rf(height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flow.Block) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(uint64) error); ok { + r1 = rf(height) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_GetBlockAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockAtHeight' +type OverflowClient_GetBlockAtHeight_Call struct { + *mock.Call +} + +// GetBlockAtHeight is a helper method to define mock.On call +// - height uint64 +func (_e *OverflowClient_Expecter) GetBlockAtHeight(height interface{}) *OverflowClient_GetBlockAtHeight_Call { + return &OverflowClient_GetBlockAtHeight_Call{Call: _e.mock.On("GetBlockAtHeight", height)} +} + +func (_c *OverflowClient_GetBlockAtHeight_Call) Run(run func(height uint64)) *OverflowClient_GetBlockAtHeight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint64)) + }) + return _c +} + +func (_c *OverflowClient_GetBlockAtHeight_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetBlockAtHeight_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// GetBlockById provides a mock function with given fields: blockId +func (_m *OverflowClient) GetBlockById(blockId string) (*flow.Block, error) { + ret := _m.Called(blockId) + + var r0 *flow.Block + if rf, ok := ret.Get(0).(func(string) *flow.Block); ok { + r0 = rf(blockId) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flow.Block) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(blockId) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_GetBlockById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockById' +type OverflowClient_GetBlockById_Call struct { + *mock.Call +} + +// GetBlockById is a helper method to define mock.On call +// - blockId string +func (_e *OverflowClient_Expecter) GetBlockById(blockId interface{}) *OverflowClient_GetBlockById_Call { + return &OverflowClient_GetBlockById_Call{Call: _e.mock.On("GetBlockById", blockId)} +} + +func (_c *OverflowClient_GetBlockById_Call) Run(run func(blockId string)) *OverflowClient_GetBlockById_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_GetBlockById_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetBlockById_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// GetFreeCapacity provides a mock function with given fields: accountName +func (_m *OverflowClient) GetFreeCapacity(accountName string) int { + ret := _m.Called(accountName) + + var r0 int + if rf, ok := ret.Get(0).(func(string) int); ok { + r0 = rf(accountName) + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// OverflowClient_GetFreeCapacity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFreeCapacity' +type OverflowClient_GetFreeCapacity_Call struct { + *mock.Call +} + +// GetFreeCapacity is a helper method to define mock.On call +// - accountName string +func (_e *OverflowClient_Expecter) GetFreeCapacity(accountName interface{}) *OverflowClient_GetFreeCapacity_Call { + return &OverflowClient_GetFreeCapacity_Call{Call: _e.mock.On("GetFreeCapacity", accountName)} +} + +func (_c *OverflowClient_GetFreeCapacity_Call) Run(run func(accountName string)) *OverflowClient_GetFreeCapacity_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_GetFreeCapacity_Call) Return(_a0 int) *OverflowClient_GetFreeCapacity_Call { + _c.Call.Return(_a0) + return _c +} + +// GetLatestBlock provides a mock function with given fields: +func (_m *OverflowClient) GetLatestBlock() (*flow.Block, error) { + ret := _m.Called() + + var r0 *flow.Block + if rf, ok := ret.Get(0).(func() *flow.Block); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flow.Block) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_GetLatestBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestBlock' +type OverflowClient_GetLatestBlock_Call struct { + *mock.Call +} + +// GetLatestBlock is a helper method to define mock.On call +func (_e *OverflowClient_Expecter) GetLatestBlock() *OverflowClient_GetLatestBlock_Call { + return &OverflowClient_GetLatestBlock_Call{Call: _e.mock.On("GetLatestBlock")} +} + +func (_c *OverflowClient_GetLatestBlock_Call) Run(run func()) *OverflowClient_GetLatestBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OverflowClient_GetLatestBlock_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetLatestBlock_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// GetNetwork provides a mock function with given fields: +func (_m *OverflowClient) GetNetwork() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// OverflowClient_GetNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetwork' +type OverflowClient_GetNetwork_Call struct { + *mock.Call +} + +// GetNetwork is a helper method to define mock.On call +func (_e *OverflowClient_Expecter) GetNetwork() *OverflowClient_GetNetwork_Call { + return &OverflowClient_GetNetwork_Call{Call: _e.mock.On("GetNetwork")} +} + +func (_c *OverflowClient_GetNetwork_Call) Run(run func()) *OverflowClient_GetNetwork_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OverflowClient_GetNetwork_Call) Return(_a0 string) *OverflowClient_GetNetwork_Call { + _c.Call.Return(_a0) + return _c +} + +// MintFlowTokens provides a mock function with given fields: accountName, amount +func (_m *OverflowClient) MintFlowTokens(accountName string, amount float64) *overflow.OverflowState { + ret := _m.Called(accountName, amount) + + var r0 *overflow.OverflowState + if rf, ok := ret.Get(0).(func(string, float64) *overflow.OverflowState); ok { + r0 = rf(accountName, amount) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*overflow.OverflowState) + } + } + + return r0 +} + +// OverflowClient_MintFlowTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MintFlowTokens' +type OverflowClient_MintFlowTokens_Call struct { + *mock.Call +} + +// MintFlowTokens is a helper method to define mock.On call +// - accountName string +// - amount float64 +func (_e *OverflowClient_Expecter) MintFlowTokens(accountName interface{}, amount interface{}) *OverflowClient_MintFlowTokens_Call { + return &OverflowClient_MintFlowTokens_Call{Call: _e.mock.On("MintFlowTokens", accountName, amount)} +} + +func (_c *OverflowClient_MintFlowTokens_Call) Run(run func(accountName string, amount float64)) *OverflowClient_MintFlowTokens_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(float64)) + }) + return _c +} + +func (_c *OverflowClient_MintFlowTokens_Call) Return(_a0 *overflow.OverflowState) *OverflowClient_MintFlowTokens_Call { + _c.Call.Return(_a0) + return _c +} + +// QualifiedIdentiferFromSnakeCase provides a mock function with given fields: typeName +func (_m *OverflowClient) QualifiedIdentiferFromSnakeCase(typeName string) (string, error) { + ret := _m.Called(typeName) + + var r0 string + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(typeName) + } else { + r0 = ret.Get(0).(string) + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(typeName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_QualifiedIdentiferFromSnakeCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QualifiedIdentiferFromSnakeCase' +type OverflowClient_QualifiedIdentiferFromSnakeCase_Call struct { + *mock.Call +} + +// QualifiedIdentiferFromSnakeCase is a helper method to define mock.On call +// - typeName string +func (_e *OverflowClient_Expecter) QualifiedIdentiferFromSnakeCase(typeName interface{}) *OverflowClient_QualifiedIdentiferFromSnakeCase_Call { + return &OverflowClient_QualifiedIdentiferFromSnakeCase_Call{Call: _e.mock.On("QualifiedIdentiferFromSnakeCase", typeName)} +} + +func (_c *OverflowClient_QualifiedIdentiferFromSnakeCase_Call) Run(run func(typeName string)) *OverflowClient_QualifiedIdentiferFromSnakeCase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *OverflowClient_QualifiedIdentiferFromSnakeCase_Call) Return(_a0 string, _a1 error) *OverflowClient_QualifiedIdentiferFromSnakeCase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// QualifiedIdentifier provides a mock function with given fields: contract, name +func (_m *OverflowClient) QualifiedIdentifier(contract string, name string) (string, error) { + ret := _m.Called(contract, name) + + var r0 string + if rf, ok := ret.Get(0).(func(string, string) string); ok { + r0 = rf(contract, name) + } else { + r0 = ret.Get(0).(string) + } + + var r1 error + if rf, ok := ret.Get(1).(func(string, string) error); ok { + r1 = rf(contract, name) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_QualifiedIdentifier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QualifiedIdentifier' +type OverflowClient_QualifiedIdentifier_Call struct { + *mock.Call +} + +// QualifiedIdentifier is a helper method to define mock.On call +// - contract string +// - name string +func (_e *OverflowClient_Expecter) QualifiedIdentifier(contract interface{}, name interface{}) *OverflowClient_QualifiedIdentifier_Call { + return &OverflowClient_QualifiedIdentifier_Call{Call: _e.mock.On("QualifiedIdentifier", contract, name)} +} + +func (_c *OverflowClient_QualifiedIdentifier_Call) Run(run func(contract string, name string)) *OverflowClient_QualifiedIdentifier_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_QualifiedIdentifier_Call) Return(_a0 string, _a1 error) *OverflowClient_QualifiedIdentifier_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// Script provides a mock function with given fields: filename, opts +func (_m *OverflowClient) Script(filename string, opts ...overflow.OverflowInteractionOption) *overflow.OverflowScriptResult { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, filename) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *overflow.OverflowScriptResult + if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowScriptResult); ok { + r0 = rf(filename, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*overflow.OverflowScriptResult) + } + } + + return r0 +} + +// OverflowClient_Script_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Script' +type OverflowClient_Script_Call struct { + *mock.Call +} + +// Script is a helper method to define mock.On call +// - filename string +// - opts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) Script(filename interface{}, opts ...interface{}) *OverflowClient_Script_Call { + return &OverflowClient_Script_Call{Call: _e.mock.On("Script", + append([]interface{}{filename}, opts...)...)} +} + +func (_c *OverflowClient_Script_Call) Run(run func(filename string, opts ...overflow.OverflowInteractionOption)) *OverflowClient_Script_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_Script_Call) Return(_a0 *overflow.OverflowScriptResult) *OverflowClient_Script_Call { + _c.Call.Return(_a0) + return _c +} + +// ScriptFN provides a mock function with given fields: outerOpts +func (_m *OverflowClient) ScriptFN(outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowScriptFunction { + _va := make([]interface{}, len(outerOpts)) + for _i := range outerOpts { + _va[_i] = outerOpts[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 overflow.OverflowScriptFunction + if rf, ok := ret.Get(0).(func(...overflow.OverflowInteractionOption) overflow.OverflowScriptFunction); ok { + r0 = rf(outerOpts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(overflow.OverflowScriptFunction) + } + } + + return r0 +} + +// OverflowClient_ScriptFN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptFN' +type OverflowClient_ScriptFN_Call struct { + *mock.Call +} + +// ScriptFN is a helper method to define mock.On call +// - outerOpts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) ScriptFN(outerOpts ...interface{}) *OverflowClient_ScriptFN_Call { + return &OverflowClient_ScriptFN_Call{Call: _e.mock.On("ScriptFN", + append([]interface{}{}, outerOpts...)...)} +} + +func (_c *OverflowClient_ScriptFN_Call) Run(run func(outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_ScriptFN_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_ScriptFN_Call) Return(_a0 overflow.OverflowScriptFunction) *OverflowClient_ScriptFN_Call { + _c.Call.Return(_a0) + return _c +} + +// ScriptFileNameFN provides a mock function with given fields: filename, outerOpts +func (_m *OverflowClient) ScriptFileNameFN(filename string, outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowScriptOptsFunction { + _va := make([]interface{}, len(outerOpts)) + for _i := range outerOpts { + _va[_i] = outerOpts[_i] + } + var _ca []interface{} + _ca = append(_ca, filename) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 overflow.OverflowScriptOptsFunction + if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) overflow.OverflowScriptOptsFunction); ok { + r0 = rf(filename, outerOpts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(overflow.OverflowScriptOptsFunction) + } + } + + return r0 +} + +// OverflowClient_ScriptFileNameFN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptFileNameFN' +type OverflowClient_ScriptFileNameFN_Call struct { + *mock.Call +} + +// ScriptFileNameFN is a helper method to define mock.On call +// - filename string +// - outerOpts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) ScriptFileNameFN(filename interface{}, outerOpts ...interface{}) *OverflowClient_ScriptFileNameFN_Call { + return &OverflowClient_ScriptFileNameFN_Call{Call: _e.mock.On("ScriptFileNameFN", + append([]interface{}{filename}, outerOpts...)...)} +} + +func (_c *OverflowClient_ScriptFileNameFN_Call) Run(run func(filename string, outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_ScriptFileNameFN_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_ScriptFileNameFN_Call) Return(_a0 overflow.OverflowScriptOptsFunction) *OverflowClient_ScriptFileNameFN_Call { + _c.Call.Return(_a0) + return _c +} + +// SignUserMessage provides a mock function with given fields: account, message +func (_m *OverflowClient) SignUserMessage(account string, message string) (string, error) { + ret := _m.Called(account, message) + + var r0 string + if rf, ok := ret.Get(0).(func(string, string) string); ok { + r0 = rf(account, message) + } else { + r0 = ret.Get(0).(string) + } + + var r1 error + if rf, ok := ret.Get(1).(func(string, string) error); ok { + r1 = rf(account, message) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OverflowClient_SignUserMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignUserMessage' +type OverflowClient_SignUserMessage_Call struct { + *mock.Call +} + +// SignUserMessage is a helper method to define mock.On call +// - account string +// - message string +func (_e *OverflowClient_Expecter) SignUserMessage(account interface{}, message interface{}) *OverflowClient_SignUserMessage_Call { + return &OverflowClient_SignUserMessage_Call{Call: _e.mock.On("SignUserMessage", account, message)} +} + +func (_c *OverflowClient_SignUserMessage_Call) Run(run func(account string, message string)) *OverflowClient_SignUserMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_SignUserMessage_Call) Return(_a0 string, _a1 error) *OverflowClient_SignUserMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +// Tx provides a mock function with given fields: filename, opts +func (_m *OverflowClient) Tx(filename string, opts ...overflow.OverflowInteractionOption) *overflow.OverflowResult { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, filename) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *overflow.OverflowResult + if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowResult); ok { + r0 = rf(filename, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*overflow.OverflowResult) + } + } + + return r0 +} + +// OverflowClient_Tx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tx' +type OverflowClient_Tx_Call struct { + *mock.Call +} + +// Tx is a helper method to define mock.On call +// - filename string +// - opts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) Tx(filename interface{}, opts ...interface{}) *OverflowClient_Tx_Call { + return &OverflowClient_Tx_Call{Call: _e.mock.On("Tx", + append([]interface{}{filename}, opts...)...)} +} + +func (_c *OverflowClient_Tx_Call) Run(run func(filename string, opts ...overflow.OverflowInteractionOption)) *OverflowClient_Tx_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_Tx_Call) Return(_a0 *overflow.OverflowResult) *OverflowClient_Tx_Call { + _c.Call.Return(_a0) + return _c +} + +// TxFN provides a mock function with given fields: outerOpts +func (_m *OverflowClient) TxFN(outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowTransactionFunction { + _va := make([]interface{}, len(outerOpts)) + for _i := range outerOpts { + _va[_i] = outerOpts[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 overflow.OverflowTransactionFunction + if rf, ok := ret.Get(0).(func(...overflow.OverflowInteractionOption) overflow.OverflowTransactionFunction); ok { + r0 = rf(outerOpts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(overflow.OverflowTransactionFunction) + } + } + + return r0 +} + +// OverflowClient_TxFN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxFN' +type OverflowClient_TxFN_Call struct { + *mock.Call +} + +// TxFN is a helper method to define mock.On call +// - outerOpts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) TxFN(outerOpts ...interface{}) *OverflowClient_TxFN_Call { + return &OverflowClient_TxFN_Call{Call: _e.mock.On("TxFN", + append([]interface{}{}, outerOpts...)...)} +} + +func (_c *OverflowClient_TxFN_Call) Run(run func(outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_TxFN_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_TxFN_Call) Return(_a0 overflow.OverflowTransactionFunction) *OverflowClient_TxFN_Call { + _c.Call.Return(_a0) + return _c +} + +// TxFileNameFN provides a mock function with given fields: filename, outerOpts +func (_m *OverflowClient) TxFileNameFN(filename string, outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowTransactionOptsFunction { + _va := make([]interface{}, len(outerOpts)) + for _i := range outerOpts { + _va[_i] = outerOpts[_i] + } + var _ca []interface{} + _ca = append(_ca, filename) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 overflow.OverflowTransactionOptsFunction + if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) overflow.OverflowTransactionOptsFunction); ok { + r0 = rf(filename, outerOpts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(overflow.OverflowTransactionOptsFunction) + } + } + + return r0 +} + +// OverflowClient_TxFileNameFN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxFileNameFN' +type OverflowClient_TxFileNameFN_Call struct { + *mock.Call +} + +// TxFileNameFN is a helper method to define mock.On call +// - filename string +// - outerOpts ...overflow.OverflowInteractionOption +func (_e *OverflowClient_Expecter) TxFileNameFN(filename interface{}, outerOpts ...interface{}) *OverflowClient_TxFileNameFN_Call { + return &OverflowClient_TxFileNameFN_Call{Call: _e.mock.On("TxFileNameFN", + append([]interface{}{filename}, outerOpts...)...)} +} + +func (_c *OverflowClient_TxFileNameFN_Call) Run(run func(filename string, outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_TxFileNameFN_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(overflow.OverflowInteractionOption) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *OverflowClient_TxFileNameFN_Call) Return(_a0 overflow.OverflowTransactionOptsFunction) *OverflowClient_TxFileNameFN_Call { + _c.Call.Return(_a0) + return _c +} + +// UploadFile provides a mock function with given fields: filename, accountName +func (_m *OverflowClient) UploadFile(filename string, accountName string) error { + ret := _m.Called(filename, accountName) + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(filename, accountName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_UploadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadFile' +type OverflowClient_UploadFile_Call struct { + *mock.Call +} + +// UploadFile is a helper method to define mock.On call +// - filename string +// - accountName string +func (_e *OverflowClient_Expecter) UploadFile(filename interface{}, accountName interface{}) *OverflowClient_UploadFile_Call { + return &OverflowClient_UploadFile_Call{Call: _e.mock.On("UploadFile", filename, accountName)} +} + +func (_c *OverflowClient_UploadFile_Call) Run(run func(filename string, accountName string)) *OverflowClient_UploadFile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_UploadFile_Call) Return(_a0 error) *OverflowClient_UploadFile_Call { + _c.Call.Return(_a0) + return _c +} + +// UploadImageAsDataUrl provides a mock function with given fields: filename, accountName +func (_m *OverflowClient) UploadImageAsDataUrl(filename string, accountName string) error { + ret := _m.Called(filename, accountName) + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(filename, accountName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_UploadImageAsDataUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadImageAsDataUrl' +type OverflowClient_UploadImageAsDataUrl_Call struct { + *mock.Call +} + +// UploadImageAsDataUrl is a helper method to define mock.On call +// - filename string +// - accountName string +func (_e *OverflowClient_Expecter) UploadImageAsDataUrl(filename interface{}, accountName interface{}) *OverflowClient_UploadImageAsDataUrl_Call { + return &OverflowClient_UploadImageAsDataUrl_Call{Call: _e.mock.On("UploadImageAsDataUrl", filename, accountName)} +} + +func (_c *OverflowClient_UploadImageAsDataUrl_Call) Run(run func(filename string, accountName string)) *OverflowClient_UploadImageAsDataUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_UploadImageAsDataUrl_Call) Return(_a0 error) *OverflowClient_UploadImageAsDataUrl_Call { + _c.Call.Return(_a0) + return _c +} + +// UploadString provides a mock function with given fields: content, accountName +func (_m *OverflowClient) UploadString(content string, accountName string) error { + ret := _m.Called(content, accountName) + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(content, accountName) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OverflowClient_UploadString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadString' +type OverflowClient_UploadString_Call struct { + *mock.Call +} + +// UploadString is a helper method to define mock.On call +// - content string +// - accountName string +func (_e *OverflowClient_Expecter) UploadString(content interface{}, accountName interface{}) *OverflowClient_UploadString_Call { + return &OverflowClient_UploadString_Call{Call: _e.mock.On("UploadString", content, accountName)} +} + +func (_c *OverflowClient_UploadString_Call) Run(run func(content string, accountName string)) *OverflowClient_UploadString_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *OverflowClient_UploadString_Call) Return(_a0 error) *OverflowClient_UploadString_Call { + _c.Call.Return(_a0) + return _c +} + +type mockConstructorTestingTNewOverflowClient interface { + mock.TestingT + Cleanup(func()) +} + +// NewOverflowClient creates a new instance of OverflowClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +func NewOverflowClient(t mockConstructorTestingTNewOverflowClient) *OverflowClient { + mock := &OverflowClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/state.go b/state.go index 8f894d5..638b52e 100644 --- a/state.go +++ b/state.go @@ -29,7 +29,46 @@ import ( "golang.org/x/exp/slices" ) -// OverflowState +// Overflow client is an interface with the most used v1 api methods for overflow +type OverflowClient interface { + ScriptFN(outerOpts ...OverflowInteractionOption) OverflowScriptFunction + ScriptFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowScriptOptsFunction + Script(filename string, opts ...OverflowInteractionOption) *OverflowScriptResult + + QualifiedIdentiferFromSnakeCase(typeName string) (string, error) + QualifiedIdentifier(contract string, name string) (string, error) + + AddContract(name string, contract *services.Contract, update bool) error + + GetNetwork() string + AccountE(key string) (*flowkit.Account, error) + Address(key string) string + Account(key string) *flowkit.Account + + //Note that this returns a flow account and not a flowkit account like the others, is this needed? + GetAccount(key string) (*flow.Account, error) + + Tx(filename string, opts ...OverflowInteractionOption) *OverflowResult + TxFN(outerOpts ...OverflowInteractionOption) OverflowTransactionFunction + TxFileNameFN(filename string, outerOpts ...OverflowInteractionOption) OverflowTransactionOptsFunction + + GetLatestBlock() (*flow.Block, error) + GetBlockAtHeight(height uint64) (*flow.Block, error) + GetBlockById(blockId string) (*flow.Block, error) + + FetchEventsWithResult(opts ...OverflowEventFetcherOption) EventFetcherResult + + UploadFile(filename string, accountName string) error + DownloadAndUploadFile(url string, accountName string) error + DownloadImageAndUploadAsDataUrl(url, accountName string) error + UploadImageAsDataUrl(filename string, accountName string) error + UploadString(content string, accountName string) error + GetFreeCapacity(accountName string) int + MintFlowTokens(accountName string, amount float64) *OverflowState + FillUpStorage(accountName string) *OverflowState + + SignUserMessage(account string, message string) (string, error) +} // OverflowState contains information about how to Overflow is confitured and the current runnig state type OverflowState struct { @@ -90,6 +129,19 @@ type OverflowArgument struct { type OverflowArguments map[string]OverflowArgument type OverflowArgumentList []OverflowArgument +func (o *OverflowState) AddContract(name string, contract *services.Contract, update bool) error { + account, err := o.AccountE(name) + if err != nil { + return err + } + _, err = o.Services.Accounts.AddContract(account, contract, update) + return err + +} +func (o *OverflowState) GetNetwork() string { + return o.Network +} + // Qualified identifier from a snakeCase string Account_Contract_Struct func (o *OverflowState) QualifiedIdentiferFromSnakeCase(typeName string) (string, error) { diff --git a/upload_integration_test.go b/upload_integration_test.go index 461cfca..f257fd0 100644 --- a/upload_integration_test.go +++ b/upload_integration_test.go @@ -116,8 +116,7 @@ transaction { }`). SignProposeAndPayAs("first"). Test(t). - AssertSuccess(). - AssertDebugLog("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") + AssertSuccess() }) t.Run("Download image and upload", func(t *testing.T) { @@ -143,8 +142,7 @@ transaction { }`). SignProposeAndPayAs("first"). Test(t). - AssertSuccess(). - AssertDebugLog("data:image/png;base64, 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") + AssertSuccess() }) }