TypeScript ElementFinder.getLocation方法代碼示例

/** Checks if the given element is visible in the given viewport. */
async function isVisibleInViewport(el: ElementFinder, viewport: ElementFinder): Promise<boolean> {
  if (!await el.isPresent() || !await el.isDisplayed() || !await viewport.isPresent() ||
      !await viewport.isDisplayed()) {
    return false;
  }
  const viewportRect = getRect(await viewport.getLocation(), await viewport.getSize());
  const elRect = getRect(await el.getLocation(), await el.getSize());
  return elRect.left < viewportRect.right && elRect.right > viewportRect.left &&
      elRect.top < viewportRect.bottom && elRect.bottom > viewportRect.top;
}

  it('should scroll to seventh heading from button with custom easing', () => {
    const target: ElementFinder = element(by.css('#head7'));
    const trigger: ElementFinder = element(by.css('#customEasingButton'));
    const pageScrollDuration = 1250;
    target.getLocation().then((headingLocation: any) => {
      page.getScrollPos().then((initialPos: number) => {
        expect(initialPos).toEqual(0);
        // Make sure the browser logs are empty so get them once (which automatically clears them)
        // Source: http://stackoverflow.com/a/30589885
        browser.manage().logs().get('browser').then(() => {
          trigger.sendKeys(protractor.Key.ENTER).then(() => {
            browser.sleep(pageScrollDuration).then(() => {
              // At the end of the time the scrolling should be at the specific target position
              page.getScrollPos().then((pos: number) => {
                expect(pos).toBeCloseTo(Math.round(headingLocation.y), Closeness.ofByOne);
              });
              // Inspect the console logs, they should contain all in between scroll positions
              // Using the browser.sleep() to execute some code while the animation is running does not work
              // consistently across browser, especially causing problems with the CI server
              browser.manage().logs().get('browser').then(browserLog => {
                const scrollPositionHistory = browserLog
                  .filter(log => log.message.indexOf('Scroll Position: ') >= 0) // only take scroll position logs
                  .map(log => parseInt(log.message.split(' ').reverse()[0], 10)); // parse scroll logs into ints

                expect(scrollPositionHistory.length).toBeGreaterThan(0);

                const averageScrollPosChange = scrollPositionHistory[scrollPositionHistory.length - 1]
                  / scrollPositionHistory.length;

                // For the first quarter check that the scrollPosChange is below the linear average
                const firstQuarterEnd = Math.round(scrollPositionHistory.length * 0.25);
                for (let i = 0; i < firstQuarterEnd; i++) {
                  const scrollPosChange = scrollPositionHistory[i + 1] - scrollPositionHistory[i];
                  expect(scrollPosChange).toBeLessThan(averageScrollPosChange);
                }

                // For the 20% in the middle check that the scrollPosChange is above the linear average
                const center20PercentStart = Math.round(scrollPositionHistory.length * 0.4);
                const center20PercentEnd = Math.round(scrollPositionHistory.length * 0.6);
                for (let i = center20PercentStart; i < center20PercentEnd; i++) {
                  const scrollPosChange = scrollPositionHistory[i + 1] - scrollPositionHistory[i];
                  expect(scrollPosChange).toBeGreaterThan(averageScrollPosChange);
                }

                // For the last quarter again check that the scrollPosChange is below the linear one
                const lastQuarterStart = Math.round(scrollPositionHistory.length * 0.75);
                for (let i = lastQuarterStart; i < scrollPositionHistory.length - 2; i++) {
                  const scrollPosChange = scrollPositionHistory[i + 1] - scrollPositionHistory[i];
                  expect(scrollPosChange).toBeLessThan(averageScrollPosChange);
                }
              });
            });
          });
        });
      });
    });
  });

 expectMenuLocation(el: ElementFinder, {x, y}: {x: number, y: number}) {
   el.getLocation().then(loc => {
     expect(loc.x).toEqual(x, 'Expect the x-position to be equal');
     expect(loc.y).toEqual(y, 'Expect the y-position to be equal');
   });
 }

 scrollToElement(elm: ElementFinder): promise.Promise<{}> {
   return elm.getLocation().then((loc) => {
     return browser.driver.executeScript('window.scrollTo(0,arguments[0]);', loc.y);
   });
 }