15665285882

Committed 15 Jun 2025 04:42PM UTC coverage: 88.823% (+2.2%) from 86.624%

Build # 15665285882

Build Type

push

github

Committed by

rovifran

Commit Message

tests: added rabbitmq on docker compose files and set env variables for connection

Run Details

11 of 11 new or added lines in 2 files covered. (100.0%)

9 existing lines in 2 files now uncovered.

3123 of 3516 relevant lines covered (88.82%)

1.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.12

/src/controller/assignments_controller.go

package controller

import (
        "log"
        "log/slog"
        "net/http"

        "courses-service/src/queues"
        "courses-service/src/schemas"
        "courses-service/src/service"

        "github.com/gin-gonic/gin"
)

type AssignmentsController struct {
        service            service.AssignmentServiceInterface
        notificationsQueue queues.NotificationsQueueInterface
}

func NewAssignmentsController(
        service service.AssignmentServiceInterface,
        notificationsQueue queues.NotificationsQueueInterface,
) *AssignmentsController {
        return &AssignmentsController{
                service:            service,
                notificationsQueue: notificationsQueue,
        }
}

// @Summary Get all assignments
// @Description Get all assignments
// @Tags assignments
// @Accept json
// @Produce json
// @Router /assignments [get]
// @Success 200 {array} model.Assignment
func (c *AssignmentsController) GetAssignments(ctx *gin.Context) {
        slog.Debug("Getting assignments")

        assignments, err := c.service.GetAssignments()
        if err != nil {
                slog.Error("Error getting assignments", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignments retrieved", "assignments", assignments)
        ctx.JSON(http.StatusOK, assignments)
}

// @Summary Create an assignment
// @Description Create an assignment
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignment body schemas.CreateAssignmentRequest true "Assignment to create"
// @Success 201 {object} model.Assignment
// @Router /assignments [post]
func (c *AssignmentsController) CreateAssignment(ctx *gin.Context) {
        log.Println("Creating assignment")

        var assignment schemas.CreateAssignmentRequest
        if err := ctx.ShouldBindJSON(&assignment); err != nil {
                log.Println("Error binding JSON:", err)
                ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
        }

        createdAssignment, err := c.service.CreateAssignment(assignment)
        if err != nil {
                log.Println("Error creating assignment:", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        // 🟡 Publicar evento en RabbitMQ con amqp091-go
        // go func() {
        //         conn, err := amqp091.Dial(os.Getenv("RABBITMQ_URL"))
        //         if err != nil {
        //                 log.Println("RabbitMQ connection error:", err)
        //                 return
        //         }
        //         defer conn.Close()

        //         ch, err := conn.Channel()
        //         if err != nil {
        //                 log.Println("RabbitMQ channel error:", err)
        //                 return
        //         }
        //         defer ch.Close()

        //         _, err = ch.QueueDeclare(
        //                 os.Getenv("NOTIFICATIONS_QUEUE_NAME"),
        //                 false,
        //                 false,
        //                 false,
        //                 false,
        //                 nil,
        //         )
        //         if err != nil {
        //                 log.Println("Queue declare error:", err)
        //                 return
        //         }

        //         event := map[string]interface{}{
        //                 "event_type":          "assignment.created",
        //                 "course_id":           createdAssignment.CourseID,
        //                 "assignment_id":       createdAssignment.ID,
        //                 "assignment_title":    createdAssignment.Title,
        //                 "assignment_due_date": createdAssignment.DueDate.Format(time.RFC3339),
        //         }

        //         body, err := json.Marshal(event)
        //         if err != nil {
        //                 log.Println("Error marshaling event:", err)
        //                 return
        //         }

        //         err = ch.Publish(
        //                 "",
        //                 os.Getenv("NOTIFICATIONS_QUEUE_NAME"),
        //                 false,
        //                 false,
        //                 amqp091.Publishing{
        //                         ContentType: "application/json",
        //                         Body:        body,
        //                 },
        //         )
        //         if err != nil {
        //                 log.Println("Error publishing message:", err)
        //                 return
        //         }

        //         log.Println("📤 Event published: assignment.created")
        // }()
        queueMessage := queues.NewAssignmentCreatedMessage(
                createdAssignment.CourseID,
                createdAssignment.ID.Hex(),
                createdAssignment.Title,
                createdAssignment.DueDate,
        )
        err = c.notificationsQueue.Publish(queueMessage)
        if err != nil {
                log.Println("Error publishing message:", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        log.Println("Assignment created:", createdAssignment.ID)
        ctx.JSON(http.StatusCreated, createdAssignment)
}

// @Summary Get an assignment by ID
// @Description Get an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Success 200 {object} model.Assignment
// @Router /assignments/{assignmentId} [get]
func (c *AssignmentsController) GetAssignmentById(ctx *gin.Context) {
        slog.Debug("Getting assignment by ID")
        id := ctx.Param("assignmentId")

        assignment, err := c.service.GetAssignmentById(id)
        if err != nil {
                slog.Error("Error getting assignment", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        if assignment == nil {
                ctx.JSON(http.StatusNotFound, gin.H{"error": "assignment not found"})
                return
        }

        slog.Debug("Assignment retrieved", "assignment", assignment)
        ctx.JSON(http.StatusOK, assignment)
}

// @Summary Get assignments by course ID
// @Description Get assignments by course ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param courseId path string true "Course ID"
// @Success 200 {array} model.Assignment
// @Router /assignments/course/{courseId} [get]
func (c *AssignmentsController) GetAssignmentsByCourseId(ctx *gin.Context) {
        slog.Debug("Getting assignments by course ID")
        courseId := ctx.Param("courseId")

        assignments, err := c.service.GetAssignmentsByCourseId(courseId)
        if err != nil {
                slog.Error("Error getting assignments", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignments retrieved", "assignments", assignments)
        ctx.JSON(http.StatusOK, assignments)
}

// @Summary Update an assignment
// @Description Update an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Param assignment body schemas.UpdateAssignmentRequest true "Assignment to update"
// @Success 200 {object} model.Assignment
// @Router /assignments/{assignmentId} [put]
func (c *AssignmentsController) UpdateAssignment(ctx *gin.Context) {
        slog.Debug("Updating assignment")
        id := ctx.Param("assignmentId")

        var updateAssignmentRequest schemas.UpdateAssignmentRequest
        if err := ctx.ShouldBindJSON(&updateAssignmentRequest); err != nil {
                slog.Error("Error binding JSON", "error", err)
                ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
        }

        updatedAssignment, err := c.service.UpdateAssignment(id, updateAssignmentRequest)
        if err != nil {
                slog.Error("Error updating assignment", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignment updated", "assignment", updatedAssignment)
        ctx.JSON(http.StatusOK, updatedAssignment)
}

// @Summary Delete an assignment
// @Description Delete an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Success 200 {string} string "Assignment deleted successfully"
// @Router /assignments/{assignmentId} [delete]
func (c *AssignmentsController) DeleteAssignment(ctx *gin.Context) {
        slog.Debug("Deleting assignment")
        id := ctx.Param("assignmentId")

        if err := c.service.DeleteAssignment(id); err != nil {
                slog.Error("Error deleting assignment", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignment deleted")
        ctx.JSON(http.StatusNoContent, nil)
}

1	package controller
2
3	import (
4	"log"
5	"log/slog"
6	"net/http"
7
8	"courses-service/src/queues"
9	"courses-service/src/schemas"
10	"courses-service/src/service"
11
12	"github.com/gin-gonic/gin"
13	)
14
15	type AssignmentsController struct {
16	service service.AssignmentServiceInterface
17	notificationsQueue queues.NotificationsQueueInterface
18	}
19
20	func NewAssignmentsController(
21	service service.AssignmentServiceInterface,
22	notificationsQueue queues.NotificationsQueueInterface,
23	) *AssignmentsController {	1✔
24	return &AssignmentsController{	1✔
25	service: service,	1✔
26	notificationsQueue: notificationsQueue,	1✔
27	}	1✔
28	}	1✔
29
30	// @Summary Get all assignments
31	// @Description Get all assignments
32	// @Tags assignments
33	// @Accept json
34	// @Produce json
35	// @Router /assignments [get]
36	// @Success 200 {array} model.Assignment
37	func (c AssignmentsController) GetAssignments(ctx gin.Context) {	1✔
38	slog.Debug("Getting assignments")	1✔
39		1✔
40	assignments, err := c.service.GetAssignments()	1✔
41	if err != nil {	2✔
42	slog.Error("Error getting assignments", "error", err)	1✔
43	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
44	return	1✔
45	}	1✔
46
47	slog.Debug("Assignments retrieved", "assignments", assignments)	1✔
48	ctx.JSON(http.StatusOK, assignments)	1✔
49	}
50
51	// @Summary Create an assignment
52	// @Description Create an assignment
53	// @Tags assignments
54	// @Accept json
55	// @Produce json
56	// @Param assignment body schemas.CreateAssignmentRequest true "Assignment to create"
57	// @Success 201 {object} model.Assignment
58	// @Router /assignments [post]
59	func (c AssignmentsController) CreateAssignment(ctx gin.Context) {	1✔
60	log.Println("Creating assignment")	1✔
61		1✔
62	var assignment schemas.CreateAssignmentRequest	1✔
63	if err := ctx.ShouldBindJSON(&assignment); err != nil {	2✔
64	log.Println("Error binding JSON:", err)	1✔
65	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
66	return	1✔
67	}	1✔
68
69	createdAssignment, err := c.service.CreateAssignment(assignment)	1✔
70	if err != nil {	2✔
71	log.Println("Error creating assignment:", err)	1✔
72	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
73	return	1✔
74	}	1✔
75
76	// 🟡 Publicar evento en RabbitMQ con amqp091-go
77	// go func() {
78	// conn, err := amqp091.Dial(os.Getenv("RABBITMQ_URL"))
79	// if err != nil {
80	// log.Println("RabbitMQ connection error:", err)
81	// return
82	// }
83	// defer conn.Close()
84
85	// ch, err := conn.Channel()
86	// if err != nil {
87	// log.Println("RabbitMQ channel error:", err)
88	// return
89	// }
90	// defer ch.Close()
91
92	// _, err = ch.QueueDeclare(
93	// os.Getenv("NOTIFICATIONS_QUEUE_NAME"),
94	// false,
95	// false,
96	// false,
97	// false,
98	// nil,
99	// )
100	// if err != nil {
101	// log.Println("Queue declare error:", err)
102	// return
103	// }
104
105	// event := map[string]interface{}{
106	// "event_type": "assignment.created",
107	// "course_id": createdAssignment.CourseID,
108	// "assignment_id": createdAssignment.ID,
109	// "assignment_title": createdAssignment.Title,
110	// "assignment_due_date": createdAssignment.DueDate.Format(time.RFC3339),
111	// }
112
113	// body, err := json.Marshal(event)
114	// if err != nil {
115	// log.Println("Error marshaling event:", err)
116	// return
117	// }
118
119	// err = ch.Publish(
120	// "",
121	// os.Getenv("NOTIFICATIONS_QUEUE_NAME"),
122	// false,
123	// false,
124	// amqp091.Publishing{
125	// ContentType: "application/json",
126	// Body: body,
127	// },
128	// )
129	// if err != nil {
130	// log.Println("Error publishing message:", err)
131	// return
132	// }
133
134	// log.Println("📤 Event published: assignment.created")
135	// }()
136	queueMessage := queues.NewAssignmentCreatedMessage(	1✔
137	createdAssignment.CourseID,	1✔
138	createdAssignment.ID.Hex(),	1✔
139	createdAssignment.Title,	1✔
140	createdAssignment.DueDate,	1✔
141	)	1✔
142	err = c.notificationsQueue.Publish(queueMessage)	1✔
143	if err != nil {	1✔
UNCOV 144	log.Println("Error publishing message:", err)	×
UNCOV 145	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	×
UNCOV 146	return	×
UNCOV 147	}	×
148
149	log.Println("Assignment created:", createdAssignment.ID)	1✔
150	ctx.JSON(http.StatusCreated, createdAssignment)	1✔
151	}
152
153	// @Summary Get an assignment by ID
154	// @Description Get an assignment by ID
155	// @Tags assignments
156	// @Accept json
157	// @Produce json
158	// @Param assignmentId path string true "Assignment ID"
159	// @Success 200 {object} model.Assignment
160	// @Router /assignments/{assignmentId} [get]
161	func (c AssignmentsController) GetAssignmentById(ctx gin.Context) {	1✔
162	slog.Debug("Getting assignment by ID")	1✔
163	id := ctx.Param("assignmentId")	1✔
164		1✔
165	assignment, err := c.service.GetAssignmentById(id)	1✔
166	if err != nil {	2✔
167	slog.Error("Error getting assignment", "error", err)	1✔
168	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
169	return	1✔
170	}	1✔
171
172	if assignment == nil {	2✔
173	ctx.JSON(http.StatusNotFound, gin.H{"error": "assignment not found"})	1✔
174	return	1✔
175	}	1✔
176
177	slog.Debug("Assignment retrieved", "assignment", assignment)	1✔
178	ctx.JSON(http.StatusOK, assignment)	1✔
179	}
180
181	// @Summary Get assignments by course ID
182	// @Description Get assignments by course ID
183	// @Tags assignments
184	// @Accept json
185	// @Produce json
186	// @Param courseId path string true "Course ID"
187	// @Success 200 {array} model.Assignment
188	// @Router /assignments/course/{courseId} [get]
189	func (c AssignmentsController) GetAssignmentsByCourseId(ctx gin.Context) {	1✔
190	slog.Debug("Getting assignments by course ID")	1✔
191	courseId := ctx.Param("courseId")	1✔
192		1✔
193	assignments, err := c.service.GetAssignmentsByCourseId(courseId)	1✔
194	if err != nil {	2✔
195	slog.Error("Error getting assignments", "error", err)	1✔
196	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
197	return	1✔
198	}	1✔
199
200	slog.Debug("Assignments retrieved", "assignments", assignments)	1✔
201	ctx.JSON(http.StatusOK, assignments)	1✔
202	}
203
204	// @Summary Update an assignment
205	// @Description Update an assignment by ID
206	// @Tags assignments
207	// @Accept json
208	// @Produce json
209	// @Param assignmentId path string true "Assignment ID"
210	// @Param assignment body schemas.UpdateAssignmentRequest true "Assignment to update"
211	// @Success 200 {object} model.Assignment
212	// @Router /assignments/{assignmentId} [put]
213	func (c AssignmentsController) UpdateAssignment(ctx gin.Context) {	1✔
214	slog.Debug("Updating assignment")	1✔
215	id := ctx.Param("assignmentId")	1✔
216		1✔
217	var updateAssignmentRequest schemas.UpdateAssignmentRequest	1✔
218	if err := ctx.ShouldBindJSON(&updateAssignmentRequest); err != nil {	2✔
219	slog.Error("Error binding JSON", "error", err)	1✔
220	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
221	return	1✔
222	}	1✔
223
224	updatedAssignment, err := c.service.UpdateAssignment(id, updateAssignmentRequest)	1✔
225	if err != nil {	2✔
226	slog.Error("Error updating assignment", "error", err)	1✔
227	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
228	return	1✔
229	}	1✔
230
231	slog.Debug("Assignment updated", "assignment", updatedAssignment)	1✔
232	ctx.JSON(http.StatusOK, updatedAssignment)	1✔
233	}
234
235	// @Summary Delete an assignment
236	// @Description Delete an assignment by ID
237	// @Tags assignments
238	// @Accept json
239	// @Produce json
240	// @Param assignmentId path string true "Assignment ID"
241	// @Success 200 {string} string "Assignment deleted successfully"
242	// @Router /assignments/{assignmentId} [delete]
243	func (c AssignmentsController) DeleteAssignment(ctx gin.Context) {	1✔
244	slog.Debug("Deleting assignment")	1✔
245	id := ctx.Param("assignmentId")	1✔
246		1✔
247	if err := c.service.DeleteAssignment(id); err != nil {	2✔
248	slog.Error("Error deleting assignment", "error", err)	1✔
249	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
250	return	1✔
251	}	1✔
252
253	slog.Debug("Assignment deleted")	1✔
254	ctx.JSON(http.StatusNoContent, nil)	1✔
255	}

classconnect-grupo3 / courses-service / 15665285882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous