feat: memoria passando resposta correta caso peça posições pressionadas em etapas anteriores e retornando erro caso a etapa atual nao tenha 5 itens.

lvolcov · lvolcov · commit 137d0e2ca768 · 2021-01-24T11:55:52.000Z
#12
diff --git a/src/622/modules/memoria/index.js b/src/622/modules/memoria/index.js
@@ -1,14 +1,18 @@
 /**
    * Função que resolve o módulo Memória
-   * @param {string[]} previousStep - Array que traz as arrays das interações anteriores e suas respostas
+   * @param {string[]} previousSteps - Array que traz as arrays das interações anteriores e suas respostas
    * @param {string[]} currentStep - Array que traz a informação da interação atual
    * @returns {string[]} Array com as arrays das interações anteriores e a atual, todas com as suas respectivas respostas
+   * @throws {CURRENT_STEP_INCOMPLETED} A array com o passo atual precisa ter 5 itens.
    */
 
 
-const memoria = (previousStep, currentStep) => {
+const memoria = (previousSteps, currentStep) => {
+    if (currentStep.length !== 5){
+        throw 'CURRENT_STEP_INCOMPLETED'
+    }
     let answer
-    switch(previousStep.length) {
+    switch(previousSteps.length) {
         case 0:
             switch(currentStep[0]){
                 case 1: answer = currentStep[2]; break;
@@ -20,39 +24,39 @@ const memoria = (previousStep, currentStep) => {
       case 1:
             switch(currentStep[0]){ 
                 case 1: answer = 4; break;
-                case 2: answer = previousStep[0][5]; break;
+                case 2: answer = currentStep[previousSteps[0].indexOf(previousSteps[0][5],1)]; break;
                 case 3: answer = currentStep[1]; break;
-                case 4: answer = previousStep[0][5]; break;
+                case 4: answer = currentStep[previousSteps[0].indexOf(previousSteps[0][5],1)]; break;
             }
             break
         case 2:
             switch(currentStep[0]){
-                case 1: answer = previousStep[1][5]; break;
-                case 2: answer = previousStep[0][5]; break;
+                case 1: answer = previousSteps[1][5]; break;
+                case 2: answer = previousSteps[0][5]; break;
                 case 3: answer = currentStep[3]; break;
                 case 4: answer = 4; break;
             }
             break
         case 3:
             switch(currentStep[0]){
-                case 1: answer = previousStep[0][5]; break;
+                case 1: answer = currentStep[previousSteps[0].indexOf(previousSteps[0][5],1)]; break;
                 case 2: answer = currentStep[1]; break;
-                case 3: answer = previousStep[1][5]; break;
-                case 4: answer = previousStep[1][5]; break;
+                case 3: answer = currentStep[previousSteps[1].indexOf(previousSteps[1][5],1)]; break;
+                case 4: answer = currentStep[previousSteps[1].indexOf(previousSteps[1][5],1)]; break;
             }
             break
         case 4:
             switch(currentStep[0]){
-                case 1: answer = previousStep[0][5]; break;
-                case 2: answer = previousStep[1][5]; break;
-                case 3: answer = previousStep[3][5]; break;
-                case 4: answer = previousStep[2][5]; break;
+                case 1: answer = previousSteps[0][5]; break;
+                case 2: answer = previousSteps[1][5]; break;
+                case 3: answer = previousSteps[3][5]; break;
+                case 4: answer = previousSteps[2][5]; break;
             }
             break
     }
     currentStep.push(answer)
-    previousStep.push(currentStep)
-    return previousStep
-  }
+    previousSteps.push(currentStep)
+    return previousSteps
+}
   
-  module.exports = memoria
+module.exports = memoria
diff --git a/src/622/modules/memoria/index.test.js b/src/622/modules/memoria/index.test.js
@@ -2,182 +2,61 @@ const memoria = require('./index')
 
 describe('memoria', () => {
     describe('passo 1', () => {
-        let answer 
-
-        previousStep0 = []
-        currentStep0 = [1, 1, 3, 4, 2]
-        expectAnswerStep0 = [[1, 1, 3, 4, 2, 3]]
-        it('deveria retornar 3', () => {
-            const resp = memoria(previousStep0, currentStep0)
-            expect(resp).toStrictEqual(expectAnswerStep0)
-        })
-
-        previousStep1 = []
-        currentStep1 = [2, 3, 4, 1, 2]
-        expectAnswerStep1 = [[2, 3, 4, 1, 2, 4]]
-        it('deveria retornar 4', () => {
-          const resp = memoria(previousStep1, currentStep1)
-          expect(resp).toStrictEqual(expectAnswerStep1)
-        })
-
-        previousStep2 = []
-        currentStep2 = [3, 4, 1, 3, 2]
-        expectAnswerStep2 = [[3, 4, 1, 3, 2, 3]]
-        it('deveria retornar 3', () => {
-          const resp = memoria(previousStep2, currentStep2)
-          expect(resp).toStrictEqual(expectAnswerStep2)
-        })
-
-        previousStep3 = []
-        currentStep3 = [4, 3, 4, 1, 2]
-        expectAnswerStep3 = [[4, 3, 4, 1, 2, 2]]
-        it('deveria retornar 2', () => {
-          const resp = memoria(previousStep3, currentStep3)
-          expect(resp).toStrictEqual(expectAnswerStep3)
+      it('Deveria retornar 3 se o número no visor do primeiro passo é 1 e o botão na segunda posição é 3', () => {
+          previousSteps = []
+          currentStep = [1, 1, 3, 4, 2]
+          expectAnswerStep = [[1, 1, 3, 4, 2, 3]]
+          const resp = memoria(previousSteps, currentStep)
+          expect(resp).toStrictEqual(expectAnswerStep)
         })
     })
 
     describe('passo 2', () => {
-      let answer 
-
-      previousStep4 = [[1, 1, 3, 4, 2, 3]]
-      currentStep4 = [2, 3, 4, 1, 2]
-      expectAnswerStep4 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3]]
-      it('deveria retornar 3', () => {
-          const resp = memoria(previousStep4, currentStep4)
-          expect(resp).toStrictEqual(expectAnswerStep4)
-      })
-
-      previousStep5 = [[2, 3, 4, 1, 2, 4]]
-      currentStep5 = [3, 4, 1, 3, 2]
-      expectAnswerStep5 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep5, currentStep5)
-        expect(resp).toStrictEqual(expectAnswerStep5)
-      })
-
-      previousStep6 = [[3, 4, 1, 3, 2, 3]]
-      currentStep6 = [4, 3, 4, 1, 2]
-      expectAnswerStep6 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3]]
-      it('deveria retornar 3', () => {
-        const resp = memoria(previousStep6, currentStep6)
-        expect(resp).toStrictEqual(expectAnswerStep6)
-      })
-
-      previousStep7 = [[4, 3, 4, 1, 2, 2]]
-      currentStep7 = [1, 1, 3, 4, 2]
-      expectAnswerStep7 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep7, currentStep7)
-        expect(resp).toStrictEqual(expectAnswerStep7)
+      it('Deveria retornar 1 se o número no visor do segundo passo é 4, a posição pressionada no passo 1 foi a terceira posição e o número que está na terceira posição do estágio atual é 1', () => {
+        previousSteps = [[3, 4, 1, 3, 2, 3]]
+        currentStep = [4, 3, 4, 1, 2]
+        expectAnswerStep = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 1]]
+        const resp = memoria(previousSteps, currentStep)
+        expect(resp).toStrictEqual(expectAnswerStep)
       })
     })
 
     describe('passo 3', () => {
-      let answer 
-
-      previousStep8 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3]]
-      currentStep8 = [3, 4, 1, 3, 2]
-      expectAnswerStep8 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3]]
-      it('deveria retornar 3', () => {
-          const resp = memoria(previousStep8, currentStep8)
-          expect(resp).toStrictEqual(expectAnswerStep8)
-      })
-
-      previousStep9 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4]]
-      currentStep9 = [4, 3, 4, 1, 2]
-      expectAnswerStep9 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep9, currentStep9)
-        expect(resp).toStrictEqual(expectAnswerStep9)
-      })
-
-      previousStep10 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3]]
-      currentStep10 = [1, 1, 3, 4, 2]
-      expectAnswerStep10 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3]]
-      it('deveria retornar 3', () => {
-        const resp = memoria(previousStep10, currentStep10)
-        expect(resp).toStrictEqual(expectAnswerStep10)
-      })
-
-      previousStep11 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4]]
-      currentStep11 = [2, 3, 4, 1, 2]
-      expectAnswerStep11 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 2]]
-      it('deveria retornar 2', () => {
-        const resp = memoria(previousStep11, currentStep11)
-        expect(resp).toStrictEqual(expectAnswerStep11)
+      it('Deveria retornar 4 se o número no visor do terceiro passo é 1, o número do botão pressionado no segundo passo foi 4', () => {
+        previousSteps = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4]]
+        currentStep = [1, 3, 4, 1, 2]
+        expectAnswerStep = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [1, 3, 4, 1, 2, 4]]
+        const resp = memoria(previousSteps, currentStep)
+        expect(resp).toStrictEqual(expectAnswerStep)
       })
     })
 
     describe('passo 4', () => {
-      let answer 
-
-      previousStep12 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3]]
-      currentStep12 = [4, 3, 4, 1, 2]
-      expectAnswerStep12 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3], [4, 3, 4, 1, 2, 3]]
-      it('deveria retornar 3', () => {
-          const resp = memoria(previousStep12, currentStep12)
-          expect(resp).toStrictEqual(expectAnswerStep12)
-      })
-
-      previousStep13 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 4]]
-      currentStep13 = [1, 1, 3, 4, 2]
-      expectAnswerStep13 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 4], [1, 1, 3, 4, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep13, currentStep13)
-        expect(resp).toStrictEqual(expectAnswerStep13)
-      })
-
-      previousStep14 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3]]
-      currentStep14 = [2, 3, 4, 1, 2]
-      expectAnswerStep14 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3], [2, 3, 4, 1, 2, 3]]
-      it('deveria retornar 3', () => {
-        const resp = memoria(previousStep14, currentStep14)
-        expect(resp).toStrictEqual(expectAnswerStep14)
-      })
-
-      previousStep15 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 2]]
-      currentStep15 = [3, 4, 1, 3, 2]
-      expectAnswerStep15 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 2], [3, 4, 1, 3, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep15, currentStep15)
-        expect(resp).toStrictEqual(expectAnswerStep15)
+      it('Deveria retornar 1 se o número no visor do quarto passo é 3, a posição pressionada no passo 2 foi a primeira posição e o número que está na primeira posição do estágio atual é 1', () => {
+        previousSteps = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3]]
+        currentStep = [3, 1, 3, 4, 2]
+        expectAnswerStep = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3], [3, 1, 3, 4, 2, 1]]
+        const resp = memoria(previousSteps, currentStep)
+        expect(resp).toStrictEqual(expectAnswerStep)
       })
     })
 
     describe('passo 5', () => {
-      let answer 
-
-      previousStep16 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3], [4, 3, 4, 1, 2, 3]]
-      currentStep16 = [1, 1, 3, 4, 2]
-      expectAnswerStep16 = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3], [4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3]]
-      it('deveria retornar 3', () => {
-          const resp = memoria(previousStep16, currentStep16)
-          expect(resp).toStrictEqual(expectAnswerStep16)
-      })
-
-      previousStep17 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 4], [1, 1, 3, 4, 2, 4]]
-      currentStep17 = [2, 3, 4, 1, 2]
-      expectAnswerStep17 = [[2, 3, 4, 1, 2, 4],[3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 4], [1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 4]]
-      it('deveria retornar 4', () => {
-        const resp = memoria(previousStep17, currentStep17)
-        expect(resp).toStrictEqual(expectAnswerStep17)
+      it('Deveria retornar 3 se o número no visor do quinto passo é 3, o número do botão pressionado no quarto passo foi 3', () => {
+        previousSteps = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3], [4, 3, 4, 1, 2, 3]]
+        currentStep = [3, 1, 3, 4, 2]
+        expectAnswerStep = [[1, 1, 3, 4, 2, 3],[2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3], [4, 3, 4, 1, 2, 3], [3, 1, 3, 4, 2, 3]]
+        const resp = memoria(previousSteps, currentStep)
+        expect(resp).toStrictEqual(expectAnswerStep)
       })
-
-      previousStep18 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3], [2, 3, 4, 1, 2, 3]]
-      currentStep18 = [3, 4, 1, 3, 2]
-      expectAnswerStep18 = [[3, 4, 1, 3, 2, 3],[4, 3, 4, 1, 2, 3], [1, 1, 3, 4, 2, 3], [2, 3, 4, 1, 2, 3], [3, 4, 1, 3, 2, 3]]
-      it('deveria retornar 3', () => {
-        const resp = memoria(previousStep18, currentStep18)
-        expect(resp).toStrictEqual(expectAnswerStep18)
-      })
-
-      previousStep19 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 2], [3, 4, 1, 3, 2, 4]]
-      currentStep19 = [4, 3, 4, 1, 2]
-      expectAnswerStep19 = [[4, 3, 4, 1, 2, 2],[1, 1, 3, 4, 2, 4], [2, 3, 4, 1, 2, 2], [3, 4, 1, 3, 2, 4], [4, 3, 4, 1, 2, 2]]
-      it('deveria retornar 2', () => {
-        const resp = memoria(previousStep19, currentStep19)
-        expect(resp).toStrictEqual(expectAnswerStep19)
+    })
+    describe('error', () => {
+      it('Deveria lançar uma exceção quando o passo atual não estiver completo (número no visor mais os quatro números nos botões', () => {
+        previousSteps = []
+        currentStep = [1, 1, 3, 2]
+        expect(() => {
+          memoria(previousSteps, currentStep)
+        }).toThrowError('CURRENT_STEP_INCOMPLETED')
       })
     })
 })
