boards-auto-installer.test.ts

// import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
// const disableJSDOM = enableJSDOM();

// import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
// import { ApplicationProps } from '@theia/application-package/lib/application-props';
// FrontendApplicationConfigProvider.set({
//   ...ApplicationProps.DEFAULT.frontend.config,
// });

// import { MessageService } from '@theia/core';
// import { BoardsServiceProvider } from '../../browser/boards/boards-service-provider';
// import { BoardsListWidgetFrontendContribution } from '../../browser/boards/boards-widget-frontend-contribution';
// import {
//   Board,
//   BoardsPackage,
//   BoardsService,
//   Port,
//   ResponseServiceArduino,
// } from '../../common/protocol';
// import { IMock, It, Mock, Times } from 'typemoq';
// import { Container, ContainerModule } from 'inversify';
// import { BoardsAutoInstaller } from '../../browser/boards/boards-auto-installer';
// import { BoardsConfig } from '../../browser/boards/boards-config';
// import { tick } from '../utils';
// import { ListWidget } from '../../browser/widgets/component-list/list-widget';

// disableJSDOM();

// const aBoard: Board = {
//   fqbn: 'some:board:fqbn',
//   name: 'Some Arduino Board',
//   port: { address: '/lol/port1234', protocol: 'serial' },
// };
// const aPort: Port = {
//   address: aBoard.port!.address,
//   protocol: aBoard.port!.protocol,
// };
// const aBoardConfig: BoardsConfig.Config = {
//   selectedBoard: aBoard,
//   selectedPort: aPort,
// };
// const aPackage: BoardsPackage = {
//   author: 'someAuthor',
//   availableVersions: ['some.ver.sion', 'some.other.version'],
//   boards: [aBoard],
//   deprecated: false,
//   description: 'Some Arduino Board, Some Other Arduino Board',
//   id: 'some:arduinoCoreId',
//   installable: true,
//   moreInfoLink: 'http://www.some-url.lol/',
//   name: 'Some Arduino Package',
//   summary: 'Boards included in this package:',
// };

// const anInstalledPackage: BoardsPackage = {
//   ...aPackage,
//   installedVersion: 'some.ver.sion',
// };

// describe('BoardsAutoInstaller', () => {
//   let subject: BoardsAutoInstaller;
//   let messageService: IMock<MessageService>;
//   let boardsService: IMock<BoardsService>;
//   let boardsServiceClient: IMock<BoardsServiceProvider>;
//   let responseService: IMock<ResponseServiceArduino>;
//   let boardsManagerFrontendContribution: IMock<BoardsListWidgetFrontendContribution>;
//   let boardsManagerWidget: IMock<ListWidget<BoardsPackage>>;

//   let testContainer: Container;

//   beforeEach(() => {
//     testContainer = new Container();
//     messageService = Mock.ofType<MessageService>();
//     boardsService = Mock.ofType<BoardsService>();
//     boardsServiceClient = Mock.ofType<BoardsServiceProvider>();
//     responseService = Mock.ofType<ResponseServiceArduino>();
//     boardsManagerFrontendContribution =
//       Mock.ofType<BoardsListWidgetFrontendContribution>();
//     boardsManagerWidget = Mock.ofType<ListWidget<BoardsPackage>>();

//     boardsManagerWidget.setup((b) =>
//       b.refresh(aPackage.name.toLocaleLowerCase())
//     );

//     boardsManagerFrontendContribution
//       .setup((b) => b.openView({ reveal: true }))
//       .returns(async () => boardsManagerWidget.object);

//     messageService
//       .setup((m) => m.showProgress(It.isAny(), It.isAny()))
//       .returns(async () => ({
//         cancel: () => null,
//         id: '',
//         report: () => null,
//         result: Promise.resolve(''),
//       }));

//     responseService
//       .setup((r) => r.onProgressDidChange(It.isAny()))
//       .returns(() => ({ dispose: () => null }));

//     const module = new ContainerModule((bind) => {
//       bind(BoardsAutoInstaller).toSelf();
//       bind(MessageService).toConstantValue(messageService.object);
//       bind(BoardsService).toConstantValue(boardsService.object);
//       bind(BoardsServiceProvider).toConstantValue(boardsServiceClient.object);
//       bind(ResponseServiceArduino).toConstantValue(responseService.object);
//       bind(BoardsListWidgetFrontendContribution).toConstantValue(
//         boardsManagerFrontendContribution.object
//       );
//     });

//     testContainer.load(module);
//     subject = testContainer.get(BoardsAutoInstaller);
//   });

//   context('when it starts', () => {
//     it('should register to the BoardsServiceClient in order to check the packages every a new board is plugged in', () => {
//       subject.onStart();
//       boardsServiceClient.verify(
//         (b) => b.onBoardsConfigChanged(It.isAny()),
//         Times.once()
//       );
//     });

//     context('and it checks the installable packages', () => {
//       context(`and a port and a board a selected`, () => {
//         beforeEach(() => {
//           boardsServiceClient
//             .setup((b) => b.boardsConfig)
//             .returns(() => aBoardConfig);
//         });
//         context('if no package for the board is already installed', () => {
//           context('if a candidate package for the board is found', () => {
//             beforeEach(() => {
//               boardsService
//                 .setup((b) => b.search(It.isValue({})))
//                 .returns(async () => [aPackage]);
//             });
//             it('should show a notification suggesting to install that package', async () => {
//               messageService
//                 .setup((m) =>
//                   m.info(It.isAnyString(), It.isAnyString(), It.isAnyString())
//                 )
//                 .returns(() => Promise.resolve('Install Manually'));
//               subject.onStart();
//               await tick();
//               messageService.verify(
//                 (m) =>
//                   m.info(It.isAnyString(), It.isAnyString(), It.isAnyString()),
//                 Times.once()
//               );
//             });
//             context(`if the answer to the message is 'Yes'`, () => {
//               beforeEach(() => {
//                 messageService
//                   .setup((m) =>
//                     m.info(It.isAnyString(), It.isAnyString(), It.isAnyString())
//                   )
//                   .returns(() => Promise.resolve('Yes'));
//               });
//               it('should install the package', async () => {
//                 subject.onStart();

//                 await tick();

//                 messageService.verify(
//                   (m) => m.showProgress(It.isAny(), It.isAny()),
//                   Times.once()
//                 );
//               });
//             });
//             context(
//               `if the answer to the message is 'Install Manually'`,
//               () => {
//                 beforeEach(() => {
//                   messageService
//                     .setup((m) =>
//                       m.info(
//                         It.isAnyString(),
//                         It.isAnyString(),
//                         It.isAnyString()
//                       )
//                     )
//                     .returns(() => Promise.resolve('Install Manually'));
//                 });
//                 it('should open the boards manager widget', () => {
//                   subject.onStart();
//                 });
//               }
//             );
//           });
//           context('if a candidate package for the board is not found', () => {
//             beforeEach(() => {
//               boardsService
//                 .setup((b) => b.search(It.isValue({})))
//                 .returns(async () => []);
//             });
//             it('should do nothing', async () => {
//               subject.onStart();
//               await tick();
//               messageService.verify(
//                 (m) =>
//                   m.info(It.isAnyString(), It.isAnyString(), It.isAnyString()),
//                 Times.never()
//               );
//             });
//           });
//         });
//         context(
//           'if one of the packages for the board is already installed',
//           () => {
//             beforeEach(() => {
//               boardsService
//                 .setup((b) => b.search(It.isValue({})))
//                 .returns(async () => [aPackage, anInstalledPackage]);
//               messageService
//                 .setup((m) =>
//                   m.info(It.isAnyString(), It.isAnyString(), It.isAnyString())
//                 )
//                 .returns(() => Promise.resolve('Yes'));
//             });
//             it('should do nothing', async () => {
//               subject.onStart();
//               await tick();
//               messageService.verify(
//                 (m) =>
//                   m.info(It.isAnyString(), It.isAnyString(), It.isAnyString()),
//                 Times.never()
//               );
//             });
//           }
//         );
//       });
//       context('and there is no selected board or port', () => {
//         it('should do nothing', async () => {
//           subject.onStart();
//           await tick();
//           messageService.verify(
//             (m) => m.info(It.isAnyString(), It.isAnyString(), It.isAnyString()),
//             Times.never()
//           );
//         });
//       });
//     });
//   });
// });