update error messages

internal/auth/jwt/token_generator.go

@@ -48,7 +48,7 @@ func (g *tokenGenerator) Generate(metadata Metadata) (string, error) {
 	at := jwt.NewWithClaims(jwt.SigningMethodHS256, atClaims)
 	accessToken, err := at.SignedString([]byte(g.accessSecret))
 	if err != nil {
-		return "", errors.Wrap(err, "TokenGenerator.Generate")
+		return "", errors.Wrap(err, "couldn't get signed access token")
 	}
 
 	return accessToken, nil
@@ -67,10 +67,10 @@ func verifyToken(secret string, tokenString string) (*jwt.Token, error) {
 		return []byte(secret), nil
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "verifyToken")
+		return nil, errors.Wrap(err, "couldn't parse the token")
 	}
 	if !token.Valid {
-		return nil, errors.New("Token is invalid")
+		return nil, errors.New("token is invalid")
 	}
 	return token, nil
 }
@@ -85,15 +85,15 @@ func extractTokenMetadata(secret, tokenString string) (*Metadata, error) {
 	if ok {
 		staySignedIn, ok := claims["stay_signed_in"].(bool)
 		if !ok {
-			return nil, errors.New("Invalid token payload (staySignedIn should be a boolean)")
+			return nil, errors.New("invalid token payload (staySignedIn should be a boolean)")
 		}
 		email, ok := claims["email"].(string)
 		if !ok {
-			return nil, errors.New("Invalid token payload (email should be a string)")
+			return nil, errors.New("invalid token payload (email should be a string)")
 		}
 		password, ok := claims["password"].(string)
 		if !ok {
-			return nil, errors.New("Invalid token payload (password should be a string)")
+			return nil, errors.New("invalid token payload (password should be a string)")
 		}
 		return &Metadata{
 			StaySignedIn: staySignedIn,
@@ -104,5 +104,5 @@ func extractTokenMetadata(secret, tokenString string) (*Metadata, error) {
 		}, nil
 	}
 
-	return nil, errors.New("Cannot extract token metadata")
+	return nil, errors.New("couldn't extract token metadata")
 }

internal/auth/usecase/usecase.go

@@ -22,7 +22,7 @@ type Config struct {
 
 func New(cfg *Config) (auth.Usecase, error) {
 	if cfg == nil || cfg.UserRepository == nil {
-		return nil, errors.New("user/usecase: UserRepository is required")
+		return nil, errors.New("cfg.UserRepository is required")
 	}
 	return &usecase{
 		cfg.UserRepository,

internal/gin/middleware/authenticate.go

@@ -35,7 +35,7 @@ func Authenticate(ucase auth.Usecase) gin.HandlerFunc {
 func UserFromContext(ctx context.Context) (*models.User, error) {
 	user := ctx.Value(authenticateKey)
 	if user == nil {
-		err := errors.New("Could not retrieve *models.User")
+		err := errors.New("couldn't retrieve *models.User")
 		return nil, err
 	}
 

internal/gin/middleware/dataloader_to_context.go

@@ -23,7 +23,7 @@ func DataLoaderToContext(cfg dataloader.Config) gin.HandlerFunc {
 func DataLoaderFromContext(ctx context.Context) (*dataloader.DataLoader, error) {
 	dataLoader := ctx.Value(dataLoaderToContext)
 	if dataLoader == nil {
-		err := errors.New("could not retrieve dataloader.DataLoader")
+		err := errors.New("couldn't retrieve dataloader.DataLoader")
 		return nil, err
 	}
 

internal/gin/middleware/gin_context_to_context.go

@@ -22,7 +22,7 @@ func GinContextToContext() gin.HandlerFunc {
 func GinContextFromContext(ctx context.Context) (*gin.Context, error) {
 	ginContext := ctx.Value(ginContextToContextKey)
 	if ginContext == nil {
-		err := errors.New("could not retrieve gin.Context")
+		err := errors.New("couldn't retrieve gin.Context")
 		return nil, err
 	}
 

internal/postgres/postgres.go

@@ -13,7 +13,7 @@ import (
 	"github.com/zdam-egzamin-zawodowy/backend/internal/models"
 )
 
-var log = logrus.WithField("package", "internal/db")
+var log = logrus.WithField("package", "internal/postgres")
 
 type Config struct {
 	LogQueries bool

internal/profession/repository/pg_repository.go

@@ -23,7 +23,7 @@ type PGRepositoryConfig struct {
 
 func NewPGRepository(cfg *PGRepositoryConfig) (profession.Repository, error) {
 	if cfg == nil || cfg.DB == nil {
-		return nil, errors.New("profession/pg_repository: *pg.DB is required")
+		return nil, errors.New("cfg.DB is required")
 	}
 	return &pgRepository{
 		cfg.DB,

internal/profession/usecase/usecase.go

@@ -18,7 +18,7 @@ type Config struct {
 
 func New(cfg *Config) (profession.Usecase, error) {
 	if cfg == nil || cfg.ProfessionRepository == nil {
-		return nil, errors.New("profession/usecase: ProfessionRepository is required")
+		return nil, errors.New("cfg.ProfessionRepository is required")
 	}
 	return &usecase{
 		cfg.ProfessionRepository,

internal/qualification/repository/pg_repository.go

@@ -23,7 +23,7 @@ type PGRepositoryConfig struct {
 
 func NewPGRepository(cfg *PGRepositoryConfig) (qualification.Repository, error) {
 	if cfg == nil || cfg.DB == nil {
-		return nil, errors.New("qualification/pg_repository: *pg.DB is required")
+		return nil, errors.New("cfg.DB is required")
 	}
 	return &pgRepository{
 		cfg.DB,

internal/qualification/usecase/usecase.go

@@ -18,7 +18,7 @@ type Config struct {
 
 func New(cfg *Config) (qualification.Usecase, error) {
 	if cfg == nil || cfg.QualificationRepository == nil {
-		return nil, errors.New("qualification/usecase: QualificationRepository is required")
+		return nil, errors.New("cfg.QualificationRepository is required")
 	}
 	return &usecase{
 		cfg.QualificationRepository,

internal/question/repository/pg_repository.go

@@ -25,8 +25,11 @@ type PGRepositoryConfig struct {
 }
 
 func NewPGRepository(cfg *PGRepositoryConfig) (question.Repository, error) {
-	if cfg == nil || cfg.DB == nil || cfg.FileStorage == nil {
-		return nil, errors.New("question/pg_repository: *pg.DB and filestorage.FileStorage are required")
+	if cfg == nil || cfg.DB == nil {
+		return nil, errors.New("cfg.DB is required")
+	}
+	if cfg.FileStorage == nil {
+		return nil, errors.New("cfg.FileStorage is required")
 	}
 	return &pgRepository{
 		cfg.DB,

internal/question/usecase/usecase.go

@@ -26,7 +26,7 @@ type Config struct {
 
 func New(cfg *Config) (question.Usecase, error) {
 	if cfg == nil || cfg.QuestionRepository == nil {
-		return nil, errors.New("question/usecase: cfg.QuestionRepository is required")
+		return nil, errors.New("cfg.QuestionRepository is required")
 	}
 	return &usecase{
 		cfg.QuestionRepository,

internal/user/repository/pg_repository.go

@@ -23,7 +23,7 @@ type PGRepositoryConfig struct {
 
 func NewPGRepository(cfg *PGRepositoryConfig) (user.Repository, error) {
 	if cfg == nil || cfg.DB == nil {
-		return nil, errors.New("user/pg_repository: *pg.DB is required")
+		return nil, errors.New("cfg.DB is required")
 	}
 	return &pgRepository{
 		cfg.DB,

internal/user/usecase/usecase.go

@@ -19,7 +19,7 @@ type Config struct {
 
 func New(cfg *Config) (user.Usecase, error) {
 	if cfg == nil || cfg.UserRepository == nil {
-		return nil, errors.New("user/usecase: UserRepository is required")
+		return nil, errors.New("cfg.UserRepository is required")
 	}
 	return &usecase{
 		cfg.UserRepository,

main.go

@@ -63,26 +63,26 @@ func main() {
 		DB: dbConn,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "userRepository"))
 	}
 	professionRepository, err := professionrepository.NewPGRepository(&professionrepository.PGRepositoryConfig{
 		DB: dbConn,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "professionRepository"))
 	}
 	qualificationRepository, err := qualificationrepository.NewPGRepository(&qualificationrepository.PGRepositoryConfig{
 		DB: dbConn,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "qualificationRepository"))
 	}
 	questionRepository, err := questionrepository.NewPGRepository(&questionrepository.PGRepositoryConfig{
 		DB:          dbConn,
 		FileStorage: fileStorage,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "questionRepository"))
 	}
 
 	//usecases
@@ -91,13 +91,13 @@ func main() {
 		TokenGenerator: jwt.NewTokenGenerator(envutil.GetenvString("ACCESS_SECRET")),
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "authUsecase"))
 	}
 	userUsecase, err := userusecase.New(&userusecase.Config{
 		UserRepository: userRepository,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "userUsecase"))
 	}
 	professionUsecase, err := professionusecase.New(&professionusecase.Config{
 		ProfessionRepository: professionRepository,
@@ -109,13 +109,13 @@ func main() {
 		QualificationRepository: qualificationRepository,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "qualificationUsecase"))
 	}
 	questionUsecase, err := questionusecase.New(&questionusecase.Config{
 		QuestionRepository: questionRepository,
 	})
 	if err != nil {
-		logrus.Fatal(err)
+		logrus.Fatal(errors.Wrap(err, "questionUsecase"))
 	}
 
 	router := setupRouter()
@@ -145,7 +145,7 @@ func main() {
 	go func() {
 		// service connections
 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logrus.Fatalf("listen: %s\n", err)
+			logrus.Fatalln("listen:", err)
 		}
 	}()
 	logrus.Info("Server is listening on the port 8080")
@@ -158,7 +158,7 @@ func main() {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := srv.Shutdown(ctx); err != nil {
-		logrus.Fatal("Server Shutdown:", err)
+		logrus.Fatalln("Server Shutdown:", err)
 	}
 	logrus.Info("Server exiting")
 }

pkg/fstorage/filestorage.go

@@ -26,12 +26,12 @@ func (storage *fileStorage) Put(file io.Reader, filename string) error {
 	fullPath := path.Join(storage.basePath, filename)
 	f, err := os.Create(fullPath)
 	if err != nil {
-		return errors.Wrap(err, "FileStorage.Put")
+		return errors.Wrap(err, "couldn't create a file")
 	}
 	defer f.Close()
 	_, err = io.Copy(f, file)
 	if err != nil {
-		return errors.Wrap(err, "FileStorage.Put")
+		return errors.Wrap(err, "couldn't write a file")
 	}
 	return nil
 }
@@ -39,8 +39,8 @@ func (storage *fileStorage) Put(file io.Reader, filename string) error {
 func (storage *fileStorage) Remove(filename string) error {
 	fullPath := path.Join(storage.basePath, filename)
 	err := os.Remove(fullPath)
-	if err != nil {
-		return errors.Wrap(err, "FileStorage.Remove")
+	if err != nil && !os.IsNotExist(err) {
+		return errors.Wrap(err, "couldn't remove a file")
 	}
 	return nil
 }