Unit tests CI + Lint CI + Coefficients calc unit tests

.github/workflows/unit_tests.yml

@@ -0,0 +1,60 @@
+name: Unit tests & lint
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  lint:
+    timeout-minutes: 5
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install node
+      uses: actions/setup-node@v1
+      with:
+        node-version: 16.x
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Check lint
+      run: npm run lint
+
+  unit-tests:
+    timeout-minutes: 10
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install Yarn
+      run: npm install -g yarn
+
+    - name: Start docker containers
+      run: cd app && docker-compose -f "docker-compose.yaml" up -d --build
+
+    - name: Install node
+      uses: actions/setup-node@v1
+      with:
+        node-version: 16.x
+
+    - name: Install dependencies
+      run: cd app && yarn install
+
+    - name: Run unit tests
+      run: cd app && yarn run test
+
+    - name: Stop docker containers
+      if: always()
+      run: cd app && docker-compose -f "docker-compose.yaml" down

app/api/comment/create/func.js

@@ -1,23 +1,23 @@
-const app = require("@/app");
-const errors = require("@/errors");
-const Fields = require("@/api/comment/Fields");
-const pickFields = require("@/helpers/parse/pickFields");
+const app = require('@/app')
+const errors = require('@/errors')
+const Fields = require('@/api/comment/Fields')
+const pickFields = require('@/helpers/parse/pickFields')
 
 module.exports = async function (context) {
-  const Comment = app.models.comments;
-  const Enrollment = app.models.enrollments;
+  const Comment = app.models.comments
+  const Enrollment = app.models.enrollments
 
   app.helpers.validate.throwMissingParameter(
-    ["enrollment", "comment", "type"],
+    ['enrollment', 'comment', 'type'],
     context.body
-  );
+  )
 
-  let enrollment = await Enrollment.findById(String(context.body.enrollment));
+  let enrollment = await Enrollment.findById(String(context.body.enrollment))
 
   if (!enrollment)
     throw new errors.BadRequest(
       `Este vínculo não existe: ${context.body.enrollment}`
-    );
+    )
 
   return pickFields(
     await Comment.create({
@@ -30,5 +30,5 @@ module.exports = async function (context) {
       ra: enrollment.ra,
     }),
     Fields
-  );
-};
+  )
+}

app/api/comment/create/spec.js

@@ -1,68 +1,68 @@
-const app = require("@/app");
-const func = require("./func");
-const assert = require("assert");
-const populate = require("@/populate");
+const app = require('@/app')
+const func = require('./func')
+const assert = require('assert')
+const populate = require('@/populate')
 
-describe("POST /v1/comments", async function () {
-  let models;
-  let context;
-  let enrollment;
+describe('POST /v1/comments', async function () {
+  let models
+  let context
+  let enrollment
   beforeEach(async function () {
     models = await populate({
-      operation: "both",
-      only: ["enrollments", "teachers", "subjects", "comments"],
-    });
+      operation: 'both',
+      only: ['enrollments', 'teachers', 'subjects', 'comments'],
+    })
 
-    enrollment = models.enrollments[0];
+    enrollment = models.enrollments[0]
     context = {
       body: {
         enrollment: enrollment._id,
-        comment: "Some comment",
-        type: "pratica",
+        comment: 'Some comment',
+        type: 'pratica',
       },
-    };
-  });
-  describe("func", async function () {
-    describe("with valid params", async function () {
-      it("create and return a filtered comment", async function () {
-        const resp = await func(context);
+    }
+  })
+  describe('func', async function () {
+    describe('with valid params', async function () {
+      it('create and return a filtered comment', async function () {
+        const resp = await func(context)
 
-        assert(resp._id);
-        assert.equal(resp.comment, context.body.comment);
-        assert(resp.createdAt);
-        assert(new Date() > resp.createdAt);
-        assert.equal(resp.enrollment._id, context.body.enrollment);
-        assert.equal(resp.subject, enrollment.subject);
-        assert.equal(resp.teacher, enrollment.mainTeacher);
-        assert.notEqual(resp.ra, enrollment.ra);
+        assert(resp._id)
+        assert.equal(resp.comment, context.body.comment)
+        assert(resp.createdAt)
+        assert(new Date() > resp.createdAt)
+        assert.equal(resp.enrollment._id, context.body.enrollment)
+        assert.equal(resp.subject, enrollment.subject)
+        assert.equal(resp.teacher, enrollment.mainTeacher)
+        assert.notEqual(resp.ra, enrollment.ra)
 
-        const Comment = app.models.comments;
-        const comment = await Comment.findOne({ _id: resp._id });
-        assert(comment);
-      });
-    });
-    describe("with invalid params", async function () {
-      it("should throw if enrollment is missing", async function () {
-        delete context.body.enrollment;
-        await assertFuncThrows("MissingParameter", func, context);
-      });
-      it("should throw if comment is missing", async function () {
-        delete context.body.comment;
-        await assertFuncThrows("MissingParameter", func, context);
-      });
-      it("should throw if type is missing", async function () {
-        delete context.body.type;
-        await assertFuncThrows("MissingParameter", func, context);
-      });
-      it("should throw if enrollment is invalid", async function () {
+        const Comment = app.models.comments
+        const comment = await Comment.findOne({ _id: resp._id })
+        assert(comment)
+      })
+    })
+    describe('with invalid params', async function () {
+      it('should throw if enrollment is missing', async function () {
+        delete context.body.enrollment
+        await assertFuncThrows('MissingParameter', func, context)
+      })
+      it('should throw if comment is missing', async function () {
+        delete context.body.comment
+        await assertFuncThrows('MissingParameter', func, context)
+      })
+      it('should throw if type is missing', async function () {
+        delete context.body.type
+        await assertFuncThrows('MissingParameter', func, context)
+      })
+      it('should throw if enrollment is invalid', async function () {
         // Invalid enrollment id
-        context.body.enrollment = models.comments[0]._id;
-        await assertFuncThrows("BadRequest", func, context);
-      });
-      it("should throw if is a duplicated comment", async function () {
-        await func(context);
-        await assertFuncThrows("BadRequest", func, context);
-      });
-    });
-  });
-});
+        context.body.enrollment = models.comments[0]._id
+        await assertFuncThrows('BadRequest', func, context)
+      })
+      it('should throw if is a duplicated comment', async function () {
+        await func(context)
+        await assertFuncThrows('BadRequest', func, context)
+      })
+    })
+  })
+})

app/api/disciplinas/disciplinaId/kicks/func.js

@@ -1,56 +1,56 @@
-const _ = require("lodash");
-const app = require("@/app");
-const errors = require("@/errors");
+const _ = require('lodash')
+const app = require('@/app')
+const errors = require('@/errors')
 
 module.exports = async function (context) {
-  let { disciplinaId } = context.params;
-  let { sort } = context.query;
+  let { disciplinaId } = context.params
+  let { sort } = context.query
 
   if (!disciplinaId) {
-    throw new errors.BadRequest.MissingParameter("disciplinaId");
+    throw new errors.BadRequest.MissingParameter('disciplinaId')
   }
 
-  const season = app.helpers.season.findSeasonKey();
-  const Disciplinas = app.models.disciplinas.bySeason(season);
-  const Alunos = app.models.alunos.bySeason(season);
-  const findId = app.helpers.courses.findId;
+  const season = app.helpers.season.findSeasonKey()
+  const Disciplinas = app.models.disciplinas.bySeason(season)
+  const Alunos = app.models.alunos.bySeason(season)
+  const findId = app.helpers.courses.findId
 
   // find disciplina
-  let disciplina = await Disciplinas.findOne({ disciplina_id: disciplinaId });
+  let disciplina = await Disciplinas.findOne({ disciplina_id: disciplinaId })
 
   if (!disciplina) {
-    throw new errors.NotFound("disciplina");
+    throw new errors.NotFound('disciplina')
   }
 
   // create sort mechanism
-  const kicks = sort ? sort : kickRule(disciplina);
-  const order = Array(kicks.length || 0).fill("desc");
+  const kicks = sort ? sort : kickRule(disciplina)
+  const order = Array(kicks.length || 0).fill('desc')
 
   // turno must have a special treatment
-  const turnoIndex = kicks.indexOf("turno");
+  const turnoIndex = kicks.indexOf('turno')
   if (turnoIndex != -1) {
-    order[turnoIndex] = disciplina.turno == "diurno" ? "asc" : "desc";
+    order[turnoIndex] = disciplina.turno == 'diurno' ? 'asc' : 'desc'
   }
 
   const isAfterKick = _(disciplina.after_kick).castArray().compact().value()
-    .length;
-  const result = resolveMatriculas(disciplina, isAfterKick);
+    .length
+  const result = resolveMatriculas(disciplina, isAfterKick)
 
-  const resultMap = new Map([...result.map((r) => [r.aluno_id, r])]);
+  const resultMap = new Map([...result.map((r) => [r.aluno_id, r])])
   let students = await Alunos.aggregate([
-    { $match: { aluno_id: { $in: _.map(result, "aluno_id") } } },
-    { $unwind: "$cursos" },
-  ]);
+    { $match: { aluno_id: { $in: _.map(result, 'aluno_id') } } },
+    { $unwind: '$cursos' },
+  ])
 
   const interIds = [
-    await findId("Bacharelado em Ciência e Tecnologia", season),
-    await findId("Bacharelado em Ciência e Humanidades", season),
-  ];
+    await findId('Bacharelado em Ciência e Tecnologia', season),
+    await findId('Bacharelado em Ciência e Humanidades', season),
+  ]
 
-  const obrigatorias = _.pull(disciplina.obrigatorias, ...interIds);
+  const obrigatorias = _.pull(disciplina.obrigatorias, ...interIds)
 
   students = students.map((s) => {
-    const reserva = _.includes(obrigatorias, s.cursos.id_curso);
+    const reserva = _.includes(obrigatorias, s.cursos.id_curso)
 
     return _.extend(
       {
@@ -63,15 +63,15 @@ module.exports = async function (context) {
         curso: s.cursos.nome_curso,
       },
       resultMap.get(s.aluno_id) || {}
-    );
-  });
+    )
+  })
 
-  return _(students).orderBy(kicks, order).uniqBy("aluno_id").value();
-};
+  return _(students).orderBy(kicks, order).uniqBy('aluno_id').value()
+}
 
 function kickRule(disciplina) {
-  const season = app.helpers.season.findSeasonKey();
-  let coeffRule = null;
+  const season = app.helpers.season.findSeasonKey()
+  let coeffRule = null
   if (
     season == "2020:2" ||
     season == "2020:3" ||
@@ -80,30 +80,30 @@ function kickRule(disciplina) {
     season == "2021:3" ||
     season == "2022:1"
   ) {
-    coeffRule = ["cp", "cr"];
+    coeffRule = ['cp', 'cr']
   } else {
-    coeffRule = disciplina.ideal_quad ? ["cr", "cp"] : ["cp", "cr"];
+    coeffRule = disciplina.ideal_quad ? ['cr', 'cp'] : ['cp', 'cr']
   }
-  return ["reserva", "turno", "ik"].concat(coeffRule);
+  return ['reserva', 'turno', 'ik'].concat(coeffRule)
 }
 
 function resolveMatriculas(disciplina, isAfterKick) {
   // if kick has not arrived, not one has been kicked
   if (!isAfterKick) {
     return (disciplina.alunos_matriculados || []).map((d) => ({
       aluno_id: d,
-    }));
+    }))
   }
 
   // check diff between before_kick and after_kick
   let kicked = _.difference(
     disciplina.before_kick || [],
     disciplina.after_kick || []
-  );
+  )
 
   // return who has been kicked
   return disciplina.before_kick.map((d) => ({
     aluno_id: d,
     kicked: kicked.includes(d),
-  }));
+  }))
 }