Add isActive() command to new Element API (#4261)

Co-authored-by: Priyansh Garg <[email protected]>

lib/api/web-element/commands/isActive.js

@@ -0,0 +1,30 @@
+/**
+ * Determines if an element is currently active/focused in the DOM.
+ *
+ * For more info on working with DOM elements in Nightwatch, refer to the <a href="https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html">Finding & interacting with DOM Elements</a> guide page.
+ *
+ * @example
+ * describe('isActive Demo', function() {
+ *   it('test isActive', function(browser) {
+ *     browser.element('#search')
+ *       .isActive()
+ *       .assert.equals(true);
+ *   });
+ *
+ *   it('test async isActive', async function(browser) {
+ *     const result = await browser.element('#search').isActive();
+ *     browser.assert.equal(result, true);
+ *   });
+ * });
+ *
+ * @since 3.9.0
+ * @method isActive
+ * @memberof ScopedWebElement
+ * @instance
+ * @syntax browser.element.find(selector).isActive()
+ * @link /#get-active-element
+ * @returns {ScopedValue<boolean>}
+ */
+module.exports.command = function () {
+  return this.runQueuedCommandScoped('isElementActive');
+};

lib/transport/selenium-webdriver/method-mappings.js

@@ -493,6 +493,15 @@ module.exports = class MethodMappings {
           };
         },
 
+        async isElementActive(webElementOrId) {
+          const element = this.getWebElement(webElementOrId);
+          const elementId = await element.getId();
+
+          const currentActiveElementId = await this.methods.session.getActiveElement.call(this);
+
+          return elementId === currentActiveElementId;
+        },
+
         async setElementProperty(webElementOrId, name, value) {
           const element = this.getWebElement(webElementOrId);
 

test/src/api/commands/web-element/testIsActive.js

@@ -0,0 +1,130 @@
+const assert = require('assert');
+const {WebElement} = require('selenium-webdriver');
+const MockServer  = require('../../../../lib/mockserver.js');
+const CommandGlobals = require('../../../../lib/globals/commands-w3c.js');
+const common = require('../../../../common.js');
+const Element = common.require('element/index.js');
+
+describe('element().isActive() command', function() {
+  before(function (done) {
+    CommandGlobals.beforeEach.call(this, done);
+  });
+
+  after(function (done) {
+    CommandGlobals.afterEach.call(this, done);
+  });
+
+  it('test .element().isActive() active', async function() {
+    MockServer.addMock({
+      url: '/session/13521-10219-202/element/active',
+      method: 'GET',
+      response: JSON.stringify({
+        value: {
+          'element-6066-11e4-a52e-4f735466cecf': '0'
+        }
+      })
+    }, true);
+
+    const resultPromise = this.client.api.element('#signupSection').isActive();
+    assert.strictEqual(resultPromise instanceof Element, false);
+    assert.strictEqual(typeof resultPromise.find, 'undefined');
+
+    assert.strictEqual(resultPromise instanceof Promise, false);
+    assert.strictEqual(typeof resultPromise.then, 'function');
+
+    const result = await resultPromise;
+    assert.strictEqual(result instanceof WebElement, false);
+    assert.strictEqual(result, true);
+  });
+
+  it('test .element().isActive() not active', async function() {
+    MockServer.addMock({
+      url: '/session/13521-10219-202/element/active',
+      method: 'GET',
+      response: JSON.stringify({
+        value: {
+          'element-6066-11e4-a52e-4f735466cecf': 'random-elem'
+        }
+      })
+    }, true);
+
+    const resultPromise = this.client.api.element('#signupSection').isActive();
+    assert.strictEqual(resultPromise instanceof Element, false);
+    assert.strictEqual(typeof resultPromise.find, 'undefined');
+
+    assert.strictEqual(resultPromise instanceof Promise, false);
+    assert.strictEqual(typeof resultPromise.then, 'function');
+
+    const result = await resultPromise;
+    assert.strictEqual(result instanceof WebElement, false);
+    assert.strictEqual(result, false);
+  });
+
+  it('test .element().find().isActive()', async function() {
+    MockServer.addMock({
+      url: '/session/13521-10219-202/element/active',
+      method: 'GET',
+      response: JSON.stringify({
+        value: {
+          'element-6066-11e4-a52e-4f735466cecf': '1'
+        }
+      })
+    }, true);
+
+    const resultPromise = this.client.api.element('#signupSection').find('#helpBtn').isActive();
+    assert.strictEqual(resultPromise instanceof Element, false);
+    assert.strictEqual(typeof resultPromise.find, 'undefined');
+
+    assert.strictEqual(resultPromise instanceof Promise, false);
+    assert.strictEqual(typeof resultPromise.then, 'function');
+
+    const result = await resultPromise;
+    assert.strictEqual(result instanceof WebElement, false);
+    assert.strictEqual(result, true);
+  });
+
+  it('test .element.find().isActive() not active', async function() {
+    MockServer.addMock({
+      url: '/session/13521-10219-202/element/active',
+      method: 'GET',
+      response: JSON.stringify({
+        value: {
+          'element-6066-11e4-a52e-4f735466cecf': 'random-elem'
+        }
+      })
+    }, true);
+
+    const resultPromise = this.client.api.element.find('#signupSection').isActive();
+    assert.strictEqual(resultPromise instanceof Element, false);
+    assert.strictEqual(typeof resultPromise.find, 'undefined');
+
+    assert.strictEqual(resultPromise instanceof Promise, false);
+    assert.strictEqual(typeof resultPromise.then, 'function');
+
+    const result = await resultPromise;
+    assert.strictEqual(result instanceof WebElement, false);
+    assert.strictEqual(result, false);
+  });
+
+  it('test .element().isActive() assert', async function() {
+    MockServer.addMock({
+      url: '/session/13521-10219-202/element/active',
+      method: 'GET',
+      response: JSON.stringify({
+        value: {
+          'element-6066-11e4-a52e-4f735466cecf': '0'
+        }
+      })
+    }, true);
+
+    const resultPromise = this.client.api.element('#signupSection').isActive();
+    assert.strictEqual(resultPromise instanceof Element, false);
+    assert.strictEqual(typeof resultPromise.find, 'undefined');
+
+    assert.strictEqual(resultPromise instanceof Promise, false);
+    assert.strictEqual(typeof resultPromise.then, 'function');
+
+    assert.strictEqual(await resultPromise.assert.equals(true), true);
+    assert.strictEqual(await resultPromise.assert.not.equals(false), true);
+  });
+});

types/tests/webElement.test-d.ts

@@ -163,6 +163,7 @@ describe('new element() api', function () {
     expectType<ElementValue<boolean>>(elem.isSelected());
     expectType<ElementValue<boolean>>(elem.isVisible());
     expectType<ElementValue<boolean>>(elem.isDisplayed());
+    expectType<ElementValue<boolean>>(elem.isActive());
 
     expectType<ElementValue<ScopedElementRect>>(elem.getRect());
     expectType<ElementValue<ScopedElementRect>>(elem.rect());

types/web-element.d.ts

@@ -216,6 +216,8 @@ export interface ScopedElement extends Element, PromiseLike<WebElement> {
 
   isVisible(): ElementValue<boolean>;
   isDisplayed(): ElementValue<boolean>;
+
+  isActive(): ElementValue<boolean>;
 }
 
 type WaitUntilOptions = {