Vote for ideas (#51)

* vote for ideas: POST /ideas/:id/votes

* Remove vote from idea DELETE /ideas/:id/votes/vote

* show amount of up and down votes and my vote when GET /ideas/:id

* generalize votes for other objects

use it to vote for comments

* add error messages, remove TODO comment

apidoc.raml

@@ -421,6 +421,14 @@ types:
           403:
           404:
       get:
+    /votes:
+      post:
+        description: Vote for an idea.
+        responses:
+          201:
+          400:
+          403:
+          404:
 /comments:
   /{id}:
     patch:

app.js

@@ -71,6 +71,9 @@ app.use('/messages', require('./routes/messages'));
 app.use('/account', require('./routes/account'));
 app.use('/contacts', require('./routes/contacts'));
 app.use('/ideas', require('./routes/ideas'));
+// vote for ideas, ...
+app.use('/ideas', require('./routes/votes'));
+app.use('/comments', require('./routes/votes'));
 
 // following are route factories
 // they need to know what is the primary object (i.e. idea, comment, etc.)

collections.js

@@ -117,6 +117,19 @@ module.exports = {
         fields: ['creator']
       }
     ]
+  },
+
+  votes: {
+    type: 'edge',
+    from: ['users'],
+    to: ['ideas', 'comments'],
+    indexes: [
+      {
+        type: 'hash',
+        fields: ['_from', '_to'],
+        unique: true
+      }
+    ]
   }
 
 };

controllers/comments.js

@@ -57,6 +57,9 @@ module.exports = function controllersFactory(primary) {
    * Middleware to read comments of a primary object (i.e. idea)
    */
   async function get(req, res, next) {
+
+    const { username } = req.auth;
+
     try {
       // gather data
       const { id } = req.params;
@@ -67,6 +70,20 @@ module.exports = function controllersFactory(primary) {
       // read the comments from database
       const comments = await models.comment.readCommentsOf(primary, { offset, limit, sort });
 
+      // read votes of comments
+      if (comment === 'comment') {
+        const ids = comments.map(comment => comment.id);
+        // read votes of the comments from database
+        const votes = await models.vote.readVotesToMany({ type: 'comments', ids });
+        const myVotes = await models.vote.readMany({ from: username, to: { type: 'comments', ids } });
+
+        // add the votes to their comments
+        comments.forEach((comment, i) => {
+          comment.votes = votes[i];
+          comment.myVote = myVotes[i];
+        });
+      }
+
       // serialize the comments
       const serializedComments = serialize.comment(comments);
 

controllers/ideas.js

@@ -35,12 +35,17 @@ async function get(req, res, next) {
   try {
     // gather data
     const { id } = req.params;
+    const { username } = req.auth;
 
     // read the idea from database
     const idea = await models.idea.read(id);
 
     if (!idea) return res.status(404).json({ });
 
+    // see how many votes were given to idea and if/how logged user voted (0, -1, 1)
+    idea.votes = await models.vote.readVotesTo({ type: 'ideas', id });
+    idea.myVote = await models.vote.read({ from: username, to: { type: 'ideas', id } });
+
     // serialize the idea (JSON API)
     const serializedIdea = serialize.idea(idea);
 

controllers/validators/index.js

@@ -9,4 +9,5 @@ exports.account = require('./account');
 exports.users = require('./users');
 exports.tags = require('./tags');
 exports.userTags = require('./user-tags');
+exports.votes = require('./votes');
 exports.params = require('./params');

controllers/validators/schema/definitions.js

@@ -126,6 +126,11 @@ module.exports = {
       pattern: '\\S' // at least one non-space character
     }
   },
+  vote: {
+    value: {
+      enum: [-1, 1]
+    }
+  },
   query: {
     page: {
       properties: {

controllers/validators/schema/index.js

@@ -12,8 +12,9 @@ const account = require('./account'),
       params = require('./params'),
       tags = require('./tags'),
       userTags = require('./user-tags'),
-      users = require('./users');
+      users = require('./users'),
+      votes = require('./votes');
 
 
 module.exports = Object.assign({ definitions }, account, authenticate, avatar,
-  comments, contacts, ideas, ideaTags, messages, params, tags, users, userTags);
+  comments, contacts, ideas, ideaTags, messages, params, tags, users, userTags, votes);

controllers/validators/schema/paths.js

@@ -23,5 +23,6 @@ module.exports = {
   title: { $ref: 'sch#/definitions/idea/titl' },
   detail: { $ref: 'sch#/definitions/idea/detail' },
   content: { $ref: 'sch#/definitions/comment/content' },
-  id: { $ref: 'sch#/definitions/shared/objectId' }
+  id: { $ref: 'sch#/definitions/shared/objectId' },
+  voteValue: { $ref: 'sch#/definitions/vote/value' },
 };

controllers/validators/schema/votes.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { id, voteValue: value } = require('./paths');
+
+const postVotes = {
+  properties: {
+    params: {
+      properties: { id },
+      required: ['id'],
+      additionalProperties: false
+    },
+    body: {
+      properties: { value },
+      required: ['value'],
+      additionalProperties: false
+    },
+    required: ['body', 'params']
+  }
+};
+
+const deleteVote = {
+  properties: {
+    params: {
+      properties: { id },
+      required: ['id'],
+      additionalProperties: false
+    },
+    required: ['params']
+  }
+};
+
+module.exports = { deleteVote, postVotes };

controllers/validators/votes.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const validate = require('./validate-by-schema');
+
+const del = validate('deleteVote');
+const post = validate('postVotes');
+
+module.exports = { del, post };

controllers/votes.js

@@ -0,0 +1,91 @@
+const path = require('path'),
+      models = require(path.resolve('./models')),
+      serializers = require(path.resolve('./serializers'));
+
+/**
+ * Middleware to POST a vote to idea (and other objects in the future)
+ */
+async function post(req, res, next) {
+
+  // read data from request
+  const { id } = req.params;
+  const { value } = req.body;
+  const { username } = req.auth;
+
+  // what is the type of the object we vote for (i.e. ideas, comments, ...)
+  const primarys = req.baseUrl.substring(1);
+  const primary = primarys.slice(0, -1);
+
+  try {
+    // save the vote to database
+    const vote = await models.vote.create({ from: username, to: { type: primarys, id }, value });
+    // respond
+    const serializedVote = serializers.serialize.vote(vote);
+    return res.status(201).json(serializedVote);
+  } catch (e) {
+    // handle errors
+    switch (e.code) {
+      // duplicate vote
+      case 409: {
+        return res.status(409).json({
+          errors: [{
+            status: 409,
+            detail: 'duplicate vote'
+          }]
+        });
+      }
+      // missing idea
+      case 404: {
+        return res.status(404).json({
+          errors: [{
+            status: 404,
+            detail: `${primary} doesn't exist`
+          }]
+        });
+
+      }
+      default: {
+        return next(e);
+      }
+    }
+  }
+}
+
+/**
+ * Middleware to DELETE a vote from an idea (and other objects in the future).
+ */
+async function del(req, res, next) {
+
+  // read data from request
+  const { id } = req.params;
+  const { username } = req.auth;
+
+  // what is the type of the object we vote for (i.e. ideas, comments, ...)
+  const primarys = req.baseUrl.substring(1);
+  const primary = primarys.slice(0, -1);
+
+  try {
+    // remove the vote from database
+    await models.vote.remove({ from: username, to: { type: primarys, id } });
+    // respond
+    return res.status(204).end();
+  } catch (e) {
+    // handle errors
+    switch (e.code) {
+      // primary object or vote doesn't exist
+      case 404: {
+        return res.status(404).json({
+          errors: [{
+            status: 404,
+            detail: `vote or ${primary} doesn't exist`
+          }]
+        });
+      }
+      default: {
+        return next(e);
+      }
+    }
+  }
+}
+
+module.exports = { del, post };

models/index.js

@@ -8,7 +8,8 @@ const comment = require('./comment'),
       model = require('./model'),
       tag = require('./tag'),
       user = require('./user'),
-      userTag = require('./user-tag');
+      userTag = require('./user-tag'),
+      vote = require('./vote');
 
 
 const models = {
@@ -21,4 +22,4 @@ const models = {
   }
 };
 
-module.exports = Object.assign(models, { comment, contact, idea, ideaTag, message, model, tag, user, userTag });
+module.exports = Object.assign(models, { comment, contact, idea, ideaTag, message, model, tag, user, userTag, vote });

models/vote/index.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const path = require('path');
+
+const Model = require(path.resolve('./models/model')),
+      schema = require('./schema');
+
+class Vote extends Model {
+
+  /**
+   * Create a vote.
+   * @param {string} from - username of the vote giver
+   * @param {object} to - receiver object of the vote
+   * @param {string} to.type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string} to.id - id of the receiver
+   * @param {number} value - 1 or -1 - value of the vote
+   * @returns Promise - the saved vote
+   */
+  static async create({ from: username, to: { type, id }, value }) {
+    // generate the vote
+    const vote = schema({ value });
+
+    const query = `
+      FOR u IN users FILTER u.username == @username
+        FOR i IN @@type FILTER i._key == @id
+          LET vote = MERGE(@vote, { _from: u._id, _to: i._id })
+          INSERT vote INTO votes
+
+          LET from = MERGE(KEEP(u, 'username'), u.profile)
+          LET to = MERGE(KEEP(i, 'title', 'detail', 'created'), { id: i._key })
+          LET savedVote = MERGE(KEEP(NEW, 'created', 'value'), { id: NEW._key }, { from }, { to })
+          RETURN savedVote`;
+    const params = { username, '@type': type, id, vote };
+    const cursor = await this.db.query(query, params);
+    const out = await cursor.all();
+
+    // when nothing was created, throw error
+    if (out.length === 0) {
+      const e = new Error('not found');
+      e.code = 404;
+      throw e;
+    }
+
+    // what is the type of the object the vote was given to (important for serialization)
+    out[0].to.type = type;
+
+    return out[0];
+  }
+
+  /**
+   * Read a vote from user to idea or something.
+   * @param {string} from - username of the vote giver
+   * @param {object} to - receiver object of the vote
+   * @param {string} to.type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string} to.id - id of the receiver
+   * @returns Promise - the found vote or undefined
+   */
+  static async read({ from: username, to: { type, id } }) {
+    const query = `
+      FOR u IN users FILTER u.username == @username
+        FOR i IN @@type FILTER i._key == @id
+          FOR v IN votes FILTER v._from == u._id && v._to == i._id
+            RETURN v`;
+    const params = { username, '@type': type, id };
+    const cursor = await this.db.query(query, params);
+
+    return (await cursor.all())[0];
+  }
+
+  /**
+   * Read a vote from user to multiple ideas or comments or something
+   * @param {string} from - username of the vote giver
+   * @param {object} to - receiver object of the vote
+   * @param {string} to.type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string[]} to.ids - array of ids of the receivers
+   * @returns Promise - the array of found votes or nulls
+   */
+  static async readMany({ from: username, to: { type, ids } }) {
+    const query = `
+      FOR id IN @ids
+        LET vote = (FOR u IN users FILTER u.username == @username
+          FOR i IN @@type FILTER i._key == id
+            FOR v IN votes FILTER v._from == u._id && v._to == i._id
+              RETURN v)
+        RETURN vote[0]`;
+    const params = { username, '@type': type, ids };
+    const cursor = await this.db.query(query, params);
+
+    return await cursor.all();
+  }
+
+  /**
+   * Remove a vote.
+   * @param {string} from - username of the vote giver
+   * @param {object} to - receiver object of the vote
+   * @param {string} to.type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string} to.id - id of the receiver
+   * @returns Promise
+   */
+  static async remove({ from: username, to: { type, id } }) {
+    const query = `
+      FOR u IN users FILTER u.username == @username
+        FOR i IN @@type FILTER i._key == @id
+          FOR v IN votes FILTER v._from == u._id AND v._to == i._id
+          REMOVE v IN votes`;
+    const params = { username, '@type': type, id };
+    const cursor = await this.db.query(query, params);
+
+    if (cursor.extra.stats.writesExecuted === 0) {
+      const e = new Error('primary or vote not found');
+      e.code = 404;
+      throw e;
+    }
+  }
+
+  /**
+   * Read votes of a primary object.
+   * @param {string} type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string} id - id of the receiver
+   * @returns Promise - array of votes
+   */
+  static async readVotesTo({ type, id }) {
+    const query = `
+      FOR i IN @@type FILTER i._key == @id
+        FOR v, e IN 1..1 INBOUND i INBOUND votes
+          RETURN e`;
+    const params = { '@type': type, id };
+    const cursor = await this.db.query(query, params);
+
+    return await cursor.all();
+  }
+
+  /**
+   * Read votes of array of primary objects.
+   * @param {string} type - type of the receiver (collection name, i.e. 'ideas')
+   * @param {string[]} ids - array of ids of the receivers
+   * @returns Promise - array of arrays of votes
+   */
+  static async readVotesToMany({ type, ids }) {
+    const query = `
+      FOR id IN @ids
+        LET votes = (FOR i IN @@type FILTER i._key == id
+          FOR v, e IN 1..1 INBOUND i INBOUND votes
+            RETURN e)
+        RETURN votes`;
+    const params = { '@type': type, ids };
+    const cursor = await this.db.query(query, params);
+
+    return await cursor.all();
+  }
+}
+
+module.exports = Vote;

models/vote/schema.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function ({ value, created = Date.now() }) {
+  return { value, created };
+};

routes/votes.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const express = require('express'),
+      path = require('path');
+
+const authorize = require(path.resolve('./controllers/authorize')),
+      voteControllers = require(path.resolve('./controllers/votes')),
+      voteValidators = require(path.resolve('./controllers/validators/votes'));
+
+// create router and controllers
+const router = express.Router();
+
+router.route('/:id/votes')
+  .post(authorize.onlyLogged, voteValidators.post, voteControllers.post);
+
+router.route('/:id/votes/vote')
+  .delete(authorize.onlyLogged, voteValidators.del, voteControllers.del);
+
+module.exports = router;

serializers/comments.js

@@ -55,6 +55,20 @@ function serializerFactory(type='comments') {
       relationshipLinks: {
         related: (data, { id }) => `${config.url.all}/reactions/${id}`
       }
+    },
+    dataMeta: {
+      votesUp(record, current) {
+        if (!current.votes) return;
+        return current.votes.filter(vote => vote.value === 1).length;
+      },
+      votesDown(record, current) {
+        if (!current.votes) return;
+        return current.votes.filter(vote => vote.value === -1).length;
+      },
+      myVote(record, current) {
+        if (!current.hasOwnProperty('myVote')) return;
+        return (current.myVote) ? current.myVote.value : 0;
+      }
     }
   });
 }

serializers/ideas.js

@@ -44,6 +44,20 @@ const ideaSerializer = new Serializer('ideas', {
     tag: {
       ref: 'tagname'
     }
+  },
+  dataMeta: {
+    votesUp(record, current) {
+      if (!current.votes) return;
+      return current.votes.filter(vote => vote.value === 1).length;
+    },
+    votesDown(record, current) {
+      if (!current.votes) return;
+      return current.votes.filter(vote => vote.value === -1).length;
+    },
+    myVote(record, current) {
+      if (!current.hasOwnProperty('myVote')) return;
+      return (current.myVote) ? current.myVote.value : 0;
+    }
   }
 
 });

serializers/index.js

@@ -8,7 +8,8 @@ const comments = require('./comments'),
       ideaTags = require('./idea-tags'),
       messages = require('./messages'),
       tags = require('./tags'),
-      users = require('./users');
+      users = require('./users'),
+      votes = require('./votes');
 
 // deserializing
 const deserializer = new Deserializer({
@@ -43,6 +44,6 @@ function deserialize(req, res, next) {
 }
 
 module.exports = {
-  serialize: Object.assign({ }, comments, contacts, ideas, ideaTags, messages, tags, users),
+  serialize: Object.assign({ }, comments, contacts, ideas, ideaTags, messages, tags, users, votes),
   deserialize
 };

serializers/votes.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Serializer = require('jsonapi-serializer').Serializer;
+
+const voteSerializer = new Serializer('votes', {
+  id: 'id',
+  attributes: ['title', 'detail', 'created', 'value', 'from', 'to'],
+  keyForAttribute: 'camelCase',
+  typeForAttribute(attribute, doc) {
+    if (attribute === 'from') return 'users';
+    if (attribute === 'to') return doc.type;
+  },
+  from: {
+    ref: 'username',
+    type: 'users'
+  },
+  to: {
+    ref: 'id',
+    type: 'ideas'
+  }
+});
+
+function vote(data) {
+  return voteSerializer.serialize(data);
+}
+
+module.exports = { vote };

test/handle-database.js

@@ -24,7 +24,8 @@ exports.fill = async function (data) {
     ideas: [],
     ideaTags: [],
     ideaComments: [],
-    reactions: []
+    reactions: [],
+    votes: []
   };
 
   data = _.defaults(data, def);
@@ -126,6 +127,17 @@ exports.fill = async function (data) {
     reaction.id = newReaction.id;
   }
 
+  for (const vote of processed.votes) {
+    const from = vote.from.username;
+    const to = { type: vote._to.type, id: vote.to.id };
+    const value = vote.value;
+
+    const newVote = await models.vote.create({ from, to, value });
+
+    // save the vote's id
+    vote.id = newVote.id;
+  }
+
   return processed;
 };
 
@@ -315,5 +327,16 @@ function processData(data) {
     return resp;
   });
 
+  output.votes = data.votes.map(([from, to, value]) => {
+    const [type, id] = to;
+    return {
+      _from: from,
+      _to: { type, id },
+      get from() { return output.users[this._from]; },
+      get to() { return output[this._to.type][this._to.id]; },
+      value
+    };
+  });
+
   return output;
 }

test/votes.js

@@ -0,0 +1,362 @@
+'use strict';
+
+const path = require('path'),
+      should = require('should');
+
+const agentFactory = require('./agent'),
+      dbHandle = require('./handle-database'),
+      models = require(path.resolve('./models'));
+
+voteTestFactory('idea');
+voteTestFactory('comment');
+
+/**
+ * We can test votes to different objects.
+ * @param {string} primary - what is the object we vote for? i.e. comment, idea
+ * @param {boolean} [only=false] - should we run only these tests or not? (describe vs. describe.only in mocha)
+ */
+function voteTestFactory(primary, only=false) {
+  const primarys = primary + 's';
+
+  const ds = (only) ? describe.only : describe;
+
+  function fillPrimary(data, count) {
+    switch (primary) {
+      case 'comment':
+        data.ideas = Array(1).fill([]);
+        data.ideaComments = Array(count).fill([0, 0]);
+        break;
+
+      default:
+        data[primarys] = Array(count).fill([{}, 0]);
+    }
+  }
+
+  ds(`votes for ${primarys}, ...`, () => {
+    let agent,
+        dbData,
+        existentPrimary,
+        primary0,
+        primary1,
+        loggedUser,
+        otherUser;
+
+    afterEach(async () => {
+      await dbHandle.clear();
+    });
+
+    beforeEach(() => {
+      agent = agentFactory();
+    });
+
+    describe(`POST /${primarys}/:id/votes (create a vote)`, () => {
+      let voteBody;
+
+      beforeEach(() => {
+        voteBody = { data: {
+          type: 'votes',
+          attributes: {
+            value: -1
+          }
+        } };
+      });
+
+      // put pre-data into database
+      beforeEach(async () => {
+        const data = {
+          users: 3, // how many users to make
+          verifiedUsers: [0, 1], // which  users to make verified
+        };
+
+        fillPrimary(data, 1);
+
+        // create data in database
+        dbData = await dbHandle.fill(data);
+
+        loggedUser = dbData.users[0];
+        existentPrimary = dbData[primarys][0];
+      });
+
+      context('logged', () => {
+
+        beforeEach(() => {
+          agent = agentFactory.logged(loggedUser);
+        });
+
+        context('valid data', () => {
+          it('[all is fine] save the vote', async () => {
+            const response = await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(201);
+
+            // saved into database?
+            const dbVote = await models.vote.read({ from: loggedUser.username, to: { type: primarys, id: existentPrimary.id } });
+            should(dbVote).ok();
+
+            // correct response?
+            should(response.body).match({
+              data: {
+                type: 'votes',
+                attributes: {
+                  value: -1
+                },
+                relationships: {
+                  from: { data: { type: 'users', id: loggedUser.username } },
+                  to: { data: { type: primarys, id: existentPrimary.id } }
+                }
+              }
+            });
+          });
+
+          it('[a vote already exists] 409', async () => {
+            await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(201);
+
+            voteBody.data.attributes.value = 1;
+
+            const response = await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(409);
+
+            should(response.body).deepEqual({
+              errors: [{
+                status: 409,
+                detail: 'duplicate vote'
+              }]
+            });
+          });
+
+          it(`[${primary} doesn't exist] 404`, async () => {
+            const response = await agent
+              .post(`/${primarys}/1111111/votes`)
+              .send(voteBody)
+              .expect(404);
+
+            should(response.body).deepEqual({
+              errors: [{
+                status: 404,
+                detail: `${primary} doesn't exist`
+              }]
+            });
+          });
+        });
+
+        context('invalid data', () => {
+          it('[not +1 or -1] 400', async () => {
+            voteBody.data.attributes.value = 0;
+
+            await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(400);
+          });
+
+          it('[missing value in body] 400', async () => {
+            delete voteBody.data.attributes.value;
+
+            await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(400);
+          });
+
+          it('[additional body parameters] 400', async () => {
+            voteBody.data.attributes.foo = 'bar';
+
+            await agent
+              .post(`/${primarys}/${existentPrimary.id}/votes`)
+              .send(voteBody)
+              .expect(400);
+          });
+
+          it(`[invalid ${primary} id] 400`, async () => {
+            await agent
+              .post(`/${primarys}/invalid--id/votes`)
+              .send(voteBody)
+              .expect(400);
+          });
+        });
+      });
+
+      context('not logged', () => {
+        it('403', async () => {
+          await agent
+            .post(`/${primarys}/${existentPrimary.id}/votes`)
+            .send(voteBody)
+            .expect(403);
+        });
+      });
+    });
+
+    describe(`DELETE /${primarys}/:id/votes/vote (remove a vote)`, () => {
+
+      beforeEach(async () => {
+        const data = {
+          users: 3, // how many users to make
+          verifiedUsers: [0, 1, 2], // which  users to make verified
+          votes: [
+            [0, [primarys, 0], -1],
+            [1, [primarys, 0], 1]
+          ] // user, primary, value
+        };
+
+        fillPrimary(data, 2);
+
+        // create data in database
+        dbData = await dbHandle.fill(data);
+
+        [loggedUser, otherUser] = dbData.users;
+        [primary0, primary1] = dbData[primarys];
+      });
+
+      context('logged', () => {
+
+        beforeEach(() => {
+          agent = agentFactory.logged(loggedUser);
+        });
+
+        context('valid data', () => {
+          it('[vote exists] remove the vote and 204', async () => {
+            // first the vote should exist
+            const dbVote = await models.vote.read({ from: loggedUser.username, to: { type: primarys, id: primary0.id } });
+            should(dbVote).ok();
+
+            // then we remove the vote
+            await agent
+              .delete(`/${primarys}/${primary0.id}/votes/vote`)
+              .expect(204);
+
+            // then the vote should not exist
+            const dbVoteAfter = await models.vote.read({ from: loggedUser.username, to: { type: primarys, id: primary0.id } });
+            should(dbVoteAfter).not.ok();
+            // and other votes are still there
+            const dbOtherVote = await models.vote.read({ from: otherUser.username, to: { type: primarys, id: primary0.id } });
+            should(dbOtherVote).ok();
+          });
+
+          it('[vote doesn\'t exist] 404', async () => {
+            const response = await agent
+              .delete(`/${primarys}/${primary1.id}/votes/vote`)
+              .expect(404);
+
+            should(response.body).deepEqual({
+              errors: [{
+                status: 404,
+                detail: `vote or ${primary} doesn't exist`
+              }]
+            });
+
+          });
+
+          it(`[${primary} doesn't exist] 404`, async () => {
+            const response = await agent
+              .delete(`/${primarys}/111111/votes/vote`)
+              .expect(404);
+
+            should(response.body).deepEqual({
+              errors: [{
+                status: 404,
+                detail: `vote or ${primary} doesn't exist`
+              }]
+            });
+          });
+        });
+
+        context('invalid data', () => {
+          it(`[invalid ${primary} id] 400`, async () => {
+            await agent
+              .delete(`/${primarys}/invalid--id/votes/vote`)
+              .expect(400);
+          });
+        });
+      });
+
+      context('not logged', () => {
+        it('403', async () => {
+          await agent
+            .delete(`/${primarys}/${primary0.id}/votes/vote`)
+            .expect(403);
+        });
+      });
+    });
+
+    describe(`PATCH /${primarys}/:id/votes/vote (change vote value)`, () => {
+      it('maybe todo');
+    });
+
+    describe(`show amount of votes up and down and current user\`s vote when GET /${primarys}${(primary === 'comment') ? '' : '/:id'}`, () => {
+
+      let idea0,
+          url;
+
+      beforeEach(async () => {
+        const data = {
+          users: 5, // how many users to make
+          verifiedUsers: [0, 1, 2, 3, 4], // which  users to make verified
+          votes: [
+            [0, [primarys, 0], -1],
+            [1, [primarys, 0], 1],
+            [2, [primarys, 0], 1],
+            [2, [primarys, 1], -1],
+            [3, [primarys, 0], -1],
+            [4, [primarys, 0], 1],
+          ] // user, primary, value
+        };
+
+        fillPrimary(data, 2);
+
+        // create data in database
+        dbData = await dbHandle.fill(data);
+
+        [loggedUser, otherUser] = dbData.users;
+        [primary0, primary1] = dbData[primarys];
+        [idea0] = dbData.ideas;
+      });
+
+      beforeEach(() => {
+        agent = agentFactory.logged(loggedUser);
+      });
+
+      beforeEach(() => {
+        url = (primary === 'comment') ? `/ideas/${idea0.id}/comments` : `/${primarys}/${primary0.id}`;
+      });
+
+      it('show amount of votes up and down', async () => {
+        const response = await agent
+          .get(url)
+          .expect(200);
+
+        const objectToTest = (primary === 'comment') ? response.body.data[0] : response.body.data;
+
+        should(objectToTest).match({ meta: { votesUp: 3, votesDown: 2 } });
+      });
+
+      it('show my vote', async () => {
+        const response = await agent
+          .get(url)
+          .expect(200);
+
+        const objectToTest = (primary === 'comment') ? response.body.data[0] : response.body.data;
+
+        should(objectToTest).match({ meta: { myVote: -1 } });
+      });
+
+      it('show 0 as my vote if I didn\'t vote', async () => {
+        const url2 = (primary === 'comment') ? `/ideas/${idea0.id}/comments` : `/${primarys}/${primary1.id}`;
+
+        const response = await agent
+          .get(url2)
+          .expect(200);
+
+        const objectToTest = (primary === 'comment') ? response.body.data[1] : response.body.data;
+
+        should(objectToTest).match({ meta: { myVote: 0 } });
+      });
+    });
+
+  });
+}