Impact value

.eslintrc.json

@@ -13,6 +13,7 @@
         "ecmaVersion": 12
     },
     "rules": {
+        "no-labels": "off",
         "simple-import-sort/imports": "error",
         "no-underscore-dangle": "off",
         "camelcase":"off",

__tests__/integration/impact-value-transfer.spec.js

@@ -0,0 +1,215 @@
+const request = require('supertest');
+const Zaven = require("../mock-data/Zaven.json");
+const Meisze = require("../mock-data/Meisze.json");
+const TokenA = require("../mock-data/TokenA");
+const testUtils = require("./testUtils");
+const { expect } = require('chai');
+const log = require('loglevel');
+const server = require("../../server/app");
+
+describe("Impact Value", () => {
+  let registeredZaven;
+  let registeredMeisze;
+
+  beforeEach(async () => {
+    await testUtils.clear();
+    registeredZaven = await testUtils.registerAndLogin(Zaven);
+    await testUtils.addToken(registeredZaven, TokenA);
+    registeredMeisze = await testUtils.registerAndLogin(Meisze);
+  })
+
+  describe("Zaven request to send 4 impact value to Meisze", () => {
+    let transferId;
+
+
+    beforeEach(async () => {
+      await request(server)
+        .post(`/transfers`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredZaven.apiKey)
+        .set('Authorization', `Bearer ${registeredZaven.token}`)
+        .send({
+          sender_wallet: registeredZaven.name,
+          receiver_wallet: registeredMeisze.name,
+          impact: {
+            value: 4,
+            accept_deviation: 2,
+          }
+        })
+        .expect(202)
+        .then(res => {
+          expect(res).property("body").property("id").a("string");
+          transferId = res.body.id;
+        });
+    });
+
+    it("Meisze accept the transfer", async () => {
+      await request(server)
+        .post(`/transfers/${transferId}/accept`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredMeisze.apiKey)
+        .set('Authorization', `Bearer ${registeredMeisze.token}`)
+        .expect(200)
+        .then(res => {
+          expect(res).property("body").property("impact_value_transferred").eq(4);
+        });
+
+      // Meisze should have one token
+      const token = await testUtils.getTokenById(TokenA.id);
+      expect(token).property("id").a("string");
+      expect(token).property("wallet_id").eq(registeredMeisze.id);
+      expect(token).property("claim").eq(false);
+
+      // the transfer's claim is false (by default)
+      const transfer = await testUtils.getKnex().table("transfer").first().where("id", transferId);
+      expect(transfer).property("claim").eq(false);
+
+      // the transaction's claim is false (by default)
+      const transactions = await testUtils.getKnex().table("transaction").where("transfer_id", transferId);
+      transactions.forEach(t => expect(t).property("claim").eq(false));
+    });
+
+    it("Meisze decline the transfer", async () => {
+      await request(server)
+        .post(`/transfers/${transferId}/decline`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredMeisze.apiKey)
+        .set('Authorization', `Bearer ${registeredMeisze.token}`)
+        .expect(200);
+
+      // Zeven still have the token
+      const token = await testUtils.getTokenById(TokenA.id);
+      expect(token).property("id").a("string");
+      expect(token).property("wallet_id").eq(registeredZaven.id);
+
+    });
+
+  });
+
+  describe("Meisze request to receive 4 impact value from Zaven", () => {
+    let transferId;
+
+
+    beforeEach(async () => {
+      await request(server)
+        .post(`/transfers`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredMeisze.apiKey)
+        .set('Authorization', `Bearer ${registeredMeisze.token}`)
+        .send({
+          sender_wallet: registeredZaven.name,
+          receiver_wallet: registeredMeisze.name,
+          impact: {
+            value: 4,
+            accept_deviation: 2,
+          }
+        })
+        .expect(202)
+        .then(res => {
+          expect(res).property("body").property("id").a("string");
+          transferId = res.body.id;
+        });
+    });
+
+    it("Zaven fulfill the transfer", async () => {
+      await request(server)
+        .post(`/transfers/${transferId}/fulfill`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredZaven.apiKey)
+        .set('Authorization', `Bearer ${registeredZaven.token}`)
+        .send({
+          implicit: true,
+        })
+        .expect(200)
+        .then(res => {
+          expect(res).property("body").property("impact_value_transferred").eq(4);
+        });
+
+      // Meisze should have one token
+      const token = await testUtils.getTokenById(TokenA.id);
+      expect(token).property("id").a("string");
+      expect(token).property("wallet_id").eq(registeredMeisze.id);
+      expect(token).property("claim").eq(false);
+
+      // the transfer's claim is false (by default)
+      const transfer = await testUtils.getKnex().table("transfer").first().where("id", transferId);
+      expect(transfer).property("claim").eq(false);
+
+      // the transaction's claim is false (by default)
+      const transactions = await testUtils.getKnex().table("transaction").where("transfer_id", transferId);
+      transactions.forEach(t => expect(t).property("claim").eq(false));
+    });
+
+    it("Zaven fulfill the transfer with explicit tokens, should throw error", async () => {
+      await request(server)
+        .post(`/transfers/${transferId}/fulfill`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredZaven.apiKey)
+        .set('Authorization', `Bearer ${registeredZaven.token}`)
+        .send({
+          tokens: [TokenA.id],
+        })
+        .expect(403)
+        .then(res => {
+          expect(res.body).property("message").match(/implicit/);
+        });
+
+    });
+
+    it("Zaven decline the transfer", async () => {
+      await request(server)
+        .post(`/transfers/${transferId}/decline`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredZaven.apiKey)
+        .set('Authorization', `Bearer ${registeredZaven.token}`)
+        .expect(200);
+
+      // Zeven still have the token
+      const token = await testUtils.getTokenById(TokenA.id);
+      expect(token).property("id").a("string");
+      expect(token).property("wallet_id").eq(registeredZaven.id);
+
+    });
+
+  });
+
+  describe("Zaven request to send 4 impact value to Meisze, with the trust relationship between Z and M", () => {
+    let transferId;
+
+    beforeEach(async () => {
+      log.warn("Add trust Z to M");
+      testUtils.trustASendToB(registeredZaven, registeredMeisze);
+    });
+
+    beforeEach(async () => {
+      await request(server)
+        .post(`/transfers`)
+        .set('Content-Type', "application/json")
+        .set('treetracker-api-key', registeredMeisze.apiKey)
+        .set('Authorization', `Bearer ${registeredZaven.token}`)
+        .send({
+          sender_wallet: registeredZaven.name,
+          receiver_wallet: registeredMeisze.name,
+          impact: {
+            value: 4,
+            accept_deviation: 2,
+          }
+        })
+        .expect(201)
+        .then(res => {
+          expect(res).property("body").property("id").a("string");
+          expect(res).property("body").property("state").eq("completed");
+          transferId = res.body.id;
+          expect(res).property("body").property("impact_value_transferred").eq(4);
+        });
+    });
+
+    it("Meisze already has the token", async () => {
+      // Meisze should have one token
+      const token = await testUtils.getTokenById(TokenA.id);
+      expect(token).property("id").a("string");
+      expect(token).property("wallet_id").eq(registeredMeisze.id);
+    });
+  });
+
+});

__tests__/integration/testUtils.js

@@ -5,6 +5,7 @@ const generator = require('generate-password');
 const { expect } = require('chai');
 const JWTService = require("../../server/services/JWTService");
 const Transfer = require("../../server/models/Transfer");
+const TrustRelationship = require("../../server/models/TrustRelationship");
 const knex = require("../../server/database/knex");
 
 /*
@@ -79,6 +80,7 @@ async function clear() {
  * Add a token to a wallet
  */
 async function addToken(wallet, token){
+  expect(token).property("value").a("number");
   const result = await knex("token")
     .insert({
       ...token,
@@ -114,10 +116,34 @@ async function sendAndPend(
   return result[0];
 }
 
+async function getTokenById(id){
+  const tokens = await knex("token").where("id", id);
+  return tokens[0];
+}
+
+async function trustASendToB(walletA, walletB){
+  const result = await knex("wallet_trust")
+    .insert({
+      id: uuid.v4(),
+      actor_wallet_id: walletA.id,
+      target_wallet_id: walletB.id,
+      originator_wallet_id: walletA.id,
+      type: TrustRelationship.ENTITY_TRUST_TYPE.send,
+      request_type: TrustRelationship.ENTITY_TRUST_REQUEST_TYPE.send,
+      state: TrustRelationship.ENTITY_TRUST_STATE_TYPE.trusted,
+      active: true,
+    }).returning("*");
+  expect(result[0]).property("id").a("string");
+  return result[0];
+}
+
 module.exports = {
   register,
   registerAndLogin,
   clear,
   sendAndPend,
   addToken,
+  getTokenById,
+  trustASendToB,
+  getKnex: () => knex,
 }

__tests__/mock-data/TokenA.json

@@ -1,4 +1,5 @@
 {
   "id": "71a20380-d561-43f9-bbb4-54d7a9f2ecbe",
-  "capture_id": "8f7e7d4a-f5c3-409d-8c5b-880edf73c758"
+  "capture_id": "8f7e7d4a-f5c3-409d-8c5b-880edf73c758",
+  "value": 4
 }

database/migrations/20210401005831-AddClaimBoolean.js

@@ -1,4 +1,3 @@
-// 'use strict';
 
 let dbm;
 let type;

database/migrations/20210602215334-AddImpactValueInToken.js

@@ -0,0 +1,27 @@
+// 'use strict';
+
+let dbm;
+let type;
+let seed;
+
+/**
+  * We receive the dbmigrate dependency from dbmigrate initially.
+  * This enables us to not have to rely on NODE_PATH.
+  */
+exports.setup = function(options, seedLink) {
+  dbm = options.dbmigrate;
+  type = dbm.dataType;
+  seed = seedLink;
+};
+
+exports.up = function(db) {
+  return db.addColumn('token', 'value', { type: 'int', notNull: true, defaultValue: 0 })
+};
+
+exports.down = function(db) {
+  return db.removeColumn('token', 'value');
+};
+
+exports._meta = {
+  "version": 1
+};