improve code from outputs of golangci-lint

.drone.yml

@@ -61,9 +61,7 @@ steps:
   commands:
   - cp .infomark.yml.ci .infomark.yml
   - export INFOMARK_CONFIG_DIR=`pwd`
-  -
-  - go test ./api/app -cover -v --goblin.timeout 15s
-  - go test ./api/helper -cover -v
+  - go test ./... -cover -v --goblin.timeout 15s
   environment:
     GOPROXY: https://gomods.patwie.com/
 

api/app/account.go

@@ -348,6 +348,10 @@ func (rs *AccountResource) GetEnrollmentsHandler(w http.ResponseWriter, r *http.
 
 	// get enrollments
 	enrollments, err := rs.Stores.User.GetEnrollments(accessClaims.LoginID)
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	// render JSON reponse
 	if err = render.RenderList(w, r, rs.newUserEnrollmentsResponse(enrollments)); err != nil {

api/app/account_test.go

@@ -302,8 +302,8 @@ func TestAccount(t *testing.T) {
 			g.Assert(err).Equal(nil)
 			g.Assert(w.Code).Equal(http.StatusOK)
 
-			if !strings.HasSuffix(w.HeaderMap["Content-Type"][0], "jpeg") {
-				g.Assert(strings.HasSuffix(w.HeaderMap["Content-Type"][0], "jpg")).Equal(true)
+			if !strings.HasSuffix(w.Header().Get("Content-Type"), "jpeg") {
+				g.Assert(strings.HasSuffix(w.Header().Get("Content-Type"), "jpg")).Equal(true)
 			}
 
 		})
@@ -344,7 +344,7 @@ func TestAccount(t *testing.T) {
 			w = tape.GetWithClaims("/api/v1/account/avatar", 1, true)
 			g.Assert(err).Equal(nil)
 			g.Assert(w.Code).Equal(http.StatusOK)
-			g.Assert(strings.HasSuffix(w.HeaderMap["Content-Type"][0], "png")).Equal(true)
+			g.Assert(strings.HasSuffix(w.Header().Get("Content-Type"), "png")).Equal(true)
 
 		})
 

api/app/api.go

@@ -25,13 +25,6 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
-type ctxKey int
-
-const (
-	ctxAccount ctxKey = iota
-	ctxProfile
-)
-
 // UserStore defines user related database queries
 type UserStore interface {
 	Get(userID int64) (*model.User, error)

api/app/course.go

@@ -59,6 +59,10 @@ func NewCourseResource(stores *Stores) *CourseResource {
 func (rs *CourseResource) IndexHandler(w http.ResponseWriter, r *http.Request) {
 	// fetch collection of courses from database
 	courses, err := rs.Stores.Course.GetAll()
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	// render JSON reponse
 	if err = render.RenderList(w, r, rs.newCourseListResponse(courses)); err != nil {

api/app/course_test.go

@@ -144,6 +144,7 @@ func TestCourse(t *testing.T) {
 			enrollmentsExpected, err := stores.Course.FindEnrolledUsers(courseActive.ID,
 				[]string{"0", "1", "2"}, "%chi%",
 			)
+			g.Assert(err).Equal(nil)
 
 			w := tape.GetWithClaims("/api/v1/courses/1/enrollments?q=chi", 1, false)
 			enrollmentsActual := []enrollmentResponse{}
@@ -264,6 +265,7 @@ func TestCourse(t *testing.T) {
 			// verify body
 			courseReturn := &courseResponse{}
 			err = json.NewDecoder(w.Body).Decode(&courseReturn)
+			g.Assert(err).Equal(nil)
 			g.Assert(courseReturn.Name).Equal(entrySent.Name)
 			g.Assert(courseReturn.Description).Equal(entrySent.Description)
 			g.Assert(courseReturn.BeginsAt.Equal(entrySent.BeginsAt)).Equal(true)

api/app/grade_test.go

@@ -496,16 +496,15 @@ func TestGrade(t *testing.T) {
 				PublicDockerImage:  null.StringFrom("ff"),
 				PrivateDockerImage: null.StringFrom("ff"),
 			}, sheet1.ID)
+			g.Assert(err).Equal(nil)
 
 			task2, err := stores.Task.Create(&model.Task{
 				Name:               "2",
 				MaxPoints:          31,
 				PublicDockerImage:  null.StringFrom("ff"),
 				PrivateDockerImage: null.StringFrom("ff"),
 			}, sheet2.ID)
-
-			_ = task1
-			_ = task2
+			g.Assert(err).Equal(nil)
 
 			uid1 := int64(42)
 			uid2 := int64(43)

api/app/group.go

@@ -68,6 +68,10 @@ func (rs *GroupResource) IndexHandler(w http.ResponseWriter, r *http.Request) {
 
 	course := r.Context().Value(common.CtxKeyCourse).(*model.Course)
 	groups, err = rs.Stores.Group.GroupsOfCourse(course.ID)
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	// render JSON reponse
 	if err = render.RenderList(w, r, rs.newGroupListResponse(groups)); err != nil {

api/app/group_test.go

@@ -119,6 +119,7 @@ func TestGroup(t *testing.T) {
 
 			entryReturn := &GroupResponse{}
 			err = json.NewDecoder(w.Body).Decode(&entryReturn)
+			g.Assert(err).Equal(nil)
 			g.Assert(entryReturn.Tutor.ID).Equal(tutorID)
 			g.Assert(entryReturn.CourseID).Equal(int64(1))
 			g.Assert(entryReturn.Description).Equal("blah blahe")

api/app/material_test.go

@@ -309,6 +309,7 @@ func TestMaterial(t *testing.T) {
 
 			// tutors
 			w, err = tape.UploadWithClaims("/api/v1/courses/1/materials/1/file", filename, "application/zip", 2, false)
+			g.Assert(err).Equal(nil)
 			g.Assert(w.Code).Equal(http.StatusForbidden)
 
 			// admin
@@ -339,13 +340,13 @@ func TestMaterial(t *testing.T) {
 
 			// a file should be now served
 			w = tape.GetWithClaims("/api/v1/courses/1/materials/1/file", 1, true)
-			g.Assert(w.HeaderMap["Content-Type"][0]).Equal("application/zip")
+			g.Assert(w.Header().Get("Content-Type")).Equal("application/zip")
 			g.Assert(w.Code).Equal(http.StatusOK)
 
 			course, err := stores.Material.IdentifyCourseOfMaterial(1)
 			g.Assert(err).Equal(nil)
 
-			_, params, err := mime.ParseMediaType(w.HeaderMap["Content-Disposition"][0])
+			_, params, err := mime.ParseMediaType(w.Header().Get("Content-Disposition"))
 			g.Assert(err).Equal(nil)
 			g.Assert(params["filename"]).Equal(fmt.Sprintf("%s-empty.zip", course.Name))
 		})
@@ -364,13 +365,13 @@ func TestMaterial(t *testing.T) {
 
 			// a file should be now served
 			w = tape.GetWithClaims("/api/v1/courses/1/materials/1/file", 1, true)
-			g.Assert(w.HeaderMap["Content-Type"][0]).Equal("application/pdf")
+			g.Assert(w.Header().Get("Content-Type")).Equal("application/pdf")
 			g.Assert(w.Code).Equal(http.StatusOK)
 
 			course, err := stores.Material.IdentifyCourseOfMaterial(1)
 			g.Assert(err).Equal(nil)
 
-			_, params, err := mime.ParseMediaType(w.HeaderMap["Content-Disposition"][0])
+			_, params, err := mime.ParseMediaType(w.Header().Get("Content-Disposition"))
 			g.Assert(err).Equal(nil)
 			g.Assert(params["filename"]).Equal(fmt.Sprintf("%s-empty.pdf", course.Name))
 		})

api/app/sheet.go

@@ -65,6 +65,10 @@ func (rs *SheetResource) IndexHandler(w http.ResponseWriter, r *http.Request) {
 
 	course := r.Context().Value(common.CtxKeyCourse).(*model.Course)
 	sheets, err = rs.Stores.Sheet.SheetsOfCourse(course.ID)
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	givenRole := r.Context().Value(common.CtxKeyCourseRole).(authorize.CourseRole)
 

api/app/sheet_test.go

@@ -170,6 +170,7 @@ func TestSheet(t *testing.T) {
 
 			// tutors
 			w, err = tape.UploadWithClaims("/api/v1/courses/1/sheets/1/file", filename, "application/zip", 2, false)
+			g.Assert(err).Equal(nil)
 			g.Assert(w.Code).Equal(http.StatusForbidden)
 
 			// admin

api/app/task.go

@@ -63,6 +63,10 @@ func (rs *TaskResource) IndexHandler(w http.ResponseWriter, r *http.Request) {
 	// we use middle to detect whether there is a sheet given
 	sheet := r.Context().Value(common.CtxKeySheet).(*model.Sheet)
 	tasks, err = rs.Stores.Task.TasksOfSheet(sheet.ID)
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	// render JSON reponse
 	if err = render.RenderList(w, r, newTaskListResponse(tasks)); err != nil {

api/app/task_test.go

@@ -129,6 +129,7 @@ func TestTask(t *testing.T) {
 
 			taskReturn := &TaskResponse{}
 			err = json.NewDecoder(w.Body).Decode(&taskReturn)
+			g.Assert(err).Equal(nil)
 			g.Assert(taskReturn.Name).Equal("new Task")
 			g.Assert(taskReturn.MaxPoints).Equal(88)
 			g.Assert(taskReturn.PrivateDockerImage.Valid).Equal(true)

api/app/user.go

@@ -66,6 +66,10 @@ func (rs *UserResource) IndexHandler(w http.ResponseWriter, r *http.Request) {
 
 	// fetch collection of users from database
 	users, err := rs.Stores.User.GetAll()
+	if err != nil {
+		render.Render(w, r, ErrInternalServerErrorWithDetails(err))
+		return
+	}
 
 	// render JSON reponse
 	if err = render.RenderList(w, r, newUserListResponse(users)); err != nil {

api/cronjob/submission_zipper.go

@@ -178,8 +178,6 @@ Please log in to grade these solutions.
 				fmt.Println(" --> already done", sheet.ID)
 			}
 
-		} else {
-			// fmt.Println("ok", sheet.ID)
 		}
 
 	}

api/helper/file_carrier.go

@@ -212,9 +212,14 @@ func FileExists(path string) bool {
 }
 
 // FileTouch creates an empty file
-func FileTouch(path string) error {
+func FileTouch(path string) (err error) {
 	emptyFile, err := os.Create(path)
-	defer emptyFile.Close()
+
+	defer func() {
+		if lerr := emptyFile.Close(); lerr != nil {
+			err = lerr
+		}
+	}()
 	return err
 }
 

api/server.go

@@ -122,7 +122,7 @@ func (srv *Server) Start() {
 	log.Info("starting cronjob for zipping submissions...")
 	srv.Cron.Start()
 
-	quit := make(chan os.Signal)
+	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, os.Interrupt)
 	sig := <-quit
 	log.Info("Shutting down server... Reason:", sig)

api/worker.go

@@ -57,7 +57,7 @@ func (srv *Worker) Start() {
 
 	go consumer.HandleLoop(deliveries)
 
-	quit := make(chan os.Signal)
+	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, os.Interrupt)
 	sig := <-quit
 	log.Println("Shutting down Worker... Reason:", sig)

api/worker/submission_handler.go

@@ -200,6 +200,11 @@ func (h *RealSubmissionHandler) Handle(body []byte) error {
 
 	// 2. fetch submission file from server
 	r, err := http.NewRequest("GET", msg.SubmissionFileURL, nil)
+	if err != nil {
+		DefaultLogger.Printf("error: %v\n", err)
+		return err
+	}
+
 	r.Header.Add("Authorization", "Bearer "+msg.AccessToken)
 	if err := downloadFile(r, submissionPath); err != nil {
 		DefaultLogger.Printf("error: %v\n", err)
@@ -210,7 +215,12 @@ func (h *RealSubmissionHandler) Handle(body []byte) error {
 
 	// 3. fetch framework file from server
 	r, err = http.NewRequest("GET", msg.FrameworkFileURL, nil)
+	if err != nil {
+		DefaultLogger.Printf("error: %v\n", err)
+		return err
+	}
 	r.Header.Add("Authorization", "Bearer "+msg.AccessToken)
+
 	if err := downloadFile(r, frameworkPath); err != nil {
 		DefaultLogger.Printf("error: %v\n", err)
 		return err

auth/authenticate/middleware.go

@@ -92,8 +92,6 @@ func RequiredValidAccessClaims(next http.Handler) http.Handler {
 		// serve next
 		ctx := context.WithValue(r.Context(), common.CtxKeyAccessClaims, accessClaims)
 		next.ServeHTTP(w, r.WithContext(ctx))
-		return
-
 	})
 }
 
@@ -146,6 +144,10 @@ func NewLoginLimiter(prefix string, limit string, redisURL string) (*LoginLimite
 		MaxRetry: 3,
 	})
 
+	if err != nil {
+		return nil, err
+	}
+
 	// store := memory.NewStore()
 
 	return &LoginLimiter{Store: &store, Rate: &rate, Prefix: prefix}, nil
@@ -182,7 +184,7 @@ func RateLimitMiddleware(prefix string, limit string, redisURL string) func(h ht
 
 			context, err := ll.Get(r, keyFunc)
 			if err != nil {
-				panic(err)
+				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
 				return
 			}
 

cmd/console.go

@@ -80,7 +80,7 @@ var UtilsCompletionCmd = &cobra.Command{
 		case "zsh":
 			RootCmd.GenZshCompletion(os.Stdout)
 		default:
-			log.Fatalln("Unknown shell %s, only bash and zsh are available\n", args[0])
+			log.Fatalf("Unknown shell %s, only bash and zsh are available\n", args[0])
 		}
 	},
 }

cmd/console/course_cmd.go

@@ -60,12 +60,12 @@ var UserEnrollInCourse = &cobra.Command{
 
 		user, err := stores.User.Get(userID)
 		if err != nil {
-			log.Fatal("user with id %v not found\n", userID)
+			log.Fatalf("user with id %v not found\n", userID)
 		}
 
 		course, err := stores.Course.Get(courseID)
 		if err != nil {
-			log.Fatal("user with id %v not found\n", userID)
+			log.Fatalf("user with id %v not found\n", userID)
 		}
 
 		if err := stores.Course.Enroll(course.ID, user.ID, role); err != nil {

cmd/console/database_cmd.go

@@ -166,7 +166,7 @@ var DatabaseRestoreCmd = &cobra.Command{
 		err = shell2.Wait()
 		// io.Copy(os.Stdout, &b2)
 		if err != nil {
-			log.Fatal("load db from was not successfull\n %s", err)
+			log.Fatalf("load db from was not successfull\n %s", err)
 		}
 	},
 }
@@ -211,6 +211,9 @@ var DatabaseBackupCmd = &cobra.Command{
 		shell1.Wait()
 		w.Close()
 		err := shell2.Wait()
+		if err != nil {
+			panic(err)
+		}
 
 		destination, err := os.Create(file)
 		if err != nil {
@@ -219,7 +222,7 @@ var DatabaseBackupCmd = &cobra.Command{
 		defer destination.Close()
 		_, err = io.Copy(destination, &b2)
 		if err != nil {
-			log.Fatal("storing snapshot was not successfull\n %s", err)
+			log.Fatalf("storing snapshot was not successfull\n %s", err)
 		}
 
 	},

cmd/console/group_cmd.go

@@ -460,6 +460,7 @@ var GroupParseBidsSolution = &cobra.Command{
 
 		// we perform the update as a transaction
 		tx, err := db.Begin()
+		failWhenSmallestWhiff(err)
 		// delete assignments so far
 		_, err = tx.Exec(`
 DELETE FROM