Ampliación Test QuestionGenerator y Gateway

gatewayservice/gateway-service.js

@@ -248,20 +248,6 @@ app.post('/addOrUpdateQuestionGenerator', async (req, res) => {
   }
 });
 
-// Ruta para obtener una pregunta de prueba por su ID
-app.get('/getRandomQuestionGenerator', async (req, res) => {
-  try {
-    const questionGeneratorResponse = await axios.get(`${questiongeneratorservice}/getRandomQuestionGenerator`);
-    res.json(questionGeneratorResponse.data);
-  } catch (error) {
-    if (error.response) {
-      res.status(error.response.status).json({ error: error.response.data.error });
-    } else {
-      res.status(500).json({ error: 'Error interno del servidor' });
-    }
-  }
-});
-
 //TEMATICAS
 app.get('/getRandomQuestionSports', async (req, res) => {
   try {

gatewayservice/gateway-service.test.js

@@ -40,8 +40,10 @@ describe('Gateway Service', () => {
       return Promise.resolve({ data: { ranking: 'mockedRanking' } });
     } else if (url.endsWith('/obtainRank')) {
       return Promise.resolve({ data: { rank: 'mockedRank' } });
-    } else if (url.endsWith('/getRandomQuestionGenerator')) {
-      return Promise.resolve({ data: { question: 'mockedQuestion' } });
+    } else if (url.endsWith('/getRandomQuestionDeporte') || url.endsWith('/getRandomQuestionAnio')
+            || url.endsWith('/getRandomQuestionMusica') || url.endsWith('/getRandomQuestionLibro')
+            || url.endsWith('/getRandomQuestionPaisYGeo')) {
+      return Promise.resolve({ data: { question: 'mockedQuestion'} });
     } else if (url.endsWith('/getAllQuestionGenerator')) {
       return Promise.resolve({ data: { questions: ['question1', 'question2'] } });
     } else if (url.endsWith('/countQuestionGenerator')) {
@@ -220,14 +222,17 @@ it('should get a rank from rank service', async () => {
   expect(response.body.rank).toBe('mockedRank');
 });
 
-// Test /getRandomQuestionGenerator endpoint
-it('should get a random question from question generator service', async () => {
-  const response = await request(app)
-    .get('/getRandomQuestionGenerator');
+// Test /getRandomQuestionXXXXXX endpoints (themes)
+const themes = ['Sports', 'Music', 'ImportantDates', 'Literature', 'Countries'];
 
-  expect(response.statusCode).toBe(200);
-  expect(response.body.question).toBe('mockedQuestion');
-});
+for (const theme of themes) {
+  it(`should get a random question from question generator service with theme "${theme}"`, async () => {
+    const response = await request(app).get(`/getRandomQuestion${theme}`);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.question).toBe('mockedQuestion');
+  });
+}
 
 // Test /getAllQuestionGenerator endpoint
 it('should get all questions from question generator service', async () => {

questions/questiongeneratorservice/questiongenerator-service.js

@@ -65,18 +65,6 @@ app.get('/getAllQuestionGenerator', async (req, res) => {
   }
 });
 
-// Ruta para obtener una pregunta de manera aleatoria
-app.get('/getRandomQuestionGenerator', async (req, res) => {
-  try {
-    const rQuestion = await QuestionGenerator.aggregate([{ $sample: { size: 1 } }]);
-    const q = rQuestion[0];
-
-    res.json(q);
-  } catch (error) {
-    res.status(500).json({ error: 'Internal Server Error' });
-  }
-});
-
 // Ruta para eliminar la primera pregunta de la base de datos
 app.delete('/deleteFirstQuestionGenerator', async (req, res) => {
   try {

questions/questiongeneratorservice/questiongenerator-service.test.js

@@ -7,28 +7,57 @@ let mongoServer;
 let app;
 
 //test question generator
-const question = {
+const questionLit = {
     questionBody: "¿Quién escribió la novela 'El Extranjero'?",
     correcta: 'Albert Camus',
     incorrectas: ['George Orwell','Franz Kafka','José Saramago'],
     numquest: 1,
-    typeQuestion: 'literatura'
+    typeQuestion: 'libro_autor'
 };
-const question2 = {
+const questionUpdated = {
+    questionBody: "¿Quién escribió la novela 'El Extranjero'?",
+    correcta: 'Albert Camus',
+    incorrectas: ['Miguel Delibes','Osamu Dazai','Franz Kafka'],
+    numquest: 4,
+    typeQuestion: 'libro_autor'
+};
+const questionLit2 = {
     questionBody: "¿En qué año se publicó 'Romancero Gitano' de Federico García Lorca?",
     correcta: '1928',
     incorrectas: ['1934','1926','1950'],
     numquest: 2,
-    typeQuestion: 'literatura'
+    typeQuestion: 'libro_anio'
+};
+const questionLit3 = {
+    questionBody: "¿A qué género literario pertenece 'Cinco horas con Mario'?",
+    correcta: 'Narrativo',
+    incorrectas: ['Ensayo','Teatro','Poesía'],
+    numquest: 2,
+    typeQuestion: 'libro_genero'
 };
-const question3 = {
+const questionDep = {
     questionBody: "¿En qué año nació 'The Special One' (José Mourinho)?",
     correcta: '1963',
     incorrectas: ['1950','1971','1968'],
     numquest: 3,
-    typeQuestion: 'deportes'
+    typeQuestion: 'deporte_anio'
+};
+const questionMusic = {
+    questionBody: "¿De qué grupo es la canción 'Vino Tinto'?",
+    correcta: 'Estopa',
+    incorrectas: ['U2','Los Chunguitos','ACDC'],
+    numquest: 3,
+    typeQuestion: 'cancion_cantante'
+};
+const questionCountries = {
+    questionBody: "¿Cuál es la capital de Portugal?",
+    correcta: 'Lisboa',
+    incorrectas: ['Madrid','Oporto','Langreo'],
+    numquest: 3,
+    typeQuestion: 'pais_capital'
 };
 
+
 beforeAll(async () => {
     mongoServer = await MongoMemoryServer.create();
     const mongoUri = mongoServer.getUri();
@@ -43,14 +72,27 @@ afterAll(async () => {
 
 describe('Question Generator Service', () => {
     it('Should perform an addOrUpdate operation /addOrUpdateQuestionGenerator', async () => {
-        const response = await request(app).post('/addOrUpdateQuestionGenerator').send(question);
+        const response = await request(app).post('/addOrUpdateQuestionGenerator').send(questionLit);
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty('questionBody', "¿Quién escribió la novela 'El Extranjero'?");
         expect(response.body).toHaveProperty('correcta', 'Albert Camus');
         expect(response.body).toHaveProperty('incorrectas', ['George Orwell','Franz Kafka','José Saramago']);
         expect(response.body).toHaveProperty('numquest', 1);
     });
 
+    it('Should perform two addOrUpdate operation /addOrUpdateQuestionGenerator for the same question', async () => {
+        // Actualizamos las respuestas incorrectas
+        const secondResponse = await request(app).post('/addOrUpdateQuestionGenerator').send(questionUpdated);
+        const todasIncorrectas = ['Miguel Delibes','Osamu Dazai','Franz Kafka','José Saramago','George Orwell'];
+
+        expect(secondResponse.status).toBe(200);
+        expect(secondResponse.body).toHaveProperty('questionBody', "¿Quién escribió la novela 'El Extranjero'?");
+        expect(secondResponse.body).toHaveProperty('correcta', 'Albert Camus');
+        // Comprueba que todos los valores de todasIncorrectas están contenidos en secondResponse.body.incorrectas
+        todasIncorrectas.every(val => expect(secondResponse.body.incorrectas).toContain(val));        
+        expect(secondResponse.body).toHaveProperty('numquest', 4);
+    });
+
     it('Should get the last question added /getAllQuestionGenerator', async () => {
         const response = await request(app).get(`/getAllQuestionGenerator`);
 
@@ -59,14 +101,14 @@ describe('Question Generator Service', () => {
     });
 
     it('Should perform two addOrUpdate operation /addOrUpdateQuestionGenerator', async () => {
-        const response = await request(app).post('/addOrUpdateQuestionGenerator').send(question3);
+        const response = await request(app).post('/addOrUpdateQuestionGenerator').send(questionDep);
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty('questionBody', "¿En qué año nació 'The Special One' (José Mourinho)?");
         expect(response.body).toHaveProperty('correcta', '1963');
         expect(response.body).toHaveProperty('incorrectas', ['1950','1971','1968']);
         expect(response.body).toHaveProperty('numquest', 3);
 
-        const response2 = await request(app).post('/addOrUpdateQuestionGenerator').send(question2);
+        const response2 = await request(app).post('/addOrUpdateQuestionGenerator').send(questionLit2);
         expect(response2.status).toBe(200);
         expect(response2.body).toHaveProperty('questionBody', "¿En qué año se publicó 'Romancero Gitano' de Federico " +
                                                                 "García Lorca?");
@@ -82,25 +124,97 @@ describe('Question Generator Service', () => {
         expect(response.body.length).toBe(3);
     });
 
-    it('Should get one random question /getRandomQuestionGenerator', async () => {
-        const response = await request(app).get(`/getRandomQuestionGenerator`);
+    // comienzan los tests para extraer preguntas por temática determinada
+    it('Should get one random question /getRandomQuestionDeporte', async () => {
+        await request(app).post('/addOrUpdateQuestionGenerator').send(questionDep);
+
+        const response = await request(app).get(`/getRandomQuestionDeporte`);
+        const tiposValidos = ['equipo_estadio','estadio_capacidad', 'estadio_ciudad', 'equipo_deporte', 'deporte_anio','deportista_anio' ];
 
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty('questionBody');
         expect(response.body).toHaveProperty('correcta');
         expect(response.body).toHaveProperty('incorrectas');
         expect(response.body).toHaveProperty('numquest');
+        expect(tiposValidos).toContain(response.body.typeQuestion);
     });
+    it('Should get one random question /getRandomQuestionAnio', async () => {
+        const response = await request(app).get(`/getRandomQuestionAnio`);
+        const tiposValidos = ['deporte_anio', 'deportista_anio', 'cancion_anio', 'libro_anio', 'cantante_anio'];
 
-    it('Should count 2 generated questions in the database /countQuestionGenerator', async () => {
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+        expect(tiposValidos).toContain(response.body.typeQuestion);
+    });
+    it('Should get one random question /getRandomQuestionMusica', async () => {
+        await request(app).post('/addOrUpdateQuestionGenerator').send(questionMusic);
+
+        const response = await request(app).get(`/getRandomQuestionMusica`);
+        const tiposValidos = ['cancion_cantante', 'cancion_album', 'cancion_anio', 'cantante_anio']; 
+
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+        expect(tiposValidos).toContain(response.body.typeQuestion);
+    });
+    it('Should get one random question /getRandomQuestionLibro', async () => {
+        const response = await request(app).get(`/getRandomQuestionLibro`);
+        const tiposValidos = ['libro_autor', 'libro_genero', 'libro_anio']; 
+
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+        expect(tiposValidos).toContain(response.body.typeQuestion);
+    });
+    it('Should get one random question /getRandomQuestionPaisYGeo', async () => {
+        await request(app).post('/addOrUpdateQuestionGenerator').send(questionCountries);
+
+        const response = await request(app).get(`/getRandomQuestionPaisYGeo`);
+        const tiposValidos = ['pais_capital', 'pais_poblacion', 'ciudad_pais', 'montana_altura', 'pais_moneda', 'rio_pais', 'lago_pais'];
+
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+        expect(tiposValidos).toContain(response.body.typeQuestion);
+    });
+    // fin test extraer preguntas por temática determinada
+
+    it('Should count 5 generated questions in the database /countQuestionGenerator', async () => {
         const response = await request(app).get('/countQuestionGenerator');
 
+        const res = await request(app).get(`/getAllQuestionGenerator`);
+
         expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('count', 3);
+        expect(response.body).toHaveProperty('count', 5);
     });
 
-    it('Should delete the first question added /deleteFirstQuestionGenerator', async () => {
-       const response = await request(app).delete('/deleteFirstQuestionGenerator');
+    it('Should delete the 3 first questions added /deleteFirstQuestionGenerator', async () => {
+        let response = await request(app).delete('/deleteFirstQuestionGenerator');
+
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+
+        response = await request(app).delete('/deleteFirstQuestionGenerator');
+
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('questionBody');
+        expect(response.body).toHaveProperty('correcta');
+        expect(response.body).toHaveProperty('incorrectas');
+        expect(response.body).toHaveProperty('numquest');
+
+        response = await request(app).delete('/deleteFirstQuestionGenerator');
 
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty('questionBody');
@@ -143,7 +257,7 @@ describe('Question Generator Service', () => {
         expect(response.body).toHaveProperty('numquest');
     });
 
-    it('Should count 1 generated questions in the database /countQuestionGenerator', async () => {
+    it('Should count 0 generated questions in the database /countQuestionGenerator', async () => {
         const response = await request(app).get('/countQuestionGenerator');
 
         expect(response.status).toBe(200);