Refactor custom element tests

tests/html/custom_elements_test.dart

Index: tests/html/custom_elements_test.dart
diff --git a/tests/html/custom_elements_test.dart b/tests/html/custom_elements_test.dart
index 7e179121ff8d7cdd6593ff243c5115ba47574524..8d9d0f224baab8c5a1fd9188869ce91089e36ffb 100644
--- a/tests/html/custom_elements_test.dart
+++ b/tests/html/custom_elements_test.dart
@@ -4,7 +4,7 @@
 
 library blob_test;
 import '../../pkg/unittest/lib/unittest.dart';
-import '../../pkg/unittest/lib/html_config.dart';
+import '../../pkg/unittest/lib/html_individual_config.dart';
 import 'dart:html';
 
 class CustomType extends Element {
@@ -17,77 +17,119 @@ class CustomType extends Element {
 class NotAnElement {}
 
 main() {
-  useHtmlConfiguration();
+  useHtmlIndividualConfiguration();
 
-  test('register', () {
-    document.register('x-type1', CustomType);
+  group('basic', () {

[vsm, 2013/07/29 21:00:02]

These tests are fixed by the accompanying blink CL.

+    test('create via custom tag', () {
+      var element = new Element.tag('x-basic1')..id = 'basic1';
+      document.body.nodes.add(element);
 
-    var element = new Element.tag('x-type1');
-    expect(element, isNotNull);
-    expect(element is CustomType, isTrue);
-    expect(element.onCreatedCalled, isTrue);
-  });
+      var queryById = query('#basic1');
+      expect(queryById, equals(element));
 
-  test('register twice', () {
-    document.register('x-type2', CustomType);
-    expect(() {
-      document.register('x-type2', CustomType);
-    }, throws, reason: 'Cannot register a tag more than once.');
+      var queryByTag = queryAll('x-basic1');
+      expect(queryByTag.length, equals(1));
+      expect(queryByTag[0], equals(element));
+    });
 
-    document.register('x-type3', CustomType);
+    test('custom inner html', () {
+      var element = new DivElement();
+      element.innerHtml = "<x-basic2 id='basic2'></x-basic2>";
+      document.body.nodes.add(element);
 
-    var element = new Element.tag('x-type3');
-    expect(element, isNotNull);
-    expect(element is CustomType, isTrue);
-  });
+      var queryById = query('#basic2');
+      expect(queryById is Element, isTrue);

[blois, 2013/07/29 21:04:54]

Is this an UnknownElement at this point? If so, should we validate that?

[vsm, 2013/07/29 21:43:35]

On Dartium it specifically is not an UnknownElement.  The concrete type should
be HTMLElement.  

But I'm not sure we can enforce that on other browsers.

On 2013/07/29 21:04:54, blois wrote:

 
-  test('register null', () {
-    expect(() {
-      document.register('x-type4', null);
-    }, throws, reason: 'Cannot register a null type.');
-  });
+      var queryByTag = queryAll('x-basic2');
+      expect(queryByTag.length, equals(1));
+      expect(queryByTag[0], equals(queryById));
 
-  test('register native', () {
-    expect(() {
-      document.register('x-type5', BodyElement);
-    }, throws, reason: 'Cannot register a native element.');
-  });
+    });
+
+    test('type extension inner html', () {
+      var element = new DivElement();
+      element.innerHtml = "<div is='x-basic3' id='basic3'></div>";
+      document.body.nodes.add(element);
 
-  test('register non-element', () {
-    expect(() {
-      document.register('x-type6', NotAnElement);
-    }, throws, reason: 'Cannot register a non-element.');
+      var queryById = query('#basic3');
+      expect(queryById is DivElement, isTrue);
+    });
   });
 
-  test('pre-registration construction', () {
-    var dom = new Element.html('<div><x-type7></x-type7></div>');
-    var preElement = dom.children[0];
-    expect(preElement, isNotNull);
-    expect(preElement is UnknownElement, isTrue);
-    var firedOnPre = false;
-    preElement.onFocus.listen((_) {
-      firedOnPre = true;
+  group('register', () {

[vsm, 2013/07/29 21:00:02]

We'll get these tests to pass in the near term, but they are marked fail for
now.

+    test('register', () {
+      document.register('x-type1', CustomType);
+
+      var element = new Element.tag('x-type1');
+      expect(element, isNotNull);
+      expect(element is CustomType, isTrue);
+      expect(element.onCreatedCalled, isTrue);
     });
 
-    document.register('x-type7', CustomType);
+    test('register twice', () {
+      document.register('x-type2', CustomType);
+      expect(() {
+        document.register('x-type2', CustomType);
+      }, throws, reason: 'Cannot register a tag more than once.');
+
+      document.register('x-type3', CustomType);
 
-    var postElement = dom.children[0];
-    expect(postElement, isNotNull);
-    expect(postElement is CustomType, isTrue);
-    expect(postElement.onCreatedCalled, isTrue);
+      var element = new Element.tag('x-type3');
+      expect(element, isNotNull);
+      expect(element is CustomType, isTrue);
+    });
+
+    test('register null', () {
+      expect(() {
+        document.register('x-type4', null);
+      }, throws, reason: 'Cannot register a null type.');
+    });
 
-    // Element from first query remains an UnknownElement.
-    expect(preElement is UnknownElement, isTrue);
-    expect(preElement.parent, isNull);
-    expect(dom.children.length, 1);
+    test('register native', () {
+      expect(() {
+        document.register('x-type5', BodyElement);
+      }, throws, reason: 'Cannot register a native element.');
+    });
+
+    test('register non-element', () {
+      expect(() {
+        document.register('x-type6', NotAnElement);
+      }, throws, reason: 'Cannot register a non-element.');
+    });
+  });
 
-    var firedOnPost = false;
-    postElement.onFocus.listen((_) {
-      firedOnPost = true;
+  group('preregister', () {

[vsm, 2013/07/29 21:00:02]

We still need to nail down the semantics here.

+    // TODO(vsm): Modify this test once we agree on the proper semantics.
+    test('pre-registration construction', () {
+      var dom = new Element.html('<div><x-type7></x-type7></div>');
+      var preElement = dom.children[0];
+      expect(preElement, isNotNull);
+      expect(preElement is UnknownElement, isTrue);
+      var firedOnPre = false;
+      preElement.onFocus.listen((_) {
+        firedOnPre = true;
+      });
+
+      document.register('x-type7', CustomType);
+
+      var postElement = dom.children[0];
+      expect(postElement, isNotNull);
+      expect(postElement is CustomType, isTrue);
+      expect(postElement.onCreatedCalled, isTrue);
+
+      // Element from first query remains an UnknownElement.
+      expect(preElement is UnknownElement, isTrue);
+      expect(preElement.parent, isNull);
+      expect(dom.children.length, 1);
+
+      var firedOnPost = false;
+      postElement.onFocus.listen((_) {
+        firedOnPost = true;
+      });
+      // Event handlers should not persist to new element.
+      postElement.dispatchEvent(new Event('focus'));
+      expect(firedOnPre, isFalse);
+      expect(firedOnPost, isTrue);
     });
-    // Event handlers should not persist to new element.
-    postElement.dispatchEvent(new Event('focus'));
-    expect(firedOnPre, isFalse);
-    expect(firedOnPost, isTrue);
   });
 }