feat(test): testing circles

middlewares/circles.js

@@ -1,5 +1,7 @@
 const { Circle } = require('../models');
 const errors = require('../lib/errors');
+const helpers = require('../lib/helpers');
+const { Sequelize, sequelize } = require('../lib/sequelize');
 
 exports.listAllCircles = async (req, res) => {
     const circle = await Circle.findAll({});
@@ -49,15 +51,25 @@ exports.deleteCircle = async (req, res) => {
 };
 
 exports.setParentCircle = async (req, res) => {
+    if (!helpers.isNumber(req.body.parent_circle)) {
+        return errors.makeBadRequestError(res, 'The circle ID is not valid.');
+    }
+
     // TODO: check permissions
-    const parentCircle = await Circle.findByPk(req.body.id);
+    const parentCircle = await Circle.findByPk(req.body.parent_circle);
     if (!parentCircle) {
         return errors.makeNotFoundError(res, 'No parent circle found.');
     }
 
-    await req.currentCircle.update({ parent_circle_id: parentCircle.id });
-
-    // TODO: check if there are any loops in the chain.
+    try {
+        // need to check after the update if there are any loops
+        await sequelize.transaction(async (t) => {
+            await req.currentCircle.update({ parent_circle_id: parentCircle.id }, { transaction: t });
+            await Circle.throwIfAnyLoops(t);
+        });
+    } catch (err) {
+        return errors.makeValidationError(res, err);
+    }
 
     return res.json({
         success: true,

models/Circle.js

@@ -24,4 +24,41 @@ const Circle = sequelize.define('circle', {
     updatedAt: 'updated_at',
 });
 
+// Checking if there isn't a loop inside circles (so no circle1 -> circle2 -> circle1).
+Circle.throwIfAnyLoops = async function throwIfAnyLoops(transaction) {
+    // Firstly, loading all bound circles.
+    const circles = await Circle.findAll({ transaction });
+    const boundCircles = circles.filter(circle => circle.parent_circle_id !== null);
+
+    // Secondly, creating a map of circles visited.
+    let visibleCircles = {};
+
+    // Then, defining a function that we'll call recursively.
+    const markCircleAsVisible = (circle) => {
+        // means that we'be been there before
+        if (visibleCircles[circle.id]) {
+            throw new Error(`There's a loop in circles, check ID ${circle.id}`);
+        }
+
+        // now we haven't been here before, let's mark this circle as visited
+        // and move on to its parent circle
+        visibleCircles[circle.id] = true;
+        if (!circle.parent_circle_id) {
+            return;
+        }
+
+        const parentCircle = circles.find(c => c.id === circle.parent_circle_id);
+        markCircleAsVisible(parentCircle);
+    }
+
+    // Lastly, call this function for all circles.
+    for (const circle of boundCircles) {
+        markCircleAsVisible(circle);
+
+        // Only counting loops within one chain.
+        visibleCircles = {};
+    }
+};
+
+
 module.exports = Circle;

test/api/circles-creating.test.js

@@ -0,0 +1,57 @@
+const { startServer, stopServer } = require('../../lib/server.js');
+const { request } = require('../scripts/helpers');
+const generator = require('../scripts/generator');
+
+describe('Circles creating', () => {
+    beforeAll(async () => {
+        await startServer();
+    });
+
+    afterAll(async () => {
+        await stopServer();
+    });
+
+    afterEach(async () => {
+        await generator.clearAll();
+    });
+
+    test('should fail if there are validation errors', async () => {
+        const user = await generator.createUser({ username: 'test', mail_confirmed_at: new Date() });
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = generator.generateCircle({ name: '' });
+
+        const res = await request({
+            uri: '/circles/',
+            method: 'POST',
+            headers: { 'X-Auth-Token': token.value },
+            body: circle
+        });
+
+        expect(res.statusCode).toEqual(422);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).not.toHaveProperty('data');
+        expect(res.body).toHaveProperty('errors');
+        expect(res.body.errors).toHaveProperty('name');
+    });
+
+    test('should succeed if everything is okay', async () => {
+        const user = await generator.createUser({ username: 'test', mail_confirmed_at: new Date() });
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = generator.generateCircle();
+
+        const res = await request({
+            uri: '/circles/',
+            method: 'POST',
+            headers: { 'X-Auth-Token': token.value },
+            body: circle
+        });
+
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.success).toEqual(true);
+        expect(res.body).not.toHaveProperty('errors');
+        expect(res.body).toHaveProperty('data');
+        expect(res.body.data.name).toEqual(circle.name);
+    });
+});

test/api/circles-deleting.test.js

@@ -0,0 +1,55 @@
+const { startServer, stopServer } = require('../../lib/server.js');
+const { request } = require('../scripts/helpers');
+const generator = require('../scripts/generator');
+const { Circle } = require('../../models');
+
+describe('Circles deleting', () => {
+    beforeAll(async () => {
+        await startServer();
+    });
+
+    afterAll(async () => {
+        await stopServer();
+    });
+
+    afterEach(async () => {
+        await generator.clearAll();
+    });
+
+    test('should return 404 if the circle is not found', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const res = await request({
+            uri: '/circles/1337',
+            method: 'DELETE',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(404);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).not.toHaveProperty('data');
+        expect(res.body).toHaveProperty('message');
+    });
+
+    test('should succeed if everything is okay', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = await generator.createCircle();
+
+        const res = await request({
+            uri: '/circles/' + circle.id,
+            method: 'DELETE',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.success).toEqual(true);
+        expect(res.body).not.toHaveProperty('errors');
+        expect(res.body).toHaveProperty('message');
+
+        const circleFromDb = await Circle.findByPk(circle.id);
+        expect(circleFromDb).toEqual(null);
+    });
+});

test/api/circles-details.test.js

@@ -0,0 +1,68 @@
+const { startServer, stopServer } = require('../../lib/server.js');
+const { request } = require('../scripts/helpers');
+const generator = require('../scripts/generator');
+
+describe('Circle details', () => {
+    beforeAll(async () => {
+        await startServer();
+    });
+
+    afterAll(async () => {
+        await stopServer();
+    });
+
+    afterEach(async () => {
+        await generator.clearAll();
+    });
+
+    test('should return 404 if the circle is not found', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const res = await request({
+            uri: '/circles/1337',
+            method: 'GET',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(404);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).not.toHaveProperty('data');
+        expect(res.body).toHaveProperty('message');
+    });
+
+    test('should return 400 if id us not a number', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const res = await request({
+            uri: '/circles/xxx',
+            method: 'GET',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(400);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).toHaveProperty('message');
+        expect(res.body).not.toHaveProperty('data');
+    });
+
+    test('should find the circle by id', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = await generator.createCircle();
+
+        const res = await request({
+            uri: '/circles/' + circle.id,
+            method: 'GET',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.success).toEqual(true);
+        expect(res.body).toHaveProperty('data');
+        expect(res.body).not.toHaveProperty('errors');
+        expect(res.body.data.id).toEqual(circle.id);
+    });
+});

test/api/circles-editing.test.js

@@ -0,0 +1,74 @@
+const { startServer, stopServer } = require('../../lib/server.js');
+const { request } = require('../scripts/helpers');
+const generator = require('../scripts/generator');
+
+describe('Circle details', () => {
+    beforeAll(async () => {
+        await startServer();
+    });
+
+    afterAll(async () => {
+        await stopServer();
+    });
+
+    afterEach(async () => {
+        await generator.clearAll();
+    });
+
+    test('should return 404 if the circle is not found', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const res = await request({
+            uri: '/circles/1337',
+            method: 'PUT',
+            headers: { 'X-Auth-Token': token.value },
+            body: { name: 'New name' }
+        });
+
+        expect(res.statusCode).toEqual(404);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).not.toHaveProperty('data');
+        expect(res.body).toHaveProperty('message');
+    });
+
+    test('should fail if there are validation errors', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = await generator.createCircle();
+
+        const res = await request({
+            uri: '/circles/' + circle.id,
+            method: 'PUT',
+            headers: { 'X-Auth-Token': token.value },
+            body: { name: '' }
+        });
+
+        expect(res.statusCode).toEqual(422);
+        expect(res.body.success).toEqual(false);
+        expect(res.body).not.toHaveProperty('data');
+        expect(res.body).toHaveProperty('errors');
+        expect(res.body.errors).toHaveProperty('name');
+    });
+
+    test('should succeed if everything is okay', async () => {
+        const user = await generator.createUser();
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = await generator.createCircle();
+
+        const res = await request({
+            uri: '/circles/' + circle.id,
+            method: 'PUT',
+            headers: { 'X-Auth-Token': token.value },
+            body: { name: 'New name' }
+        });
+
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.success).toEqual(true);
+        expect(res.body).not.toHaveProperty('errors');
+        expect(res.body).toHaveProperty('data');
+        expect(res.body.data.name).toEqual('New name');
+    });
+});

test/api/circles-listing.test.js

@@ -0,0 +1,39 @@
+const { startServer, stopServer } = require('../../lib/server.js');
+const { request } = require('../scripts/helpers');
+const generator = require('../scripts/generator');
+
+describe('Circles list', () => {
+    beforeAll(async () => {
+        await startServer();
+    });
+
+    afterAll(async () => {
+        await stopServer();
+    });
+
+    afterEach(async () => {
+        await generator.clearAll();
+    });
+
+
+    test('should succeed when everything is okay', async () => {
+        const user = await generator.createUser({ password: 'test', mail_confirmed_at: new Date() });
+        const token = await generator.createAccessToken({}, user);
+
+        const circle = await generator.createCircle();
+
+        const res = await request({
+            uri: '/circles',
+            method: 'GET',
+            headers: { 'X-Auth-Token': token.value }
+        });
+
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.success).toEqual(true);
+        expect(res.body).toHaveProperty('data');
+        expect(res.body).not.toHaveProperty('errors');
+
+        expect(res.body.data.length).toEqual(1);
+        expect(res.body.data[0].id).toEqual(circle.id);
+    });
+});