feat: added paged getByStatus (#1428)

Author: danieljchuser

src/controllers/suggestions.js

@@ -214,6 +214,65 @@ function SuggestionsController(ctx, sqs, env) {
     return ok(suggestions);
   };
 
+  /**
+     * Gets all suggestions for a given site, opportunity and status
+     * @param {Object} context of the request
+     * @returns {Promise<Response>} Array of suggestions response.
+     */
+  const getByStatusPaged = async (context) => {
+    const siteId = context.params?.siteId;
+    const opptyId = context.params?.opportunityId;
+    const status = context.params?.status || undefined;
+    const limit = parseInt(context.params?.limit, 10) || DEFAULT_PAGE_SIZE;
+    const cursor = context.params?.cursor || null;
+
+    if (!isValidUUID(siteId)) {
+      return badRequest('Site ID required');
+    }
+    if (!isValidUUID(opptyId)) {
+      return badRequest('Opportunity ID required');
+    }
+    if (!hasText(status)) {
+      return badRequest('Status is required');
+    }
+
+    if (!isInteger(limit) || limit < 1) {
+      return badRequest('Page size must be greater than 0');
+    }
+
+    const site = await Site.findById(siteId);
+    if (!site) {
+      return notFound('Site not found');
+    }
+
+    if (!await accessControlUtil.hasAccess(site)) {
+      return forbidden('User does not belong to the organization');
+    }
+
+    const results = await Suggestion.allByOpportunityIdAndStatus(opptyId, status, {
+      limit,
+      cursor,
+      returnCursor: true,
+    });
+    const { data: suggestionEntities = [], cursor: newCursor = null } = results;
+    // Check if the opportunity belongs to the site
+    if (suggestionEntities.length > 0) {
+      const oppty = await suggestionEntities[0].getOpportunity();
+      if (!oppty || oppty.getSiteId() !== siteId) {
+        return notFound('Opportunity not found');
+      }
+    }
+    const suggestions = suggestionEntities.map((sugg) => SuggestionDto.toJSON(sugg));
+    return ok({
+      suggestions,
+      pagination: {
+        limit,
+        cursor: newCursor ?? null,
+        hasMore: !!newCursor,
+      },
+    });
+  };
+
   /**
    * Get a suggestion given a site, opportunity and suggestion ID
    * @param {Object} context of the request
@@ -934,6 +993,7 @@ function SuggestionsController(ctx, sqs, env) {
     getAllForOpportunityPaged,
     getByID,
     getByStatus,
+    getByStatusPaged,
     getSuggestionFixes,
     patchSuggestion,
     patchSuggestionsStatus,

src/routes/index.js

@@ -187,6 +187,8 @@ export default function getRouteHandlers(
     'PATCH /sites/:siteId/opportunities/:opportunityId/suggestions/auto-fix': suggestionsController.autofixSuggestions,
     'POST /sites/:siteId/opportunities/:opportunityId/suggestions/edge-deploy': suggestionsController.deploySuggestionToEdge,
     'GET /sites/:siteId/opportunities/:opportunityId/suggestions/by-status/:status': suggestionsController.getByStatus,
+    'GET /sites/:siteId/opportunities/:opportunityId/suggestions/by-status/:status/paged/:limit/:cursor': suggestionsController.getByStatusPaged,
+    'GET /sites/:siteId/opportunities/:opportunityId/suggestions/by-status/:status/paged/:limit': suggestionsController.getByStatusPaged,
     'GET /sites/:siteId/opportunities/:opportunityId/suggestions/:suggestionId': suggestionsController.getByID,
     'GET /sites/:siteId/opportunities/:opportunityId/suggestions/:suggestionId/fixes': suggestionsController.getSuggestionFixes,
     'POST /sites/:siteId/opportunities/:opportunityId/suggestions': suggestionsController.createSuggestions,

test/controllers/suggestions.test.js

@@ -147,6 +147,7 @@ describe('Suggestions Controller', () => {
     'deploySuggestionToEdge',
     'getByID',
     'getByStatus',
+    'getByStatusPaged',
     'getSuggestionFixes',
     'patchSuggestion',
     'patchSuggestionsStatus',
@@ -913,6 +914,297 @@ describe('Suggestions Controller', () => {
     expect(error).to.have.property('message', 'Opportunity not found');
   });
 
+  it('gets paged suggestions by status returns bad request if site ID is missing', async () => {
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(400);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Site ID required');
+  });
+
+  it('gets paged suggestions by status returns bad request if opportunity ID is missing', async () => {
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(400);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Opportunity ID required');
+  });
+
+  it('gets paged suggestions by status returns bad request if status is missing', async () => {
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(400);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Status is required');
+  });
+
+  it('gets paged suggestions by status returns bad request if limit is less than 1', async () => {
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+        limit: -1,
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(400);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Page size must be greater than 0');
+  });
+
+  it('gets paged suggestions by status returns not found if site does not exist', async () => {
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID_NOT_FOUND,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(404);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Site not found');
+  });
+
+  it('gets paged suggestions by status returns forbidden if user does not have access', async () => {
+    sandbox.stub(AccessControlUtil.prototype, 'hasAccess').returns(false);
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(403);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'User does not belong to the organization');
+  });
+
+  it('gets paged suggestions by status returns not found if opportunity does not belong to site', async () => {
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionEntity(suggs[0])],
+          cursor: undefined,
+        });
+      }
+      return Promise.resolve([mockSuggestionEntity(suggs[0])]);
+    });
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID_NOT_ENABLED,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(404);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Opportunity not found');
+  });
+
+  it('gets paged suggestions by status successfully', async () => {
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionEntity(suggs[0])],
+          cursor: undefined,
+        });
+      }
+      return Promise.resolve([mockSuggestionEntity(suggs[0])]);
+    });
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(mockSuggestionDataAccess.Suggestion.allByOpportunityIdAndStatus.calledOnce).to.be.true;
+    expect(response.status).to.equal(200);
+    const result = await response.json();
+    expect(result).to.have.property('suggestions');
+    expect(result.suggestions).to.be.an('array').with.lengthOf(1);
+    expect(result).to.have.property('pagination');
+    expect(result.pagination).to.deep.equal({
+      limit: 100,
+      cursor: null,
+      hasMore: false,
+    });
+  });
+
+  it('gets paged suggestions by status with empty results', async () => {
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [],
+          cursor: undefined,
+        });
+      }
+      return Promise.resolve([]);
+    });
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+    expect(response.status).to.equal(200);
+    const result = await response.json();
+    expect(result.suggestions).to.be.an('array').with.lengthOf(0);
+    expect(result.pagination).to.deep.equal({
+      limit: 100,
+      cursor: null,
+      hasMore: false,
+    });
+  });
+
+  it('gets paged suggestions by status successfully when parameters come as strings from URL', async () => {
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionEntity(suggs[0])],
+          cursor: 'next-cursor-value',
+        });
+      }
+      return Promise.resolve([mockSuggestionEntity(suggs[0])]);
+    });
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+        limit: '50',
+        cursor: 'some-cursor',
+      },
+      ...context,
+    });
+    expect(mockSuggestionDataAccess.Suggestion.allByOpportunityIdAndStatus.calledOnce).to.be.true;
+    expect(response.status).to.equal(200);
+    const result = await response.json();
+    expect(result.suggestions).to.be.an('array').with.lengthOf(1);
+    expect(result.pagination).to.deep.equal({
+      limit: 50,
+      cursor: 'next-cursor-value',
+      hasMore: true,
+    });
+  });
+
+  it('gets paged suggestions by status with cursor parameter calls with correct options', async () => {
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionEntity(suggs[0])],
+          cursor: 'next-cursor',
+        });
+      }
+      return Promise.resolve([mockSuggestionEntity(suggs[0])]);
+    });
+
+    await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+        limit: 25,
+        cursor: 'previous-cursor',
+      },
+      ...context,
+    });
+
+    expect(mockSuggestion.allByOpportunityIdAndStatus).to.have.been.calledWith(
+      OPPORTUNITY_ID,
+      'NEW',
+      {
+        limit: 25,
+        cursor: 'previous-cursor',
+        returnCursor: true,
+      },
+    );
+  });
+
+  it('gets paged suggestions by status handles null opportunity correctly', async () => {
+    const mockSuggestionWithNullOpportunity = {
+      ...mockSuggestionEntity(suggs[0]),
+      getOpportunity: sandbox.stub().returns(null),
+    };
+
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionWithNullOpportunity],
+          cursor: null,
+        });
+      }
+      return Promise.resolve([mockSuggestionWithNullOpportunity]);
+    });
+
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+
+    expect(response.status).to.equal(404);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Opportunity not found');
+  });
+
+  it('gets paged suggestions by status handles opportunity with wrong site ID', async () => {
+    const mockSuggestionWithWrongSite = {
+      ...mockSuggestionEntity(suggs[0]),
+      getOpportunity: sandbox.stub().returns({
+        getSiteId: () => SITE_ID_NOT_ENABLED,
+      }),
+    };
+
+    mockSuggestion.allByOpportunityIdAndStatus.callsFake((opptyId, status, options) => {
+      if (options) {
+        return Promise.resolve({
+          data: [mockSuggestionWithWrongSite],
+          cursor: null,
+        });
+      }
+      return Promise.resolve([mockSuggestionWithWrongSite]);
+    });
+
+    const response = await suggestionsController.getByStatusPaged({
+      params: {
+        siteId: SITE_ID,
+        opportunityId: OPPORTUNITY_ID,
+        status: 'NEW',
+      },
+      ...context,
+    });
+
+    expect(response.status).to.equal(404);
+    const error = await response.json();
+    expect(error).to.have.property('message', 'Opportunity not found');
+  });
+
   it('gets suggestion by ID', async () => {
     const response = await suggestionsController.getByID({
       params: {