fixup 1

- Group into a `describe` block
- Tweak test descriptions
- Fix typos

Author: gkalpak

test/helpers/testabilityPatch.js

@@ -139,11 +139,15 @@ function dealoc(obj) {
   }
 
   function cleanup(element) {
-    element.off().removeData();
+    // element.off().removeData();
     if (window.jQuery) {
       // jQuery 2.x doesn't expose the cache storage; ensure all element data
       // is removed during its cleanup.
+      console.log(1, element.data());
       jQuery.cleanData([element]);
+      console.log(2, element.data());
+      jQuery.cleanData(element);
+      console.log(3, element.data());
     }
     // Note:  We aren't using element.contents() here.  Under jQuery, element.contents() can fail
     // for IFRAME elements.  jQuery explicitly uses (element.contentDocument ||

test/ngMock/angular-mocksSpec.js

@@ -2417,17 +2417,19 @@ describe('make sure that we can create an injector outside of tests', function()
 });
 
 
-describe('don\'t leak memory between tests', function() {
-  var jQuery = window.jQuery;
-  var prevRootElement;
-  var prevRemoveDataSpy;
-  var prevCleanDataSpy;
-
-  it('should run a test to keep track of `removeData()`/`cleanData()` calls for later inspection',
-    function() {
+describe('`afterEach` clean-up', function() {
+  describe('undecorated `$rootElement`', function() {
+    console.log(jqLite === window.jQuery, window.jQuery, jqLite);
+    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 `.removeData()` and `jQuery.cleanData()`,
+          // 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();
@@ -2444,44 +2446,45 @@ describe('don\'t leak memory between tests', function() {
       inject(function($rootElement) {
         expect($rootElement.injector()).toBeDefined();
       });
-    }
-  );
+    });
 
-  it('should clean up `$rootElement`-related data 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, we don't capture the 1st call when using jQuery)
-    expect(prevRemoveDataSpy.callCount).toBe(jQuery ? 1 : 2);
 
-    if (jQuery) {
+    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`
-      expect(prevCleanDataSpy.callCount).toBe(2);
+      // (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);
 
-      var cleanUpElems = prevCleanDataSpy.calls[1].args[0];
-      expect(cleanUpElems.length).toBe(1);
-      expect(cleanUpElems[0][0]).toBe(prevRootElement[0]);
-    }
+      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]);
+      }
+    });
   });
-});
 
-describe('don\'t leak memory between tests with mocked `$rootScope`', function() {
-  var jQuery = window.jQuery;
-  var prevOriginalRootElement;
-  var prevOriginalRemoveDataSpy;
-  var prevRootElement;
-  var prevRemoveDataSpy;
-  var prevCleanDataSpy;
 
-  it('should run a test to keep track of `removeData()`/`cleanData()` calls for later inspection',
-    function() {
+  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 `.removeData()` and `jQuery.cleanData()`,
+          // 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();
@@ -2505,25 +2508,25 @@ describe('don\'t leak memory between tests with mocked `$rootScope`', function()
 
         // If we don't clean up `prevOriginalRootElement`-related data now, `testabilityPatch` will
         // complain about a memory leak, because it doesn't clean up after the original
-        // `$rootElement`.
-        // This is a false alarm, because `angular-mocks` will clean up later.
+        // `$rootElement`
+        // 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 after the `$rootElement` (both original and decorated) after each test',
-    function() {
+    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, we don't capture the 1st call when using jQuery)
+      // (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) {
@@ -2536,6 +2539,6 @@ describe('don\'t leak memory between tests with mocked `$rootScope`', function()
         expect(cleanUpElems[0][0]).toBe(prevOriginalRootElement[0]);
         expect(cleanUpElems[1][0]).toBe(prevRootElement[0]);
       }
-    }
-  );
+    });
+  });
 });