TypeScript mock.Fakes类代码示例

    it('should grab the destination start and length correctly', () => {
      const targetStart = 12;
      const targetLength = 34;
      const currentStart = 56;
      const currentLength = 78;
      const selectedId = 'selectedId';

      const selectedTab = Mocks.object('selectedTab');
      const highlightElement = Mocks.object('highlightElement');
      Fakes.build(spyOn(tab, 'getStartPosition'))
          .when(highlightElement).return(currentStart)
          .when(selectedTab).return(targetStart);
      Fakes.build(spyOn(tab, 'getLength'))
          .when(highlightElement).return(currentLength)
          .when(selectedTab).return(targetLength);

      const mockElement = jasmine.createSpyObj('Element', ['querySelector']);
      mockElement.querySelector.and.returnValue(selectedTab);

      spyOn(tab, 'setHighlight_').and.returnValue(Promise.resolve());

      tab.updateHighlight_(selectedId, mockElement, highlightElement);
      assert(tab['setHighlight_']).to.haveBeenCalledWith(
          targetStart,
          targetLength,
          currentStart,
          currentLength);
      assert(mockElement.querySelector).to.haveBeenCalledWith(`[tab-id="${selectedId}"]`);
      assert(tab['getStartPosition']).to.haveBeenCalledWith(selectedTab);
      assert(tab['getLength']).to.haveBeenCalledWith(selectedTab);
      assert(tab['getStartPosition']).to.haveBeenCalledWith(highlightElement);
      assert(tab['getLength']).to.haveBeenCalledWith(highlightElement);
    });

    it('should return false if actionNormalDark on white is low contrast', () => {
      const baseNormalDark = Mocks.object('baseNormalDark');
      const baseReversedLight = Mocks.object('baseReversedLight');
      const actionNormalDark = Mocks.object('actionNormalDark');
      const actionNormalDarkest = Mocks.object('actionNormalDarkest');
      const actionNormalLight = Mocks.object('actionNormalLight');
      const actionReversedDark = Mocks.object('actionReversedDark');
      const actionReversedLight = Mocks.object('actionReversedLight');
      Fakes.build(spyOn(Theme, 'createShade_'))
          .when(Matchers.anyThing(), 0.25, false).return(actionNormalDark)
          .when(Matchers.anyThing(), 0, false).return(actionNormalDarkest)
          .when(Matchers.anyThing(), 0.75, false).return(actionNormalLight)
          .when(Matchers.anyThing(), 0.25, true).return(actionReversedDark)
          .when(Matchers.anyThing(), 0.75, true).return(actionReversedLight);

      const accentColor = Mocks.object('accentColor');
      Fakes.build(spyOn(Colors, 'getContrast'))
          .when(actionNormalDark, WHITE).return(10)
          .when(BLACK, actionNormalLight).return(13)
          .when(actionReversedLight, baseNormalDark).return(14)
          .when(WHITE, actionReversedDark).return(15)
          .when(actionReversedLight, BLACK).return(16)
          .when(actionNormalDarkest, baseReversedLight).return(17);

      const passes = Theme['isHighContrastAction_'](
          0.25,
          12,
          accentColor,
          baseNormalDark,
          baseReversedLight);
      assert(passes).to.beFalse();
    });

    it('should return the correct shade for reverseMode', () => {
      const backgroundColor = Mocks.object('backgroundColor');

      const hue = 78;
      const saturation = .9;
      const mockHueColor = jasmine.createSpyObj('HueColor', ['getHue', 'getSaturation']);
      mockHueColor.getHue.and.returnValue(hue);
      mockHueColor.getSaturation.and.returnValue(saturation);
      const idealContrast = 12;

      const distance = 0.34;
      spyOn(Solve, 'findThreshold').and.returnValue(distance);

      const testValue = 0.56;
      const testForeground = Mocks.object('testForeground');
      const shade = Mocks.object('shade');
      Fakes.build(spyOn(HslColor, 'newInstance'))
          .when(Matchers.anyThing(), Matchers.anyThing(), distance).return(shade)
          .when(Matchers.anyThing(), Matchers.anyThing(), testValue).return(testForeground);

      assert(input['getColorShade_'](backgroundColor, mockHueColor, idealContrast, true))
          .to.equal(shade);
      assert(HslColor.newInstance).to.haveBeenCalledWith(hue, saturation, distance);
      assert(Solve.findThreshold).to
          .haveBeenCalledWith(Matchers.any(Spec), Matchers.any(Function) as any, false);
    });

 it(`should do nothing if the ID does not match`, () => {
   const mockMenuContainer = jasmine.createSpyObj('MenuContainer', ['setAttribute']);
   spyOn(service, 'getShownId_').and.returnValue(Symbol('otherId'));
   Fakes.build(spyOn(OverlayBus, 'dispatch')).call((_: any, fn: () => void) => fn());
   service.hideOverlay(Symbol('id'));
   assert(mockMenuContainer.setAttribute).toNot.haveBeenCalled();
   assert(OverlayBus.dispatch).toNot.haveBeenCalled();
 });

    it(`should handle '.' and '/' correctly`, async () => {
      const value = './.';
      const normalizedValue = '___';
      const height = 12;
      const width = 34;
      const clientRect = {height, width} as any;
      const center = Vector2d.of(56, 78);
      const rootEl = document.createElement('div');
      spyOn(rootEl, 'getBoundingClientRect').and.returnValue(clientRect);
      const otherEl = document.createElement('div');
      otherEl.id = normalizedValue;
      rootEl.appendChild(otherEl);

      const containerEl = document.createElement('div');
      const slotContainerEl = document.createElement('div');
      const slotEl = document.createElement('slot');
      let callCount = 0;
      Fakes.build(mockDocument.createElement)
          .when('div').call(() => {
            const toReturn = callCount === 0 ? slotContainerEl : containerEl;
            callCount++;
            return toReturn;
          })
          .when('slot').return(slotEl);

      const lastAction = Mocks.object('lastAction');
      spyOn(ActionTracker, 'get').and.returnValue(Promise.resolve(lastAction));

      const mockContainerAnimation = jasmine.createSpyObj('ContainerAnimation', ['start']);
      const mockSlotAnimation = jasmine.createSpyObj('SlotAnimation', ['start']);

      spyOn(switchEl, 'computeAnimations_').and.returnValue({
        container: mockContainerAnimation,
        slot: mockSlotAnimation,
      });
      spyOn(switchEl, 'getAnimationCircleCenter_').and.returnValue(center);

      await switchEl.onValueChange_(value, rootEl);
      assert(mockSlotAnimation.start).to.haveBeenCalledWith(switchEl, `#${normalizedValue} > *`);
      assert(mockContainerAnimation.start).to.haveBeenCalledWith(switchEl, `#${normalizedValue}`);
      assert(rootEl).to.haveChildren([containerEl]);

      assert(containerEl).to.haveChildren([slotContainerEl]);
      assert(containerEl).to.haveClasses(['container']);
      assert(containerEl.id).to.equal(normalizedValue);

      assert(slotContainerEl).to.haveChildren([slotEl]);
      assert(slotContainerEl).to.haveClasses(['slotContainer']);
      assert(slotContainerEl.style).to
          .equal(Matchers.objectContaining({height: `${height}px`, width: `${width}px`}));

      assert(slotEl.getAttribute('name')).to.equal(value);

      assert(switchEl['computeAnimations_']).to.haveBeenCalledWith(clientRect, center);
      assert(switchEl['getAnimationCircleCenter_']).to.haveBeenCalledWith(lastAction);
    });