it('should return an OK response if all dependencies are healthy', async () => {
      when(healthcheckService.isHealthy()).thenReturn(Promise.resolve(true))

      await healthcheckController.healthcheck()

      verify(healthcheckController.setStatus(OK))
    })

  it('translate interactively with no rule result', async () => {
    const env = new TestEnvironment();
    const sourceSegment = ['Esto', 'es', 'una', 'prueba', '.'];
    when(
      env.mockedHttpClient.post<InteractiveTranslationResultDto>(
        'translation/engines/project:project01/actions/interactiveTranslate',
        deepEqual(sourceSegment)
      )
    ).thenReturn(
      of({
        status: 200,
        data: {
          wordGraph: {
            initialStateScore: -111.111,
            finalStates: [],
            arcs: []
          }
        }
      })
    );

    const result = await env.client.translateInteractively('project01', sourceSegment);
    expect(result.smtWordGraph).not.toBeUndefined();
    expect(result.ruleResult).toBeUndefined();
  });

 it('returns a promise with the id', async () => {
   when(mockedNativeCommandsSender.dismissAllModals(anyString(), anything())).thenResolve(
     'the id'
   );
   const result = await uut.dismissAllModals();
   expect(result).toEqual('the id');
 });

  beforeEach(() => {
    const mockedAssetService = mock(AssetService);
    when(mockedAssetService.resolveFromRequire(anyNumber())).thenReturn({
      height: 100,
      scale: 1,
      uri: 'lol',
      width: 100
    });
    const assetService = instance(mockedAssetService);

    const mockedColorService = mock(ColorService);
    when(mockedColorService.toNativeColor(anyString())).thenReturn(666);
    const colorService = instance(mockedColorService);

    uut = new OptionsProcessor(store, new UniqueIdProvider(), colorService, assetService);
  });

    it("should call onSuccess after segment loading succeeded", () => {
        const loader = mock<LoaderInterface>(LoaderInterfaceEmptyImpl);

        const onSuccess = sinon.spy();
        let segmentLoadedListener: Function = () => { throw new Error("SegmentLoaded listener not set"); };
        when(loader.on(Events.SegmentLoaded, anyFunction())).thenCall((eventName_unused, listener) => {
            segmentLoadedListener = listener;
        });

        const segment = new Segment(
            "id",
            testPlaylist.baseUrl + "segment-1045.ts",
            testPlaylist.url,
            testPlaylist.url,
            undefined,
            "1045",
            undefined, 0, new ArrayBuffer(0));

        const manager = new SegmentManager(instance(loader));
        manager.processPlaylist(testPlaylist.url, testPlaylist.content, testPlaylist.url);
        manager.loadSegment(segment.url, undefined, onSuccess, () => {});
        segmentLoadedListener(segment);

        onSuccess.calledWith(segment.data);
    });

    it('calls findMatchingFiles with given arguments', () => {
      const app = new BaseApp();
      const spiedContext = spy(Context);

      when(spiedContext.findMatchingFiles(anything(), anything())).thenReturn([]);

      app.addDirectory('src/**/*.js', {
        isGlob: true,
        globOptions: {
          gitignore: true,
        },
      });

      const lastCall = capture(spiedContext.findMatchingFiles).last();
      lastCall.must.eql([
        'src/**/*.js',
        {
          isGlob: true,
          globOptions: {
            gitignore: true,
          },
        },
      ]);

      reset(spiedContext);
    });