diff --git a/tests/helpers/properties/acceptance-adapter.js b/tests/helpers/properties/acceptance-adapter.js
index 1db6f0c6..d2ac43cd 100644
--- a/tests/helpers/properties/acceptance-adapter.js
+++ b/tests/helpers/properties/acceptance-adapter.js
@@ -1,9 +1,10 @@
-import Ember from 'ember';
 import startApp from '../start-app';
 import { module as qunitModule } from 'qunit';
 
 export { test as testForAcceptance } from 'qunit';
 
+import Ember from 'ember';
+
 let noop = function() {};
 
 export function AcceptanceAdapter(original) {
@@ -20,16 +21,8 @@ export function AcceptanceAdapter(original) {
 AcceptanceAdapter.prototype = {
   name: 'acceptance',
 
-  click(fn) {
-    window.click = fn;
-  },
-
-  fillIn(fn) {
-    this.spy.fillIn = fn;
-  },
-
-  triggerEvent(fn /*selector, container, eventName, eventOptions*/) {
-    window.triggerEvent = fn;
+  $(selector, isAlternative) {
+    return Ember.$(selector, isAlternative ? '#alternate-ember-testing' : '#ember-testing');
   },
 
   visit(fn) {
@@ -38,8 +31,6 @@ AcceptanceAdapter.prototype = {
 
   revert() {
     this.original.prototype = Object.create(this.originalPrototype);
-    window.click = this.originalClick;
-    window.triggerEvent = this.originalTriggerEvent;
     window.visit = this.originalVisit;
   },
 
@@ -53,6 +44,10 @@ AcceptanceAdapter.prototype = {
     fixture(template, options);
   },
 
+  find() {
+    return this.original.find(...arguments);
+  },
+
   throws(assert, block, expected, message) {
     let done = assert.async();
 
diff --git a/tests/helpers/properties/integration-adapter.js b/tests/helpers/properties/integration-adapter.js
index f8cf514d..18c4ab1b 100644
--- a/tests/helpers/properties/integration-adapter.js
+++ b/tests/helpers/properties/integration-adapter.js
@@ -1,8 +1,9 @@
-import Ember from 'ember';
 import { fixture } from './acceptance-adapter';
 export { moduleForComponent as moduleForIntegration, test as testForIntegration } from 'ember-qunit';
 import { expectEmberError } from '../../test-helper';
 
+import Ember from 'ember';
+
 export function IntegrationAdapter(original) {
   this.original = original;
   this.originalPrototype = original.prototype;
@@ -14,16 +15,8 @@ export function IntegrationAdapter(original) {
 IntegrationAdapter.prototype = {
   name: 'integration',
 
-  click(fn) {
-    this.spy.click = fn;
-  },
-
-  fillIn(fn) {
-    this.spy.fillIn = fn;
-  },
-
-  triggerEvent(fn) {
-    this.spy.triggerEvent = fn;
+  $(selector, isAlternative) {
+    return Ember.$(selector, isAlternative ? '#alternate-ember-testing' : '#ember-testing');
   },
 
   revert() {
@@ -58,6 +51,10 @@ IntegrationAdapter.prototype = {
     });
   },
 
+  find() {
+    return this.original.find(...arguments);
+  },
+
   andThen(fn) {
     fn();
   },
diff --git a/tests/unit/-private/properties/alias-test.js b/tests/unit/-private/properties/alias-test.js
index 53f4c92b..5a030291 100644
--- a/tests/unit/-private/properties/alias-test.js
+++ b/tests/unit/-private/properties/alias-test.js
@@ -36,8 +36,8 @@ moduleForProperty('alias', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>Click me</button>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
+    this.adapter.$('button').on('click', function() {
+      assert.ok(true);
     });
 
     page.aliasedClickButton();
@@ -95,8 +95,8 @@ moduleForProperty('alias', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>Click me</button>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
+    this.adapter.$('button').on('click', function() {
+      assert.ok(true);
     });
 
     page.aliasedClickButton();
@@ -159,8 +159,8 @@ moduleForProperty('alias', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>Click me</button>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
+    this.adapter.$('button').on('click', function() {
+      assert.ok(true);
     });
 
     page.aliasedClickButton();
diff --git a/tests/unit/-private/properties/click-on-text-test.js b/tests/unit/-private/properties/click-on-text-test.js
index 6a1b4814..56bb7bba 100644
--- a/tests/unit/-private/properties/click-on-text-test.js
+++ b/tests/unit/-private/properties/click-on-text-test.js
@@ -5,10 +5,7 @@ moduleForProperty('clickOnText', function(test) {
   test('calls click helper', function(assert) {
     assert.expect(2);
 
-    let expectedSelector;
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickOnText('fieldset'),
       bar: clickOnText('button')
     });
@@ -20,28 +17,30 @@ moduleForProperty('clickOnText', function(test) {
       </fieldset>
     `);
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.andThen(() => {
-      expectedSelector = 'fieldset :contains("Lorem"):last';
+      this.adapter.$('fieldset :contains("Lorem"):last').one('click', function() {
+        assert.ok(true);
+      });
+
       page.foo('Lorem');
+
+      return this.adapter.wait();
     });
 
     this.adapter.andThen(() => {
-      expectedSelector = 'button:contains("Lorem")';
+      this.adapter.$('button:contains("Lorem")').one('click', function() {
+        assert.ok(true);
+      });
       page.bar('Lorem');
+
+      return this.adapter.wait();
     });
   });
 
   test('looks for elements inside the scope', function(assert) {
     assert.expect(2);
 
-    let expectedSelector;
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickOnText('fieldset', { scope: '.scope' }),
       bar: clickOnText('button', { scope: '.scope' })
     });
@@ -55,18 +54,18 @@ moduleForProperty('clickOnText', function(test) {
       </div>
     `);
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.andThen(() => {
-      expectedSelector = '.scope fieldset :contains("Lorem"):last';
+      this.adapter.$('.scope fieldset :contains("Lorem"):last').one('click', () => assert.ok(1));
       page.foo('Lorem');
+
+      return this.adapter.wait();
     });
 
     this.adapter.andThen(() => {
-      expectedSelector = '.scope button:contains("Lorem")';
+      this.adapter.$('.scope button:contains("Lorem")').one('click', () => assert.ok(1));
       page.bar('Lorem');
+
+      return this.adapter.wait();
     });
 
     return this.adapter.wait();
@@ -75,10 +74,7 @@ moduleForProperty('clickOnText', function(test) {
   test("looks for elements inside page's scope", function(assert) {
     assert.expect(2);
 
-    let page;
-    let expectedSelector;
-
-    page = create({
+    let page = create({
       scope: '.scope',
       foo: clickOnText('fieldset'),
       bar: clickOnText('button')
@@ -93,28 +89,25 @@ moduleForProperty('clickOnText', function(test) {
       </div>
     `);
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.andThen(() => {
-      expectedSelector = '.scope fieldset :contains("Lorem"):last';
+      this.adapter.$('.scope fieldset :contains("Lorem"):last').one('click', () => assert.ok(1));
       page.foo('Lorem');
+
+      return this.adapter.wait();
     });
 
     this.adapter.andThen(() => {
-      expectedSelector = '.scope button:contains("Lorem")';
+      this.adapter.$('.scope button:contains("Lorem")').one('click', () => assert.ok(1));
       page.bar('Lorem');
+
+      return this.adapter.wait();
     });
   });
 
   test('resets scope', function(assert) {
     assert.expect(2);
 
-    let page;
-    let expectedSelector;
-
-    page = create({
+    let page = create({
       scope: '.scope',
       foo: clickOnText('fieldset', { resetScope: true }),
       bar: clickOnText('button', { resetScope: true })
@@ -127,18 +120,15 @@ moduleForProperty('clickOnText', function(test) {
       </fieldset>
     `);
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.andThen(() => {
-      expectedSelector = 'fieldset :contains("Lorem"):last';
+      this.adapter.$('fieldset :contains("Lorem"):last').one('click', () => assert.ok(1));
       page.foo('Lorem');
     });
 
     this.adapter.andThen(() => {
-      expectedSelector = 'button:contains("Lorem")';
+      this.adapter.$('button:contains("Lorem")').one('click', () => assert.ok(1));
       page.bar('Lorem');
+      return this.adapter.wait();
     });
   });
 
@@ -155,18 +145,13 @@ moduleForProperty('clickOnText', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>dummy text</button>');
 
-    this.adapter.click(() => {});
-
     assert.equal(page.foo('dummy text'), page);
   });
 
   test('finds element by index', function(assert) {
     assert.expect(2);
 
-    let expectedSelector;
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickOnText('fieldset', { at: 2 }),
       bar: clickOnText('button', { at: 2 })
     });
@@ -180,17 +165,13 @@ moduleForProperty('clickOnText', function(test) {
       </fieldset>
     `);
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.andThen(() => {
-      expectedSelector = 'fieldset :contains("Lorem"):eq(2)';
+      this.adapter.$('fieldset :contains("Lorem"):eq(2)').one('click', () => assert.ok(1));
       page.foo('Lorem');
     });
 
     this.adapter.andThen(() => {
-      expectedSelector = 'button:contains("Lorem"):eq(2)';
+      this.adapter.$('button:contains("Lorem"):eq(2)').one('click', () => assert.ok(1));
       page.bar('Lorem');
     });
   });
@@ -207,11 +188,8 @@ moduleForProperty('clickOnText', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>Lorem</button>', { useAlternateContainer: true });
 
-    this.adapter.click((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
-
     this.adapter.andThen(() => {
+      this.adapter.$('button', true).one('click', () => assert.ok(1));
       page.foo('Lorem');
     });
   });
@@ -220,21 +198,19 @@ moduleForProperty('clickOnText', function(test) {
     assert.expect(1);
 
     let expectedContext = '#alternate-ember-testing';
-    let page;
-
-    page = create({
+    let page = create({
       testContainer: expectedContext,
       foo: clickOnText('button')
     });
 
     this.adapter.createTemplate(this, page, '<button>Lorem</button>', { useAlternateContainer: true });
-
-    this.adapter.click((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
+    this.adapter.createTemplate(this, page, '<button>Lorem</button>');
 
     this.adapter.andThen(() => {
+      this.adapter.$('button', true).one('click', () => assert.ok(1));
       page.foo('Lorem');
+
+      return this.adapter.wait();
     });
   });
 
@@ -267,9 +243,7 @@ moduleForProperty('clickOnText', function(test) {
 
     this.adapter.createTemplate(this, page, '<button style="display:none">Click me</button>');
 
-    this.adapter.click(() => {
-      assert.ok(true, 'Element is clicked');
-    });
+    this.adapter.$('button').on('click', () => assert.ok(1));
 
     page.foo('Click me');
 
diff --git a/tests/unit/-private/properties/clickable-test.js b/tests/unit/-private/properties/clickable-test.js
index 7dd08de9..b86afdf4 100644
--- a/tests/unit/-private/properties/clickable-test.js
+++ b/tests/unit/-private/properties/clickable-test.js
@@ -6,21 +6,18 @@ moduleForProperty('clickable', function(test) {
     assert.expect(1);
 
     let expectedSelector = 'button';
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickable(expectedSelector)
     });
 
     this.adapter.createTemplate(this, page, '<button>Click me</button>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
-    page.foo();
+    this.adapter.andThen(() => {
+      this.adapter.$(expectedSelector).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('looks for elements inside the scope', function(assert) {
@@ -35,13 +32,12 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<div class="scope"><span>Click me</span></div>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
-    page.foo();
+    this.adapter.andThen(() => {
+      this.adapter.$(expectedSelector).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test("looks for elements inside page's scope", function(assert) {
@@ -58,13 +54,12 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<div class="scope"><span>Click me</span></div>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$(expectedSelector).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('resets scope', function(assert) {
@@ -80,28 +75,23 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<span>Click me</span>');
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$(expectedSelector).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('returns target object', function(assert) {
     assert.expect(1);
 
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickable('span')
     });
 
     this.adapter.createTemplate(this, page, '<span>Click me</span>');
 
-    this.adapter.click(function() {});
-
     assert.equal(page.foo(), page);
   });
 
@@ -109,21 +99,18 @@ moduleForProperty('clickable', function(test) {
     assert.expect(1);
 
     let expectedSelector = 'span:eq(3)';
-    let page;
-
-    page = create({
+    let page = create({
       foo: clickable('span', { at: 3 })
     });
 
-    this.adapter.click((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.createTemplate(this, page, '<span></span><span></span><span>Click me</span><span></span>');
 
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$(expectedSelector).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('looks for elements outside the testing container', function(assert) {
@@ -138,13 +125,12 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<span>Click me</span>', { useAlternateContainer: true });
 
-    this.adapter.click((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
-
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$('span', expectedContext).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('looks for elements within test container specified at node level', function(assert) {
@@ -160,13 +146,12 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<span>Click me</span>', { useAlternateContainer: true });
 
-    this.adapter.click((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
-
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$('span', expectedContext).one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test("raises an error when the element doesn't exist", function(assert) {
@@ -200,13 +185,12 @@ moduleForProperty('clickable', function(test) {
 
     this.adapter.createTemplate(this, page, '<span style="display:none">Click me</span>');
 
-    this.adapter.click(() => {
-      assert.ok(true, 'Element is clicked');
-    });
-
-    page.foo();
+    return this.adapter.andThen(() => {
+      this.adapter.$('span').one('click', () => assert.ok(1));
+      page.foo();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('raises an error when the element is not visible and `visible` is true', function(assert) {
diff --git a/tests/unit/-private/properties/dsl-test.js b/tests/unit/-private/properties/dsl-test.js
index b00885d3..8d5b85f3 100644
--- a/tests/unit/-private/properties/dsl-test.js
+++ b/tests/unit/-private/properties/dsl-test.js
@@ -63,13 +63,15 @@ moduleForProperty('dsl', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>dummy text</button>');
 
-    this.adapter.click(() => {
-      assert.ok(true, 'click called');
-    });
+    return this.adapter.andThen(() => {
+      // text nodes don't support click events
+      // instead we check that click on text content propagates to the parent button
+      this.adapter.$('button').one('click', () => assert.ok(1));
 
-    page.foo.clickOn('dummy text');
+      page.foo.clickOn('dummy text');
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('generates .click', function(assert) {
@@ -83,13 +85,13 @@ moduleForProperty('dsl', function(test) {
 
     this.adapter.createTemplate(this, page, '<button>dummy text</button>');
 
-    this.adapter.click(() => {
-      assert.ok(true, 'click called');
-    });
+    return this.adapter.andThen(() => {
+      this.adapter.$('button').one('click', () => assert.ok(1));
 
-    page.foo.click();
+      page.foo.click();
 
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test('generates .contains', function(assert) {
@@ -132,13 +134,11 @@ moduleForProperty('dsl', function(test) {
 
     this.adapter.createTemplate(this, page, '<input name="email">');
 
-    this.adapter.fillIn((selector, context, options, content) => {
-      assert.equal(content, 'lorem ipsum');
-    });
-
     page.foo.fillIn('lorem ipsum');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$('input').val(), 'lorem ipsum');
+    });
   });
 
   test('generates .select', function(assert) {
@@ -152,13 +152,11 @@ moduleForProperty('dsl', function(test) {
 
     this.adapter.createTemplate(this, page, '<input name="email">');
 
-    this.adapter.fillIn((selector, context, options, content) => {
-      assert.equal(content, 'lorem ipsum');
-    });
-
     page.foo.select('lorem ipsum');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$('input').val(), 'lorem ipsum');
+    });
   });
 
   test('generates .value', function(assert) {
diff --git a/tests/unit/-private/properties/fillable-test.js b/tests/unit/-private/properties/fillable-test.js
index 9e58b6c3..ab9599ee 100644
--- a/tests/unit/-private/properties/fillable-test.js
+++ b/tests/unit/-private/properties/fillable-test.js
@@ -3,7 +3,7 @@ import { create, fillable, selectable } from 'ember-cli-page-object';
 
 moduleForProperty('fillable', function(test) {
   test("calls fillIn method belonging to execution context", function(assert) {
-    assert.expect(2);
+    assert.expect(1);
 
     let expectedSelector = 'input';
     let expectedText = 'dummy text';
@@ -13,62 +13,77 @@ moduleForProperty('fillable', function(test) {
       foo: fillable(expectedSelector)
     });
 
-    this.adapter.fillIn((actualSelector, actualContext, options, actualContent) => {
-      assert.equal(actualSelector, expectedSelector);
-      assert.equal(actualContent, expectedText);
-    });
-
     this.adapter.createTemplate(this, page, '<input>');
 
     page.foo(expectedText);
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$(expectedSelector).val(), expectedText);
+    });
   });
 
-  test('looks for inputs or contenteditables with data-test="clue" attributes', function(assert) {
-    let expectedText = 'dummy text';
-    let clue = 'clue';
-    let page;
-
-    page = create({
-      scope: '.scope',
-
-      foo: fillable()
+  const targetAttributes = ['data-test', 'aria-label', 'placeholder', 'name', 'id'];
+
+  const formControlTemplates = [
+    '<input data-test="clue" />',
+    '<input aria-label="clue" />',
+    '<input placeholder="clue" />',
+    '<input name="clue" />',
+    '<input id="clue" />',
+
+    '<textarea data-test="clue"></textarea>',
+    '<textarea aria-label="clue"></textarea>',
+    '<textarea placeholder="clue"></textarea>',
+    '<textarea name="clue"></textarea>',
+    '<textarea id="clue"></textarea>',
+
+    '<select data-test="clue"><option></option><option>dummy text</option></select>',
+    '<select aria-label="clue"><option></option><option>dummy text</option></select>',
+    '<select placeholder="clue"><option></option><option>dummy text</option></select>',
+    '<select name="clue"><option></option><option>dummy text</option></select>',
+    '<select id="clue"><option></option><option>dummy text</option></select>',
+  ];
+
+  formControlTemplates.forEach(template => {
+    let gtPos = template.indexOf('=');
+    let name = template.substr(1, gtPos - 1);
+    const [tagName, attrName] = name.split(' ');
+
+    test(`looks for ${tagName} with ${attrName}`, function(assert) {
+      let expectedText = 'dummy text';
+      let clue = 'clue';
+      let page = create({
+        scope: '.scope',
+        foo: fillable()
+      });
+
+      this.adapter.createTemplate(this, page, `<div class="scope">${template}</div>`);
+
+      page.foo(clue, expectedText);
+
+      return this.adapter.andThen(() => {
+        assert.equal(this.adapter.$(`${tagName}[${attrName}="${clue}"]`).val(), expectedText);
+      });
     });
+  });
 
-    this.adapter.createTemplate(this, page, '<div class="scope"><input data-test="clue"></div>');
-
-    this.adapter.fillIn((actualSelector, actualContext, options, actualContent) => {
-      assert.ok(/\.scope input\[data-test="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope input\[aria-label="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope input\[placeholder="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope input\[name="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope input#clue/.test(actualSelector));
-
-      assert.ok(/\.scope textarea\[data-test="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope textarea\[aria-label="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope textarea\[placeholder="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope textarea\[name="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope textarea#clue/.test(actualSelector));
-
-      assert.ok(/\.scope select\[data-test="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope select\[aria-label="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope select\[placeholder="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope select\[name="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope select#clue/.test(actualSelector));
-
-      assert.ok(/\.scope \[contenteditable\]\[data-test="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope \[contenteditable\]\[aria-label="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope \[contenteditable\]\[placeholder="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope \[contenteditable\]\[name="clue"\]/.test(actualSelector));
-      assert.ok(/\.scope \[contenteditable\]#clue/.test(actualSelector));
-
-      assert.equal(actualContent, expectedText);
-    });
+  targetAttributes.forEach(attrName => {
+    test(`looks for [contenteditable] with ${attrName}`, function(assert) {
+      let expectedText = 'dummy text';
+      let clue = 'clue';
+      let page = create({
+        scope: '.scope',
+        foo: fillable()
+      });
+
+      this.adapter.createTemplate(this, page, `<div class="scope"><div contenteditable ${attrName}="clue"></div></div>`);
 
-    page.foo(clue, expectedText);
+      page.foo(clue, expectedText);
 
-    return this.adapter.wait();
+      return this.adapter.andThen(() => {
+        assert.equal(this.adapter.$(`div[${attrName}="${clue}"]`).html(), expectedText);
+      });
+    });
   });
 
   test('looks for elements inside the scope', function(assert) {
@@ -80,13 +95,11 @@ moduleForProperty('fillable', function(test) {
 
     this.adapter.createTemplate(this, page, '<div class="scope"><input></div>');
 
-    this.adapter.fillIn((actualSelector) => {
-      assert.equal(actualSelector, '.scope input');
-    });
-
     page.foo('dummy text');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$('.scope input').val(), 'dummy text');
+    });
   });
 
   test("looks for elements inside page's scope", function(assert) {
@@ -98,15 +111,13 @@ moduleForProperty('fillable', function(test) {
       foo: fillable('input')
     });
 
-    this.adapter.fillIn((actualSelector) => {
-      assert.equal(actualSelector, '.scope input');
-    });
-
     this.adapter.createTemplate(this, page, '<div class="scope"><input></div>');
 
     page.foo('dummy text');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$('.scope input').val(), 'dummy text');
+    });
   });
 
   test('resets scope', function(assert) {
@@ -117,15 +128,13 @@ moduleForProperty('fillable', function(test) {
       foo: fillable('input', { resetScope: true })
     });
 
-    this.adapter.fillIn((actualSelector) => {
-      assert.equal(actualSelector, 'input');
-    });
-
     this.adapter.createTemplate(this, page, '<input>');
 
     page.foo('dummy text');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$('input').val(), 'dummy text');
+    });
   });
 
   test('returns target object', function(assert) {
@@ -135,8 +144,6 @@ moduleForProperty('fillable', function(test) {
       foo: fillable('input')
     });
 
-    this.adapter.fillIn(() => {});
-
     this.adapter.createTemplate(this, page, '<input>');
 
     assert.equal(page.foo(), page);
@@ -150,19 +157,17 @@ moduleForProperty('fillable', function(test) {
       foo: fillable('input', { at: 3 })
     });
 
-    this.adapter.fillIn((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
-
     this.adapter.createTemplate(this, page, '<input><input><input><input>');
 
-    page.foo();
+    page.foo('dummy text');
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$(expectedSelector).val(), 'dummy text');
+    });
   });
 
   test('is aliased to selectable', function(assert) {
-    assert.expect(2);
+    assert.expect(1);
 
     let expectedSelector = 'input';
     let expectedText = 'dummy text';
@@ -172,18 +177,15 @@ moduleForProperty('fillable', function(test) {
 
     this.adapter.createTemplate(this, page, '<input>');
 
-    this.adapter.fillIn((actualSelector, actualContext, options, actualContent) => {
-      assert.equal(actualSelector, expectedSelector);
-      assert.equal(actualContent, expectedText);
-    });
-
     page.foo(expectedText);
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$(expectedSelector).val(), expectedText);
+    });
   });
 
   test('looks for elements outside the testing container', function(assert) {
-    assert.expect(3);
+    assert.expect(1);
 
     let expectedContext = '#alternate-ember-testing';
     let expectedSelector = 'input';
@@ -194,19 +196,15 @@ moduleForProperty('fillable', function(test) {
 
     this.adapter.createTemplate(this, page, '<input>', { useAlternateContainer: true });
 
-    this.adapter.fillIn((actualSelector, actualContext, options, actualContent) => {
-      assert.equal(actualSelector, expectedSelector);
-      assert.equal(actualContext, expectedContext);
-      assert.equal(actualContent, expectedText);
-    });
-
     page.foo(expectedText);
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$(expectedSelector, expectedContext).val(), expectedText);
+    });
   });
 
   test('looks for elements within test container specified at node level', function(assert) {
-    assert.expect(3);
+    assert.expect(1);
 
     let expectedContext = '#alternate-ember-testing';
     let expectedSelector = 'input';
@@ -218,15 +216,11 @@ moduleForProperty('fillable', function(test) {
 
     this.adapter.createTemplate(this, page, '<input>', { useAlternateContainer: true });
 
-    this.adapter.fillIn((actualSelector, actualContext, options, actualContent) => {
-      assert.equal(actualSelector, expectedSelector);
-      assert.equal(actualContext, expectedContext);
-      assert.equal(actualContent, expectedText);
-    });
-
     page.foo(expectedText);
 
-    return this.adapter.wait();
+    return this.adapter.andThen(() => {
+      assert.equal(this.adapter.$(expectedSelector, expectedContext).val(), expectedText);
+    });
   });
 
   test("raises an error when the element doesn't exist", function(assert) {
diff --git a/tests/unit/-private/properties/triggerable-test.js b/tests/unit/-private/properties/triggerable-test.js
index b24ddddb..c131a692 100644
--- a/tests/unit/-private/properties/triggerable-test.js
+++ b/tests/unit/-private/properties/triggerable-test.js
@@ -3,37 +3,37 @@ import { create, triggerable } from 'ember-cli-page-object';
 
 moduleForProperty('triggerable', function(test) {
   test("calls Ember's triggerEvent helper with proper args", function(assert) {
-    assert.expect(2);
+    assert.expect(1);
 
-    let expectedSelector = 'span';
+    let expectedSelector = 'input';
     let page = create({
       foo: triggerable('focus', expectedSelector)
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
+    this.adapter.createTemplate(this, page, '<input />');
 
-    this.adapter.triggerEvent((actualSelector, _, event) => {
-      assert.equal(actualSelector, expectedSelector);
-      assert.equal(event, 'focus');
-    });
+    return this.adapter.andThen(() => {
+      // debugger
+      this.adapter.$(expectedSelector).on('focus', () => {
+        // debugger;
+        assert.ok(1);
+      });
+      page.foo();
 
-    page.foo();
-
-    return this.adapter.wait();
+      return this.adapter.wait();
+    });
   });
 
   test("calls Ember's triggerEvent helper with static event options", function(assert) {
     assert.expect(1);
 
     let page = create({
-      foo: triggerable('keypress', 'span', { eventProperties: { keyCode: 13 } })
+      foo: triggerable('keypress', 'input', { eventProperties: { keyCode: 13 } })
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
+    this.adapter.createTemplate(this, page, '<input />');
 
-    this.adapter.triggerEvent((actualSelector, _, event, options) => {
-      assert.equal(options.keyCode, 13);
-    });
+    this.adapter.$('input').on('keypress', (e) => assert.equal(e.keyCode, 13));
 
     page.foo();
 
@@ -44,14 +44,12 @@ moduleForProperty('triggerable', function(test) {
     assert.expect(1);
 
     let page = create({
-      foo: triggerable('keypress', 'span')
+      foo: triggerable('keypress', 'input')
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
+    this.adapter.createTemplate(this, page, '<input />');
 
-    this.adapter.triggerEvent((actualSelector, _, event, options) => {
-      assert.equal(options.keyCode, 13);
-    });
+    this.adapter.$('input').on('keypress', (e) => assert.equal(e.keyCode, 13));
 
     page.foo({ keyCode: 13 });
 
@@ -62,16 +60,14 @@ moduleForProperty('triggerable', function(test) {
     assert.expect(1);
 
     let page = create({
-      foo: triggerable('keypress', 'span', {
+      foo: triggerable('keypress', 'input', {
         eventProperties: { keyCode: 0 }
       })
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
+    this.adapter.createTemplate(this, page, '<input />');
 
-    this.adapter.triggerEvent((actualSelector, _, event, options) => {
-      assert.equal(options.keyCode, 13);
-    });
+    this.adapter.$('input').on('keypress', (e) => assert.equal(e.keyCode, 13));
 
     page.foo({ keyCode: 13 });
 
@@ -82,15 +78,12 @@ moduleForProperty('triggerable', function(test) {
     assert.expect(1);
 
     let page = create({
-      foo: triggerable('focus', 'span', { scope: '.scope' })
+      foo: triggerable('focus', 'input', { scope: '.scope' })
     });
 
-    this.adapter.createTemplate(this, page, '<div class="scope"><span></span></div>');
-
-    this.adapter.triggerEvent((actualSelector) => {
-      assert.equal(actualSelector, '.scope span');
-    });
+    this.adapter.createTemplate(this, page, '<div class="scope"><input/></div>');
 
+    this.adapter.$('.scope input').on('focus', () => assert.ok(1));
     page.foo();
 
     return this.adapter.wait();
@@ -102,13 +95,12 @@ moduleForProperty('triggerable', function(test) {
     let page = create({
       scope: '.scope',
 
-      foo: triggerable('focus', 'span')
+      foo: triggerable('focus', 'input')
     });
 
-    this.adapter.createTemplate(this, page, '<div class="scope"><span></span></div>');
-    this.adapter.triggerEvent((actualSelector) => {
-      assert.equal(actualSelector, '.scope span');
-    });
+    this.adapter.createTemplate(this, page, '<div class="scope"><input /></div>');
+
+    this.adapter.$('.scope input').on('focus', () => assert.ok(1));
 
     page.foo();
 
@@ -120,14 +112,12 @@ moduleForProperty('triggerable', function(test) {
 
     let page = create({
       scope: '.scope',
-      foo: triggerable('focus', 'span', { resetScope: true })
+      foo: triggerable('focus', 'input', { resetScope: true })
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
+    this.adapter.createTemplate(this, page, '<input></input>');
 
-    this.adapter.triggerEvent((actualSelector) => {
-      assert.equal(actualSelector, 'span');
-    });
+    this.adapter.$('input').on('focus', () => assert.ok(1));
 
     page.foo();
 
@@ -138,11 +128,10 @@ moduleForProperty('triggerable', function(test) {
     assert.expect(1);
 
     let page = create({
-      foo: triggerable('focus', 'span')
+      foo: triggerable('focus', 'input')
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>');
-    this.adapter.triggerEvent(() => {});
+    this.adapter.createTemplate(this, page, '<input/>');
 
     assert.equal(page.foo(), page);
   });
@@ -150,16 +139,14 @@ moduleForProperty('triggerable', function(test) {
   test('finds element by index', function(assert) {
     assert.expect(1);
 
-    let expectedSelector = 'span:eq(3)';
+    let expectedSelector = 'input:eq(3)';
     let page = create({
-      foo: triggerable('focus', 'span', { at: 3 })
+      foo: triggerable('focus', 'input', { at: 3 })
     });
 
-    this.adapter.createTemplate(this, page, '<span></span><span></span><span></span><span></span>');
-    this.adapter.triggerEvent((actualSelector) => {
-      assert.equal(actualSelector, expectedSelector);
-    });
+    this.adapter.createTemplate(this, page, '<input /><input /><input /><input />');
 
+    this.adapter.$(expectedSelector).on('focus', () => assert.ok(1));
     page.foo();
 
     return this.adapter.wait();
@@ -170,13 +157,12 @@ moduleForProperty('triggerable', function(test) {
 
     let expectedContext = '#alternate-ember-testing';
     let page = create({
-      foo: triggerable('focus', 'span', { testContainer: expectedContext })
+      foo: triggerable('focus', 'input', { testContainer: expectedContext })
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>', { useAlternateContainer: true });
-    this.adapter.triggerEvent((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
+    this.adapter.createTemplate(this, page, '<input />', { useAlternateContainer: true });
+
+    this.adapter.$('input', expectedContext).on('focus', () => assert.ok(1));
 
     page.foo();
 
@@ -189,13 +175,12 @@ moduleForProperty('triggerable', function(test) {
     let expectedContext = '#alternate-ember-testing';
     let page = create({
       testContainer: expectedContext,
-      foo: triggerable('focus', 'span')
+      foo: triggerable('focus', 'input')
     });
 
-    this.adapter.createTemplate(this, page, '<span></span>', { useAlternateContainer: true });
-    this.adapter.triggerEvent((_, actualContext) => {
-      assert.equal(actualContext, expectedContext);
-    });
+    this.adapter.createTemplate(this, page, '<input />', { useAlternateContainer: true });
+
+    this.adapter.$('input', expectedContext).on('focus', () => assert.ok(1));
 
     page.foo();