'use strict';

describe('animations', function() {

beforeEach(module('ngAnimate'));

beforeEach(module('ngAnimateMock'));

var element, applyAnimationClasses;

beforeEach(module(function() {

return function($$jqLite) {

applyAnimationClasses = applyAnimationClassesFactory($$jqLite);

};

}));

afterEach(inject(function() {

dealoc(element);

}));

it('should allow animations if the application is bootstrapped on the document node', function() {

var capturedAnimation;

module(function($provide) {

$provide.factory('$rootElement', function($document) {

return $document;

});

$provide.factory('$$animation', function($$AnimateRunner) {

return function() {

capturedAnimation = arguments;

return new $$AnimateRunner();

};

});

});

inject(function($animate, $rootScope, $document) {

$animate.enabled(true);

element = jqLite('<div></div>');

$animate.enter(element, jqLite($document[0].body));

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

});

});

describe('during bootstrap', function() {

it('should be enabled only after the first digest is fired and the postDigest queue is empty',

inject(function($animate, $rootScope) {

var capturedEnabledState;

$rootScope.$$postDigest(function() {

capturedEnabledState = $animate.enabled();

});

expect($animate.enabled()).toBe(false);

$rootScope.$digest();

expect(capturedEnabledState).toBe(false);

expect($animate.enabled()).toBe(true);

}));

it('should be disabled until all pending template requests have been downloaded', function() {

var mockTemplateRequest = {

totalPendingRequests: 2

};

module(function($provide) {

$provide.value('$templateRequest', mockTemplateRequest);

});

inject(function($animate, $rootScope) {

expect($animate.enabled()).toBe(false);

$rootScope.$digest();

expect($animate.enabled()).toBe(false);

mockTemplateRequest.totalPendingRequests = 0;

$rootScope.$digest();

expect($animate.enabled()).toBe(true);

});

});

it('should stay disabled if set to be disabled even after all templates have been fully downloaded', function() {

var mockTemplateRequest = {

totalPendingRequests: 2

};

module(function($provide) {

$provide.value('$templateRequest', mockTemplateRequest);

});

inject(function($animate, $rootScope) {

$animate.enabled(false);

expect($animate.enabled()).toBe(false);

$rootScope.$digest();

expect($animate.enabled()).toBe(false);

mockTemplateRequest.totalPendingRequests = 0;

$rootScope.$digest();

expect($animate.enabled()).toBe(false);

});

});

});

describe('$animate', function() {

var parent;

var parent2;

var options;

var capturedAnimation;

var capturedAnimationHistory;

var overriddenAnimationRunner;

var defaultFakeAnimationRunner;

beforeEach(module(function($provide) {

overriddenAnimationRunner = null;

capturedAnimation = null;

capturedAnimationHistory = [];

options = {};

$provide.value('$$animation', function() {

capturedAnimationHistory.push(capturedAnimation = arguments);

return overriddenAnimationRunner || defaultFakeAnimationRunner;

});

return function($rootElement, $q, $animate, $$AnimateRunner, $document) {

defaultFakeAnimationRunner = new $$AnimateRunner();

$animate.enabled(true);

element = jqLite('<div class="element">element</div>');

parent = jqLite('<div class="parent1">parent</div>');

parent2 = jqLite('<div class="parent2">parent</div>');

$rootElement.append(parent);

$rootElement.append(parent2);

jqLite($document[0].body).append($rootElement);

};

}));

it('should not alter the provided options input in any way throughout the animation', inject(function($animate, $rootScope) {

var initialOptions = {

from: { height: '50px' },

to: { width: '50px' },

addClass: 'one',

removeClass: 'two',

domOperation: undefined

};

var copiedOptions = copy(initialOptions);

expect(copiedOptions).toEqual(initialOptions);

var runner = $animate.enter(element, parent, null, copiedOptions);

expect(copiedOptions).toEqual(initialOptions);

$rootScope.$digest();

expect(copiedOptions).toEqual(initialOptions);

}));

it('should skip animations entirely if the document is hidden', function() {

var hidden = true;

module(function($provide) {

$provide.value('$$isDocumentHidden', function() {

return hidden;

});

});

inject(function($animate, $rootScope) {

$animate.enter(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(element[0].parentNode).toEqual(parent[0]);

hidden = false;

$animate.leave(element);

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

});

});

it('should animate only the specified CSS className matched within $animateProvider.classNameFilter for div', function() {

module(function($animateProvider) {

$animateProvider.classNameFilter(/only-allow-this-animation/);

});

inject(function($animate, $rootScope) {

expect(element).not.toHaveClass('only-allow-this-animation');

$animate.enter(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

element.addClass('only-allow-this-animation');

$animate.leave(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

});

});

it('should animate only the specified CSS className matched within $animateProvider.classNameFilter for svg', function() {

module(function($animateProvider) {

$animateProvider.classNameFilter(/only-allow-this-animation-svg/);

});

inject(function($animate, $rootScope, $compile) {

var svgElement = $compile('<svg class="element"></svg>')($rootScope);

expect(svgElement).not.toHaveClass('only-allow-this-animation-svg');

$animate.enter(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

svgElement.attr('class', 'element only-allow-this-animation-svg');

$animate.leave(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

});

});

they('should not apply the provided options.$prop value unless it\'s a string or string-based array', ['addClass', 'removeClass'], function(prop) {

inject(function($animate, $rootScope) {

var startingCssClasses = element.attr('class') || '';

var options1 = {};

options1[prop] = function() {};

$animate.enter(element, parent, null, options1);

expect(element.attr('class')).toEqual(startingCssClasses);

$rootScope.$digest();

var options2 = {};

options2[prop] = true;

$animate.leave(element, options2);

expect(element.attr('class')).toEqual(startingCssClasses);

$rootScope.$digest();

capturedAnimation = null;

var options3 = {};

if (prop === 'removeClass') {

element.addClass('fatias');

startingCssClasses = element.attr('class');

}

options3[prop] = ['fatias'];

$animate.enter(element, parent, null, options3);

$rootScope.$digest();

expect(element.attr('class')).not.toEqual(startingCssClasses);

});

});

it('should throw a minErr if a regex value is used which partially contains or fully matches the `ng-animate` CSS class',

module(function($animateProvider) {

expect(setFilter(/ng-animate/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/first ng-animate last/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/first ng-animate ng-animate-special last/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/(ng-animate)/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/(foo|ng-animate|bar)/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/(foo|)ng-animate(|bar)/)).toThrowMinErr('$animate', 'nongcls');

expect(setFilter(/ng-animater/)).not.toThrow();

expect(setFilter(/my-ng-animate/)).not.toThrow();

expect(setFilter(/first ng-animater last/)).not.toThrow();

expect(setFilter(/first my-ng-animate last/)).not.toThrow();

function setFilter(regex) {

return function() {

$animateProvider.classNameFilter(regex);

};

}

})

);

it('should clear the `classNameFilter` if a disallowed RegExp is passed',

module(function($animateProvider) {

var validRegex = /no-ng-animate/;

var invalidRegex = /no ng-animate/;

$animateProvider.classNameFilter(validRegex);

expect($animateProvider.classNameFilter()).toEqual(validRegex);

// eslint-disable-next-line no-empty

try { $animateProvider.classNameFilter(invalidRegex); } catch (err) {}

expect($animateProvider.classNameFilter()).toBeNull();

})

);

it('should complete the leave DOM operation in case the classNameFilter fails', function() {

module(function($animateProvider) {

$animateProvider.classNameFilter(/memorable-animation/);

});

inject(function($animate, $rootScope) {

expect(element).not.toHaveClass('memorable-animation');

parent.append(element);

$animate.leave(element);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(element[0].parentNode).toBeFalsy();

});

});

it('should not try to match the `classNameFilter` RegExp if animations are globally disabled',

function() {

var regex = /foo/;

var regexTestSpy = spyOn(regex, 'test').and.callThrough();

module(function($animateProvider) {

$animateProvider.classNameFilter(regex);

});

inject(function($animate) {

$animate.addClass(element, 'foo');

expect(regexTestSpy).toHaveBeenCalled();

regexTestSpy.calls.reset();

$animate.enabled(false);

$animate.addClass(element, 'bar');

expect(regexTestSpy).not.toHaveBeenCalled();

regexTestSpy.calls.reset();

$animate.enabled(true);

$animate.addClass(element, 'baz');

expect(regexTestSpy).toHaveBeenCalled();

});

}

);

describe('customFilter()', function() {

it('should be `null` by default', module(function($animateProvider) {

expect($animateProvider.customFilter()).toBeNull();

}));

it('should clear the `customFilter` if no function is passed',

module(function($animateProvider) {

$animateProvider.customFilter(angular.noop);

expect($animateProvider.customFilter()).toEqual(jasmine.any(Function));

$animateProvider.customFilter(null);

expect($animateProvider.customFilter()).toBeNull();

$animateProvider.customFilter(angular.noop);

expect($animateProvider.customFilter()).toEqual(jasmine.any(Function));

$animateProvider.customFilter({});

expect($animateProvider.customFilter()).toBeNull();

})

);

it('should only perform animations for which the function returns a truthy value',

function() {

var animationsAllowed = false;

module(function($animateProvider) {

$animateProvider.customFilter(function() { return animationsAllowed; });

});

inject(function($animate, $rootScope) {

$animate.enter(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.leave(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

animationsAllowed = true;

$animate.enter(element, parent);

$rootScope.$digest();

expect(capturedAnimation).not.toBeNull();

capturedAnimation = null;

$animate.leave(element, parent);

$rootScope.$digest();

expect(capturedAnimation).not.toBeNull();

});

}

);

it('should only perform animations for which the function returns a truthy value (SVG)',

function() {

var animationsAllowed = false;

module(function($animateProvider) {

$animateProvider.customFilter(function() { return animationsAllowed; });

});

inject(function($animate, $compile, $rootScope) {

var svgElement = $compile('<svg class="element"></svg>')($rootScope);

$animate.enter(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.leave(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

animationsAllowed = true;

$animate.enter(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).not.toBeNull();

capturedAnimation = null;

$animate.leave(svgElement, parent);

$rootScope.$digest();

expect(capturedAnimation).not.toBeNull();

});

}

);

it('should pass the DOM element, event name and options to the filter function', function() {

var filterFn = jasmine.createSpy('filterFn');

var options = {};

module(function($animateProvider) {

$animateProvider.customFilter(filterFn);

});

inject(function($animate, $rootScope) {

$animate.enter(element, parent, null, options);

expect(filterFn).toHaveBeenCalledOnceWith(element[0], 'enter', options);

filterFn.calls.reset();

$animate.leave(element);

expect(filterFn).toHaveBeenCalledOnceWith(element[0], 'leave', jasmine.any(Object));

});

});

it('should complete the DOM operation even if filtered out', function() {

module(function($animateProvider) {

$animateProvider.customFilter(function() { return false; });

});

inject(function($animate, $rootScope) {

expect(element.parent()[0]).toBeUndefined();

$animate.enter(element, parent);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(element.parent()[0]).toBe(parent[0]);

$animate.leave(element);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(element.parent()[0]).toBeUndefined();

});

});

it('should not execute the function if animations are globally disabled', function() {

var customFilterSpy = jasmine.createSpy('customFilterFn');

module(function($animateProvider) {

$animateProvider.customFilter(customFilterSpy);

});

inject(function($animate) {

$animate.addClass(element, 'foo');

expect(customFilterSpy).toHaveBeenCalled();

customFilterSpy.calls.reset();

$animate.enabled(false);

$animate.addClass(element, 'bar');

expect(customFilterSpy).not.toHaveBeenCalled();

customFilterSpy.calls.reset();

$animate.enabled(true);

$animate.addClass(element, 'baz');

expect(customFilterSpy).toHaveBeenCalled();

});

});

});

describe('enabled()', function() {

it('should work for all animations', inject(function($animate) {

expect($animate.enabled()).toBe(true);

expect($animate.enabled(0)).toBe(false);

expect($animate.enabled()).toBe(false);

expect($animate.enabled(1)).toBe(true);

expect($animate.enabled()).toBe(true);

}));

it('should fully disable all animations in the application if false',

inject(function($animate, $rootScope) {

$animate.enabled(false);

$animate.enter(element, parent);

expect(capturedAnimation).toBeNull();

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

}));

it('should disable all animations on the given element',

inject(function($animate, $rootScope) {

parent.append(element);

$animate.enabled(element, false);

expect($animate.enabled(element)).toBeFalsy();

$animate.addClass(element, 'red');

expect(capturedAnimation).toBeNull();

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.enabled(element, true);

expect($animate.enabled(element)).toBeTruthy();

$animate.addClass(element, 'blue');

expect(capturedAnimation).toBeNull();

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

}));

it('should disable all animations for a given element\'s children',

inject(function($animate, $rootScope) {

$animate.enabled(parent, false);

$animate.enter(element, parent);

expect(capturedAnimation).toBeNull();

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.enabled(parent, true);

$animate.enter(element, parent);

expect(capturedAnimation).toBeNull();

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

}));

it('should run animations on an element and its children if explicitly enabled, even if animations are disabled on the parent',

inject(function($animate, $rootScope) {

var child = jqLite('<div></div>');

element.append(child);

parent.append(element);

$animate.enabled(parent, false);

$animate.addClass(element, 'red');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.addClass(child, 'red');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

$animate.enabled(element, true);

$animate.addClass(element, 'blue');

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

capturedAnimation = null;

$animate.addClass(child, 'blue');

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

}));

});

it('should strip all comment nodes from the animation and not issue an animation if not real elements are found',

inject(function($rootScope, $compile) {

// since the ng-if results to false then only comments will be fed into the animation

element = $compile(

'<div><div class="animated" ng-if="false" ng-repeat="item in items"></div></div>'

)($rootScope);

parent.append(element);

$rootScope.items = [1,2,3,4,5];

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

}));

it('should not attempt to perform an animation on a text node element',

inject(function($rootScope, $animate) {

element.html('hello there');

var textNode = jqLite(element[0].firstChild);

$animate.addClass(textNode, 'some-class');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

}));

it('should not attempt to perform an animation on an empty jqLite collection',

inject(function($rootScope, $animate) {

element.html('');

var emptyNode = jqLite(element[0].firstChild);

$animate.addClass(emptyNode, 'some-class');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

})

);

it('should perform the leave domOperation if a text node is used',

inject(function($rootScope, $animate) {

element.html('hello there');

var textNode = jqLite(element[0].firstChild);

var parentNode = textNode[0].parentNode;

$animate.leave(textNode);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(textNode[0].parentNode).not.toBe(parentNode);

}));

it('should perform the leave domOperation if a comment node is used',

inject(function($rootScope, $animate, $document) {

var doc = $document[0];

element.html('hello there');

var commentNode = jqLite(doc.createComment('test comment'));

var parentNode = element[0];

parentNode.appendChild(commentNode[0]);

$animate.leave(commentNode);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

expect(commentNode[0].parentNode).not.toBe(parentNode);

}));

it('enter() should animate a transcluded clone with `templateUrl`', function() {

module(function($compileProvider) {

$compileProvider.directive('foo', function() {

return {templateUrl: 'foo.html'};

});

});

inject(function($animate, $compile, $rootScope, $templateCache) {

parent.append(jqLite('<foo ng-if="showFoo"></foo>'));

$templateCache.put('foo.html', '<div>FOO</div>');

$compile(parent)($rootScope);

expect(capturedAnimation).toBeNull();

$rootScope.$apply('showFoo = true');

expect(parent.text()).toBe('parentFOO');

expect(capturedAnimation[0].html()).toBe('<div>FOO</div>');

expect(capturedAnimation[1]).toBe('enter');

});

});

it('enter() should issue an enter animation and fire the DOM operation right away before the animation kicks off', inject(function($animate, $rootScope) {

expect(parent.children().length).toBe(0);

options.foo = 'bar';

$animate.enter(element, parent, null, options);

expect(parent.children().length).toBe(1);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('enter');

expect(capturedAnimation[2].foo).toEqual(options.foo);

}));

it('move() should issue an enter animation and fire the DOM operation right away before the animation kicks off', inject(function($animate, $rootScope) {

parent.append(element);

expect(parent.children().length).toBe(1);

expect(parent2.children().length).toBe(0);

options.foo = 'bar';

$animate.move(element, parent2, null, options);

expect(parent.children().length).toBe(0);

expect(parent2.children().length).toBe(1);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('move');

expect(capturedAnimation[2].foo).toEqual(options.foo);

}));

they('$prop() should insert the element adjacent to the after element if provided',

['enter', 'move'], function(event) {

inject(function($animate, $rootScope) {

parent.append(element);

assertCompareNodes(parent2.next(), element, true);

$animate[event](element, null, parent2, options);

assertCompareNodes(parent2.next(), element);

$rootScope.$digest();

expect(capturedAnimation[1]).toBe(event);

});

});

they('$prop() should append to the parent incase the after element is destroyed before the DOM operation is issued',

['enter', 'move'], function(event) {

inject(function($animate, $rootScope) {

parent2.remove();

$animate[event](element, parent, parent2, options);

expect(parent2.next()).not.toEqual(element);

$rootScope.$digest();

expect(capturedAnimation[1]).toBe(event);

});

});

it('leave() should issue a leave animation with the correct DOM operation', inject(function($animate, $rootScope) {

parent.append(element);

options.foo = 'bar';

$animate.leave(element, options);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('leave');

expect(capturedAnimation[2].foo).toEqual(options.foo);

expect(element.parent().length).toBe(1);

capturedAnimation[2].domOperation();

expect(element.parent().length).toBe(0);

}));

it('should remove all element and comment nodes during leave animation',

inject(function($compile, $rootScope, $animate, $$AnimateRunner) {

element = $compile(

'<div>' +

' <div class="animated" ng-repeat-start="item in items">start</div>' +

' <div ng-repeat-end>end</div>' +

'</div>'

)($rootScope);

parent.append(element);

$rootScope.items = [1,2,3,4,5];

$rootScope.$digest();

// all the start/end repeat anchors + their adjacent comments

expect(element[0].childNodes.length).toBe(22);

var runner = new $$AnimateRunner();

overriddenAnimationRunner = runner;

$rootScope.items.length = 0;

$rootScope.$digest();

runner.end();

$animate.flush();

// we're left with a text node and a comment node

expect(element[0].childNodes.length).toBeLessThan(3);

}));

it('addClass() should issue an addClass animation with the correct DOM operation', inject(function($animate, $rootScope) {

parent.append(element);

options.foo = 'bar';

$animate.addClass(element, 'red', options);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('addClass');

expect(capturedAnimation[2].foo).toEqual(options.foo);

expect(element).not.toHaveClass('red');

applyAnimationClasses(element, capturedAnimation[2]);

expect(element).toHaveClass('red');

}));

it('removeClass() should issue a removeClass animation with the correct DOM operation', inject(function($animate, $rootScope) {

parent.append(element);

element.addClass('blue');

options.foo = 'bar';

$animate.removeClass(element, 'blue', options);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('removeClass');

expect(capturedAnimation[2].foo).toEqual(options.foo);

expect(element).toHaveClass('blue');

applyAnimationClasses(element, capturedAnimation[2]);

expect(element).not.toHaveClass('blue');

}));

it('setClass() should issue a setClass animation with the correct DOM operation', inject(function($animate, $rootScope) {

parent.append(element);

element.addClass('green');

options.foo = 'bar';

$animate.setClass(element, 'yellow', 'green', options);

$rootScope.$digest();

expect(capturedAnimation[0]).toBe(element);

expect(capturedAnimation[1]).toBe('setClass');

expect(capturedAnimation[2].foo).toEqual(options.foo);

expect(element).not.toHaveClass('yellow');

expect(element).toHaveClass('green');

applyAnimationClasses(element, capturedAnimation[2]);

expect(element).toHaveClass('yellow');

expect(element).not.toHaveClass('green');

}));

they('$prop() should operate using a native DOM element',

['enter', 'move', 'leave', 'addClass', 'removeClass', 'setClass', 'animate'], function(event) {

inject(function($animate, $rootScope, $document) {

var element = $document[0].createElement('div');

element.setAttribute('id', 'crazy-man');

if (event !== 'enter' && event !== 'move') {

parent.append(element);

}

switch (event) {

case 'enter':

case 'move':

$animate[event](element, parent, parent2, options);

break;

case 'addClass':

$animate.addClass(element, 'klass', options);

break;

case 'removeClass':

element.className = 'klass';

$animate.removeClass(element, 'klass', options);

break;

case 'setClass':

element.className = 'two';

$animate.setClass(element, 'one', 'two', options);

break;

case 'leave':

$animate.leave(element, options);

break;

case 'animate':

var toStyles = { color: 'red' };

$animate.animate(element, {}, toStyles, 'klass', options);

break;

}

$rootScope.$digest();

expect(capturedAnimation[0].attr('id')).toEqual(element.getAttribute('id'));

});

});

describe('addClass / removeClass', function() {

it('should not perform an animation if there are no valid CSS classes to add',

inject(function($animate, $rootScope) {

parent.append(element);

$animate.removeClass(element, 'something-to-remove');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

element.addClass('something-to-add');

$animate.addClass(element, 'something-to-add');

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

}));

});

describe('animate()', function() {

they('should not perform an animation if $prop is provided as a `to` style',

{ '{}': {},

'null': null,

'false': false,

'""': '',

'[]': [] }, function(toStyle) {

inject(function($animate, $rootScope) {

parent.append(element);

$animate.animate(element, null, toStyle);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

});

});

it('should not perform an animation if only from styles are provided',

inject(function($animate, $rootScope) {

var fromStyle = { color: 'pink' };

parent.append(element);

$animate.animate(element, fromStyle);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

}));

it('should perform an animation if only from styles are provided as well as any valid classes',

inject(function($animate, $rootScope) {

parent.append(element);

var fromStyle = { color: 'red' };

var options = { removeClass: 'goop' };

$animate.animate(element, fromStyle, null, null, options);

$rootScope.$digest();

expect(capturedAnimation).toBeNull();

fromStyle = { color: 'blue' };

options = { addClass: 'goop' };

$animate.animate(element, fromStyle, null, null, options);

$rootScope.$digest();

expect(capturedAnimation).toBeTruthy();

}));

});

describe('parent animations', function() {

they('should not cancel a pre-digest parent class-based animation if a child $prop animation is set to run',

['structural', 'class-based'], function(animationType) {

inject(function($rootScope, $animate) {

parent.append(element);

var child = jqLite('<div></div>');

if (animationType === 'structural') {

$animate.enter(child, element);

} else {

element.append(child);

$animate.addClass(child, 'test');

}

$animate.addClass(parent, 'abc');

expect(capturedAnimationHistory.length).toBe(0);

$rootScope.$digest();

expect(capturedAnimationHistory.length).toBe(2);

});

});

they('should not cancel a post-digest parent class-based animation if a child $prop animation is set to run',

['structural', 'class-based'], function(animationType) {

inject(function($rootScope, $animate) {

parent.append(element);

var child = jqLite('<div></div>');

$animate.addClass(parent, 'abc');

$rootScope.$digest();

if (animationType === 'structural') {

$animate.enter(child, element);

} else {

element.append(child);

$animate.addClass(child, 'test');

}

expect(capturedAnimationHistory.length).toBe(1);

$rootScope.$digest();

expect(capturedAnimationHistory.length).toBe(2);

});

});

they('should not cancel a post-digest $prop child animation if a class-based parent animation is set to run',

['structural', 'class-based'], function(animationType) {

inject(function($rootScope, $animate) {

parent.append(element);

var child = jqLite('<div></div>');

if (animationType === 'structural') {

$animate.enter(child, element);

} else {

element.append(child);

$animate.addClass(child, 'test');

}

$rootScope.$digest();

$animate.addClass(parent, 'abc');