{{bind}}
');
- $compile(element)($rootScope);
- $rootScope.$apply(function() {
- $rootScope.bind = 'value';
- });
-
- expect(element.text()).toBe('value');
- }));
-});
diff --git a/test/jstd-scenario-adapter/AdapterSpecs.js b/test/jstd-scenario-adapter/AdapterSpecs.js
deleted file mode 100644
index e360ad4f..00000000
--- a/test/jstd-scenario-adapter/AdapterSpecs.js
+++ /dev/null
@@ -1,322 +0,0 @@
-'use strict';
-
-describe('jstd-adapter', function() {
- var fakeJSTD = { pluginRegistrar: { register: function() {} } },
- originalNavigateTo = angular.scenario.Application.prototype.navigateTo;
-
- /**
- * Reverts hack on angular.scenario.Application.navigateTo
- * We should revert this hack after any single call of initScenarioAdapter,
- * so that it doesn't influence other tests...
- */
- function revertNavigateToHack() {
- angular.scenario.Application.prototype.navigateTo = originalNavigateTo;
- }
-
- /**
- * Helper for building angular.scenario.ObjectModel.Spec
- * @returns {angular.scenario.ObjectModel.Spec}
- */
- function buildSpec(status, name, duration, definitions, error, line) {
- var spec = new angular.scenario.ObjectModel.Spec(
- 'fake-id', name || 'name', definitions || ['desc1', 'desc2']);
- spec.duration = duration || 10;
- spec.status = status || 'success';
- spec.error = error || '';
- spec.line = line || '';
-
- return spec;
- }
-
- /**
- * Helper for building angular.scenario.ObjectModel.Spec with error and error line
- * @returns {angular.scenario.ObjectModel.Spec}
- */
- function buildErrorSpec(error, line, status, name) {
- return buildSpec(status || 'error', name, null, null, error, line);
- }
-
- /**
- * Helper for building TestConfiguration
- * @returns {jstestdriver.TestRunConfiguration}
- */
- function buildTestConf(type) {
- return new jstestdriver.TestRunConfiguration(
- new jstestdriver.TestCaseInfo('Fake test - ' + Math.random(), function() {}, type), null);
- }
-
- /**
- * Helper for building SCENARIO TestConfiguration
- * @returns {jstestdriver.TestRunConfiguration}
- */
- function buildScenarioTestConf() {
- return buildTestConf(SCENARIO_TYPE);
- }
-
- describe('initScenarioAdapter', function() {
- afterEach(revertNavigateToHack);
-
- it('should create and register plugin if jstestdriver defined', function() {
- spyOn(fakeJSTD.pluginRegistrar, 'register');
- initScenarioAdapter(fakeJSTD);
- expect(fakeJSTD.pluginRegistrar.register).toHaveBeenCalled();
- expect(fakeJSTD.pluginRegistrar.register.mostRecentCall.args[0] instanceof JstdPlugin);
- });
-
- it('should do nothing if jstestdriver not defined', function() {
- expect(function() {
- initScenarioAdapter(undefined);
- }).not.toThrow();
- });
-
- it('should set setUpAndRun callback to plugin', function() {
- var runFn = jasmine.createSpy('setUpAndRun');
- plugin.runScenario = null;
-
- initScenarioAdapter(fakeJSTD, runFn);
- expect(plugin.runScenario).toBe(runFn);
- });
-
- describe('navigateTo', function() {
- var fakeJSTD = { pluginRegistrar: { register: function() {} } },
- app = new angular.scenario.Application(_jQuery('')),
- navigateSpy;
-
- beforeEach(function() {
- navigateSpy = spyOn(angular.scenario.Application.prototype, 'navigateTo');
- });
-
- it('should add url prefix when jstd defined', function() {
- initScenarioAdapter(fakeJSTD, null, {relativeUrlPrefix: '/prefix/'});
-
- app.navigateTo('test.html');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('/prefix/test.html');
- });
-
- it('should add forward-slash as default url prefix when jstd defined', function() {
- initScenarioAdapter(fakeJSTD);
-
- app.navigateTo('test.html');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('/test.html');
- });
-
- it('should not change url when jstd not defined', function() {
- initScenarioAdapter(null);
-
- app.navigateTo('test.html');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('test.html');
- });
-
- it('should not change hash url', function() {
- initScenarioAdapter(fakeJSTD);
-
- app.navigateTo('#/index.html/a');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('#/index.html/a');
- });
-
- it('should not change absolute url', function() {
- initScenarioAdapter(fakeJSTD);
-
- app.navigateTo('/index.html/a');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('/index.html/a');
- });
-
- it('should not change "about:blank" url', function() {
- initScenarioAdapter(fakeJSTD);
-
- app.navigateTo('about:blank');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('about:blank');
- });
-
- it('should not change url with domain', function() {
- initScenarioAdapter(fakeJSTD);
-
- app.navigateTo('http://www.google.com');
- expect(navigateSpy).toHaveBeenCalled();
- expect(navigateSpy.mostRecentCall.args[0]).toEqual('http://www.google.com');
- });
- });
- });
-
- describe('JstdPlugin', function() {
- var p;
-
- beforeEach(function() {
- p = new JstdPlugin();
- });
-
- describe('runTestConfiguration', function() {
- var initScenarioSpy, onTestSpy, onAllTestsSpy, spec, modelSpec;
-
- beforeEach(function() {
- initScenarioSpy = jasmine.createSpy('initScenarioAndRun');
- onTestSpy = jasmine.createSpy('onOneTest');
- onAllTestsSpy = jasmine.createSpy('onAllTests');
-
- p.runScenario = initScenarioSpy;
- spec = {id: 'fake', name: 'Spec Name'};
- modelSpec = new angular.scenario.ObjectModel.Spec(spec.id, spec.name);
- });
-
- it('should ignore non scenario test cases', function() {
- expect(p.runTestConfiguration(buildTestConf(), onTestSpy, onAllTestsSpy)).toBe(false);
- expect(p.runTestConfiguration(buildTestConf('async'), onTestSpy, onAllTestsSpy)).toBe(false);
- expect(initScenarioSpy).not.toHaveBeenCalled();
- expect(onTestSpy).not.toHaveBeenCalled();
- expect(onAllTestsSpy).not.toHaveBeenCalled();
- });
-
- it('should return true when scenario test case', function() {
- expect(p.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy)).toBe(true);
- });
-
- it('should call initAndRunTests when scenario test case', function() {
- p.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy);
- expect(initScenarioSpy).toHaveBeenCalled();
- });
- });
-
- describe('getTestRunsConfigurationFor', function() {
- it('should add TestRunConfiguration with SCENARIO_TYPE TestCase', function() {
- var configurations = [];
- p.getTestRunsConfigurationFor(null, null, configurations);
-
- expect(configurations.length).toBe(1);
- expect(configurations[0] instanceof jstestdriver.TestRunConfiguration).toBe(true);
- expect(configurations[0].getTestCaseInfo().getType()).toEqual(SCENARIO_TYPE);
- });
-
- it('should always return true', function() {
- expect(p.getTestRunsConfigurationFor(null, null, [])).toBe(true);
- });
- });
- });
-
- describe('createTestResultFromSpec', function() {
- it('should return jstestdriver.TestResult instance', function() {
- expect(createTestResultFromSpec(buildSpec()) instanceof jstestdriver.TestResult).toBe(true);
- });
-
- it('should set proper test name', function() {
- expect(createTestResultFromSpec(buildSpec()).testName).toEqual('name');
- });
-
- it('should set duration', function() {
- expect(createTestResultFromSpec(buildSpec()).time).toEqual(10);
- });
-
- it('should set test case - full definition name', function() {
- var spec = buildSpec();
- expect(createTestResultFromSpec(spec).testCaseName).toEqual(spec.fullDefinitionName);
- });
-
- it('should set passed result when success', function() {
- expect(createTestResultFromSpec(buildSpec('success')).result)
- .toEqual(jstestdriver.TestResult.RESULT.PASSED);
- });
-
- it('should set error result when error', function() {
- expect(createTestResultFromSpec(buildSpec('error')).result)
- .toEqual(jstestdriver.TestResult.RESULT.ERROR);
- });
-
- it('should set failed result when failure', function() {
- expect(createTestResultFromSpec(buildSpec('failure')).result)
- .toEqual(jstestdriver.TestResult.RESULT.FAILED);
- });
-
- it('should set error message when error/failure', function() {
- expect(createTestResultFromSpec(buildErrorSpec('error-message')).message)
- .toEqual('error-message');
- });
-
- it('should log line number when error/failure', function() {
- expect(createTestResultFromSpec(buildErrorSpec('msg', 'line-number')).log)
- .toEqual('line-number');
- });
- });
-
- describe('angular.scenario.output.jstd', function() {
- var model;
-
- beforeEach(function() {
- var runner = new angular.scenario.testing.MockRunner(),
- context = _jQuery("");
-
- plugin = new JstdPlugin();
- model = new angular.scenario.ObjectModel(runner);
- angular.scenario.output.jstd(context, runner, model);
-
- spyOn(plugin, 'reportEnd');
- spyOn(plugin, 'reportResult');
- });
-
- it('should report end of all tests', function() {
- model.emit('RunnerEnd');
- expect(plugin.reportEnd).toHaveBeenCalled();
- });
-
- it('should report jstestdriver.TestResult', function() {
- model.emit('SpecEnd', buildSpec());
- expect(plugin.reportResult).toHaveBeenCalled();
- expect(plugin.reportResult.argsForCall[0][0] instanceof jstestdriver.TestResult).toBe(true);
- });
- });
-
- // couple of higher level tests (wiring objects together)
- describe('HIGHER LEVEL', function() {
- var initScenarioSpy, onTestSpy, onAllTestsSpy, model;
-
- beforeEach(function() {
- plugin = new JstdPlugin();
- initScenarioSpy = jasmine.createSpy('initScenarioAndRun');
- onTestSpy = jasmine.createSpy('onOneTest');
- onAllTestsSpy = jasmine.createSpy('onAllTests');
-
- var runner = new angular.scenario.testing.MockRunner(),
- context = _jQuery("");
-
- model = new angular.scenario.ObjectModel(runner);
- angular.scenario.output.jstd(context, runner, model);
-
- initScenarioAdapter(fakeJSTD, initScenarioSpy);
- plugin.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy);
- });
-
- afterEach(revertNavigateToHack);
-
- it('should report and of test suite', function() {
- model.emit('RunnerEnd');
- expect(onAllTestsSpy).toHaveBeenCalled();
- });
-
- it('should report success test result', function() {
- model.emit('SpecEnd', buildSpec('success', 'name'));
- expect(onTestSpy).toHaveBeenCalled();
- var result = onTestSpy.argsForCall[0][0];
- expect(result instanceof jstestdriver.TestResult).toBe(true);
- expect(result.testName).toEqual('name');
- expect(result.result).toEqual(jstestdriver.TestResult.RESULT.PASSED);
- });
-
- it('should report error test result', function() {
- model.emit('SpecEnd', buildSpec('error'));
- expect(onTestSpy).toHaveBeenCalled();
- var result = onTestSpy.argsForCall[0][0];
- expect(result.result).toEqual(jstestdriver.TestResult.RESULT.ERROR);
- });
-
- it('should report failed test result', function() {
- model.emit('SpecEnd', buildSpec('failure'));
- expect(onTestSpy).toHaveBeenCalled();
- var result = onTestSpy.argsForCall[0][0];
- expect(result.result).toEqual(jstestdriver.TestResult.RESULT.FAILED);
- });
- });
-});
diff --git a/test/ng/anchorScrollSpec.js b/test/ng/anchorScrollSpec.js
new file mode 100644
index 00000000..7e4b3aa3
--- /dev/null
+++ b/test/ng/anchorScrollSpec.js
@@ -0,0 +1,186 @@
+describe('$anchorScroll', function() {
+
+ var elmSpy;
+
+ function addElements() {
+ var elements = sliceArgs(arguments);
+
+ return function() {
+ forEach(elements, function(identifier) {
+ var match = identifier.match(/(\w* )?(\w*)=(\w*)/),
+ jqElm = jqLite('<' + (match[1] || 'a ') + match[2] + '="' + match[3] + '"/>'),
+ elm = jqElm[0];
+
+ elmSpy[identifier] = spyOn(elm, 'scrollIntoView');
+ jqLite(document.body).append(jqElm);
+ });
+ };
+ }
+
+ function changeHashAndScroll(hash) {
+ return function($location, $anchorScroll) {
+ $location.hash(hash);
+ $anchorScroll();
+ };
+ }
+
+ function expectScrollingToTop($window) {
+ forEach(elmSpy, function(spy, id) {
+ expect(spy).not.toHaveBeenCalled();
+ });
+
+ expect($window.scrollTo).toHaveBeenCalledWith(0, 0);
+ }
+
+ function expectScrollingTo(identifier) {
+ return function($window) {
+ forEach(elmSpy, function(spy, id) {
+ if (identifier === id) expect(spy).toHaveBeenCalledOnce();
+ else expect(spy).not.toHaveBeenCalled();
+ });
+ expect($window.scrollTo).not.toHaveBeenCalled();
+ };
+ }
+
+ function expectNoScrolling() {
+ return expectScrollingTo(NaN);
+ }
+
+
+ beforeEach(module(function($provide) {
+ elmSpy = {};
+ $provide.value('$window', {
+ scrollTo: jasmine.createSpy('$window.scrollTo'),
+ document: document
+ });
+ }));
+
+
+ it('should scroll to top of the window if empty hash', inject(
+ changeHashAndScroll(''),
+ expectScrollingToTop));
+
+
+ it('should not scroll if hash does not match any element', inject(
+ addElements('id=one', 'id=two'),
+ changeHashAndScroll('non-existing'),
+ expectNoScrolling()));
+
+
+ it('should scroll to anchor element with name', inject(
+ addElements('a name=abc'),
+ changeHashAndScroll('abc'),
+ expectScrollingTo('a name=abc')));
+
+
+ it('should not scroll to other than anchor element with name', inject(
+ addElements('input name=xxl', 'select name=xxl', 'form name=xxl'),
+ changeHashAndScroll('xxl'),
+ expectNoScrolling()));
+
+
+ it('should scroll to anchor even if other element with given name exist', inject(
+ addElements('input name=some', 'a name=some'),
+ changeHashAndScroll('some'),
+ expectScrollingTo('a name=some')));
+
+
+ it('should scroll to element with id with precedence over name', inject(
+ addElements('name=abc', 'id=abc'),
+ changeHashAndScroll('abc'),
+ expectScrollingTo('id=abc')));
+
+
+ it('should scroll to top if hash == "top" and no matching element', inject(
+ changeHashAndScroll('top'),
+ expectScrollingToTop));
+
+
+ it('should scroll to element with id "top" if present', inject(
+ addElements('id=top'),
+ changeHashAndScroll('top'),
+ expectScrollingTo('id=top')));
+
+
+ describe('watcher', function() {
+
+ function initLocation(config) {
+ return function($provide, $locationProvider) {
+ $provide.value('$sniffer', {history: config.historyApi});
+ $locationProvider.html5Mode(config.html5Mode);
+ };
+ }
+
+ function changeHashTo(hash) {
+ return function ($location, $rootScope, $anchorScroll) {
+ $rootScope.$apply(function() {
+ $location.hash(hash);
+ });
+ };
+ }
+
+ function disableAutoScrolling() {
+ return function($anchorScrollProvider) {
+ $anchorScrollProvider.disableAutoScrolling();
+ };
+ }
+
+ afterEach(inject(function($document) {
+ dealoc($document);
+ }));
+
+
+ it('should scroll to element when hash change in hashbang mode', function() {
+ module(initLocation({html5Mode: false, historyApi: true}));
+ inject(
+ addElements('id=some'),
+ changeHashTo('some'),
+ expectScrollingTo('id=some')
+ );
+ });
+
+
+ it('should scroll to element when hash change in html5 mode with no history api', function() {
+ module(initLocation({html5Mode: true, historyApi: false}));
+ inject(
+ addElements('id=some'),
+ changeHashTo('some'),
+ expectScrollingTo('id=some')
+ );
+ });
+
+
+ it('should not scroll when element does not exist', function() {
+ module(initLocation({html5Mode: false, historyApi: false}));
+ inject(
+ addElements('id=some'),
+ changeHashTo('other'),
+ expectNoScrolling()
+ );
+ });
+
+
+ it('should scroll when html5 mode with history api', function() {
+ module(initLocation({html5Mode: true, historyApi: true}));
+ inject(
+ addElements('id=some'),
+ changeHashTo('some'),
+ expectScrollingTo('id=some')
+ );
+ });
+
+
+ it('should not scroll when disabled', function() {
+ module(
+ disableAutoScrolling(),
+ initLocation({html5Mode: false, historyApi: false})
+ );
+ inject(
+ addElements('id=fake'),
+ changeHashTo('fake'),
+ expectNoScrolling()
+ );
+ });
+ });
+});
+
diff --git a/test/ng/browserSpecs.js b/test/ng/browserSpecs.js
new file mode 100644
index 00000000..4563d14b
--- /dev/null
+++ b/test/ng/browserSpecs.js
@@ -0,0 +1,578 @@
+'use strict';
+
+function MockWindow() {
+ var events = {};
+ var timeouts = this.timeouts = [];
+
+ this.setTimeout = function(fn) {
+ return timeouts.push(fn) - 1;
+ };
+
+ this.clearTimeout = function(id) {
+ timeouts[id] = noop;
+ };
+
+ this.setTimeout.flush = function() {
+ var length = timeouts.length;
+ while (length-- > 0) timeouts.shift()();
+ };
+
+ this.addEventListener = function(name, listener) {
+ if (isUndefined(events[name])) events[name] = [];
+ events[name].push(listener);
+ };
+
+ this.attachEvent = function(name, listener) {
+ this.addEventListener(name.substr(2), listener);
+ };
+
+ this.removeEventListener = noop;
+ this.detachEvent = noop;
+
+ this.fire = function(name) {
+ forEach(events[name], function(fn) {
+ fn({type: name}); // type to make jQuery happy
+ });
+ };
+
+ this.location = {
+ href: 'http://server',
+ replace: noop
+ };
+
+ this.history = {
+ replaceState: noop,
+ pushState: noop
+ };
+}
+
+describe('browser', function() {
+
+ var browser, fakeWindow, logs, scripts, removedScripts, sniffer;
+
+ beforeEach(function() {
+ scripts = [];
+ removedScripts = [];
+ sniffer = {history: true, hashchange: true};
+ fakeWindow = new MockWindow();
+
+ var fakeBody = [{appendChild: function(node){scripts.push(node);},
+ removeChild: function(node){removedScripts.push(node);}}];
+
+ logs = {log:[], warn:[], info:[], error:[]};
+
+ var fakeLog = {log: function() { logs.log.push(slice.call(arguments)); },
+ warn: function() { logs.warn.push(slice.call(arguments)); },
+ info: function() { logs.info.push(slice.call(arguments)); },
+ error: function() { logs.error.push(slice.call(arguments)); }};
+
+ browser = new Browser(fakeWindow, jqLite(window.document), fakeBody, fakeLog, sniffer);
+ });
+
+ it('should contain cookie cruncher', function() {
+ expect(browser.cookies).toBeDefined();
+ });
+
+ describe('outstading requests', function() {
+ it('should process callbacks immedietly with no outstanding requests', function() {
+ var callback = jasmine.createSpy('callback');
+ browser.notifyWhenNoOutstandingRequests(callback);
+ expect(callback).toHaveBeenCalled();
+ });
+ });
+
+
+ describe('defer', function() {
+ it('should execute fn asynchroniously via setTimeout', function() {
+ var callback = jasmine.createSpy('deferred');
+
+ browser.defer(callback);
+ expect(callback).not.toHaveBeenCalled();
+
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it('should update outstandingRequests counter', function() {
+ var callback = jasmine.createSpy('deferred');
+
+ browser.defer(callback);
+ expect(callback).not.toHaveBeenCalled();
+
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it('should return unique deferId', function() {
+ var deferId1 = browser.defer(noop),
+ deferId2 = browser.defer(noop);
+
+ expect(deferId1).toBeDefined();
+ expect(deferId2).toBeDefined();
+ expect(deferId1).not.toEqual(deferId2);
+ });
+
+
+ describe('cancel', function() {
+ it('should allow tasks to be canceled with returned deferId', function() {
+ var log = [],
+ deferId1 = browser.defer(function() { log.push('cancel me'); }),
+ deferId2 = browser.defer(function() { log.push('ok'); }),
+ deferId3 = browser.defer(function() { log.push('cancel me, now!'); });
+
+ expect(log).toEqual([]);
+ expect(browser.defer.cancel(deferId1)).toBe(true);
+ expect(browser.defer.cancel(deferId3)).toBe(true);
+ fakeWindow.setTimeout.flush();
+ expect(log).toEqual(['ok']);
+ expect(browser.defer.cancel(deferId2)).toBe(false);
+ });
+ });
+ });
+
+
+ describe('cookies', function() {
+
+ function deleteAllCookies() {
+ var cookies = document.cookie.split(";");
+
+ for (var i = 0; i < cookies.length; i++) {
+ var cookie = cookies[i];
+ var eqPos = cookie.indexOf("=");
+ var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+ document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+ }
+ }
+
+ beforeEach(function() {
+ deleteAllCookies();
+ expect(document.cookie).toEqual('');
+ });
+
+
+ afterEach(function() {
+ deleteAllCookies();
+ expect(document.cookie).toEqual('');
+ });
+
+
+ describe('remove all via (null)', function() {
+
+ it('should do nothing when no cookies are set', function() {
+ browser.cookies(null);
+ expect(document.cookie).toEqual('');
+ expect(browser.cookies()).toEqual({});
+ });
+
+ });
+
+ describe('remove via cookies(cookieName, undefined)', function() {
+
+ it('should remove a cookie when it is present', function() {
+ document.cookie = 'foo=bar';
+
+ browser.cookies('foo', undefined);
+
+ expect(document.cookie).toEqual('');
+ expect(browser.cookies()).toEqual({});
+ });
+
+
+ it('should do nothing when an nonexisting cookie is being removed', function() {
+ browser.cookies('doesntexist', undefined);
+ expect(document.cookie).toEqual('');
+ expect(browser.cookies()).toEqual({});
+ });
+ });
+
+
+ describe('put via cookies(cookieName, string)', function() {
+
+ it('should create and store a cookie', function() {
+ browser.cookies('cookieName', 'cookie=Value');
+ expect(document.cookie).toMatch(/cookieName=cookie%3DValue;? ?/);
+ expect(browser.cookies()).toEqual({'cookieName':'cookie=Value'});
+ });
+
+
+ it('should overwrite an existing unsynced cookie', function() {
+ document.cookie = "cookie=new";
+
+ var oldVal = browser.cookies('cookie', 'newer');
+
+ expect(document.cookie).toEqual('cookie=newer');
+ expect(browser.cookies()).toEqual({'cookie':'newer'});
+ expect(oldVal).not.toBeDefined();
+ });
+
+ it('should escape both name and value', function() {
+ browser.cookies('cookie1=', 'val;ue');
+ browser.cookies('cookie2=bar;baz', 'val=ue');
+
+ var rawCookies = document.cookie.split("; "); //order is not guaranteed, so we need to parse
+ expect(rawCookies.length).toEqual(2);
+ expect(rawCookies).toContain('cookie1%3D=val%3Bue');
+ expect(rawCookies).toContain('cookie2%3Dbar%3Bbaz=val%3Due');
+ });
+
+ it('should log warnings when 4kb per cookie storage limit is reached', function() {
+ var i, longVal = '', cookieStr;
+
+ for(i=0; i<4091; i++) {
+ longVal += '+';
+ }
+
+ cookieStr = document.cookie;
+ browser.cookies('x', longVal); //total size 4093-4096, so it should go through
+ expect(document.cookie).not.toEqual(cookieStr);
+ expect(browser.cookies()['x']).toEqual(longVal);
+ expect(logs.warn).toEqual([]);
+
+ browser.cookies('x', longVal + 'xxxx'); //total size 4097-4099, a warning should be logged
+ expect(logs.warn).toEqual(
+ [[ "Cookie 'x' possibly not set or overflowed because it was too large (4097 > 4096 " +
+ "bytes)!" ]]);
+
+ //force browser to dropped a cookie and make sure that the cache is not out of sync
+ browser.cookies('x', 'shortVal');
+ expect(browser.cookies().x).toEqual('shortVal'); //needed to prime the cache
+ cookieStr = document.cookie;
+ browser.cookies('x', longVal + longVal + longVal); //should be too long for all browsers
+
+ if (document.cookie !== cookieStr) {
+ fail("browser didn't drop long cookie when it was expected. make the cookie in this " +
+ "test longer");
+ }
+
+ expect(browser.cookies().x).toEqual('shortVal');
+ });
+
+ it('should log warnings when 20 cookies per domain storage limit is reached', function() {
+ var i, str, cookieStr;
+
+ for (i=0; i<20; i++) {
+ str = '' + i;
+ browser.cookies(str, str);
+ }
+
+ i=0;
+ for (str in browser.cookies()) {
+ i++;
+ }
+ expect(i).toEqual(20);
+ expect(logs.warn).toEqual([]);
+ cookieStr = document.cookie;
+
+ browser.cookies('one', 'more');
+ expect(logs.warn).toEqual([]);
+
+ //if browser dropped a cookie (very likely), make sure that the cache is not out of sync
+ if (document.cookie === cookieStr) {
+ expect(size(browser.cookies())).toEqual(20);
+ } else {
+ expect(size(browser.cookies())).toEqual(21);
+ }
+ });
+ });
+
+
+ describe('get via cookies()[cookieName]', function() {
+
+ it('should return undefined for nonexistent cookie', function() {
+ expect(browser.cookies().nonexistent).not.toBeDefined();
+ });
+
+
+ it ('should return a value for an existing cookie', function() {
+ document.cookie = "foo=bar=baz";
+ expect(browser.cookies().foo).toEqual('bar=baz');
+ });
+
+
+ it ('should unescape cookie values that were escaped by puts', function() {
+ document.cookie = "cookie2%3Dbar%3Bbaz=val%3Due";
+ expect(browser.cookies()['cookie2=bar;baz']).toEqual('val=ue');
+ });
+
+
+ it('should preserve leading & trailing spaces in names and values', function() {
+ browser.cookies(' cookie name ', ' cookie value ');
+ expect(browser.cookies()[' cookie name ']).toEqual(' cookie value ');
+ expect(browser.cookies()['cookie name']).not.toBeDefined();
+ });
+ });
+
+
+ describe('getAll via cookies()', function() {
+
+ it('should return cookies as hash', function() {
+ document.cookie = "foo1=bar1";
+ document.cookie = "foo2=bar2";
+ expect(browser.cookies()).toEqual({'foo1':'bar1', 'foo2':'bar2'});
+ });
+
+
+ it('should return empty hash if no cookies exist', function() {
+ expect(browser.cookies()).toEqual({});
+ });
+ });
+
+
+ it('should pick up external changes made to browser cookies', function() {
+ browser.cookies('oatmealCookie', 'drool');
+ expect(browser.cookies()).toEqual({'oatmealCookie':'drool'});
+
+ document.cookie = 'oatmealCookie=changed';
+ expect(browser.cookies().oatmealCookie).toEqual('changed');
+ });
+
+
+ it('should initialize cookie cache with existing cookies', function() {
+ document.cookie = "existingCookie=existingValue";
+ expect(browser.cookies()).toEqual({'existingCookie':'existingValue'});
+ });
+
+ });
+
+ describe('poller', function() {
+
+ it('should call functions in pollFns in regular intervals', function() {
+ var log = '';
+ browser.addPollFn(function() {log+='a';});
+ browser.addPollFn(function() {log+='b';});
+ expect(log).toEqual('');
+ fakeWindow.setTimeout.flush();
+ expect(log).toEqual('ab');
+ fakeWindow.setTimeout.flush();
+ expect(log).toEqual('abab');
+ });
+
+ it('should startPoller', function() {
+ expect(fakeWindow.timeouts.length).toEqual(0);
+
+ browser.addPollFn(function() {});
+ expect(fakeWindow.timeouts.length).toEqual(1);
+
+ //should remain 1 as it is the check fn
+ browser.addPollFn(function() {});
+ expect(fakeWindow.timeouts.length).toEqual(1);
+ });
+
+ it('should return fn that was passed into addPollFn', function() {
+ var fn = function() { return 1; };
+ var returnedFn = browser.addPollFn(fn);
+ expect(returnedFn).toBe(fn);
+ });
+ });
+
+ describe('url', function() {
+ var pushState, replaceState, locationReplace;
+
+ beforeEach(function() {
+ pushState = spyOn(fakeWindow.history, 'pushState');
+ replaceState = spyOn(fakeWindow.history, 'replaceState');
+ locationReplace = spyOn(fakeWindow.location, 'replace');
+ });
+
+ it('should return current location.href', function() {
+ fakeWindow.location.href = 'http://test.com';
+ expect(browser.url()).toEqual('http://test.com');
+
+ fakeWindow.location.href = 'https://another.com';
+ expect(browser.url()).toEqual('https://another.com');
+ });
+
+ it('should use history.pushState when available', function() {
+ sniffer.history = true;
+ browser.url('http://new.org');
+
+ expect(pushState).toHaveBeenCalledOnce();
+ expect(pushState.argsForCall[0][2]).toEqual('http://new.org');
+
+ expect(replaceState).not.toHaveBeenCalled();
+ expect(locationReplace).not.toHaveBeenCalled();
+ expect(fakeWindow.location.href).toEqual('http://server');
+ });
+
+ it('should use history.replaceState when available', function() {
+ sniffer.history = true;
+ browser.url('http://new.org', true);
+
+ expect(replaceState).toHaveBeenCalledOnce();
+ expect(replaceState.argsForCall[0][2]).toEqual('http://new.org');
+
+ expect(pushState).not.toHaveBeenCalled();
+ expect(locationReplace).not.toHaveBeenCalled();
+ expect(fakeWindow.location.href).toEqual('http://server');
+ });
+
+ it('should set location.href when pushState not available', function() {
+ sniffer.history = false;
+ browser.url('http://new.org');
+
+ expect(fakeWindow.location.href).toEqual('http://new.org');
+
+ expect(pushState).not.toHaveBeenCalled();
+ expect(replaceState).not.toHaveBeenCalled();
+ expect(locationReplace).not.toHaveBeenCalled();
+ });
+
+ it('should use location.replace when history.replaceState not available', function() {
+ sniffer.history = false;
+ browser.url('http://new.org', true);
+
+ expect(locationReplace).toHaveBeenCalledWith('http://new.org');
+
+ expect(pushState).not.toHaveBeenCalled();
+ expect(replaceState).not.toHaveBeenCalled();
+ expect(fakeWindow.location.href).toEqual('http://server');
+ });
+
+ it('should return $browser to allow chaining', function() {
+ expect(browser.url('http://any.com')).toBe(browser);
+ });
+ });
+
+ describe('urlChange', function() {
+ var callback;
+
+ beforeEach(function() {
+ callback = jasmine.createSpy('onUrlChange');
+ });
+
+ afterEach(function() {
+ if (!jQuery) jqLite(fakeWindow).dealoc();
+ });
+
+ it('should return registered callback', function() {
+ expect(browser.onUrlChange(callback)).toBe(callback);
+ });
+
+ it('should forward popstate event with new url when history supported', function() {
+ sniffer.history = true;
+ browser.onUrlChange(callback);
+ fakeWindow.location.href = 'http://server/new';
+
+ fakeWindow.fire('popstate');
+ expect(callback).toHaveBeenCalledWith('http://server/new');
+
+ fakeWindow.fire('hashchange');
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+ it('should forward only popstate event when both history and hashchange supported', function() {
+ sniffer.history = true;
+ sniffer.hashchange = true;
+ browser.onUrlChange(callback);
+ fakeWindow.location.href = 'http://server/new';
+
+ fakeWindow.fire('popstate');
+ expect(callback).toHaveBeenCalledWith('http://server/new');
+
+ fakeWindow.fire('hashchange');
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+ it('should forward hashchange event with new url when only hashchange supported', function() {
+ sniffer.history = false;
+ sniffer.hashchange = true;
+ browser.onUrlChange(callback);
+ fakeWindow.location.href = 'http://server/new';
+
+ fakeWindow.fire('hashchange');
+ expect(callback).toHaveBeenCalledWith('http://server/new');
+
+ fakeWindow.fire('popstate');
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+ it('should use polling when neither history nor hashchange supported', function() {
+ sniffer.history = false;
+ sniffer.hashchange = false;
+ browser.onUrlChange(callback);
+
+ fakeWindow.location.href = 'http://server.new';
+ fakeWindow.setTimeout.flush();
+ expect(callback).toHaveBeenCalledWith('http://server.new');
+
+ fakeWindow.fire('popstate');
+ fakeWindow.fire('hashchange');
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+ it('should not fire urlChange if changed by browser.url method (polling)', function() {
+ sniffer.history = false;
+ sniffer.hashchange = false;
+ browser.onUrlChange(callback);
+ browser.url('http://new.com');
+
+ fakeWindow.setTimeout.flush();
+ expect(callback).not.toHaveBeenCalled();
+ });
+
+ it('should not fire urlChange if changed by browser.url method (hashchange)', function() {
+ sniffer.history = false;
+ sniffer.hashchange = true;
+ browser.onUrlChange(callback);
+ browser.url('http://new.com');
+
+ fakeWindow.fire('hashchange');
+ expect(callback).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('addJs', function() {
+ it('should append a script tag to body', function() {
+ browser.addJs('http://localhost/bar.js');
+ expect(scripts.length).toBe(1);
+ expect(scripts[0].src).toBe('http://localhost/bar.js');
+ expect(scripts[0].id).toBe('');
+ });
+
+ it('should return the appended script element', function() {
+ var script = browser.addJs('http://localhost/bar.js');
+ expect(script).toBe(scripts[0]);
+ });
+ });
+
+ describe('baseHref', function() {
+ var jqDocHead;
+
+ function setDocumentBaseHrefTo(href) {
+ clearDocumentBaseHref();
+ jqDocHead.append('A<a>B</a>C
');
+ var text = element.contents();
+ expect(text[0].nodeName).toEqual('#text');
+ text = $compile(text)($rootScope);
+ expect(lowercase(text[0].nodeName)).toEqual('span');
+ expect(element.find('span').text()).toEqual('ABC');
+ }));
+
+ describe('multiple directives per element', function() {
+ it('should allow multiple directives per element', inject(function($compile, $rootScope, log){
+ element = $compile(
+ '')
+ ($rootScope);
+ expect(element.text()).toEqual('Hello angular');
+ expect(log).toEqual('H; M; L');
+ }));
+
+
+ it('should recurse to children', inject(function($compile, $rootScope){
+ element = $compile('01234
')($rootScope);
+ expect(element.text()).toEqual('0hello2angular4');
+ }));
+
+
+ it('should allow directives in classes', inject(function($compile, $rootScope, log) {
+ element = $compile('')($rootScope);
+ expect(element.html()).toEqual('Hello angular');
+ expect(log).toEqual('123');
+ }));
+
+
+ it('should ignore not set CSS classes on SVG elements', inject(function($compile, $rootScope, log) {
+ if (!window.SVGElement) return;
+ // According to spec SVG element className property is readonly, but only FF
+ // implements it this way which causes compile exceptions.
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('1');
+ }));
+
+
+ it('should allow directives in comments', inject(
+ function($compile, $rootScope, log) {
+ element = $compile('01
')($rootScope);
+ expect(log).toEqual('angular');
+ }
+ ));
+
+
+ it('should receive scope, element, and attributes', function() {
+ var injector;
+ module(function($compileProvider) {
+ $compileProvider.directive('log', function($injector, $rootScope) {
+ injector = $injector;
+ return {
+ restrict: 'CA',
+ compile: function(element, templateAttr) {
+ expect(typeof templateAttr.$normalize).toBe('function');
+ expect(typeof templateAttr.$set).toBe('function');
+ expect(isElement(templateAttr.$element)).toBeTruthy();
+ expect(element.text()).toEqual('unlinked');
+ expect(templateAttr.exp).toEqual('abc');
+ expect(templateAttr.aa).toEqual('A');
+ expect(templateAttr.bb).toEqual('B');
+ expect(templateAttr.cc).toEqual('C');
+ return function(scope, element, attr) {
+ expect(element.text()).toEqual('unlinked');
+ expect(attr).toBe(templateAttr);
+ expect(scope).toEqual($rootScope);
+ element.text('worked');
+ }
+ }
+ };
+ });
+ });
+ inject(function($rootScope, $compile, $injector) {
+ element = $compile(
+ 'unlinked
')($rootScope);
+ expect(element.text()).toEqual('worked');
+ expect(injector).toBe($injector); // verify that directive is injectable
+ });
+ });
+ });
+
+ describe('error handling', function() {
+
+ it('should handle exceptions', function() {
+ module(function($compileProvider, $exceptionHandlerProvider) {
+ $exceptionHandlerProvider.mode('log');
+ $compileProvider.directive('factoryError', function() { throw 'FactoryError'; });
+ $compileProvider.directive('templateError',
+ valueFn({ compile: function() { throw 'TemplateError'; } }));
+ $compileProvider.directive('linkingError',
+ valueFn(function() { throw 'LinkingError'; }));
+ });
+ inject(function($rootScope, $compile, $exceptionHandler) {
+ element = $compile('')($rootScope);
+ expect($exceptionHandler.errors[0]).toEqual('FactoryError');
+ expect($exceptionHandler.errors[1][0]).toEqual('TemplateError');
+ expect(ie($exceptionHandler.errors[1][1])).
+ toEqual('');
+ expect($exceptionHandler.errors[2][0]).toEqual('LinkingError');
+ expect(ie($exceptionHandler.errors[2][1])).
+ toEqual('
');
+
+
+ // crazy stuff to make IE happy
+ function ie(text) {
+ var list = [],
+ parts, elementName;
+
+ parts = lowercase(text).
+ replace('<', '').
+ replace('>', '').
+ split(' ');
+ elementName = parts.shift();
+ parts.sort();
+ parts.unshift(elementName);
+ forEach(parts, function(value, key){
+ if (value.substring(0,3) == 'ng-') {
+ } else {
+ value = value.replace('=""', '');
+ var match = value.match(/=(.*)/);
+ if (match && match[1].charAt(0) != '"') {
+ value = value.replace(/=(.*)/, '="$1"');
+ }
+ list.push(value);
+ }
+ });
+ return '<' + list.join(' ') + '>';
+ }
+ });
+ });
+
+
+ it('should prevent changing of structure', inject(
+ function($compile, $rootScope){
+ element = jqLite("
");
+ var linkFn = $compile(element);
+ element.append("");
+ expect(function() {
+ linkFn($rootScope);
+ }).toThrow('Template changed structure!');
+ }
+ ));
+ });
+
+ describe('compiler control', function() {
+ describe('priority', function() {
+ it('should honor priority', inject(function($compile, $rootScope, log){
+ element = $compile(
+ '')
+ ($rootScope);
+ expect(log).toEqual('H; M; L');
+ }));
+ });
+
+
+ describe('terminal', function() {
+
+ it('should prevent further directives from running', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(element.text()).toEqual('OK');
+ }
+ ));
+
+
+ it('should prevent further directives from running, but finish current priority level',
+ inject(function($rootScope, $compile, log) {
+ // class is processed after attrs, so putting log in class will put it after
+ // the stop in the current level. This proves that the log runs after stop
+ element = $compile(
+ '')($rootScope);
+ expect(element.text()).toEqual('OK');
+ expect(log.toArray().sort()).toEqual(['HIGH', 'MEDIUM']);
+ })
+ );
+ });
+
+
+ describe('restrict', function() {
+
+ it('should allow restriction of attributes', function() {
+ module(function($compileProvider, $provide) {
+ forEach({div:'E', attr:'A', clazz:'C', all:'EAC'}, function(restrict, name) {
+ $compileProvider.directive(name, function(log) {
+ return {
+ restrict: restrict,
+ compile: valueFn(function(scope, element, attr) {
+ log(name);
+ })
+ };
+ });
+ });
+ });
+ inject(function($rootScope, $compile, log) {
+ dealoc($compile('')($rootScope));
+ expect(log).toEqual('');
+ log.reset();
+
+ dealoc($compile('')($rootScope));
+ expect(log).toEqual('div');
+ log.reset();
+
+ dealoc($compile('
Hello: <>
',
+ compile: function(element, attr) {
+ attr.$set('compiled', 'COMPILED');
+ expect(element).toBe(attr.$element);
+ }
+ }));
+ $compileProvider.directive('append', valueFn({
+ restrict: 'CAM',
+ template: 'Hello: <>
',
+ compile: function(element, attr) {
+ attr.$set('compiled', 'COMPILED');
+ expect(element).toBe(attr.$element);
+ }
+ }));
+ }));
+
+
+ it('should replace element with template', inject(function($compile, $rootScope) {
+ element = $compile('content
')($rootScope);
+ expect(element.text()).toEqual('Hello: content');
+ expect(element.find('div').attr('compiled')).toEqual('COMPILED');
+ }));
+
+
+ it('should append element with template', inject(function($compile, $rootScope) {
+ element = $compile('
content
')($rootScope);
+ expect(element.text()).toEqual('Hello: content');
+ expect(element.find('div').attr('compiled')).toEqual('COMPILED');
+ }));
+
+
+ it('should compile replace template', inject(function($compile, $rootScope, log) {
+ element = $compile('
{{ "angular" }}
')
+ ($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('Hello: angular');
+ // HIGH goes after MEDIUM since it executes as part of replaced template
+ expect(log).toEqual('MEDIUM; HIGH; LOG');
+ }));
+
+
+ it('should compile append template', inject(function($compile, $rootScope, log) {
+ element = $compile('
{{ "angular" }}
')
+ ($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('Hello: angular');
+ expect(log).toEqual('HIGH; LOG; MEDIUM');
+ }));
+
+
+ it('should merge attributes including style attr', inject(function($compile, $rootScope) {
+ element = $compile(
+ '" / >').
+ toEqual('');
+ });
+
+ it('should ignore back slash as escape', function() {
+ expectHTML('![xxx\\]( "><script>....")
').
+ toEqual('![xxx\\]( "><script>....")
');
+ });
+
+ it('should ignore object attributes', function() {
+ expectHTML(':)').
+ toEqual(':)');
+ expectHTML(':) ').
+ toEqual('');
+ });
+
+ describe('htmlSanitizerWriter', function() {
+ var writer, html;
+ beforeEach(function() {
+ html = '';
+ writer = htmlSanitizeWriter({push:function(text){html+=text;}});
+ });
+
+ it('should write basic HTML', function() {
+ writer.chars('before');
+ writer.start('div', {rel:'123'}, false);
+ writer.chars('in');
+ writer.end('div');
+ writer.chars('after');
+
+ expect(html).toEqual('before
')
+ ($rootScope);
+ var div = element.find('div');
+ expect(div.hasClass('medium-log')).toBe(true);
+ expect(div.hasClass('log')).toBe(true);
+ expect(div.css('width')).toBe('10px');
+ expect(div.css('height')).toBe('20px');
+ expect(div.attr('replace')).toEqual('');
+ expect(div.attr('high-log')).toEqual('');
+ }));
+
+ it('should prevent multiple templates per element', inject(function($compile) {
+ try {
+ $compile('> ');
+ element = jqLite('{{1+2}}');
+ $compile(element)($rootScope);
+
+ $httpBackend.flush();
+ expect(element.text()).toEqual('3==3');
+ }
+ ));
+
+
+ it('should work when widget is a repeater', inject(
+ function($compile, $httpBackend, $rootScope) {
+ $httpBackend.expect('GET', 'hello.html').respond('i=<>; ');
+ element = jqLite('' +
+ '' +
+ '' +
+ '' +
+ ' ' +
+ ' ');
+ $compile(doc)(scope);
+
+ var parent = scope.parent,
+ child = scope.child,
+ inputA = child.inputA,
+ inputB = child.inputB;
+
+ inputA.$setValidity('MyError', false);
+ inputB.$setValidity('MyError', false);
+ expect(parent.$error.MyError).toEqual([child]);
+ expect(child.$error.MyError).toEqual([inputA, inputB]);
+
+ inputA.$setValidity('MyError', true);
+ expect(parent.$error.MyError).toEqual([child]);
+ expect(child.$error.MyError).toEqual([inputB]);
+
+ inputB.$setValidity('MyError', true);
+ expect(parent.$error.MyError).toBe(false);
+ expect(child.$error.MyError).toBe(false);
+ });
+
+
+ it('should deregister a child form when its DOM is removed', function() {
+ doc = jqLite(
+ '');
+ $compile(doc)(scope);
+ scope.$apply();
+
+ var parent = scope.parent,
+ child = scope.child;
+
+ expect(parent).toBeDefined();
+ expect(child).toBeDefined();
+ expect(parent.$error.required).toEqual([child]);
+ doc.children().remove(); //remove child
+
+ expect(parent.child).toBeUndefined();
+ expect(scope.child).toBeUndefined();
+ expect(parent.$error.required).toBe(false);
+ });
+
+
+ it('should chain nested forms in repeater', function() {
+ doc = jqLite(
+ '' +
+ '' +
+ '' +
+ ' ' +
+ ' ');
+ $compile(doc)(scope);
+
+ scope.$apply(function() {
+ scope.forms = [1];
+ });
+
+ var parent = scope.parent;
+ var child = doc.find('input').scope().child;
+ var input = child.text;
+
+ expect(parent).toBeDefined();
+ expect(child).toBeDefined();
+ expect(input).toBeDefined();
+
+ input.$setValidity('myRule', false);
+ expect(input.$error.myRule).toEqual(true);
+ expect(child.$error.myRule).toEqual([input]);
+ expect(parent.$error.myRule).toEqual([child]);
+
+ input.$setValidity('myRule', true);
+ expect(parent.$error.myRule).toBe(false);
+ expect(child.$error.myRule).toBe(false);
+ });
+ })
+
+
+ describe('validation', function() {
+
+ beforeEach(function() {
+ doc = $compile(
+ '')(scope);
+
+ scope.$digest();
+ });
+
+
+ it('should have ng-valid/ng-invalid css class', function() {
+ expect(doc).toBeValid();
+
+ control.$setValidity('error', false);
+ expect(doc).toBeInvalid();
+ expect(doc.hasClass('ng-valid-error')).toBe(false);
+ expect(doc.hasClass('ng-invalid-error')).toBe(true);
+
+ control.$setValidity('another', false);
+ expect(doc.hasClass('ng-valid-error')).toBe(false);
+ expect(doc.hasClass('ng-invalid-error')).toBe(true);
+ expect(doc.hasClass('ng-valid-another')).toBe(false);
+ expect(doc.hasClass('ng-invalid-another')).toBe(true);
+
+ control.$setValidity('error', true);
+ expect(doc).toBeInvalid();
+ expect(doc.hasClass('ng-valid-error')).toBe(true);
+ expect(doc.hasClass('ng-invalid-error')).toBe(false);
+ expect(doc.hasClass('ng-valid-another')).toBe(false);
+ expect(doc.hasClass('ng-invalid-another')).toBe(true);
+
+ control.$setValidity('another', true);
+ expect(doc).toBeValid();
+ expect(doc.hasClass('ng-valid-error')).toBe(true);
+ expect(doc.hasClass('ng-invalid-error')).toBe(false);
+ expect(doc.hasClass('ng-valid-another')).toBe(true);
+ expect(doc.hasClass('ng-invalid-another')).toBe(false);
+ });
+
+
+ it('should have ng-pristine/ng-dirty css class', function() {
+ expect(doc).toBePristine();
+
+ control.$setViewValue('');
+ scope.$apply();
+ expect(doc).toBeDirty();
+ });
+ });
+});
diff --git a/test/ng/directive/inputSpec.js b/test/ng/directive/inputSpec.js
new file mode 100644
index 00000000..e5f083b3
--- /dev/null
+++ b/test/ng/directive/inputSpec.js
@@ -0,0 +1,1119 @@
+'use strict';
+
+describe('NgModelController', function() {
+ var ctrl, scope, ngModelAccessor, element, parentFormCtrl;
+
+ beforeEach(inject(function($rootScope, $controller) {
+ var attrs = {name: 'testAlias'};
+
+ parentFormCtrl = {
+ $setValidity: jasmine.createSpy('$setValidity'),
+ $setDirty: jasmine.createSpy('$setDirty')
+ }
+
+ element = jqLite('');
+ element.data('$formController', parentFormCtrl);
+
+ scope = $rootScope;
+ ngModelAccessor = jasmine.createSpy('ngModel accessor');
+ ctrl = $controller(NgModelController, {
+ $scope: scope, $element: element.find('input'), ngModel: ngModelAccessor, $attrs: attrs
+ });
+ // mock accessor (locals)
+ ngModelAccessor.andCallFake(function(val) {
+ if (isDefined(val)) scope.value = val;
+ return scope.value;
+ });
+ }));
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should init the properties', function() {
+ expect(ctrl.$dirty).toBe(false);
+ expect(ctrl.$pristine).toBe(true);
+ expect(ctrl.$valid).toBe(true);
+ expect(ctrl.$invalid).toBe(false);
+
+ expect(ctrl.$viewValue).toBeDefined();
+ expect(ctrl.$modelValue).toBeDefined();
+
+ expect(ctrl.$formatters).toEqual([]);
+ expect(ctrl.$parsers).toEqual([]);
+
+ expect(ctrl.$name).toBe('testAlias');
+ });
+
+
+ describe('setValidity', function() {
+
+ it('should propagate invalid to the parent form only when valid', function() {
+ expect(parentFormCtrl.$setValidity).not.toHaveBeenCalled();
+ ctrl.$setValidity('ERROR', false);
+ expect(parentFormCtrl.$setValidity).toHaveBeenCalledOnceWith('ERROR', false, ctrl);
+
+ parentFormCtrl.$setValidity.reset();
+ ctrl.$setValidity('ERROR', false);
+ expect(parentFormCtrl.$setValidity).not.toHaveBeenCalled();
+ });
+
+
+ it('should set and unset the error', function() {
+ ctrl.$setValidity('required', false);
+ expect(ctrl.$error.required).toBe(true);
+
+ ctrl.$setValidity('required', true);
+ expect(ctrl.$error.required).toBe(false);
+ });
+
+
+ it('should set valid/invalid', function() {
+ ctrl.$setValidity('first', false);
+ expect(ctrl.$valid).toBe(false);
+ expect(ctrl.$invalid).toBe(true);
+
+ ctrl.$setValidity('second', false);
+ expect(ctrl.$valid).toBe(false);
+ expect(ctrl.$invalid).toBe(true);
+
+ ctrl.$setValidity('second', true);
+ expect(ctrl.$valid).toBe(false);
+ expect(ctrl.$invalid).toBe(true);
+
+ ctrl.$setValidity('first', true);
+ expect(ctrl.$valid).toBe(true);
+ expect(ctrl.$invalid).toBe(false);
+ });
+
+
+ it('should emit $valid only when $invalid', function() {
+ ctrl.$setValidity('error', true);
+ expect(parentFormCtrl.$setValidity).toHaveBeenCalledOnceWith('error', true, ctrl);
+ parentFormCtrl.$setValidity.reset();
+
+ ctrl.$setValidity('error', false);
+ expect(parentFormCtrl.$setValidity).toHaveBeenCalledOnceWith('error', false, ctrl);
+ parentFormCtrl.$setValidity.reset();
+ ctrl.$setValidity('error', true);
+ expect(parentFormCtrl.$setValidity).toHaveBeenCalledOnceWith('error', true, ctrl);
+ });
+ });
+
+
+ describe('view -> model', function() {
+
+ it('should set the value to $viewValue', function() {
+ ctrl.$setViewValue('some-val');
+ expect(ctrl.$viewValue).toBe('some-val');
+ });
+
+
+ it('should pipeline all registered parsers and set result to $modelValue', function() {
+ var log = [];
+
+ ctrl.$parsers.push(function(value) {
+ log.push(value);
+ return value + '-a';
+ });
+
+ ctrl.$parsers.push(function(value) {
+ log.push(value);
+ return value + '-b';
+ });
+
+ ctrl.$setViewValue('init');
+ expect(log).toEqual(['init', 'init-a']);
+ expect(ctrl.$modelValue).toBe('init-a-b');
+ });
+
+
+ it('should fire viewChangeListeners when the value changes in the view (even if invalid)',
+ function() {
+ var spy = jasmine.createSpy('viewChangeListener');
+ ctrl.$viewChangeListeners.push(spy);
+ ctrl.$setViewValue('val');
+ expect(spy).toHaveBeenCalledOnce();
+ spy.reset();
+
+ // invalid
+ ctrl.$parsers.push(function() {return undefined;});
+ ctrl.$setViewValue('val');
+ expect(spy).toHaveBeenCalledOnce();
+ });
+
+
+ it('should reset the model when the view is invalid', function() {
+ ctrl.$setViewValue('aaaa');
+ expect(ctrl.$modelValue).toBe('aaaa');
+
+ // add a validator that will make any input invalid
+ ctrl.$parsers.push(function() {return undefined;});
+ expect(ctrl.$modelValue).toBe('aaaa');
+ ctrl.$setViewValue('bbbb');
+ expect(ctrl.$modelValue).toBeUndefined();
+ });
+
+
+ it('should call parentForm.$setDirty only when pristine', function() {
+ ctrl.$setViewValue('');
+ expect(ctrl.$pristine).toBe(false);
+ expect(ctrl.$dirty).toBe(true);
+ expect(parentFormCtrl.$setDirty).toHaveBeenCalledOnce();
+
+ parentFormCtrl.$setDirty.reset();
+ ctrl.$setViewValue('');
+ expect(ctrl.$pristine).toBe(false);
+ expect(ctrl.$dirty).toBe(true);
+ expect(parentFormCtrl.$setDirty).not.toHaveBeenCalled();
+ });
+ });
+
+
+ describe('model -> view', function() {
+
+ it('should set the value to $modelValue', function() {
+ scope.$apply(function() {
+ scope.value = 10;
+ });
+ expect(ctrl.$modelValue).toBe(10);
+ });
+
+
+ it('should pipeline all registered formatters in reversed order and set result to $viewValue',
+ function() {
+ var log = [];
+
+ ctrl.$formatters.unshift(function(value) {
+ log.push(value);
+ return value + 2;
+ });
+
+ ctrl.$formatters.unshift(function(value) {
+ log.push(value);
+ return value + '';
+ });
+
+ scope.$apply(function() {
+ scope.value = 3;
+ });
+ expect(log).toEqual([3, 5]);
+ expect(ctrl.$viewValue).toBe('5');
+ });
+
+
+ it('should $render only if value changed', function() {
+ spyOn(ctrl, '$render');
+
+ scope.$apply(function() {
+ scope.value = 3;
+ });
+ expect(ctrl.$render).toHaveBeenCalledOnce();
+ ctrl.$render.reset();
+
+ ctrl.$formatters.push(function() {return 3;});
+ scope.$apply(function() {
+ scope.value = 5;
+ });
+ expect(ctrl.$render).not.toHaveBeenCalled();
+ });
+
+
+ it('should clear the view even if invalid', function() {
+ spyOn(ctrl, '$render');
+
+ ctrl.$formatters.push(function() {return undefined;});
+ scope.$apply(function() {
+ scope.value = 5;
+ });
+ expect(ctrl.$render).toHaveBeenCalledOnce();
+ });
+ });
+});
+
+describe('ng-model', function() {
+
+ it('should set css classes (ng-valid, ng-invalid, ng-pristine, ng-dirty)',
+ inject(function($compile, $rootScope) {
+ var element = $compile('')($rootScope);
+
+ $rootScope.$digest();
+ expect(element).toBeValid();
+ expect(element).toBePristine();
+ expect(element.hasClass('ng-valid-email')).toBe(true);
+ expect(element.hasClass('ng-invalid-email')).toBe(false);
+
+ $rootScope.$apply(function() {
+ $rootScope.value = 'invalid-email';
+ });
+ expect(element).toBeInvalid();
+ expect(element).toBePristine();
+ expect(element.hasClass('ng-valid-email')).toBe(false);
+ expect(element.hasClass('ng-invalid-email')).toBe(true);
+
+ element.val('invalid-again');
+ browserTrigger(element, 'blur');
+ expect(element).toBeInvalid();
+ expect(element).toBeDirty();
+ expect(element.hasClass('ng-valid-email')).toBe(false);
+ expect(element.hasClass('ng-invalid-email')).toBe(true);
+
+ element.val('vojta@google.com');
+ browserTrigger(element, 'blur');
+ expect(element).toBeValid();
+ expect(element).toBeDirty();
+ expect(element.hasClass('ng-valid-email')).toBe(true);
+ expect(element.hasClass('ng-invalid-email')).toBe(false);
+
+ dealoc(element);
+ }));
+
+
+ it('should set invalid classes on init', inject(function($compile, $rootScope) {
+ var element = $compile('')($rootScope);
+ $rootScope.$digest();
+
+ expect(element).toBeInvalid();
+ expect(element).toHaveClass('ng-invalid-required');
+ }));
+});
+
+
+describe('input', function() {
+ var formElm, inputElm, scope, $compile;
+
+ function compileInput(inputHtml) {
+ formElm = jqLite('');
+ inputElm = formElm.find('input');
+ $compile(formElm)(scope);
+ }
+
+ function changeInputValueTo(value) {
+ inputElm.val(value);
+ browserTrigger(inputElm, 'blur');
+ }
+
+ beforeEach(inject(function($injector) {
+ $compile = $injector.get('$compile');
+ scope = $injector.get('$rootScope');
+ }));
+
+ afterEach(function() {
+ dealoc(formElm);
+ });
+
+
+ it('should bind to a model', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.name = 'misko';
+ });
+
+ expect(inputElm.val()).toBe('misko');
+ });
+
+
+ it('should not set readonly or disabled property on ie7', function() {
+ this.addMatchers({
+ toBeOff: function(attributeName) {
+ var actualValue = this.actual.attr(attributeName);
+ this.message = function() {
+ return "Attribute '" + attributeName + "' expected to be off but was '" + actualValue +
+ "' in: " + angular.mock.dump(this.actual);
+ }
+
+ return !actualValue || actualValue == 'false';
+ }
+ });
+
+ compileInput('');
+ expect(inputElm.prop('readOnly')).toBe(false);
+ expect(inputElm.prop('disabled')).toBe(false);
+
+ expect(inputElm).toBeOff('readOnly');
+ expect(inputElm).toBeOff('readonly');
+ expect(inputElm).toBeOff('disabled');
+ });
+
+
+ it('should cleanup it self from the parent form', function() {
+ compileInput('');
+
+ scope.$apply();
+ expect(scope.form.$error.required.length).toBe(1);
+
+ inputElm.remove();
+ expect(scope.form.$error.required).toBe(false);
+ });
+
+
+ it('should update the model on "blur" event', function() {
+ compileInput('');
+
+ changeInputValueTo('adam');
+ expect(scope.name).toEqual('adam');
+ });
+
+
+ it('should update the model and trim the value', function() {
+ compileInput('');
+
+ changeInputValueTo(' a ');
+ expect(scope.name).toEqual('a');
+ });
+
+
+ it('should allow complex reference binding', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.obj = { abc: { name: 'Misko'} };
+ });
+ expect(inputElm.val()).toEqual('Misko');
+ });
+
+
+ it('should ignore input without ng-model attr', function() {
+ compileInput('');
+
+ browserTrigger(inputElm, 'blur');
+ expect(inputElm.hasClass('ng-valid')).toBe(false);
+ expect(inputElm.hasClass('ng-invalid')).toBe(false);
+ expect(inputElm.hasClass('ng-pristine')).toBe(false);
+ expect(inputElm.hasClass('ng-dirty')).toBe(false);
+ });
+
+
+ it('should report error on assignment error', function() {
+ expect(function() {
+ compileInput('');
+ scope.$digest();
+ }).toThrow("Syntax Error: Token '''' is an unexpected token at column 7 of the expression [throw ''] starting at [''].");
+ });
+
+
+ it("should render as blank if null", function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.age = null;
+ });
+
+ expect(scope.age).toBeNull();
+ expect(inputElm.val()).toEqual('');
+ });
+
+
+ it('should render 0 even if it is a number', function() {
+ compileInput('');
+ scope.$apply(function() {
+ scope.value = 0;
+ });
+
+ expect(inputElm.val()).toBe('0');
+ });
+
+
+ describe('pattern', function() {
+
+ it('should validate in-lined pattern', function() {
+ compileInput('');
+ scope.$digest();
+
+ changeInputValueTo('x000-00-0000x');
+ expect(inputElm).toBeInvalid();
+
+ changeInputValueTo('000-00-0000');
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('000-00-0000x');
+ expect(inputElm).toBeInvalid();
+
+ changeInputValueTo('123-45-6789');
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('x');
+ expect(inputElm).toBeInvalid();
+ });
+
+
+ it('should validate pattern from scope', function() {
+ compileInput('');
+ scope.regexp = /^\d\d\d-\d\d-\d\d\d\d$/;
+ scope.$digest();
+
+ changeInputValueTo('x000-00-0000x');
+ expect(inputElm).toBeInvalid();
+
+ changeInputValueTo('000-00-0000');
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('000-00-0000x');
+ expect(inputElm).toBeInvalid();
+
+ changeInputValueTo('123-45-6789');
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('x');
+ expect(inputElm).toBeInvalid();
+
+ scope.regexp = /abc?/;
+
+ changeInputValueTo('ab');
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('xx');
+ expect(inputElm).toBeInvalid();
+ });
+
+
+ xit('should throw an error when scope pattern can\'t be found', function() {
+ compileInput('');
+
+ expect(function() { changeInputValueTo('xx'); }).
+ toThrow('Expected fooRegexp to be a RegExp but was undefined');
+ });
+ });
+
+
+ describe('minlength', function() {
+
+ it('should invalid shorter than given minlenght', function() {
+ compileInput('');
+
+ changeInputValueTo('aa');
+ expect(scope.value).toBeUndefined();
+
+ changeInputValueTo('aaa');
+ expect(scope.value).toBe('aaa');
+ });
+ });
+
+
+ describe('maxlength', function() {
+
+ it('should invalid shorter than given maxlenght', function() {
+ compileInput('');
+
+ changeInputValueTo('aaaaaaaa');
+ expect(scope.value).toBeUndefined();
+
+ changeInputValueTo('aaa');
+ expect(scope.value).toBe('aaa');
+ });
+ });
+
+
+ // INPUT TYPES
+
+ describe('number', function() {
+
+ it('should reset the model if view is invalid', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.age = 123;
+ });
+ expect(inputElm.val()).toBe('123');
+
+ try {
+ // to allow non-number values, we have to change type so that
+ // the browser which have number validation will not interfere with
+ // this test. IE8 won't allow it hence the catch.
+ inputElm[0].setAttribute('type', 'text');
+ } catch (e) {}
+
+ changeInputValueTo('123X');
+ expect(inputElm.val()).toBe('123X');
+ expect(scope.age).toBeUndefined();
+ expect(inputElm).toBeInvalid();
+ });
+
+
+ it('should render as blank if null', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.age = null;
+ });
+
+ expect(scope.age).toBeNull();
+ expect(inputElm.val()).toEqual('');
+ });
+
+
+ it('should come up blank when no value specified', function() {
+ compileInput('');
+
+ scope.$digest();
+ expect(inputElm.val()).toBe('');
+
+ scope.$apply(function() {
+ scope.age = null;
+ });
+
+ expect(scope.age).toBeNull();
+ expect(inputElm.val()).toBe('');
+ });
+
+
+ it('should parse empty string to null', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.age = 10;
+ });
+
+ changeInputValueTo('');
+ expect(scope.age).toBeNull();
+ expect(inputElm).toBeValid();
+ });
+
+
+ describe('min', function() {
+
+ it('should validate', function() {
+ compileInput('');
+ scope.$digest();
+
+ changeInputValueTo('1');
+ expect(inputElm).toBeInvalid();
+ expect(scope.value).toBeFalsy();
+ expect(scope.form.alias.$error.min).toBeTruthy();
+
+ changeInputValueTo('100');
+ expect(inputElm).toBeValid();
+ expect(scope.value).toBe(100);
+ expect(scope.form.alias.$error.min).toBeFalsy();
+ });
+ });
+
+
+ describe('max', function() {
+
+ it('should validate', function() {
+ compileInput('');
+ scope.$digest();
+
+ changeInputValueTo('20');
+ expect(inputElm).toBeInvalid();
+ expect(scope.value).toBeFalsy();
+ expect(scope.form.alias.$error.max).toBeTruthy();
+
+ changeInputValueTo('0');
+ expect(inputElm).toBeValid();
+ expect(scope.value).toBe(0);
+ expect(scope.form.alias.$error.max).toBeFalsy();
+ });
+ });
+
+
+ describe('required', function() {
+
+ it('should be valid even if value is 0', function() {
+ compileInput('');
+
+ changeInputValueTo('0');
+ expect(inputElm).toBeValid();
+ expect(scope.value).toBe(0);
+ expect(scope.form.alias.$error.required).toBeFalsy();
+ });
+
+ it('should be valid even if value 0 is set from model', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.value = 0;
+ });
+
+ expect(inputElm).toBeValid();
+ expect(inputElm.val()).toBe('0')
+ expect(scope.form.alias.$error.required).toBeFalsy();
+ });
+ });
+ });
+
+ describe('email', function() {
+
+ it('should validate e-mail', function() {
+ compileInput('');
+
+ var widget = scope.form.alias;
+ changeInputValueTo('vojta@google.com');
+
+ expect(scope.email).toBe('vojta@google.com');
+ expect(inputElm).toBeValid();
+ expect(widget.$error.email).toBe(false);
+
+ changeInputValueTo('invalid@');
+ expect(scope.email).toBeUndefined();
+ expect(inputElm).toBeInvalid();
+ expect(widget.$error.email).toBeTruthy();
+ });
+
+
+ describe('EMAIL_REGEXP', function() {
+
+ it('should validate email', function() {
+ expect(EMAIL_REGEXP.test('a@b.com')).toBe(true);
+ expect(EMAIL_REGEXP.test('a@B.c')).toBe(false);
+ });
+ });
+ });
+
+
+ describe('url', function() {
+
+ it('should validate url', function() {
+ compileInput('');
+ var widget = scope.form.alias;
+
+ changeInputValueTo('http://www.something.com');
+ expect(scope.url).toBe('http://www.something.com');
+ expect(inputElm).toBeValid();
+ expect(widget.$error.url).toBe(false);
+
+ changeInputValueTo('invalid.com');
+ expect(scope.url).toBeUndefined();
+ expect(inputElm).toBeInvalid();
+ expect(widget.$error.url).toBeTruthy();
+ });
+
+
+ describe('URL_REGEXP', function() {
+
+ it('should validate url', function() {
+ expect(URL_REGEXP.test('http://server:123/path')).toBe(true);
+ expect(URL_REGEXP.test('a@B.c')).toBe(false);
+ });
+ });
+ });
+
+
+ describe('radio', function() {
+
+ it('should update the model', function() {
+ compileInput(
+ '' +
+ '' +
+ '');
+
+ scope.$apply(function() {
+ scope.color = 'white';
+ });
+ expect(inputElm[0].checked).toBe(true);
+ expect(inputElm[1].checked).toBe(false);
+ expect(inputElm[2].checked).toBe(false);
+
+ scope.$apply(function() {
+ scope.color = 'red';
+ });
+ expect(inputElm[0].checked).toBe(false);
+ expect(inputElm[1].checked).toBe(true);
+ expect(inputElm[2].checked).toBe(false);
+
+ browserTrigger(inputElm[2]);
+ expect(scope.color).toBe('blue');
+ });
+
+
+ it('should allow {{expr}} as value', function() {
+ scope.some = 11;
+ compileInput(
+ '' +
+ '');
+
+ scope.$apply(function() {
+ scope.value = 'blue';
+ scope.some = 'blue';
+ scope.other = 'red';
+ });
+
+ expect(inputElm[0].checked).toBe(true);
+ expect(inputElm[1].checked).toBe(false);
+
+ browserTrigger(inputElm[1]);
+ expect(scope.value).toBe('red');
+
+ scope.$apply(function() {
+ scope.other = 'non-red';
+ });
+
+ expect(inputElm[0].checked).toBe(false);
+ expect(inputElm[1].checked).toBe(false);
+ });
+ });
+
+
+ describe('checkbox', function() {
+
+ it('should ignore checkbox without ng-model attr', function() {
+ compileInput('');
+
+ browserTrigger(inputElm, 'blur');
+ expect(inputElm.hasClass('ng-valid')).toBe(false);
+ expect(inputElm.hasClass('ng-invalid')).toBe(false);
+ expect(inputElm.hasClass('ng-pristine')).toBe(false);
+ expect(inputElm.hasClass('ng-dirty')).toBe(false);
+ });
+
+
+ it('should format booleans', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.name = false;
+ });
+ expect(inputElm[0].checked).toBe(false);
+
+ scope.$apply(function() {
+ scope.name = true;
+ });
+ expect(inputElm[0].checked).toBe(true);
+ });
+
+
+ it('should support type="checkbox" with non-standard capitalization', function() {
+ compileInput('');
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.checkbox).toBe(true);
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.checkbox).toBe(false);
+ });
+
+
+ it('should allow custom enumeration', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.name = 'y';
+ });
+ expect(inputElm[0].checked).toBe(true);
+
+ scope.$apply(function() {
+ scope.name = 'n';
+ });
+ expect(inputElm[0].checked).toBe(false);
+
+ scope.$apply(function() {
+ scope.name = 'something else';
+ });
+ expect(inputElm[0].checked).toBe(false);
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.name).toEqual('y');
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.name).toEqual('n');
+ });
+
+
+ it('should be required if false', function() {
+ compileInput('');
+
+ browserTrigger(inputElm, 'click');
+ expect(inputElm[0].checked).toBe(true);
+ expect(inputElm).toBeValid();
+
+ browserTrigger(inputElm, 'click');
+ expect(inputElm[0].checked).toBe(false);
+ expect(inputElm).toBeInvalid();
+ });
+ });
+
+
+ describe('textarea', function() {
+
+ it("should process textarea", function() {
+ compileInput('');
+ inputElm = formElm.find('textarea');
+
+ scope.$apply(function() {
+ scope.name = 'Adam';
+ });
+ expect(inputElm.val()).toEqual('Adam');
+
+ changeInputValueTo('Shyam');
+ expect(scope.name).toEqual('Shyam');
+
+ changeInputValueTo('Kai');
+ expect(scope.name).toEqual('Kai');
+ });
+
+
+ it('should ignore textarea without ng-model attr', function() {
+ compileInput('');
+ inputElm = formElm.find('textarea');
+
+ browserTrigger(inputElm, 'blur');
+ expect(inputElm.hasClass('ng-valid')).toBe(false);
+ expect(inputElm.hasClass('ng-invalid')).toBe(false);
+ expect(inputElm.hasClass('ng-pristine')).toBe(false);
+ expect(inputElm.hasClass('ng-dirty')).toBe(false);
+ });
+ });
+
+
+ describe('ng-list', function() {
+
+ it('should parse text into an array', function() {
+ compileInput('');
+
+ // model -> view
+ scope.$apply(function() {
+ scope.list = ['x', 'y', 'z'];
+ });
+ expect(inputElm.val()).toBe('x, y, z');
+
+ // view -> model
+ changeInputValueTo('1, 2, 3');
+ expect(scope.list).toEqual(['1', '2', '3']);
+ });
+
+
+ it("should not clobber text if model changes due to itself", function() {
+ // When the user types 'a,b' the 'a,' stage parses to ['a'] but if the
+ // $parseModel function runs it will change to 'a', in essence preventing
+ // the user from ever typying ','.
+ compileInput('');
+
+ changeInputValueTo('a ');
+ expect(inputElm.val()).toEqual('a ');
+ expect(scope.list).toEqual(['a']);
+
+ changeInputValueTo('a ,');
+ expect(inputElm.val()).toEqual('a ,');
+ expect(scope.list).toEqual(['a']);
+
+ changeInputValueTo('a , ');
+ expect(inputElm.val()).toEqual('a , ');
+ expect(scope.list).toEqual(['a']);
+
+ changeInputValueTo('a , b');
+ expect(inputElm.val()).toEqual('a , b');
+ expect(scope.list).toEqual(['a', 'b']);
+ });
+
+
+ xit('should require at least one item', function() {
+ compileInput('');
+
+ changeInputValueTo(' , ');
+ expect(inputElm).toBeInvalid();
+ });
+
+
+ it('should convert empty string to an empty array', function() {
+ compileInput('');
+
+ changeInputValueTo('');
+ expect(scope.list).toEqual([]);
+ });
+
+
+ it('should allow custom separator', function() {
+ compileInput('');
+
+ changeInputValueTo('a,a');
+ expect(scope.list).toEqual(['a,a']);
+
+ changeInputValueTo('a:b');
+ expect(scope.list).toEqual(['a', 'b']);
+ });
+
+
+ it('should allow regexp as a separator', function() {
+ compileInput('');
+
+ changeInputValueTo('a,b');
+ expect(scope.list).toEqual(['a', 'b']);
+
+ changeInputValueTo('a,b: c');
+ expect(scope.list).toEqual(['a', 'b', 'c']);
+ });
+ });
+
+ describe('required', function() {
+
+ it('should allow bindings on ng-required', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.required = false;
+ });
+
+ changeInputValueTo('');
+ expect(inputElm).toBeValid();
+
+
+ scope.$apply(function() {
+ scope.required = true;
+ });
+ expect(inputElm).toBeInvalid();
+
+ scope.$apply(function() {
+ scope.value = 'some';
+ });
+ expect(inputElm).toBeValid();
+
+ changeInputValueTo('');
+ expect(inputElm).toBeInvalid();
+
+ scope.$apply(function() {
+ scope.required = false;
+ });
+ expect(inputElm).toBeValid();
+ });
+
+
+ it('should invalid initial value with bound required', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.required = true;
+ });
+
+ expect(inputElm).toBeInvalid();
+ });
+
+
+ it('should be $invalid but $pristine if not touched', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.name = '';
+ });
+
+ expect(inputElm).toBeInvalid();
+ expect(inputElm).toBePristine();
+
+ changeInputValueTo('');
+ expect(inputElm).toBeInvalid();
+ expect(inputElm).toBeDirty();
+ });
+
+
+ it('should allow empty string if not required', function() {
+ compileInput('');
+ changeInputValueTo('a');
+ changeInputValueTo('');
+ expect(scope.foo).toBe('');
+ });
+
+
+ it('should set $invalid when model undefined', function() {
+ compileInput('');
+ scope.$digest();
+ expect(inputElm).toBeInvalid();
+ })
+ });
+
+
+ describe('ng-change', function() {
+
+ it('should $eval expression after new value is set in the model', function() {
+ compileInput('');
+
+ scope.change = jasmine.createSpy('change').andCallFake(function() {
+ expect(scope.value).toBe('new value');
+ });
+
+ changeInputValueTo('new value');
+ expect(scope.change).toHaveBeenCalledOnce();
+ });
+
+ it('should not $eval the expression if changed from model', function() {
+ compileInput('');
+
+ scope.change = jasmine.createSpy('change');
+ scope.$apply(function() {
+ scope.value = true;
+ });
+
+ expect(scope.change).not.toHaveBeenCalled();
+ });
+
+
+ it('should $eval ng-change expression on checkbox', function() {
+ compileInput('');
+
+ scope.changeFn = jasmine.createSpy('changeFn');
+ scope.$digest();
+ expect(scope.changeFn).not.toHaveBeenCalled();
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.changeFn).toHaveBeenCalledOnce();
+ });
+ });
+
+
+ describe('ng-model-instant', function() {
+
+ it('should bind keydown, change, input events', inject(function($browser) {
+ compileInput('');
+
+ inputElm.val('value1');
+ browserTrigger(inputElm, 'keydown');
+
+ // should be async (because of keydown)
+ expect(scope.value).toBeUndefined();
+
+ $browser.defer.flush();
+ expect(scope.value).toBe('value1');
+
+ inputElm.val('value2');
+ browserTrigger(inputElm, 'change');
+ expect(scope.value).toBe('value2');
+
+ if (msie < 9) return;
+
+ inputElm.val('value3');
+ browserTrigger(inputElm, 'input');
+ expect(scope.value).toBe('value3');
+ }));
+ });
+
+
+ describe('ng-value', function() {
+
+ it('should evaluate and set constant expressions', function() {
+ compileInput('' +
+ '' +
+ '');
+ scope.$digest();
+
+ browserTrigger(inputElm[0], 'click');
+ expect(scope.selected).toBe(true);
+
+ browserTrigger(inputElm[1], 'click');
+ expect(scope.selected).toBe(false);
+
+ browserTrigger(inputElm[2], 'click');
+ expect(scope.selected).toBe(1);
+ });
+
+
+ it('should watch the expression', function() {
+ compileInput('');
+
+ scope.$apply(function() {
+ scope.selected = scope.value = {some: 'object'};
+ });
+ expect(inputElm[0].checked).toBe(true);
+
+ scope.$apply(function() {
+ scope.value = {some: 'other'};
+ });
+ expect(inputElm[0].checked).toBe(false);
+
+ browserTrigger(inputElm, 'click');
+ expect(scope.selected).toBe(scope.value);
+ });
+ });
+});
diff --git a/test/ng/directive/ngBindSpec.js b/test/ng/directive/ngBindSpec.js
new file mode 100644
index 00000000..01a07c52
--- /dev/null
+++ b/test/ng/directive/ngBindSpec.js
@@ -0,0 +1,80 @@
+'use strict';
+
+describe('ng-bind-*', function() {
+ var element;
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ describe('ng-bind', function() {
+
+ it('should set text', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(element.text()).toEqual('');
+ $rootScope.a = 'misko';
+ $rootScope.$digest();
+ expect(element.hasClass('ng-binding')).toEqual(true);
+ expect(element.text()).toEqual('misko');
+ }));
+
+ it('should set text to blank if undefined', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.a = 'misko';
+ $rootScope.$digest();
+ expect(element.text()).toEqual('misko');
+ $rootScope.a = undefined;
+ $rootScope.$digest();
+ expect(element.text()).toEqual('');
+ $rootScope.a = null;
+ $rootScope.$digest();
+ expect(element.text()).toEqual('');
+ }));
+
+ it('should set html', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.html = 'content ')($rootScope);
+ $httpBackend.expect('GET', 'myUrl').respond(404, '');
+
+ $rootScope.url = 'myUrl';
+ $rootScope.$digest();
+ $httpBackend.flush();
+
+ expect(element.text()).toBe('');
+ }));
+
+
+ it('should be async even if served from cache', inject(
+ putIntoCache('myUrl', 'my partial'),
+ function($rootScope, $compile) {
+ element = $compile('" +
+ ' ')($rootScope);
+ }));
+
+
+ it('should show single/plural strings', inject(function($rootScope) {
+ $rootScope.email = 0;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have no new email');
+
+ $rootScope.email = '0';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have no new email');
+
+ $rootScope.email = 1;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have one new email');
+
+ $rootScope.email = 0.01;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have 0.01 new emails');
+
+ $rootScope.email = '0.1';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have 0.1 new emails');
+
+ $rootScope.email = 2;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have 2 new emails');
+
+ $rootScope.email = -0.1;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have -0.1 new emails');
+
+ $rootScope.email = '-0.01';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have -0.01 new emails');
+
+ $rootScope.email = -2;
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have -2 new emails');
+ }));
+
+
+ it('should show single/plural strings with mal-formed inputs', inject(function($rootScope) {
+ $rootScope.email = '';
+ $rootScope.$digest();
+ expect(element.text()).toBe('');
+
+ $rootScope.email = null;
+ $rootScope.$digest();
+ expect(element.text()).toBe('');
+
+ $rootScope.email = undefined;
+ $rootScope.$digest();
+ expect(element.text()).toBe('');
+
+ $rootScope.email = 'a3';
+ $rootScope.$digest();
+ expect(element.text()).toBe('');
+
+ $rootScope.email = '011';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have 11 new emails');
+
+ $rootScope.email = '-011';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have -11 new emails');
+
+ $rootScope.email = '1fff';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have one new email');
+
+ $rootScope.email = '0aa22';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have no new email');
+
+ $rootScope.email = '000001';
+ $rootScope.$digest();
+ expect(element.text()).toBe('You have one new email');
+ }));
+ });
+
+
+ describe('deal with pluralized strings with offset', function() {
+ it('should show single/plural strings with offset', inject(function($rootScope, $compile) {
+ element = $compile(
+ "" +
+ " ")($rootScope);
+ $rootScope.p1 = 'Igor';
+ $rootScope.p2 = 'Misko';
+
+ $rootScope.viewCount = 0;
+ $rootScope.$digest();
+ expect(element.text()).toBe('Nobody is viewing.');
+
+ $rootScope.viewCount = 1;
+ $rootScope.$digest();
+ expect(element.text()).toBe('Igor is viewing.');
+
+ $rootScope.viewCount = 2;
+ $rootScope.$digest();
+ expect(element.text()).toBe('Igor and Misko are viewing.');
+
+ $rootScope.viewCount = 3;
+ $rootScope.$digest();
+ expect(element.text()).toBe('Igor, Misko and one other person are viewing.');
+
+ $rootScope.viewCount = 4;
+ $rootScope.$digest();
+ expect(element.text()).toBe('Igor, Misko and 2 other people are viewing.');
+ }));
+ });
+});
diff --git a/test/ng/directive/ngRepeatSpec.js b/test/ng/directive/ngRepeatSpec.js
new file mode 100644
index 00000000..85aa1511
--- /dev/null
+++ b/test/ng/directive/ngRepeatSpec.js
@@ -0,0 +1,289 @@
+'use strict';
+
+describe('ng-repeat', function() {
+ var element;
+
+
+ afterEach(function(){
+ dealoc(element);
+ });
+
+
+ it('should ng-repeat over array', inject(function($rootScope, $compile) {
+ element = $compile(
+ '' +
+ ' ')($rootScope);
+ $rootScope.$apply();
+ expect(element.text()).toEqual('other');
+ $rootScope.select = 1;
+ $rootScope.$apply();
+ expect(element.text()).toEqual('one');
+ }));
+
+
+ it('should call change on switch', inject(function($rootScope, $compile) {
+ element = $compile(
+ '' +
+ ' ')($rootScope);
+ $rootScope.url = 'a';
+ $rootScope.$apply();
+ expect($rootScope.name).toEqual('works');
+ expect(element.text()).toEqual('works');
+ }));
+
+
+ it('should properly create and destroy child scopes', inject(function($rootScope, $compile) {
+ element = $compile(
+ '' +
+ ' ')($rootScope);
+ $rootScope.$apply();
+
+ var getChildScope = function() { return element.find('div').scope(); };
+
+ expect(getChildScope()).toBeUndefined();
+
+ $rootScope.url = 'a';
+ $rootScope.$apply();
+ var child1 = getChildScope();
+ expect(child1).toBeDefined();
+ spyOn(child1, '$destroy');
+
+ $rootScope.url = 'x';
+ $rootScope.$apply();
+ expect(getChildScope()).toBeUndefined();
+ expect(child1.$destroy).toHaveBeenCalledOnce();
+
+ $rootScope.url = 'a';
+ $rootScope.$apply();
+ var child2 = getChildScope();
+ expect(child2).toBeDefined();
+ expect(child2).not.toBe(child1);
+ }));
+});
diff --git a/test/ng/directive/ngViewSpec.js b/test/ng/directive/ngViewSpec.js
new file mode 100644
index 00000000..636e15a8
--- /dev/null
+++ b/test/ng/directive/ngViewSpec.js
@@ -0,0 +1,459 @@
+'use strict';
+
+describe('ng-view', function() {
+ var element;
+
+ beforeEach(module(function() {
+ return function($rootScope, $compile) {
+ element = $compile('{{y}} ');
+ expect($templateCache.get('/ignore')).toBeUndefined();
+ }
+ ));
+
+
+ it('should not compile scripts', inject(function($compile, $templateCache, $rootScope) {
+ if (msie <=8) return; // see above
+
+ var doc = jqLite('');
+ // jQuery is too smart and removes
+ doc[0].innerHTML = '' +
+ '';
+
+ $compile(doc)($rootScope);
+ $rootScope.$digest();
+
+ var scripts = doc.find('script');
+ expect(scripts.eq(0).text()).toBe('some {{binding}}');
+ expect(scripts.eq(1).text()).toBe('other {{binding}}');
+ dealoc(doc);
+ }));
+});
diff --git a/test/ng/directive/selectSpec.js b/test/ng/directive/selectSpec.js
new file mode 100644
index 00000000..2e3cfaaf
--- /dev/null
+++ b/test/ng/directive/selectSpec.js
@@ -0,0 +1,863 @@
+'use strict';
+
+describe('select', function() {
+ var scope, formElement, element, $compile;
+
+ function compile(html) {
+ formElement = jqLite('');
+ element = formElement.find('select');
+ $compile(formElement)(scope);
+ scope.$apply();
+ }
+
+ beforeEach(inject(function($injector, $rootScope) {
+ scope = $rootScope;
+ $compile = $injector.get('$compile');
+ formElement = element = null;
+ }));
+
+ afterEach(function() {
+ dealoc(formElement);
+ });
+
+
+ describe('select-one', function() {
+
+ it('should compile children of a select without a ng-model, but not create a model for it',
+ function() {
+ compile('');
+ scope.$apply(function() {
+ scope.a = 'foo';
+ scope.b = 'bar';
+ });
+
+ expect(element.text()).toBe('foobarC');
+ });
+
+
+ it('should require', function() {
+ compile(
+ '');
+
+ scope.change = function() {
+ scope.log += 'change;';
+ };
+
+ scope.$apply(function() {
+ scope.log = '';
+ scope.selection = 'c';
+ });
+
+ expect(scope.form.select.$error.required).toBeFalsy();
+ expect(element).toBeValid();
+ expect(element).toBePristine();
+
+ scope.$apply(function() {
+ scope.selection = '';
+ });
+
+ expect(scope.form.select.$error.required).toBeTruthy();
+ expect(element).toBeInvalid();
+ expect(element).toBePristine();
+ expect(scope.log).toEqual('');
+
+ element[0].value = 'c';
+ browserTrigger(element, 'change');
+ expect(element).toBeValid();
+ expect(element).toBeDirty();
+ expect(scope.log).toEqual('change;');
+ });
+
+
+ it('should not be invalid if no require', function() {
+ compile(
+ '');
+
+ expect(element).toBeValid();
+ expect(element).toBePristine();
+ });
+ });
+
+
+ describe('select-multiple', function() {
+
+ it('should support type="select-multiple"', function() {
+ compile(
+ '');
+
+ scope.$apply(function() {
+ scope.selection = ['A'];
+ });
+
+ expect(element.find('option')[0].selected).toEqual(true);
+ expect(element.find('option')[1].selected).toEqual(false);
+
+ scope.$apply(function() {
+ scope.selection.push('B');
+ });
+
+ expect(element.find('option')[0].selected).toEqual(true);
+ expect(element.find('option')[1].selected).toEqual(true);
+ });
+
+
+ it('should require', function() {
+ compile(
+ '');
+
+ scope.$apply(function() {
+ scope.selection = [];
+ });
+
+ expect(scope.form.select.$error.required).toBeTruthy();
+ expect(element).toBeInvalid();
+ expect(element).toBePristine();
+
+ scope.$apply(function() {
+ scope.selection = ['A'];
+ });
+
+ expect(element).toBeValid();
+ expect(element).toBePristine();
+
+ element[0].value = 'B';
+ browserTrigger(element, 'change');
+ expect(element).toBeValid();
+ expect(element).toBeDirty();
+ });
+ });
+
+
+ describe('ng-options', function() {
+ function createSelect(attrs, blank, unknown) {
+ var html = 'blank') : '') +
+ (unknown ? (isString(unknown) ? unknown : '') : '') +
+ '';
+
+ compile(html);
+ }
+
+ function createSingleSelect(blank, unknown) {
+ createSelect({
+ 'ng-model':'selected',
+ 'ng-options':'value.name for value in values'
+ }, blank, unknown);
+ }
+
+ function createMultiSelect(blank, unknown) {
+ createSelect({
+ 'ng-model':'selected',
+ 'multiple':true,
+ 'ng-options':'value.name for value in values'
+ }, blank, unknown);
+ }
+
+
+ it('should throw when not formated "? for ? in ?"', function() {
+ expect(function() {
+ compile('');
+ }).toThrow("Expected ng-options in form of '_select_ (as _label_)? for (_key_,)?_value_ in" +
+ " _collection_' but got 'i dont parse'.");
+ });
+
+
+ it('should render a list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}, {name: 'C'}];
+ scope.selected = scope.values[0];
+ });
+
+ var options = element.find('option');
+ expect(options.length).toEqual(3);
+ expect(sortedHtml(options[0])).toEqual('');
+ expect(sortedHtml(options[1])).toEqual('');
+ expect(sortedHtml(options[2])).toEqual('');
+ });
+
+
+ it('should render an object', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'value as key for (key, value) in object'
+ });
+
+ scope.$apply(function() {
+ scope.object = {'red': 'FF0000', 'green': '00FF00', 'blue': '0000FF'};
+ scope.selected = scope.object.red;
+ });
+
+ var options = element.find('option');
+ expect(options.length).toEqual(3);
+ expect(sortedHtml(options[0])).toEqual('');
+ expect(sortedHtml(options[1])).toEqual('');
+ expect(sortedHtml(options[2])).toEqual('');
+ expect(options[2].selected).toEqual(true);
+
+ scope.$apply(function() {
+ scope.object.azur = '8888FF';
+ });
+
+ options = element.find('option');
+ expect(options[3].selected).toEqual(true);
+ });
+
+
+ it('should grow list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [];
+ });
+
+ expect(element.find('option').length).toEqual(1); // because we add special empty option
+ expect(sortedHtml(element.find('option')[0])).toEqual('');
+
+ scope.$apply(function() {
+ scope.values.push({name:'A'});
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(1);
+ expect(sortedHtml(element.find('option')[0])).toEqual('');
+
+ scope.$apply(function() {
+ scope.values.push({name:'B'});
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(sortedHtml(element.find('option')[0])).toEqual('');
+ expect(sortedHtml(element.find('option')[1])).toEqual('');
+ });
+
+
+ it('should shrink list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name:'A'}, {name:'B'}, {name:'C'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(3);
+
+ scope.$apply(function() {
+ scope.values.pop();
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(sortedHtml(element.find('option')[0])).toEqual('');
+ expect(sortedHtml(element.find('option')[1])).toEqual('');
+
+ scope.$apply(function() {
+ scope.values.pop();
+ });
+
+ expect(element.find('option').length).toEqual(1);
+ expect(sortedHtml(element.find('option')[0])).toEqual('');
+
+ scope.$apply(function() {
+ scope.values.pop();
+ scope.selected = null;
+ });
+
+ expect(element.find('option').length).toEqual(1); // we add back the special empty option
+ });
+
+
+ it('should shrink and then grow list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name:'A'}, {name:'B'}, {name:'C'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(3);
+
+ scope.$apply(function() {
+ scope.values = [{name: '1'}, {name: '2'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(2);
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}, {name: 'C'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(3);
+ });
+
+
+ it('should update list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}, {name: 'C'}];
+ scope.selected = scope.values[0];
+ });
+
+ scope.$apply(function() {
+ scope.values = [{name: 'B'}, {name: 'C'}, {name: 'D'}];
+ scope.selected = scope.values[0];
+ });
+
+ var options = element.find('option');
+ expect(options.length).toEqual(3);
+ expect(sortedHtml(options[0])).toEqual('');
+ expect(sortedHtml(options[1])).toEqual('');
+ expect(sortedHtml(options[2])).toEqual('');
+ });
+
+
+ it('should preserve existing options', function() {
+ createSingleSelect(true);
+
+ scope.$apply(function() {
+ scope.values = [];
+ });
+
+ expect(element.find('option').length).toEqual(1);
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(jqLite(element.find('option')[0]).text()).toEqual('blank');
+ expect(jqLite(element.find('option')[1]).text()).toEqual('A');
+
+ scope.$apply(function() {
+ scope.values = [];
+ scope.selected = null;
+ });
+
+ expect(element.find('option').length).toEqual(1);
+ expect(jqLite(element.find('option')[0]).text()).toEqual('blank');
+ });
+
+
+ describe('binding', function() {
+
+ it('should bind to scope value', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[1];
+ });
+
+ expect(element.val()).toEqual('1');
+ });
+
+
+ it('should bind to scope value and group', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'item.name group by item.group for item in values'
+ });
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'},
+ {name: 'B', group: 'first'},
+ {name: 'C', group: 'second'},
+ {name: 'D', group: 'first'},
+ {name: 'E', group: 'second'}];
+ scope.selected = scope.values[3];
+ });
+
+ expect(element.val()).toEqual('3');
+
+ var first = jqLite(element.find('optgroup')[0]);
+ var b = jqLite(first.find('option')[0]);
+ var d = jqLite(first.find('option')[1]);
+ expect(first.attr('label')).toEqual('first');
+ expect(b.text()).toEqual('B');
+ expect(d.text()).toEqual('D');
+
+ var second = jqLite(element.find('optgroup')[1]);
+ var c = jqLite(second.find('option')[0]);
+ var e = jqLite(second.find('option')[1]);
+ expect(second.attr('label')).toEqual('second');
+ expect(c.text()).toEqual('C');
+ expect(e.text()).toEqual('E');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+ });
+
+
+ it('should bind to scope value through experession', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'item.id as item.name for item in values'
+ });
+
+ scope.$apply(function() {
+ scope.values = [{id: 10, name: 'A'}, {id: 20, name: 'B'}];
+ scope.selected = scope.values[0].id;
+ });
+
+ expect(element.val()).toEqual('0');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[1].id;
+ });
+
+ expect(element.val()).toEqual('1');
+ });
+
+
+ it('should bind to object key', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'key as value for (key, value) in object'
+ });
+
+ scope.$apply(function() {
+ scope.object = {red: 'FF0000', green: '00FF00', blue: '0000FF'};
+ scope.selected = 'green';
+ });
+
+ expect(element.val()).toEqual('green');
+
+ scope.$apply(function() {
+ scope.selected = 'blue';
+ });
+
+ expect(element.val()).toEqual('blue');
+ });
+
+
+ it('should bind to object value', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'value as key for (key, value) in object'
+ });
+
+ scope.$apply(function() {
+ scope.object = {red: 'FF0000', green: '00FF00', blue:'0000FF'};
+ scope.selected = '00FF00';
+ });
+
+ expect(element.val()).toEqual('green');
+
+ scope.$apply(function() {
+ scope.selected = '0000FF';
+ });
+
+ expect(element.val()).toEqual('blue');
+ });
+
+
+ it('should insert a blank option if bound to null', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}];
+ scope.selected = null;
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.val()).toEqual('');
+ expect(jqLite(element.find('option')[0]).val()).toEqual('');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+ expect(element.find('option').length).toEqual(1);
+ });
+
+
+ it('should reuse blank option if bound to null', function() {
+ createSingleSelect(true);
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}];
+ scope.selected = null;
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.val()).toEqual('');
+ expect(jqLite(element.find('option')[0]).val()).toEqual('');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+ expect(element.find('option').length).toEqual(2);
+ });
+
+
+ it('should insert a unknown option if bound to something not in the list', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}];
+ scope.selected = {};
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.val()).toEqual('?');
+ expect(jqLite(element.find('option')[0]).val()).toEqual('?');
+
+ scope.$apply(function() {
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+ expect(element.find('option').length).toEqual(1);
+ });
+
+
+ it('should select correct input if previously selected option was "?"', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = {};
+ });
+
+ expect(element.find('option').length).toEqual(3);
+ expect(element.val()).toEqual('?');
+ expect(element.find('option').eq(0).val()).toEqual('?');
+
+ browserTrigger(element.find('option').eq(1));
+ expect(element.val()).toEqual('0');
+ expect(element.find('option').eq(0).prop('selected')).toBeTruthy();
+ expect(element.find('option').length).toEqual(2);
+ });
+ });
+
+
+ describe('blank option', function () {
+
+ it('should be compiled as template, be watched and updated', function () {
+ var option;
+ createSingleSelect('');
+
+ scope.$apply(function() {
+ scope.blankVal = 'so blank';
+ scope.values = [{name: 'A'}];
+ });
+
+ // check blank option is first and is compiled
+ expect(element.find('option').length).toBe(2);
+ option = element.find('option').eq(0);
+ expect(option.val()).toBe('');
+ expect(option.text()).toBe('blank is so blank');
+
+ scope.$apply(function() {
+ scope.blankVal = 'not so blank';
+ });
+
+ // check blank option is first and is compiled
+ expect(element.find('option').length).toBe(2);
+ option = element.find('option').eq(0);
+ expect(option.val()).toBe('');
+ expect(option.text()).toBe('blank is not so blank');
+ });
+
+
+ it('should support binding via ng-bind-template attribute', function () {
+ var option;
+ createSingleSelect('');
+
+ scope.$apply(function() {
+ scope.blankVal = 'so blank';
+ scope.values = [{name: 'A'}];
+ });
+
+ // check blank option is first and is compiled
+ expect(element.find('option').length).toBe(2);
+ option = element.find('option').eq(0);
+ expect(option.val()).toBe('');
+ expect(option.text()).toBe('blank is so blank');
+ });
+
+
+ it('should support biding via ng-bind attribute', function () {
+ var option;
+ createSingleSelect('');
+
+ scope.$apply(function() {
+ scope.blankVal = 'is blank';
+ scope.values = [{name: 'A'}];
+ });
+
+ // check blank option is first and is compiled
+ expect(element.find('option').length).toBe(2);
+ option = element.find('option').eq(0);
+ expect(option.val()).toBe('');
+ expect(option.text()).toBe('is blank');
+ });
+
+
+ it('should be rendered with the attributes preserved', function () {
+ var option;
+ createSingleSelect('');
+
+ scope.$apply(function() {
+ scope.blankVal = 'is blank';
+ });
+
+ // check blank option is first and is compiled
+ option = element.find('option').eq(0);
+ expect(option.hasClass('coyote')).toBeTruthy();
+ expect(option.attr('id')).toBe('road-runner');
+ expect(option.attr('custom-attr')).toBe('custom-attr');
+ });
+ });
+
+
+ describe('on change', function() {
+
+ it('should update model on change', function() {
+ createSingleSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = scope.values[0];
+ });
+
+ expect(element.val()).toEqual('0');
+
+ element.val('1');
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual(scope.values[1]);
+ });
+
+
+ it('should update model on change through expression', function() {
+ createSelect({
+ 'ng-model': 'selected',
+ 'ng-options': 'item.id as item.name for item in values'
+ });
+
+ scope.$apply(function() {
+ scope.values = [{id: 10, name: 'A'}, {id: 20, name: 'B'}];
+ scope.selected = scope.values[0].id;
+ });
+
+ expect(element.val()).toEqual('0');
+
+ element.val('1');
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual(scope.values[1].id);
+ });
+
+
+ it('should update model to null on change', function() {
+ createSingleSelect(true);
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = scope.values[0];
+ element.val('0');
+ });
+
+ element.val('');
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual(null);
+ });
+ });
+
+
+ describe('select-many', function() {
+
+ it('should read multiple selection', function() {
+ createMultiSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = [];
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.find('option')[0].selected).toBeFalsy();
+ expect(element.find('option')[1].selected).toBeFalsy();
+
+ scope.$apply(function() {
+ scope.selected.push(scope.values[1]);
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.find('option')[0].selected).toBeFalsy();
+ expect(element.find('option')[1].selected).toBeTruthy();
+
+ scope.$apply(function() {
+ scope.selected.push(scope.values[0]);
+ });
+
+ expect(element.find('option').length).toEqual(2);
+ expect(element.find('option')[0].selected).toBeTruthy();
+ expect(element.find('option')[1].selected).toBeTruthy();
+ });
+
+
+ it('should update model on change', function() {
+ createMultiSelect();
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A'}, {name: 'B'}];
+ scope.selected = [];
+ });
+
+ element.find('option')[0].selected = true;
+
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual([scope.values[0]]);
+ });
+
+ it('should select from object', function() {
+ createSelect({
+ 'ng-model':'selected',
+ 'multiple':true,
+ 'ng-options':'key as value for (key,value) in values'
+ });
+ scope.values = {'0':'A', '1':'B'};
+
+ scope.selected = ['1'];
+ scope.$digest();
+ expect(element.find('option')[1].selected).toBe(true);
+
+ element.find('option')[0].selected = true;
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual(['0', '1']);
+
+ element.find('option')[1].selected = false;
+ browserTrigger(element, 'change');
+ expect(scope.selected).toEqual(['0']);
+ });
+ });
+
+
+ describe('ng-required', function() {
+
+ it('should allow bindings on ng-required', function() {
+ createSelect({
+ 'ng-model': 'value',
+ 'ng-options': 'item.name for item in values',
+ 'ng-required': 'required'
+ }, true);
+
+
+ scope.$apply(function() {
+ scope.values = [{name: 'A', id: 1}, {name: 'B', id: 2}];
+ scope.required = false;
+ });
+
+ element.val('');
+ browserTrigger(element, 'change');
+ expect(element).toBeValid();
+
+ scope.$apply(function() {
+ scope.required = true;
+ });
+ expect(element).toBeInvalid();
+
+ scope.$apply(function() {
+ scope.value = scope.values[0];
+ });
+ expect(element).toBeValid();
+
+ element.val('');
+ browserTrigger(element, 'change');
+ expect(element).toBeInvalid();
+
+ scope.$apply(function() {
+ scope.required = false;
+ });
+ expect(element).toBeValid();
+ });
+ });
+ });
+
+
+ describe('OPTION value', function() {
+ beforeEach(function() {
+ this.addMatchers({
+ toHaveValue: function(expected){
+ this.message = function() {
+ return 'Expected "' + this.actual.html() + '" to have value="' + expected + '".';
+ };
+
+ var value;
+ htmlParser(this.actual.html(), {
+ start:function(tag, attrs){
+ value = attrs.value;
+ },
+ end:noop,
+ chars:noop
+ });
+ return trim(value) == trim(expected);
+ }
+ });
+ });
+
+
+ it('should populate value attribute on OPTION', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ expect(element).toHaveValue('abc');
+ }));
+
+ it('should ignore value if already exists', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ expect(element).toHaveValue('abc');
+ }));
+
+ it('should set value even if newlines present', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ expect(element).toHaveValue('\nabc\n');
+ }));
+
+ it('should set value even if self closing HTML', inject(function($rootScope, $compile) {
+ // IE removes the \n from option, which makes this test pointless
+ if (msie) return;
+ element = $compile('')($rootScope)
+ expect(element).toHaveValue('\n');
+ }));
+ });
+});
diff --git a/test/ng/directive/styleSpec.js b/test/ng/directive/styleSpec.js
new file mode 100644
index 00000000..bdc4ea85
--- /dev/null
+++ b/test/ng/directive/styleSpec.js
@@ -0,0 +1,31 @@
+'use strict';
+
+describe('style', function() {
+ var element;
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should not compile style element', inject(function($compile, $rootScope) {
+ element = jqLite('');
+ $compile(element)($rootScope);
+ $rootScope.$digest();
+
+ // read innerHTML and trim to pass on IE8
+ expect(trim(element[0].innerHTML)).toBe('should {{notBound}}');
+ }));
+
+
+ it('should compile content of element with style attr', inject(function($compile, $rootScope) {
+ element = jqLite('text ', handler);
+ expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
+ expect(text).toEqual('text');
+ });
+
+ it('should parse newlines in tags', function() {
+ htmlParser('<\ntag\n attr="value"\n>text<\n/\ntag\n>', handler);
+ expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
+ expect(text).toEqual('text');
+ });
+
+ it('should parse newlines in attributes', function() {
+ htmlParser('text ', handler);
+ expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
+ expect(text).toEqual('text');
+ });
+
+ it('should parse namespace', function() {
+ htmlParser('text ', handler);
+ expect(start).toEqual({tag:'ns:t-a-g', attrs:{'ns:a-t-t-r':'value'}, unary:false});
+ expect(text).toEqual('text');
+ });
+
+ it('should parse empty value attribute of node', function() {
+ htmlParser('', handler);
+ expect(start).toEqual({tag:'option', attrs:{selected:'', value:''}, unary:false});
+ expect(text).toEqual('abc');
+ });
+
+ });
+
+ it('should echo html', function() {
+ expectHTML('helloworld.').
+ toEqual('helloworld.');
+ });
+
+ it('should remove script', function() {
+ expectHTML('ac.').toEqual('ac.');
+ });
+
+ it('should remove double nested script', function() {
+ expectHTML('ailc.').toEqual('ac.');
+ });
+
+ it('should remove unknown names', function() {
+ expectHTML('ab c').toEqual('abc');
+ });
+
+ it('should remove unsafe value', function() {
+ expectHTML('').toEqual('');
+ });
+
+ it('should handle self closed elements', function() {
+ expectHTML('a
c').toEqual('a
c'); + }); + + it('should handle namespace', function() { + expectHTML('ab c').toEqual('abc');
+ });
+
+ it('should handle entities', function() {
+ var everything = '
" alt=abc dir=\'"\' >text< /div>').
+ toEqual('')
+ fail();
+ } catch(e) {
+ expect(e.message).toMatch(/Multiple directives .* asking for template/);
+ }
+ }));
+
+ it('should play nice with repeater when inline', inject(function($compile, $rootScope) {
+ element = $compile(
+ '
' +
+ '
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('Hello: 1; Hello: 2; ');
+ }));
+
+
+ it('should play nice with repeater when append', inject(function($compile, $rootScope) {
+ element = $compile(
+ '{{i}};
' +
+ '' +
+ '
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('Hello: 1; Hello: 2; ');
+ }));
+
+
+ it('should merge interpolated css class', inject(function($compile, $rootScope) {
+ element = $compile('')($rootScope);
+
+ $rootScope.$apply(function() {
+ $rootScope.cls = 'two';
+ });
+
+ expect(element).toHaveClass('one');
+ expect(element).toHaveClass('two'); // interpolated
+ expect(element).toHaveClass('three');
+ expect(element).toHaveClass('log'); // merged from replace directive template
+ }));
+
+
+ it('should merge interpolated css class with ng-repeat',
+ inject(function($compile, $rootScope) {
+ element = $compile(
+ '{{i}};
' +
+ '' +
+ '' +
+ '
')($rootScope);
+
+ $rootScope.$apply(function() {
+ $rootScope.cls = 'two';
+ });
+
+ var child = element.find('div').eq(0);
+ expect(child).toHaveClass('one');
+ expect(child).toHaveClass('two'); // interpolated
+ expect(child).toHaveClass('three');
+ expect(child).toHaveClass('log'); // merged from replace directive template
+ }));
+ });
+
+
+ describe('async templates', function() {
+
+ beforeEach(module(
+ function($compileProvider) {
+ $compileProvider.directive('hello', valueFn({ restrict: 'CAM', templateUrl: 'hello.html' }));
+ $compileProvider.directive('cau', valueFn({ restrict: 'CAM', templateUrl:'cau.html' }));
+
+ $compileProvider.directive('cError', valueFn({
+ restrict: 'CAM',
+ templateUrl:'error.html',
+ compile: function() {
+ throw Error('cError');
+ }
+ }));
+ $compileProvider.directive('lError', valueFn({
+ restrict: 'CAM',
+ templateUrl: 'error.html',
+ compile: function() {
+ throw Error('lError');
+ }
+ }));
+
+
+ $compileProvider.directive('iHello', valueFn({
+ restrict: 'CAM',
+ replace: true,
+ templateUrl: 'hello.html'
+ }));
+ $compileProvider.directive('iCau', valueFn({
+ restrict: 'CAM',
+ replace: true,
+ templateUrl:'cau.html'
+ }));
+
+ $compileProvider.directive('iCError', valueFn({
+ restrict: 'CAM',
+ replace: true,
+ templateUrl:'error.html',
+ compile: function() {
+ throw Error('cError');
+ }
+ }));
+ $compileProvider.directive('iLError', valueFn({
+ restrict: 'CAM',
+ replace: true,
+ templateUrl: 'error.html',
+ compile: function() {
+ throw Error('lError');
+ }
+ }));
+
+ }
+ ));
+
+
+ it('should append template via $http and cache it in $templateCache', inject(
+ function($compile, $httpBackend, $templateCache, $rootScope, $browser) {
+ $httpBackend.expect('GET', 'hello.html').respond('Hello! World!');
+ $templateCache.put('cau.html', 'Cau!');
+ element = $compile('ignoreignore
')($rootScope);
+ expect(sortedHtml(element)).
+ toEqual('');
+
+ $rootScope.$digest();
+
+
+ expect(sortedHtml(element)).
+ toEqual('
Cau!
');
+
+ $httpBackend.flush();
+ expect(sortedHtml(element)).toEqual(
+ '' +
+ 'Hello! World!' +
+ 'Cau!' +
+ '
');
+ }
+ ));
+
+
+ it('should inline template via $http and cache it in $templateCache', inject(
+ function($compile, $httpBackend, $templateCache, $rootScope) {
+ $httpBackend.expect('GET', 'hello.html').respond('Hello!');
+ $templateCache.put('cau.html', 'Cau!');
+ element = $compile('ignoreignore
')($rootScope);
+ expect(sortedHtml(element)).
+ toEqual('');
+
+ $rootScope.$digest();
+
+
+ expect(sortedHtml(element)).
+ toEqual('
Cau!
');
+
+ $httpBackend.flush();
+ expect(sortedHtml(element)).
+ toEqual('Hello!Cau!
');
+ }
+ ));
+
+
+ it('should compile, link and flush the template append', inject(
+ function($compile, $templateCache, $rootScope, $browser) {
+ $templateCache.put('hello.html', 'Hello, {{name}}!');
+ $rootScope.name = 'Elvis';
+ element = $compile('')($rootScope);
+
+ $rootScope.$digest();
+
+ expect(sortedHtml(element)).
+ toEqual('
Hello, Elvis!
');
+ }
+ ));
+
+
+ it('should compile, link and flush the template inline', inject(
+ function($compile, $templateCache, $rootScope) {
+ $templateCache.put('hello.html', 'Hello, {{name}}!');
+ $rootScope.name = 'Elvis';
+ element = $compile('')($rootScope);
+
+ $rootScope.$digest();
+
+ expect(sortedHtml(element)).
+ toEqual('
Hello, Elvis!
');
+ }
+ ));
+
+
+ it('should compile, flush and link the template append', inject(
+ function($compile, $templateCache, $rootScope) {
+ $templateCache.put('hello.html', 'Hello, {{name}}!');
+ $rootScope.name = 'Elvis';
+ var template = $compile('');
+
+ element = template($rootScope);
+ $rootScope.$digest();
+
+ expect(sortedHtml(element)).
+ toEqual('
Hello, Elvis!
');
+ }
+ ));
+
+
+ it('should compile, flush and link the template inline', inject(
+ function($compile, $templateCache, $rootScope) {
+ $templateCache.put('hello.html', 'Hello, {{name}}!');
+ $rootScope.name = 'Elvis';
+ var template = $compile('');
+
+ element = template($rootScope);
+ $rootScope.$digest();
+
+ expect(sortedHtml(element)).
+ toEqual('
Hello, Elvis!
');
+ }
+ ));
+
+
+ it('should resolve widgets after cloning in append mode', function() {
+ module(function($exceptionHandlerProvider) {
+ $exceptionHandlerProvider.mode('log');
+ });
+ inject(function($compile, $templateCache, $rootScope, $httpBackend, $browser,
+ $exceptionHandler) {
+ $httpBackend.expect('GET', 'hello.html').respond('{{greeting}} ');
+ $httpBackend.expect('GET', 'error.html').respond('');
+ $templateCache.put('cau.html', '{{name}}');
+ $rootScope.greeting = 'Hello';
+ $rootScope.name = 'Elvis';
+ var template = $compile(
+ '' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '
');
+ var e1;
+ var e2;
+
+ e1 = template($rootScope.$new(), noop); // clone
+ expect(e1.text()).toEqual('');
+
+ $httpBackend.flush();
+
+ e2 = template($rootScope.$new(), noop); // clone
+ $rootScope.$digest();
+ expect(e1.text()).toEqual('Hello Elvis');
+ expect(e2.text()).toEqual('Hello Elvis');
+
+ expect($exceptionHandler.errors.length).toEqual(2);
+ expect($exceptionHandler.errors[0][0].message).toEqual('cError');
+ expect($exceptionHandler.errors[1][0].message).toEqual('lError');
+
+ dealoc(e1);
+ dealoc(e2);
+ });
+ });
+
+
+ it('should resolve widgets after cloning in inline mode', function() {
+ module(function($exceptionHandlerProvider) {
+ $exceptionHandlerProvider.mode('log');
+ });
+ inject(function($compile, $templateCache, $rootScope, $httpBackend, $browser,
+ $exceptionHandler) {
+ $httpBackend.expect('GET', 'hello.html').respond('{{greeting}} ');
+ $httpBackend.expect('GET', 'error.html').respond('');
+ $templateCache.put('cau.html', '{{name}}');
+ $rootScope.greeting = 'Hello';
+ $rootScope.name = 'Elvis';
+ var template = $compile(
+ '' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '
');
+ var e1;
+ var e2;
+
+ e1 = template($rootScope.$new(), noop); // clone
+ expect(e1.text()).toEqual('');
+
+ $httpBackend.flush();
+
+ e2 = template($rootScope.$new(), noop); // clone
+ $rootScope.$digest();
+ expect(e1.text()).toEqual('Hello Elvis');
+ expect(e2.text()).toEqual('Hello Elvis');
+
+ expect($exceptionHandler.errors.length).toEqual(2);
+ expect($exceptionHandler.errors[0][0].message).toEqual('cError');
+ expect($exceptionHandler.errors[1][0].message).toEqual('lError');
+
+ dealoc(e1);
+ dealoc(e2);
+ });
+ });
+
+
+ it('should be implicitly terminal and not compile placeholder content in append', inject(
+ function($compile, $templateCache, $rootScope, log) {
+ // we can't compile the contents because that would result in a memory leak
+
+ $templateCache.put('hello.html', 'Hello!');
+ element = $compile('')($rootScope);
+
+ expect(log).toEqual('');
+ }
+ ));
+
+
+ it('should be implicitly terminal and not compile placeholder content in inline', inject(
+ function($compile, $templateCache, $rootScope, log) {
+ // we can't compile the contents because that would result in a memory leak
+
+ $templateCache.put('hello.html', 'Hello!');
+ element = $compile('
')($rootScope);
+
+ expect(log).toEqual('');
+ }
+ ));
+
+
+ it('should throw an error and clear element content if the template fails to load', inject(
+ function($compile, $httpBackend, $rootScope) {
+ $httpBackend.expect('GET', 'hello.html').respond(404, 'Not Found!');
+ element = $compile('
content
')($rootScope);
+
+ expect(function() {
+ $httpBackend.flush();
+ }).toThrow('Failed to load template: hello.html');
+ expect(sortedHtml(element)).toBe('');
+ }
+ ));
+
+
+ it('should prevent multiple templates per element', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('sync', valueFn({
+ restrict: 'C',
+ template: ''
+ }));
+ $compileProvider.directive('async', valueFn({
+ restrict: 'C',
+ templateUrl: 'template.html'
+ }));
+ });
+ inject(function($compile){
+ expect(function() {
+ $compile('
');
+ }).toThrow('Multiple directives [sync, async] asking for template on: <'+
+ (msie <= 8 ? 'DIV' : 'div') + ' class="sync async">');
+ });
+ });
+
+
+ describe('delay compile / linking functions until after template is resolved', function(){
+ var template;
+ beforeEach(module(function($compileProvider) {
+ function directive (name, priority, options) {
+ $compileProvider.directive(name, function(log) {
+ return (extend({
+ priority: priority,
+ compile: function() {
+ log(name + '-C');
+ return function() { log(name + '-L'); }
+ }
+ }, options || {}));
+ });
+ }
+
+ directive('first', 10);
+ directive('second', 5, { templateUrl: 'second.html' });
+ directive('third', 3);
+ directive('last', 0);
+
+ directive('iFirst', 10, {replace: true});
+ directive('iSecond', 5, {replace: true, templateUrl: 'second.html' });
+ directive('iThird', 3, {replace: true});
+ directive('iLast', 0, {replace: true});
+ }));
+
+ it('should flush after link append', inject(
+ function($compile, $rootScope, $httpBackend, log) {
+ $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
+ template = $compile('');
+ element = template($rootScope);
+ expect(log).toEqual('first-C');
+
+ log('FLUSH');
+ $httpBackend.flush();
+ $rootScope.$digest();
+ expect(log).toEqual(
+ 'first-C; FLUSH; second-C; last-C; third-C; ' +
+ 'third-L; first-L; second-L; last-L');
+
+ var span = element.find('span');
+ expect(span.attr('first')).toEqual('');
+ expect(span.attr('second')).toEqual('');
+ expect(span.find('div').attr('third')).toEqual('');
+ expect(span.attr('last')).toEqual('');
+
+ expect(span.text()).toEqual('3');
+ }));
+
+
+ it('should flush after link inline', inject(
+ function($compile, $rootScope, $httpBackend, log) {
+ $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
+ template = $compile('');
+ element = template($rootScope);
+ expect(log).toEqual('iFirst-C');
+
+ log('FLUSH');
+ $httpBackend.flush();
+ $rootScope.$digest();
+ expect(log).toEqual(
+ 'iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C; ' +
+ 'iFirst-L; iSecond-L; iThird-L; iLast-L');
+
+ var div = element.find('div');
+ expect(div.attr('i-first')).toEqual('');
+ expect(div.attr('i-second')).toEqual('');
+ expect(div.attr('i-third')).toEqual('');
+ expect(div.attr('i-last')).toEqual('');
+
+ expect(div.text()).toEqual('3');
+ }));
+
+
+ it('should flush before link append', inject(
+ function($compile, $rootScope, $httpBackend, log) {
+ $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
+ template = $compile('');
+ expect(log).toEqual('first-C');
+ log('FLUSH');
+ $httpBackend.flush();
+ expect(log).toEqual('first-C; FLUSH; second-C; last-C; third-C');
+
+ element = template($rootScope);
+ $rootScope.$digest();
+ expect(log).toEqual(
+ 'first-C; FLUSH; second-C; last-C; third-C; ' +
+ 'third-L; first-L; second-L; last-L');
+
+ var span = element.find('span');
+ expect(span.attr('first')).toEqual('');
+ expect(span.attr('second')).toEqual('');
+ expect(span.find('div').attr('third')).toEqual('');
+ expect(span.attr('last')).toEqual('');
+
+ expect(span.text()).toEqual('3');
+ }));
+
+
+ it('should flush before link inline', inject(
+ function($compile, $rootScope, $httpBackend, log) {
+ $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
+ template = $compile('');
+ expect(log).toEqual('iFirst-C');
+ log('FLUSH');
+ $httpBackend.flush();
+ expect(log).toEqual('iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C');
+
+ element = template($rootScope);
+ $rootScope.$digest();
+ expect(log).toEqual(
+ 'iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C; ' +
+ 'iFirst-L; iSecond-L; iThird-L; iLast-L');
+
+ var div = element.find('div');
+ expect(div.attr('i-first')).toEqual('');
+ expect(div.attr('i-second')).toEqual('');
+ expect(div.attr('i-third')).toEqual('');
+ expect(div.attr('i-last')).toEqual('');
+
+ expect(div.text()).toEqual('3');
+ }));
+ });
+
+
+ it('should check that template has root element', inject(function($compile, $httpBackend) {
+ $httpBackend.expect('GET', 'hello.html').respond('before mid after');
+ $compile('');
+ expect(function(){
+ $httpBackend.flush();
+ }).toThrow('Template must have exactly one root element: before mid after');
+ }));
+
+
+ it('should allow multiple elements in template', inject(function($compile, $httpBackend) {
+ $httpBackend.expect('GET', 'hello.html').respond('before mid after');
+ element = jqLite('');
+ $compile(element);
+ $httpBackend.flush();
+ expect(element.text()).toEqual('before mid after');
+ }));
+
+
+ it('should work when widget is in root element', inject(
+ function($compile, $httpBackend, $rootScope) {
+ $httpBackend.expect('GET', 'hello.html').respond('3==<
{{i}}
');
+ $compile(element)($rootScope);
+
+ $httpBackend.flush();
+ expect(element.text()).toEqual('i=1;i=2;');
+ }
+ ));
+ });
+
+
+ describe('scope', function() {
+ var iscope;
+
+ beforeEach(module(function($compileProvider) {
+ forEach(['', 'a', 'b'], function(name) {
+ $compileProvider.directive('scope' + uppercase(name), function(log) {
+ return {
+ scope: true,
+ restrict: 'CA',
+ compile: function() {
+ return function (scope, element) {
+ log(scope.$id);
+ expect(element.data('$scope')).toBe(scope);
+ };
+ }
+ };
+ });
+ $compileProvider.directive('iscope' + uppercase(name), function(log) {
+ return {
+ scope: {},
+ restrict: 'CA',
+ compile: function() {
+ return function (scope, element) {
+ iscope = scope;
+ log(scope.$id);
+ expect(element.data('$scope')).toBe(scope);
+ };
+ }
+ };
+ });
+ $compileProvider.directive('tiscope' + uppercase(name), function(log) {
+ return {
+ scope: {},
+ restrict: 'CA',
+ templateUrl: 'tiscope.html',
+ compile: function() {
+ return function (scope, element) {
+ iscope = scope;
+ log(scope.$id);
+ expect(element.data('$scope')).toBe(scope);
+ };
+ }
+ };
+ });
+ });
+ $compileProvider.directive('log', function(log) {
+ return {
+ restrict: 'CA',
+ link: function(scope) {
+ log('log-' + scope.$id + '-' + scope.$parent.$id);
+ }
+ };
+ });
+ }));
+
+
+ it('should allow creation of new scopes', inject(function($rootScope, $compile, log) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('LOG; log-002-001; 002');
+ expect(element.find('span').hasClass('ng-scope')).toBe(true);
+ }));
+
+
+ it('should allow creation of new isolated scopes for directives', inject(
+ function($rootScope, $compile, log) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('LOG; log-002-001; 002');
+ $rootScope.name = 'abc';
+ expect(iscope.$parent).toBe($rootScope);
+ expect(iscope.name).toBeUndefined();
+ }));
+
+
+ it('should allow creation of new isolated scopes for directives with templates', inject(
+ function($rootScope, $compile, log, $httpBackend) {
+ $httpBackend.expect('GET', 'tiscope.html').respond('');
+ element = $compile('')($rootScope);
+ $httpBackend.flush();
+ expect(log).toEqual('LOG; log-002-001; 002');
+ $rootScope.name = 'abc';
+ expect(iscope.$parent).toBe($rootScope);
+ expect(iscope.name).toBeUndefined();
+ }));
+
+
+ it('should correctly create the scope hierachy', inject(
+ function($rootScope, $compile, log) {
+ element = $compile(
+ '
' + //1
+ '' + //2
+ '' + //3
+ '' +
+ '' +
+ '' + //4
+ '' +
+ '' +
+ '
'
+ )($rootScope);
+ expect(log).toEqual('LOG; log-003-002; 003; LOG; log-002-001; 002; LOG; log-004-001; 004');
+ })
+ );
+
+
+ it('should allow more one new scope directives per element, but directives should share' +
+ 'the scope', inject(
+ function($rootScope, $compile, log) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('002; 002');
+ })
+ );
+
+ it('should not allow more then one isolate scope creation per element', inject(
+ function($rootScope, $compile) {
+ expect(function(){
+ $compile('');
+ }).toThrow('Multiple directives [iscopeA, scopeB] asking for isolated scope on: ' +
+ '<' + (msie < 9 ? 'DIV' : 'div') +
+ ' class="iscope-a; scope-b ng-isolate-scope ng-scope">');
+ })
+ );
+
+
+ it('should not allow more then one isolate scope creation per element', inject(
+ function($rootScope, $compile) {
+ expect(function(){
+ $compile('');
+ }).toThrow('Multiple directives [iscopeA, iscopeB] asking for isolated scope on: ' +
+ '<' + (msie < 9 ? 'DIV' : 'div') +
+ ' class="iscope-a; iscope-b ng-isolate-scope ng-scope">');
+ })
+ );
+
+
+ it('should create new scope even at the root of the template', inject(
+ function($rootScope, $compile, log) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('002');
+ })
+ );
+
+
+ it('should create isolate scope even at the root of the template', inject(
+ function($rootScope, $compile, log) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('002');
+ })
+ );
+ });
+ });
+ });
+
+
+ describe('interpolation', function() {
+ var observeSpy, attrValueDuringLinking;
+
+ beforeEach(module(function($compileProvider) {
+ $compileProvider.directive('observer', function() {
+ return function(scope, elm, attr) {
+ observeSpy = jasmine.createSpy('$observe attr');
+
+ attr.$observe('someAttr', observeSpy);
+ attrValueDuringLinking = attr.someAttr;
+ };
+ });
+ }));
+
+
+ it('should compile and link both attribute and text bindings', inject(
+ function($rootScope, $compile) {
+ $rootScope.name = 'angular';
+ element = $compile('text: {{name}}
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('text: angular');
+ expect(element.attr('name')).toEqual('attr: angular');
+ }));
+
+
+ it('should decorate the binding with ng-binding and interpolation function', inject(
+ function($compile, $rootScope) {
+ element = $compile('{{1+2}}
')($rootScope);
+ expect(element.hasClass('ng-binding')).toBe(true);
+ expect(element.data('$binding')[0].exp).toEqual('{{1+2}}');
+ }));
+
+
+ it('should observe interpolated attrs', inject(function($rootScope, $compile) {
+ $compile('')($rootScope);
+
+ // should be async
+ expect(observeSpy).not.toHaveBeenCalled();
+
+ $rootScope.$apply(function() {
+ $rootScope.value = 'bound-value';
+ });
+ expect(observeSpy).toHaveBeenCalledOnceWith('bound-value');
+ }));
+
+
+ it('should set interpolated attrs to undefined', inject(function($rootScope, $compile) {
+ attrValueDuringLinking = null;
+ $compile('')($rootScope);
+ expect(attrValueDuringLinking).toBeUndefined();
+ }));
+
+
+ it('should not call observer of non-interpolated attr', inject(function($rootScope, $compile) {
+ $compile('')($rootScope);
+ expect(attrValueDuringLinking).toBe('nonBound');
+
+ $rootScope.$digest();
+ expect(observeSpy).not.toHaveBeenCalled();
+ }));
+
+
+ it('should delegate exceptions to $exceptionHandler', function() {
+ observeSpy = jasmine.createSpy('$observe attr').andThrow('ERROR');
+
+ module(function($compileProvider, $exceptionHandlerProvider) {
+ $exceptionHandlerProvider.mode('log');
+ $compileProvider.directive('error', function() {
+ return function(scope, elm, attr) {
+ attr.$observe('someAttr', observeSpy);
+ attr.$observe('someAttr', observeSpy);
+ };
+ });
+ });
+
+ inject(function($compile, $rootScope, $exceptionHandler) {
+ $compile('')($rootScope);
+ $rootScope.$digest();
+
+ expect(observeSpy).toHaveBeenCalled();
+ expect(observeSpy.callCount).toBe(2);
+ expect($exceptionHandler.errors).toEqual(['ERROR', 'ERROR']);
+ });
+ });
+
+
+ it('should translate {{}} in terminal nodes', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.$digest();
+ expect(sortedHtml(element).replace(' selected="true"', '')).
+ toEqual('');
+ $rootScope.name = 'Misko';
+ $rootScope.$digest();
+ expect(sortedHtml(element).replace(' selected="true"', '')).
+ toEqual('');
+ }));
+ });
+
+
+ describe('link phase', function() {
+
+ beforeEach(module(function($compileProvider) {
+
+ forEach(['a', 'b', 'c'], function(name) {
+ $compileProvider.directive(name, function(log) {
+ return {
+ restrict: 'ECA',
+ compile: function() {
+ log('t' + uppercase(name))
+ return {
+ pre: function() {
+ log('pre' + uppercase(name));
+ },
+ post: function linkFn() {
+ log('post' + uppercase(name));
+ }
+ };
+ }
+ };
+ });
+ });
+ }));
+
+
+ it('should not store linkingFns for noop branches', inject(function ($rootScope, $compile) {
+ element = jqLite('ignore
');
+ var linkingFn = $compile(element);
+ // Now prune the branches with no directives
+ element.find('span').remove();
+ expect(element.find('span').length).toBe(0);
+ // and we should still be able to compile without errors
+ linkingFn($rootScope);
+ }));
+
+
+ it('should compile from top to bottom but link from bottom up', inject(
+ function($compile, $rootScope, log) {
+ element = $compile('FAIL
')($rootScope);
+ expect(element.text()).toEqual('WORKS');
+ });
+ });
+ });
+
+
+ describe('attrs', function() {
+
+ it('should allow setting of attributes', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive({
+ setter: valueFn(function(scope, element, attr) {
+ attr.$set('name', 'abc');
+ attr.$set('disabled', true);
+ expect(attr.name).toBe('abc');
+ expect(attr.disabled).toBe(true);
+ })
+ });
+ });
+ inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(element.attr('name')).toEqual('abc');
+ expect(element.attr('disabled')).toEqual('disabled');
+ });
+ });
+
+
+ it('should read boolean attributes as boolean only on control elements', function() {
+ var value;
+ module(function($compileProvider) {
+ $compileProvider.directive({
+ input: valueFn({
+ restrict: 'ECA',
+ link:function(scope, element, attr) {
+ value = attr.required;
+ }
+ })
+ });
+ });
+ inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(value).toEqual(true);
+ });
+ });
+
+ it('should read boolean attributes as text on non-controll elements', function() {
+ var value;
+ module(function($compileProvider) {
+ $compileProvider.directive({
+ div: valueFn({
+ restrict: 'ECA',
+ link:function(scope, element, attr) {
+ value = attr.required;
+ }
+ })
+ });
+ });
+ inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(value).toEqual('some text');
+ });
+ });
+
+ it('should allow setting of attributes', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive({
+ setter: valueFn(function(scope, element, attr) {
+ attr.$set('name', 'abc');
+ attr.$set('disabled', true);
+ expect(attr.name).toBe('abc');
+ expect(attr.disabled).toBe(true);
+ })
+ });
+ });
+ inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ expect(element.attr('name')).toEqual('abc');
+ expect(element.attr('disabled')).toEqual('disabled');
+ });
+ });
+
+
+ it('should create new instance of attr for each template stamping', function() {
+ module(function($compileProvider, $provide) {
+ var state = { first: [], second: [] };
+ $provide.value('state', state);
+ $compileProvider.directive({
+ first: valueFn({
+ priority: 1,
+ compile: function(templateElement, templateAttr) {
+ return function(scope, element, attr) {
+ state.first.push({
+ template: {element: templateElement, attr:templateAttr},
+ link: {element: element, attr: attr}
+ });
+ }
+ }
+ }),
+ second: valueFn({
+ priority: 2,
+ compile: function(templateElement, templateAttr) {
+ return function(scope, element, attr) {
+ state.second.push({
+ template: {element: templateElement, attr:templateAttr},
+ link: {element: element, attr: attr}
+ });
+ }
+ }
+ })
+ });
+ });
+ inject(function($rootScope, $compile, state) {
+ var template = $compile('');
+ dealoc(template($rootScope.$new(), noop));
+ dealoc(template($rootScope.$new(), noop));
+
+ // instance between directives should be shared
+ expect(state.first[0].template.element).toBe(state.second[0].template.element);
+ expect(state.first[0].template.attr).toBe(state.second[0].template.attr);
+
+ // the template and the link can not be the same instance
+ expect(state.first[0].template.element).not.toBe(state.first[0].link.element);
+ expect(state.first[0].template.attr).not.toBe(state.first[0].link.attr);
+
+ // each new template needs to be new instance
+ expect(state.first[0].link.element).not.toBe(state.first[1].link.element);
+ expect(state.first[0].link.attr).not.toBe(state.first[1].link.attr);
+ expect(state.second[0].link.element).not.toBe(state.second[1].link.element);
+ expect(state.second[0].link.attr).not.toBe(state.second[1].link.attr);
+ });
+ });
+
+
+ describe('$set', function() {
+ var attr;
+ beforeEach(function(){
+ module(function($compileProvider) {
+ $compileProvider.directive('input', valueFn({
+ restrict: 'ECA',
+ link: function(scope, element, attr) {
+ scope.attr = attr;
+ }
+ }));
+ });
+ inject(function($compile, $rootScope) {
+ element = $compile('')($rootScope);
+ attr = $rootScope.attr;
+ expect(attr).toBeDefined();
+ });
+ });
+
+
+ it('should set attributes', function() {
+ attr.$set('ngMyAttr', 'value');
+ expect(element.attr('ng-my-attr')).toEqual('value');
+ expect(attr.ngMyAttr).toEqual('value');
+ });
+
+
+ it('should allow overriding of attribute name and remember the name', function() {
+ attr.$set('ngOther', '123', true, 'other');
+ expect(element.attr('other')).toEqual('123');
+ expect(attr.ngOther).toEqual('123');
+
+ attr.$set('ngOther', '246');
+ expect(element.attr('other')).toEqual('246');
+ expect(attr.ngOther).toEqual('246');
+ });
+
+
+ it('should remove attribute', function() {
+ attr.$set('ngMyAttr', 'value');
+ expect(element.attr('ng-my-attr')).toEqual('value');
+
+ attr.$set('ngMyAttr', undefined);
+ expect(element.attr('ng-my-attr')).toBe(undefined);
+
+ attr.$set('ngMyAttr', 'value');
+ attr.$set('ngMyAttr', null);
+ expect(element.attr('ng-my-attr')).toBe(undefined);
+ });
+
+
+ it('should not set DOM element attr if writeAttr false', function() {
+ attr.$set('test', 'value', false);
+
+ expect(element.attr('test')).toBeUndefined();
+ expect(attr.test).toBe('value');
+ });
+ });
+ });
+
+
+ describe('locals', function() {
+ it('should marshal to locals', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('widget', function(log) {
+ return {
+ scope: {
+ attr: 'attribute',
+ prop: 'evaluate',
+ bind: 'bind',
+ assign: 'accessor',
+ read: 'accessor',
+ exp: 'expression',
+ nonExist: 'accessor',
+ nonExistExpr: 'expression'
+ },
+ link: function(scope, element, attrs) {
+ scope.nonExist(); // noop
+ scope.nonExist(123); // noop
+ scope.nonExistExpr(); // noop
+ scope.nonExistExpr(123); // noop
+ log(scope.attr);
+ log(scope.prop);
+ log(scope.assign());
+ log(scope.read());
+ log(scope.assign('ng'));
+ scope.exp({myState:'OK'});
+ expect(function() { scope.read(undefined); }).
+ toThrow("Expression ''D'' not assignable.");
+ scope.$watch('bind', log);
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ $rootScope.myProp = 'B';
+ $rootScope.bi = {nd: 'C'};
+ $rootScope.name = 'C';
+ element = $compile(
+ '')
+ ($rootScope);
+ expect(log).toEqual('A; B; C; D; ng');
+ expect($rootScope.name).toEqual('ng');
+ expect($rootScope.state).toEqual('OK');
+ log.reset();
+ $rootScope.$apply();
+ expect(element.text()).toEqual('C');
+ expect(log).toEqual('C');
+ $rootScope.bi.nd = 'c';
+ $rootScope.$apply();
+ expect(log).toEqual('C; c');
+ });
+ });
+ });
+
+
+ describe('controller', function() {
+ it('should inject locals to controller', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('widget', function(log) {
+ return {
+ controller: function(attr, prop, assign, read, exp){
+ log(attr);
+ log(prop);
+ log(assign());
+ log(read());
+ log(assign('ng'));
+ exp();
+ expect(function() { read(undefined); }).
+ toThrow("Expression ''D'' not assignable.");
+ this.result = 'OK';
+ },
+ inject: {
+ attr: 'attribute',
+ prop: 'evaluate',
+ assign: 'accessor',
+ read: 'accessor',
+ exp: 'expression'
+ },
+ link: function(scope, element, attrs, controller) {
+ log(controller.result);
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ $rootScope.myProp = 'B';
+ $rootScope.bi = {nd: 'C'};
+ $rootScope.name = 'C';
+ element = $compile(
+ '')
+ ($rootScope);
+ expect(log).toEqual('A; B; C; D; ng; OK');
+ expect($rootScope.name).toEqual('ng');
+ });
+ });
+
+
+ it('should get required controller', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('main', function(log) {
+ return {
+ priority: 2,
+ controller: function() {
+ this.name = 'main';
+ },
+ link: function(scope, element, attrs, controller) {
+ log(controller.name);
+ }
+ };
+ });
+ $compileProvider.directive('dep', function(log) {
+ return {
+ priority: 1,
+ require: 'main',
+ link: function(scope, element, attrs, controller) {
+ log('dep:' + controller.name);
+ }
+ };
+ });
+ $compileProvider.directive('other', function(log) {
+ return {
+ link: function(scope, element, attrs, controller) {
+ log(!!controller); // should be false
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ element = $compile('')($rootScope);
+ expect(log).toEqual('main; dep:main; false');
+ });
+ });
+
+
+ it('should require controller on parent element',function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('main', function(log) {
+ return {
+ controller: function() {
+ this.name = 'main';
+ }
+ };
+ });
+ $compileProvider.directive('dep', function(log) {
+ return {
+ require: '^main',
+ link: function(scope, element, attrs, controller) {
+ log('dep:' + controller.name);
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ element = $compile('')
+ ($rootScope);
+ $rootScope.$apply();
+ expect(log).toEqual('compile: ; HIGH; link; LOG; LOG');
+ expect(element.text()).toEqual('001-002;001-003;');
+ });
+ });
+
+
+ it('should support transclude directive', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('trans', function() {
+ return {
+ transclude: 'content',
+ replace: true,
+ scope: true,
+ template: '')
+ ($rootScope);
+ $rootScope.$apply();
+ expect(element.text()).toEqual('W:001-002;T:001-003;');
+ expect(jqLite(element.find('span')[0]).text()).toEqual('T:001-003');
+ expect(jqLite(element.find('span')[1]).text()).toEqual(';');
+ });
+ });
+
+
+ it('should transclude transcluded content', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('book', valueFn({
+ transclude: 'content',
+ template: '
'
+ }));
+ return function($httpBackend) {
+ $httpBackend.
+ expect('GET', 'chapter.html').
+ respond('{{bind}}
{{bind}}
')($rootScope);
+ expect(log).toEqual('dep:main');
+ });
+ });
+
+
+ it('should have optional controller on current element', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('dep', function(log) {
+ return {
+ require: '?main',
+ link: function(scope, element, attrs, controller) {
+ log('dep:' + !!controller);
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ element = $compile('
')($rootScope);
+ expect(log).toEqual('dep:false');
+ });
+ });
+
+
+ it('should support multiple controllers', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('c1', valueFn({
+ controller: function() { this.name = 'c1'; }
+ }));
+ $compileProvider.directive('c2', valueFn({
+ controller: function() { this.name = 'c2'; }
+ }));
+ $compileProvider.directive('dep', function(log) {
+ return {
+ require: ['^c1', '^c2'],
+ link: function(scope, element, attrs, controller) {
+ log('dep:' + controller[0].name + '-' + controller[1].name);
+ }
+ };
+ });
+ });
+ inject(function(log, $compile, $rootScope) {
+ element = $compile('
')($rootScope);
+ expect(log).toEqual('dep:c1-c2');
+ });
+
+ });
+ });
+
+
+ describe('transclude', function() {
+ it('should compile get templateFn', function() {
+ module(function($compileProvider) {
+ $compileProvider.directive('trans', function(log) {
+ return {
+ transclude: 'element',
+ priority: 2,
+ controller: function($transclude) { this.$transclude = $transclude; },
+ compile: function(element, attrs, template) {
+ log('compile: ' + angular.mock.dump(element));
+ return function(scope, element, attrs, ctrl) {
+ log('link');
+ var cursor = element;
+ template(scope.$new(), function(clone) {cursor.after(cursor = clone)});
+ ctrl.$transclude(function(clone) {cursor.after(clone)});
+ };
+ }
+ }
+ });
+ });
+ inject(function(log, $rootScope, $compile) {
+ element = $compile('
{{$parent.$id}}-{{$id}};
- W:{{$parent.$id}}-{{$id}};
T:{{$parent.$id}}-{{$id}};
book-
'
+ }));
+ $compileProvider.directive('chapter', valueFn({
+ transclude: 'content',
+ templateUrl: 'chapter.html'
+ }));
+ $compileProvider.directive('section', valueFn({
+ transclude: 'content',
+ template: '()
section-!!
chapter-
');
+ }
+ });
+ inject(function(log, $rootScope, $compile, $httpBackend) {
+ element = $compile('[]
paragraph
Hello: {{name}}!
user: {{username}}
beforeafter
').contents();
+ expect(element.length).toEqual(3);
+ expect(nodeName_(element[1])).toBe('DIV');
+ $compile(element)($rootScope);
+ expect(nodeName_(element[1])).toBe('#comment');
+ expect(nodeName_(comment)).toBe('#comment');
+ });
+ });
+ });
+});
diff --git a/test/ng/controllerSpec.js b/test/ng/controllerSpec.js
new file mode 100644
index 00000000..91389013
--- /dev/null
+++ b/test/ng/controllerSpec.js
@@ -0,0 +1,73 @@
+'use strict';
+
+describe('$controller', function() {
+ var $controllerProvider, $controller;
+
+ beforeEach(module(function(_$controllerProvider_) {
+ $controllerProvider = _$controllerProvider_;
+ }));
+
+
+ beforeEach(inject(function(_$controller_) {
+ $controller = _$controller_;
+ }));
+
+
+ describe('provider', function() {
+
+ it('should allow registration of controllers', function() {
+ var FooCtrl = function($scope) { $scope.foo = 'bar' },
+ scope = {},
+ ctrl;
+
+ $controllerProvider.register('FooCtrl', FooCtrl);
+ ctrl = $controller('FooCtrl', {$scope: scope});
+
+ expect(scope.foo).toBe('bar');
+ expect(ctrl instanceof FooCtrl).toBe(true);
+ });
+
+
+ it('should allow registration of controllers annotated with arrays', function() {
+ var FooCtrl = function($scope) { $scope.foo = 'bar' },
+ scope = {},
+ ctrl;
+
+ $controllerProvider.register('FooCtrl', ['$scope', FooCtrl]);
+ ctrl = $controller('FooCtrl', {$scope: scope});
+
+ expect(scope.foo).toBe('bar');
+ expect(ctrl instanceof FooCtrl).toBe(true);
+ });
+ });
+
+
+ it('should return instance of given controller class', function() {
+ var MyClass = function() {},
+ ctrl = $controller(MyClass);
+
+ expect(ctrl).toBeDefined();
+ expect(ctrl instanceof MyClass).toBe(true);
+ });
+
+ it('should inject arguments', inject(function($http) {
+ var MyClass = function($http) {
+ this.$http = $http;
+ };
+
+ var ctrl = $controller(MyClass);
+ expect(ctrl.$http).toBe($http);
+ }));
+
+
+ it('should inject given scope', function() {
+ var MyClass = function($scope) {
+ this.$scope = $scope;
+ };
+
+ var scope = {},
+ ctrl = $controller(MyClass, {$scope: scope});
+
+ expect(ctrl.$scope).toBe(scope);
+ });
+});
diff --git a/test/ng/cookieStoreSpec.js b/test/ng/cookieStoreSpec.js
new file mode 100644
index 00000000..50ac7797
--- /dev/null
+++ b/test/ng/cookieStoreSpec.js
@@ -0,0 +1,30 @@
+'use strict';
+
+describe('$cookieStore', function() {
+
+
+ it('should serialize objects to json', inject(function($cookieStore, $browser, $rootScope) {
+ $cookieStore.put('objectCookie', {id: 123, name: 'blah'});
+ $rootScope.$digest();
+ expect($browser.cookies()).toEqual({'objectCookie': '{"id":123,"name":"blah"}'});
+ }));
+
+
+ it('should deserialize json to object', inject(function($cookieStore, $browser) {
+ $browser.cookies('objectCookie', '{"id":123,"name":"blah"}');
+ $browser.poll();
+ expect($cookieStore.get('objectCookie')).toEqual({id: 123, name: 'blah'});
+ }));
+
+
+ it('should delete objects from the store when remove is called', inject(function($cookieStore, $browser, $rootScope) {
+ $cookieStore.put('gonner', { "I'll":"Be Back"});
+ $rootScope.$digest(); //force eval in test
+ $browser.poll();
+ expect($browser.cookies()).toEqual({'gonner': '{"I\'ll":"Be Back"}'});
+
+ $cookieStore.remove('gonner');
+ $rootScope.$digest();
+ expect($browser.cookies()).toEqual({});
+ }));
+});
diff --git a/test/ng/cookiesSpec.js b/test/ng/cookiesSpec.js
new file mode 100644
index 00000000..5427ac36
--- /dev/null
+++ b/test/ng/cookiesSpec.js
@@ -0,0 +1,97 @@
+'use strict';
+
+describe('$cookies', function() {
+ beforeEach(module(function($provide) {
+ $provide.factory('$browser', function(){
+ return angular.extend(new angular.mock.$Browser(), {cookieHash: {preexisting:'oldCookie'}});
+ });
+ }));
+
+
+ it('should provide access to existing cookies via object properties and keep them in sync',
+ inject(function($cookies, $browser, $rootScope) {
+ expect($cookies).toEqual({'preexisting': 'oldCookie'});
+
+ // access internal cookie storage of the browser mock directly to simulate behavior of
+ // document.cookie
+ $browser.cookieHash['brandNew'] = 'cookie';
+ $browser.poll();
+
+ expect($cookies).toEqual({'preexisting': 'oldCookie', 'brandNew':'cookie'});
+
+ $browser.cookieHash['brandNew'] = 'cookie2';
+ $browser.poll();
+ expect($cookies).toEqual({'preexisting': 'oldCookie', 'brandNew':'cookie2'});
+
+ delete $browser.cookieHash['brandNew'];
+ $browser.poll();
+ expect($cookies).toEqual({'preexisting': 'oldCookie'});
+ }));
+
+
+ it('should create or update a cookie when a value is assigned to a property',
+ inject(function($cookies, $browser, $rootScope) {
+ $cookies.oatmealCookie = 'nom nom';
+ $rootScope.$digest();
+
+ expect($browser.cookies()).
+ toEqual({'preexisting': 'oldCookie', 'oatmealCookie':'nom nom'});
+
+ $cookies.oatmealCookie = 'gone';
+ $rootScope.$digest();
+
+ expect($browser.cookies()).
+ toEqual({'preexisting': 'oldCookie', 'oatmealCookie': 'gone'});
+ }));
+
+
+ it('should drop or reset any cookie that was set to a non-string value',
+ inject(function($cookies, $browser, $rootScope) {
+ $cookies.nonString = [1, 2, 3];
+ $cookies.nullVal = null;
+ $cookies.undefVal = undefined;
+ $cookies.preexisting = function() {};
+ $rootScope.$digest();
+ expect($browser.cookies()).toEqual({'preexisting': 'oldCookie'});
+ expect($cookies).toEqual({'preexisting': 'oldCookie'});
+ }));
+
+
+ it('should remove a cookie when a $cookies property is deleted',
+ inject(function($cookies, $browser, $rootScope) {
+ $cookies.oatmealCookie = 'nom nom';
+ $rootScope.$digest();
+ $browser.poll();
+ expect($browser.cookies()).
+ toEqual({'preexisting': 'oldCookie', 'oatmealCookie':'nom nom'});
+
+ delete $cookies.oatmealCookie;
+ $rootScope.$digest();
+
+ expect($browser.cookies()).toEqual({'preexisting': 'oldCookie'});
+ }));
+
+
+ it('should drop or reset cookies that browser refused to store',
+ inject(function($cookies, $browser, $rootScope) {
+ var i, longVal;
+
+ for (i=0; i<5000; i++) {
+ longVal += '*';
+ }
+
+ //drop if no previous value
+ $cookies.longCookie = longVal;
+ $rootScope.$digest();
+ expect($cookies).toEqual({'preexisting': 'oldCookie'});
+
+
+ //reset if previous value existed
+ $cookies.longCookie = 'shortVal';
+ $rootScope.$digest();
+ expect($cookies).toEqual({'preexisting': 'oldCookie', 'longCookie': 'shortVal'});
+ $cookies.longCookie = longVal;
+ $rootScope.$digest();
+ expect($cookies).toEqual({'preexisting': 'oldCookie', 'longCookie': 'shortVal'});
+ }));
+});
diff --git a/test/ng/deferSpec.js b/test/ng/deferSpec.js
new file mode 100644
index 00000000..48c9e912
--- /dev/null
+++ b/test/ng/deferSpec.js
@@ -0,0 +1,113 @@
+'use strict';
+
+describe('$defer', function() {
+ beforeEach(module(function($provide) {
+ $provide.factory('$exceptionHandler', function(){
+ return jasmine.createSpy('$exceptionHandler');
+ });
+ }));
+
+
+ it('should delegate functions to $browser.defer', inject(function($defer, $browser, $exceptionHandler) {
+ var counter = 0;
+ $defer(function() { counter++; });
+
+ expect(counter).toBe(0);
+
+ $browser.defer.flush();
+ expect(counter).toBe(1);
+
+ expect(function() {$browser.defer.flush();}).toThrow('No deferred tasks to be flushed');
+ expect(counter).toBe(1);
+
+ expect($exceptionHandler).not.toHaveBeenCalled();
+ }));
+
+
+ it('should delegate exception to the $exceptionHandler service', inject(function($defer, $browser, $exceptionHandler) {
+ $defer(function() {throw "Test Error";});
+ expect($exceptionHandler).not.toHaveBeenCalled();
+
+ $browser.defer.flush();
+ expect($exceptionHandler).toHaveBeenCalledWith("Test Error");
+ }));
+
+
+ it('should call $apply after each callback is executed', inject(function($defer, $browser, $rootScope) {
+ var applySpy = this.spyOn($rootScope, '$apply').andCallThrough();
+
+ $defer(function() {});
+ expect(applySpy).not.toHaveBeenCalled();
+
+ $browser.defer.flush();
+ expect(applySpy).toHaveBeenCalled();
+
+ applySpy.reset(); //reset the spy;
+
+ $defer(function() {});
+ $defer(function() {});
+ $browser.defer.flush();
+ expect(applySpy.callCount).toBe(2);
+ }));
+
+
+ it('should call $apply even if an exception is thrown in callback', inject(function($defer, $browser, $rootScope) {
+ var applySpy = this.spyOn($rootScope, '$apply').andCallThrough();
+
+ $defer(function() {throw "Test Error";});
+ expect(applySpy).not.toHaveBeenCalled();
+
+ $browser.defer.flush();
+ expect(applySpy).toHaveBeenCalled();
+ }));
+
+
+ it('should allow you to specify the delay time', inject(function($defer, $browser) {
+ var defer = this.spyOn($browser, 'defer');
+ $defer(noop, 123);
+ expect(defer.callCount).toEqual(1);
+ expect(defer.mostRecentCall.args[1]).toEqual(123);
+ }));
+
+
+ it('should return a cancelation token', inject(function($defer, $browser) {
+ var defer = this.spyOn($browser, 'defer').andReturn('xxx');
+ expect($defer(noop)).toEqual('xxx');
+ }));
+
+
+ describe('cancel', function() {
+ it('should cancel tasks', inject(function($defer, $browser) {
+ var task1 = jasmine.createSpy('task1'),
+ task2 = jasmine.createSpy('task2'),
+ task3 = jasmine.createSpy('task3'),
+ token1, token3;
+
+ token1 = $defer(task1);
+ $defer(task2);
+ token3 = $defer(task3, 333);
+
+ $defer.cancel(token3);
+ $defer.cancel(token1);
+ $browser.defer.flush();
+
+ expect(task1).not.toHaveBeenCalled();
+ expect(task2).toHaveBeenCalledOnce();
+ expect(task3).not.toHaveBeenCalled();
+ }));
+
+
+ it('should return true if a task was succesffuly canceled', inject(function($defer, $browser) {
+ var task1 = jasmine.createSpy('task1'),
+ task2 = jasmine.createSpy('task2'),
+ token1, token2;
+
+ token1 = $defer(task1);
+ $browser.defer.flush();
+ token2 = $defer(task2);
+
+ expect($defer.cancel(token1)).toBe(false);
+ expect($defer.cancel(token2)).toBe(true);
+ }));
+ });
+});
diff --git a/test/ng/directive/aSpec.js b/test/ng/directive/aSpec.js
new file mode 100644
index 00000000..8aa2449d
--- /dev/null
+++ b/test/ng/directive/aSpec.js
@@ -0,0 +1,46 @@
+'use strict';
+
+describe('a', function() {
+ var element;
+
+
+ afterEach(function(){
+ dealoc(element);
+ });
+
+
+ it('should prevent default action to be executed when href is empty',
+ inject(function($rootScope, $compile) {
+ var orgLocation = document.location.href,
+ preventDefaultCalled = false,
+ event;
+
+ element = $compile('empty link')($rootScope);
+
+ if (msie < 9) {
+
+ event = document.createEventObject();
+ expect(event.returnValue).not.toBeDefined();
+ element[0].fireEvent('onclick', event);
+ expect(event.returnValue).toEqual(false);
+
+ } else {
+
+ event = document.createEvent('MouseEvent');
+ event.initMouseEvent(
+ 'click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+
+ event.preventDefaultOrg = event.preventDefault;
+ event.preventDefault = function() {
+ preventDefaultCalled = true;
+ if (this.preventDefaultOrg) this.preventDefaultOrg();
+ };
+
+ element[0].dispatchEvent(event);
+
+ expect(preventDefaultCalled).toEqual(true);
+ }
+
+ expect(document.location.href).toEqual(orgLocation);
+ }));
+});
diff --git a/test/ng/directive/booleanAttrDirSpecs.js b/test/ng/directive/booleanAttrDirSpecs.js
new file mode 100644
index 00000000..7a4244a8
--- /dev/null
+++ b/test/ng/directive/booleanAttrDirSpecs.js
@@ -0,0 +1,125 @@
+'use strict';
+
+describe('boolean attr directives', function() {
+ var element;
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should bind href', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.url = 'http://server'
+ $rootScope.$digest();
+ expect(element.attr('href')).toEqual('http://server');
+ }));
+
+
+ it('should bind disabled', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.isDisabled = false;
+ $rootScope.$digest();
+ expect(element.attr('disabled')).toBeFalsy();
+ $rootScope.isDisabled = true;
+ $rootScope.$digest();
+ expect(element.attr('disabled')).toBeTruthy();
+ }));
+
+
+ it('should bind checked', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.isChecked = false;
+ $rootScope.$digest();
+ expect(element.attr('checked')).toBeFalsy();
+ $rootScope.isChecked=true;
+ $rootScope.$digest();
+ expect(element.attr('checked')).toBeTruthy();
+ }));
+
+
+ it('should bind selected', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ jqLite(document.body).append(element)
+ $rootScope.isSelected=false;
+ $rootScope.$digest();
+ expect(element.children()[1].selected).toBeFalsy();
+ $rootScope.isSelected=true;
+ $rootScope.$digest();
+ expect(element.children()[1].selected).toBeTruthy();
+ }));
+
+
+ it('should bind readonly', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.isReadonly=false;
+ $rootScope.$digest();
+ expect(element.attr('readOnly')).toBeFalsy();
+ $rootScope.isReadonly=true;
+ $rootScope.$digest();
+ expect(element.attr('readOnly')).toBeTruthy();
+ }));
+
+
+ it('should bind multiple', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.isMultiple=false;
+ $rootScope.$digest();
+ expect(element.attr('multiple')).toBeFalsy();
+ $rootScope.isMultiple='multiple';
+ $rootScope.$digest();
+ expect(element.attr('multiple')).toBeTruthy();
+ }));
+
+
+ it('should bind src', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope)
+ $rootScope.url = 'http://localhost/';
+ $rootScope.$digest();
+ expect(element.attr('src')).toEqual('http://localhost/');
+ }));
+
+
+ it('should bind href and merge with other attrs', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.url = 'http://server';
+ $rootScope.rel = 'REL';
+ $rootScope.$digest();
+ expect(element.attr('href')).toEqual('http://server');
+ expect(element.attr('rel')).toEqual('REL');
+ }));
+});
+
+
+describe('ng-src', function() {
+
+ it('should interpolate the expression and bind to src', inject(function($compile, $rootScope) {
+ var element = $compile('')($rootScope)
+ $rootScope.$digest();
+ expect(element.attr('src')).toEqual('some/');
+
+ $rootScope.$apply(function() {
+ $rootScope.id = 1;
+ });
+ expect(element.attr('src')).toEqual('some/1');
+
+ dealoc(element);
+ }));
+});
+
+
+describe('ng-href', function() {
+
+ it('should interpolate the expression and bind to href', inject(function($compile, $rootScope) {
+ var element = $compile('')($rootScope)
+ $rootScope.$digest();
+ expect(element.attr('href')).toEqual('some/');
+
+ $rootScope.$apply(function() {
+ $rootScope.id = 1;
+ });
+ expect(element.attr('href')).toEqual('some/1');
+
+ dealoc(element);
+ }));
+});
diff --git a/test/ng/directive/formSpec.js b/test/ng/directive/formSpec.js
new file mode 100644
index 00000000..5c34b5ad
--- /dev/null
+++ b/test/ng/directive/formSpec.js
@@ -0,0 +1,294 @@
+'use strict';
+
+describe('form', function() {
+ var doc, control, scope, $compile;
+
+ beforeEach(module(function($compileProvider) {
+ $compileProvider.directive('storeModelCtrl', function() {
+ return {
+ require: 'ngModel',
+ link: function(scope, elm, attr, ctrl) {
+ control = ctrl;
+ }
+ };
+ });
+ }));
+
+ beforeEach(inject(function($injector) {
+ $compile = $injector.get('$compile');
+ scope = $injector.get('$rootScope');
+ }));
+
+ afterEach(function() {
+ dealoc(doc);
+ });
+
+
+ it('should instantiate form and attach it to DOM', function() {
+ doc = $compile('')(scope);
+
+ var form = scope.myForm;
+ control.$setValidity('required', false);
+ expect(form.alias).toBe(control);
+ expect(form.$error.required).toEqual([control]);
+
+ doc.find('input').remove();
+ expect(form.$error.required).toBe(false);
+ expect(form.alias).toBeUndefined();
+ });
+
+
+ it('should use ng-form as form name', function() {
+ doc = $compile(
+ '' +
+ '' +
+ '
')(scope);
+
+ expect(scope.myForm).toBeDefined();
+ expect(scope.myForm.alias).toBeDefined();
+ });
+
+
+ it('should prevent form submission', function() {
+ var startingUrl = '' + window.location;
+ doc = jqLite('')(scope);
+ doc.bind('submit', callback);
+
+ browserTrigger(doc, 'submit');
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it('should publish form to scope when name attr is defined', function() {
+ doc = $compile('')(scope);
+ expect(scope.myForm).toBeTruthy();
+ expect(doc.data('$formController')).toBeTruthy();
+ expect(doc.data('$formController')).toEqual(scope.myForm);
+ });
+
+
+ it('should allow form name to be an expression', function() {
+ doc = $compile('')(scope);
+
+ expect(scope['obj.myForm']).toBeTruthy();
+ });
+
+
+ it('should support two forms on a single scope', function() {
+ doc = $compile(
+ '' +
+ '' +
+ '' +
+ '
'
+ )(scope);
+
+ scope.$apply();
+
+ expect(scope.formA.$error.required.length).toBe(1);
+ expect(scope.formA.$error.required).toEqual([scope.formA.firstName]);
+ expect(scope.formB.$error.required.length).toBe(1);
+ expect(scope.formB.$error.required).toEqual([scope.formB.lastName]);
+
+ var inputA = doc.find('input').eq(0),
+ inputB = doc.find('input').eq(1);
+
+ inputA.val('val1');
+ browserTrigger(inputA, 'blur');
+ inputB.val('val2');
+ browserTrigger(inputB, 'blur');
+
+ expect(scope.firstName).toBe('val1');
+ expect(scope.lastName).toBe('val2');
+
+ expect(scope.formA.$error.required).toBe(false);
+ expect(scope.formB.$error.required).toBe(false);
+ });
+
+
+ it('should publish widgets', function() {
+ doc = jqLite('');
+ $compile(doc)(scope);
+
+ var widget = scope.form.w1;
+ expect(widget).toBeDefined();
+ expect(widget.$pristine).toBe(true);
+ expect(widget.$dirty).toBe(false);
+ expect(widget.$valid).toBe(true);
+ expect(widget.$invalid).toBe(false);
+ });
+
+
+ describe('nested forms', function() {
+
+ it('should chain nested forms', function() {
+ doc = jqLite(
+ 'hello
';
+ $rootScope.$digest();
+ expect(lowercase(element.html())).toEqual('hello
');
+ }));
+
+ it('should set unsafe html', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.html = 'hello
';
+ $rootScope.$digest();
+ expect(lowercase(element.html())).toEqual('hello
');
+ }));
+
+ it('should suppress rendering of falsy values', inject(function($rootScope, $compile) {
+ element = $compile('{{ null }}{{ undefined }}{{ "" }}-{{ 0 }}{{ false }}
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toEqual('-0false');
+ }));
+
+ it('should render object as JSON ignore $$', inject(function($rootScope, $compile) {
+ element = $compile('{{ {key:"value", $$key:"hide"} }}
')($rootScope);
+ $rootScope.$digest();
+ expect(fromJson(element.text())).toEqual({key:'value'});
+ }));
+ });
+
+
+ describe('ng-bind-template', function() {
+
+ it('should ng-bind-template', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.name = 'Misko';
+ $rootScope.$digest();
+ expect(element.hasClass('ng-binding')).toEqual(true);
+ expect(element.text()).toEqual('Hello Misko!');
+ }));
+
+ it('should render object as JSON ignore $$', inject(function($rootScope, $compile) {
+ element = $compile('{{ {key:"value", $$key:"hide"} }}')($rootScope);
+ $rootScope.$digest();
+ expect(fromJson(element.text())).toEqual({key:'value'});
+ }));
+ });
+});
diff --git a/test/ng/directive/ngClassSpec.js b/test/ng/directive/ngClassSpec.js
new file mode 100644
index 00000000..2297e343
--- /dev/null
+++ b/test/ng/directive/ngClassSpec.js
@@ -0,0 +1,204 @@
+'use strict';
+
+describe('ng-class', function() {
+ var element;
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should add new and remove old classes dynamically', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynClass = 'A';
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBe(true);
+ expect(element.hasClass('A')).toBe(true);
+
+ $rootScope.dynClass = 'B';
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBe(true);
+ expect(element.hasClass('A')).toBe(false);
+ expect(element.hasClass('B')).toBe(true);
+
+ delete $rootScope.dynClass;
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBe(true);
+ expect(element.hasClass('A')).toBe(false);
+ expect(element.hasClass('B')).toBe(false);
+ }));
+
+
+ it('should support adding multiple classes via an array', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBeTruthy();
+ expect(element.hasClass('A')).toBeTruthy();
+ expect(element.hasClass('B')).toBeTruthy();
+ }));
+
+
+ it('should support adding multiple classes conditionally via a map of class names to boolean' +
+ 'expressions', inject(function($rootScope, $compile) {
+ var element = $compile(
+ '' +
+ '
')($rootScope);
+ $rootScope.conditionA = true;
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBeTruthy();
+ expect(element.hasClass('A')).toBeTruthy();
+ expect(element.hasClass('B')).toBeFalsy();
+ expect(element.hasClass('AnotB')).toBeTruthy();
+
+ $rootScope.conditionB = function() { return true };
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBeTruthy();
+ expect(element.hasClass('A')).toBeTruthy();
+ expect(element.hasClass('B')).toBeTruthy();
+ expect(element.hasClass('AnotB')).toBeFalsy();
+ }));
+
+
+ it('should support adding multiple classes via a space delimited string', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBeTruthy();
+ expect(element.hasClass('A')).toBeTruthy();
+ expect(element.hasClass('B')).toBeTruthy();
+ }));
+
+
+ it('should preserve class added post compilation with pre-existing classes', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynClass = 'A';
+ $rootScope.$digest();
+ expect(element.hasClass('existing')).toBe(true);
+
+ // add extra class, change model and eval
+ element.addClass('newClass');
+ $rootScope.dynClass = 'B';
+ $rootScope.$digest();
+
+ expect(element.hasClass('existing')).toBe(true);
+ expect(element.hasClass('B')).toBe(true);
+ expect(element.hasClass('newClass')).toBe(true);
+ }));
+
+
+ it('should preserve class added post compilation without pre-existing classes"', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynClass = 'A';
+ $rootScope.$digest();
+ expect(element.hasClass('A')).toBe(true);
+
+ // add extra class, change model and eval
+ element.addClass('newClass');
+ $rootScope.dynClass = 'B';
+ $rootScope.$digest();
+
+ expect(element.hasClass('B')).toBe(true);
+ expect(element.hasClass('newClass')).toBe(true);
+ }));
+
+
+ it('should preserve other classes with similar name"', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynCls = 'panel';
+ $rootScope.$digest();
+ $rootScope.dynCls = 'foo';
+ $rootScope.$digest();
+ expect(element[0].className).toBe('ui-panel ui-selected ng-scope foo');
+ }));
+
+
+ it('should not add duplicate classes', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynCls = 'panel';
+ $rootScope.$digest();
+ expect(element[0].className).toBe('panel bar ng-scope');
+ }));
+
+
+ it('should remove classes even if it was specified via class attribute', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynCls = 'panel';
+ $rootScope.$digest();
+ $rootScope.dynCls = 'window';
+ $rootScope.$digest();
+ expect(element[0].className).toBe('bar ng-scope window');
+ }));
+
+
+ it('should remove classes even if they were added by another code', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynCls = 'foo';
+ $rootScope.$digest();
+ element.addClass('foo');
+ $rootScope.dynCls = '';
+ $rootScope.$digest();
+ }));
+
+
+ it('should convert undefined and null values to an empty string', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.dynCls = [undefined, null];
+ $rootScope.$digest();
+ }));
+
+
+ it('should ng-class odd/even', inject(function($rootScope, $compile) {
+ element = $compile('- ')($rootScope);
+ $rootScope.$digest();
+ var e1 = jqLite(element[0].childNodes[1]);
+ var e2 = jqLite(element[0].childNodes[2]);
+ expect(e1.hasClass('existing')).toBeTruthy();
+ expect(e1.hasClass('odd')).toBeTruthy();
+ expect(e2.hasClass('existing')).toBeTruthy();
+ expect(e2.hasClass('even')).toBeTruthy();
+ }));
+
+
+ it('should allow both ng-class and ng-class-odd/even on the same element', inject(function($rootScope, $compile) {
+ element = $compile('
- ' +
+ '' +
+ '
- ')($rootScope);
+ $rootScope.$apply();
+ var e1 = jqLite(element[0].childNodes[1]);
+ var e2 = jqLite(element[0].childNodes[2]);
+
+ expect(e1.hasClass('plainClass')).toBeTruthy();
+ expect(e1.hasClass('odd')).toBeTruthy();
+ expect(e1.hasClass('even')).toBeFalsy();
+ expect(e2.hasClass('plainClass')).toBeTruthy();
+ expect(e2.hasClass('even')).toBeTruthy();
+ expect(e2.hasClass('odd')).toBeFalsy();
+ }));
+
+
+ it('should allow both ng-class and ng-class-odd/even with multiple classes', inject(function($rootScope, $compile) {
+ element = $compile('
- ' +
+ '' +
+ '
- ')($rootScope);
+ $rootScope.$apply();
+ var e1 = jqLite(element[0].childNodes[1]);
+ var e2 = jqLite(element[0].childNodes[2]);
+
+ expect(e1.hasClass('A')).toBeTruthy();
+ expect(e1.hasClass('B')).toBeTruthy();
+ expect(e1.hasClass('C')).toBeTruthy();
+ expect(e1.hasClass('D')).toBeTruthy();
+ expect(e1.hasClass('E')).toBeFalsy();
+ expect(e1.hasClass('F')).toBeFalsy();
+
+ expect(e2.hasClass('A')).toBeTruthy();
+ expect(e2.hasClass('B')).toBeTruthy();
+ expect(e2.hasClass('E')).toBeTruthy();
+ expect(e2.hasClass('F')).toBeTruthy();
+ expect(e2.hasClass('C')).toBeFalsy();
+ expect(e2.hasClass('D')).toBeFalsy();
+ }));
+});
diff --git a/test/ng/directive/ngClickSpec.js b/test/ng/directive/ngClickSpec.js
new file mode 100644
index 00000000..f5086d1c
--- /dev/null
+++ b/test/ng/directive/ngClickSpec.js
@@ -0,0 +1,26 @@
+'use strict';
+
+describe('ng-click', function() {
+ var element;
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+ it('should get called on a click', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect($rootScope.clicked).toBeFalsy();
+
+ browserTrigger(element, 'click');
+ expect($rootScope.clicked).toEqual(true);
+ }));
+
+ it('should pass event object', inject(function($rootScope, $compile) {
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+
+ browserTrigger(element, 'click');
+ expect($rootScope.event).toBeDefined();
+ }));
+});
diff --git a/test/ng/directive/ngCloakSpec.js b/test/ng/directive/ngCloakSpec.js
new file mode 100644
index 00000000..f3c28b60
--- /dev/null
+++ b/test/ng/directive/ngCloakSpec.js
@@ -0,0 +1,49 @@
+'use strict';
+
+describe('ng-cloak', function() {
+ var element;
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should get removed when an element is compiled', inject(function($rootScope, $compile) {
+ element = jqLite('');
+ expect(element.attr('ng-cloak')).toBe('');
+ $compile(element);
+ expect(element.attr('ng-cloak')).toBeUndefined();
+ }));
+
+
+ it('should remove ng-cloak class from a compiled element with attribute', inject(
+ function($rootScope, $compile) {
+ element = jqLite('');
+
+ expect(element.hasClass('foo')).toBe(true);
+ expect(element.hasClass('ng-cloak')).toBe(true);
+ expect(element.hasClass('bar')).toBe(true);
+
+ $compile(element);
+
+ expect(element.hasClass('foo')).toBe(true);
+ expect(element.hasClass('ng-cloak')).toBe(false);
+ expect(element.hasClass('bar')).toBe(true);
+ }));
+
+
+ it('should remove ng-cloak class from a compiled element', inject(function($rootScope, $compile) {
+ element = jqLite('');
+
+ expect(element.hasClass('foo')).toBe(true);
+ expect(element.hasClass('ng-cloak')).toBe(true);
+ expect(element.hasClass('bar')).toBe(true);
+
+ $compile(element);
+
+ expect(element.hasClass('foo')).toBe(true);
+ expect(element.hasClass('ng-cloak')).toBe(false);
+ expect(element.hasClass('bar')).toBe(true);
+ }));
+});
diff --git a/test/ng/directive/ngControllerSpec.js b/test/ng/directive/ngControllerSpec.js
new file mode 100644
index 00000000..832a683d
--- /dev/null
+++ b/test/ng/directive/ngControllerSpec.js
@@ -0,0 +1,65 @@
+'use strict';
+
+describe('ng-controller', function() {
+ var element;
+
+ beforeEach(inject(function($window) {
+ $window.Greeter = function($scope) {
+ // private stuff (not exported to scope)
+ this.prefix = 'Hello ';
+
+ // public stuff (exported to scope)
+ var ctrl = this;
+ $scope.name = 'Misko';
+ $scope.greet = function(name) {
+ return ctrl.prefix + name + ctrl.suffix;
+ };
+
+ $scope.protoGreet = bind(this, this.protoGreet);
+ };
+ $window.Greeter.prototype = {
+ suffix: '!',
+ protoGreet: function(name) {
+ return this.prefix + name + this.suffix;
+ }
+ };
+
+ $window.Child = function($scope) {
+ $scope.name = 'Adam';
+ };
+ }));
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ it('should instantiate controller and bind methods', inject(function($compile, $rootScope) {
+ element = $compile('
{{greet(name)}}
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toBe('Hello Misko!');
+ }));
+
+
+ it('should allow nested controllers', inject(function($compile, $rootScope) {
+ element = $compile('{{greet(name)}}
{{protoGreet(name)}}
{{name}}
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toBe('Vojta');
+ }));
+});
diff --git a/test/ng/directive/ngEventDirsSpec.js b/test/ng/directive/ngEventDirsSpec.js
new file mode 100644
index 00000000..c42f9b26
--- /dev/null
+++ b/test/ng/directive/ngEventDirsSpec.js
@@ -0,0 +1,25 @@
+'use strict';
+
+describe('event directives', function() {
+ var element;
+
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ describe('ng-submit', function() {
+
+ it('should get called on form submit', inject(function($rootScope, $compile) {
+ element = $compile('{{logger("url1")}}
');
+ $rootScope.$digest();
+ expect(log.join('; ')).toEqual('');
+ $rootScope.templateUrl = 'myUrl2';
+ $httpBackend.expect('GET', 'myUrl2').respond('{{logger("url2")}}
');
+ $rootScope.$digest();
+ $httpBackend.flush(); // now that we have two requests pending, flush!
+
+ expect(log.join('; ')).toEqual('url2; url2'); // it's here twice because we go through at
+ // least two digest cycles
+ }));
+
+
+ it('should compile only the content', inject(function($compile, $rootScope, $templateCache) {
+ // regression
+
+ var onload = jasmine.createSpy('$includeContentLoaded');
+ $rootScope.$on('$includeContentLoaded', onload);
+ $templateCache.put('tpl.html', [200, 'partial {{tpl}}', {}]);
+
+ element = $compile('' +
+ '
')($rootScope);
+ $rootScope.name = 'misko';
+ $rootScope.$digest();
+ expect(element.text()).toEqual('');
+ expect(element.attr('text')).toEqual('{{name}}');
+ }));
+});
diff --git a/test/ng/directive/ngPluralizeSpec.js b/test/ng/directive/ngPluralizeSpec.js
new file mode 100644
index 00000000..c7766c7b
--- /dev/null
+++ b/test/ng/directive/ngPluralizeSpec.js
@@ -0,0 +1,136 @@
+'use strict';
+
+describe('ng-pluralize', function() {
+ var element;
+
+
+ afterEach(function(){
+ dealoc(element);
+ });
+
+
+ describe('deal with pluralized strings without offset', function() {
+ beforeEach(inject(function($rootScope, $compile) {
+ element = $compile(
+ '
- ' +
+ '' +
+ '
- ' +
+ '' +
+ '
- ' +
+ '' +
+ '
- ' +
+ '' +
+ '
- ' +
+ '' +
+ '
- ' +
+ '' +
+ '
- ' +
+ '
- ' + + ' ' + + '
- {{i}}|
- ' +
+ '
- ' +
+ '{{group}}|X' + + ' ' +
+ '
- {{item}}|
- {{item}}|
- {{item}}|
- ' +
+ '' +
+ '
' +
+ '
')($rootScope);
+ expect(element.html()).toEqual(
+ '');
+ $rootScope.select = 1;
+ $rootScope.$apply();
+ expect(element.text()).toEqual('first:');
+ $rootScope.name="shyam";
+ $rootScope.$apply();
+ expect(element.text()).toEqual('first:shyam');
+ $rootScope.select = 2;
+ $rootScope.$apply();
+ expect(element.text()).toEqual('second:shyam');
+ $rootScope.name = 'misko';
+ $rootScope.$apply();
+ expect(element.text()).toEqual('second:misko');
+ $rootScope.select = true;
+ $rootScope.$apply();
+ expect(element.text()).toEqual('true:misko');
+ }));
+
+
+ it('should switch on switch-when-default', inject(function($rootScope, $compile) {
+ element = $compile(
+ 'first:{{name}}
' +
+ 'second:{{name}}
' +
+ 'true:{{name}}
' +
+ 'one
' +
+ 'other
' +
+ '{{name}}
' +
+ '{{name}}
' +
+ 'partial
', {}]);
+ $location.path('/some');
+ $rootScope.$digest();
+
+ expect(controllerScope.$parent).toBe($rootScope);
+ expect(controllerScope).toBe($route.current.scope);
+ expect(log).toEqual(['compile', 'ctrl-init']);
+ });
+ });
+
+
+ it('should support string controller declaration', function() {
+ var MyCtrl = jasmine.createSpy('MyCtrl');
+
+ module(function($controllerProvider, $routeProvider) {
+ $controllerProvider.register('MyCtrl', ['$scope', MyCtrl]);
+ $routeProvider.when('/foo', {controller: 'MyCtrl', template: '/tpl.html'});
+ });
+
+ inject(function($route, $location, $rootScope, $templateCache) {
+ $templateCache.put('/tpl.html', [200, '', {}]);
+ $location.path('/foo');
+ $rootScope.$digest();
+
+ expect($route.current.controller).toBe('MyCtrl');
+ expect(MyCtrl).toHaveBeenCalledWith(element.contents().scope());
+ });
+ });
+
+
+ it('should load content via xhr when route changes', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'myUrl1'});
+ $routeProvider.when('/bar', {template: 'myUrl2'});
+ });
+
+ inject(function($rootScope, $compile, $httpBackend, $location, $route) {
+ expect(element.text()).toEqual('');
+
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'myUrl1').respond('{{1+3}}
');
+ $rootScope.$digest();
+ $httpBackend.flush();
+ expect(element.text()).toEqual('4');
+
+ $location.path('/bar');
+ $httpBackend.expect('GET', 'myUrl2').respond('angular is da best');
+ $rootScope.$digest();
+ $httpBackend.flush();
+ expect(element.text()).toEqual('angular is da best');
+ });
+ });
+
+
+ it('should remove all content when location changes to an unknown route', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'myUrl1'});
+ });
+
+ inject(function($rootScope, $compile, $location, $httpBackend, $route) {
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'myUrl1').respond('{{1+3}}
');
+ $rootScope.$digest();
+ $httpBackend.flush();
+ expect(element.text()).toEqual('4');
+
+ $location.path('/unknown');
+ $rootScope.$digest();
+ expect(element.text()).toEqual('');
+ });
+ });
+
+
+ it('should chain scopes and propagate evals to the child scope', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'myUrl1'});
+ });
+
+ inject(function($rootScope, $compile, $location, $httpBackend, $route) {
+ $rootScope.parentVar = 'parent';
+
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'myUrl1').respond('{{parentVar}}
');
+ $rootScope.$digest();
+ $httpBackend.flush();
+ expect(element.text()).toEqual('parent');
+
+ $rootScope.parentVar = 'new parent';
+ $rootScope.$digest();
+ expect(element.text()).toEqual('new parent');
+ });
+ });
+
+
+ it('should be possible to nest ng-view in ng-include', inject(function() {
+ // TODO(vojta): refactor this test
+ dealoc(element);
+ var injector = angular.injector(['ng', 'ngMock', function($routeProvider) {
+ $routeProvider.when('/foo', {controller: angular.noop, template: 'viewPartial.html'});
+ }]);
+ var myApp = injector.get('$rootScope');
+ var $httpBackend = injector.get('$httpBackend');
+ $httpBackend.expect('GET', 'includePartial.html').respond('view: ' +
+ 'include: ' +
+ '
')(myApp);
+ myApp.$apply();
+
+ $httpBackend.expect('GET', 'viewPartial.html').respond('content');
+ $httpBackend.flush();
+
+ expect(element.text()).toEqual('include: view: content');
+ expect($route.current.template).toEqual('viewPartial.html');
+ dealoc(myApp);
+ dealoc(element);
+ }));
+
+
+ it('should initialize view template after the view controller was initialized even when ' +
+ 'templates were cached', function() {
+ //this is a test for a regression that was introduced by making the ng-view cache sync
+ function ParentCtrl($scope) {
+ $scope.log.push('parent');
+ }
+
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {controller: ParentCtrl, template: 'viewPartial.html'});
+ });
+
+
+ inject(function($rootScope, $compile, $location, $httpBackend, $route) {
+ $rootScope.log = [];
+
+ $rootScope.ChildCtrl = function($scope) {
+ $scope.log.push('child');
+ };
+
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'viewPartial.html').
+ respond('' +
+ '' +
+ '
');
+ $rootScope.$apply();
+ $httpBackend.flush();
+
+ expect($rootScope.log).toEqual(['parent', 'init', 'child']);
+
+ $location.path('/');
+ $rootScope.$apply();
+ expect($rootScope.log).toEqual(['parent', 'init', 'child']);
+
+ $rootScope.log = [];
+ $location.path('/foo');
+ $rootScope.$apply();
+
+ expect($rootScope.log).toEqual(['parent', 'init', 'child']);
+ });
+ });
+
+
+ it('should discard pending xhr callbacks if a new route is requested before the current ' +
+ 'finished loading', function() {
+ // this is a test for a bad race condition that affected feedback
+
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'myUrl1'});
+ $routeProvider.when('/bar', {template: 'myUrl2'});
+ });
+
+ inject(function($route, $rootScope, $location, $httpBackend) {
+ expect(element.text()).toEqual('');
+
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'myUrl1').respond('{{1+3}}
');
+ $rootScope.$digest();
+ $location.path('/bar');
+ $httpBackend.expect('GET', 'myUrl2').respond('{{1+1}}
');
+ $rootScope.$digest();
+ $httpBackend.flush(); // now that we have two requests pending, flush!
+
+ expect(element.text()).toEqual('2');
+ });
+ });
+
+
+ it('should clear the content when error during xhr request', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {controller: noop, template: 'myUrl1'});
+ });
+
+ inject(function($route, $location, $rootScope, $httpBackend) {
+ $location.path('/foo');
+ $httpBackend.expect('GET', 'myUrl1').respond(404, '');
+ element.text('content');
+
+ $rootScope.$digest();
+ $httpBackend.flush();
+
+ expect(element.text()).toBe('');
+ });
+ });
+
+
+ it('should be async even if served from cache', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {controller: noop, template: 'myUrl1'});
+ });
+
+ inject(function($route, $rootScope, $location, $templateCache) {
+ $templateCache.put('myUrl1', [200, 'my partial', {}]);
+ $location.path('/foo');
+
+ var called = 0;
+ // we want to assert only during first watch
+ $rootScope.$watch(function() {
+ if (!called++) expect(element.text()).toBe('');
+ });
+
+ $rootScope.$digest();
+ expect(element.text()).toBe('my partial');
+ });
+ });
+
+ it('should fire $contentLoaded event when content compiled and linked', function() {
+ var log = [];
+ var logger = function(name) {
+ return function() {
+ log.push(name);
+ };
+ };
+ var Ctrl = function($scope) {
+ $scope.value = 'bound-value';
+ log.push('init-ctrl');
+ };
+
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'tpl.html', controller: Ctrl});
+ });
+
+ inject(function($templateCache, $rootScope, $location) {
+ $rootScope.$on('$beforeRouteChange', logger('$beforeRouteChange'));
+ $rootScope.$on('$afterRouteChange', logger('$afterRouteChange'));
+ $rootScope.$on('$viewContentLoaded', logger('$viewContentLoaded'));
+
+ $templateCache.put('tpl.html', [200, '{{value}}', {}]);
+ $location.path('/foo');
+ $rootScope.$digest();
+
+ expect(element.text()).toBe('bound-value');
+ expect(log).toEqual(['$beforeRouteChange', '$afterRouteChange', 'init-ctrl',
+ '$viewContentLoaded']);
+ });
+ });
+
+ it('should destroy previous scope', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'tpl.html'});
+ });
+
+ inject(function($templateCache, $rootScope, $location) {
+ $templateCache.put('tpl.html', [200, 'partial', {}]);
+
+ expect($rootScope.$$childHead).toBeNull();
+ expect($rootScope.$$childTail).toBeNull();
+
+ $location.path('/foo');
+ $rootScope.$digest();
+
+ expect(element.text()).toBe('partial');
+ expect($rootScope.$$childHead).not.toBeNull();
+ expect($rootScope.$$childTail).not.toBeNull();
+
+ $location.path('/non/existing/route');
+ $rootScope.$digest();
+
+ expect(element.text()).toBe('');
+ expect($rootScope.$$childHead).toBeNull();
+ expect($rootScope.$$childTail).toBeNull();
+ });
+ });
+
+
+ it('should destroy previous scope if multiple route changes occur before server responds',
+ function() {
+ var log = [];
+ var createCtrl = function(name) {
+ return function($scope) {
+ log.push('init-' + name);
+ $scope.$on('$destroy', function() {log.push('destroy-' + name);});
+ };
+ };
+
+ module(function($routeProvider) {
+ $routeProvider.when('/one', {template: 'one.html', controller: createCtrl('ctrl1')});
+ $routeProvider.when('/two', {template: 'two.html', controller: createCtrl('ctrl2')});
+ });
+
+ inject(function($httpBackend, $rootScope, $location) {
+ $httpBackend.whenGET('one.html').respond('content 1');
+ $httpBackend.whenGET('two.html').respond('content 2');
+
+ $location.path('/one');
+ $rootScope.$digest();
+ $location.path('/two');
+ $rootScope.$digest();
+
+ $httpBackend.flush();
+ expect(element.text()).toBe('content 2');
+ expect(log).toEqual(['init-ctrl2']);
+
+ $location.path('/non-existing');
+ $rootScope.$digest();
+
+ expect(element.text()).toBe('');
+ expect(log).toEqual(['init-ctrl2', 'destroy-ctrl2']);
+
+ expect($rootScope.$$childHead).toBeNull();
+ expect($rootScope.$$childTail).toBeNull();
+ });
+ });
+
+
+ it('should $destroy scope after update and reload', function() {
+ // this is a regression of bug, where $route doesn't copy scope when only updating
+
+ var log = [];
+
+ function logger(msg) {
+ return function() {
+ log.push(msg);
+ };
+ }
+
+ function createController(name) {
+ return function($scope) {
+ log.push('init-' + name);
+ $scope.$on('$destroy', logger('destroy-' + name));
+ $scope.$on('$routeUpdate', logger('route-update'));
+ };
+ }
+
+ module(function($routeProvider) {
+ $routeProvider.when('/bar', {template: 'tpl.html', controller: createController('bar')});
+ $routeProvider.when('/foo', {
+ template: 'tpl.html', controller: createController('foo'), reloadOnSearch: false});
+ });
+
+ inject(function($templateCache, $location, $rootScope) {
+ $templateCache.put('tpl.html', [200, 'partial', {}]);
+
+ $location.url('/foo');
+ $rootScope.$digest();
+ expect(log).toEqual(['init-foo']);
+
+ $location.search({q: 'some'});
+ $rootScope.$digest();
+ expect(log).toEqual(['init-foo', 'route-update']);
+
+ $location.url('/bar');
+ $rootScope.$digest();
+ expect(log).toEqual(['init-foo', 'route-update', 'destroy-foo', 'init-bar']);
+ });
+ });
+
+
+ it('should evaluate onload expression after linking the content', function() {
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'tpl.html'});
+ });
+
+ inject(function($templateCache, $location, $rootScope) {
+ $templateCache.put('tpl.html', [200, '{{1+1}}', {}]);
+ $rootScope.load = jasmine.createSpy('onload');
+
+ $location.url('/foo');
+ $rootScope.$digest();
+ expect($rootScope.load).toHaveBeenCalledOnce();
+ });
+ })
+
+
+ it('should set $scope and $controllerController on the view', function() {
+ function MyCtrl($scope) {
+ $scope.state = 'WORKS';
+ $scope.ctrl = this;
+ }
+
+ module(function($routeProvider) {
+ $routeProvider.when('/foo', {template: 'tpl.html', controller: MyCtrl});
+ });
+
+ inject(function($templateCache, $location, $rootScope, $route) {
+ $templateCache.put('tpl.html', [200, '{{state}}
', {}]);
+
+ $location.url('/foo');
+ $rootScope.$digest();
+ expect(element.text()).toEqual('WORKS');
+
+ var div = element.find('div');
+ expect(nodeName_(div.parent())).toEqual('NG:VIEW');
+
+ expect(div.scope()).toBe($route.current.scope);
+ expect(div.scope().hasOwnProperty('state')).toBe(true);
+ expect(div.scope().state).toEqual('WORKS');
+
+ expect(div.controller()).toBe($route.current.scope.ctrl);
+ });
+ });
+});
diff --git a/test/ng/directive/scriptSpec.js b/test/ng/directive/scriptSpec.js
new file mode 100644
index 00000000..471e04ce
--- /dev/null
+++ b/test/ng/directive/scriptSpec.js
@@ -0,0 +1,44 @@
+'use strict';
+
+describe('scriptDirective', function() {
+ var element;
+
+
+ afterEach(function(){
+ dealoc(element);
+ });
+
+
+ it('should populate $templateCache with contents of a ng-template script element', inject(
+ function($compile, $templateCache) {
+ if (msie <=8) return;
+ // in ie8 it is not possible to create a script tag with the right content.
+ // it always comes up as empty. I was trying to set the text of the
+ // script tag, but that did not work either, so I gave up.
+ $compile('foo' +
+ '' +
+ '' +
+ '
' );
+ expect($templateCache.get('/myTemplate.html')).toBe('{{bind}}
');
+ $compile(element)($rootScope);
+ $rootScope.$apply(function() {
+ $rootScope.bind = 'value';
+ });
+
+ expect(element.text()).toBe('value');
+ }));
+});
diff --git a/test/ng/documentSpec.js b/test/ng/documentSpec.js
new file mode 100644
index 00000000..064904a2
--- /dev/null
+++ b/test/ng/documentSpec.js
@@ -0,0 +1,9 @@
+'use strict';
+
+describe('$document', function() {
+
+
+ it("should inject $document", inject(function($document) {
+ expect($document).toEqual(jqLite(document));
+ }));
+});
diff --git a/test/ng/exceptionHandlerSpec.js b/test/ng/exceptionHandlerSpec.js
new file mode 100644
index 00000000..3f3dd800
--- /dev/null
+++ b/test/ng/exceptionHandlerSpec.js
@@ -0,0 +1,24 @@
+'use strict';
+
+describe('$exceptionHandler', function() {
+ it('should log errors with single argument', function() {
+ module(function($provide){
+ $provide.provider('$exceptionHandler', $ExceptionHandlerProvider);
+ });
+ inject(function($log, $exceptionHandler) {
+ $exceptionHandler('myError');
+ expect($log.error.logs.shift()).toEqual(['myError']);
+ });
+ });
+
+
+ it('should log errors with multiple arguments', function() {
+ module(function($provide){
+ $provide.provider('$exceptionHandler', $ExceptionHandlerProvider);
+ });
+ inject(function($log, $exceptionHandler) {
+ $exceptionHandler('myError', 'comment');
+ expect($log.error.logs.shift()).toEqual(['myError', 'comment']);
+ });
+ });
+});
diff --git a/test/ng/filter/filterSpec.js b/test/ng/filter/filterSpec.js
new file mode 100644
index 00000000..a33358d0
--- /dev/null
+++ b/test/ng/filter/filterSpec.js
@@ -0,0 +1,69 @@
+'use strict';
+
+describe('Filter: filter', function() {
+ var filter;
+
+ beforeEach(inject(function($filter){
+ filter = $filter('filter');
+ }));
+
+ it('should filter by string', function() {
+ var items = ['MIsKO', {name: 'shyam'}, ['adam'], 1234];
+ expect(filter(items, '').length).toBe(4);
+ expect(filter(items, undefined).length).toBe(4);
+
+ expect(filter(items, 'iSk').length).toBe(1);
+ expect(filter(items, 'isk')[0]).toBe('MIsKO');
+
+ expect(filter(items, 'yam').length).toBe(1);
+ expect(filter(items, 'yam')[0]).toEqual(items[1]);
+
+ expect(filter(items, 'da').length).toBe(1);
+ expect(filter(items, 'da')[0]).toEqual(items[2]);
+
+ expect(filter(items, '34').length).toBe(1);
+ expect(filter(items, '34')[0]).toBe(1234);
+
+ expect(filter(items, "I don't exist").length).toBe(0);
+ });
+
+ it('should not read $ properties', function() {
+ expect(''.charAt(0)).toBe(''); // assumption
+
+ var items = [{$name: 'misko'}];
+ expect(filter(items, 'misko').length).toBe(0);
+ });
+
+ it('should filter on specific property', function() {
+ var items = [{ignore: 'a', name: 'a'}, {ignore: 'a', name: 'abc'}];
+ expect(filter(items, {}).length).toBe(2);
+
+ expect(filter(items, {name: 'a'}).length).toBe(2);
+
+ expect(filter(items, {name: 'b'}).length).toBe(1);
+ expect(filter(items, {name: 'b'})[0].name).toBe('abc');
+ });
+
+ it('should take function as predicate', function() {
+ var items = [{name: 'a'}, {name: 'abc', done: true}];
+ expect(filter(items, function(i) {return i.done;}).length).toBe(1);
+ });
+
+ it('should take object as perdicate', function() {
+ var items = [{first: 'misko', last: 'hevery'},
+ {first: 'adam', last: 'abrons'}];
+
+ expect(filter(items, {first:'', last:''}).length).toBe(2);
+ expect(filter(items, {first:'', last:'hevery'}).length).toBe(1);
+ expect(filter(items, {first:'adam', last:'hevery'}).length).toBe(0);
+ expect(filter(items, {first:'misko', last:'hevery'}).length).toBe(1);
+ expect(filter(items, {first:'misko', last:'hevery'})[0]).toEqual(items[0]);
+ });
+
+ it('should support negation operator', function() {
+ var items = ['misko', 'adam'];
+
+ expect(filter(items, '!isk').length).toBe(1);
+ expect(filter(items, '!isk')[0]).toEqual(items[1]);
+ });
+});
diff --git a/test/ng/filter/filtersSpec.js b/test/ng/filter/filtersSpec.js
new file mode 100644
index 00000000..98651c58
--- /dev/null
+++ b/test/ng/filter/filtersSpec.js
@@ -0,0 +1,280 @@
+'use strict';
+
+describe('filters', function() {
+
+ var filter;
+
+ beforeEach(inject(function($filter){
+ filter = $filter;
+ }));
+
+ it('should call the filter when evaluating expression', function(){
+ var filter = jasmine.createSpy('myFilter');
+ createInjector(['ng', function($filterProvider) {
+ $filterProvider.register('myFilter', valueFn(filter));
+ }]).invoke(function($rootScope) {
+ $rootScope.$eval('10|myFilter');
+ });
+ expect(filter).toHaveBeenCalledWith(10);
+ });
+
+ describe('formatNumber', function() {
+ var pattern;
+
+ beforeEach(function() {
+ pattern = { minInt: 1,
+ minFrac: 0,
+ maxFrac: 3,
+ posPre: '',
+ posSuf: '',
+ negPre: '-',
+ negSuf: '',
+ gSize: 3,
+ lgSize: 3 };
+ });
+
+ it('should format according to different patterns', function() {
+ pattern.gSize = 2;
+ var num = formatNumber(1234567.89, pattern, ',', '.');
+ expect(num).toBe('12,34,567.89');
+ num = formatNumber(1234.56, pattern, ',', '.');
+ expect(num).toBe('1,234.56');
+
+ pattern.negPre = '(';
+ pattern.negSuf = '-)';
+ num = formatNumber(-1234, pattern, ',', '.');
+ expect(num).toBe('(1,234-)');
+ pattern.posPre = '+';
+ pattern.posSuf = '+';
+ num = formatNumber(1234, pattern, ',', '.');
+ expect(num).toBe('+1,234+');
+ pattern.posPre = pattern.posSuf = '';
+
+ pattern.minFrac = 2;
+ num = formatNumber(1, pattern, ',', '.');
+ expect(num).toBe('1.00');
+ pattern.maxFrac = 4;
+ num = formatNumber(1.11119, pattern, ',', '.');
+ expect(num).toBe('1.1112');
+ });
+
+ it('should format according different seperators', function() {
+ var num = formatNumber(1234567.1, pattern, '.', ',', 2);
+ expect(num).toBe('1.234.567,10');
+ });
+
+ it('should format with or without fractionSize', function() {
+ var num = formatNumber(123.1, pattern, ',', '.', 3);
+ expect(num).toBe('123.100');
+ num = formatNumber(123.12, pattern, ',', '.');
+ expect(num).toBe('123.12');
+ var num = formatNumber(123.1116, pattern, ',', '.');
+ expect(num).toBe('123.112');
+ });
+ });
+
+ describe('currency', function() {
+ var currency;
+
+ beforeEach(function() {
+ currency = filter('currency');
+ });
+
+ it('should do basic currency filtering', function() {
+ expect(currency(0)).toEqual('$0.00');
+ expect(currency(-999)).toEqual('($999.00)');
+ expect(currency(1234.5678, "USD$")).toEqual('USD$1,234.57');
+ });
+
+
+ it('should return empty string for non-numbers', function() {
+ expect(currency()).toBe('');
+ expect(currency('abc')).toBe('');
+ });
+ });
+
+
+ describe('number', function() {
+ var number;
+
+ beforeEach(inject(function($rootScope) {
+ number = filter('number');
+ }));
+
+
+ it('should do basic filter', function() {
+ expect(number(0, 0)).toEqual('0');
+ expect(number(-999)).toEqual('-999');
+ expect(number(123)).toEqual('123');
+ expect(number(1234567)).toEqual('1,234,567');
+ expect(number(1234)).toEqual('1,234');
+ expect(number(1234.5678)).toEqual('1,234.568');
+ expect(number(Number.NaN)).toEqual('');
+ expect(number("1234.5678")).toEqual('1,234.568');
+ expect(number(1/0)).toEqual("");
+ expect(number(1, 2)).toEqual("1.00");
+ expect(number(.1, 2)).toEqual("0.10");
+ expect(number(.01, 2)).toEqual("0.01");
+ expect(number(.001, 3)).toEqual("0.001");
+ expect(number(.0001, 3)).toEqual("0.000");
+ expect(number(9, 2)).toEqual("9.00");
+ expect(number(.9, 2)).toEqual("0.90");
+ expect(number(.99, 2)).toEqual("0.99");
+ expect(number(.999, 3)).toEqual("0.999");
+ expect(number(.9999, 3)).toEqual("1.000");
+ expect(number(1234.567, 0)).toEqual("1,235");
+ expect(number(1234.567, 1)).toEqual("1,234.6");
+ expect(number(1234.567, 2)).toEqual("1,234.57");
+ });
+
+ it('should filter exponential numbers', function() {
+ expect(number(1e50, 0)).toEqual('1e+50');
+ expect(number(-2e50, 2)).toEqual('-2e+50');
+ });
+ });
+
+ describe('json', function () {
+ it('should do basic filter', function() {
+ expect(filter('json')({a:"b"})).toEqual(toJson({a:"b"}, true));
+ });
+ });
+
+ describe('lowercase', function() {
+ it('should do basic filter', function() {
+ expect(filter('lowercase')('AbC')).toEqual('abc');
+ expect(filter('lowercase')(null)).toBeNull();
+ });
+ });
+
+ describe('uppercase', function() {
+ it('should do basic filter', function() {
+ expect(filter('uppercase')('AbC')).toEqual('ABC');
+ expect(filter('uppercase')(null)).toBeNull();
+ });
+ });
+
+ describe('linky', function() {
+ var linky;
+
+ beforeEach(inject(function($filter){
+ linky = $filter('linky')
+ }));
+
+ it('should do basic filter', function() {
+ expect(linky("http://ab/ (http://a/) c').toEqual('a
c'); + }); + + it('should handle namespace', function() { + expectHTML('a
' +
+ '!@#$%^&*()_+-={}[]:";\'<>?,./`~ ħ
';
+ expectHTML(everything).toEqual(everything);
+ });
+
+ it('should handle improper html', function() {
+ expectHTML('< div rel="text
');
+ });
+
+ it('should handle improper html2', function() {
+ expectHTML('< div rel="in
after');
+ });
+
+ it('should escape text nodes', function() {
+ writer.chars('a&
c');
+ expect(html).toEqual('a<div>&</div>c');
+ });
+
+ it('should escape IE script', function() {
+ writer.chars('&<>{}');
+ expect(html).toEqual('&<>{}');
+ });
+
+ it('should escape attributes', function() {
+ writer.start('div', {rel:'!@#$%^&*()_+-={}[]:";\'<>?,./`~ \n\0\r\u0127'});
+ expect(html).toEqual('');
+ });
+
+ it('should ignore missformed elements', function() {
+ writer.start('d>i&v', {});
+ expect(html).toEqual('');
+ });
+
+ it('should ignore unknown attributes', function() {
+ writer.start('div', {unknown:""});
+ expect(html).toEqual('
');
+ });
+
+ describe('explicitly dissallow', function() {
+ it('should not allow attributes', function() {
+ writer.start('div', {id:'a', name:'a', style:'a'});
+ expect(html).toEqual('![xxx\\]( "><script>....")
').
- toEqual('![xxx\\]( "><script>....")
');
- });
-
- it('should ignore object attributes', function() {
- expectHTML(':)').
- toEqual(':)');
- expectHTML(':) ').
- toEqual('');
- });
-
- describe('htmlSanitizerWriter', function() {
- var writer, html;
- beforeEach(function() {
- html = '';
- writer = htmlSanitizeWriter({push:function(text){html+=text;}});
- });
-
- it('should write basic HTML', function() {
- writer.chars('before');
- writer.start('div', {rel:'123'}, false);
- writer.chars('in');
- writer.end('div');
- writer.chars('after');
-
- expect(html).toEqual('before
');
+ });
+
+ it('should not allow tags', function() {
+ function tag(name) {
+ writer.start(name, {});
+ writer.end(name);
+ }
+ tag('frameset');
+ tag('frame');
+ tag('form');
+ tag('param');
+ tag('object');
+ tag('embed');
+ tag('textarea');
+ tag('input');
+ tag('button');
+ tag('option');
+ tag('select');
+ tag('script');
+ tag('style');
+ tag('link');
+ tag('base');
+ tag('basefont');
+ expect(html).toEqual('');
+ });
+ });
+
+ describe('isUri', function() {
+
+ function isUri(value) {
+ return value.match(URI_REGEXP);
+ }
+
+ it('should be URI', function() {
+ expect(isUri('http://abc')).toBeTruthy();
+ expect(isUri('https://abc')).toBeTruthy();
+ expect(isUri('ftp://abc')).toBeTruthy();
+ expect(isUri('mailto:me@example.com')).toBeTruthy();
+ expect(isUri('#anchor')).toBeTruthy();
+ });
+
+ it('should not be UIR', function() {
+ expect(isUri('')).toBeFalsy();
+ expect(isUri('javascript:alert')).toBeFalsy();
+ });
+ });
+
+ describe('javascript URL attribute', function() {
+ beforeEach(function() {
+ this.addMatchers({
+ toBeValidUrl: function() {
+ return URI_REGEXP.exec(this.actual);
+ }
+ });
+ });
+
+ it('should ignore javascript:', function() {
+ expect('JavaScript:abc').not.toBeValidUrl();
+ expect(' \n Java\n Script:abc').not.toBeValidUrl();
+ expect('http://JavaScript/my.js').toBeValidUrl();
+ });
+
+ it('should ignore dec encoded javascript:', function() {
+ expect('javascript:').not.toBeValidUrl();
+ expect('javascript:').not.toBeValidUrl();
+ expect('j avascript:').not.toBeValidUrl();
+ });
+
+ it('should ignore decimal with leading 0 encodede javascript:', function() {
+ expect('javascript:').not.toBeValidUrl();
+ expect('j avascript:').not.toBeValidUrl();
+ expect('j avascript:').not.toBeValidUrl();
+ });
+
+ it('should ignore hex encoded javascript:', function() {
+ expect('javascript:').not.toBeValidUrl();
+ expect('javascript:').not.toBeValidUrl();
+ expect('j avascript:').not.toBeValidUrl();
+ });
+
+ it('should ignore hex encoded whitespace javascript:', function() {
+ expect('jav ascript:alert("A");').not.toBeValidUrl();
+ expect('jav
ascript:alert("B");').not.toBeValidUrl();
+ expect('jav
ascript:alert("C");').not.toBeValidUrl();
+ expect('jav\u0000ascript:alert("D");').not.toBeValidUrl();
+ expect('java\u0000\u0000script:alert("D");').not.toBeValidUrl();
+ expect(' java\u0000\u0000script:alert("D");').not.toBeValidUrl();
+ });
+ });
+
+ });
+
+});
diff --git a/test/ng/snifferSpec.js b/test/ng/snifferSpec.js
new file mode 100644
index 00000000..b359e118
--- /dev/null
+++ b/test/ng/snifferSpec.js
@@ -0,0 +1,33 @@
+'use strict';
+
+describe('$sniffer', function() {
+
+ function sniffer($window) {
+ return new $SnifferProvider().$get[1]($window);
+ }
+
+ describe('history', function() {
+ it('should be true if history.pushState defined', function() {
+ expect(sniffer({history: {pushState: noop, replaceState: noop}}).history).toBe(true);
+ });
+
+ it('should be false if history or pushState not defined', function() {
+ expect(sniffer({history: {}}).history).toBe(false);
+ expect(sniffer({}).history).toBe(false);
+ });
+ });
+
+ describe('hashchange', function() {
+ it('should be true if onhashchange property defined', function() {
+ expect(sniffer({onhashchange: true, document: {}}).hashchange).toBe(true);
+ });
+
+ it('should be false if onhashchange property not defined', function() {
+ expect(sniffer({document: {}}).hashchange).toBe(false);
+ });
+
+ it('should be false if documentMode is 7 (IE8 comp mode)', function() {
+ expect(sniffer({onhashchange: true, document: {documentMode: 7}}).hashchange).toBe(false);
+ });
+ });
+});
diff --git a/test/ng/windowSpec.js b/test/ng/windowSpec.js
new file mode 100644
index 00000000..3b847146
--- /dev/null
+++ b/test/ng/windowSpec.js
@@ -0,0 +1,7 @@
+'use strict';
+
+describe('$window', function() {
+ it("should inject $window", inject(function($window) {
+ expect($window).toBe(window);
+ }));
+});
diff --git a/test/ngMock/angular-mocksSpec.js b/test/ngMock/angular-mocksSpec.js
new file mode 100644
index 00000000..2527ca48
--- /dev/null
+++ b/test/ngMock/angular-mocksSpec.js
@@ -0,0 +1,924 @@
+'use strict';
+
+describe('ngMock', function() {
+
+ describe('$browser', function() {
+
+ describe('addJs', function() {
+
+ it('should store url, done', inject(function($browser) {
+ var url = 'some.js',
+ done = noop;
+
+ $browser.addJs(url, done);
+
+ var script = $browser.$$scripts.shift();
+ expect(script.url).toBe(url);
+ expect(script.done).toBe(done);
+ }));
+
+
+ it('should return the script object', inject(function($browser) {
+ expect($browser.addJs('some.js', null, noop)).toBe($browser.$$scripts[0]);
+ }));
+ });
+ });
+
+
+ describe('TzDate', function() {
+
+ function minutes(min) {
+ return min*60*1000;
+ }
+
+ it('should look like a Date', function() {
+ var date = new angular.mock.TzDate(0,0);
+ expect(angular.isDate(date)).toBe(true);
+ });
+
+ it('should take millis as constructor argument', function() {
+ expect(new angular.mock.TzDate(0, 0).getTime()).toBe(0);
+ expect(new angular.mock.TzDate(0, 1283555108000).getTime()).toBe(1283555108000);
+ });
+
+ it('should take dateString as constructor argument', function() {
+ expect(new angular.mock.TzDate(0, '1970-01-01T00:00:00.000Z').getTime()).toBe(0);
+ expect(new angular.mock.TzDate(0, '2010-09-03T23:05:08.023Z').getTime()).toBe(1283555108023);
+ });
+
+
+ it('should fake getLocalDateString method', function() {
+ //0 in -3h
+ var t0 = new angular.mock.TzDate(-3, 0);
+ expect(t0.toLocaleDateString()).toMatch('1970');
+
+ //0 in +0h
+ var t1 = new angular.mock.TzDate(0, 0);
+ expect(t1.toLocaleDateString()).toMatch('1970');
+
+ //0 in +3h
+ var t2 = new angular.mock.TzDate(3, 0);
+ expect(t2.toLocaleDateString()).toMatch('1969');
+ });
+
+
+ it('should fake getHours method', function() {
+ //0 in -3h
+ var t0 = new angular.mock.TzDate(-3, 0);
+ expect(t0.getHours()).toBe(3);
+
+ //0 in +0h
+ var t1 = new angular.mock.TzDate(0, 0);
+ expect(t1.getHours()).toBe(0);
+
+ //0 in +3h
+ var t2 = new angular.mock.TzDate(3, 0);
+ expect(t2.getHours()).toMatch(21);
+ });
+
+
+ it('should fake getMinutes method', function() {
+ //0:15 in -3h
+ var t0 = new angular.mock.TzDate(-3, minutes(15));
+ expect(t0.getMinutes()).toBe(15);
+
+ //0:15 in -3.25h
+ var t0a = new angular.mock.TzDate(-3.25, minutes(15));
+ expect(t0a.getMinutes()).toBe(30);
+
+ //0 in +0h
+ var t1 = new angular.mock.TzDate(0, minutes(0));
+ expect(t1.getMinutes()).toBe(0);
+
+ //0:15 in +0h
+ var t1a = new angular.mock.TzDate(0, minutes(15));
+ expect(t1a.getMinutes()).toBe(15);
+
+ //0:15 in +3h
+ var t2 = new angular.mock.TzDate(3, minutes(15));
+ expect(t2.getMinutes()).toMatch(15);
+
+ //0:15 in +3.25h
+ var t2a = new angular.mock.TzDate(3.25, minutes(15));
+ expect(t2a.getMinutes()).toMatch(0);
+ });
+
+
+ it('should fake getSeconds method', function() {
+ //0 in -3h
+ var t0 = new angular.mock.TzDate(-3, 0);
+ expect(t0.getSeconds()).toBe(0);
+
+ //0 in +0h
+ var t1 = new angular.mock.TzDate(0, 0);
+ expect(t1.getSeconds()).toBe(0);
+
+ //0 in +3h
+ var t2 = new angular.mock.TzDate(3, 0);
+ expect(t2.getSeconds()).toMatch(0);
+ });
+
+
+ it('should create a date representing new year in Bratislava', function() {
+ var newYearInBratislava = new angular.mock.TzDate(-1, '2009-12-31T23:00:00.000Z');
+ expect(newYearInBratislava.getTimezoneOffset()).toBe(-60);
+ expect(newYearInBratislava.getFullYear()).toBe(2010);
+ expect(newYearInBratislava.getMonth()).toBe(0);
+ expect(newYearInBratislava.getDate()).toBe(1);
+ expect(newYearInBratislava.getHours()).toBe(0);
+ expect(newYearInBratislava.getMinutes()).toBe(0);
+ });
+
+
+ it('should delegate all the UTC methods to the original UTC Date object', function() {
+ //from when created from string
+ var date1 = new angular.mock.TzDate(-1, '2009-12-31T23:00:00.000Z');
+ expect(date1.getUTCFullYear()).toBe(2009);
+ expect(date1.getUTCMonth()).toBe(11);
+ expect(date1.getUTCDate()).toBe(31);
+ expect(date1.getUTCHours()).toBe(23);
+ expect(date1.getUTCMinutes()).toBe(0);
+ expect(date1.getUTCSeconds()).toBe(0);
+
+
+ //from when created from millis
+ var date2 = new angular.mock.TzDate(-1, date1.getTime());
+ expect(date2.getUTCFullYear()).toBe(2009);
+ expect(date2.getUTCMonth()).toBe(11);
+ expect(date2.getUTCDate()).toBe(31);
+ expect(date2.getUTCHours()).toBe(23);
+ expect(date2.getUTCMinutes()).toBe(0);
+ expect(date2.getUTCSeconds()).toBe(0);
+ });
+
+
+ it('should throw error when no third param but toString called', function() {
+ expect(function() { new angular.mock.TzDate(0,0).toString(); }).
+ toThrow('Method \'toString\' is not implemented in the TzDate mock');
+ });
+ });
+
+ describe('$log', function() {
+ var $log;
+ beforeEach(inject(['$log', function(log) {
+ $log = log;
+ }]));
+
+ afterEach(inject(function($log){
+ $log.reset();
+ }));
+
+ it('should provide log method', function() {
+ expect(function() { $log.log(''); }).not.toThrow();
+ });
+
+ it('should provide info method', function() {
+ expect(function() { $log.info(''); }).not.toThrow();
+ });
+
+ it('should provide warn method', function() {
+ expect(function() { $log.warn(''); }).not.toThrow();
+ });
+
+ it('should provide error method', function() {
+ expect(function() { $log.error(''); }).not.toThrow();
+ });
+
+ it('should store log messages', function() {
+ $log.log('fake log');
+ expect($log.log.logs).toContain(['fake log']);
+ });
+
+ it('should store info messages', function() {
+ $log.info('fake log');
+ expect($log.info.logs).toContain(['fake log']);
+ });
+
+ it('should store warn messages', function() {
+ $log.warn('fake log');
+ expect($log.warn.logs).toContain(['fake log']);
+ });
+
+ it('should store error messages', function() {
+ $log.error('fake log');
+ expect($log.error.logs).toContain(['fake log']);
+ });
+
+ it('should assertEmpty', function(){
+ try {
+ $log.error(Error('MyError'));
+ $log.warn(Error('MyWarn'));
+ $log.info(Error('MyInfo'));
+ $log.log(Error('MyLog'));
+ $log.assertEmpty();
+ } catch (error) {
+ error = error.message || error;
+ expect(error).toMatch(/Error: MyError/m);
+ expect(error).toMatch(/Error: MyWarn/m);
+ expect(error).toMatch(/Error: MyInfo/m);
+ expect(error).toMatch(/Error: MyLog/m);
+ } finally {
+ $log.reset();
+ }
+ });
+
+ it('should reset state', function(){
+ $log.error(Error('MyError'));
+ $log.warn(Error('MyWarn'));
+ $log.info(Error('MyInfo'));
+ $log.log(Error('MyLog'));
+ $log.reset();
+ var passed = false;
+ try {
+ $log.assertEmpty(); // should not throw error!
+ passed = true;
+ } catch (e) {
+ passed = e;
+ }
+ expect(passed).toBe(true);
+ });
+ });
+
+ describe('defer', function() {
+ var browser, log;
+ beforeEach(inject(function($browser) {
+ browser = $browser;
+ log = '';
+ }));
+
+ function logFn(text){ return function() {
+ log += text +';';
+ };
+ }
+
+ it('should flush', function() {
+ browser.defer(logFn('A'));
+ expect(log).toEqual('');
+ browser.defer.flush();
+ expect(log).toEqual('A;');
+ });
+
+ it('should flush delayed', function() {
+ browser.defer(logFn('A'));
+ browser.defer(logFn('B'), 10);
+ browser.defer(logFn('C'), 20);
+ expect(log).toEqual('');
+
+ expect(browser.defer.now).toEqual(0);
+ browser.defer.flush(0);
+ expect(log).toEqual('A;');
+
+ browser.defer.flush();
+ expect(log).toEqual('A;B;C;');
+ });
+
+ it('should defer and flush over time', function() {
+ browser.defer(logFn('A'), 1);
+ browser.defer(logFn('B'), 2);
+ browser.defer(logFn('C'), 3);
+
+ browser.defer.flush(0);
+ expect(browser.defer.now).toEqual(0);
+ expect(log).toEqual('');
+
+ browser.defer.flush(1);
+ expect(browser.defer.now).toEqual(1);
+ expect(log).toEqual('A;');
+
+ browser.defer.flush(2);
+ expect(browser.defer.now).toEqual(3);
+ expect(log).toEqual('A;B;C;');
+ });
+
+ it('should throw an exception if there is nothing to be flushed', function() {
+ expect(function() {browser.defer.flush();}).toThrow('No deferred tasks to be flushed');
+ });
+ });
+
+
+ describe('$exceptionHandler', function() {
+ it('should rethrow exceptions', inject(function($exceptionHandler) {
+ expect(function() { $exceptionHandler('myException'); }).toThrow('myException');
+ }));
+
+
+ it('should log exceptions', module(function($exceptionHandlerProvider){
+ $exceptionHandlerProvider.mode('log');
+ var $exceptionHandler = $exceptionHandlerProvider.$get();
+ $exceptionHandler('MyError');
+ expect($exceptionHandler.errors).toEqual(['MyError']);
+
+ $exceptionHandler('MyError', 'comment');
+ expect($exceptionHandler.errors[1]).toEqual(['MyError', 'comment']);
+ }));
+
+
+ it('should throw on wrong argument', module(function($exceptionHandlerProvider) {
+ expect(function() {
+ $exceptionHandlerProvider.mode('XXX');
+ }).toThrow("Unknown mode 'XXX', only 'log'/'rethrow' modes are allowed!");
+ }));
+ });
+
+
+ describe('angular.mock.dump', function(){
+ var d = angular.mock.dump;
+
+
+ it('should serialize primitive types', function(){
+ expect(d(undefined)).toEqual('undefined');
+ expect(d(1)).toEqual('1');
+ expect(d(null)).toEqual('null');
+ expect(d('abc')).toEqual('abc');
+ });
+
+
+ it('should serialize element', function(){
+ var e = angular.element('
{{ true }}'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('some value'); + + $root.dsl.binding('true'); + expect($root.futureResult).toEqual('true'); + }); + + it('should select binding by name', function() { + compile(''); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('some value'); + }); + + it('should select binding by regexp', function() { + compile('some value'); + $root.dsl.binding(/^foo\..+/); + expect($root.futureResult).toEqual('some value'); + }); + + it('should return innerHTML for all the other elements', function() { + compile('', 'some value'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult.toLowerCase()).toEqual('some value'); + }); + + it('should select binding in template by name', function() { + compile('', 'bar'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('bar'); + }); + + it('should match bindings by substring match', function() { + compile('', 'binding value'); + $root.dsl.binding('foo . bar'); + expect($root.futureResult).toEqual('binding value'); + }); + + it('should return error if no bindings in document', function() { + $root.dsl.binding('foo.bar'); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should return error if no binding matches', function() { + compile('some value'); + $root.dsl.binding('foo.bar'); + expect($root.futureError).toMatch(/did not match/); + }); + }); + + describe('Using', function() { + it('should prefix selector in $document.elements()', function() { + var chain; + doc.append( + '' + + '' + ); + chain = $root.dsl.using('div#test2'); + chain.input('test.input').enter('foo'); + var inputs = _jQuery('input[ng-model="test.input"]'); + expect(inputs.first().val()).toEqual('something'); + expect(inputs.last().val()).toEqual('foo'); + }); + + it('should use the selector as label if none is given', function() { + $root.dsl.using('mySelector'); + expect($root.label).toEqual('mySelector'); + }); + + it('should include the selector in paren when a label is given', function() { + $root.dsl.using('mySelector', 'myLabel'); + expect($root.label).toEqual('myLabel ( mySelector )'); + }); + + }); + + describe('Input', function() { + it('should change value in text input', function() { + doc.append(''); + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); + }); + + it('should change value in text input in dash form', function() { + doc.append(''); + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); + }); + + it('should return error if no input exists', function() { + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should toggle checkbox state', function() { + doc.append(''); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(true); + var chain = $root.dsl.input('test.input'); + chain.check(); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(false); + $window.angular.reset(); + chain.check(); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(true); + }); + + it('should return error if checkbox did not match', function() { + var chain = $root.dsl.input('test.input'); + chain.check(); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should select option from radio group', function() { + doc.append( + '' + + '' + ); + // HACK! We don't know why this is sometimes false on chrome + _jQuery('input[ng\\:model="test.input"][value="bar"]').prop('checked', true); + expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). + prop('checked')).toBe(true); + expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). + prop('checked')).toBe(false); + var chain = $root.dsl.input('test.input'); + chain.select('foo'); + expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). + prop('checked')).toBe(false); + expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). + prop('checked')).toBe(true); + }); + + it('should return error if radio button did not match', function() { + var chain = $root.dsl.input('test.input'); + chain.select('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + + describe('val', function() { + it('should return value in text input', function() { + doc.append(''); + $root.dsl.input('test.input').val(); + expect($root.futureResult).toEqual("something"); + }); + }); + }); + + describe('Textarea', function() { + + it('should change value in textarea', function() { + doc.append(''); + var chain = $root.dsl.input('test.textarea'); + chain.enter('foo'); + expect(_jQuery('textarea[ng-model="test.textarea"]').val()).toEqual('foo'); + }); + + it('should return error if no textarea exists', function() { + var chain = $root.dsl.input('test.textarea'); + chain.enter('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + }); + }); +}); diff --git a/test/ngScenario/e2e/Runner-compiled.html b/test/ngScenario/e2e/Runner-compiled.html new file mode 100644 index 00000000..530fef96 --- /dev/null +++ b/test/ngScenario/e2e/Runner-compiled.html @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/test/ngScenario/e2e/Runner.html b/test/ngScenario/e2e/Runner.html new file mode 100644 index 00000000..1191dc86 --- /dev/null +++ b/test/ngScenario/e2e/Runner.html @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/test/ngScenario/e2e/style.css b/test/ngScenario/e2e/style.css new file mode 100644 index 00000000..26540bec --- /dev/null +++ b/test/ngScenario/e2e/style.css @@ -0,0 +1,11 @@ +th { + text-align: left; +} + +tr { + border: 1px solid black; +} + +.redbox { + background-color: red; +} diff --git a/test/ngScenario/e2e/widgets-scenario.js b/test/ngScenario/e2e/widgets-scenario.js new file mode 100644 index 00000000..fda9b3c6 --- /dev/null +++ b/test/ngScenario/e2e/widgets-scenario.js @@ -0,0 +1,67 @@ +'use strict'; + +describe('widgets', function() { + it('should verify that basic widgets work', function() { + browser().navigateTo('widgets.html'); + + using('#text-basic-box').input('text.basic').enter('Carlos'); + expect(binding('text.basic')).toEqual('Carlos'); + input('text.basic').enter('Carlos Santana'); + expect(binding('text.basic')).not().toEqual('Carlos Boozer'); + + input('text.password').enter('secret'); + expect(binding('text.password')).toEqual('secret'); + + expect(binding('text.hidden')).toEqual('hiddenValue'); + + expect(binding('gender')).toEqual('male'); + input('gender').select('female'); + expect(using('#gender-box').binding('gender')).toEqual('female'); + + expect(repeater('#repeater-row ul li').count()).toEqual(2); + expect(repeater('#repeater-row ul li').row(1)).toEqual(['adam']); + expect(repeater('#repeater-row ul li').column('name')).toEqual(['misko', 'adam']); + + select('select').option('B'); + expect(binding('select')).toEqual('B'); + + select('multiselect').options('A', 'C'); + expect(binding('multiselect').fromJson()).toEqual(['A', 'C']); + + expect(binding('button').fromJson()).toEqual({'count': 0}); + expect(binding('form').fromJson()).toEqual({'count': 0}); + + element('form a', "'action' link").click(); + expect(binding('button').fromJson()).toEqual({'count': 1}); + + element('input[value="submit input"]', "'submit input' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 2}); + expect(binding('form').fromJson()).toEqual({'count': 1}); + + element('button:contains("submit button")', "'submit button' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 2}); + expect(binding('form').fromJson()).toEqual({'count': 2}); + + element('input[value="button"]', "'button' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 3}); + + element('input[type="image"]', 'form image').click(); + expect(binding('button').fromJson()).toEqual({'count': 4}); + + /** + * Custom value parser for futures. + */ + function checkboxParser(value) { + return angular.fromJson(value.substring(value.indexOf('=')+1)); + } + + input('checkbox.tea').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: false, tea: false}); + input('checkbox.coffee').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: false}); + input('checkbox.tea').check(); + input('checkbox.tea').check(); + input('checkbox.tea').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: true}); + }); +}); diff --git a/test/ngScenario/e2e/widgets.html b/test/ngScenario/e2e/widgets.html new file mode 100644 index 00000000..f986144e --- /dev/null +++ b/test/ngScenario/e2e/widgets.html @@ -0,0 +1,99 @@ + + + + + + + +
+
+
+
diff --git a/test/ngScenario/jstd-scenario-adapter/AdapterSpecs.js b/test/ngScenario/jstd-scenario-adapter/AdapterSpecs.js
new file mode 100644
index 00000000..e360ad4f
--- /dev/null
+++ b/test/ngScenario/jstd-scenario-adapter/AdapterSpecs.js
@@ -0,0 +1,322 @@
+'use strict';
+
+describe('jstd-adapter', function() {
+ var fakeJSTD = { pluginRegistrar: { register: function() {} } },
+ originalNavigateTo = angular.scenario.Application.prototype.navigateTo;
+
+ /**
+ * Reverts hack on angular.scenario.Application.navigateTo
+ * We should revert this hack after any single call of initScenarioAdapter,
+ * so that it doesn't influence other tests...
+ */
+ function revertNavigateToHack() {
+ angular.scenario.Application.prototype.navigateTo = originalNavigateTo;
+ }
+
+ /**
+ * Helper for building angular.scenario.ObjectModel.Spec
+ * @returns {angular.scenario.ObjectModel.Spec}
+ */
+ function buildSpec(status, name, duration, definitions, error, line) {
+ var spec = new angular.scenario.ObjectModel.Spec(
+ 'fake-id', name || 'name', definitions || ['desc1', 'desc2']);
+ spec.duration = duration || 10;
+ spec.status = status || 'success';
+ spec.error = error || '';
+ spec.line = line || '';
+
+ return spec;
+ }
+
+ /**
+ * Helper for building angular.scenario.ObjectModel.Spec with error and error line
+ * @returns {angular.scenario.ObjectModel.Spec}
+ */
+ function buildErrorSpec(error, line, status, name) {
+ return buildSpec(status || 'error', name, null, null, error, line);
+ }
+
+ /**
+ * Helper for building TestConfiguration
+ * @returns {jstestdriver.TestRunConfiguration}
+ */
+ function buildTestConf(type) {
+ return new jstestdriver.TestRunConfiguration(
+ new jstestdriver.TestCaseInfo('Fake test - ' + Math.random(), function() {}, type), null);
+ }
+
+ /**
+ * Helper for building SCENARIO TestConfiguration
+ * @returns {jstestdriver.TestRunConfiguration}
+ */
+ function buildScenarioTestConf() {
+ return buildTestConf(SCENARIO_TYPE);
+ }
+
+ describe('initScenarioAdapter', function() {
+ afterEach(revertNavigateToHack);
+
+ it('should create and register plugin if jstestdriver defined', function() {
+ spyOn(fakeJSTD.pluginRegistrar, 'register');
+ initScenarioAdapter(fakeJSTD);
+ expect(fakeJSTD.pluginRegistrar.register).toHaveBeenCalled();
+ expect(fakeJSTD.pluginRegistrar.register.mostRecentCall.args[0] instanceof JstdPlugin);
+ });
+
+ it('should do nothing if jstestdriver not defined', function() {
+ expect(function() {
+ initScenarioAdapter(undefined);
+ }).not.toThrow();
+ });
+
+ it('should set setUpAndRun callback to plugin', function() {
+ var runFn = jasmine.createSpy('setUpAndRun');
+ plugin.runScenario = null;
+
+ initScenarioAdapter(fakeJSTD, runFn);
+ expect(plugin.runScenario).toBe(runFn);
+ });
+
+ describe('navigateTo', function() {
+ var fakeJSTD = { pluginRegistrar: { register: function() {} } },
+ app = new angular.scenario.Application(_jQuery('')),
+ navigateSpy;
+
+ beforeEach(function() {
+ navigateSpy = spyOn(angular.scenario.Application.prototype, 'navigateTo');
+ });
+
+ it('should add url prefix when jstd defined', function() {
+ initScenarioAdapter(fakeJSTD, null, {relativeUrlPrefix: '/prefix/'});
+
+ app.navigateTo('test.html');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('/prefix/test.html');
+ });
+
+ it('should add forward-slash as default url prefix when jstd defined', function() {
+ initScenarioAdapter(fakeJSTD);
+
+ app.navigateTo('test.html');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('/test.html');
+ });
+
+ it('should not change url when jstd not defined', function() {
+ initScenarioAdapter(null);
+
+ app.navigateTo('test.html');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('test.html');
+ });
+
+ it('should not change hash url', function() {
+ initScenarioAdapter(fakeJSTD);
+
+ app.navigateTo('#/index.html/a');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('#/index.html/a');
+ });
+
+ it('should not change absolute url', function() {
+ initScenarioAdapter(fakeJSTD);
+
+ app.navigateTo('/index.html/a');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('/index.html/a');
+ });
+
+ it('should not change "about:blank" url', function() {
+ initScenarioAdapter(fakeJSTD);
+
+ app.navigateTo('about:blank');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('about:blank');
+ });
+
+ it('should not change url with domain', function() {
+ initScenarioAdapter(fakeJSTD);
+
+ app.navigateTo('http://www.google.com');
+ expect(navigateSpy).toHaveBeenCalled();
+ expect(navigateSpy.mostRecentCall.args[0]).toEqual('http://www.google.com');
+ });
+ });
+ });
+
+ describe('JstdPlugin', function() {
+ var p;
+
+ beforeEach(function() {
+ p = new JstdPlugin();
+ });
+
+ describe('runTestConfiguration', function() {
+ var initScenarioSpy, onTestSpy, onAllTestsSpy, spec, modelSpec;
+
+ beforeEach(function() {
+ initScenarioSpy = jasmine.createSpy('initScenarioAndRun');
+ onTestSpy = jasmine.createSpy('onOneTest');
+ onAllTestsSpy = jasmine.createSpy('onAllTests');
+
+ p.runScenario = initScenarioSpy;
+ spec = {id: 'fake', name: 'Spec Name'};
+ modelSpec = new angular.scenario.ObjectModel.Spec(spec.id, spec.name);
+ });
+
+ it('should ignore non scenario test cases', function() {
+ expect(p.runTestConfiguration(buildTestConf(), onTestSpy, onAllTestsSpy)).toBe(false);
+ expect(p.runTestConfiguration(buildTestConf('async'), onTestSpy, onAllTestsSpy)).toBe(false);
+ expect(initScenarioSpy).not.toHaveBeenCalled();
+ expect(onTestSpy).not.toHaveBeenCalled();
+ expect(onAllTestsSpy).not.toHaveBeenCalled();
+ });
+
+ it('should return true when scenario test case', function() {
+ expect(p.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy)).toBe(true);
+ });
+
+ it('should call initAndRunTests when scenario test case', function() {
+ p.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy);
+ expect(initScenarioSpy).toHaveBeenCalled();
+ });
+ });
+
+ describe('getTestRunsConfigurationFor', function() {
+ it('should add TestRunConfiguration with SCENARIO_TYPE TestCase', function() {
+ var configurations = [];
+ p.getTestRunsConfigurationFor(null, null, configurations);
+
+ expect(configurations.length).toBe(1);
+ expect(configurations[0] instanceof jstestdriver.TestRunConfiguration).toBe(true);
+ expect(configurations[0].getTestCaseInfo().getType()).toEqual(SCENARIO_TYPE);
+ });
+
+ it('should always return true', function() {
+ expect(p.getTestRunsConfigurationFor(null, null, [])).toBe(true);
+ });
+ });
+ });
+
+ describe('createTestResultFromSpec', function() {
+ it('should return jstestdriver.TestResult instance', function() {
+ expect(createTestResultFromSpec(buildSpec()) instanceof jstestdriver.TestResult).toBe(true);
+ });
+
+ it('should set proper test name', function() {
+ expect(createTestResultFromSpec(buildSpec()).testName).toEqual('name');
+ });
+
+ it('should set duration', function() {
+ expect(createTestResultFromSpec(buildSpec()).time).toEqual(10);
+ });
+
+ it('should set test case - full definition name', function() {
+ var spec = buildSpec();
+ expect(createTestResultFromSpec(spec).testCaseName).toEqual(spec.fullDefinitionName);
+ });
+
+ it('should set passed result when success', function() {
+ expect(createTestResultFromSpec(buildSpec('success')).result)
+ .toEqual(jstestdriver.TestResult.RESULT.PASSED);
+ });
+
+ it('should set error result when error', function() {
+ expect(createTestResultFromSpec(buildSpec('error')).result)
+ .toEqual(jstestdriver.TestResult.RESULT.ERROR);
+ });
+
+ it('should set failed result when failure', function() {
+ expect(createTestResultFromSpec(buildSpec('failure')).result)
+ .toEqual(jstestdriver.TestResult.RESULT.FAILED);
+ });
+
+ it('should set error message when error/failure', function() {
+ expect(createTestResultFromSpec(buildErrorSpec('error-message')).message)
+ .toEqual('error-message');
+ });
+
+ it('should log line number when error/failure', function() {
+ expect(createTestResultFromSpec(buildErrorSpec('msg', 'line-number')).log)
+ .toEqual('line-number');
+ });
+ });
+
+ describe('angular.scenario.output.jstd', function() {
+ var model;
+
+ beforeEach(function() {
+ var runner = new angular.scenario.testing.MockRunner(),
+ context = _jQuery("");
+
+ plugin = new JstdPlugin();
+ model = new angular.scenario.ObjectModel(runner);
+ angular.scenario.output.jstd(context, runner, model);
+
+ spyOn(plugin, 'reportEnd');
+ spyOn(plugin, 'reportResult');
+ });
+
+ it('should report end of all tests', function() {
+ model.emit('RunnerEnd');
+ expect(plugin.reportEnd).toHaveBeenCalled();
+ });
+
+ it('should report jstestdriver.TestResult', function() {
+ model.emit('SpecEnd', buildSpec());
+ expect(plugin.reportResult).toHaveBeenCalled();
+ expect(plugin.reportResult.argsForCall[0][0] instanceof jstestdriver.TestResult).toBe(true);
+ });
+ });
+
+ // couple of higher level tests (wiring objects together)
+ describe('HIGHER LEVEL', function() {
+ var initScenarioSpy, onTestSpy, onAllTestsSpy, model;
+
+ beforeEach(function() {
+ plugin = new JstdPlugin();
+ initScenarioSpy = jasmine.createSpy('initScenarioAndRun');
+ onTestSpy = jasmine.createSpy('onOneTest');
+ onAllTestsSpy = jasmine.createSpy('onAllTests');
+
+ var runner = new angular.scenario.testing.MockRunner(),
+ context = _jQuery("");
+
+ model = new angular.scenario.ObjectModel(runner);
+ angular.scenario.output.jstd(context, runner, model);
+
+ initScenarioAdapter(fakeJSTD, initScenarioSpy);
+ plugin.runTestConfiguration(buildScenarioTestConf(), onTestSpy, onAllTestsSpy);
+ });
+
+ afterEach(revertNavigateToHack);
+
+ it('should report and of test suite', function() {
+ model.emit('RunnerEnd');
+ expect(onAllTestsSpy).toHaveBeenCalled();
+ });
+
+ it('should report success test result', function() {
+ model.emit('SpecEnd', buildSpec('success', 'name'));
+ expect(onTestSpy).toHaveBeenCalled();
+ var result = onTestSpy.argsForCall[0][0];
+ expect(result instanceof jstestdriver.TestResult).toBe(true);
+ expect(result.testName).toEqual('name');
+ expect(result.result).toEqual(jstestdriver.TestResult.RESULT.PASSED);
+ });
+
+ it('should report error test result', function() {
+ model.emit('SpecEnd', buildSpec('error'));
+ expect(onTestSpy).toHaveBeenCalled();
+ var result = onTestSpy.argsForCall[0][0];
+ expect(result.result).toEqual(jstestdriver.TestResult.RESULT.ERROR);
+ });
+
+ it('should report failed test result', function() {
+ model.emit('SpecEnd', buildSpec('failure'));
+ expect(onTestSpy).toHaveBeenCalled();
+ var result = onTestSpy.argsForCall[0][0];
+ expect(result.result).toEqual(jstestdriver.TestResult.RESULT.FAILED);
+ });
+ });
+});
diff --git a/test/ngScenario/matchersSpec.js b/test/ngScenario/matchersSpec.js
new file mode 100644
index 00000000..7a5217d7
--- /dev/null
+++ b/test/ngScenario/matchersSpec.js
@@ -0,0 +1,51 @@
+'use strict';
+
+describe('angular.scenario.matchers', function () {
+ var matchers;
+
+ function expectMatcher(value, test) {
+ delete matchers.error;
+ delete matchers.future.value;
+ if (value !== undefined) {
+ matchers.future.value = value;
+ }
+ test();
+ expect(matchers.error).toBeUndefined();
+ }
+
+ beforeEach(function() {
+ /**
+ * Mock up the future system wrapped around matchers.
+ *
+ * @see Scenario.js#angular.scenario.matcher
+ */
+ matchers = {
+ future: { name: 'test' }
+ };
+ matchers.addFuture = function(name, callback) {
+ callback(function(error) {
+ matchers.error = error;
+ });
+ };
+ angular.extend(matchers, angular.scenario.matcher);
+ });
+
+ it('should handle basic matching', function() {
+ expectMatcher(10, function() { matchers.toEqual(10); });
+ expectMatcher('value', function() { matchers.toBeDefined(); });
+ expectMatcher([1], function() { matchers.toBeTruthy(); });
+ expectMatcher("", function() { matchers.toBeFalsy(); });
+ expectMatcher(0, function() { matchers.toBeFalsy(); });
+ expectMatcher('foo', function() { matchers.toMatch('.o.'); });
+ expectMatcher(null, function() { matchers.toBeNull(); });
+ expectMatcher([1, 2, 3], function() { matchers.toContain(2); });
+ expectMatcher(3, function() { matchers.toBeLessThan(10); });
+ expectMatcher(3, function() { matchers.toBeGreaterThan(-5); });
+ });
+
+ it('should have toHaveClass matcher', function(){
+ var e = angular.element('
" / >').
- toEqual('');
- });
-
- it('should ignore back slash as escape', function() {
- expectHTML('abc
xyz');
+ expect(d(e).toLowerCase()).toEqual('abc
xyz');
+ expect(d(e[0]).toLowerCase()).toEqual('abc
');
+ });
+
+ it('should serialize scope', inject(function($rootScope){
+ $rootScope.obj = {abc:'123'};
+ expect(d($rootScope)).toMatch(/Scope\(.*\): \{/);
+ expect(d($rootScope)).toMatch(/{"abc":"123"}/);
+ }));
+
+
+ it('should be published on window', function(){
+ expect(window.dump instanceof Function).toBe(true);
+ });
+ });
+
+ describe('jasmine module and inject', function(){
+ var log;
+
+ beforeEach(function(){
+ log = '';
+ });
+
+ describe('module', function() {
+ describe('in DSL', function() {
+ it('should load module', module(function() {
+ log += 'module';
+ }));
+
+ afterEach(function() {
+ inject();
+ expect(log).toEqual('module');
+ });
+ });
+
+
+ describe('inline in test', function() {
+ it('should load module', function() {
+ module(function() {
+ log += 'module';
+ });
+ inject();
+ });
+
+ afterEach(function() {
+ expect(log).toEqual('module');
+ });
+ });
+ });
+
+ describe('inject', function() {
+ describe('in DSL', function() {
+ it('should load module', inject(function() {
+ log += 'inject';
+ }));
+
+ afterEach(function() {
+ expect(log).toEqual('inject');
+ });
+ });
+
+
+ describe('inline in test', function() {
+ it('should load module', function() {
+ inject(function() {
+ log += 'inject';
+ });
+ });
+
+ afterEach(function() {
+ expect(log).toEqual('inject');
+ });
+ });
+
+ describe('module with inject', function() {
+ beforeEach(module(function(){
+ log += 'module;';
+ }));
+
+ it('should inject', inject(function() {
+ log += 'inject;';
+ }));
+
+ afterEach(function() {
+ expect(log).toEqual('module;inject;')
+ });
+ });
+ });
+ });
+
+
+ describe('$httpBackend', function() {
+ var hb, callback, realBackendSpy;
+
+ beforeEach(inject(function($httpBackend) {
+ callback = jasmine.createSpy('callback');
+ hb = $httpBackend;
+ }));
+
+
+ it('should respond with first matched definition', function() {
+ hb.when('GET', '/url1').respond(200, 'content', {});
+ hb.when('GET', '/url1').respond(201, 'another', {});
+
+ callback.andCallFake(function(status, response) {
+ expect(status).toBe(200);
+ expect(response).toBe('content');
+ });
+
+ hb('GET', '/url1', null, callback);
+ expect(callback).not.toHaveBeenCalled();
+ hb.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it('should throw error when unexpected request', function() {
+ hb.when('GET', '/url1').respond(200, 'content');
+ expect(function() {
+ hb('GET', '/xxx');
+ }).toThrow('Unexpected request: GET /xxx\nNo more request expected');
+ });
+
+
+ it('should match headers if specified', function() {
+ hb.when('GET', '/url', null, {'X': 'val1'}).respond(201, 'content1');
+ hb.when('GET', '/url', null, {'X': 'val2'}).respond(202, 'content2');
+ hb.when('GET', '/url').respond(203, 'content3');
+
+ hb('GET', '/url', null, function(status, response) {
+ expect(status).toBe(203);
+ expect(response).toBe('content3');
+ });
+
+ hb('GET', '/url', null, function(status, response) {
+ expect(status).toBe(201);
+ expect(response).toBe('content1');
+ }, {'X': 'val1'});
+
+ hb('GET', '/url', null, function(status, response) {
+ expect(status).toBe(202);
+ expect(response).toBe('content2');
+ }, {'X': 'val2'});
+
+ hb.flush();
+ });
+
+
+ it('should match data if specified', function() {
+ hb.when('GET', '/a/b', '{a: true}').respond(201, 'content1');
+ hb.when('GET', '/a/b').respond(202, 'content2');
+
+ hb('GET', '/a/b', '{a: true}', function(status, response) {
+ expect(status).toBe(201);
+ expect(response).toBe('content1');
+ });
+
+ hb('GET', '/a/b', null, function(status, response) {
+ expect(status).toBe(202);
+ expect(response).toBe('content2');
+ });
+
+ hb.flush();
+ });
+
+
+ it('should match only method', function() {
+ hb.when('GET').respond(202, 'c');
+ callback.andCallFake(function(status, response) {
+ expect(status).toBe(202);
+ expect(response).toBe('c');
+ });
+
+ hb('GET', '/some', null, callback, {});
+ hb('GET', '/another', null, callback, {'X-Fake': 'Header'});
+ hb('GET', '/third', 'some-data', callback, {});
+ hb.flush();
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+
+ it('should preserve the order of requests', function() {
+ hb.when('GET', '/url1').respond(200, 'first');
+ hb.when('GET', '/url2').respond(201, 'second');
+
+ hb('GET', '/url2', null, callback);
+ hb('GET', '/url1', null, callback);
+
+ hb.flush();
+
+ expect(callback.callCount).toBe(2);
+ expect(callback.argsForCall[0]).toEqual([201, 'second', '']);
+ expect(callback.argsForCall[1]).toEqual([200, 'first', '']);
+ });
+
+
+ describe('respond()', function() {
+ it('should take values', function() {
+ hb.expect('GET', '/url1').respond(200, 'first', {'header': 'val'});
+ hb('GET', '/url1', undefined, callback);
+ hb.flush();
+
+ expect(callback).toHaveBeenCalledOnceWith(200, 'first', 'header: val');
+ });
+
+ it('should take function', function() {
+ hb.expect('GET', '/some').respond(function(m, u, d, h) {
+ return [301, m + u + ';' + d + ';a=' + h.a, {'Connection': 'keep-alive'}];
+ });
+
+ hb('GET', '/some', 'data', callback, {a: 'b'});
+ hb.flush();
+
+ expect(callback).toHaveBeenCalledOnceWith(301, 'GET/some;data;a=b', 'Connection: keep-alive');
+ });
+
+ it('should default status code to 200', function() {
+ callback.andCallFake(function(status, response) {
+ expect(status).toBe(200);
+ expect(response).toBe('some-data');
+ });
+
+ hb.expect('GET', '/url1').respond('some-data');
+ hb.expect('GET', '/url2').respond('some-data', {'X-Header': 'true'});
+ hb('GET', '/url1', null, callback);
+ hb('GET', '/url2', null, callback);
+ hb.flush();
+ expect(callback).toHaveBeenCalled();
+ expect(callback.callCount).toBe(2);
+ });
+
+
+ it('should default response headers to ""', function() {
+ hb.expect('GET', '/url1').respond(200, 'first');
+ hb.expect('GET', '/url2').respond('second');
+
+ hb('GET', '/url1', null, callback);
+ hb('GET', '/url2', null, callback);
+
+ hb.flush();
+
+ expect(callback.callCount).toBe(2);
+ expect(callback.argsForCall[0]).toEqual([200, 'first', '']);
+ expect(callback.argsForCall[1]).toEqual([200, 'second', '']);
+ });
+ });
+
+
+ describe('expect()', function() {
+ it('should require specified order', function() {
+ hb.expect('GET', '/url1').respond(200, '');
+ hb.expect('GET', '/url2').respond(200, '');
+
+ expect(function() {
+ hb('GET', '/url2', null, noop, {});
+ }).toThrow('Unexpected request: GET /url2\nExpected GET /url1');
+ });
+
+
+ it('should have precedence over when()', function() {
+ callback.andCallFake(function(status, response) {
+ expect(status).toBe(300);
+ expect(response).toBe('expect');
+ });
+
+ hb.when('GET', '/url').respond(200, 'when');
+ hb.expect('GET', '/url').respond(300, 'expect');
+
+ hb('GET', '/url', null, callback, {});
+ hb.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it ('should throw exception when only headers differs from expectation', function() {
+ hb.when('GET').respond(200, '', {});
+ hb.expect('GET', '/match', undefined, {'Content-Type': 'application/json'});
+
+ expect(function() {
+ hb('GET', '/match', null, noop, {});
+ }).toThrow('Expected GET /match with different headers\n' +
+ 'EXPECTED: {"Content-Type":"application/json"}\nGOT: {}');
+ });
+
+
+ it ('should throw exception when only data differs from expectation', function() {
+ hb.when('GET').respond(200, '', {});
+ hb.expect('GET', '/match', 'some-data');
+
+ expect(function() {
+ hb('GET', '/match', 'different', noop, {});
+ }).toThrow('Expected GET /match with different data\n' +
+ 'EXPECTED: some-data\nGOT: different');
+ });
+
+
+ it("should use when's respond() when no expect() respond is defined", function() {
+ callback.andCallFake(function(status, response) {
+ expect(status).toBe(201);
+ expect(response).toBe('data');
+ });
+
+ hb.when('GET', '/some').respond(201, 'data');
+ hb.expect('GET', '/some');
+ hb('GET', '/some', null, callback);
+ hb.flush();
+
+ expect(callback).toHaveBeenCalled();
+ expect(function() { hb.verifyNoOutstandingExpectation(); }).not.toThrow();
+ });
+ });
+
+
+ describe('flush()', function() {
+ it('flush() should flush requests fired during callbacks', function() {
+ hb.when('GET').respond(200, '');
+ hb('GET', '/some', null, function() {
+ hb('GET', '/other', null, callback);
+ });
+
+ hb.flush();
+ expect(callback).toHaveBeenCalled();
+ });
+
+
+ it('should flush given number of pending requests', function() {
+ hb.when('GET').respond(200, '');
+ hb('GET', '/some', null, callback);
+ hb('GET', '/some', null, callback);
+ hb('GET', '/some', null, callback);
+
+ hb.flush(2);
+ expect(callback).toHaveBeenCalled();
+ expect(callback.callCount).toBe(2);
+ });
+
+
+ it('should throw exception when flushing more requests than pending', function() {
+ hb.when('GET').respond(200, '');
+ hb('GET', '/url', null, callback);
+
+ expect(function() {hb.flush(2);}).toThrow('No more pending request to flush !');
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+
+ it('should throw exception when no request to flush', function() {
+ expect(function() {hb.flush();}).toThrow('No pending request to flush !');
+
+ hb.when('GET').respond(200, '');
+ hb('GET', '/some', null, callback);
+ hb.flush();
+
+ expect(function() {hb.flush();}).toThrow('No pending request to flush !');
+ });
+
+
+ it('should throw exception if not all expectations satisfied', function() {
+ hb.expect('GET', '/url1').respond();
+ hb.expect('GET', '/url2').respond();
+
+ hb('GET', '/url1', null, angular.noop);
+ expect(function() {hb.flush();}).toThrow('Unsatisfied requests: GET /url2');
+ });
+ });
+
+
+ it('should throw an exception if no response defined', function() {
+ hb.when('GET', '/test');
+ expect(function() {
+ hb('GET', '/test', null, callback);
+ }).toThrow('No response defined !');
+ });
+
+
+ it('should throw an exception if no response for exception and no definition', function() {
+ hb.expect('GET', '/url');
+ expect(function() {
+ hb('GET', '/url', null, callback);
+ }).toThrow('No response defined !');
+ });
+
+
+ it('should respond undefined when JSONP method', function() {
+ hb.when('JSONP', '/url1').respond(200);
+ hb.expect('JSONP', '/url2').respond(200);
+
+ expect(hb('JSONP', '/url1')).toBeUndefined();
+ expect(hb('JSONP', '/url2')).toBeUndefined();
+ });
+
+
+ it('should not have passThrough method', function() {
+ expect(hb.passThrough).toBeUndefined();
+ });
+
+
+ describe('verifyExpectations', function() {
+
+ it('should throw exception if not all expectations were satisfied', function() {
+ hb.expect('POST', '/u1', 'ddd').respond(201, '', {});
+ hb.expect('GET', '/u2').respond(200, '', {});
+ hb.expect('POST', '/u3').respond(201, '', {});
+
+ hb('POST', '/u1', 'ddd', noop, {});
+
+ expect(function() {hb.verifyNoOutstandingExpectation();}).
+ toThrow('Unsatisfied requests: GET /u2, POST /u3');
+ });
+
+
+ it('should do nothing when no expectation', function() {
+ hb.when('DELETE', '/some').respond(200, '');
+
+ expect(function() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+ });
+
+
+ it('should do nothing when all expectations satisfied', function() {
+ hb.expect('GET', '/u2').respond(200, '', {});
+ hb.expect('POST', '/u3').respond(201, '', {});
+ hb.when('DELETE', '/some').respond(200, '');
+
+ hb('GET', '/u2', noop);
+ hb('POST', '/u3', noop);
+
+ expect(function() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+ });
+ });
+
+ describe('verifyRequests', function() {
+
+ it('should throw exception if not all requests were flushed', function() {
+ hb.when('GET').respond(200);
+ hb('GET', '/some', null, noop, {});
+
+ expect(function() {
+ hb.verifyNoOutstandingRequest();
+ }).toThrow('Unflushed requests: 1');
+ });
+ });
+
+
+ describe('resetExpectations', function() {
+
+ it('should remove all expectations', function() {
+ hb.expect('GET', '/u2').respond(200, '', {});
+ hb.expect('POST', '/u3').respond(201, '', {});
+ hb.resetExpectations();
+
+ expect(function() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+ });
+
+
+ it('should remove all pending responses', function() {
+ var cancelledClb = jasmine.createSpy('cancelled');
+
+ hb.expect('GET', '/url').respond(200, '');
+ hb('GET', '/url', null, cancelledClb);
+ hb.resetExpectations();
+
+ hb.expect('GET', '/url').respond(300, '');
+ hb('GET', '/url', null, callback, {});
+ hb.flush();
+
+ expect(callback).toHaveBeenCalledOnce();
+ expect(cancelledClb).not.toHaveBeenCalled();
+ });
+
+
+ it('should not remove definitions', function() {
+ var cancelledClb = jasmine.createSpy('cancelled');
+
+ hb.when('GET', '/url').respond(200, 'success');
+ hb('GET', '/url', null, cancelledClb);
+ hb.resetExpectations();
+
+ hb('GET', '/url', null, callback, {});
+ hb.flush();
+
+ expect(callback).toHaveBeenCalledOnce();
+ expect(cancelledClb).not.toHaveBeenCalled();
+ });
+ });
+
+
+ describe('expect/when shortcuts', function() {
+ angular.forEach(['expect', 'when'], function(prefix) {
+ angular.forEach(['GET', 'POST', 'PUT', 'DELETE', 'JSONP'], function(method) {
+ var shortcut = prefix + method;
+ it('should provide ' + shortcut + ' shortcut method', function() {
+ hb[shortcut]('/foo').respond('bar');
+ hb(method, '/foo', undefined, callback);
+ hb.flush();
+ expect(callback).toHaveBeenCalledOnceWith(200, 'bar', '');
+ });
+ });
+ });
+ });
+
+
+ describe('MockHttpExpectation', function() {
+
+ it('should accept url as regexp', function() {
+ var exp = new MockHttpExpectation('GET', /^\/x/);
+
+ expect(exp.match('GET', '/x')).toBe(true);
+ expect(exp.match('GET', '/xxx/x')).toBe(true);
+ expect(exp.match('GET', 'x')).toBe(false);
+ expect(exp.match('GET', 'a/x')).toBe(false);
+ });
+
+
+ it('should accept data as regexp', function() {
+ var exp = new MockHttpExpectation('POST', '/url', /\{.*?\}/);
+
+ expect(exp.match('POST', '/url', '{"a": "aa"}')).toBe(true);
+ expect(exp.match('POST', '/url', '{"one": "two"}')).toBe(true);
+ expect(exp.match('POST', '/url', '{"one"')).toBe(false);
+ });
+
+
+ it('should ignore data only if undefined (not null or false)', function() {
+ var exp = new MockHttpExpectation('POST', '/url', null);
+ expect(exp.matchData(null)).toBe(true);
+ expect(exp.matchData('some-data')).toBe(false);
+
+ exp = new MockHttpExpectation('POST', '/url', undefined);
+ expect(exp.matchData(null)).toBe(true);
+ expect(exp.matchData('some-data')).toBe(true);
+ });
+
+
+ it('should accept headers as function', function() {
+ var exp = new MockHttpExpectation('GET', '/url', undefined, function(h) {
+ return h['Content-Type'] == 'application/json';
+ });
+
+ expect(exp.matchHeaders({})).toBe(false);
+ expect(exp.matchHeaders({'Content-Type': 'application/json', 'X-Another': 'true'})).toBe(true);
+ });
+ });
+ });
+});
+
+
+describe('ngMockE2E', function() {
+ describe('$httpBackend', function() {
+ var hb, realHttpBackend, callback;
+
+ beforeEach(function() {
+ module(function($provide) {
+ callback = jasmine.createSpy('callback');
+ realHttpBackend = jasmine.createSpy('real $httpBackend');
+ $provide.value('$httpBackend', realHttpBackend);
+ $provide.decorator('$httpBackend', angular.mock.e2e.$httpBackendDecorator);
+ });
+ inject(function($injector) {
+ hb = $injector.get('$httpBackend');
+ });
+ });
+
+
+ describe('passThrough()', function() {
+ it('should delegate requests to the real backend when passThrough is invoked', function() {
+ hb.when('GET', /\/passThrough\/.*/).passThrough();
+ hb('GET', '/passThrough/23', null, callback);
+
+ expect(realHttpBackend).
+ toHaveBeenCalledOnceWith('GET', '/passThrough/23', null, callback, undefined);
+ });
+ });
+
+
+ describe('autoflush', function() {
+ it('should flush responses via $defer', inject(function($browser) {
+ hb.when('GET', '/foo').respond('bar');
+ hb('GET', '/foo', null, callback);
+
+ expect(callback).not.toHaveBeenCalled();
+ $browser.defer.flush();
+ expect(callback).toHaveBeenCalledOnce();
+ }));
+ });
+ });
+});
diff --git a/test/ngScenario/ApplicationSpec.js b/test/ngScenario/ApplicationSpec.js
new file mode 100644
index 00000000..7384ecaa
--- /dev/null
+++ b/test/ngScenario/ApplicationSpec.js
@@ -0,0 +1,141 @@
+'use strict';
+
+describe('angular.scenario.Application', function() {
+ var $window;
+ var app, frames;
+
+ function callLoadHandlers(app) {
+ var handlers = app.getFrame_().data('events').load;
+ expect(handlers).toBeDefined();
+ expect(handlers.length).toEqual(1);
+ handlers[0].handler();
+ }
+
+ beforeEach(function() {
+ frames = _jQuery("");
+ app = new angular.scenario.Application(frames);
+ });
+
+ it('should return new $window and $document after navigate', function() {
+ var called;
+ var testWindow, testDocument, counter = 0;
+ app.getWindow_ = function() {
+ return {x:counter++, document:{x:counter++}};
+ };
+ app.navigateTo('http://www.google.com/');
+ app.executeAction(function($document, $window) {
+ testWindow = $window;
+ testDocument = $document;
+ });
+ app.navigateTo('http://www.google.com/');
+ app.executeAction(function($window, $document) {
+ expect($window).not.toEqual(testWindow);
+ expect($document).not.toEqual(testDocument);
+ called = true;
+ });
+ expect(called).toBeTruthy();
+ });
+
+ it('should execute callback with correct arguments', function() {
+ var called;
+ var testWindow = {document: {}};
+ app.getWindow_ = function() {
+ return testWindow;
+ };
+ app.executeAction(function($window, $document) {
+ expect(this).toEqual(app);
+ expect($document).toEqual(_jQuery($window.document));
+ expect($window).toEqual(testWindow);
+ called = true;
+ });
+ expect(called).toBeTruthy();
+ });
+
+ it('should use a new iframe each time', function() {
+ app.navigateTo('http://localhost/');
+ var frame = app.getFrame_();
+ frame.attr('test', true);
+ app.navigateTo('http://localhost/');
+ expect(app.getFrame_().attr('test')).toBeFalsy();
+ });
+
+ it('should call error handler if document not accessible', function() {
+ var called;
+ app.getWindow_ = function() {
+ return {};
+ };
+ app.navigateTo('http://localhost/', angular.noop, function(error) {
+ expect(error).toMatch(/Sandbox Error/);
+ called = true;
+ });
+ callLoadHandlers(app);
+ expect(called).toBeTruthy();
+ });
+
+ it('should call error handler if navigating to about:blank', function() {
+ var called;
+ app.navigateTo('about:blank', angular.noop, function(error) {
+ expect(error).toMatch(/Sandbox Error/);
+ called = true;
+ });
+ expect(called).toBeTruthy();
+ });
+
+ it('should remove old iframes', function() {
+ app.navigateTo('http://localhost/#foo');
+ frames.find('iframe')[0].id = 'test';
+
+ app.navigateTo('http://localhost/#bar');
+ var iframes = frames.find('iframe');
+
+ expect(iframes.length).toEqual(1);
+ expect(iframes[0].src).toEqual('http://localhost/#bar');
+ expect(iframes[0].id).toBeFalsy();
+ });
+
+ it('should URL update description bar', function() {
+ app.navigateTo('http://localhost/');
+ var anchor = frames.find('> h2 a');
+ expect(anchor.attr('href')).toEqual('http://localhost/');
+ expect(anchor.text()).toEqual('http://localhost/');
+ });
+
+ it('should call onload handler when frame loads', function() {
+ var called;
+ app.getWindow_ = function() {
+ return {document: {}};
+ };
+ app.navigateTo('http://localhost/', function($window, $document) {
+ called = true;
+ });
+ callLoadHandlers(app);
+ expect(called).toBeTruthy();
+ });
+
+ it('should wait for pending requests in executeAction', inject(function($injector, $browser) {
+ var called, polled;
+ var handlers = [];
+ var testWindow = {
+ document: jqLite('')[0],
+ angular: {
+ element: jqLite,
+ service: {}
+ }
+ };
+ $browser.notifyWhenNoOutstandingRequests = function(fn) {
+ handlers.push(fn);
+ };
+ jqLite(testWindow.document).data('$injector', $injector);
+ app.getWindow_ = function() {
+ return testWindow;
+ };
+ app.executeAction(function($window, $document) {
+ expect($window).toEqual(testWindow);
+ expect($document).toBeDefined();
+ expect($document[0].className).toEqual('test-foo');
+ });
+ expect(handlers.length).toEqual(1);
+ handlers[0]();
+ dealoc(testWindow.document);
+ }));
+});
diff --git a/test/ngScenario/DescribeSpec.js b/test/ngScenario/DescribeSpec.js
new file mode 100644
index 00000000..6741ed6d
--- /dev/null
+++ b/test/ngScenario/DescribeSpec.js
@@ -0,0 +1,122 @@
+'use strict';
+
+describe('angular.scenario.Describe', function() {
+ var log;
+ var root;
+
+ beforeEach(function() {
+ root = new angular.scenario.Describe();
+
+ /**
+ * Simple callback logging system. Use to assert proper order of calls.
+ */
+ log = function(text) {
+ log.text = log.text + text;
+ };
+ log.fn = function(text) {
+ return function(done){
+ log(text);
+ (done || angular.noop)();
+ };
+ };
+ log.reset = function() {
+ log.text = '';
+ };
+ log.reset();
+ });
+
+ it('should handle basic nested case', function() {
+ root.describe('A', function() {
+ this.beforeEach(log.fn('{'));
+ this.afterEach(log.fn('}'));
+ this.it('1', log.fn('1'));
+ this.describe('B', function() {
+ this.beforeEach(log.fn('('));
+ this.afterEach(log.fn(')'));
+ this.it('2', log.fn('2'));
+ });
+ });
+ var specs = root.getSpecs();
+ expect(specs.length).toEqual(2);
+
+ expect(specs[0].name).toEqual('2');
+ specs[0].before();
+ specs[0].body();
+ specs[0].after();
+ expect(log.text).toEqual('{(2)}');
+
+ log.reset();
+ expect(specs[1].name).toEqual('1');
+ specs[1].before();
+ specs[1].body();
+ specs[1].after();
+ expect(log.text).toEqual('{1}');
+ });
+
+ it('should link nested describe blocks with parent and children', function() {
+ root.describe('A', function() {
+ this.it('1', angular.noop);
+ this.describe('B', function() {
+ this.it('2', angular.noop);
+ this.describe('C', function() {
+ this.it('3', angular.noop);
+ });
+ });
+ });
+ var specs = root.getSpecs();
+ expect(specs[2].definition.parent).toEqual(root);
+ expect(specs[0].definition.parent).toEqual(specs[2].definition.children[0]);
+ });
+
+ it('should not process xit and xdescribe', function() {
+ root.describe('A', function() {
+ this.xit('1', angular.noop);
+ this.xdescribe('B', function() {
+ this.it('2', angular.noop);
+ this.describe('C', function() {
+ this.it('3', angular.noop);
+ });
+ });
+ });
+ var specs = root.getSpecs();
+ expect(specs.length).toEqual(0);
+ });
+
+ it('should only return iit and ddescribe if present', function() {
+ root.describe('A', function() {
+ this.it('1', angular.noop);
+ this.iit('2', angular.noop);
+ this.describe('B', function() {
+ this.it('3', angular.noop);
+ this.ddescribe('C', function() {
+ this.it('4', angular.noop);
+ this.describe('D', function() {
+ this.it('5', angular.noop);
+ });
+ });
+ });
+ });
+ var specs = root.getSpecs();
+ expect(specs.length).toEqual(3);
+ expect(specs[0].name).toEqual('5');
+ expect(specs[1].name).toEqual('4');
+ expect(specs[2].name).toEqual('2');
+ });
+
+ it('should create uniqueIds in the tree', function() {
+ angular.scenario.Describe.id = 0;
+ var a = new angular.scenario.Describe();
+ var b = new angular.scenario.Describe();
+ expect(a.id).toNotEqual(b.id);
+ });
+
+ it('should create uniqueIds for each spec', function() {
+ var d = new angular.scenario.Describe();
+ d.it('fake', function() {});
+ d.it('fake', function() {});
+
+ expect(d.its[0].id).toBeDefined();
+ expect(d.its[1].id).toBeDefined();
+ expect(d.its[0].id).not.toEqual(d.its[1].id);
+ });
+});
diff --git a/test/ngScenario/FutureSpec.js b/test/ngScenario/FutureSpec.js
new file mode 100644
index 00000000..2a75f275
--- /dev/null
+++ b/test/ngScenario/FutureSpec.js
@@ -0,0 +1,77 @@
+'use strict';
+
+describe('angular.scenario.Future', function() {
+ var future;
+
+ it('should set the sane defaults', function() {
+ var behavior = function() {};
+ var future = new angular.scenario.Future('test name', behavior, 'foo');
+ expect(future.name).toEqual('test name');
+ expect(future.behavior).toEqual(behavior);
+ expect(future.line).toEqual('foo');
+ expect(future.value).toBeUndefined();
+ expect(future.fulfilled).toBeFalsy();
+ expect(future.parser).toEqual(angular.identity);
+ });
+
+ it('should be fulfilled after execution and done callback', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done();
+ });
+ future.execute(angular.noop);
+ expect(future.fulfilled).toBeTruthy();
+ });
+
+ it('should take callback with (error, result) and forward', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(10, 20);
+ });
+ future.execute(function(error, result) {
+ expect(error).toEqual(10);
+ expect(result).toEqual(20);
+ });
+ });
+
+ it('should use error as value if provided', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(10, 20);
+ });
+ future.execute(angular.noop);
+ expect(future.value).toEqual(10);
+ });
+
+ it('should parse json with fromJson', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(null, "{test: 'foo'}");
+ });
+ future.fromJson().execute(angular.noop);
+ expect(future.value).toEqual({test: 'foo'});
+ });
+
+ it('should convert to json with toJson', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(null, {test: 'foo'});
+ });
+ future.toJson().execute(angular.noop);
+ expect(future.value).toEqual('{"test":"foo"}');
+ });
+
+ it('should convert with custom parser', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(null, 'foo');
+ });
+ future.parsedWith(function(value) {
+ return value.toUpperCase();
+ }).execute(angular.noop);
+ expect(future.value).toEqual('FOO');
+ });
+
+ it('should pass error if parser fails', function() {
+ var future = new angular.scenario.Future('test name', function(done) {
+ done(null, '{');
+ });
+ future.fromJson().execute(function(error, result) {
+ expect(error).toBeDefined();
+ });
+ });
+});
diff --git a/test/ngScenario/ObjectModelSpec.js b/test/ngScenario/ObjectModelSpec.js
new file mode 100644
index 00000000..e0da628d
--- /dev/null
+++ b/test/ngScenario/ObjectModelSpec.js
@@ -0,0 +1,333 @@
+'use strict';
+
+describe('angular.scenario.ObjectModel', function() {
+ var model;
+ var runner;
+ var spec, step;
+
+ function buildSpec(id, name, definitions) {
+ var spec = {
+ id: id,
+ name: name,
+ definition: {
+ name: definitions.shift()
+ }
+ };
+ var currentDef = spec.definition;
+
+ forEach(definitions, function(defName) {
+ currentDef.parent = {
+ name: defName
+ };
+ currentDef = currentDef.parent;
+ });
+
+ return spec;
+ }
+
+ function buildStep(name, line) {
+ return {
+ name: name || 'test step',
+ line: function() { return line || ''; }
+ };
+ }
+
+ beforeEach(function() {
+ spec = buildSpec(1, 'test spec', ['describe 1']);
+ step = buildStep();
+ runner = new angular.scenario.testing.MockRunner();
+ model = new angular.scenario.ObjectModel(runner);
+ });
+
+ it('should value default empty value', function() {
+ expect(model.value).toEqual({
+ name: '',
+ children: []
+ });
+ });
+
+ it('should add spec and create describe blocks on SpecBegin event', function() {
+ runner.emit('SpecBegin', buildSpec(1, 'test spec', ['describe 2', 'describe 1']));
+
+ expect(model.value.children['describe 1']).toBeDefined();
+ expect(model.value.children['describe 1'].children['describe 2']).toBeDefined();
+ expect(model.value.children['describe 1'].children['describe 2'].specs['test spec']).toBeDefined();
+ });
+
+ it('should set fullDefinitionName on SpecBegin event', function() {
+ runner.emit('SpecBegin', buildSpec(1, 'fake spec', ['describe 2']));
+ var spec = model.getSpec(1);
+
+ expect(spec.fullDefinitionName).toBeDefined();
+ expect(spec.fullDefinitionName).toEqual('describe 2');
+ });
+
+ it('should set fullDefinitionName on SpecBegin event (join more names by space)', function() {
+ runner.emit('SpecBegin', buildSpec(1, 'fake spec', ['describe 2', 'describe 1']));
+ var spec = model.getSpec(1);
+
+ expect(spec.fullDefinitionName).toEqual('describe 1 describe 2');
+ });
+
+ it('should add step to spec on StepBegin', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].steps.length).toEqual(1);
+ });
+
+ it('should update spec timer duration on SpecEnd event', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].duration).toBeDefined();
+ });
+
+ it('should update step timer duration on StepEnd event', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].steps[0].duration).toBeDefined();
+ });
+
+ it('should set spec status on SpecEnd to success if no status set', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('success');
+ });
+
+ it('should set status to error after SpecError', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecError', spec, 'error');
+
+ expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('error');
+ });
+
+ it('should set spec status to failure if step fails', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('failure');
+ });
+
+ it('should set spec status to error if step errors', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepError', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('error');
+ });
+
+ describe('events', function() {
+ var Spec = angular.scenario.ObjectModel.Spec,
+ Step = angular.scenario.ObjectModel.Step,
+ callback;
+
+ beforeEach(function() {
+ callback = jasmine.createSpy('listener');
+ });
+
+ it('should provide method for registering a listener', function() {
+ expect(model.on).toBeDefined();
+ expect(model.on instanceof Function).toBe(true);
+ });
+
+ it('should forward SpecBegin event', function() {
+ model.on('SpecBegin', callback);
+ runner.emit('SpecBegin', spec);
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward SpecBegin event with ObjectModel.Spec as a param', function() {
+ model.on('SpecBegin', callback);
+ runner.emit('SpecBegin', spec);
+
+ expect(callback.mostRecentCall.args[0] instanceof Spec).toBe(true);
+ expect(callback.mostRecentCall.args[0].name).toEqual(spec.name);
+ });
+
+ it('should forward SpecError event', function() {
+ model.on('SpecError', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecError', spec, {});
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward SpecError event with ObjectModel.Spec and error as a params', function() {
+ var error = {};
+ model.on('SpecError', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecError', spec, error);
+
+ var param = callback.mostRecentCall.args[0];
+ expect(param instanceof Spec).toBe(true);
+ expect(param.name).toEqual(spec.name);
+ expect(param.status).toEqual('error');
+ expect(param.error).toBe(error);
+ });
+
+ it('should forward SpecEnd event', function() {
+ model.on('SpecEnd', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecEnd', spec);
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward SpecEnd event with ObjectModel.Spec as a param', function() {
+ model.on('SpecEnd', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecEnd', spec);
+
+ expect(callback.mostRecentCall.args[0] instanceof Spec).toBe(true);
+ expect(callback.mostRecentCall.args[0].name).toEqual(spec.name);
+ });
+
+ it('should forward StepBegin event', function() {
+ model.on('StepBegin', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward StepBegin event with Spec and Step as params', function() {
+ model.on('StepBegin', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+
+ var params = callback.mostRecentCall.args;
+ expect(params[0] instanceof Spec).toBe(true);
+ expect(params[0].name).toEqual(spec.name);
+ expect(params[1] instanceof Step).toBe(true);
+ });
+
+ it('should forward StepError event', function() {
+ model.on('StepError', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepError', spec, step, {});
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward StepError event with Spec, Step and error as params', function() {
+ var error = {};
+ model.on('StepError', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepError', spec, step, error);
+
+ var params = callback.mostRecentCall.args;
+ expect(params[0] instanceof Spec).toBe(true);
+ expect(params[0].name).toEqual(spec.name);
+ expect(params[1] instanceof Step).toBe(true);
+ expect(params[1].status).toEqual('error');
+ expect(params[2]).toBe(error);
+ });
+
+ it('should forward StepFailure event', function() {
+ model.on('StepFailure', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, {});
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward StepFailure event with Spec, Step and error as params', function() {
+ var error = {};
+ model.on('StepFailure', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, error);
+
+ var params = callback.mostRecentCall.args;
+ expect(params[0] instanceof Spec).toBe(true);
+ expect(params[0].name).toEqual(spec.name);
+ expect(params[1] instanceof Step).toBe(true);
+ expect(params[1].status).toEqual('failure');
+ expect(params[2]).toBe(error);
+ });
+
+ it('should forward StepEnd event', function() {
+ model.on('StepEnd', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should forward StepEnd event with Spec and Step as params', function() {
+ model.on('StepEnd', callback);
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+
+ var params = callback.mostRecentCall.args;
+ expect(params[0] instanceof Spec).toBe(true);
+ expect(params[0].name).toEqual(spec.name);
+ expect(params[1] instanceof Step).toBe(true);
+ });
+
+ it('should forward RunnerEnd event', function() {
+ model.on('RunnerEnd', callback);
+ runner.emit('RunnerEnd');
+ expect(callback).toHaveBeenCalled();
+ });
+
+ it('should set error of first failure', function() {
+ var error = 'first-error',
+ step2 = buildStep();
+
+ model.on('SpecEnd', function(spec) {
+ expect(spec.error).toBeDefined();
+ expect(spec.error).toBe(error);
+ });
+
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, error);
+ runner.emit('StepBegin', spec, step2);
+ runner.emit('StepFailure', spec, step2, 'second-error');
+ runner.emit('SpecEnd', spec);
+ });
+
+ it('should set line number of first failure', function() {
+ var step = buildStep('fake', 'first-line'),
+ step2 = buildStep('fake2', 'second-line');
+
+ model.on('SpecEnd', function(spec) {
+ expect(spec.line).toBeDefined();
+ expect(spec.line).toBe('first-line');
+ });
+
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, null);
+ runner.emit('StepBegin', spec, step2);
+ runner.emit('StepFailure', spec, step2, null);
+ runner.emit('SpecEnd', spec);
+ });
+ });
+});
diff --git a/test/ngScenario/RunnerSpec.js b/test/ngScenario/RunnerSpec.js
new file mode 100644
index 00000000..c4ad6f95
--- /dev/null
+++ b/test/ngScenario/RunnerSpec.js
@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * Mock spec runner.
+ */
+function MockSpecRunner() {}
+MockSpecRunner.prototype.run = function(spec, specDone) {
+ spec.before.call(this);
+ spec.body.call(this);
+ spec.after.call(this);
+ specDone();
+};
+
+MockSpecRunner.prototype.addFuture = function(name, fn, line) {
+ return {name: name, fn: fn, line: line};
+};
+
+describe('angular.scenario.Runner', function() {
+ var $window;
+ var runner;
+
+ beforeEach(function() {
+ // Trick to get the scope out of a DSL statement
+ angular.scenario.dsl('dslAddFuture', function() {
+ return function() {
+ return this.addFuture('future name', angular.noop);
+ };
+ });
+ // Trick to get the scope out of a DSL statement
+ angular.scenario.dsl('dslScope', function() {
+ var scope = this;
+ return function() { return scope; };
+ });
+ // Trick to get the scope out of a DSL statement
+ angular.scenario.dsl('dslChain', function() {
+ return function() {
+ this.chained = 0;
+ this.chain = function() { this.chained++; return this; };
+ return this;
+ };
+ });
+ $window = {
+ location: {}
+ };
+ runner = new angular.scenario.Runner($window);
+ runner.on('SpecError', angular.mock.rethrow);
+ runner.on('StepError', angular.mock.rethrow);
+ });
+
+ afterEach(function() {
+ delete angular.scenario.dsl.dslScope;
+ delete angular.scenario.dsl.dslChain;
+ });
+
+ it('should publish the functions in the public API', function() {
+ angular.forEach(runner.api, function(fn, name) {
+ var func;
+ if (name in $window) {
+ func = $window[name];
+ }
+ expect(angular.isFunction(func)).toBeTruthy();
+ });
+ });
+
+ it('should construct valid describe trees with public API', function() {
+ var before = [];
+ var after = [];
+ $window.describe('A', function() {
+ $window.beforeEach(function() { before.push('A'); });
+ $window.afterEach(function() { after.push('A'); });
+ $window.it('1', angular.noop);
+ $window.describe('B', function() {
+ $window.beforeEach(function() { before.push('B'); });
+ $window.afterEach(function() { after.push('B'); });
+ $window.it('2', angular.noop);
+ $window.describe('C', function() {
+ $window.beforeEach(function() { before.push('C'); });
+ $window.afterEach(function() { after.push('C'); });
+ $window.it('3', angular.noop);
+ });
+ });
+ });
+ var specs = runner.rootDescribe.getSpecs();
+ specs[0].before();
+ specs[0].body();
+ specs[0].after();
+ expect(before).toEqual(['A', 'B', 'C']);
+ expect(after).toEqual(['C', 'B', 'A']);
+ expect(specs[2].definition.parent).toEqual(runner.rootDescribe);
+ expect(specs[0].definition.parent).toEqual(specs[2].definition.children[0]);
+ });
+
+ it('should publish the DSL statements to the $window', function() {
+ $window.describe('describe', function() {
+ $window.it('1', function() {
+ expect($window.dslScope).toBeDefined();
+ });
+ });
+ runner.run(null/*application*/);
+ });
+
+ it('should create a new scope for each DSL chain', function() {
+ $window.describe('describe', function() {
+ $window.it('1', function() {
+ var scope = $window.dslScope();
+ scope.test = "foo";
+ expect($window.dslScope().test).toBeUndefined();
+ });
+ $window.it('2', function() {
+ var scope = $window.dslChain().chain().chain();
+ expect(scope.chained).toEqual(2);
+ });
+ });
+ runner.run(null/*application*/);
+ });
+});
diff --git a/test/ngScenario/ScenarioSpec.js b/test/ngScenario/ScenarioSpec.js
new file mode 100644
index 00000000..cc2efd1e
--- /dev/null
+++ b/test/ngScenario/ScenarioSpec.js
@@ -0,0 +1,32 @@
+'use strict';
+
+describe("ScenarioSpec: Compilation", function() {
+ var element;
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+
+ describe('compilation', function() {
+ it("should compile dom node and return scope", inject(function($rootScope, $compile) {
+ var node = jqLite('{{b=a+1}}
')[0];
+ element = $compile(node)($rootScope);
+ $rootScope.$digest();
+ expect($rootScope.a).toEqual(1);
+ expect($rootScope.b).toEqual(2);
+ }));
+
+ it("should compile jQuery node and return scope", inject(function($rootScope, $compile) {
+ element = $compile(jqLite('{{a=123}}
'))($rootScope);
+ $rootScope.$digest();
+ expect(jqLite(element).text()).toEqual('123');
+ }));
+
+ it("should compile text node and return scope", inject(function($rootScope, $compile) {
+ element = $compile('{{a=123}}
')($rootScope);
+ $rootScope.$digest();
+ expect(jqLite(element).text()).toEqual('123');
+ }));
+ });
+});
diff --git a/test/ngScenario/SpecRunnerSpec.js b/test/ngScenario/SpecRunnerSpec.js
new file mode 100644
index 00000000..c104a9b7
--- /dev/null
+++ b/test/ngScenario/SpecRunnerSpec.js
@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * Mock Application
+ */
+function ApplicationMock($window) {
+ this.$window = $window;
+}
+ApplicationMock.prototype = {
+ executeAction: function(callback) {
+ callback.call(this.$window, _jQuery(this.$window.document), this.$window);
+ }
+};
+
+describe('angular.scenario.SpecRunner', function() {
+ var $window, $root, log;
+ var runner;
+
+ function createSpec(name, body) {
+ return {
+ name: name,
+ before: angular.noop,
+ body: body || angular.noop,
+ after: angular.noop
+ };
+ }
+
+ beforeEach(inject(function($rootScope) {
+ log = [];
+ $window = {};
+ $window.setTimeout = function(fn, timeout) {
+ fn();
+ };
+ $root = $rootScope;
+ $root.emit = function(eventName) {
+ log.push(eventName);
+ };
+ $root.on = function(eventName) {
+ log.push('Listener Added for ' + eventName);
+ };
+ $root.application = new ApplicationMock($window);
+ $root.$window = $window;
+ runner = $root.$new();
+
+ var Cls = angular.scenario.SpecRunner;
+ for (var name in Cls.prototype)
+ runner[name] = angular.bind(runner, Cls.prototype[name]);
+
+ Cls.call(runner);
+ }));
+
+ it('should bind futures to the spec', function() {
+ runner.addFuture('test future', function(done) {
+ this.value = 10;
+ done();
+ });
+ runner.futures[0].execute(angular.noop);
+ expect(runner.value).toEqual(10);
+ });
+
+ it('should pass done to future action behavior', function() {
+ runner.addFutureAction('test future', function($window, $document, done) {
+ expect(angular.isFunction(done)).toBeTruthy();
+ done(10, 20);
+ });
+ runner.futures[0].execute(function(error, result) {
+ expect(error).toEqual(10);
+ expect(result).toEqual(20);
+ });
+ });
+
+ it('should execute spec function and notify UI', function() {
+ var finished;
+ var spec = createSpec('test spec', function() {
+ this.test = 'some value';
+ });
+ runner.addFuture('test future', function(done) {
+ done();
+ });
+ runner.run(spec, function() {
+ finished = true;
+ });
+ expect(runner.test).toEqual('some value');
+ expect(finished).toBeTruthy();
+ expect(log).toEqual([
+ 'SpecBegin',
+ 'StepBegin',
+ 'StepEnd',
+ 'SpecEnd'
+ ]);
+ });
+
+ it('should execute notify UI on spec setup error', function() {
+ var finished;
+ var spec = createSpec('test spec', function() {
+ throw 'message';
+ });
+ runner.run(spec, function() {
+ finished = true;
+ });
+ expect(finished).toBeTruthy();
+ expect(log).toEqual([
+ 'SpecBegin',
+ 'SpecError',
+ 'SpecEnd'
+ ]);
+ });
+
+ it('should execute notify UI on step failure', function() {
+ var finished;
+ var spec = createSpec('test spec');
+ runner.addFuture('test future', function(done) {
+ done('failure message');
+ });
+ runner.run(spec, function() {
+ finished = true;
+ });
+ expect(finished).toBeTruthy();
+ expect(log).toEqual([
+ 'SpecBegin',
+ 'StepBegin',
+ 'StepFailure',
+ 'StepEnd',
+ 'SpecEnd'
+ ]);
+ });
+
+ it('should execute notify UI on step error', function() {
+ var finished;
+ var spec = createSpec('test spec', function() {
+ this.addFuture('test future', function(done) {
+ throw 'error message';
+ });
+ });
+ runner.run(spec, function() {
+ finished = true;
+ });
+ expect(finished).toBeTruthy();
+ expect(log).toEqual([
+ 'SpecBegin',
+ 'StepBegin',
+ 'StepError',
+ 'StepEnd',
+ 'SpecEnd'
+ ]);
+ });
+
+ it('should run after handlers even if error in body of spec', function() {
+ var finished, after;
+ var spec = createSpec('test spec', function() {
+ this.addFuture('body', function(done) {
+ throw 'error message';
+ });
+ });
+ spec.after = function() {
+ this.addFuture('after', function(done) {
+ after = true;
+ done();
+ });
+ };
+ runner.run(spec, function() {
+ finished = true;
+ });
+ expect(finished).toBeTruthy();
+ expect(after).toBeTruthy();
+ expect(log).toEqual([
+ 'SpecBegin',
+ 'StepBegin',
+ 'StepError',
+ 'StepEnd',
+ 'StepBegin',
+ 'StepEnd',
+ 'SpecEnd'
+ ]);
+ });
+
+});
diff --git a/test/ngScenario/dslSpec.js b/test/ngScenario/dslSpec.js
new file mode 100644
index 00000000..0a8ab762
--- /dev/null
+++ b/test/ngScenario/dslSpec.js
@@ -0,0 +1,629 @@
+'use strict';
+
+describe("angular.scenario.dsl", function() {
+ var element;
+ var $window, $root;
+ var eventLog;
+
+ afterEach(function() {
+ dealoc(element);
+ });
+
+ beforeEach(inject(function($injector) {
+ eventLog = [];
+ $window = {
+ document: window.document.body,
+ angular: new angular.scenario.testing.MockAngular()
+ };
+ jqLite($window.document).data('$injector', $injector).attr('ng-app', '').addClass('html');
+ $root = $injector.get('$rootScope');
+ $root.emit = function(eventName) {
+ eventLog.push(eventName);
+ };
+ $root.on = function(eventName) {
+ eventLog.push('Listener Added for ' + eventName);
+ };
+ $root.futures = [];
+ $root.futureLog = [];
+ $root.$window = $window;
+ $root.addFuture = function(name, fn) {
+ this.futures.push(name);
+ fn.call(this, function(error, result) {
+ $root.futureError = error;
+ $root.futureResult = result;
+ $root.futureLog.push(name);
+ });
+ };
+ $root.dsl = {};
+ angular.forEach(angular.scenario.dsl, function(fn, name) {
+ $root.dsl[name] = function() {
+ return fn.call($root).apply($root, arguments);
+ };
+ });
+ $root.application = new angular.scenario.Application(jqLite($window.document));
+ $root.application.getWindow_ = function() {
+ return $window;
+ };
+ $root.application.navigateTo = function(url, callback) {
+ $window.location = url;
+ callback();
+ };
+ // Just use the real one since it delegates to this.addFuture
+ $root.addFutureAction = angular.scenario.
+ SpecRunner.prototype.addFutureAction;
+ jqLite($window.document).html('');
+ }));
+
+ afterEach(function(){
+ jqLite($window.document).removeData('$injector');
+ });
+
+ describe('Pause', function() {
+ it('should pause until resume to complete', function() {
+ expect($window.resume).toBeUndefined();
+ $root.dsl.pause();
+ expect(angular.isFunction($window.resume)).toBeTruthy();
+ expect($root.futureLog).toEqual([]);
+ $window.resume();
+ expect($root.futureLog).
+ toEqual(['pausing for you to resume']);
+ expect(eventLog).toContain('InteractivePause');
+ });
+ });
+
+ describe('Sleep', function() {
+ beforeEach(function() {
+ $root.$window.setTimeout = function(fn, value) {
+ $root.timerValue = value;
+ fn();
+ };
+ });
+
+ it('should sleep for specified seconds', function() {
+ $root.dsl.sleep(10);
+ expect($root.timerValue).toEqual(10000);
+ expect($root.futureResult).toEqual(10000);
+ });
+ });
+
+ describe('Expect', function() {
+ it('should chain and execute matcher', function() {
+ var future = {value: 10};
+ var result = $root.dsl.expect(future);
+ result.toEqual(10);
+ expect($root.futureError).toBeUndefined();
+ expect($root.futureResult).toBeUndefined();
+ result = $root.dsl.expect(future);
+ result.toEqual(20);
+ expect($root.futureError).toBeDefined();
+ });
+ });
+
+ describe('Browser', function() {
+ describe('Reload', function() {
+ it('should navigateTo', function() {
+ $window.location = {
+ href: '#foo'
+ };
+ $root.dsl.browser().reload();
+ expect($root.futureResult).toEqual('#foo');
+ expect($window.location).toEqual('#foo');
+ });
+ });
+
+ describe('NavigateTo', function() {
+ it('should allow a string url', function() {
+ $root.dsl.browser().navigateTo('http://myurl');
+ expect($window.location).toEqual('http://myurl');
+ expect($root.futureResult).toEqual('http://myurl');
+ });
+
+ it('should allow a future url', function() {
+ $root.dsl.browser().navigateTo('http://myurl', function() {
+ return 'http://futureUrl/';
+ });
+ expect($window.location).toEqual('http://futureUrl/');
+ expect($root.futureResult).toEqual('http://futureUrl/');
+ });
+
+ it('should complete if angular is missing from app frame', function() {
+ delete $window.angular;
+ $root.dsl.browser().navigateTo('http://myurl');
+ expect($window.location).toEqual('http://myurl');
+ expect($root.futureResult).toEqual('http://myurl');
+ });
+ });
+
+ describe('window', function() {
+ beforeEach(function() {
+ $window.location = {
+ href: 'http://myurl/some/path?foo=10#/bar?x=2',
+ pathname: '/some/path',
+ search: '?foo=10',
+ hash: '#bar?x=2'
+ };
+ });
+
+ it('should return full URL for href', function() {
+ $root.dsl.browser().window().href();
+ expect($root.futureResult).toEqual($window.location.href);
+ });
+
+ it('should return the pathname', function() {
+ $root.dsl.browser().window().path();
+ expect($root.futureResult).toEqual($window.location.pathname);
+ });
+
+ it('should return the search part', function() {
+ $root.dsl.browser().window().search();
+ expect($root.futureResult).toEqual($window.location.search);
+ });
+
+ it('should return the hash without the #', function() {
+ $root.dsl.browser().window().hash();
+ expect($root.futureResult).toEqual('bar?x=2');
+ });
+ });
+
+ describe('location', function() {
+ beforeEach(function() {
+ $window.angular.injector = function() {
+ return {
+ get: function(serviceId) {
+ if (serviceId == '$location') {
+ return {
+ url: function() {return '/path?search=a#hhh';},
+ path: function() {return '/path';},
+ search: function() {return {search: 'a'};},
+ hash: function() {return 'hhh';}
+ };
+ }
+ throw new Error('unknown service id ' + serviceId);
+ }
+ };
+ };
+ });
+
+ it('should return full url', function() {
+ $root.dsl.browser().location().url();
+ expect($root.futureResult).toEqual('/path?search=a#hhh');
+ });
+
+ it('should return the pathname', function() {
+ $root.dsl.browser().location().path();
+ expect($root.futureResult).toEqual('/path');
+ });
+
+ it('should return the query string as an object', function() {
+ $root.dsl.browser().location().search();
+ expect($root.futureResult).toEqual({search: 'a'});
+ });
+
+ it('should return the hash without the #', function() {
+ $root.dsl.browser().location().hash();
+ expect($root.futureResult).toEqual('hhh');
+ });
+ });
+ });
+
+ describe('Element Finding', function() {
+ var doc;
+ beforeEach(inject(function($injector) {
+ doc = _jQuery($window.document).append('').find('.body');
+ }));
+
+ describe('Select', function() {
+ it('should select single option', function() {
+ doc.append(
+ ''
+ );
+ $root.dsl.select('test').option('A');
+ expect(doc.find('[ng-model="test"]').val()).toEqual('A');
+ });
+
+ it('should select option by name', function() {
+ doc.append(
+ ''
+ );
+ $root.dsl.select('test').option('one');
+ expect(doc.find('[ng-model="test"]').val()).toEqual('A');
+ });
+
+ it('should select multiple options', function() {
+ doc.append(
+ ''
+ );
+ $root.dsl.select('test').options('A', 'B');
+ expect(doc.find('[ng-model="test"]').val()).toEqual(['A','B']);
+ });
+
+ it('should fail to select multiple options on non-multiple select', function() {
+ doc.append('');
+ $root.dsl.select('test').options('A', 'B');
+ expect($root.futureError).toMatch(/did not match/);
+ });
+ });
+
+ describe('Element', function() {
+ it('should execute click', function() {
+ var clicked;
+ // Hash is important, otherwise we actually
+ // go to a different page and break the runner
+ doc.append('');
+ doc.find('a').click(function() {
+ clicked = true;
+ });
+ $root.dsl.element('a').click();
+ });
+
+ it('should navigate page if click on anchor', function() {
+ expect($window.location).not.toEqual('#foo');
+ doc.append('');
+ $root.dsl.element('a').click();
+ expect($window.location).toMatch(/#foo$/);
+ });
+
+ it('should not navigate if click event was cancelled', function() {
+ var initLocation = $window.location,
+ elm = jqLite('');
+
+ doc.append(elm);
+ elm.bind('click', function(event) {
+ event.preventDefault();
+ });
+
+ $root.dsl.element('a').click();
+ expect($window.location).toBe(initLocation);
+ dealoc(elm);
+ });
+
+ it('should count matching elements', function() {
+ doc.append('');
+ $root.dsl.element('span').count();
+ expect($root.futureResult).toEqual(2);
+ });
+
+ it('should return count of 0 if no matching elements', function() {
+ $root.dsl.element('span').count();
+ expect($root.futureResult).toEqual(0);
+ });
+
+ it('should get attribute', function() {
+ doc.append('');
+ $root.dsl.element('#test').attr('class');
+ expect($root.futureResult).toEqual('foo');
+ });
+
+ it('should set attribute', function() {
+ doc.append('');
+ $root.dsl.element('#test').attr('class', 'bam');
+ expect(doc.find('#test').attr('class')).toEqual('bam');
+ });
+
+ it('should get property', function() {
+ doc.append('');
+ $root.dsl.element('#test').prop('className');
+ expect($root.futureResult).toEqual('foo');
+ });
+
+ it('should set property', function() {
+ doc.append('');
+ $root.dsl.element('#test').prop('className', 'bam');
+ expect(doc.find('#test').prop('className')).toEqual('bam');
+ });
+
+ it('should get css', function() {
+ doc.append('');
+ $root.dsl.element('#test').css('height');
+ expect($root.futureResult).toMatch(/30px/);
+ });
+
+ it('should set css', function() {
+ doc.append('');
+ $root.dsl.element('#test').css('height', '20px');
+ expect(doc.find('#test').css('height')).toEqual('20px');
+ });
+
+ it('should add all jQuery key/value methods', function() {
+ var METHODS = ['css', 'attr'];
+ var chain = $root.dsl.element('input');
+ angular.forEach(METHODS, function(name) {
+ expect(angular.isFunction(chain[name])).toBeTruthy();
+ });
+ });
+
+ it('should get val', function() {
+ doc.append('');
+ $root.dsl.element('input').val();
+ expect($root.futureResult).toEqual('bar');
+ });
+
+ it('should set val', function() {
+ doc.append('');
+ $root.dsl.element('input').val('baz');
+ expect(doc.find('input').val()).toEqual('baz');
+ });
+
+ it('should use correct future name for generated set methods', function() {
+ doc.append('');
+ $root.dsl.element('input').val(false);
+ expect($root.futures.pop()).toMatch(/element 'input' set val/);
+ });
+
+ it('should use correct future name for generated get methods', function() {
+ doc.append('');
+ $root.dsl.element('input').val();
+ expect($root.futures.pop()).toMatch(/element 'input' val/);
+ });
+
+ it('should add all jQuery property methods', function() {
+ var METHODS = [
+ 'val', 'text', 'html', 'height', 'innerHeight', 'outerHeight', 'width',
+ 'innerWidth', 'outerWidth', 'position', 'scrollLeft', 'scrollTop', 'offset'
+ ];
+ var chain = $root.dsl.element('input');
+ angular.forEach(METHODS, function(name) {
+ expect(angular.isFunction(chain[name])).toBeTruthy();
+ });
+ });
+
+ it('should execute custom query', function() {
+ doc.append('');
+ $root.dsl.element('#test').query(function(elements, done) {
+ done(null, elements.attr('href'));
+ });
+ expect($root.futureResult).toEqual('http://example.com/myUrl');
+ });
+
+ it('should use the selector as label if none is given', function() {
+ $root.dsl.element('mySelector');
+ expect($root.label).toEqual('mySelector');
+ });
+
+ it('should include the selector in paren when a label is given', function() {
+ $root.dsl.element('mySelector', 'myLabel');
+ expect($root.label).toEqual('myLabel ( mySelector )');
+ });
+ });
+
+ describe('Repeater', function() {
+ var chain;
+ beforeEach(inject(function($compile, $rootScope) {
+ element = $compile(
+ '- {{i.name}} {{i.gender}}
{{ true }}'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('some value'); + + $root.dsl.binding('true'); + expect($root.futureResult).toEqual('true'); + }); + + it('should select binding by name', function() { + compile(''); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('some value'); + }); + + it('should select binding by regexp', function() { + compile('some value'); + $root.dsl.binding(/^foo\..+/); + expect($root.futureResult).toEqual('some value'); + }); + + it('should return innerHTML for all the other elements', function() { + compile('', 'some value'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult.toLowerCase()).toEqual('some value'); + }); + + it('should select binding in template by name', function() { + compile('', 'bar'); + $root.dsl.binding('foo.bar'); + expect($root.futureResult).toEqual('bar'); + }); + + it('should match bindings by substring match', function() { + compile('', 'binding value'); + $root.dsl.binding('foo . bar'); + expect($root.futureResult).toEqual('binding value'); + }); + + it('should return error if no bindings in document', function() { + $root.dsl.binding('foo.bar'); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should return error if no binding matches', function() { + compile('some value'); + $root.dsl.binding('foo.bar'); + expect($root.futureError).toMatch(/did not match/); + }); + }); + + describe('Using', function() { + it('should prefix selector in $document.elements()', function() { + var chain; + doc.append( + '' + + '' + ); + chain = $root.dsl.using('div#test2'); + chain.input('test.input').enter('foo'); + var inputs = _jQuery('input[ng-model="test.input"]'); + expect(inputs.first().val()).toEqual('something'); + expect(inputs.last().val()).toEqual('foo'); + }); + + it('should use the selector as label if none is given', function() { + $root.dsl.using('mySelector'); + expect($root.label).toEqual('mySelector'); + }); + + it('should include the selector in paren when a label is given', function() { + $root.dsl.using('mySelector', 'myLabel'); + expect($root.label).toEqual('myLabel ( mySelector )'); + }); + + }); + + describe('Input', function() { + it('should change value in text input', function() { + doc.append(''); + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); + }); + + it('should change value in text input in dash form', function() { + doc.append(''); + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); + }); + + it('should return error if no input exists', function() { + var chain = $root.dsl.input('test.input'); + chain.enter('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should toggle checkbox state', function() { + doc.append(''); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(true); + var chain = $root.dsl.input('test.input'); + chain.check(); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(false); + $window.angular.reset(); + chain.check(); + expect(_jQuery('input[ng-model="test.input"]'). + prop('checked')).toBe(true); + }); + + it('should return error if checkbox did not match', function() { + var chain = $root.dsl.input('test.input'); + chain.check(); + expect($root.futureError).toMatch(/did not match/); + }); + + it('should select option from radio group', function() { + doc.append( + '' + + '' + ); + // HACK! We don't know why this is sometimes false on chrome + _jQuery('input[ng\\:model="test.input"][value="bar"]').prop('checked', true); + expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). + prop('checked')).toBe(true); + expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). + prop('checked')).toBe(false); + var chain = $root.dsl.input('test.input'); + chain.select('foo'); + expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). + prop('checked')).toBe(false); + expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). + prop('checked')).toBe(true); + }); + + it('should return error if radio button did not match', function() { + var chain = $root.dsl.input('test.input'); + chain.select('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + + describe('val', function() { + it('should return value in text input', function() { + doc.append(''); + $root.dsl.input('test.input').val(); + expect($root.futureResult).toEqual("something"); + }); + }); + }); + + describe('Textarea', function() { + + it('should change value in textarea', function() { + doc.append(''); + var chain = $root.dsl.input('test.textarea'); + chain.enter('foo'); + expect(_jQuery('textarea[ng-model="test.textarea"]').val()).toEqual('foo'); + }); + + it('should return error if no textarea exists', function() { + var chain = $root.dsl.input('test.textarea'); + chain.enter('foo'); + expect($root.futureError).toMatch(/did not match/); + }); + }); + }); +}); diff --git a/test/ngScenario/e2e/Runner-compiled.html b/test/ngScenario/e2e/Runner-compiled.html new file mode 100644 index 00000000..530fef96 --- /dev/null +++ b/test/ngScenario/e2e/Runner-compiled.html @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/test/ngScenario/e2e/Runner.html b/test/ngScenario/e2e/Runner.html new file mode 100644 index 00000000..1191dc86 --- /dev/null +++ b/test/ngScenario/e2e/Runner.html @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/test/ngScenario/e2e/style.css b/test/ngScenario/e2e/style.css new file mode 100644 index 00000000..26540bec --- /dev/null +++ b/test/ngScenario/e2e/style.css @@ -0,0 +1,11 @@ +th { + text-align: left; +} + +tr { + border: 1px solid black; +} + +.redbox { + background-color: red; +} diff --git a/test/ngScenario/e2e/widgets-scenario.js b/test/ngScenario/e2e/widgets-scenario.js new file mode 100644 index 00000000..fda9b3c6 --- /dev/null +++ b/test/ngScenario/e2e/widgets-scenario.js @@ -0,0 +1,67 @@ +'use strict'; + +describe('widgets', function() { + it('should verify that basic widgets work', function() { + browser().navigateTo('widgets.html'); + + using('#text-basic-box').input('text.basic').enter('Carlos'); + expect(binding('text.basic')).toEqual('Carlos'); + input('text.basic').enter('Carlos Santana'); + expect(binding('text.basic')).not().toEqual('Carlos Boozer'); + + input('text.password').enter('secret'); + expect(binding('text.password')).toEqual('secret'); + + expect(binding('text.hidden')).toEqual('hiddenValue'); + + expect(binding('gender')).toEqual('male'); + input('gender').select('female'); + expect(using('#gender-box').binding('gender')).toEqual('female'); + + expect(repeater('#repeater-row ul li').count()).toEqual(2); + expect(repeater('#repeater-row ul li').row(1)).toEqual(['adam']); + expect(repeater('#repeater-row ul li').column('name')).toEqual(['misko', 'adam']); + + select('select').option('B'); + expect(binding('select')).toEqual('B'); + + select('multiselect').options('A', 'C'); + expect(binding('multiselect').fromJson()).toEqual(['A', 'C']); + + expect(binding('button').fromJson()).toEqual({'count': 0}); + expect(binding('form').fromJson()).toEqual({'count': 0}); + + element('form a', "'action' link").click(); + expect(binding('button').fromJson()).toEqual({'count': 1}); + + element('input[value="submit input"]', "'submit input' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 2}); + expect(binding('form').fromJson()).toEqual({'count': 1}); + + element('button:contains("submit button")', "'submit button' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 2}); + expect(binding('form').fromJson()).toEqual({'count': 2}); + + element('input[value="button"]', "'button' button").click(); + expect(binding('button').fromJson()).toEqual({'count': 3}); + + element('input[type="image"]', 'form image').click(); + expect(binding('button').fromJson()).toEqual({'count': 4}); + + /** + * Custom value parser for futures. + */ + function checkboxParser(value) { + return angular.fromJson(value.substring(value.indexOf('=')+1)); + } + + input('checkbox.tea').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: false, tea: false}); + input('checkbox.coffee').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: false}); + input('checkbox.tea').check(); + input('checkbox.tea').check(); + input('checkbox.tea').check(); + expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: true}); + }); +}); diff --git a/test/ngScenario/e2e/widgets.html b/test/ngScenario/e2e/widgets.html new file mode 100644 index 00000000..f986144e --- /dev/null +++ b/test/ngScenario/e2e/widgets.html @@ -0,0 +1,99 @@ + + + + + + + +
| Description | +Test | +Result | +
|---|---|---|
| Input text field | ||
| basic | ++ + | +text.basic={{text.basic}} | +
| password | ++ | text.password={{text.password}} | +
| hidden | ++ | text.hidden={{text.hidden}} | +
| Input selection field | ||
| radio | +
+ Female + Male + |
+ gender={{gender}} | +
| checkbox | +
+ Tea + Coffe + |
+
+ checkbox={{checkbox}}
+ |
+
| select | ++ + | +select={{select}} | +
| multiselect | ++ + | +multiselect={{multiselect}} | +
| Buttons | ||
| ng-change ng-click |
+ + + | +button={{button}} form={{form}} | +
| Repeaters | ||
| ng-repeat | +
+
|
+ + |
');
+ expect(e).not.toHaveClass('none');
+ expect(e).toHaveClass('abc');
+ });
+});
diff --git a/test/ngScenario/mocks.js b/test/ngScenario/mocks.js
new file mode 100644
index 00000000..e135390f
--- /dev/null
+++ b/test/ngScenario/mocks.js
@@ -0,0 +1,33 @@
+'use strict';
+
+angular.scenario.testing = angular.scenario.testing || {};
+
+angular.scenario.testing.MockAngular = function() {
+ this.reset();
+ this.element = jqLite;
+};
+
+angular.scenario.testing.MockAngular.prototype.reset = function() {
+ this.log = [];
+};
+
+angular.scenario.testing.MockAngular.prototype.poll = function() {
+ this.log.push('$brower.poll()');
+ return this;
+};
+
+angular.scenario.testing.MockRunner = function() {
+ this.listeners = [];
+};
+
+angular.scenario.testing.MockRunner.prototype.on = function(eventName, fn) {
+ this.listeners[eventName] = this.listeners[eventName] || [];
+ this.listeners[eventName].push(fn);
+};
+
+angular.scenario.testing.MockRunner.prototype.emit = function(eventName) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ angular.forEach(this.listeners[eventName] || [], function(fn) {
+ fn.apply(this, args);
+ });
+};
diff --git a/test/ngScenario/output/HtmlSpec.js b/test/ngScenario/output/HtmlSpec.js
new file mode 100644
index 00000000..442e596d
--- /dev/null
+++ b/test/ngScenario/output/HtmlSpec.js
@@ -0,0 +1,126 @@
+'use strict';
+
+describe('angular.scenario.output.html', function() {
+ var runner, model, spec, step, listeners, ui, context;
+
+ beforeEach(function() {
+ listeners = [];
+ spec = {
+ name: 'test spec',
+ definition: {
+ id: 10,
+ name: 'child',
+ children: [],
+ parent: {
+ id: 20,
+ name: 'parent',
+ children: []
+ }
+ }
+ };
+ step = {
+ name: 'some step',
+ line: function() { return 'unknown:-1'; }
+ };
+ runner = new angular.scenario.testing.MockRunner();
+ model = new angular.scenario.ObjectModel(runner);
+ context = _jQuery("");
+ ui = angular.scenario.output.html(context, runner, model);
+ });
+
+ it('should create nested describe context', function() {
+ runner.emit('SpecBegin', spec);
+ expect(context.find('#describe-20 #describe-10 > h2').text()).
+ toEqual('describe: child');
+ expect(context.find('#describe-20 > h2').text()).toEqual('describe: parent');
+ expect(context.find('#describe-10 .tests > li .test-info .test-name').text()).
+ toEqual('test spec');
+ expect(context.find('#describe-10 .tests > li').hasClass('status-pending')).
+ toBeTruthy();
+ });
+
+ it('should add link on InteractivePause', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('InteractivePause', spec, step);
+ expect(context.find('.test-actions .test-title:first').text()).toEqual('some step');
+ expect(lowercase(context.find('.test-actions .test-title:last').html())).toEqual(
+ 'paused... resume when ready.'
+ );
+ });
+
+ it('should update totals when steps complete', function() {
+ // Failure
+ for (var i=0; i < 3; ++i) {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+ }
+
+ // Error
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecError', spec, 'error');
+ runner.emit('SpecEnd', spec);
+
+ // Error
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepError', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ // Success
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ expect(parseInt(context.find('#status-legend .status-failure').text(), 10)).
+ toEqual(3);
+ expect(parseInt(context.find('#status-legend .status-error').text(), 10)).
+ toEqual(2);
+ expect(parseInt(context.find('#status-legend .status-success').text(), 10)).
+ toEqual(1);
+ });
+
+ it('should update timer when test completes', function() {
+ // Success
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ // Failure
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ // Error
+ runner.emit('SpecBegin', spec);
+ runner.emit('SpecError', spec, 'error');
+ runner.emit('SpecEnd', spec);
+
+ context.find('#describe-10 .tests > li .test-info .timer-result').
+ each(function(index, timer) {
+ expect(timer.innerHTML).toMatch(/ms$/);
+ });
+ });
+
+ it('should include line if provided', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepFailure', spec, step, 'error');
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+
+ var errorHtml = context.find('#describe-10 .tests li pre').html();
+ expect(errorHtml.indexOf('unknown:-1')).toEqual(0);
+ });
+
+});
diff --git a/test/ngScenario/output/jsonSpec.js b/test/ngScenario/output/jsonSpec.js
new file mode 100644
index 00000000..06caf91c
--- /dev/null
+++ b/test/ngScenario/output/jsonSpec.js
@@ -0,0 +1,37 @@
+'use strict';
+
+describe('angular.scenario.output.json', function() {
+ var output, context;
+ var runner, model, $window;
+ var spec, step;
+
+ beforeEach(function() {
+ $window = {};
+ context = _jQuery('');
+ runner = new angular.scenario.testing.MockRunner();
+ model = new angular.scenario.ObjectModel(runner);
+ output = angular.scenario.output.json(context, runner, model);
+ spec = {
+ name: 'test spec',
+ definition: {
+ id: 10,
+ name: 'describe'
+ }
+ };
+ step = {
+ name: 'some step',
+ line: function() { return 'unknown:-1'; }
+ };
+ });
+
+ it('should put json in context on RunnerEnd', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+ runner.emit('RunnerEnd');
+
+ expect(angular.fromJson(context.html()).children['describe']
+ .specs['test spec'].status).toEqual('success');
+ });
+});
diff --git a/test/ngScenario/output/objectSpec.js b/test/ngScenario/output/objectSpec.js
new file mode 100644
index 00000000..d92c939d
--- /dev/null
+++ b/test/ngScenario/output/objectSpec.js
@@ -0,0 +1,40 @@
+'use strict';
+
+describe('angular.scenario.output.object', function() {
+ var output;
+ var runner, model, $window;
+ var spec, step;
+
+ beforeEach(function() {
+ $window = {};
+ runner = new angular.scenario.testing.MockRunner();
+ model = new angular.scenario.ObjectModel(runner);
+ runner.$window = $window;
+ output = angular.scenario.output.object(null, runner, model);
+ spec = {
+ name: 'test spec',
+ definition: {
+ id: 10,
+ name: 'describe',
+ children: []
+ }
+ };
+ step = {
+ name: 'some step',
+ line: function() { return 'unknown:-1'; }
+ };
+ });
+
+ it('should create a global variable $result', function() {
+ expect($window.$result).toBeDefined();
+ });
+
+ it('should maintain live state in $result', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+
+ expect($window.$result.children['describe']
+ .specs['test spec'].steps[0].duration).toBeDefined();
+ });
+});
diff --git a/test/ngScenario/output/xmlSpec.js b/test/ngScenario/output/xmlSpec.js
new file mode 100644
index 00000000..94c3cb5a
--- /dev/null
+++ b/test/ngScenario/output/xmlSpec.js
@@ -0,0 +1,36 @@
+'use strict';
+
+describe('angular.scenario.output.json', function() {
+ var output, context;
+ var runner, model, $window;
+ var spec, step;
+
+ beforeEach(function() {
+ $window = {};
+ context = _jQuery('');
+ runner = new angular.scenario.testing.MockRunner();
+ model = new angular.scenario.ObjectModel(runner);
+ output = angular.scenario.output.xml(context, runner, model);
+ spec = {
+ name: 'test spec',
+ definition: {
+ id: 10,
+ name: 'describe'
+ }
+ };
+ step = {
+ name: 'some step',
+ line: function() { return 'unknown:-1'; }
+ };
+ });
+
+ it('should create XML nodes for object model', function() {
+ runner.emit('SpecBegin', spec);
+ runner.emit('StepBegin', spec, step);
+ runner.emit('StepEnd', spec, step);
+ runner.emit('SpecEnd', spec);
+ runner.emit('RunnerEnd');
+ expect(context.find('it').attr('status')).toEqual('success');
+ expect(context.find('it step').attr('status')).toEqual('success');
+ });
+});
diff --git a/test/sanitizerSpec.js b/test/sanitizerSpec.js
deleted file mode 100644
index a33d8992..00000000
--- a/test/sanitizerSpec.js
+++ /dev/null
@@ -1,281 +0,0 @@
-'use strict';
-
-describe('HTML', function() {
-
- var expectHTML;
-
- beforeEach(inject(function($sanitize) {
- expectHTML = function(html){
- return expect($sanitize(html));
- };
- }));
-
- describe('htmlParser', function() {
- var handler, start, text;
- beforeEach(function() {
- handler = {
- start: function(tag, attrs, unary){
- start = {
- tag: tag,
- attrs: attrs,
- unary: unary
- };
- // Since different browsers handle newlines differenttly we trim
- // so that it is easier to write tests.
- forEach(attrs, function(value, key){
- attrs[key] = trim(value);
- });
- },
- chars: function(text_){
- text = text_;
- },
- end:function(tag) {
- expect(tag).toEqual(start.tag);
- }
- };
- });
-
- it('should parse basic format', function() {
- htmlParser('text ', handler);
- expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
- expect(text).toEqual('text');
- });
-
- it('should parse newlines in tags', function() {
- htmlParser('<\ntag\n attr="value"\n>text<\n/\ntag\n>', handler);
- expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
- expect(text).toEqual('text');
- });
-
- it('should parse newlines in attributes', function() {
- htmlParser('text ', handler);
- expect(start).toEqual({tag:'tag', attrs:{attr:'value'}, unary:false});
- expect(text).toEqual('text');
- });
-
- it('should parse namespace', function() {
- htmlParser('text ', handler);
- expect(start).toEqual({tag:'ns:t-a-g', attrs:{'ns:a-t-t-r':'value'}, unary:false});
- expect(text).toEqual('text');
- });
-
- it('should parse empty value attribute of node', function() {
- htmlParser('', handler);
- expect(start).toEqual({tag:'option', attrs:{selected:'', value:''}, unary:false});
- expect(text).toEqual('abc');
- });
-
- });
-
- it('should echo html', function() {
- expectHTML('helloworld.').
- toEqual('helloworld.');
- });
-
- it('should remove script', function() {
- expectHTML('ac.').toEqual('ac.');
- });
-
- it('should remove double nested script', function() {
- expectHTML('ailc.').toEqual('ac.');
- });
-
- it('should remove unknown names', function() {
- expectHTML('ab c').toEqual('abc');
- });
-
- it('should remove unsafe value', function() {
- expectHTML('').toEqual('');
- });
-
- it('should handle self closed elements', function() {
- expectHTML('a
c').toEqual('a
c'); - }); - - it('should handle namespace', function() { - expectHTML('ab c').toEqual('abc');
- });
-
- it('should handle entities', function() {
- var everything = '
" alt=abc dir=\'"\' >text< /div>').
- toEqual('c').toEqual('a
c'); - }); - - it('should handle namespace', function() { - expectHTML('a
' +
- '!@#$%^&*()_+-={}[]:";\'<>?,./`~ ħ
';
- expectHTML(everything).toEqual(everything);
- });
-
- it('should handle improper html', function() {
- expectHTML('< div rel="text
');
- });
-
- it('should handle improper html2', function() {
- expectHTML('< div rel="in
after');
- });
-
- it('should escape text nodes', function() {
- writer.chars('a&
c');
- expect(html).toEqual('a<div>&</div>c');
- });
-
- it('should escape IE script', function() {
- writer.chars('&<>{}');
- expect(html).toEqual('&<>{}');
- });
-
- it('should escape attributes', function() {
- writer.start('div', {rel:'!@#$%^&*()_+-={}[]:";\'<>?,./`~ \n\0\r\u0127'});
- expect(html).toEqual('');
- });
-
- it('should ignore missformed elements', function() {
- writer.start('d>i&v', {});
- expect(html).toEqual('');
- });
-
- it('should ignore unknown attributes', function() {
- writer.start('div', {unknown:""});
- expect(html).toEqual('
');
- });
-
- describe('explicitly dissallow', function() {
- it('should not allow attributes', function() {
- writer.start('div', {id:'a', name:'a', style:'a'});
- expect(html).toEqual('
');
- });
-
- it('should not allow tags', function() {
- function tag(name) {
- writer.start(name, {});
- writer.end(name);
- }
- tag('frameset');
- tag('frame');
- tag('form');
- tag('param');
- tag('object');
- tag('embed');
- tag('textarea');
- tag('input');
- tag('button');
- tag('option');
- tag('select');
- tag('script');
- tag('style');
- tag('link');
- tag('base');
- tag('basefont');
- expect(html).toEqual('');
- });
- });
-
- describe('isUri', function() {
-
- function isUri(value) {
- return value.match(URI_REGEXP);
- }
-
- it('should be URI', function() {
- expect(isUri('http://abc')).toBeTruthy();
- expect(isUri('https://abc')).toBeTruthy();
- expect(isUri('ftp://abc')).toBeTruthy();
- expect(isUri('mailto:me@example.com')).toBeTruthy();
- expect(isUri('#anchor')).toBeTruthy();
- });
-
- it('should not be UIR', function() {
- expect(isUri('')).toBeFalsy();
- expect(isUri('javascript:alert')).toBeFalsy();
- });
- });
-
- describe('javascript URL attribute', function() {
- beforeEach(function() {
- this.addMatchers({
- toBeValidUrl: function() {
- return URI_REGEXP.exec(this.actual);
- }
- });
- });
-
- it('should ignore javascript:', function() {
- expect('JavaScript:abc').not.toBeValidUrl();
- expect(' \n Java\n Script:abc').not.toBeValidUrl();
- expect('http://JavaScript/my.js').toBeValidUrl();
- });
-
- it('should ignore dec encoded javascript:', function() {
- expect('javascript:').not.toBeValidUrl();
- expect('javascript:').not.toBeValidUrl();
- expect('j avascript:').not.toBeValidUrl();
- });
-
- it('should ignore decimal with leading 0 encodede javascript:', function() {
- expect('javascript:').not.toBeValidUrl();
- expect('j avascript:').not.toBeValidUrl();
- expect('j avascript:').not.toBeValidUrl();
- });
-
- it('should ignore hex encoded javascript:', function() {
- expect('javascript:').not.toBeValidUrl();
- expect('javascript:').not.toBeValidUrl();
- expect('j avascript:').not.toBeValidUrl();
- });
-
- it('should ignore hex encoded whitespace javascript:', function() {
- expect('jav ascript:alert("A");').not.toBeValidUrl();
- expect('jav
ascript:alert("B");').not.toBeValidUrl();
- expect('jav
ascript:alert("C");').not.toBeValidUrl();
- expect('jav\u0000ascript:alert("D");').not.toBeValidUrl();
- expect('java\u0000\u0000script:alert("D");').not.toBeValidUrl();
- expect(' java\u0000\u0000script:alert("D");').not.toBeValidUrl();
- });
- });
-
- });
-
-});
diff --git a/test/scenario/ApplicationSpec.js b/test/scenario/ApplicationSpec.js
deleted file mode 100644
index 7384ecaa..00000000
--- a/test/scenario/ApplicationSpec.js
+++ /dev/null
@@ -1,141 +0,0 @@
-'use strict';
-
-describe('angular.scenario.Application', function() {
- var $window;
- var app, frames;
-
- function callLoadHandlers(app) {
- var handlers = app.getFrame_().data('events').load;
- expect(handlers).toBeDefined();
- expect(handlers.length).toEqual(1);
- handlers[0].handler();
- }
-
- beforeEach(function() {
- frames = _jQuery("");
- app = new angular.scenario.Application(frames);
- });
-
- it('should return new $window and $document after navigate', function() {
- var called;
- var testWindow, testDocument, counter = 0;
- app.getWindow_ = function() {
- return {x:counter++, document:{x:counter++}};
- };
- app.navigateTo('http://www.google.com/');
- app.executeAction(function($document, $window) {
- testWindow = $window;
- testDocument = $document;
- });
- app.navigateTo('http://www.google.com/');
- app.executeAction(function($window, $document) {
- expect($window).not.toEqual(testWindow);
- expect($document).not.toEqual(testDocument);
- called = true;
- });
- expect(called).toBeTruthy();
- });
-
- it('should execute callback with correct arguments', function() {
- var called;
- var testWindow = {document: {}};
- app.getWindow_ = function() {
- return testWindow;
- };
- app.executeAction(function($window, $document) {
- expect(this).toEqual(app);
- expect($document).toEqual(_jQuery($window.document));
- expect($window).toEqual(testWindow);
- called = true;
- });
- expect(called).toBeTruthy();
- });
-
- it('should use a new iframe each time', function() {
- app.navigateTo('http://localhost/');
- var frame = app.getFrame_();
- frame.attr('test', true);
- app.navigateTo('http://localhost/');
- expect(app.getFrame_().attr('test')).toBeFalsy();
- });
-
- it('should call error handler if document not accessible', function() {
- var called;
- app.getWindow_ = function() {
- return {};
- };
- app.navigateTo('http://localhost/', angular.noop, function(error) {
- expect(error).toMatch(/Sandbox Error/);
- called = true;
- });
- callLoadHandlers(app);
- expect(called).toBeTruthy();
- });
-
- it('should call error handler if navigating to about:blank', function() {
- var called;
- app.navigateTo('about:blank', angular.noop, function(error) {
- expect(error).toMatch(/Sandbox Error/);
- called = true;
- });
- expect(called).toBeTruthy();
- });
-
- it('should remove old iframes', function() {
- app.navigateTo('http://localhost/#foo');
- frames.find('iframe')[0].id = 'test';
-
- app.navigateTo('http://localhost/#bar');
- var iframes = frames.find('iframe');
-
- expect(iframes.length).toEqual(1);
- expect(iframes[0].src).toEqual('http://localhost/#bar');
- expect(iframes[0].id).toBeFalsy();
- });
-
- it('should URL update description bar', function() {
- app.navigateTo('http://localhost/');
- var anchor = frames.find('> h2 a');
- expect(anchor.attr('href')).toEqual('http://localhost/');
- expect(anchor.text()).toEqual('http://localhost/');
- });
-
- it('should call onload handler when frame loads', function() {
- var called;
- app.getWindow_ = function() {
- return {document: {}};
- };
- app.navigateTo('http://localhost/', function($window, $document) {
- called = true;
- });
- callLoadHandlers(app);
- expect(called).toBeTruthy();
- });
-
- it('should wait for pending requests in executeAction', inject(function($injector, $browser) {
- var called, polled;
- var handlers = [];
- var testWindow = {
- document: jqLite('')[0],
- angular: {
- element: jqLite,
- service: {}
- }
- };
- $browser.notifyWhenNoOutstandingRequests = function(fn) {
- handlers.push(fn);
- };
- jqLite(testWindow.document).data('$injector', $injector);
- app.getWindow_ = function() {
- return testWindow;
- };
- app.executeAction(function($window, $document) {
- expect($window).toEqual(testWindow);
- expect($document).toBeDefined();
- expect($document[0].className).toEqual('test-foo');
- });
- expect(handlers.length).toEqual(1);
- handlers[0]();
- dealoc(testWindow.document);
- }));
-});
diff --git a/test/scenario/DescribeSpec.js b/test/scenario/DescribeSpec.js
deleted file mode 100644
index 6741ed6d..00000000
--- a/test/scenario/DescribeSpec.js
+++ /dev/null
@@ -1,122 +0,0 @@
-'use strict';
-
-describe('angular.scenario.Describe', function() {
- var log;
- var root;
-
- beforeEach(function() {
- root = new angular.scenario.Describe();
-
- /**
- * Simple callback logging system. Use to assert proper order of calls.
- */
- log = function(text) {
- log.text = log.text + text;
- };
- log.fn = function(text) {
- return function(done){
- log(text);
- (done || angular.noop)();
- };
- };
- log.reset = function() {
- log.text = '';
- };
- log.reset();
- });
-
- it('should handle basic nested case', function() {
- root.describe('A', function() {
- this.beforeEach(log.fn('{'));
- this.afterEach(log.fn('}'));
- this.it('1', log.fn('1'));
- this.describe('B', function() {
- this.beforeEach(log.fn('('));
- this.afterEach(log.fn(')'));
- this.it('2', log.fn('2'));
- });
- });
- var specs = root.getSpecs();
- expect(specs.length).toEqual(2);
-
- expect(specs[0].name).toEqual('2');
- specs[0].before();
- specs[0].body();
- specs[0].after();
- expect(log.text).toEqual('{(2)}');
-
- log.reset();
- expect(specs[1].name).toEqual('1');
- specs[1].before();
- specs[1].body();
- specs[1].after();
- expect(log.text).toEqual('{1}');
- });
-
- it('should link nested describe blocks with parent and children', function() {
- root.describe('A', function() {
- this.it('1', angular.noop);
- this.describe('B', function() {
- this.it('2', angular.noop);
- this.describe('C', function() {
- this.it('3', angular.noop);
- });
- });
- });
- var specs = root.getSpecs();
- expect(specs[2].definition.parent).toEqual(root);
- expect(specs[0].definition.parent).toEqual(specs[2].definition.children[0]);
- });
-
- it('should not process xit and xdescribe', function() {
- root.describe('A', function() {
- this.xit('1', angular.noop);
- this.xdescribe('B', function() {
- this.it('2', angular.noop);
- this.describe('C', function() {
- this.it('3', angular.noop);
- });
- });
- });
- var specs = root.getSpecs();
- expect(specs.length).toEqual(0);
- });
-
- it('should only return iit and ddescribe if present', function() {
- root.describe('A', function() {
- this.it('1', angular.noop);
- this.iit('2', angular.noop);
- this.describe('B', function() {
- this.it('3', angular.noop);
- this.ddescribe('C', function() {
- this.it('4', angular.noop);
- this.describe('D', function() {
- this.it('5', angular.noop);
- });
- });
- });
- });
- var specs = root.getSpecs();
- expect(specs.length).toEqual(3);
- expect(specs[0].name).toEqual('5');
- expect(specs[1].name).toEqual('4');
- expect(specs[2].name).toEqual('2');
- });
-
- it('should create uniqueIds in the tree', function() {
- angular.scenario.Describe.id = 0;
- var a = new angular.scenario.Describe();
- var b = new angular.scenario.Describe();
- expect(a.id).toNotEqual(b.id);
- });
-
- it('should create uniqueIds for each spec', function() {
- var d = new angular.scenario.Describe();
- d.it('fake', function() {});
- d.it('fake', function() {});
-
- expect(d.its[0].id).toBeDefined();
- expect(d.its[1].id).toBeDefined();
- expect(d.its[0].id).not.toEqual(d.its[1].id);
- });
-});
diff --git a/test/scenario/FutureSpec.js b/test/scenario/FutureSpec.js
deleted file mode 100644
index 2a75f275..00000000
--- a/test/scenario/FutureSpec.js
+++ /dev/null
@@ -1,77 +0,0 @@
-'use strict';
-
-describe('angular.scenario.Future', function() {
- var future;
-
- it('should set the sane defaults', function() {
- var behavior = function() {};
- var future = new angular.scenario.Future('test name', behavior, 'foo');
- expect(future.name).toEqual('test name');
- expect(future.behavior).toEqual(behavior);
- expect(future.line).toEqual('foo');
- expect(future.value).toBeUndefined();
- expect(future.fulfilled).toBeFalsy();
- expect(future.parser).toEqual(angular.identity);
- });
-
- it('should be fulfilled after execution and done callback', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done();
- });
- future.execute(angular.noop);
- expect(future.fulfilled).toBeTruthy();
- });
-
- it('should take callback with (error, result) and forward', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(10, 20);
- });
- future.execute(function(error, result) {
- expect(error).toEqual(10);
- expect(result).toEqual(20);
- });
- });
-
- it('should use error as value if provided', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(10, 20);
- });
- future.execute(angular.noop);
- expect(future.value).toEqual(10);
- });
-
- it('should parse json with fromJson', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(null, "{test: 'foo'}");
- });
- future.fromJson().execute(angular.noop);
- expect(future.value).toEqual({test: 'foo'});
- });
-
- it('should convert to json with toJson', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(null, {test: 'foo'});
- });
- future.toJson().execute(angular.noop);
- expect(future.value).toEqual('{"test":"foo"}');
- });
-
- it('should convert with custom parser', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(null, 'foo');
- });
- future.parsedWith(function(value) {
- return value.toUpperCase();
- }).execute(angular.noop);
- expect(future.value).toEqual('FOO');
- });
-
- it('should pass error if parser fails', function() {
- var future = new angular.scenario.Future('test name', function(done) {
- done(null, '{');
- });
- future.fromJson().execute(function(error, result) {
- expect(error).toBeDefined();
- });
- });
-});
diff --git a/test/scenario/ObjectModelSpec.js b/test/scenario/ObjectModelSpec.js
deleted file mode 100644
index e0da628d..00000000
--- a/test/scenario/ObjectModelSpec.js
+++ /dev/null
@@ -1,333 +0,0 @@
-'use strict';
-
-describe('angular.scenario.ObjectModel', function() {
- var model;
- var runner;
- var spec, step;
-
- function buildSpec(id, name, definitions) {
- var spec = {
- id: id,
- name: name,
- definition: {
- name: definitions.shift()
- }
- };
- var currentDef = spec.definition;
-
- forEach(definitions, function(defName) {
- currentDef.parent = {
- name: defName
- };
- currentDef = currentDef.parent;
- });
-
- return spec;
- }
-
- function buildStep(name, line) {
- return {
- name: name || 'test step',
- line: function() { return line || ''; }
- };
- }
-
- beforeEach(function() {
- spec = buildSpec(1, 'test spec', ['describe 1']);
- step = buildStep();
- runner = new angular.scenario.testing.MockRunner();
- model = new angular.scenario.ObjectModel(runner);
- });
-
- it('should value default empty value', function() {
- expect(model.value).toEqual({
- name: '',
- children: []
- });
- });
-
- it('should add spec and create describe blocks on SpecBegin event', function() {
- runner.emit('SpecBegin', buildSpec(1, 'test spec', ['describe 2', 'describe 1']));
-
- expect(model.value.children['describe 1']).toBeDefined();
- expect(model.value.children['describe 1'].children['describe 2']).toBeDefined();
- expect(model.value.children['describe 1'].children['describe 2'].specs['test spec']).toBeDefined();
- });
-
- it('should set fullDefinitionName on SpecBegin event', function() {
- runner.emit('SpecBegin', buildSpec(1, 'fake spec', ['describe 2']));
- var spec = model.getSpec(1);
-
- expect(spec.fullDefinitionName).toBeDefined();
- expect(spec.fullDefinitionName).toEqual('describe 2');
- });
-
- it('should set fullDefinitionName on SpecBegin event (join more names by space)', function() {
- runner.emit('SpecBegin', buildSpec(1, 'fake spec', ['describe 2', 'describe 1']));
- var spec = model.getSpec(1);
-
- expect(spec.fullDefinitionName).toEqual('describe 1 describe 2');
- });
-
- it('should add step to spec on StepBegin', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].steps.length).toEqual(1);
- });
-
- it('should update spec timer duration on SpecEnd event', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].duration).toBeDefined();
- });
-
- it('should update step timer duration on StepEnd event', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].steps[0].duration).toBeDefined();
- });
-
- it('should set spec status on SpecEnd to success if no status set', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('success');
- });
-
- it('should set status to error after SpecError', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('SpecError', spec, 'error');
-
- expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('error');
- });
-
- it('should set spec status to failure if step fails', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('failure');
- });
-
- it('should set spec status to error if step errors', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepError', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- expect(model.value.children['describe 1'].specs['test spec'].status).toEqual('error');
- });
-
- describe('events', function() {
- var Spec = angular.scenario.ObjectModel.Spec,
- Step = angular.scenario.ObjectModel.Step,
- callback;
-
- beforeEach(function() {
- callback = jasmine.createSpy('listener');
- });
-
- it('should provide method for registering a listener', function() {
- expect(model.on).toBeDefined();
- expect(model.on instanceof Function).toBe(true);
- });
-
- it('should forward SpecBegin event', function() {
- model.on('SpecBegin', callback);
- runner.emit('SpecBegin', spec);
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward SpecBegin event with ObjectModel.Spec as a param', function() {
- model.on('SpecBegin', callback);
- runner.emit('SpecBegin', spec);
-
- expect(callback.mostRecentCall.args[0] instanceof Spec).toBe(true);
- expect(callback.mostRecentCall.args[0].name).toEqual(spec.name);
- });
-
- it('should forward SpecError event', function() {
- model.on('SpecError', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('SpecError', spec, {});
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward SpecError event with ObjectModel.Spec and error as a params', function() {
- var error = {};
- model.on('SpecError', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('SpecError', spec, error);
-
- var param = callback.mostRecentCall.args[0];
- expect(param instanceof Spec).toBe(true);
- expect(param.name).toEqual(spec.name);
- expect(param.status).toEqual('error');
- expect(param.error).toBe(error);
- });
-
- it('should forward SpecEnd event', function() {
- model.on('SpecEnd', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('SpecEnd', spec);
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward SpecEnd event with ObjectModel.Spec as a param', function() {
- model.on('SpecEnd', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('SpecEnd', spec);
-
- expect(callback.mostRecentCall.args[0] instanceof Spec).toBe(true);
- expect(callback.mostRecentCall.args[0].name).toEqual(spec.name);
- });
-
- it('should forward StepBegin event', function() {
- model.on('StepBegin', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward StepBegin event with Spec and Step as params', function() {
- model.on('StepBegin', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
-
- var params = callback.mostRecentCall.args;
- expect(params[0] instanceof Spec).toBe(true);
- expect(params[0].name).toEqual(spec.name);
- expect(params[1] instanceof Step).toBe(true);
- });
-
- it('should forward StepError event', function() {
- model.on('StepError', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepError', spec, step, {});
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward StepError event with Spec, Step and error as params', function() {
- var error = {};
- model.on('StepError', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepError', spec, step, error);
-
- var params = callback.mostRecentCall.args;
- expect(params[0] instanceof Spec).toBe(true);
- expect(params[0].name).toEqual(spec.name);
- expect(params[1] instanceof Step).toBe(true);
- expect(params[1].status).toEqual('error');
- expect(params[2]).toBe(error);
- });
-
- it('should forward StepFailure event', function() {
- model.on('StepFailure', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, {});
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward StepFailure event with Spec, Step and error as params', function() {
- var error = {};
- model.on('StepFailure', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, error);
-
- var params = callback.mostRecentCall.args;
- expect(params[0] instanceof Spec).toBe(true);
- expect(params[0].name).toEqual(spec.name);
- expect(params[1] instanceof Step).toBe(true);
- expect(params[1].status).toEqual('failure');
- expect(params[2]).toBe(error);
- });
-
- it('should forward StepEnd event', function() {
- model.on('StepEnd', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
-
- expect(callback).toHaveBeenCalled();
- });
-
- it('should forward StepEnd event with Spec and Step as params', function() {
- model.on('StepEnd', callback);
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
-
- var params = callback.mostRecentCall.args;
- expect(params[0] instanceof Spec).toBe(true);
- expect(params[0].name).toEqual(spec.name);
- expect(params[1] instanceof Step).toBe(true);
- });
-
- it('should forward RunnerEnd event', function() {
- model.on('RunnerEnd', callback);
- runner.emit('RunnerEnd');
- expect(callback).toHaveBeenCalled();
- });
-
- it('should set error of first failure', function() {
- var error = 'first-error',
- step2 = buildStep();
-
- model.on('SpecEnd', function(spec) {
- expect(spec.error).toBeDefined();
- expect(spec.error).toBe(error);
- });
-
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, error);
- runner.emit('StepBegin', spec, step2);
- runner.emit('StepFailure', spec, step2, 'second-error');
- runner.emit('SpecEnd', spec);
- });
-
- it('should set line number of first failure', function() {
- var step = buildStep('fake', 'first-line'),
- step2 = buildStep('fake2', 'second-line');
-
- model.on('SpecEnd', function(spec) {
- expect(spec.line).toBeDefined();
- expect(spec.line).toBe('first-line');
- });
-
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, null);
- runner.emit('StepBegin', spec, step2);
- runner.emit('StepFailure', spec, step2, null);
- runner.emit('SpecEnd', spec);
- });
- });
-});
diff --git a/test/scenario/RunnerSpec.js b/test/scenario/RunnerSpec.js
deleted file mode 100644
index c4ad6f95..00000000
--- a/test/scenario/RunnerSpec.js
+++ /dev/null
@@ -1,116 +0,0 @@
-'use strict';
-
-/**
- * Mock spec runner.
- */
-function MockSpecRunner() {}
-MockSpecRunner.prototype.run = function(spec, specDone) {
- spec.before.call(this);
- spec.body.call(this);
- spec.after.call(this);
- specDone();
-};
-
-MockSpecRunner.prototype.addFuture = function(name, fn, line) {
- return {name: name, fn: fn, line: line};
-};
-
-describe('angular.scenario.Runner', function() {
- var $window;
- var runner;
-
- beforeEach(function() {
- // Trick to get the scope out of a DSL statement
- angular.scenario.dsl('dslAddFuture', function() {
- return function() {
- return this.addFuture('future name', angular.noop);
- };
- });
- // Trick to get the scope out of a DSL statement
- angular.scenario.dsl('dslScope', function() {
- var scope = this;
- return function() { return scope; };
- });
- // Trick to get the scope out of a DSL statement
- angular.scenario.dsl('dslChain', function() {
- return function() {
- this.chained = 0;
- this.chain = function() { this.chained++; return this; };
- return this;
- };
- });
- $window = {
- location: {}
- };
- runner = new angular.scenario.Runner($window);
- runner.on('SpecError', angular.mock.rethrow);
- runner.on('StepError', angular.mock.rethrow);
- });
-
- afterEach(function() {
- delete angular.scenario.dsl.dslScope;
- delete angular.scenario.dsl.dslChain;
- });
-
- it('should publish the functions in the public API', function() {
- angular.forEach(runner.api, function(fn, name) {
- var func;
- if (name in $window) {
- func = $window[name];
- }
- expect(angular.isFunction(func)).toBeTruthy();
- });
- });
-
- it('should construct valid describe trees with public API', function() {
- var before = [];
- var after = [];
- $window.describe('A', function() {
- $window.beforeEach(function() { before.push('A'); });
- $window.afterEach(function() { after.push('A'); });
- $window.it('1', angular.noop);
- $window.describe('B', function() {
- $window.beforeEach(function() { before.push('B'); });
- $window.afterEach(function() { after.push('B'); });
- $window.it('2', angular.noop);
- $window.describe('C', function() {
- $window.beforeEach(function() { before.push('C'); });
- $window.afterEach(function() { after.push('C'); });
- $window.it('3', angular.noop);
- });
- });
- });
- var specs = runner.rootDescribe.getSpecs();
- specs[0].before();
- specs[0].body();
- specs[0].after();
- expect(before).toEqual(['A', 'B', 'C']);
- expect(after).toEqual(['C', 'B', 'A']);
- expect(specs[2].definition.parent).toEqual(runner.rootDescribe);
- expect(specs[0].definition.parent).toEqual(specs[2].definition.children[0]);
- });
-
- it('should publish the DSL statements to the $window', function() {
- $window.describe('describe', function() {
- $window.it('1', function() {
- expect($window.dslScope).toBeDefined();
- });
- });
- runner.run(null/*application*/);
- });
-
- it('should create a new scope for each DSL chain', function() {
- $window.describe('describe', function() {
- $window.it('1', function() {
- var scope = $window.dslScope();
- scope.test = "foo";
- expect($window.dslScope().test).toBeUndefined();
- });
- $window.it('2', function() {
- var scope = $window.dslChain().chain().chain();
- expect(scope.chained).toEqual(2);
- });
- });
- runner.run(null/*application*/);
- });
-});
diff --git a/test/scenario/SpecRunnerSpec.js b/test/scenario/SpecRunnerSpec.js
deleted file mode 100644
index c104a9b7..00000000
--- a/test/scenario/SpecRunnerSpec.js
+++ /dev/null
@@ -1,177 +0,0 @@
-'use strict';
-
-/**
- * Mock Application
- */
-function ApplicationMock($window) {
- this.$window = $window;
-}
-ApplicationMock.prototype = {
- executeAction: function(callback) {
- callback.call(this.$window, _jQuery(this.$window.document), this.$window);
- }
-};
-
-describe('angular.scenario.SpecRunner', function() {
- var $window, $root, log;
- var runner;
-
- function createSpec(name, body) {
- return {
- name: name,
- before: angular.noop,
- body: body || angular.noop,
- after: angular.noop
- };
- }
-
- beforeEach(inject(function($rootScope) {
- log = [];
- $window = {};
- $window.setTimeout = function(fn, timeout) {
- fn();
- };
- $root = $rootScope;
- $root.emit = function(eventName) {
- log.push(eventName);
- };
- $root.on = function(eventName) {
- log.push('Listener Added for ' + eventName);
- };
- $root.application = new ApplicationMock($window);
- $root.$window = $window;
- runner = $root.$new();
-
- var Cls = angular.scenario.SpecRunner;
- for (var name in Cls.prototype)
- runner[name] = angular.bind(runner, Cls.prototype[name]);
-
- Cls.call(runner);
- }));
-
- it('should bind futures to the spec', function() {
- runner.addFuture('test future', function(done) {
- this.value = 10;
- done();
- });
- runner.futures[0].execute(angular.noop);
- expect(runner.value).toEqual(10);
- });
-
- it('should pass done to future action behavior', function() {
- runner.addFutureAction('test future', function($window, $document, done) {
- expect(angular.isFunction(done)).toBeTruthy();
- done(10, 20);
- });
- runner.futures[0].execute(function(error, result) {
- expect(error).toEqual(10);
- expect(result).toEqual(20);
- });
- });
-
- it('should execute spec function and notify UI', function() {
- var finished;
- var spec = createSpec('test spec', function() {
- this.test = 'some value';
- });
- runner.addFuture('test future', function(done) {
- done();
- });
- runner.run(spec, function() {
- finished = true;
- });
- expect(runner.test).toEqual('some value');
- expect(finished).toBeTruthy();
- expect(log).toEqual([
- 'SpecBegin',
- 'StepBegin',
- 'StepEnd',
- 'SpecEnd'
- ]);
- });
-
- it('should execute notify UI on spec setup error', function() {
- var finished;
- var spec = createSpec('test spec', function() {
- throw 'message';
- });
- runner.run(spec, function() {
- finished = true;
- });
- expect(finished).toBeTruthy();
- expect(log).toEqual([
- 'SpecBegin',
- 'SpecError',
- 'SpecEnd'
- ]);
- });
-
- it('should execute notify UI on step failure', function() {
- var finished;
- var spec = createSpec('test spec');
- runner.addFuture('test future', function(done) {
- done('failure message');
- });
- runner.run(spec, function() {
- finished = true;
- });
- expect(finished).toBeTruthy();
- expect(log).toEqual([
- 'SpecBegin',
- 'StepBegin',
- 'StepFailure',
- 'StepEnd',
- 'SpecEnd'
- ]);
- });
-
- it('should execute notify UI on step error', function() {
- var finished;
- var spec = createSpec('test spec', function() {
- this.addFuture('test future', function(done) {
- throw 'error message';
- });
- });
- runner.run(spec, function() {
- finished = true;
- });
- expect(finished).toBeTruthy();
- expect(log).toEqual([
- 'SpecBegin',
- 'StepBegin',
- 'StepError',
- 'StepEnd',
- 'SpecEnd'
- ]);
- });
-
- it('should run after handlers even if error in body of spec', function() {
- var finished, after;
- var spec = createSpec('test spec', function() {
- this.addFuture('body', function(done) {
- throw 'error message';
- });
- });
- spec.after = function() {
- this.addFuture('after', function(done) {
- after = true;
- done();
- });
- };
- runner.run(spec, function() {
- finished = true;
- });
- expect(finished).toBeTruthy();
- expect(after).toBeTruthy();
- expect(log).toEqual([
- 'SpecBegin',
- 'StepBegin',
- 'StepError',
- 'StepEnd',
- 'StepBegin',
- 'StepEnd',
- 'SpecEnd'
- ]);
- });
-
-});
diff --git a/test/scenario/dslSpec.js b/test/scenario/dslSpec.js
deleted file mode 100644
index 0a8ab762..00000000
--- a/test/scenario/dslSpec.js
+++ /dev/null
@@ -1,629 +0,0 @@
-'use strict';
-
-describe("angular.scenario.dsl", function() {
- var element;
- var $window, $root;
- var eventLog;
-
- afterEach(function() {
- dealoc(element);
- });
-
- beforeEach(inject(function($injector) {
- eventLog = [];
- $window = {
- document: window.document.body,
- angular: new angular.scenario.testing.MockAngular()
- };
- jqLite($window.document).data('$injector', $injector).attr('ng-app', '').addClass('html');
- $root = $injector.get('$rootScope');
- $root.emit = function(eventName) {
- eventLog.push(eventName);
- };
- $root.on = function(eventName) {
- eventLog.push('Listener Added for ' + eventName);
- };
- $root.futures = [];
- $root.futureLog = [];
- $root.$window = $window;
- $root.addFuture = function(name, fn) {
- this.futures.push(name);
- fn.call(this, function(error, result) {
- $root.futureError = error;
- $root.futureResult = result;
- $root.futureLog.push(name);
- });
- };
- $root.dsl = {};
- angular.forEach(angular.scenario.dsl, function(fn, name) {
- $root.dsl[name] = function() {
- return fn.call($root).apply($root, arguments);
- };
- });
- $root.application = new angular.scenario.Application(jqLite($window.document));
- $root.application.getWindow_ = function() {
- return $window;
- };
- $root.application.navigateTo = function(url, callback) {
- $window.location = url;
- callback();
- };
- // Just use the real one since it delegates to this.addFuture
- $root.addFutureAction = angular.scenario.
- SpecRunner.prototype.addFutureAction;
- jqLite($window.document).html('');
- }));
-
- afterEach(function(){
- jqLite($window.document).removeData('$injector');
- });
-
- describe('Pause', function() {
- it('should pause until resume to complete', function() {
- expect($window.resume).toBeUndefined();
- $root.dsl.pause();
- expect(angular.isFunction($window.resume)).toBeTruthy();
- expect($root.futureLog).toEqual([]);
- $window.resume();
- expect($root.futureLog).
- toEqual(['pausing for you to resume']);
- expect(eventLog).toContain('InteractivePause');
- });
- });
-
- describe('Sleep', function() {
- beforeEach(function() {
- $root.$window.setTimeout = function(fn, value) {
- $root.timerValue = value;
- fn();
- };
- });
-
- it('should sleep for specified seconds', function() {
- $root.dsl.sleep(10);
- expect($root.timerValue).toEqual(10000);
- expect($root.futureResult).toEqual(10000);
- });
- });
-
- describe('Expect', function() {
- it('should chain and execute matcher', function() {
- var future = {value: 10};
- var result = $root.dsl.expect(future);
- result.toEqual(10);
- expect($root.futureError).toBeUndefined();
- expect($root.futureResult).toBeUndefined();
- result = $root.dsl.expect(future);
- result.toEqual(20);
- expect($root.futureError).toBeDefined();
- });
- });
-
- describe('Browser', function() {
- describe('Reload', function() {
- it('should navigateTo', function() {
- $window.location = {
- href: '#foo'
- };
- $root.dsl.browser().reload();
- expect($root.futureResult).toEqual('#foo');
- expect($window.location).toEqual('#foo');
- });
- });
-
- describe('NavigateTo', function() {
- it('should allow a string url', function() {
- $root.dsl.browser().navigateTo('http://myurl');
- expect($window.location).toEqual('http://myurl');
- expect($root.futureResult).toEqual('http://myurl');
- });
-
- it('should allow a future url', function() {
- $root.dsl.browser().navigateTo('http://myurl', function() {
- return 'http://futureUrl/';
- });
- expect($window.location).toEqual('http://futureUrl/');
- expect($root.futureResult).toEqual('http://futureUrl/');
- });
-
- it('should complete if angular is missing from app frame', function() {
- delete $window.angular;
- $root.dsl.browser().navigateTo('http://myurl');
- expect($window.location).toEqual('http://myurl');
- expect($root.futureResult).toEqual('http://myurl');
- });
- });
-
- describe('window', function() {
- beforeEach(function() {
- $window.location = {
- href: 'http://myurl/some/path?foo=10#/bar?x=2',
- pathname: '/some/path',
- search: '?foo=10',
- hash: '#bar?x=2'
- };
- });
-
- it('should return full URL for href', function() {
- $root.dsl.browser().window().href();
- expect($root.futureResult).toEqual($window.location.href);
- });
-
- it('should return the pathname', function() {
- $root.dsl.browser().window().path();
- expect($root.futureResult).toEqual($window.location.pathname);
- });
-
- it('should return the search part', function() {
- $root.dsl.browser().window().search();
- expect($root.futureResult).toEqual($window.location.search);
- });
-
- it('should return the hash without the #', function() {
- $root.dsl.browser().window().hash();
- expect($root.futureResult).toEqual('bar?x=2');
- });
- });
-
- describe('location', function() {
- beforeEach(function() {
- $window.angular.injector = function() {
- return {
- get: function(serviceId) {
- if (serviceId == '$location') {
- return {
- url: function() {return '/path?search=a#hhh';},
- path: function() {return '/path';},
- search: function() {return {search: 'a'};},
- hash: function() {return 'hhh';}
- };
- }
- throw new Error('unknown service id ' + serviceId);
- }
- };
- };
- });
-
- it('should return full url', function() {
- $root.dsl.browser().location().url();
- expect($root.futureResult).toEqual('/path?search=a#hhh');
- });
-
- it('should return the pathname', function() {
- $root.dsl.browser().location().path();
- expect($root.futureResult).toEqual('/path');
- });
-
- it('should return the query string as an object', function() {
- $root.dsl.browser().location().search();
- expect($root.futureResult).toEqual({search: 'a'});
- });
-
- it('should return the hash without the #', function() {
- $root.dsl.browser().location().hash();
- expect($root.futureResult).toEqual('hhh');
- });
- });
- });
-
- describe('Element Finding', function() {
- var doc;
- beforeEach(inject(function($injector) {
- doc = _jQuery($window.document).append('').find('.body');
- }));
-
- describe('Select', function() {
- it('should select single option', function() {
- doc.append(
- ''
- );
- $root.dsl.select('test').option('A');
- expect(doc.find('[ng-model="test"]').val()).toEqual('A');
- });
-
- it('should select option by name', function() {
- doc.append(
- ''
- );
- $root.dsl.select('test').option('one');
- expect(doc.find('[ng-model="test"]').val()).toEqual('A');
- });
-
- it('should select multiple options', function() {
- doc.append(
- ''
- );
- $root.dsl.select('test').options('A', 'B');
- expect(doc.find('[ng-model="test"]').val()).toEqual(['A','B']);
- });
-
- it('should fail to select multiple options on non-multiple select', function() {
- doc.append('');
- $root.dsl.select('test').options('A', 'B');
- expect($root.futureError).toMatch(/did not match/);
- });
- });
-
- describe('Element', function() {
- it('should execute click', function() {
- var clicked;
- // Hash is important, otherwise we actually
- // go to a different page and break the runner
- doc.append('');
- doc.find('a').click(function() {
- clicked = true;
- });
- $root.dsl.element('a').click();
- });
-
- it('should navigate page if click on anchor', function() {
- expect($window.location).not.toEqual('#foo');
- doc.append('');
- $root.dsl.element('a').click();
- expect($window.location).toMatch(/#foo$/);
- });
-
- it('should not navigate if click event was cancelled', function() {
- var initLocation = $window.location,
- elm = jqLite('');
-
- doc.append(elm);
- elm.bind('click', function(event) {
- event.preventDefault();
- });
-
- $root.dsl.element('a').click();
- expect($window.location).toBe(initLocation);
- dealoc(elm);
- });
-
- it('should count matching elements', function() {
- doc.append('');
- $root.dsl.element('span').count();
- expect($root.futureResult).toEqual(2);
- });
-
- it('should return count of 0 if no matching elements', function() {
- $root.dsl.element('span').count();
- expect($root.futureResult).toEqual(0);
- });
-
- it('should get attribute', function() {
- doc.append('');
- $root.dsl.element('#test').attr('class');
- expect($root.futureResult).toEqual('foo');
- });
-
- it('should set attribute', function() {
- doc.append('');
- $root.dsl.element('#test').attr('class', 'bam');
- expect(doc.find('#test').attr('class')).toEqual('bam');
- });
-
- it('should get property', function() {
- doc.append('');
- $root.dsl.element('#test').prop('className');
- expect($root.futureResult).toEqual('foo');
- });
-
- it('should set property', function() {
- doc.append('');
- $root.dsl.element('#test').prop('className', 'bam');
- expect(doc.find('#test').prop('className')).toEqual('bam');
- });
-
- it('should get css', function() {
- doc.append('');
- $root.dsl.element('#test').css('height');
- expect($root.futureResult).toMatch(/30px/);
- });
-
- it('should set css', function() {
- doc.append('');
- $root.dsl.element('#test').css('height', '20px');
- expect(doc.find('#test').css('height')).toEqual('20px');
- });
-
- it('should add all jQuery key/value methods', function() {
- var METHODS = ['css', 'attr'];
- var chain = $root.dsl.element('input');
- angular.forEach(METHODS, function(name) {
- expect(angular.isFunction(chain[name])).toBeTruthy();
- });
- });
-
- it('should get val', function() {
- doc.append('');
- $root.dsl.element('input').val();
- expect($root.futureResult).toEqual('bar');
- });
-
- it('should set val', function() {
- doc.append('');
- $root.dsl.element('input').val('baz');
- expect(doc.find('input').val()).toEqual('baz');
- });
-
- it('should use correct future name for generated set methods', function() {
- doc.append('');
- $root.dsl.element('input').val(false);
- expect($root.futures.pop()).toMatch(/element 'input' set val/);
- });
-
- it('should use correct future name for generated get methods', function() {
- doc.append('');
- $root.dsl.element('input').val();
- expect($root.futures.pop()).toMatch(/element 'input' val/);
- });
-
- it('should add all jQuery property methods', function() {
- var METHODS = [
- 'val', 'text', 'html', 'height', 'innerHeight', 'outerHeight', 'width',
- 'innerWidth', 'outerWidth', 'position', 'scrollLeft', 'scrollTop', 'offset'
- ];
- var chain = $root.dsl.element('input');
- angular.forEach(METHODS, function(name) {
- expect(angular.isFunction(chain[name])).toBeTruthy();
- });
- });
-
- it('should execute custom query', function() {
- doc.append('');
- $root.dsl.element('#test').query(function(elements, done) {
- done(null, elements.attr('href'));
- });
- expect($root.futureResult).toEqual('http://example.com/myUrl');
- });
-
- it('should use the selector as label if none is given', function() {
- $root.dsl.element('mySelector');
- expect($root.label).toEqual('mySelector');
- });
-
- it('should include the selector in paren when a label is given', function() {
- $root.dsl.element('mySelector', 'myLabel');
- expect($root.label).toEqual('myLabel ( mySelector )');
- });
- });
-
- describe('Repeater', function() {
- var chain;
- beforeEach(inject(function($compile, $rootScope) {
- element = $compile(
- '
{{ true }}'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('some value'); - - $root.dsl.binding('true'); - expect($root.futureResult).toEqual('true'); - }); - - it('should select binding by name', function() { - compile(''); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('some value'); - }); - - it('should select binding by regexp', function() { - compile('some value'); - $root.dsl.binding(/^foo\..+/); - expect($root.futureResult).toEqual('some value'); - }); - - it('should return innerHTML for all the other elements', function() { - compile('', 'some value'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult.toLowerCase()).toEqual('some value'); - }); - - it('should select binding in template by name', function() { - compile('', 'bar'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('bar'); - }); - - it('should match bindings by substring match', function() { - compile('', 'binding value'); - $root.dsl.binding('foo . bar'); - expect($root.futureResult).toEqual('binding value'); - }); - - it('should return error if no bindings in document', function() { - $root.dsl.binding('foo.bar'); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should return error if no binding matches', function() { - compile('some value'); - $root.dsl.binding('foo.bar'); - expect($root.futureError).toMatch(/did not match/); - }); - }); - - describe('Using', function() { - it('should prefix selector in $document.elements()', function() { - var chain; - doc.append( - '' + - '' - ); - chain = $root.dsl.using('div#test2'); - chain.input('test.input').enter('foo'); - var inputs = _jQuery('input[ng-model="test.input"]'); - expect(inputs.first().val()).toEqual('something'); - expect(inputs.last().val()).toEqual('foo'); - }); - - it('should use the selector as label if none is given', function() { - $root.dsl.using('mySelector'); - expect($root.label).toEqual('mySelector'); - }); - - it('should include the selector in paren when a label is given', function() { - $root.dsl.using('mySelector', 'myLabel'); - expect($root.label).toEqual('myLabel ( mySelector )'); - }); - - }); - - describe('Input', function() { - it('should change value in text input', function() { - doc.append(''); - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); - }); - - it('should change value in text input in dash form', function() { - doc.append(''); - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); - }); - - it('should return error if no input exists', function() { - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should toggle checkbox state', function() { - doc.append(''); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(true); - var chain = $root.dsl.input('test.input'); - chain.check(); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(false); - $window.angular.reset(); - chain.check(); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(true); - }); - - it('should return error if checkbox did not match', function() { - var chain = $root.dsl.input('test.input'); - chain.check(); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should select option from radio group', function() { - doc.append( - '' + - '' - ); - // HACK! We don't know why this is sometimes false on chrome - _jQuery('input[ng\\:model="test.input"][value="bar"]').prop('checked', true); - expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). - prop('checked')).toBe(true); - expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). - prop('checked')).toBe(false); - var chain = $root.dsl.input('test.input'); - chain.select('foo'); - expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). - prop('checked')).toBe(false); - expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). - prop('checked')).toBe(true); - }); - - it('should return error if radio button did not match', function() { - var chain = $root.dsl.input('test.input'); - chain.select('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - - describe('val', function() { - it('should return value in text input', function() { - doc.append(''); - $root.dsl.input('test.input').val(); - expect($root.futureResult).toEqual("something"); - }); - }); - }); - - describe('Textarea', function() { - - it('should change value in textarea', function() { - doc.append(''); - var chain = $root.dsl.input('test.textarea'); - chain.enter('foo'); - expect(_jQuery('textarea[ng-model="test.textarea"]').val()).toEqual('foo'); - }); - - it('should return error if no textarea exists', function() { - var chain = $root.dsl.input('test.textarea'); - chain.enter('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - }); - }); -}); diff --git a/test/scenario/e2e/Runner-compiled.html b/test/scenario/e2e/Runner-compiled.html deleted file mode 100644 index 530fef96..00000000 --- a/test/scenario/e2e/Runner-compiled.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/test/scenario/e2e/Runner.html b/test/scenario/e2e/Runner.html deleted file mode 100644 index 1191dc86..00000000 --- a/test/scenario/e2e/Runner.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/test/scenario/e2e/style.css b/test/scenario/e2e/style.css deleted file mode 100644 index 26540bec..00000000 --- a/test/scenario/e2e/style.css +++ /dev/null @@ -1,11 +0,0 @@ -th { - text-align: left; -} - -tr { - border: 1px solid black; -} - -.redbox { - background-color: red; -} diff --git a/test/scenario/e2e/widgets-scenario.js b/test/scenario/e2e/widgets-scenario.js deleted file mode 100644 index fda9b3c6..00000000 --- a/test/scenario/e2e/widgets-scenario.js +++ /dev/null @@ -1,67 +0,0 @@ -'use strict'; - -describe('widgets', function() { - it('should verify that basic widgets work', function() { - browser().navigateTo('widgets.html'); - - using('#text-basic-box').input('text.basic').enter('Carlos'); - expect(binding('text.basic')).toEqual('Carlos'); - input('text.basic').enter('Carlos Santana'); - expect(binding('text.basic')).not().toEqual('Carlos Boozer'); - - input('text.password').enter('secret'); - expect(binding('text.password')).toEqual('secret'); - - expect(binding('text.hidden')).toEqual('hiddenValue'); - - expect(binding('gender')).toEqual('male'); - input('gender').select('female'); - expect(using('#gender-box').binding('gender')).toEqual('female'); - - expect(repeater('#repeater-row ul li').count()).toEqual(2); - expect(repeater('#repeater-row ul li').row(1)).toEqual(['adam']); - expect(repeater('#repeater-row ul li').column('name')).toEqual(['misko', 'adam']); - - select('select').option('B'); - expect(binding('select')).toEqual('B'); - - select('multiselect').options('A', 'C'); - expect(binding('multiselect').fromJson()).toEqual(['A', 'C']); - - expect(binding('button').fromJson()).toEqual({'count': 0}); - expect(binding('form').fromJson()).toEqual({'count': 0}); - - element('form a', "'action' link").click(); - expect(binding('button').fromJson()).toEqual({'count': 1}); - - element('input[value="submit input"]', "'submit input' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 2}); - expect(binding('form').fromJson()).toEqual({'count': 1}); - - element('button:contains("submit button")', "'submit button' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 2}); - expect(binding('form').fromJson()).toEqual({'count': 2}); - - element('input[value="button"]', "'button' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 3}); - - element('input[type="image"]', 'form image').click(); - expect(binding('button').fromJson()).toEqual({'count': 4}); - - /** - * Custom value parser for futures. - */ - function checkboxParser(value) { - return angular.fromJson(value.substring(value.indexOf('=')+1)); - } - - input('checkbox.tea').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: false, tea: false}); - input('checkbox.coffee').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: false}); - input('checkbox.tea').check(); - input('checkbox.tea').check(); - input('checkbox.tea').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: true}); - }); -}); diff --git a/test/scenario/e2e/widgets.html b/test/scenario/e2e/widgets.html deleted file mode 100644 index f986144e..00000000 --- a/test/scenario/e2e/widgets.html +++ /dev/null @@ -1,99 +0,0 @@ - - - - - - - -
-
-
-
diff --git a/test/scenario/matchersSpec.js b/test/scenario/matchersSpec.js
deleted file mode 100644
index 7a5217d7..00000000
--- a/test/scenario/matchersSpec.js
+++ /dev/null
@@ -1,51 +0,0 @@
-'use strict';
-
-describe('angular.scenario.matchers', function () {
- var matchers;
-
- function expectMatcher(value, test) {
- delete matchers.error;
- delete matchers.future.value;
- if (value !== undefined) {
- matchers.future.value = value;
- }
- test();
- expect(matchers.error).toBeUndefined();
- }
-
- beforeEach(function() {
- /**
- * Mock up the future system wrapped around matchers.
- *
- * @see Scenario.js#angular.scenario.matcher
- */
- matchers = {
- future: { name: 'test' }
- };
- matchers.addFuture = function(name, callback) {
- callback(function(error) {
- matchers.error = error;
- });
- };
- angular.extend(matchers, angular.scenario.matcher);
- });
-
- it('should handle basic matching', function() {
- expectMatcher(10, function() { matchers.toEqual(10); });
- expectMatcher('value', function() { matchers.toBeDefined(); });
- expectMatcher([1], function() { matchers.toBeTruthy(); });
- expectMatcher("", function() { matchers.toBeFalsy(); });
- expectMatcher(0, function() { matchers.toBeFalsy(); });
- expectMatcher('foo', function() { matchers.toMatch('.o.'); });
- expectMatcher(null, function() { matchers.toBeNull(); });
- expectMatcher([1, 2, 3], function() { matchers.toContain(2); });
- expectMatcher(3, function() { matchers.toBeLessThan(10); });
- expectMatcher(3, function() { matchers.toBeGreaterThan(-5); });
- });
-
- it('should have toHaveClass matcher', function(){
- var e = angular.element('
- {{i.name}} {{i.gender}}
{{ true }}'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('some value'); - - $root.dsl.binding('true'); - expect($root.futureResult).toEqual('true'); - }); - - it('should select binding by name', function() { - compile(''); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('some value'); - }); - - it('should select binding by regexp', function() { - compile('some value'); - $root.dsl.binding(/^foo\..+/); - expect($root.futureResult).toEqual('some value'); - }); - - it('should return innerHTML for all the other elements', function() { - compile('', 'some value'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult.toLowerCase()).toEqual('some value'); - }); - - it('should select binding in template by name', function() { - compile('', 'bar'); - $root.dsl.binding('foo.bar'); - expect($root.futureResult).toEqual('bar'); - }); - - it('should match bindings by substring match', function() { - compile('', 'binding value'); - $root.dsl.binding('foo . bar'); - expect($root.futureResult).toEqual('binding value'); - }); - - it('should return error if no bindings in document', function() { - $root.dsl.binding('foo.bar'); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should return error if no binding matches', function() { - compile('some value'); - $root.dsl.binding('foo.bar'); - expect($root.futureError).toMatch(/did not match/); - }); - }); - - describe('Using', function() { - it('should prefix selector in $document.elements()', function() { - var chain; - doc.append( - '' + - '' - ); - chain = $root.dsl.using('div#test2'); - chain.input('test.input').enter('foo'); - var inputs = _jQuery('input[ng-model="test.input"]'); - expect(inputs.first().val()).toEqual('something'); - expect(inputs.last().val()).toEqual('foo'); - }); - - it('should use the selector as label if none is given', function() { - $root.dsl.using('mySelector'); - expect($root.label).toEqual('mySelector'); - }); - - it('should include the selector in paren when a label is given', function() { - $root.dsl.using('mySelector', 'myLabel'); - expect($root.label).toEqual('myLabel ( mySelector )'); - }); - - }); - - describe('Input', function() { - it('should change value in text input', function() { - doc.append(''); - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); - }); - - it('should change value in text input in dash form', function() { - doc.append(''); - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect(_jQuery('input[ng-model="test.input"]').val()).toEqual('foo'); - }); - - it('should return error if no input exists', function() { - var chain = $root.dsl.input('test.input'); - chain.enter('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should toggle checkbox state', function() { - doc.append(''); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(true); - var chain = $root.dsl.input('test.input'); - chain.check(); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(false); - $window.angular.reset(); - chain.check(); - expect(_jQuery('input[ng-model="test.input"]'). - prop('checked')).toBe(true); - }); - - it('should return error if checkbox did not match', function() { - var chain = $root.dsl.input('test.input'); - chain.check(); - expect($root.futureError).toMatch(/did not match/); - }); - - it('should select option from radio group', function() { - doc.append( - '' + - '' - ); - // HACK! We don't know why this is sometimes false on chrome - _jQuery('input[ng\\:model="test.input"][value="bar"]').prop('checked', true); - expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). - prop('checked')).toBe(true); - expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). - prop('checked')).toBe(false); - var chain = $root.dsl.input('test.input'); - chain.select('foo'); - expect(_jQuery('input[ng\\:model="test.input"][value="bar"]'). - prop('checked')).toBe(false); - expect(_jQuery('input[ng\\:model="test.input"][value="foo"]'). - prop('checked')).toBe(true); - }); - - it('should return error if radio button did not match', function() { - var chain = $root.dsl.input('test.input'); - chain.select('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - - describe('val', function() { - it('should return value in text input', function() { - doc.append(''); - $root.dsl.input('test.input').val(); - expect($root.futureResult).toEqual("something"); - }); - }); - }); - - describe('Textarea', function() { - - it('should change value in textarea', function() { - doc.append(''); - var chain = $root.dsl.input('test.textarea'); - chain.enter('foo'); - expect(_jQuery('textarea[ng-model="test.textarea"]').val()).toEqual('foo'); - }); - - it('should return error if no textarea exists', function() { - var chain = $root.dsl.input('test.textarea'); - chain.enter('foo'); - expect($root.futureError).toMatch(/did not match/); - }); - }); - }); -}); diff --git a/test/scenario/e2e/Runner-compiled.html b/test/scenario/e2e/Runner-compiled.html deleted file mode 100644 index 530fef96..00000000 --- a/test/scenario/e2e/Runner-compiled.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/test/scenario/e2e/Runner.html b/test/scenario/e2e/Runner.html deleted file mode 100644 index 1191dc86..00000000 --- a/test/scenario/e2e/Runner.html +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/test/scenario/e2e/style.css b/test/scenario/e2e/style.css deleted file mode 100644 index 26540bec..00000000 --- a/test/scenario/e2e/style.css +++ /dev/null @@ -1,11 +0,0 @@ -th { - text-align: left; -} - -tr { - border: 1px solid black; -} - -.redbox { - background-color: red; -} diff --git a/test/scenario/e2e/widgets-scenario.js b/test/scenario/e2e/widgets-scenario.js deleted file mode 100644 index fda9b3c6..00000000 --- a/test/scenario/e2e/widgets-scenario.js +++ /dev/null @@ -1,67 +0,0 @@ -'use strict'; - -describe('widgets', function() { - it('should verify that basic widgets work', function() { - browser().navigateTo('widgets.html'); - - using('#text-basic-box').input('text.basic').enter('Carlos'); - expect(binding('text.basic')).toEqual('Carlos'); - input('text.basic').enter('Carlos Santana'); - expect(binding('text.basic')).not().toEqual('Carlos Boozer'); - - input('text.password').enter('secret'); - expect(binding('text.password')).toEqual('secret'); - - expect(binding('text.hidden')).toEqual('hiddenValue'); - - expect(binding('gender')).toEqual('male'); - input('gender').select('female'); - expect(using('#gender-box').binding('gender')).toEqual('female'); - - expect(repeater('#repeater-row ul li').count()).toEqual(2); - expect(repeater('#repeater-row ul li').row(1)).toEqual(['adam']); - expect(repeater('#repeater-row ul li').column('name')).toEqual(['misko', 'adam']); - - select('select').option('B'); - expect(binding('select')).toEqual('B'); - - select('multiselect').options('A', 'C'); - expect(binding('multiselect').fromJson()).toEqual(['A', 'C']); - - expect(binding('button').fromJson()).toEqual({'count': 0}); - expect(binding('form').fromJson()).toEqual({'count': 0}); - - element('form a', "'action' link").click(); - expect(binding('button').fromJson()).toEqual({'count': 1}); - - element('input[value="submit input"]', "'submit input' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 2}); - expect(binding('form').fromJson()).toEqual({'count': 1}); - - element('button:contains("submit button")', "'submit button' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 2}); - expect(binding('form').fromJson()).toEqual({'count': 2}); - - element('input[value="button"]', "'button' button").click(); - expect(binding('button').fromJson()).toEqual({'count': 3}); - - element('input[type="image"]', 'form image').click(); - expect(binding('button').fromJson()).toEqual({'count': 4}); - - /** - * Custom value parser for futures. - */ - function checkboxParser(value) { - return angular.fromJson(value.substring(value.indexOf('=')+1)); - } - - input('checkbox.tea').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: false, tea: false}); - input('checkbox.coffee').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: false}); - input('checkbox.tea').check(); - input('checkbox.tea').check(); - input('checkbox.tea').check(); - expect(binding('checkbox').parsedWith(checkboxParser)).toEqual({coffee: true, tea: true}); - }); -}); diff --git a/test/scenario/e2e/widgets.html b/test/scenario/e2e/widgets.html deleted file mode 100644 index f986144e..00000000 --- a/test/scenario/e2e/widgets.html +++ /dev/null @@ -1,99 +0,0 @@ - - - - - - - -
| Description | -Test | -Result | -
|---|---|---|
| Input text field | ||
| basic | -- - | -text.basic={{text.basic}} | -
| password | -- | text.password={{text.password}} | -
| hidden | -- | text.hidden={{text.hidden}} | -
| Input selection field | ||
| radio | -
- Female - Male - |
- gender={{gender}} | -
| checkbox | -
- Tea - Coffe - |
-
- checkbox={{checkbox}}
- |
-
| select | -- - | -select={{select}} | -
| multiselect | -- - | -multiselect={{multiselect}} | -
| Buttons | ||
| ng-change ng-click |
- - - | -button={{button}} form={{form}} | -
| Repeaters | ||
| ng-repeat | -
-
|
- - |
');
- expect(e).not.toHaveClass('none');
- expect(e).toHaveClass('abc');
- });
-});
diff --git a/test/scenario/mocks.js b/test/scenario/mocks.js
deleted file mode 100644
index e135390f..00000000
--- a/test/scenario/mocks.js
+++ /dev/null
@@ -1,33 +0,0 @@
-'use strict';
-
-angular.scenario.testing = angular.scenario.testing || {};
-
-angular.scenario.testing.MockAngular = function() {
- this.reset();
- this.element = jqLite;
-};
-
-angular.scenario.testing.MockAngular.prototype.reset = function() {
- this.log = [];
-};
-
-angular.scenario.testing.MockAngular.prototype.poll = function() {
- this.log.push('$brower.poll()');
- return this;
-};
-
-angular.scenario.testing.MockRunner = function() {
- this.listeners = [];
-};
-
-angular.scenario.testing.MockRunner.prototype.on = function(eventName, fn) {
- this.listeners[eventName] = this.listeners[eventName] || [];
- this.listeners[eventName].push(fn);
-};
-
-angular.scenario.testing.MockRunner.prototype.emit = function(eventName) {
- var args = Array.prototype.slice.call(arguments, 1);
- angular.forEach(this.listeners[eventName] || [], function(fn) {
- fn.apply(this, args);
- });
-};
diff --git a/test/scenario/output/HtmlSpec.js b/test/scenario/output/HtmlSpec.js
deleted file mode 100644
index 442e596d..00000000
--- a/test/scenario/output/HtmlSpec.js
+++ /dev/null
@@ -1,126 +0,0 @@
-'use strict';
-
-describe('angular.scenario.output.html', function() {
- var runner, model, spec, step, listeners, ui, context;
-
- beforeEach(function() {
- listeners = [];
- spec = {
- name: 'test spec',
- definition: {
- id: 10,
- name: 'child',
- children: [],
- parent: {
- id: 20,
- name: 'parent',
- children: []
- }
- }
- };
- step = {
- name: 'some step',
- line: function() { return 'unknown:-1'; }
- };
- runner = new angular.scenario.testing.MockRunner();
- model = new angular.scenario.ObjectModel(runner);
- context = _jQuery("");
- ui = angular.scenario.output.html(context, runner, model);
- });
-
- it('should create nested describe context', function() {
- runner.emit('SpecBegin', spec);
- expect(context.find('#describe-20 #describe-10 > h2').text()).
- toEqual('describe: child');
- expect(context.find('#describe-20 > h2').text()).toEqual('describe: parent');
- expect(context.find('#describe-10 .tests > li .test-info .test-name').text()).
- toEqual('test spec');
- expect(context.find('#describe-10 .tests > li').hasClass('status-pending')).
- toBeTruthy();
- });
-
- it('should add link on InteractivePause', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('StepBegin', spec, step);
- runner.emit('InteractivePause', spec, step);
- expect(context.find('.test-actions .test-title:first').text()).toEqual('some step');
- expect(lowercase(context.find('.test-actions .test-title:last').html())).toEqual(
- 'paused... resume when ready.'
- );
- });
-
- it('should update totals when steps complete', function() {
- // Failure
- for (var i=0; i < 3; ++i) {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
- }
-
- // Error
- runner.emit('SpecBegin', spec);
- runner.emit('SpecError', spec, 'error');
- runner.emit('SpecEnd', spec);
-
- // Error
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepError', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- // Success
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- expect(parseInt(context.find('#status-legend .status-failure').text(), 10)).
- toEqual(3);
- expect(parseInt(context.find('#status-legend .status-error').text(), 10)).
- toEqual(2);
- expect(parseInt(context.find('#status-legend .status-success').text(), 10)).
- toEqual(1);
- });
-
- it('should update timer when test completes', function() {
- // Success
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- // Failure
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- // Error
- runner.emit('SpecBegin', spec);
- runner.emit('SpecError', spec, 'error');
- runner.emit('SpecEnd', spec);
-
- context.find('#describe-10 .tests > li .test-info .timer-result').
- each(function(index, timer) {
- expect(timer.innerHTML).toMatch(/ms$/);
- });
- });
-
- it('should include line if provided', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepFailure', spec, step, 'error');
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
-
- var errorHtml = context.find('#describe-10 .tests li pre').html();
- expect(errorHtml.indexOf('unknown:-1')).toEqual(0);
- });
-
-});
diff --git a/test/scenario/output/jsonSpec.js b/test/scenario/output/jsonSpec.js
deleted file mode 100644
index 06caf91c..00000000
--- a/test/scenario/output/jsonSpec.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-
-describe('angular.scenario.output.json', function() {
- var output, context;
- var runner, model, $window;
- var spec, step;
-
- beforeEach(function() {
- $window = {};
- context = _jQuery('');
- runner = new angular.scenario.testing.MockRunner();
- model = new angular.scenario.ObjectModel(runner);
- output = angular.scenario.output.json(context, runner, model);
- spec = {
- name: 'test spec',
- definition: {
- id: 10,
- name: 'describe'
- }
- };
- step = {
- name: 'some step',
- line: function() { return 'unknown:-1'; }
- };
- });
-
- it('should put json in context on RunnerEnd', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
- runner.emit('RunnerEnd');
-
- expect(angular.fromJson(context.html()).children['describe']
- .specs['test spec'].status).toEqual('success');
- });
-});
diff --git a/test/scenario/output/objectSpec.js b/test/scenario/output/objectSpec.js
deleted file mode 100644
index d92c939d..00000000
--- a/test/scenario/output/objectSpec.js
+++ /dev/null
@@ -1,40 +0,0 @@
-'use strict';
-
-describe('angular.scenario.output.object', function() {
- var output;
- var runner, model, $window;
- var spec, step;
-
- beforeEach(function() {
- $window = {};
- runner = new angular.scenario.testing.MockRunner();
- model = new angular.scenario.ObjectModel(runner);
- runner.$window = $window;
- output = angular.scenario.output.object(null, runner, model);
- spec = {
- name: 'test spec',
- definition: {
- id: 10,
- name: 'describe',
- children: []
- }
- };
- step = {
- name: 'some step',
- line: function() { return 'unknown:-1'; }
- };
- });
-
- it('should create a global variable $result', function() {
- expect($window.$result).toBeDefined();
- });
-
- it('should maintain live state in $result', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
-
- expect($window.$result.children['describe']
- .specs['test spec'].steps[0].duration).toBeDefined();
- });
-});
diff --git a/test/scenario/output/xmlSpec.js b/test/scenario/output/xmlSpec.js
deleted file mode 100644
index 94c3cb5a..00000000
--- a/test/scenario/output/xmlSpec.js
+++ /dev/null
@@ -1,36 +0,0 @@
-'use strict';
-
-describe('angular.scenario.output.json', function() {
- var output, context;
- var runner, model, $window;
- var spec, step;
-
- beforeEach(function() {
- $window = {};
- context = _jQuery('');
- runner = new angular.scenario.testing.MockRunner();
- model = new angular.scenario.ObjectModel(runner);
- output = angular.scenario.output.xml(context, runner, model);
- spec = {
- name: 'test spec',
- definition: {
- id: 10,
- name: 'describe'
- }
- };
- step = {
- name: 'some step',
- line: function() { return 'unknown:-1'; }
- };
- });
-
- it('should create XML nodes for object model', function() {
- runner.emit('SpecBegin', spec);
- runner.emit('StepBegin', spec, step);
- runner.emit('StepEnd', spec, step);
- runner.emit('SpecEnd', spec);
- runner.emit('RunnerEnd');
- expect(context.find('it').attr('status')).toEqual('success');
- expect(context.find('it step').attr('status')).toEqual('success');
- });
-});
diff --git a/test/service/anchorScrollSpec.js b/test/service/anchorScrollSpec.js
deleted file mode 100644
index 7e4b3aa3..00000000
--- a/test/service/anchorScrollSpec.js
+++ /dev/null
@@ -1,186 +0,0 @@
-describe('$anchorScroll', function() {
-
- var elmSpy;
-
- function addElements() {
- var elements = sliceArgs(arguments);
-
- return function() {
- forEach(elements, function(identifier) {
- var match = identifier.match(/(\w* )?(\w*)=(\w*)/),
- jqElm = jqLite('<' + (match[1] || 'a ') + match[2] + '="' + match[3] + '"/>'),
- elm = jqElm[0];
-
- elmSpy[identifier] = spyOn(elm, 'scrollIntoView');
- jqLite(document.body).append(jqElm);
- });
- };
- }
-
- function changeHashAndScroll(hash) {
- return function($location, $anchorScroll) {
- $location.hash(hash);
- $anchorScroll();
- };
- }
-
- function expectScrollingToTop($window) {
- forEach(elmSpy, function(spy, id) {
- expect(spy).not.toHaveBeenCalled();
- });
-
- expect($window.scrollTo).toHaveBeenCalledWith(0, 0);
- }
-
- function expectScrollingTo(identifier) {
- return function($window) {
- forEach(elmSpy, function(spy, id) {
- if (identifier === id) expect(spy).toHaveBeenCalledOnce();
- else expect(spy).not.toHaveBeenCalled();
- });
- expect($window.scrollTo).not.toHaveBeenCalled();
- };
- }
-
- function expectNoScrolling() {
- return expectScrollingTo(NaN);
- }
-
-
- beforeEach(module(function($provide) {
- elmSpy = {};
- $provide.value('$window', {
- scrollTo: jasmine.createSpy('$window.scrollTo'),
- document: document
- });
- }));
-
-
- it('should scroll to top of the window if empty hash', inject(
- changeHashAndScroll(''),
- expectScrollingToTop));
-
-
- it('should not scroll if hash does not match any element', inject(
- addElements('id=one', 'id=two'),
- changeHashAndScroll('non-existing'),
- expectNoScrolling()));
-
-
- it('should scroll to anchor element with name', inject(
- addElements('a name=abc'),
- changeHashAndScroll('abc'),
- expectScrollingTo('a name=abc')));
-
-
- it('should not scroll to other than anchor element with name', inject(
- addElements('input name=xxl', 'select name=xxl', 'form name=xxl'),
- changeHashAndScroll('xxl'),
- expectNoScrolling()));
-
-
- it('should scroll to anchor even if other element with given name exist', inject(
- addElements('input name=some', 'a name=some'),
- changeHashAndScroll('some'),
- expectScrollingTo('a name=some')));
-
-
- it('should scroll to element with id with precedence over name', inject(
- addElements('name=abc', 'id=abc'),
- changeHashAndScroll('abc'),
- expectScrollingTo('id=abc')));
-
-
- it('should scroll to top if hash == "top" and no matching element', inject(
- changeHashAndScroll('top'),
- expectScrollingToTop));
-
-
- it('should scroll to element with id "top" if present', inject(
- addElements('id=top'),
- changeHashAndScroll('top'),
- expectScrollingTo('id=top')));
-
-
- describe('watcher', function() {
-
- function initLocation(config) {
- return function($provide, $locationProvider) {
- $provide.value('$sniffer', {history: config.historyApi});
- $locationProvider.html5Mode(config.html5Mode);
- };
- }
-
- function changeHashTo(hash) {
- return function ($location, $rootScope, $anchorScroll) {
- $rootScope.$apply(function() {
- $location.hash(hash);
- });
- };
- }
-
- function disableAutoScrolling() {
- return function($anchorScrollProvider) {
- $anchorScrollProvider.disableAutoScrolling();
- };
- }
-
- afterEach(inject(function($document) {
- dealoc($document);
- }));
-
-
- it('should scroll to element when hash change in hashbang mode', function() {
- module(initLocation({html5Mode: false, historyApi: true}));
- inject(
- addElements('id=some'),
- changeHashTo('some'),
- expectScrollingTo('id=some')
- );
- });
-
-
- it('should scroll to element when hash change in html5 mode with no history api', function() {
- module(initLocation({html5Mode: true, historyApi: false}));
- inject(
- addElements('id=some'),
- changeHashTo('some'),
- expectScrollingTo('id=some')
- );
- });
-
-
- it('should not scroll when element does not exist', function() {
- module(initLocation({html5Mode: false, historyApi: false}));
- inject(
- addElements('id=some'),
- changeHashTo('other'),
- expectNoScrolling()
- );
- });
-
-
- it('should scroll when html5 mode with history api', function() {
- module(initLocation({html5Mode: true, historyApi: true}));
- inject(
- addElements('id=some'),
- changeHashTo('some'),
- expectScrollingTo('id=some')
- );
- });
-
-
- it('should not scroll when disabled', function() {
- module(
- disableAutoScrolling(),
- initLocation({html5Mode: false, historyApi: false})
- );
- inject(
- addElements('id=fake'),
- changeHashTo('fake'),
- expectNoScrolling()
- );
- });
- });
-});
-
diff --git a/test/service/browserSpecs.js b/test/service/browserSpecs.js
deleted file mode 100644
index 4563d14b..00000000
--- a/test/service/browserSpecs.js
+++ /dev/null
@@ -1,578 +0,0 @@
-'use strict';
-
-function MockWindow() {
- var events = {};
- var timeouts = this.timeouts = [];
-
- this.setTimeout = function(fn) {
- return timeouts.push(fn) - 1;
- };
-
- this.clearTimeout = function(id) {
- timeouts[id] = noop;
- };
-
- this.setTimeout.flush = function() {
- var length = timeouts.length;
- while (length-- > 0) timeouts.shift()();
- };
-
- this.addEventListener = function(name, listener) {
- if (isUndefined(events[name])) events[name] = [];
- events[name].push(listener);
- };
-
- this.attachEvent = function(name, listener) {
- this.addEventListener(name.substr(2), listener);
- };
-
- this.removeEventListener = noop;
- this.detachEvent = noop;
-
- this.fire = function(name) {
- forEach(events[name], function(fn) {
- fn({type: name}); // type to make jQuery happy
- });
- };
-
- this.location = {
- href: 'http://server',
- replace: noop
- };
-
- this.history = {
- replaceState: noop,
- pushState: noop
- };
-}
-
-describe('browser', function() {
-
- var browser, fakeWindow, logs, scripts, removedScripts, sniffer;
-
- beforeEach(function() {
- scripts = [];
- removedScripts = [];
- sniffer = {history: true, hashchange: true};
- fakeWindow = new MockWindow();
-
- var fakeBody = [{appendChild: function(node){scripts.push(node);},
- removeChild: function(node){removedScripts.push(node);}}];
-
- logs = {log:[], warn:[], info:[], error:[]};
-
- var fakeLog = {log: function() { logs.log.push(slice.call(arguments)); },
- warn: function() { logs.warn.push(slice.call(arguments)); },
- info: function() { logs.info.push(slice.call(arguments)); },
- error: function() { logs.error.push(slice.call(arguments)); }};
-
- browser = new Browser(fakeWindow, jqLite(window.document), fakeBody, fakeLog, sniffer);
- });
-
- it('should contain cookie cruncher', function() {
- expect(browser.cookies).toBeDefined();
- });
-
- describe('outstading requests', function() {
- it('should process callbacks immedietly with no outstanding requests', function() {
- var callback = jasmine.createSpy('callback');
- browser.notifyWhenNoOutstandingRequests(callback);
- expect(callback).toHaveBeenCalled();
- });
- });
-
-
- describe('defer', function() {
- it('should execute fn asynchroniously via setTimeout', function() {
- var callback = jasmine.createSpy('deferred');
-
- browser.defer(callback);
- expect(callback).not.toHaveBeenCalled();
-
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledOnce();
- });
-
-
- it('should update outstandingRequests counter', function() {
- var callback = jasmine.createSpy('deferred');
-
- browser.defer(callback);
- expect(callback).not.toHaveBeenCalled();
-
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledOnce();
- });
-
-
- it('should return unique deferId', function() {
- var deferId1 = browser.defer(noop),
- deferId2 = browser.defer(noop);
-
- expect(deferId1).toBeDefined();
- expect(deferId2).toBeDefined();
- expect(deferId1).not.toEqual(deferId2);
- });
-
-
- describe('cancel', function() {
- it('should allow tasks to be canceled with returned deferId', function() {
- var log = [],
- deferId1 = browser.defer(function() { log.push('cancel me'); }),
- deferId2 = browser.defer(function() { log.push('ok'); }),
- deferId3 = browser.defer(function() { log.push('cancel me, now!'); });
-
- expect(log).toEqual([]);
- expect(browser.defer.cancel(deferId1)).toBe(true);
- expect(browser.defer.cancel(deferId3)).toBe(true);
- fakeWindow.setTimeout.flush();
- expect(log).toEqual(['ok']);
- expect(browser.defer.cancel(deferId2)).toBe(false);
- });
- });
- });
-
-
- describe('cookies', function() {
-
- function deleteAllCookies() {
- var cookies = document.cookie.split(";");
-
- for (var i = 0; i < cookies.length; i++) {
- var cookie = cookies[i];
- var eqPos = cookie.indexOf("=");
- var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
- document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
- }
- }
-
- beforeEach(function() {
- deleteAllCookies();
- expect(document.cookie).toEqual('');
- });
-
-
- afterEach(function() {
- deleteAllCookies();
- expect(document.cookie).toEqual('');
- });
-
-
- describe('remove all via (null)', function() {
-
- it('should do nothing when no cookies are set', function() {
- browser.cookies(null);
- expect(document.cookie).toEqual('');
- expect(browser.cookies()).toEqual({});
- });
-
- });
-
- describe('remove via cookies(cookieName, undefined)', function() {
-
- it('should remove a cookie when it is present', function() {
- document.cookie = 'foo=bar';
-
- browser.cookies('foo', undefined);
-
- expect(document.cookie).toEqual('');
- expect(browser.cookies()).toEqual({});
- });
-
-
- it('should do nothing when an nonexisting cookie is being removed', function() {
- browser.cookies('doesntexist', undefined);
- expect(document.cookie).toEqual('');
- expect(browser.cookies()).toEqual({});
- });
- });
-
-
- describe('put via cookies(cookieName, string)', function() {
-
- it('should create and store a cookie', function() {
- browser.cookies('cookieName', 'cookie=Value');
- expect(document.cookie).toMatch(/cookieName=cookie%3DValue;? ?/);
- expect(browser.cookies()).toEqual({'cookieName':'cookie=Value'});
- });
-
-
- it('should overwrite an existing unsynced cookie', function() {
- document.cookie = "cookie=new";
-
- var oldVal = browser.cookies('cookie', 'newer');
-
- expect(document.cookie).toEqual('cookie=newer');
- expect(browser.cookies()).toEqual({'cookie':'newer'});
- expect(oldVal).not.toBeDefined();
- });
-
- it('should escape both name and value', function() {
- browser.cookies('cookie1=', 'val;ue');
- browser.cookies('cookie2=bar;baz', 'val=ue');
-
- var rawCookies = document.cookie.split("; "); //order is not guaranteed, so we need to parse
- expect(rawCookies.length).toEqual(2);
- expect(rawCookies).toContain('cookie1%3D=val%3Bue');
- expect(rawCookies).toContain('cookie2%3Dbar%3Bbaz=val%3Due');
- });
-
- it('should log warnings when 4kb per cookie storage limit is reached', function() {
- var i, longVal = '', cookieStr;
-
- for(i=0; i<4091; i++) {
- longVal += '+';
- }
-
- cookieStr = document.cookie;
- browser.cookies('x', longVal); //total size 4093-4096, so it should go through
- expect(document.cookie).not.toEqual(cookieStr);
- expect(browser.cookies()['x']).toEqual(longVal);
- expect(logs.warn).toEqual([]);
-
- browser.cookies('x', longVal + 'xxxx'); //total size 4097-4099, a warning should be logged
- expect(logs.warn).toEqual(
- [[ "Cookie 'x' possibly not set or overflowed because it was too large (4097 > 4096 " +
- "bytes)!" ]]);
-
- //force browser to dropped a cookie and make sure that the cache is not out of sync
- browser.cookies('x', 'shortVal');
- expect(browser.cookies().x).toEqual('shortVal'); //needed to prime the cache
- cookieStr = document.cookie;
- browser.cookies('x', longVal + longVal + longVal); //should be too long for all browsers
-
- if (document.cookie !== cookieStr) {
- fail("browser didn't drop long cookie when it was expected. make the cookie in this " +
- "test longer");
- }
-
- expect(browser.cookies().x).toEqual('shortVal');
- });
-
- it('should log warnings when 20 cookies per domain storage limit is reached', function() {
- var i, str, cookieStr;
-
- for (i=0; i<20; i++) {
- str = '' + i;
- browser.cookies(str, str);
- }
-
- i=0;
- for (str in browser.cookies()) {
- i++;
- }
- expect(i).toEqual(20);
- expect(logs.warn).toEqual([]);
- cookieStr = document.cookie;
-
- browser.cookies('one', 'more');
- expect(logs.warn).toEqual([]);
-
- //if browser dropped a cookie (very likely), make sure that the cache is not out of sync
- if (document.cookie === cookieStr) {
- expect(size(browser.cookies())).toEqual(20);
- } else {
- expect(size(browser.cookies())).toEqual(21);
- }
- });
- });
-
-
- describe('get via cookies()[cookieName]', function() {
-
- it('should return undefined for nonexistent cookie', function() {
- expect(browser.cookies().nonexistent).not.toBeDefined();
- });
-
-
- it ('should return a value for an existing cookie', function() {
- document.cookie = "foo=bar=baz";
- expect(browser.cookies().foo).toEqual('bar=baz');
- });
-
-
- it ('should unescape cookie values that were escaped by puts', function() {
- document.cookie = "cookie2%3Dbar%3Bbaz=val%3Due";
- expect(browser.cookies()['cookie2=bar;baz']).toEqual('val=ue');
- });
-
-
- it('should preserve leading & trailing spaces in names and values', function() {
- browser.cookies(' cookie name ', ' cookie value ');
- expect(browser.cookies()[' cookie name ']).toEqual(' cookie value ');
- expect(browser.cookies()['cookie name']).not.toBeDefined();
- });
- });
-
-
- describe('getAll via cookies()', function() {
-
- it('should return cookies as hash', function() {
- document.cookie = "foo1=bar1";
- document.cookie = "foo2=bar2";
- expect(browser.cookies()).toEqual({'foo1':'bar1', 'foo2':'bar2'});
- });
-
-
- it('should return empty hash if no cookies exist', function() {
- expect(browser.cookies()).toEqual({});
- });
- });
-
-
- it('should pick up external changes made to browser cookies', function() {
- browser.cookies('oatmealCookie', 'drool');
- expect(browser.cookies()).toEqual({'oatmealCookie':'drool'});
-
- document.cookie = 'oatmealCookie=changed';
- expect(browser.cookies().oatmealCookie).toEqual('changed');
- });
-
-
- it('should initialize cookie cache with existing cookies', function() {
- document.cookie = "existingCookie=existingValue";
- expect(browser.cookies()).toEqual({'existingCookie':'existingValue'});
- });
-
- });
-
- describe('poller', function() {
-
- it('should call functions in pollFns in regular intervals', function() {
- var log = '';
- browser.addPollFn(function() {log+='a';});
- browser.addPollFn(function() {log+='b';});
- expect(log).toEqual('');
- fakeWindow.setTimeout.flush();
- expect(log).toEqual('ab');
- fakeWindow.setTimeout.flush();
- expect(log).toEqual('abab');
- });
-
- it('should startPoller', function() {
- expect(fakeWindow.timeouts.length).toEqual(0);
-
- browser.addPollFn(function() {});
- expect(fakeWindow.timeouts.length).toEqual(1);
-
- //should remain 1 as it is the check fn
- browser.addPollFn(function() {});
- expect(fakeWindow.timeouts.length).toEqual(1);
- });
-
- it('should return fn that was passed into addPollFn', function() {
- var fn = function() { return 1; };
- var returnedFn = browser.addPollFn(fn);
- expect(returnedFn).toBe(fn);
- });
- });
-
- describe('url', function() {
- var pushState, replaceState, locationReplace;
-
- beforeEach(function() {
- pushState = spyOn(fakeWindow.history, 'pushState');
- replaceState = spyOn(fakeWindow.history, 'replaceState');
- locationReplace = spyOn(fakeWindow.location, 'replace');
- });
-
- it('should return current location.href', function() {
- fakeWindow.location.href = 'http://test.com';
- expect(browser.url()).toEqual('http://test.com');
-
- fakeWindow.location.href = 'https://another.com';
- expect(browser.url()).toEqual('https://another.com');
- });
-
- it('should use history.pushState when available', function() {
- sniffer.history = true;
- browser.url('http://new.org');
-
- expect(pushState).toHaveBeenCalledOnce();
- expect(pushState.argsForCall[0][2]).toEqual('http://new.org');
-
- expect(replaceState).not.toHaveBeenCalled();
- expect(locationReplace).not.toHaveBeenCalled();
- expect(fakeWindow.location.href).toEqual('http://server');
- });
-
- it('should use history.replaceState when available', function() {
- sniffer.history = true;
- browser.url('http://new.org', true);
-
- expect(replaceState).toHaveBeenCalledOnce();
- expect(replaceState.argsForCall[0][2]).toEqual('http://new.org');
-
- expect(pushState).not.toHaveBeenCalled();
- expect(locationReplace).not.toHaveBeenCalled();
- expect(fakeWindow.location.href).toEqual('http://server');
- });
-
- it('should set location.href when pushState not available', function() {
- sniffer.history = false;
- browser.url('http://new.org');
-
- expect(fakeWindow.location.href).toEqual('http://new.org');
-
- expect(pushState).not.toHaveBeenCalled();
- expect(replaceState).not.toHaveBeenCalled();
- expect(locationReplace).not.toHaveBeenCalled();
- });
-
- it('should use location.replace when history.replaceState not available', function() {
- sniffer.history = false;
- browser.url('http://new.org', true);
-
- expect(locationReplace).toHaveBeenCalledWith('http://new.org');
-
- expect(pushState).not.toHaveBeenCalled();
- expect(replaceState).not.toHaveBeenCalled();
- expect(fakeWindow.location.href).toEqual('http://server');
- });
-
- it('should return $browser to allow chaining', function() {
- expect(browser.url('http://any.com')).toBe(browser);
- });
- });
-
- describe('urlChange', function() {
- var callback;
-
- beforeEach(function() {
- callback = jasmine.createSpy('onUrlChange');
- });
-
- afterEach(function() {
- if (!jQuery) jqLite(fakeWindow).dealoc();
- });
-
- it('should return registered callback', function() {
- expect(browser.onUrlChange(callback)).toBe(callback);
- });
-
- it('should forward popstate event with new url when history supported', function() {
- sniffer.history = true;
- browser.onUrlChange(callback);
- fakeWindow.location.href = 'http://server/new';
-
- fakeWindow.fire('popstate');
- expect(callback).toHaveBeenCalledWith('http://server/new');
-
- fakeWindow.fire('hashchange');
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledOnce();
- });
-
- it('should forward only popstate event when both history and hashchange supported', function() {
- sniffer.history = true;
- sniffer.hashchange = true;
- browser.onUrlChange(callback);
- fakeWindow.location.href = 'http://server/new';
-
- fakeWindow.fire('popstate');
- expect(callback).toHaveBeenCalledWith('http://server/new');
-
- fakeWindow.fire('hashchange');
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledOnce();
- });
-
- it('should forward hashchange event with new url when only hashchange supported', function() {
- sniffer.history = false;
- sniffer.hashchange = true;
- browser.onUrlChange(callback);
- fakeWindow.location.href = 'http://server/new';
-
- fakeWindow.fire('hashchange');
- expect(callback).toHaveBeenCalledWith('http://server/new');
-
- fakeWindow.fire('popstate');
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledOnce();
- });
-
- it('should use polling when neither history nor hashchange supported', function() {
- sniffer.history = false;
- sniffer.hashchange = false;
- browser.onUrlChange(callback);
-
- fakeWindow.location.href = 'http://server.new';
- fakeWindow.setTimeout.flush();
- expect(callback).toHaveBeenCalledWith('http://server.new');
-
- fakeWindow.fire('popstate');
- fakeWindow.fire('hashchange');
- expect(callback).toHaveBeenCalledOnce();
- });
-
- it('should not fire urlChange if changed by browser.url method (polling)', function() {
- sniffer.history = false;
- sniffer.hashchange = false;
- browser.onUrlChange(callback);
- browser.url('http://new.com');
-
- fakeWindow.setTimeout.flush();
- expect(callback).not.toHaveBeenCalled();
- });
-
- it('should not fire urlChange if changed by browser.url method (hashchange)', function() {
- sniffer.history = false;
- sniffer.hashchange = true;
- browser.onUrlChange(callback);
- browser.url('http://new.com');
-
- fakeWindow.fire('hashchange');
- expect(callback).not.toHaveBeenCalled();
- });
- });
-
- describe('addJs', function() {
- it('should append a script tag to body', function() {
- browser.addJs('http://localhost/bar.js');
- expect(scripts.length).toBe(1);
- expect(scripts[0].src).toBe('http://localhost/bar.js');
- expect(scripts[0].id).toBe('');
- });
-
- it('should return the appended script element', function() {
- var script = browser.addJs('http://localhost/bar.js');
- expect(script).toBe(scripts[0]);
- });
- });
-
- describe('baseHref', function() {
- var jqDocHead;
-
- function setDocumentBaseHrefTo(href) {
- clearDocumentBaseHref();
- jqDocHead.append('
A<a>B</a>C
');
- var text = element.contents();
- expect(text[0].nodeName).toEqual('#text');
- text = $compile(text)($rootScope);
- expect(lowercase(text[0].nodeName)).toEqual('span');
- expect(element.find('span').text()).toEqual('ABC');
- }));
-
- describe('multiple directives per element', function() {
- it('should allow multiple directives per element', inject(function($compile, $rootScope, log){
- element = $compile(
- '')
- ($rootScope);
- expect(element.text()).toEqual('Hello angular');
- expect(log).toEqual('H; M; L');
- }));
-
-
- it('should recurse to children', inject(function($compile, $rootScope){
- element = $compile('01234
')($rootScope);
- expect(element.text()).toEqual('0hello2angular4');
- }));
-
-
- it('should allow directives in classes', inject(function($compile, $rootScope, log) {
- element = $compile('')($rootScope);
- expect(element.html()).toEqual('Hello angular');
- expect(log).toEqual('123');
- }));
-
-
- it('should ignore not set CSS classes on SVG elements', inject(function($compile, $rootScope, log) {
- if (!window.SVGElement) return;
- // According to spec SVG element className property is readonly, but only FF
- // implements it this way which causes compile exceptions.
- element = $compile('')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('1');
- }));
-
-
- it('should allow directives in comments', inject(
- function($compile, $rootScope, log) {
- element = $compile('01
')($rootScope);
- expect(log).toEqual('angular');
- }
- ));
-
-
- it('should receive scope, element, and attributes', function() {
- var injector;
- module(function($compileProvider) {
- $compileProvider.directive('log', function($injector, $rootScope) {
- injector = $injector;
- return {
- restrict: 'CA',
- compile: function(element, templateAttr) {
- expect(typeof templateAttr.$normalize).toBe('function');
- expect(typeof templateAttr.$set).toBe('function');
- expect(isElement(templateAttr.$element)).toBeTruthy();
- expect(element.text()).toEqual('unlinked');
- expect(templateAttr.exp).toEqual('abc');
- expect(templateAttr.aa).toEqual('A');
- expect(templateAttr.bb).toEqual('B');
- expect(templateAttr.cc).toEqual('C');
- return function(scope, element, attr) {
- expect(element.text()).toEqual('unlinked');
- expect(attr).toBe(templateAttr);
- expect(scope).toEqual($rootScope);
- element.text('worked');
- }
- }
- };
- });
- });
- inject(function($rootScope, $compile, $injector) {
- element = $compile(
- 'unlinked
')($rootScope);
- expect(element.text()).toEqual('worked');
- expect(injector).toBe($injector); // verify that directive is injectable
- });
- });
- });
-
- describe('error handling', function() {
-
- it('should handle exceptions', function() {
- module(function($compileProvider, $exceptionHandlerProvider) {
- $exceptionHandlerProvider.mode('log');
- $compileProvider.directive('factoryError', function() { throw 'FactoryError'; });
- $compileProvider.directive('templateError',
- valueFn({ compile: function() { throw 'TemplateError'; } }));
- $compileProvider.directive('linkingError',
- valueFn(function() { throw 'LinkingError'; }));
- });
- inject(function($rootScope, $compile, $exceptionHandler) {
- element = $compile('')($rootScope);
- expect($exceptionHandler.errors[0]).toEqual('FactoryError');
- expect($exceptionHandler.errors[1][0]).toEqual('TemplateError');
- expect(ie($exceptionHandler.errors[1][1])).
- toEqual('');
- expect($exceptionHandler.errors[2][0]).toEqual('LinkingError');
- expect(ie($exceptionHandler.errors[2][1])).
- toEqual('
');
-
-
- // crazy stuff to make IE happy
- function ie(text) {
- var list = [],
- parts, elementName;
-
- parts = lowercase(text).
- replace('<', '').
- replace('>', '').
- split(' ');
- elementName = parts.shift();
- parts.sort();
- parts.unshift(elementName);
- forEach(parts, function(value, key){
- if (value.substring(0,3) == 'ng-') {
- } else {
- value = value.replace('=""', '');
- var match = value.match(/=(.*)/);
- if (match && match[1].charAt(0) != '"') {
- value = value.replace(/=(.*)/, '="$1"');
- }
- list.push(value);
- }
- });
- return '<' + list.join(' ') + '>';
- }
- });
- });
-
-
- it('should prevent changing of structure', inject(
- function($compile, $rootScope){
- element = jqLite("
");
- var linkFn = $compile(element);
- element.append("");
- expect(function() {
- linkFn($rootScope);
- }).toThrow('Template changed structure!');
- }
- ));
- });
-
- describe('compiler control', function() {
- describe('priority', function() {
- it('should honor priority', inject(function($compile, $rootScope, log){
- element = $compile(
- '')
- ($rootScope);
- expect(log).toEqual('H; M; L');
- }));
- });
-
-
- describe('terminal', function() {
-
- it('should prevent further directives from running', inject(function($rootScope, $compile) {
- element = $compile('')($rootScope);
- expect(element.text()).toEqual('OK');
- }
- ));
-
-
- it('should prevent further directives from running, but finish current priority level',
- inject(function($rootScope, $compile, log) {
- // class is processed after attrs, so putting log in class will put it after
- // the stop in the current level. This proves that the log runs after stop
- element = $compile(
- '')($rootScope);
- expect(element.text()).toEqual('OK');
- expect(log.toArray().sort()).toEqual(['HIGH', 'MEDIUM']);
- })
- );
- });
-
-
- describe('restrict', function() {
-
- it('should allow restriction of attributes', function() {
- module(function($compileProvider, $provide) {
- forEach({div:'E', attr:'A', clazz:'C', all:'EAC'}, function(restrict, name) {
- $compileProvider.directive(name, function(log) {
- return {
- restrict: restrict,
- compile: valueFn(function(scope, element, attr) {
- log(name);
- })
- };
- });
- });
- });
- inject(function($rootScope, $compile, log) {
- dealoc($compile('')($rootScope));
- expect(log).toEqual('');
- log.reset();
-
- dealoc($compile('')($rootScope));
- expect(log).toEqual('div');
- log.reset();
-
- dealoc($compile('
Hello: <>
',
- compile: function(element, attr) {
- attr.$set('compiled', 'COMPILED');
- expect(element).toBe(attr.$element);
- }
- }));
- $compileProvider.directive('append', valueFn({
- restrict: 'CAM',
- template: 'Hello: <>
',
- compile: function(element, attr) {
- attr.$set('compiled', 'COMPILED');
- expect(element).toBe(attr.$element);
- }
- }));
- }));
-
-
- it('should replace element with template', inject(function($compile, $rootScope) {
- element = $compile('content
')($rootScope);
- expect(element.text()).toEqual('Hello: content');
- expect(element.find('div').attr('compiled')).toEqual('COMPILED');
- }));
-
-
- it('should append element with template', inject(function($compile, $rootScope) {
- element = $compile('
content
')($rootScope);
- expect(element.text()).toEqual('Hello: content');
- expect(element.find('div').attr('compiled')).toEqual('COMPILED');
- }));
-
-
- it('should compile replace template', inject(function($compile, $rootScope, log) {
- element = $compile('
{{ "angular" }}
')
- ($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('Hello: angular');
- // HIGH goes after MEDIUM since it executes as part of replaced template
- expect(log).toEqual('MEDIUM; HIGH; LOG');
- }));
-
-
- it('should compile append template', inject(function($compile, $rootScope, log) {
- element = $compile('
{{ "angular" }}
')
- ($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('Hello: angular');
- expect(log).toEqual('HIGH; LOG; MEDIUM');
- }));
-
-
- it('should merge attributes including style attr', inject(function($compile, $rootScope) {
- element = $compile(
- '
')
- ($rootScope);
- var div = element.find('div');
- expect(div.hasClass('medium-log')).toBe(true);
- expect(div.hasClass('log')).toBe(true);
- expect(div.css('width')).toBe('10px');
- expect(div.css('height')).toBe('20px');
- expect(div.attr('replace')).toEqual('');
- expect(div.attr('high-log')).toEqual('');
- }));
-
- it('should prevent multiple templates per element', inject(function($compile) {
- try {
- $compile('> ');
- element = jqLite('{{1+2}}');
- $compile(element)($rootScope);
-
- $httpBackend.flush();
- expect(element.text()).toEqual('3==3');
- }
- ));
-
-
- it('should work when widget is a repeater', inject(
- function($compile, $httpBackend, $rootScope) {
- $httpBackend.expect('GET', 'hello.html').respond('i=<>; ');
- element = jqLite('
')
- fail();
- } catch(e) {
- expect(e.message).toMatch(/Multiple directives .* asking for template/);
- }
- }));
-
- it('should play nice with repeater when inline', inject(function($compile, $rootScope) {
- element = $compile(
- '
' +
- '
')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('Hello: 1; Hello: 2; ');
- }));
-
-
- it('should play nice with repeater when append', inject(function($compile, $rootScope) {
- element = $compile(
- '{{i}};
' +
- '' +
- '
')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('Hello: 1; Hello: 2; ');
- }));
-
-
- it('should merge interpolated css class', inject(function($compile, $rootScope) {
- element = $compile('')($rootScope);
-
- $rootScope.$apply(function() {
- $rootScope.cls = 'two';
- });
-
- expect(element).toHaveClass('one');
- expect(element).toHaveClass('two'); // interpolated
- expect(element).toHaveClass('three');
- expect(element).toHaveClass('log'); // merged from replace directive template
- }));
-
-
- it('should merge interpolated css class with ng-repeat',
- inject(function($compile, $rootScope) {
- element = $compile(
- '{{i}};
' +
- '' +
- '' +
- '
')($rootScope);
-
- $rootScope.$apply(function() {
- $rootScope.cls = 'two';
- });
-
- var child = element.find('div').eq(0);
- expect(child).toHaveClass('one');
- expect(child).toHaveClass('two'); // interpolated
- expect(child).toHaveClass('three');
- expect(child).toHaveClass('log'); // merged from replace directive template
- }));
- });
-
-
- describe('async templates', function() {
-
- beforeEach(module(
- function($compileProvider) {
- $compileProvider.directive('hello', valueFn({ restrict: 'CAM', templateUrl: 'hello.html' }));
- $compileProvider.directive('cau', valueFn({ restrict: 'CAM', templateUrl:'cau.html' }));
-
- $compileProvider.directive('cError', valueFn({
- restrict: 'CAM',
- templateUrl:'error.html',
- compile: function() {
- throw Error('cError');
- }
- }));
- $compileProvider.directive('lError', valueFn({
- restrict: 'CAM',
- templateUrl: 'error.html',
- compile: function() {
- throw Error('lError');
- }
- }));
-
-
- $compileProvider.directive('iHello', valueFn({
- restrict: 'CAM',
- replace: true,
- templateUrl: 'hello.html'
- }));
- $compileProvider.directive('iCau', valueFn({
- restrict: 'CAM',
- replace: true,
- templateUrl:'cau.html'
- }));
-
- $compileProvider.directive('iCError', valueFn({
- restrict: 'CAM',
- replace: true,
- templateUrl:'error.html',
- compile: function() {
- throw Error('cError');
- }
- }));
- $compileProvider.directive('iLError', valueFn({
- restrict: 'CAM',
- replace: true,
- templateUrl: 'error.html',
- compile: function() {
- throw Error('lError');
- }
- }));
-
- }
- ));
-
-
- it('should append template via $http and cache it in $templateCache', inject(
- function($compile, $httpBackend, $templateCache, $rootScope, $browser) {
- $httpBackend.expect('GET', 'hello.html').respond('Hello! World!');
- $templateCache.put('cau.html', 'Cau!');
- element = $compile('ignoreignore
')($rootScope);
- expect(sortedHtml(element)).
- toEqual('');
-
- $rootScope.$digest();
-
-
- expect(sortedHtml(element)).
- toEqual('
Cau!
');
-
- $httpBackend.flush();
- expect(sortedHtml(element)).toEqual(
- '' +
- 'Hello! World!' +
- 'Cau!' +
- '
');
- }
- ));
-
-
- it('should inline template via $http and cache it in $templateCache', inject(
- function($compile, $httpBackend, $templateCache, $rootScope) {
- $httpBackend.expect('GET', 'hello.html').respond('Hello!');
- $templateCache.put('cau.html', 'Cau!');
- element = $compile('ignoreignore
')($rootScope);
- expect(sortedHtml(element)).
- toEqual('');
-
- $rootScope.$digest();
-
-
- expect(sortedHtml(element)).
- toEqual('
Cau!
');
-
- $httpBackend.flush();
- expect(sortedHtml(element)).
- toEqual('Hello!Cau!
');
- }
- ));
-
-
- it('should compile, link and flush the template append', inject(
- function($compile, $templateCache, $rootScope, $browser) {
- $templateCache.put('hello.html', 'Hello, {{name}}!');
- $rootScope.name = 'Elvis';
- element = $compile('')($rootScope);
-
- $rootScope.$digest();
-
- expect(sortedHtml(element)).
- toEqual('
Hello, Elvis!
');
- }
- ));
-
-
- it('should compile, link and flush the template inline', inject(
- function($compile, $templateCache, $rootScope) {
- $templateCache.put('hello.html', 'Hello, {{name}}!');
- $rootScope.name = 'Elvis';
- element = $compile('')($rootScope);
-
- $rootScope.$digest();
-
- expect(sortedHtml(element)).
- toEqual('
Hello, Elvis!
');
- }
- ));
-
-
- it('should compile, flush and link the template append', inject(
- function($compile, $templateCache, $rootScope) {
- $templateCache.put('hello.html', 'Hello, {{name}}!');
- $rootScope.name = 'Elvis';
- var template = $compile('');
-
- element = template($rootScope);
- $rootScope.$digest();
-
- expect(sortedHtml(element)).
- toEqual('
Hello, Elvis!
');
- }
- ));
-
-
- it('should compile, flush and link the template inline', inject(
- function($compile, $templateCache, $rootScope) {
- $templateCache.put('hello.html', 'Hello, {{name}}!');
- $rootScope.name = 'Elvis';
- var template = $compile('');
-
- element = template($rootScope);
- $rootScope.$digest();
-
- expect(sortedHtml(element)).
- toEqual('
Hello, Elvis!
');
- }
- ));
-
-
- it('should resolve widgets after cloning in append mode', function() {
- module(function($exceptionHandlerProvider) {
- $exceptionHandlerProvider.mode('log');
- });
- inject(function($compile, $templateCache, $rootScope, $httpBackend, $browser,
- $exceptionHandler) {
- $httpBackend.expect('GET', 'hello.html').respond('{{greeting}} ');
- $httpBackend.expect('GET', 'error.html').respond('');
- $templateCache.put('cau.html', '{{name}}');
- $rootScope.greeting = 'Hello';
- $rootScope.name = 'Elvis';
- var template = $compile(
- '' +
- '' +
- '' +
- '' +
- '' +
- '
');
- var e1;
- var e2;
-
- e1 = template($rootScope.$new(), noop); // clone
- expect(e1.text()).toEqual('');
-
- $httpBackend.flush();
-
- e2 = template($rootScope.$new(), noop); // clone
- $rootScope.$digest();
- expect(e1.text()).toEqual('Hello Elvis');
- expect(e2.text()).toEqual('Hello Elvis');
-
- expect($exceptionHandler.errors.length).toEqual(2);
- expect($exceptionHandler.errors[0][0].message).toEqual('cError');
- expect($exceptionHandler.errors[1][0].message).toEqual('lError');
-
- dealoc(e1);
- dealoc(e2);
- });
- });
-
-
- it('should resolve widgets after cloning in inline mode', function() {
- module(function($exceptionHandlerProvider) {
- $exceptionHandlerProvider.mode('log');
- });
- inject(function($compile, $templateCache, $rootScope, $httpBackend, $browser,
- $exceptionHandler) {
- $httpBackend.expect('GET', 'hello.html').respond('{{greeting}} ');
- $httpBackend.expect('GET', 'error.html').respond('');
- $templateCache.put('cau.html', '{{name}}');
- $rootScope.greeting = 'Hello';
- $rootScope.name = 'Elvis';
- var template = $compile(
- '' +
- '' +
- '' +
- '' +
- '' +
- '
');
- var e1;
- var e2;
-
- e1 = template($rootScope.$new(), noop); // clone
- expect(e1.text()).toEqual('');
-
- $httpBackend.flush();
-
- e2 = template($rootScope.$new(), noop); // clone
- $rootScope.$digest();
- expect(e1.text()).toEqual('Hello Elvis');
- expect(e2.text()).toEqual('Hello Elvis');
-
- expect($exceptionHandler.errors.length).toEqual(2);
- expect($exceptionHandler.errors[0][0].message).toEqual('cError');
- expect($exceptionHandler.errors[1][0].message).toEqual('lError');
-
- dealoc(e1);
- dealoc(e2);
- });
- });
-
-
- it('should be implicitly terminal and not compile placeholder content in append', inject(
- function($compile, $templateCache, $rootScope, log) {
- // we can't compile the contents because that would result in a memory leak
-
- $templateCache.put('hello.html', 'Hello!');
- element = $compile('')($rootScope);
-
- expect(log).toEqual('');
- }
- ));
-
-
- it('should be implicitly terminal and not compile placeholder content in inline', inject(
- function($compile, $templateCache, $rootScope, log) {
- // we can't compile the contents because that would result in a memory leak
-
- $templateCache.put('hello.html', 'Hello!');
- element = $compile('
')($rootScope);
-
- expect(log).toEqual('');
- }
- ));
-
-
- it('should throw an error and clear element content if the template fails to load', inject(
- function($compile, $httpBackend, $rootScope) {
- $httpBackend.expect('GET', 'hello.html').respond(404, 'Not Found!');
- element = $compile('
content
')($rootScope);
-
- expect(function() {
- $httpBackend.flush();
- }).toThrow('Failed to load template: hello.html');
- expect(sortedHtml(element)).toBe('');
- }
- ));
-
-
- it('should prevent multiple templates per element', function() {
- module(function($compileProvider) {
- $compileProvider.directive('sync', valueFn({
- restrict: 'C',
- template: ''
- }));
- $compileProvider.directive('async', valueFn({
- restrict: 'C',
- templateUrl: 'template.html'
- }));
- });
- inject(function($compile){
- expect(function() {
- $compile('
');
- }).toThrow('Multiple directives [sync, async] asking for template on: <'+
- (msie <= 8 ? 'DIV' : 'div') + ' class="sync async">');
- });
- });
-
-
- describe('delay compile / linking functions until after template is resolved', function(){
- var template;
- beforeEach(module(function($compileProvider) {
- function directive (name, priority, options) {
- $compileProvider.directive(name, function(log) {
- return (extend({
- priority: priority,
- compile: function() {
- log(name + '-C');
- return function() { log(name + '-L'); }
- }
- }, options || {}));
- });
- }
-
- directive('first', 10);
- directive('second', 5, { templateUrl: 'second.html' });
- directive('third', 3);
- directive('last', 0);
-
- directive('iFirst', 10, {replace: true});
- directive('iSecond', 5, {replace: true, templateUrl: 'second.html' });
- directive('iThird', 3, {replace: true});
- directive('iLast', 0, {replace: true});
- }));
-
- it('should flush after link append', inject(
- function($compile, $rootScope, $httpBackend, log) {
- $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
- template = $compile('');
- element = template($rootScope);
- expect(log).toEqual('first-C');
-
- log('FLUSH');
- $httpBackend.flush();
- $rootScope.$digest();
- expect(log).toEqual(
- 'first-C; FLUSH; second-C; last-C; third-C; ' +
- 'third-L; first-L; second-L; last-L');
-
- var span = element.find('span');
- expect(span.attr('first')).toEqual('');
- expect(span.attr('second')).toEqual('');
- expect(span.find('div').attr('third')).toEqual('');
- expect(span.attr('last')).toEqual('');
-
- expect(span.text()).toEqual('3');
- }));
-
-
- it('should flush after link inline', inject(
- function($compile, $rootScope, $httpBackend, log) {
- $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
- template = $compile('');
- element = template($rootScope);
- expect(log).toEqual('iFirst-C');
-
- log('FLUSH');
- $httpBackend.flush();
- $rootScope.$digest();
- expect(log).toEqual(
- 'iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C; ' +
- 'iFirst-L; iSecond-L; iThird-L; iLast-L');
-
- var div = element.find('div');
- expect(div.attr('i-first')).toEqual('');
- expect(div.attr('i-second')).toEqual('');
- expect(div.attr('i-third')).toEqual('');
- expect(div.attr('i-last')).toEqual('');
-
- expect(div.text()).toEqual('3');
- }));
-
-
- it('should flush before link append', inject(
- function($compile, $rootScope, $httpBackend, log) {
- $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
- template = $compile('');
- expect(log).toEqual('first-C');
- log('FLUSH');
- $httpBackend.flush();
- expect(log).toEqual('first-C; FLUSH; second-C; last-C; third-C');
-
- element = template($rootScope);
- $rootScope.$digest();
- expect(log).toEqual(
- 'first-C; FLUSH; second-C; last-C; third-C; ' +
- 'third-L; first-L; second-L; last-L');
-
- var span = element.find('span');
- expect(span.attr('first')).toEqual('');
- expect(span.attr('second')).toEqual('');
- expect(span.find('div').attr('third')).toEqual('');
- expect(span.attr('last')).toEqual('');
-
- expect(span.text()).toEqual('3');
- }));
-
-
- it('should flush before link inline', inject(
- function($compile, $rootScope, $httpBackend, log) {
- $httpBackend.expect('GET', 'second.html').respond('
{{1+2}}
');
- template = $compile('');
- expect(log).toEqual('iFirst-C');
- log('FLUSH');
- $httpBackend.flush();
- expect(log).toEqual('iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C');
-
- element = template($rootScope);
- $rootScope.$digest();
- expect(log).toEqual(
- 'iFirst-C; FLUSH; iSecond-C; iThird-C; iLast-C; ' +
- 'iFirst-L; iSecond-L; iThird-L; iLast-L');
-
- var div = element.find('div');
- expect(div.attr('i-first')).toEqual('');
- expect(div.attr('i-second')).toEqual('');
- expect(div.attr('i-third')).toEqual('');
- expect(div.attr('i-last')).toEqual('');
-
- expect(div.text()).toEqual('3');
- }));
- });
-
-
- it('should check that template has root element', inject(function($compile, $httpBackend) {
- $httpBackend.expect('GET', 'hello.html').respond('before mid after');
- $compile('');
- expect(function(){
- $httpBackend.flush();
- }).toThrow('Template must have exactly one root element: before mid after');
- }));
-
-
- it('should allow multiple elements in template', inject(function($compile, $httpBackend) {
- $httpBackend.expect('GET', 'hello.html').respond('before mid after');
- element = jqLite('');
- $compile(element);
- $httpBackend.flush();
- expect(element.text()).toEqual('before mid after');
- }));
-
-
- it('should work when widget is in root element', inject(
- function($compile, $httpBackend, $rootScope) {
- $httpBackend.expect('GET', 'hello.html').respond('3==<
{{i}}
');
- $compile(element)($rootScope);
-
- $httpBackend.flush();
- expect(element.text()).toEqual('i=1;i=2;');
- }
- ));
- });
-
-
- describe('scope', function() {
- var iscope;
-
- beforeEach(module(function($compileProvider) {
- forEach(['', 'a', 'b'], function(name) {
- $compileProvider.directive('scope' + uppercase(name), function(log) {
- return {
- scope: true,
- restrict: 'CA',
- compile: function() {
- return function (scope, element) {
- log(scope.$id);
- expect(element.data('$scope')).toBe(scope);
- };
- }
- };
- });
- $compileProvider.directive('iscope' + uppercase(name), function(log) {
- return {
- scope: {},
- restrict: 'CA',
- compile: function() {
- return function (scope, element) {
- iscope = scope;
- log(scope.$id);
- expect(element.data('$scope')).toBe(scope);
- };
- }
- };
- });
- $compileProvider.directive('tiscope' + uppercase(name), function(log) {
- return {
- scope: {},
- restrict: 'CA',
- templateUrl: 'tiscope.html',
- compile: function() {
- return function (scope, element) {
- iscope = scope;
- log(scope.$id);
- expect(element.data('$scope')).toBe(scope);
- };
- }
- };
- });
- });
- $compileProvider.directive('log', function(log) {
- return {
- restrict: 'CA',
- link: function(scope) {
- log('log-' + scope.$id + '-' + scope.$parent.$id);
- }
- };
- });
- }));
-
-
- it('should allow creation of new scopes', inject(function($rootScope, $compile, log) {
- element = $compile('')($rootScope);
- expect(log).toEqual('LOG; log-002-001; 002');
- expect(element.find('span').hasClass('ng-scope')).toBe(true);
- }));
-
-
- it('should allow creation of new isolated scopes for directives', inject(
- function($rootScope, $compile, log) {
- element = $compile('')($rootScope);
- expect(log).toEqual('LOG; log-002-001; 002');
- $rootScope.name = 'abc';
- expect(iscope.$parent).toBe($rootScope);
- expect(iscope.name).toBeUndefined();
- }));
-
-
- it('should allow creation of new isolated scopes for directives with templates', inject(
- function($rootScope, $compile, log, $httpBackend) {
- $httpBackend.expect('GET', 'tiscope.html').respond('');
- element = $compile('')($rootScope);
- $httpBackend.flush();
- expect(log).toEqual('LOG; log-002-001; 002');
- $rootScope.name = 'abc';
- expect(iscope.$parent).toBe($rootScope);
- expect(iscope.name).toBeUndefined();
- }));
-
-
- it('should correctly create the scope hierachy', inject(
- function($rootScope, $compile, log) {
- element = $compile(
- '
' + //1
- '' + //2
- '' + //3
- '' +
- '' +
- '' + //4
- '' +
- '' +
- '
'
- )($rootScope);
- expect(log).toEqual('LOG; log-003-002; 003; LOG; log-002-001; 002; LOG; log-004-001; 004');
- })
- );
-
-
- it('should allow more one new scope directives per element, but directives should share' +
- 'the scope', inject(
- function($rootScope, $compile, log) {
- element = $compile('')($rootScope);
- expect(log).toEqual('002; 002');
- })
- );
-
- it('should not allow more then one isolate scope creation per element', inject(
- function($rootScope, $compile) {
- expect(function(){
- $compile('');
- }).toThrow('Multiple directives [iscopeA, scopeB] asking for isolated scope on: ' +
- '<' + (msie < 9 ? 'DIV' : 'div') +
- ' class="iscope-a; scope-b ng-isolate-scope ng-scope">');
- })
- );
-
-
- it('should not allow more then one isolate scope creation per element', inject(
- function($rootScope, $compile) {
- expect(function(){
- $compile('');
- }).toThrow('Multiple directives [iscopeA, iscopeB] asking for isolated scope on: ' +
- '<' + (msie < 9 ? 'DIV' : 'div') +
- ' class="iscope-a; iscope-b ng-isolate-scope ng-scope">');
- })
- );
-
-
- it('should create new scope even at the root of the template', inject(
- function($rootScope, $compile, log) {
- element = $compile('')($rootScope);
- expect(log).toEqual('002');
- })
- );
-
-
- it('should create isolate scope even at the root of the template', inject(
- function($rootScope, $compile, log) {
- element = $compile('')($rootScope);
- expect(log).toEqual('002');
- })
- );
- });
- });
- });
-
-
- describe('interpolation', function() {
- var observeSpy, attrValueDuringLinking;
-
- beforeEach(module(function($compileProvider) {
- $compileProvider.directive('observer', function() {
- return function(scope, elm, attr) {
- observeSpy = jasmine.createSpy('$observe attr');
-
- attr.$observe('someAttr', observeSpy);
- attrValueDuringLinking = attr.someAttr;
- };
- });
- }));
-
-
- it('should compile and link both attribute and text bindings', inject(
- function($rootScope, $compile) {
- $rootScope.name = 'angular';
- element = $compile('text: {{name}}
')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toEqual('text: angular');
- expect(element.attr('name')).toEqual('attr: angular');
- }));
-
-
- it('should decorate the binding with ng-binding and interpolation function', inject(
- function($compile, $rootScope) {
- element = $compile('{{1+2}}
')($rootScope);
- expect(element.hasClass('ng-binding')).toBe(true);
- expect(element.data('$binding')[0].exp).toEqual('{{1+2}}');
- }));
-
-
- it('should observe interpolated attrs', inject(function($rootScope, $compile) {
- $compile('')($rootScope);
-
- // should be async
- expect(observeSpy).not.toHaveBeenCalled();
-
- $rootScope.$apply(function() {
- $rootScope.value = 'bound-value';
- });
- expect(observeSpy).toHaveBeenCalledOnceWith('bound-value');
- }));
-
-
- it('should set interpolated attrs to undefined', inject(function($rootScope, $compile) {
- attrValueDuringLinking = null;
- $compile('')($rootScope);
- expect(attrValueDuringLinking).toBeUndefined();
- }));
-
-
- it('should not call observer of non-interpolated attr', inject(function($rootScope, $compile) {
- $compile('')($rootScope);
- expect(attrValueDuringLinking).toBe('nonBound');
-
- $rootScope.$digest();
- expect(observeSpy).not.toHaveBeenCalled();
- }));
-
-
- it('should delegate exceptions to $exceptionHandler', function() {
- observeSpy = jasmine.createSpy('$observe attr').andThrow('ERROR');
-
- module(function($compileProvider, $exceptionHandlerProvider) {
- $exceptionHandlerProvider.mode('log');
- $compileProvider.directive('error', function() {
- return function(scope, elm, attr) {
- attr.$observe('someAttr', observeSpy);
- attr.$observe('someAttr', observeSpy);
- };
- });
- });
-
- inject(function($compile, $rootScope, $exceptionHandler) {
- $compile('')($rootScope);
- $rootScope.$digest();
-
- expect(observeSpy).toHaveBeenCalled();
- expect(observeSpy.callCount).toBe(2);
- expect($exceptionHandler.errors).toEqual(['ERROR', 'ERROR']);
- });
- });
-
-
- it('should translate {{}} in terminal nodes', inject(function($rootScope, $compile) {
- element = $compile('')($rootScope)
- $rootScope.$digest();
- expect(sortedHtml(element).replace(' selected="true"', '')).
- toEqual('');
- $rootScope.name = 'Misko';
- $rootScope.$digest();
- expect(sortedHtml(element).replace(' selected="true"', '')).
- toEqual('');
- }));
- });
-
-
- describe('link phase', function() {
-
- beforeEach(module(function($compileProvider) {
-
- forEach(['a', 'b', 'c'], function(name) {
- $compileProvider.directive(name, function(log) {
- return {
- restrict: 'ECA',
- compile: function() {
- log('t' + uppercase(name))
- return {
- pre: function() {
- log('pre' + uppercase(name));
- },
- post: function linkFn() {
- log('post' + uppercase(name));
- }
- };
- }
- };
- });
- });
- }));
-
-
- it('should not store linkingFns for noop branches', inject(function ($rootScope, $compile) {
- element = jqLite('ignore
');
- var linkingFn = $compile(element);
- // Now prune the branches with no directives
- element.find('span').remove();
- expect(element.find('span').length).toBe(0);
- // and we should still be able to compile without errors
- linkingFn($rootScope);
- }));
-
-
- it('should compile from top to bottom but link from bottom up', inject(
- function($compile, $rootScope, log) {
- element = $compile('FAIL
')($rootScope);
- expect(element.text()).toEqual('WORKS');
- });
- });
- });
-
-
- describe('attrs', function() {
-
- it('should allow setting of attributes', function() {
- module(function($compileProvider) {
- $compileProvider.directive({
- setter: valueFn(function(scope, element, attr) {
- attr.$set('name', 'abc');
- attr.$set('disabled', true);
- expect(attr.name).toBe('abc');
- expect(attr.disabled).toBe(true);
- })
- });
- });
- inject(function($rootScope, $compile) {
- element = $compile('')($rootScope);
- expect(element.attr('name')).toEqual('abc');
- expect(element.attr('disabled')).toEqual('disabled');
- });
- });
-
-
- it('should read boolean attributes as boolean only on control elements', function() {
- var value;
- module(function($compileProvider) {
- $compileProvider.directive({
- input: valueFn({
- restrict: 'ECA',
- link:function(scope, element, attr) {
- value = attr.required;
- }
- })
- });
- });
- inject(function($rootScope, $compile) {
- element = $compile('')($rootScope);
- expect(value).toEqual(true);
- });
- });
-
- it('should read boolean attributes as text on non-controll elements', function() {
- var value;
- module(function($compileProvider) {
- $compileProvider.directive({
- div: valueFn({
- restrict: 'ECA',
- link:function(scope, element, attr) {
- value = attr.required;
- }
- })
- });
- });
- inject(function($rootScope, $compile) {
- element = $compile('')($rootScope);
- expect(value).toEqual('some text');
- });
- });
-
- it('should allow setting of attributes', function() {
- module(function($compileProvider) {
- $compileProvider.directive({
- setter: valueFn(function(scope, element, attr) {
- attr.$set('name', 'abc');
- attr.$set('disabled', true);
- expect(attr.name).toBe('abc');
- expect(attr.disabled).toBe(true);
- })
- });
- });
- inject(function($rootScope, $compile) {
- element = $compile('')($rootScope);
- expect(element.attr('name')).toEqual('abc');
- expect(element.attr('disabled')).toEqual('disabled');
- });
- });
-
-
- it('should create new instance of attr for each template stamping', function() {
- module(function($compileProvider, $provide) {
- var state = { first: [], second: [] };
- $provide.value('state', state);
- $compileProvider.directive({
- first: valueFn({
- priority: 1,
- compile: function(templateElement, templateAttr) {
- return function(scope, element, attr) {
- state.first.push({
- template: {element: templateElement, attr:templateAttr},
- link: {element: element, attr: attr}
- });
- }
- }
- }),
- second: valueFn({
- priority: 2,
- compile: function(templateElement, templateAttr) {
- return function(scope, element, attr) {
- state.second.push({
- template: {element: templateElement, attr:templateAttr},
- link: {element: element, attr: attr}
- });
- }
- }
- })
- });
- });
- inject(function($rootScope, $compile, state) {
- var template = $compile('');
- dealoc(template($rootScope.$new(), noop));
- dealoc(template($rootScope.$new(), noop));
-
- // instance between directives should be shared
- expect(state.first[0].template.element).toBe(state.second[0].template.element);
- expect(state.first[0].template.attr).toBe(state.second[0].template.attr);
-
- // the template and the link can not be the same instance
- expect(state.first[0].template.element).not.toBe(state.first[0].link.element);
- expect(state.first[0].template.attr).not.toBe(state.first[0].link.attr);
-
- // each new template needs to be new instance
- expect(state.first[0].link.element).not.toBe(state.first[1].link.element);
- expect(state.first[0].link.attr).not.toBe(state.first[1].link.attr);
- expect(state.second[0].link.element).not.toBe(state.second[1].link.element);
- expect(state.second[0].link.attr).not.toBe(state.second[1].link.attr);
- });
- });
-
-
- describe('$set', function() {
- var attr;
- beforeEach(function(){
- module(function($compileProvider) {
- $compileProvider.directive('input', valueFn({
- restrict: 'ECA',
- link: function(scope, element, attr) {
- scope.attr = attr;
- }
- }));
- });
- inject(function($compile, $rootScope) {
- element = $compile('')($rootScope);
- attr = $rootScope.attr;
- expect(attr).toBeDefined();
- });
- });
-
-
- it('should set attributes', function() {
- attr.$set('ngMyAttr', 'value');
- expect(element.attr('ng-my-attr')).toEqual('value');
- expect(attr.ngMyAttr).toEqual('value');
- });
-
-
- it('should allow overriding of attribute name and remember the name', function() {
- attr.$set('ngOther', '123', true, 'other');
- expect(element.attr('other')).toEqual('123');
- expect(attr.ngOther).toEqual('123');
-
- attr.$set('ngOther', '246');
- expect(element.attr('other')).toEqual('246');
- expect(attr.ngOther).toEqual('246');
- });
-
-
- it('should remove attribute', function() {
- attr.$set('ngMyAttr', 'value');
- expect(element.attr('ng-my-attr')).toEqual('value');
-
- attr.$set('ngMyAttr', undefined);
- expect(element.attr('ng-my-attr')).toBe(undefined);
-
- attr.$set('ngMyAttr', 'value');
- attr.$set('ngMyAttr', null);
- expect(element.attr('ng-my-attr')).toBe(undefined);
- });
-
-
- it('should not set DOM element attr if writeAttr false', function() {
- attr.$set('test', 'value', false);
-
- expect(element.attr('test')).toBeUndefined();
- expect(attr.test).toBe('value');
- });
- });
- });
-
-
- describe('locals', function() {
- it('should marshal to locals', function() {
- module(function($compileProvider) {
- $compileProvider.directive('widget', function(log) {
- return {
- scope: {
- attr: 'attribute',
- prop: 'evaluate',
- bind: 'bind',
- assign: 'accessor',
- read: 'accessor',
- exp: 'expression',
- nonExist: 'accessor',
- nonExistExpr: 'expression'
- },
- link: function(scope, element, attrs) {
- scope.nonExist(); // noop
- scope.nonExist(123); // noop
- scope.nonExistExpr(); // noop
- scope.nonExistExpr(123); // noop
- log(scope.attr);
- log(scope.prop);
- log(scope.assign());
- log(scope.read());
- log(scope.assign('ng'));
- scope.exp({myState:'OK'});
- expect(function() { scope.read(undefined); }).
- toThrow("Expression ''D'' not assignable.");
- scope.$watch('bind', log);
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- $rootScope.myProp = 'B';
- $rootScope.bi = {nd: 'C'};
- $rootScope.name = 'C';
- element = $compile(
- '')
- ($rootScope);
- expect(log).toEqual('A; B; C; D; ng');
- expect($rootScope.name).toEqual('ng');
- expect($rootScope.state).toEqual('OK');
- log.reset();
- $rootScope.$apply();
- expect(element.text()).toEqual('C');
- expect(log).toEqual('C');
- $rootScope.bi.nd = 'c';
- $rootScope.$apply();
- expect(log).toEqual('C; c');
- });
- });
- });
-
-
- describe('controller', function() {
- it('should inject locals to controller', function() {
- module(function($compileProvider) {
- $compileProvider.directive('widget', function(log) {
- return {
- controller: function(attr, prop, assign, read, exp){
- log(attr);
- log(prop);
- log(assign());
- log(read());
- log(assign('ng'));
- exp();
- expect(function() { read(undefined); }).
- toThrow("Expression ''D'' not assignable.");
- this.result = 'OK';
- },
- inject: {
- attr: 'attribute',
- prop: 'evaluate',
- assign: 'accessor',
- read: 'accessor',
- exp: 'expression'
- },
- link: function(scope, element, attrs, controller) {
- log(controller.result);
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- $rootScope.myProp = 'B';
- $rootScope.bi = {nd: 'C'};
- $rootScope.name = 'C';
- element = $compile(
- '')
- ($rootScope);
- expect(log).toEqual('A; B; C; D; ng; OK');
- expect($rootScope.name).toEqual('ng');
- });
- });
-
-
- it('should get required controller', function() {
- module(function($compileProvider) {
- $compileProvider.directive('main', function(log) {
- return {
- priority: 2,
- controller: function() {
- this.name = 'main';
- },
- link: function(scope, element, attrs, controller) {
- log(controller.name);
- }
- };
- });
- $compileProvider.directive('dep', function(log) {
- return {
- priority: 1,
- require: 'main',
- link: function(scope, element, attrs, controller) {
- log('dep:' + controller.name);
- }
- };
- });
- $compileProvider.directive('other', function(log) {
- return {
- link: function(scope, element, attrs, controller) {
- log(!!controller); // should be false
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- element = $compile('')($rootScope);
- expect(log).toEqual('main; dep:main; false');
- });
- });
-
-
- it('should require controller on parent element',function() {
- module(function($compileProvider) {
- $compileProvider.directive('main', function(log) {
- return {
- controller: function() {
- this.name = 'main';
- }
- };
- });
- $compileProvider.directive('dep', function(log) {
- return {
- require: '^main',
- link: function(scope, element, attrs, controller) {
- log('dep:' + controller.name);
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- element = $compile('')
- ($rootScope);
- $rootScope.$apply();
- expect(log).toEqual('compile: ; HIGH; link; LOG; LOG');
- expect(element.text()).toEqual('001-002;001-003;');
- });
- });
-
-
- it('should support transclude directive', function() {
- module(function($compileProvider) {
- $compileProvider.directive('trans', function() {
- return {
- transclude: 'content',
- replace: true,
- scope: true,
- template: '')
- ($rootScope);
- $rootScope.$apply();
- expect(element.text()).toEqual('W:001-002;T:001-003;');
- expect(jqLite(element.find('span')[0]).text()).toEqual('T:001-003');
- expect(jqLite(element.find('span')[1]).text()).toEqual(';');
- });
- });
-
-
- it('should transclude transcluded content', function() {
- module(function($compileProvider) {
- $compileProvider.directive('book', valueFn({
- transclude: 'content',
- template: '
'
- }));
- return function($httpBackend) {
- $httpBackend.
- expect('GET', 'chapter.html').
- respond('{{bind}}
{{bind}}
')($rootScope);
- expect(log).toEqual('dep:main');
- });
- });
-
-
- it('should have optional controller on current element', function() {
- module(function($compileProvider) {
- $compileProvider.directive('dep', function(log) {
- return {
- require: '?main',
- link: function(scope, element, attrs, controller) {
- log('dep:' + !!controller);
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- element = $compile('
')($rootScope);
- expect(log).toEqual('dep:false');
- });
- });
-
-
- it('should support multiple controllers', function() {
- module(function($compileProvider) {
- $compileProvider.directive('c1', valueFn({
- controller: function() { this.name = 'c1'; }
- }));
- $compileProvider.directive('c2', valueFn({
- controller: function() { this.name = 'c2'; }
- }));
- $compileProvider.directive('dep', function(log) {
- return {
- require: ['^c1', '^c2'],
- link: function(scope, element, attrs, controller) {
- log('dep:' + controller[0].name + '-' + controller[1].name);
- }
- };
- });
- });
- inject(function(log, $compile, $rootScope) {
- element = $compile('
')($rootScope);
- expect(log).toEqual('dep:c1-c2');
- });
-
- });
- });
-
-
- describe('transclude', function() {
- it('should compile get templateFn', function() {
- module(function($compileProvider) {
- $compileProvider.directive('trans', function(log) {
- return {
- transclude: 'element',
- priority: 2,
- controller: function($transclude) { this.$transclude = $transclude; },
- compile: function(element, attrs, template) {
- log('compile: ' + angular.mock.dump(element));
- return function(scope, element, attrs, ctrl) {
- log('link');
- var cursor = element;
- template(scope.$new(), function(clone) {cursor.after(cursor = clone)});
- ctrl.$transclude(function(clone) {cursor.after(clone)});
- };
- }
- }
- });
- });
- inject(function(log, $rootScope, $compile) {
- element = $compile('
{{$parent.$id}}-{{$id}};
- W:{{$parent.$id}}-{{$id}};
T:{{$parent.$id}}-{{$id}};
book-
'
- }));
- $compileProvider.directive('chapter', valueFn({
- transclude: 'content',
- templateUrl: 'chapter.html'
- }));
- $compileProvider.directive('section', valueFn({
- transclude: 'content',
- template: '()
section-!!
chapter-
');
- }
- });
- inject(function(log, $rootScope, $compile, $httpBackend) {
- element = $compile('[]
paragraph
Hello: {{name}}!
user: {{username}}
beforeafter
').contents();
- expect(element.length).toEqual(3);
- expect(nodeName_(element[1])).toBe('DIV');
- $compile(element)($rootScope);
- expect(nodeName_(element[1])).toBe('#comment');
- expect(nodeName_(comment)).toBe('#comment');
- });
- });
- });
-});
diff --git a/test/service/controllerSpec.js b/test/service/controllerSpec.js
deleted file mode 100644
index 91389013..00000000
--- a/test/service/controllerSpec.js
+++ /dev/null
@@ -1,73 +0,0 @@
-'use strict';
-
-describe('$controller', function() {
- var $controllerProvider, $controller;
-
- beforeEach(module(function(_$controllerProvider_) {
- $controllerProvider = _$controllerProvider_;
- }));
-
-
- beforeEach(inject(function(_$controller_) {
- $controller = _$controller_;
- }));
-
-
- describe('provider', function() {
-
- it('should allow registration of controllers', function() {
- var FooCtrl = function($scope) { $scope.foo = 'bar' },
- scope = {},
- ctrl;
-
- $controllerProvider.register('FooCtrl', FooCtrl);
- ctrl = $controller('FooCtrl', {$scope: scope});
-
- expect(scope.foo).toBe('bar');
- expect(ctrl instanceof FooCtrl).toBe(true);
- });
-
-
- it('should allow registration of controllers annotated with arrays', function() {
- var FooCtrl = function($scope) { $scope.foo = 'bar' },
- scope = {},
- ctrl;
-
- $controllerProvider.register('FooCtrl', ['$scope', FooCtrl]);
- ctrl = $controller('FooCtrl', {$scope: scope});
-
- expect(scope.foo).toBe('bar');
- expect(ctrl instanceof FooCtrl).toBe(true);
- });
- });
-
-
- it('should return instance of given controller class', function() {
- var MyClass = function() {},
- ctrl = $controller(MyClass);
-
- expect(ctrl).toBeDefined();
- expect(ctrl instanceof MyClass).toBe(true);
- });
-
- it('should inject arguments', inject(function($http) {
- var MyClass = function($http) {
- this.$http = $http;
- };
-
- var ctrl = $controller(MyClass);
- expect(ctrl.$http).toBe($http);
- }));
-
-
- it('should inject given scope', function() {
- var MyClass = function($scope) {
- this.$scope = $scope;
- };
-
- var scope = {},
- ctrl = $controller(MyClass, {$scope: scope});
-
- expect(ctrl.$scope).toBe(scope);
- });
-});
diff --git a/test/service/cookieStoreSpec.js b/test/service/cookieStoreSpec.js
deleted file mode 100644
index 50ac7797..00000000
--- a/test/service/cookieStoreSpec.js
+++ /dev/null
@@ -1,30 +0,0 @@
-'use strict';
-
-describe('$cookieStore', function() {
-
-
- it('should serialize objects to json', inject(function($cookieStore, $browser, $rootScope) {
- $cookieStore.put('objectCookie', {id: 123, name: 'blah'});
- $rootScope.$digest();
- expect($browser.cookies()).toEqual({'objectCookie': '{"id":123,"name":"blah"}'});
- }));
-
-
- it('should deserialize json to object', inject(function($cookieStore, $browser) {
- $browser.cookies('objectCookie', '{"id":123,"name":"blah"}');
- $browser.poll();
- expect($cookieStore.get('objectCookie')).toEqual({id: 123, name: 'blah'});
- }));
-
-
- it('should delete objects from the store when remove is called', inject(function($cookieStore, $browser, $rootScope) {
- $cookieStore.put('gonner', { "I'll":"Be Back"});
- $rootScope.$digest(); //force eval in test
- $browser.poll();
- expect($browser.cookies()).toEqual({'gonner': '{"I\'ll":"Be Back"}'});
-
- $cookieStore.remove('gonner');
- $rootScope.$digest();
- expect($browser.cookies()).toEqual({});
- }));
-});
diff --git a/test/service/cookiesSpec.js b/test/service/cookiesSpec.js
deleted file mode 100644
index 5427ac36..00000000
--- a/test/service/cookiesSpec.js
+++ /dev/null
@@ -1,97 +0,0 @@
-'use strict';
-
-describe('$cookies', function() {
- beforeEach(module(function($provide) {
- $provide.factory('$browser', function(){
- return angular.extend(new angular.mock.$Browser(), {cookieHash: {preexisting:'oldCookie'}});
- });
- }));
-
-
- it('should provide access to existing cookies via object properties and keep them in sync',
- inject(function($cookies, $browser, $rootScope) {
- expect($cookies).toEqual({'preexisting': 'oldCookie'});
-
- // access internal cookie storage of the browser mock directly to simulate behavior of
- // document.cookie
- $browser.cookieHash['brandNew'] = 'cookie';
- $browser.poll();
-
- expect($cookies).toEqual({'preexisting': 'oldCookie', 'brandNew':'cookie'});
-
- $browser.cookieHash['brandNew'] = 'cookie2';
- $browser.poll();
- expect($cookies).toEqual({'preexisting': 'oldCookie', 'brandNew':'cookie2'});
-
- delete $browser.cookieHash['brandNew'];
- $browser.poll();
- expect($cookies).toEqual({'preexisting': 'oldCookie'});
- }));
-
-
- it('should create or update a cookie when a value is assigned to a property',
- inject(function($cookies, $browser, $rootScope) {
- $cookies.oatmealCookie = 'nom nom';
- $rootScope.$digest();
-
- expect($browser.cookies()).
- toEqual({'preexisting': 'oldCookie', 'oatmealCookie':'nom nom'});
-
- $cookies.oatmealCookie = 'gone';
- $rootScope.$digest();
-
- expect($browser.cookies()).
- toEqual({'preexisting': 'oldCookie', 'oatmealCookie': 'gone'});
- }));
-
-
- it('should drop or reset any cookie that was set to a non-string value',
- inject(function($cookies, $browser, $rootScope) {
- $cookies.nonString = [1, 2, 3];
- $cookies.nullVal = null;
- $cookies.undefVal = undefined;
- $cookies.preexisting = function() {};
- $rootScope.$digest();
- expect($browser.cookies()).toEqual({'preexisting': 'oldCookie'});
- expect($cookies).toEqual({'preexisting': 'oldCookie'});
- }));
-
-
- it('should remove a cookie when a $cookies property is deleted',
- inject(function($cookies, $browser, $rootScope) {
- $cookies.oatmealCookie = 'nom nom';
- $rootScope.$digest();
- $browser.poll();
- expect($browser.cookies()).
- toEqual({'preexisting': 'oldCookie', 'oatmealCookie':'nom nom'});
-
- delete $cookies.oatmealCookie;
- $rootScope.$digest();
-
- expect($browser.cookies()).toEqual({'preexisting': 'oldCookie'});
- }));
-
-
- it('should drop or reset cookies that browser refused to store',
- inject(function($cookies, $browser, $rootScope) {
- var i, longVal;
-
- for (i=0; i<5000; i++) {
- longVal += '*';
- }
-
- //drop if no previous value
- $cookies.longCookie = longVal;
- $rootScope.$digest();
- expect($cookies).toEqual({'preexisting': 'oldCookie'});
-
-
- //reset if previous value existed
- $cookies.longCookie = 'shortVal';
- $rootScope.$digest();
- expect($cookies).toEqual({'preexisting': 'oldCookie', 'longCookie': 'shortVal'});
- $cookies.longCookie = longVal;
- $rootScope.$digest();
- expect($cookies).toEqual({'preexisting': 'oldCookie', 'longCookie': 'shortVal'});
- }));
-});
diff --git a/test/service/deferSpec.js b/test/service/deferSpec.js
deleted file mode 100644
index 48c9e912..00000000
--- a/test/service/deferSpec.js
+++ /dev/null
@@ -1,113 +0,0 @@
-'use strict';
-
-describe('$defer', function() {
- beforeEach(module(function($provide) {
- $provide.factory('$exceptionHandler', function(){
- return jasmine.createSpy('$exceptionHandler');
- });
- }));
-
-
- it('should delegate functions to $browser.defer', inject(function($defer, $browser, $exceptionHandler) {
- var counter = 0;
- $defer(function() { counter++; });
-
- expect(counter).toBe(0);
-
- $browser.defer.flush();
- expect(counter).toBe(1);
-
- expect(function() {$browser.defer.flush();}).toThrow('No deferred tasks to be flushed');
- expect(counter).toBe(1);
-
- expect($exceptionHandler).not.toHaveBeenCalled();
- }));
-
-
- it('should delegate exception to the $exceptionHandler service', inject(function($defer, $browser, $exceptionHandler) {
- $defer(function() {throw "Test Error";});
- expect($exceptionHandler).not.toHaveBeenCalled();
-
- $browser.defer.flush();
- expect($exceptionHandler).toHaveBeenCalledWith("Test Error");
- }));
-
-
- it('should call $apply after each callback is executed', inject(function($defer, $browser, $rootScope) {
- var applySpy = this.spyOn($rootScope, '$apply').andCallThrough();
-
- $defer(function() {});
- expect(applySpy).not.toHaveBeenCalled();
-
- $browser.defer.flush();
- expect(applySpy).toHaveBeenCalled();
-
- applySpy.reset(); //reset the spy;
-
- $defer(function() {});
- $defer(function() {});
- $browser.defer.flush();
- expect(applySpy.callCount).toBe(2);
- }));
-
-
- it('should call $apply even if an exception is thrown in callback', inject(function($defer, $browser, $rootScope) {
- var applySpy = this.spyOn($rootScope, '$apply').andCallThrough();
-
- $defer(function() {throw "Test Error";});
- expect(applySpy).not.toHaveBeenCalled();
-
- $browser.defer.flush();
- expect(applySpy).toHaveBeenCalled();
- }));
-
-
- it('should allow you to specify the delay time', inject(function($defer, $browser) {
- var defer = this.spyOn($browser, 'defer');
- $defer(noop, 123);
- expect(defer.callCount).toEqual(1);
- expect(defer.mostRecentCall.args[1]).toEqual(123);
- }));
-
-
- it('should return a cancelation token', inject(function($defer, $browser) {
- var defer = this.spyOn($browser, 'defer').andReturn('xxx');
- expect($defer(noop)).toEqual('xxx');
- }));
-
-
- describe('cancel', function() {
- it('should cancel tasks', inject(function($defer, $browser) {
- var task1 = jasmine.createSpy('task1'),
- task2 = jasmine.createSpy('task2'),
- task3 = jasmine.createSpy('task3'),
- token1, token3;
-
- token1 = $defer(task1);
- $defer(task2);
- token3 = $defer(task3, 333);
-
- $defer.cancel(token3);
- $defer.cancel(token1);
- $browser.defer.flush();
-
- expect(task1).not.toHaveBeenCalled();
- expect(task2).toHaveBeenCalledOnce();
- expect(task3).not.toHaveBeenCalled();
- }));
-
-
- it('should return true if a task was succesffuly canceled', inject(function($defer, $browser) {
- var task1 = jasmine.createSpy('task1'),
- task2 = jasmine.createSpy('task2'),
- token1, token2;
-
- token1 = $defer(task1);
- $browser.defer.flush();
- token2 = $defer(task2);
-
- expect($defer.cancel(token1)).toBe(false);
- expect($defer.cancel(token2)).toBe(true);
- }));
- });
-});
diff --git a/test/service/documentSpec.js b/test/service/documentSpec.js
deleted file mode 100644
index 064904a2..00000000
--- a/test/service/documentSpec.js
+++ /dev/null
@@ -1,9 +0,0 @@
-'use strict';
-
-describe('$document', function() {
-
-
- it("should inject $document", inject(function($document) {
- expect($document).toEqual(jqLite(document));
- }));
-});
diff --git a/test/service/exceptionHandlerSpec.js b/test/service/exceptionHandlerSpec.js
deleted file mode 100644
index 3f3dd800..00000000
--- a/test/service/exceptionHandlerSpec.js
+++ /dev/null
@@ -1,24 +0,0 @@
-'use strict';
-
-describe('$exceptionHandler', function() {
- it('should log errors with single argument', function() {
- module(function($provide){
- $provide.provider('$exceptionHandler', $ExceptionHandlerProvider);
- });
- inject(function($log, $exceptionHandler) {
- $exceptionHandler('myError');
- expect($log.error.logs.shift()).toEqual(['myError']);
- });
- });
-
-
- it('should log errors with multiple arguments', function() {
- module(function($provide){
- $provide.provider('$exceptionHandler', $ExceptionHandlerProvider);
- });
- inject(function($log, $exceptionHandler) {
- $exceptionHandler('myError', 'comment');
- expect($log.error.logs.shift()).toEqual(['myError', 'comment']);
- });
- });
-});
diff --git a/test/service/filter/filterSpec.js b/test/service/filter/filterSpec.js
deleted file mode 100644
index a33358d0..00000000
--- a/test/service/filter/filterSpec.js
+++ /dev/null
@@ -1,69 +0,0 @@
-'use strict';
-
-describe('Filter: filter', function() {
- var filter;
-
- beforeEach(inject(function($filter){
- filter = $filter('filter');
- }));
-
- it('should filter by string', function() {
- var items = ['MIsKO', {name: 'shyam'}, ['adam'], 1234];
- expect(filter(items, '').length).toBe(4);
- expect(filter(items, undefined).length).toBe(4);
-
- expect(filter(items, 'iSk').length).toBe(1);
- expect(filter(items, 'isk')[0]).toBe('MIsKO');
-
- expect(filter(items, 'yam').length).toBe(1);
- expect(filter(items, 'yam')[0]).toEqual(items[1]);
-
- expect(filter(items, 'da').length).toBe(1);
- expect(filter(items, 'da')[0]).toEqual(items[2]);
-
- expect(filter(items, '34').length).toBe(1);
- expect(filter(items, '34')[0]).toBe(1234);
-
- expect(filter(items, "I don't exist").length).toBe(0);
- });
-
- it('should not read $ properties', function() {
- expect(''.charAt(0)).toBe(''); // assumption
-
- var items = [{$name: 'misko'}];
- expect(filter(items, 'misko').length).toBe(0);
- });
-
- it('should filter on specific property', function() {
- var items = [{ignore: 'a', name: 'a'}, {ignore: 'a', name: 'abc'}];
- expect(filter(items, {}).length).toBe(2);
-
- expect(filter(items, {name: 'a'}).length).toBe(2);
-
- expect(filter(items, {name: 'b'}).length).toBe(1);
- expect(filter(items, {name: 'b'})[0].name).toBe('abc');
- });
-
- it('should take function as predicate', function() {
- var items = [{name: 'a'}, {name: 'abc', done: true}];
- expect(filter(items, function(i) {return i.done;}).length).toBe(1);
- });
-
- it('should take object as perdicate', function() {
- var items = [{first: 'misko', last: 'hevery'},
- {first: 'adam', last: 'abrons'}];
-
- expect(filter(items, {first:'', last:''}).length).toBe(2);
- expect(filter(items, {first:'', last:'hevery'}).length).toBe(1);
- expect(filter(items, {first:'adam', last:'hevery'}).length).toBe(0);
- expect(filter(items, {first:'misko', last:'hevery'}).length).toBe(1);
- expect(filter(items, {first:'misko', last:'hevery'})[0]).toEqual(items[0]);
- });
-
- it('should support negation operator', function() {
- var items = ['misko', 'adam'];
-
- expect(filter(items, '!isk').length).toBe(1);
- expect(filter(items, '!isk')[0]).toEqual(items[1]);
- });
-});
diff --git a/test/service/filter/filtersSpec.js b/test/service/filter/filtersSpec.js
deleted file mode 100644
index 98651c58..00000000
--- a/test/service/filter/filtersSpec.js
+++ /dev/null
@@ -1,280 +0,0 @@
-'use strict';
-
-describe('filters', function() {
-
- var filter;
-
- beforeEach(inject(function($filter){
- filter = $filter;
- }));
-
- it('should call the filter when evaluating expression', function(){
- var filter = jasmine.createSpy('myFilter');
- createInjector(['ng', function($filterProvider) {
- $filterProvider.register('myFilter', valueFn(filter));
- }]).invoke(function($rootScope) {
- $rootScope.$eval('10|myFilter');
- });
- expect(filter).toHaveBeenCalledWith(10);
- });
-
- describe('formatNumber', function() {
- var pattern;
-
- beforeEach(function() {
- pattern = { minInt: 1,
- minFrac: 0,
- maxFrac: 3,
- posPre: '',
- posSuf: '',
- negPre: '-',
- negSuf: '',
- gSize: 3,
- lgSize: 3 };
- });
-
- it('should format according to different patterns', function() {
- pattern.gSize = 2;
- var num = formatNumber(1234567.89, pattern, ',', '.');
- expect(num).toBe('12,34,567.89');
- num = formatNumber(1234.56, pattern, ',', '.');
- expect(num).toBe('1,234.56');
-
- pattern.negPre = '(';
- pattern.negSuf = '-)';
- num = formatNumber(-1234, pattern, ',', '.');
- expect(num).toBe('(1,234-)');
- pattern.posPre = '+';
- pattern.posSuf = '+';
- num = formatNumber(1234, pattern, ',', '.');
- expect(num).toBe('+1,234+');
- pattern.posPre = pattern.posSuf = '';
-
- pattern.minFrac = 2;
- num = formatNumber(1, pattern, ',', '.');
- expect(num).toBe('1.00');
- pattern.maxFrac = 4;
- num = formatNumber(1.11119, pattern, ',', '.');
- expect(num).toBe('1.1112');
- });
-
- it('should format according different seperators', function() {
- var num = formatNumber(1234567.1, pattern, '.', ',', 2);
- expect(num).toBe('1.234.567,10');
- });
-
- it('should format with or without fractionSize', function() {
- var num = formatNumber(123.1, pattern, ',', '.', 3);
- expect(num).toBe('123.100');
- num = formatNumber(123.12, pattern, ',', '.');
- expect(num).toBe('123.12');
- var num = formatNumber(123.1116, pattern, ',', '.');
- expect(num).toBe('123.112');
- });
- });
-
- describe('currency', function() {
- var currency;
-
- beforeEach(function() {
- currency = filter('currency');
- });
-
- it('should do basic currency filtering', function() {
- expect(currency(0)).toEqual('$0.00');
- expect(currency(-999)).toEqual('($999.00)');
- expect(currency(1234.5678, "USD$")).toEqual('USD$1,234.57');
- });
-
-
- it('should return empty string for non-numbers', function() {
- expect(currency()).toBe('');
- expect(currency('abc')).toBe('');
- });
- });
-
-
- describe('number', function() {
- var number;
-
- beforeEach(inject(function($rootScope) {
- number = filter('number');
- }));
-
-
- it('should do basic filter', function() {
- expect(number(0, 0)).toEqual('0');
- expect(number(-999)).toEqual('-999');
- expect(number(123)).toEqual('123');
- expect(number(1234567)).toEqual('1,234,567');
- expect(number(1234)).toEqual('1,234');
- expect(number(1234.5678)).toEqual('1,234.568');
- expect(number(Number.NaN)).toEqual('');
- expect(number("1234.5678")).toEqual('1,234.568');
- expect(number(1/0)).toEqual("");
- expect(number(1, 2)).toEqual("1.00");
- expect(number(.1, 2)).toEqual("0.10");
- expect(number(.01, 2)).toEqual("0.01");
- expect(number(.001, 3)).toEqual("0.001");
- expect(number(.0001, 3)).toEqual("0.000");
- expect(number(9, 2)).toEqual("9.00");
- expect(number(.9, 2)).toEqual("0.90");
- expect(number(.99, 2)).toEqual("0.99");
- expect(number(.999, 3)).toEqual("0.999");
- expect(number(.9999, 3)).toEqual("1.000");
- expect(number(1234.567, 0)).toEqual("1,235");
- expect(number(1234.567, 1)).toEqual("1,234.6");
- expect(number(1234.567, 2)).toEqual("1,234.57");
- });
-
- it('should filter exponential numbers', function() {
- expect(number(1e50, 0)).toEqual('1e+50');
- expect(number(-2e50, 2)).toEqual('-2e+50');
- });
- });
-
- describe('json', function () {
- it('should do basic filter', function() {
- expect(filter('json')({a:"b"})).toEqual(toJson({a:"b"}, true));
- });
- });
-
- describe('lowercase', function() {
- it('should do basic filter', function() {
- expect(filter('lowercase')('AbC')).toEqual('abc');
- expect(filter('lowercase')(null)).toBeNull();
- });
- });
-
- describe('uppercase', function() {
- it('should do basic filter', function() {
- expect(filter('uppercase')('AbC')).toEqual('ABC');
- expect(filter('uppercase')(null)).toBeNull();
- });
- });
-
- describe('linky', function() {
- var linky;
-
- beforeEach(inject(function($filter){
- linky = $filter('linky')
- }));
-
- it('should do basic filter', function() {
- expect(linky("http://ab/ (http://a/)