Ported read card, added unit tests, added read card route and integration tests

common/locales/en/api-v3.json

@@ -128,5 +128,8 @@
   "privateMessageGiftSubscriptionMessage": "<%= numberOfMonths %> months of subscription! ",
   "cannotSendGemsToYourself": "Cannot send gems to yourself. Try a subscription instead.",
   "notEnoughGemsToSend": "Amount must be within 0 and your current number of gems.",
-  "mustPurchaseToSet": "Must purchase <%= val %> to set it on <%= key %>."
+  "mustPurchaseToSet": "Must purchase <%= val %> to set it on <%= key %>.",
+  "readCard": "<%= cardType %> has been read",
+  "cardTypeRequired": "Card type required",
+  "cardTypeNotAllowed": "Unkown card type."
 }

common/script/index.js

@@ -114,6 +114,7 @@ import feed from './ops/feed';
 import equip from './ops/equip';
 import changeClass from './ops/changeClass';
 import disableClasses from './ops/disableClasses';
+import readCard from './ops/readCard';
 
 api.ops = {
   scoreTask,
@@ -129,6 +130,7 @@ api.ops = {
   equip,
   changeClass,
   disableClasses,
+  readCard,
 };
 
 import handleTwoHanded from './fns/handleTwoHanded';

common/script/ops/readCard.js

@@ -1,10 +1,28 @@
-module.exports = function(user, req, cb) {
+import splitWhitespace from '../libs/splitWhitespace';
-  var cardType;
+import _ from 'lodash';
-  cardType = req.params.cardType;
+import i18n from '../i18n';
-  user.items.special[cardType + "Received"].shift();
+import {
-  if (typeof user.markModified === "function") {
+  BadRequest,
-    user.markModified("items.special." + cardType + "Received");
+  NotAuthorized,
+} from '../libs/errors';
+import content from '../content/index';
+
+module.exports = function readCard (user, req = {}) {
+  let cardType = _.get(req.params, 'cardType');
+
+  if (!cardType) {
+    throw new BadRequest(i18n.t('cardTypeRequired', req.language));
   }
+
+  if (_.keys(content.cardTypes).indexOf(cardType) === -1) {
+    throw new NotAuthorized(i18n.t('cardTypeNotAllowed', req.language));
+  }
+
+  user.items.special[`${cardType}Received`].shift();
   user.flags.cardReceived = false;
-  return typeof cb === "function" ? cb(null, 'items.special flags.cardReceived') : void 0;
+
+  return {
+    message: i18n.t('readCard', {cardType}, req.language),
+    data: _.pick(user, splitWhitespace('items.special flags.cardReceived')),
+  };
 };

test/api/v3/integration/user/POST-user_read_card.test.js

@@ -0,0 +1,38 @@
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /user/read-card/:cardType', () => {
+  let user;
+  let cardType = 'greeting';
+
+  beforeEach(async () => {
+    user = await generateUser();
+  });
+
+  it('returns an error when unknown cardType is provded', async () => {
+    await expect(user.post('/user/read-card/randomCardType'))
+      .to.eventually.be.rejected.and.to.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('cardTypeNotAllowed'),
+      });
+  });
+
+  // More tests in common code unit tests
+
+  it('reads a card', async () => {
+    await user.update({
+      'items.special.greetingReceived': [true],
+      'flags.cardReceived': true,
+    });
+
+    let response = await user.post(`/user/read-card/${cardType}`);
+    await user.sync();
+
+    expect(response.message).to.equal(t('readCard', {cardType}));
+    expect(user.items.special[`${cardType}Received`]).to.be.empty;
+    expect(user.flags.cardReceived).to.be.false;
+  });
+});

test/common/ops/readCard.js

@@ -0,0 +1,48 @@
+import readCard from '../../../common/script/ops/readCard';
+import i18n from '../../../common/script/i18n';
+import {
+  generateUser,
+} from '../../helpers/common.helper';
+import {
+  BadRequest,
+  NotAuthorized,
+} from '../../../common/script/libs/errors';
+
+describe('shared.ops.readCard', () => {
+  let user;
+  let cardType = 'greeting';
+
+  beforeEach(() => {
+    user = generateUser();
+    user.items.special[`${cardType}Received`] = [true];
+    user.flags.cardReceived = true;
+  });
+
+  it('returns an error when cardType is not provided', (done) => {
+    try {
+      readCard(user);
+    } catch (err) {
+      expect(err).to.be.an.instanceof(BadRequest);
+      expect(err.message).to.equal(i18n.t('cardTypeRequired'));
+      done();
+    }
+  });
+
+  it('returns an error when unknown cardType is provided', (done) => {
+    try {
+      readCard(user, {params: {cardType: 'randomCardType'}});
+    } catch (err) {
+      expect(err).to.be.an.instanceof(NotAuthorized);
+      expect(err.message).to.equal(i18n.t('cardTypeNotAllowed'));
+      done();
+    }
+  });
+
+  it('reads a card', () => {
+    let response = readCard(user, {params: {cardType: 'greeting'}});
+
+    expect(response.message).to.equal(i18n.t('readCard', {cardType}));
+    expect(user.items.special[`${cardType}Received`]).to.be.empty;
+    expect(user.flags.cardReceived).to.be.false;
+  });
+});

website/src/controllers/api-v3/user.js

@@ -676,4 +676,26 @@ api.disableClasses = {
   },
 };
 
+/**
+* @api {post} /user/read-card/:cardType Reads a card.
+* @apiVersion 3.0.0
+* @apiName UserReadCard
+* @apiGroup User
+*
+* @apiParam {string} cardType Type of card to read
+*
+* @apiSuccess {Object} data `items.special flags.cardReceived`
+*/
+api.readCard = {
+  method: 'POST',
+  middlewares: [authWithHeaders(), cron],
+  url: '/user/read-card/:cardType',
+  async handler (req, res) {
+    let user = res.locals.user;
+    let readCardResponse = common.ops.readCard(user, req);
+    await user.save();
+    res.respond(200, readCardResponse);
+  },
+};
+
 module.exports = api;