use-case-example.js

export const UseCase = (dependencies) => {
 
  const {
    logger,
    repositories: {
      repository,
    },
    services: {
      someExternalCall,
    },
  }
  
  const specificCase = ({ data, onFinish }) => {
    try {
      // os dados já devem chegar preparados para manipulação, uma camada de controller e validation fazem os parses necessários
      
      const [serviceResult, dbCallResult] = await Promise.all([
        someExternalCall(data),
        repository.find(data),
        ]);
      
      return onFinish.OK(); 
    } catch (err) {
      // excessões também são só tratadas aqui
      logger.warn(err);
      onFinish.SERVICE_UNAVAILABLE()
    }
  }
  
  return {
    specificCase,
  }
}

use-case-example.test.js

import { expect } from 'chai';
import sinon from 'sinon';


import { UseCase } from './use-case-example.js';

describe('[APP - V1 - USE CASES] - UseCase', () => {
  let useCases;
  
  const logger = {
    warn: sbox.stub()
  };
  
  const repository = {
    find: sbox.stub(),
  };
  
  const someExternalCall = sbox.stub();
  
  const dependencies = {
    logger,
    repositories: {
      repository,
    },
    services: {
      someExternalCall,
    },
  };

  before(() => {
    useCases = UseCases(dependencies);
  });

  context('instance', () => {
    it('should have a specificCase as a function', () => {
      expect(useCases.specificCase).to.be.a('function');
    });
  });
  
  context('specificCase', () => {
    const onFinish = {
      OK: sbox.stub(),
      SERVICE_UNAVAILABLE: sbox.stub(),
    };
    
    context('OK', () => {
      before(async() => {
        sbox.reset();

        repository.find.resolves(mockedData);
        someExternalCall.resolves({});

        await useCases.specificCase({ data, onFinish });
      });

      it('should call someExternalCall', () => {
        expect(someExternalCall.calledOnce).to.be.true;
      });
      
      it('should call repository find', () => {
        expect(repository.find.calledOnce).to.be.true;
      });

      it('expect onFinish.OK to be called', () => {
        expect(onFinish.OK.calledOnce).to.be.true;
      });
      
      // Se quiser pode ser mais específico sobre o retorno e é até aconselhável
    });
    
    context('SERVICE_UNAVAILABLE', () => {
      before(async() => {
        sbox.reset();

        repository.find.rejects();

        await useCases.specificCase({ data, onFinish });
      });
       
      it('should call repository find', () => {
        expect(logger.warn.calledOnce).to.be.true;
      });

      it('expect onFinish.SERVICE_UNAVAILABLE to be called', () => {
        expect(onFinish.SERVICE_UNAVAILABLE.calledOnce).to.be.true;
      });
    });
  });
});