Merhaba arkadaşlar;
Şöyle bir methodum var
func (r *realmStore) Find(ctx context.Context, skip int, take int) (*interfaces.PaginatedResult[realm.IRealm], error) {
var rollbackErr error
resp := new(interfaces.PaginatedResult[realm.IRealm])
resp.Items = make([]realm.IRealm, 0)
query := `
WITH total AS (
SELECT COUNT(*) AS total_count FROM realms
)
SELECT id, name, (SELECT total_count FROM total) AS total_count
FROM realms
ORDER BY id
LIMIT $1 OFFSET $2`
tx, err := r.conn.Begin(ctx)
if err != nil {
err = errors.Join(
err,
fmt.Errorf("tx error"))
return nil, rpErrors.NewErrUnexpected(err)
}
rows, err := tx.Query(ctx, query, take, skip)
if err != nil {
rollbackErr = tx.Rollback(ctx)
err = errors.Join(err, rollbackErr, fmt.Errorf("query error"))
return nil, rpErrors.NewErrUnexpected(err)
}
defer rows.Close()
for rows.Next() {
var id string
var name string
var totalCount int
if err := rows.Scan(&id, &name, &totalCount); err != nil {
rollbackErr := tx.Rollback(ctx)
if rollbackErr != nil {
err = errors.Join(rollbackErr, fmt.Errorf("rollback error"))
}
return nil, rpErrors.NewErrUnexpected(errors.Join(err, errors.New("row error")))
}
parsedId, err := ValueObject.ParseRealmId(id)
if err != nil {
rollbackErr := tx.Rollback(ctx)
err = errors.Join(err, rollbackErr, errors.New("incorrect id"))
return nil, rpErrors.NewErrUnexpected(err)
}
r := realm.NewRealm(parsedId, name, nil)
resp.Items = append(resp.Items, r)
resp.Total = totalCount
}
if err := tx.Commit(ctx); err != nil {
rollbackErr = tx.Rollback(ctx)
err = errors.Join(err, rollbackErr, fmt.Errorf("tx.Commit error"))
return resp, rpErrors.NewErrUnexpected(err)
}
return resp, nil
}
su ilk satır nedense coverlanmıyor
func (r *realmStore) Find(ctx context.Context, skip int, take int) (*interfaces.PaginatedResult[realm.IRealm], error) {
test caselerim de şu şekilde
func TestRealmStore_Find(t *testing.T) {
RegisterTestingT(t)
ctx := context.Background()
query := regexp.QuoteMeta(`
WITH total AS (
SELECT COUNT(*) AS total_count FROM realms
)
SELECT id, name, (SELECT total_count FROM total) AS total_count
FROM realms
ORDER BY id
LIMIT $1 OFFSET $2`)
t.Run("FincShouldReturnTxError", func(t *testing.T) {
conn, err := pgxmock.NewConn()
if err != nil {
t.Fatalf("failed to create mock connection: %v", err)
}
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
conn.ExpectBegin().WillReturnError(errors.New("tx error"))
_, err = store.Find(ctx, 0, 20)
Expect(err).To(MatchError(ContainSubstring("tx error")))
Expect(conn.ExpectationsWereMet()).Should(BeNil())
})
t.Run("FindShouldReturnRollbackError", func(t *testing.T) {
conn, err := pgxmock.NewConn()
if err != nil {
t.Fatalf("failed to create mock connection: %v", err)
}
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
// Set up the expectations for the query.
conn.ExpectBegin() // Expect a transaction to begin
conn.ExpectQuery(query).
WithArgs(20, 0).
WillReturnError(fmt.Errorf("query error")) // Simulate an error in the query
conn.ExpectRollback().WillReturnError(errors.New("rollback error")) // Expect a rollback due to the error
// Call the Find method
_, err = store.Find(ctx, 0, 20)
// Check that an error is returned
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("rollback error"))) // Check for the specific error
// Ensure all expectations were met
Expect(conn.ExpectationsWereMet()).To(BeNil())
})
t.Run("FindShouldReturnQueryError", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnError(fmt.Errorf("query error"))
conn.ExpectRollback()
_, err := store.Find(ctx, 0, 20)
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("query error")))
})
t.Run("FindShouldReturnRowsError", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow(124123, r2.GetName(), 2))
conn.ExpectRollback()
_, err := store.Find(ctx, 0, 20)
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("row error")))
})
t.Run("FindShouldRollbackErrorOnRowScanFail", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow(124123, r2.GetName(), 2))
conn.ExpectRollback().WillReturnError(errors.New("rollback error"))
_, err := store.Find(ctx, 0, 20)
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("rollback error")))
})
t.Run("FindShouldReturnIncorrectIdOnScanningIncorrectId", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow("124123", r2.GetName(), 2))
conn.ExpectRollback()
_, err := store.Find(ctx, 0, 20)
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("incorrect id")))
})
t.Run("FindShouldReturnCommitError", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow(r2.GetId().GetValue(), r2.GetName(), 2))
conn.ExpectCommit().WillReturnError(errors.New("tx.Commit error"))
_, err := store.Find(ctx, 0, 20)
Expect(err).NotTo(BeNil())
Expect(err).To(MatchError(ContainSubstring("tx.Commit error")))
})
t.Run("FindShouldReturnRowsOnSuccess", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow(r2.GetId().GetValue(), r2.GetName(), 2))
conn.ExpectCommit()
resp, err := store.Find(ctx, 0, 20)
Expect(resp.Items).To(HaveLen(2))
Expect(resp.Total).To(Equal(2))
Expect(err).To(BeNil())
})
t.Run("FindShouldReturnRollbackErrorOnCommitError", func(t *testing.T) {
conn, _ := pgxmock.NewConn()
defer conn.Close(ctx)
store := &realmStore{
conn: conn,
}
r1 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 1", nil)
r2 := realm.NewRealm(ValueObject.NewRealmId(), "Realm 2", nil)
conn.ExpectBegin()
conn.ExpectQuery(query).WithArgs(20, 0).WillReturnRows(
pgxmock.NewRows([]string{"id", "name", "total_count"}).
AddRow(r1.GetId().GetValue(), r1.GetName(), 2).
AddRow(r2.GetId().GetValue(), r2.GetName(), 2))
conn.ExpectCommit().WillReturnError(errors.New("tx.Commit error"))
conn.ExpectRollback().WillReturnError(errors.New("tx.Rollback error"))
resp, err := store.Find(ctx, 0, 20)
Expect(resp.Items).To(HaveLen(2))
Expect(resp.Total).To(Equal(2))
Expect(err).Should(MatchError(ContainSubstring("tx.Commit error")))
Expect(err).Should(MatchError(ContainSubstring("tx.Rollback error")))
})
}
bir çeşit bug mıdır yoksa birşeyler eksik mi?
