♻️ chore(api) reduce bounded context violation

Author: yaf

api/src/devcomp/domain/usecases/find-tutorials.js

@@ -1,28 +1,20 @@
 import _ from 'lodash';
 
-// TODO Bounded context violation
-import { Scorecard } from '../../../evaluation/domain/models/Scorecard.js';
-import { UserNotAuthorizedToAccessEntityError } from '../../../shared/domain/errors.js';
 import { KnowledgeElement } from '../../../shared/domain/models/KnowledgeElement.js';
 
 const findTutorials = async function ({
-  authenticatedUserId,
-  scorecardId,
+  userId,
+  competenceId,
   knowledgeElementRepository,
   skillRepository,
   tubeRepository,
   tutorialRepository,
   locale,
 }) {
-  // TODO replace scorecardId by competenceId
-  const { userId, competenceId } = Scorecard.parseId(scorecardId);
-
-  // TODO refactor to extract this guard to controller
-  if (parseInt(authenticatedUserId) !== parseInt(userId)) {
-    throw new UserNotAuthorizedToAccessEntityError();
-  }
-
-  const knowledgeElements = await knowledgeElementRepository.findUniqByUserIdAndCompetenceId({ userId, competenceId });
+  const knowledgeElements = await knowledgeElementRepository.findUniqByUserIdAndCompetenceId({
+    userId,
+    competenceId,
+  });
   const invalidatedDirectKnowledgeElements = _getInvalidatedDirectKnowledgeElements(knowledgeElements);
 
   if (invalidatedDirectKnowledgeElements.length === 0) {

api/src/evaluation/application/scorecards/scorecard-controller.js

@@ -2,8 +2,10 @@
 import { usecases as devCompUsecases } from '../../../devcomp/domain/usecases/index.js';
 // TODO Bounded context violation
 import * as tutorialSerializer from '../../../devcomp/infrastructure/serializers/jsonapi/tutorial-serializer.js';
-import { evaluationUsecases } from '../../../evaluation/domain/usecases/index.js';
+import { UserNotAuthorizedToAccessEntityError } from '../../../shared/domain/errors.js';
 import * as requestResponseUtils from '../../../shared/infrastructure/utils/request-response-utils.js';
+import { Scorecard } from '../../domain/models/Scorecard.js';
+import { evaluationUsecases } from '../../domain/usecases/index.js';
 import * as scorecardSerializer from '../../infrastructure/serializers/jsonapi/scorecard-serializer.js';
 
 const getScorecard = function (request, h, dependencies = { requestResponseUtils, scorecardSerializer }) {
@@ -20,18 +22,22 @@ const getScorecard = function (request, h, dependencies = { requestResponseUtils
     .then(dependencies.scorecardSerializer.serialize);
 };
 
-const findTutorials = function (request, h, dependencies = { requestResponseUtils, tutorialSerializer }) {
+const findTutorials = async function (request, h, dependencies = { requestResponseUtils, tutorialSerializer }) {
   const locale = dependencies.requestResponseUtils.extractLocaleFromRequest(request);
   const authenticatedUserId = request.auth.credentials.userId;
   const scorecardId = request.params.id;
 
-  return devCompUsecases
-    .findTutorials({
-      authenticatedUserId,
-      scorecardId,
-      locale,
-    })
-    .then(dependencies.tutorialSerializer.serialize);
+  const { userId, competenceId } = await Scorecard.parseId(scorecardId);
+  if (parseInt(authenticatedUserId) !== parseInt(userId)) {
+    throw new UserNotAuthorizedToAccessEntityError();
+  }
+  const tutorials = await devCompUsecases.findTutorials({
+    userId,
+    competenceId,
+    locale,
+  });
+  console.log('tutorials ', tutorials);
+  return dependencies.tutorialSerializer.serialize(tutorials);
 };
 
 const resetScorecard = function (request, h, dependencies = { scorecardSerializer, requestResponseUtils }) {

api/tests/devcomp/unit/domain/usecases/find-tutorials_test.js

@@ -1,14 +1,10 @@
 import { findTutorials } from '../../../../../src/devcomp/domain/usecases/find-tutorials.js';
-import { Scorecard } from '../../../../../src/evaluation/domain/models/Scorecard.js';
-import { UserNotAuthorizedToAccessEntityError } from '../../../../../src/shared/domain/errors.js';
 import { KnowledgeElement } from '../../../../../src/shared/domain/models/KnowledgeElement.js';
 import { domainBuilder, expect, sinon } from '../../../../test-helper.js';
 
 describe('Unit | UseCase | find-tutorials', function () {
-  let authenticatedUserId;
+  let userId;
   let competenceId;
-  let scorecardId;
-  let parseIdStub;
   let knowledgeElementRepository;
   let skillRepository;
   let tubeRepository;
@@ -17,10 +13,8 @@ describe('Unit | UseCase | find-tutorials', function () {
   let locale;
 
   beforeEach(function () {
-    scorecardId = '1_recabC123';
     competenceId = 'recABc123';
-    authenticatedUserId = 1;
-    parseIdStub = sinon.stub(Scorecard, 'parseId');
+    userId = 1;
     knowledgeElementRepository = { findUniqByUserIdAndCompetenceId: sinon.stub() };
     skillRepository = { findActiveByCompetenceId: sinon.stub() };
     tubeRepository = { findByNames: sinon.stub() };
@@ -29,19 +23,15 @@ describe('Unit | UseCase | find-tutorials', function () {
   });
 
   context('When user is authenticated', function () {
-    beforeEach(function () {
-      parseIdStub.withArgs(scorecardId).returns({ competenceId, userId: authenticatedUserId });
-    });
-
     context('And user asks for tutorials belonging to his scorecard', function () {
       it('should resolve', function () {
         // given
         knowledgeElementRepository.findUniqByUserIdAndCompetenceId.resolves({});
 
         // when
         const result = findTutorials({
-          authenticatedUserId,
-          scorecardId,
+          userId,
+          competenceId,
           knowledgeElementRepository,
           skillRepository,
           tubeRepository,
@@ -101,14 +91,14 @@ describe('Unit | UseCase | find-tutorials', function () {
             const inferredTutorialIdList = [inferredTutorial.id];
 
             tutorialRepository.findByRecordIdsForCurrentUser
-              .withArgs({ ids: tutorialIdList1, userId: authenticatedUserId, locale })
+              .withArgs({ ids: tutorialIdList1, userId: userId, locale })
               .returns([tutorial1, tutorial2]);
             tutorialRepository.findByRecordIdsForCurrentUser
-              .withArgs({ ids: tutorialIdList2, userId: authenticatedUserId, locale })
+              .withArgs({ ids: tutorialIdList2, userId: userId, locale })
               .returns([tutorial3]);
 
             tutorialRepository.findByRecordIdsForCurrentUser
-              .withArgs({ ids: inferredTutorialIdList, userId: authenticatedUserId })
+              .withArgs({ ids: inferredTutorialIdList, userId: userId })
               .returns([inferredTutorial]);
 
             const skill_1 = domainBuilder.buildSkill({
@@ -227,8 +217,8 @@ describe('Unit | UseCase | find-tutorials', function () {
           it('should return the tutorials related to the scorecard', async function () {
             // when
             const result = await findTutorials({
-              authenticatedUserId,
-              scorecardId,
+              userId,
+              competenceId,
               knowledgeElementRepository,
               skillRepository,
               tubeRepository,
@@ -267,8 +257,8 @@ describe('Unit | UseCase | find-tutorials', function () {
 
           // when
           const result = await findTutorials({
-            authenticatedUserId,
-            scorecardId,
+            userId,
+            competenceId,
             knowledgeElementRepository,
             skillRepository,
             tubeRepository,
@@ -282,26 +272,5 @@ describe('Unit | UseCase | find-tutorials', function () {
         });
       });
     });
-
-    context('And user asks for a scorecard that do not belongs to him', function () {
-      it('should reject a "UserNotAuthorizedToAccessEntityError" domain error', function () {
-        // given
-        const unauthorizedUserId = 42;
-
-        // when
-        const promise = findTutorials({
-          authenticatedUserId: unauthorizedUserId,
-          scorecardId,
-          knowledgeElementRepository,
-          skillRepository,
-          tubeRepository,
-          tutorialRepository,
-          userSavedTutorialRepository,
-        });
-
-        // then
-        return expect(promise).to.be.rejectedWith(UserNotAuthorizedToAccessEntityError);
-      });
-    });
   });
 });

api/tests/evaluation/unit/application/scorecards/scorecard-controller_test.js

@@ -1,5 +1,6 @@
 import { usecases as devCompUsecases } from '../../../../../src/devcomp/domain/usecases/index.js';
 import { scorecardController } from '../../../../../src/evaluation/application/scorecards/scorecard-controller.js';
+import { Scorecard } from '../../../../../src/evaluation/domain/models/Scorecard.js';
 import { evaluationUsecases } from '../../../../../src/evaluation/domain/usecases/index.js';
 import * as requestResponseUtils from '../../../../../src/shared/infrastructure/utils/request-response-utils.js';
 import { expect, hFake, sinon } from '../../../../test-helper.js';
@@ -54,16 +55,16 @@ describe('Unit | Controller | scorecard-controller', function () {
 
   describe('#findTutorials', function () {
     const tutorials = [];
+    const competenceId = 13;
+    const userId = authenticatedUserId;
+    const scorecard = { userId, competenceId };
 
-    beforeEach(function () {
+    it('should call the expected usecase', async function () {
       sinon
         .stub(devCompUsecases, 'findTutorials')
-        .withArgs({ authenticatedUserId, scorecardId, locale })
+        .withArgs({ userId: authenticatedUserId, competenceId, locale })
         .resolves(tutorials);
-    });
-
-    it('should call the expected usecase', async function () {
-      // given
+      sinon.stub(Scorecard, 'parseId').withArgs(scorecardId).resolves(scorecard);
       const tutorialSerializer = {
         serialize: sinon.stub(),
       };