fixup 2

- Unify the clean-up paths for tests with/without jQuery, using `angular.element.cleanData()`.
- Remove redundant calls to `.off().removeData()`.
- Fix bug in `testabilityPatch.js`, where `cleanData()` was called with an array of jqLite/jQuery
  elements (instead of "raw" nodes).

Author: gkalpak

src/ngMock/angular-mocks.js

@@ -2602,16 +2602,10 @@ if (window.jasmine || window.mocha) {
     currentSpec = null;
 
     if (injector) {
-      var cleanUpElems = [originalRootElement];
-      var $rootElement = injector.get('$rootElement');
-      if ($rootElement !== originalRootElement) cleanUpElems.push($rootElement);
-      cleanUpElems.forEach(function(elem) {
-        // The `$rootElement` might not have been created or
-        // a mocked `$rootElement` might not have the standard methods
-        if (elem && elem.off) elem.off();
-        if (elem && elem.removeData) elem.removeData();
-      });
-      if (window.jQuery) window.jQuery.cleanData(cleanUpElems);
+      var cleanUpElems = [originalRootElement[0]];
+      var rootNode = injector.get('$rootElement')[0];
+      if (rootNode && (rootNode !== originalRootElement[0])) cleanUpElems.push(rootNode);
+      angular.element.cleanData(cleanUpElems);
 
       injector.get('$rootScope').$destroy();
     }

test/helpers/testabilityPatch.js

@@ -139,12 +139,8 @@ function dealoc(obj) {
   }
 
   function cleanup(element) {
-    element.off().removeData();
-    if (window.jQuery) {
-      // jQuery 2.x doesn't expose the cache storage; ensure all element data
-      // is removed during its cleanup.
-      jQuery.cleanData([element]);
-    }
+    angular.element.cleanData(element);
+
     // Note:  We aren't using element.contents() here.  Under jQuery, element.contents() can fail
     // for IFRAME elements.  jQuery explicitly uses (element.contentDocument ||
     // element.contentWindow.document) and both properties are null for IFRAMES that aren't attached

test/ngMock/angular-mocksSpec.js

@@ -2419,23 +2419,19 @@ describe('make sure that we can create an injector outside of tests', function()
 
 describe('`afterEach` clean-up', function() {
   describe('undecorated `$rootElement`', function() {
-    var jQuery = window.jQuery;
     var prevRootElement;
-    var prevRemoveDataSpy;
     var prevCleanDataSpy;
 
 
     it('should set up spies so the next test can verify `$rootElement` was cleaned up', function() {
       module(function($provide) {
         $provide.decorator('$rootElement', function($delegate) {
-          // Spy on `$rootElement.removeData()` and `jQuery.cleanData()`,
-          // so the next test can verify that they have been called as necessary
           prevRootElement = $delegate;
-          prevRemoveDataSpy = spyOn($delegate, 'removeData').andCallThrough();
 
-          if (jQuery) {
-            prevCleanDataSpy = spyOn(jQuery, 'cleanData').andCallThrough();
-          }
+          // Spy on `angular.element.cleanData()`, so the next test can verify
+          // that it has been called as necessary
+          prevCleanDataSpy = spyOn(angular.element, 'cleanData').andCallThrough();
+          // prevCleanDataSpy = mockCleanData([prevRootElement[0]]);
 
           return $delegate;
         });
@@ -2451,51 +2447,35 @@ describe('`afterEach` clean-up', function() {
     it('should clean up `$rootElement` after each test', function() {
       // One call is made by `testabilityPatch`'s `dealoc()`
       // We want to verify the subsequent call, made by `angular-mocks`
-      // (Since `testabilityPatch` re-wrapps `$rootElement` and because jQuery returns a different
-      //  object when re-wrapping, we don't capture the 1st call when using jQuery)
-      expect(prevRemoveDataSpy.callCount).toBe(jQuery ? 1 : 2);
-
-      if (jQuery) {
-        // One call is made by `testabilityPatch`'s `dealoc()`
-        // We want to verify the subsequent call, made by `angular-mocks`
-        expect(prevCleanDataSpy.callCount).toBe(2);
-
-        var cleanUpElems = prevCleanDataSpy.calls[1].args[0];
-        expect(cleanUpElems.length).toBe(1);
-        expect(cleanUpElems[0][0]).toBe(prevRootElement[0]);
-      }
+      expect(prevCleanDataSpy.callCount).toBe(2);
+
+      var cleanUpElems = prevCleanDataSpy.calls[1].args[0];
+      expect(cleanUpElems.length).toBe(1);
+      expect(cleanUpElems[0]).toBe(prevRootElement[0]);
     });
   });
 
 
   describe('decorated `$rootElement`', function() {
-    var jQuery = window.jQuery;
     var prevOriginalRootElement;
-    var prevOriginalRemoveDataSpy;
     var prevRootElement;
-    var prevRemoveDataSpy;
     var prevCleanDataSpy;
 
 
     it('should set up spies so the next text can verify `$rootElement` was cleaned up', function() {
       module(function($provide) {
         $provide.decorator('$rootElement', function($delegate) {
-          // Mock `$rootElement` to be able to verify that the correct object is cleaned up
-          var mockRootElement = angular.element('<div></div>');
-
-          // Spy on `$rootElement.removeData()` and `jQuery.cleanData()`,
-          // so the next test can verify that they have been called as necessary
           prevOriginalRootElement = $delegate;
-          prevOriginalRemoveDataSpy = spyOn($delegate, 'removeData').andCallThrough();
 
-          prevRootElement = mockRootElement;
-          prevRemoveDataSpy = spyOn(mockRootElement, 'removeData').andCallThrough();
+          // Mock `$rootElement` to be able to verify that the correct object is cleaned up
+          prevRootElement = angular.element('<div></div>');
 
-          if (jQuery) {
-            prevCleanDataSpy = spyOn(jQuery, 'cleanData').andCallThrough();
-          }
+          // Spy on `angular.element.cleanData()`, so the next test can verify
+          // that it has been called as necessary
+          prevCleanDataSpy = spyOn(angular.element, 'cleanData').andCallThrough();
+          // prevCleanDataSpy = mockCleanData([prevRootElement[0], prevOriginalRootElement[0]]);
 
-          return mockRootElement;
+          return prevRootElement;
         });
       });
 
@@ -2511,33 +2491,43 @@ describe('`afterEach` clean-up', function() {
         // This is a false alarm, because `angular-mocks` would have cleaned up in a subsequent
         // `afterEach` block
         prevOriginalRootElement.removeData();
-        prevOriginalRemoveDataSpy.reset();
-
-        expect(prevOriginalRemoveDataSpy.callCount).toBe(0);
       });
     });
 
 
     it('should clean up `$rootElement` (both original and decorated) after each test', function() {
-      // Only `angular-mocks` cleans up after the original `$rootElement`, not `testabilityPatch`
-      expect(prevOriginalRemoveDataSpy.callCount).toBe(1);
-
       // One call is made by `testabilityPatch`'s `dealoc()`
       // We want to verify the subsequent call, made by `angular-mocks`
-      // (Since `testabilityPatch` re-wrapps `$rootElement` and because jQuery returns a different
-      //  object when re-wrapping, we don't capture the 1st call when using jQuery)
-      expect(prevRemoveDataSpy.callCount).toBe(jQuery ? 1 : 2);
-
-      if (jQuery) {
-        // One call is made by `testabilityPatch`'s `dealoc()`
-        // We want to verify the subsequent call, made by `angular-mocks`
-        expect(prevCleanDataSpy.callCount).toBe(2);
-
-        var cleanUpElems = prevCleanDataSpy.calls[1].args[0];
-        expect(cleanUpElems.length).toBe(2);
-        expect(cleanUpElems[0][0]).toBe(prevOriginalRootElement[0]);
-        expect(cleanUpElems[1][0]).toBe(prevRootElement[0]);
-      }
+      expect(prevCleanDataSpy.callCount).toBe(2);
+
+      var cleanUpElems = prevCleanDataSpy.calls[1].args[0];
+      expect(cleanUpElems.length).toBe(2);
+      expect(cleanUpElems[0]).toBe(prevOriginalRootElement[0]);
+      expect(cleanUpElems[1]).toBe(prevRootElement[0]);
     });
   });
+
+
+  // Helpers
+  function mockCleanData(expectedNodes) {
+    var callIdx = -1;
+
+    var cleanData_ = angular.element.cleanData;
+    var cleanDataSpy = spyOn(angular.element, 'cleanData').andCallFake(function(cleanUpElems) {
+      var expectedNode = expectedNodes[++callIdx % expectedNodes.length];
+      var actualNode = cleanUpElems[0];
+      if (actualNode !== expectedNode) {
+        throw new Error('Unexpected node for clean-up: ' + actualNode.outerHTML);
+      }
+
+      cleanData_.apply(angular.element, arguments);
+
+      var data = angular.element(actualNode).data();
+      if (Object.keys(data).length) {
+        throw new Error('Data clean-up failed on: ' + actualNode.outerHTML);
+      }
+    });
+
+    return cleanDataSpy;
+  }
 });