From 800132d6838aa0ecb51372b349e6a2cea7e117c6 Mon Sep 17 00:00:00 2001 From: itsscb Date: Sun, 24 Sep 2023 23:56:45 +0200 Subject: [PATCH] ft/add db.createAccountTx transaction --- api/account.go | 4 +-- api/account_test.go | 32 +++++++++++++++------- db/mock/store.go | 30 +++++++++++++++++++++ db/sqlc/store.go | 3 ++- db/sqlc/tx_create_account.go | 51 ++++++++++++++++++++++++++++++++++++ 5 files changed, 108 insertions(+), 12 deletions(-) create mode 100644 db/sqlc/tx_create_account.go diff --git a/api/account.go b/api/account.go index 6f8410b..985e3f5 100644 --- a/api/account.go +++ b/api/account.go @@ -29,7 +29,7 @@ func (server *Server) createAccount(ctx *gin.Context) { return } - arg := db.CreateAccountParams{ + arg := db.CreateAccountTxParams{ Passwordhash: req.Passwordhash, Firstname: req.Firstname, Lastname: req.Lastname, @@ -46,7 +46,7 @@ func (server *Server) createAccount(ctx *gin.Context) { }, } - account, err := server.store.CreateAccount(ctx, arg) + account, err := server.store.CreateAccountTx(ctx, arg) if err != nil { ctx.JSON(http.StatusInternalServerError, errorResponse(err)) return diff --git a/api/account_test.go b/api/account_test.go index 1bbed5c..f73515d 100644 --- a/api/account_test.go +++ b/api/account_test.go @@ -44,7 +44,7 @@ func TestCreateAccountAPI(t *testing.T) { "creator": account.Creator, }, buildStubs: func(store *mockdb.MockStore) { - arg := db.CreateAccountParams{ + arg := db.CreateAccountTxParams{ Passwordhash: account.Passwordhash, Firstname: account.Firstname, Lastname: account.Lastname, @@ -58,14 +58,29 @@ func TestCreateAccountAPI(t *testing.T) { Creator: account.Creator, } + exp := db.CreateAccountTxResult{ + Account: account, + } + store.EXPECT(). - CreateAccount(gomock.Any(), gomock.Eq(arg)). + CreateAccountTx(gomock.Any(), gomock.Eq(arg)). Times(1). - Return(account, nil) + Return(exp, nil) }, checkResponse: func(recorder *httptest.ResponseRecorder) { require.Equal(t, http.StatusOK, recorder.Code) - requireBodyMatchAccount(t, recorder.Body, account) + data, err := io.ReadAll(recorder.Body) + require.NoError(t, err) + + var getAccount db.CreateAccountTxResult + err = json.Unmarshal(data, &getAccount) + require.NoError(t, err) + require.Equal(t, + db.CreateAccountTxResult{ + Account: account, + }, + getAccount, + ) }, }, // { @@ -89,9 +104,8 @@ func TestCreateAccountAPI(t *testing.T) { }, buildStubs: func(store *mockdb.MockStore) { store.EXPECT(). - CreateAccount(gomock.Any(), gomock.Any()). - Times(0). - Return(db.Account{}, sql.ErrConnDone) + CreateAccountTx(gomock.Any(), gomock.Any()). + Times(0) }, checkResponse: func(recorder *httptest.ResponseRecorder) { require.Equal(t, http.StatusBadRequest, recorder.Code) @@ -114,9 +128,9 @@ func TestCreateAccountAPI(t *testing.T) { }, buildStubs: func(store *mockdb.MockStore) { store.EXPECT(). - CreateAccount(gomock.Any(), gomock.Any()). + CreateAccountTx(gomock.Any(), gomock.Any()). Times(1). - Return(db.Account{}, sql.ErrConnDone) + Return(db.CreateAccountTxResult{}, sql.ErrConnDone) }, checkResponse: func(recorder *httptest.ResponseRecorder) { require.Equal(t, http.StatusInternalServerError, recorder.Code) diff --git a/db/mock/store.go b/db/mock/store.go index 8099fb8..b53bff0 100644 --- a/db/mock/store.go +++ b/db/mock/store.go @@ -54,6 +54,21 @@ func (mr *MockStoreMockRecorder) CreateAccount(arg0, arg1 any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccount", reflect.TypeOf((*MockStore)(nil).CreateAccount), arg0, arg1) } +// CreateAccountTx mocks base method. +func (m *MockStore) CreateAccountTx(arg0 context.Context, arg1 db.CreateAccountTxParams) (db.CreateAccountTxResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAccountTx", arg0, arg1) + ret0, _ := ret[0].(db.CreateAccountTxResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAccountTx indicates an expected call of CreateAccountTx. +func (mr *MockStoreMockRecorder) CreateAccountTx(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountTx", reflect.TypeOf((*MockStore)(nil).CreateAccountTx), arg0, arg1) +} + // CreateDocumentMail mocks base method. func (m *MockStore) CreateDocumentMail(arg0 context.Context, arg1 db.CreateDocumentMailParams) (db.Document, error) { m.ctrl.T.Helper() @@ -301,6 +316,21 @@ func (mr *MockStoreMockRecorder) GetAccount(arg0, arg1 any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockStore)(nil).GetAccount), arg0, arg1) } +// GetAccountForUpdate mocks base method. +func (m *MockStore) GetAccountForUpdate(arg0 context.Context, arg1 int64) (db.Account, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountForUpdate", arg0, arg1) + ret0, _ := ret[0].(db.Account) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountForUpdate indicates an expected call of GetAccountForUpdate. +func (mr *MockStoreMockRecorder) GetAccountForUpdate(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountForUpdate", reflect.TypeOf((*MockStore)(nil).GetAccountForUpdate), arg0, arg1) +} + // GetDocument mocks base method. func (m *MockStore) GetDocument(arg0 context.Context, arg1 int64) (db.Document, error) { m.ctrl.T.Helper() diff --git a/db/sqlc/store.go b/db/sqlc/store.go index 77150e2..00d3bdc 100644 --- a/db/sqlc/store.go +++ b/db/sqlc/store.go @@ -8,6 +8,7 @@ import ( type Store interface { Querier + CreateAccountTx(ctx context.Context, arg CreateAccountTxParams) (CreateAccountTxResult, error) } // Store provides all functions to execute db queries and transactions @@ -17,7 +18,7 @@ type SQLStore struct { } func NewStore(db *sql.DB) Store { - return SQLStore{ + return &SQLStore{ db: db, Queries: New(db), } diff --git a/db/sqlc/tx_create_account.go b/db/sqlc/tx_create_account.go new file mode 100644 index 0000000..7a4fefb --- /dev/null +++ b/db/sqlc/tx_create_account.go @@ -0,0 +1,51 @@ +package db + +import ( + "context" + "database/sql" + "time" +) + +type CreateAccountTxParams struct { + Passwordhash string `json:"passwordhash"` + Firstname string `json:"firstname"` + Lastname string `json:"lastname"` + Birthday time.Time `json:"birthday"` + Email string `json:"email"` + Phone sql.NullString `json:"phone"` + City string `json:"city"` + Zip string `json:"zip"` + Street string `json:"street"` + Country string `json:"country"` + Creator string `json:"creator"` +} + +type CreateAccountTxResult struct { + Account Account `json:"account"` +} + +func (store *SQLStore) CreateAccountTx(ctx context.Context, arg CreateAccountTxParams) (CreateAccountTxResult, error) { + var result CreateAccountTxResult + + err := store.execTx(ctx, func(q *Queries) error { + var err error + + result.Account, err = q.CreateAccount(ctx, CreateAccountParams(arg)) //{ + // Passwordhash: arg.Passwordhash, + // Firstname: arg.Firstname, + // Lastname: arg.Lastname, + // Birthday: arg.Birthday, + // City: arg.City, + // Zip: arg.Zip, + // Street: arg.Street, + // Country: arg.Country, + // Creator: arg.Creator, + // Phone: arg.Phone, + // Email: arg.Email, + // }) + + return err + }) + + return result, err +}