Hopiu/angular.js
1
0
Fork 0
mirror of https://github.com/Hopiu/angular.js.git synced 2026-03-16 23:30:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

doc(AUTO, NG_MOCK): Documenting the AUTO and NG_MOCK module

Browse source
This commit is contained in:
Misko Hevery 2011-11-09 21:18:34 -08:00
parent c283bf6035
commit f0fa5e6376
28 changed files with 625 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
docs/content/api/angular.module.NG.ngdoc Normal file
View file

@ -0,0 +1,5 @@
@ngdoc overview
@name angular.module.NG
@description
The `NG` is an angular module which contains all of the core angular services.

54
docs/content/api/angular.module.ngdoc Normal file
View file

@ -0,0 +1,54 @@
@ngdoc overview
@name angular.module
@description
The angular.module namespace is a global place for registering angular modules. All modules
(angular core or 3rd party) that should be available to an application must be registered in this
namespace.
# Module
A module is a function that is used to register new service providers and configure existing
providers. Once a provider is registered, {@link angular.module.AUTO.$injector $injector} will use
it to ask for a service instance when it is resolving a dependency for the first time.
<pre>
// Declare the module configuration function.
// The function arguments are fully injectable so that the module function
// can create new providers or configure existing ones.
function MyModule($provide, $locationProvider){
// see $provide for more information.
$provide.value('appName', 'MyCoolApp');
// Configure existing providers
$locationProvider.hashPrefix = '!';
};
</pre>
See: {@link angular.module.NG.$provide $provide}, {@link angular.module.NG.$locationProvider $locationProvider}.
# Registering Module Function
In your JavaScript file:
<pre>
// Create the angular.module namespace if one does not exist
// This allows the module code to be loaded before angular.js code.
if (!window.angular) window.angular = {};
if (!angular.module) angular.module = {};
angular.module.MyModule = function(){
// add configuration code here.
};
</pre>
Then you can refer to your module like this:
<pre>
var injector = angular.injector('NG', 'MyModule')
</pre>
Or
<pre>
var injector = angular.injector('NG', angular.module.MyModule)
</pre>

2
docs/spec/domSpec.js
View file

@ -24,7 +24,7 @@ describe('dom', function() {
dom.h('heading', function() {
this.html('<h1>sub-heading</h1>');
});
expect(dom.toString()).toContain('<h1>heading</h1>');
expect(dom.toString()).toContain('<h1 id="heading">heading</h1>');
expect(dom.toString()).toContain('<h2>sub-heading</h2>');
});

2
docs/spec/ngdocSpec.js
View file

@ -528,7 +528,7 @@ describe('ngdoc', function() {
returns: {type: 'number', description: 'return desc'}
});
doc.html_usage_function(dom);
expect(dom).toContain('some.name([a][, b], c)'); //TODO(i) the comma position here is lame
expect(dom).toContain('name([a][, b], c)'); //TODO(i) the comma position here is lame
expect(dom).toContain('param desc');
expect(dom).toContain('(optional="xxx")');
expect(dom).toContain('return desc');

16
docs/src/dom.js
View file

@ -77,10 +77,18 @@ DOM.prototype = {
h: function(heading, content, fn){
if (content==undefined || (content instanceof Array && content.length == 0)) return;
this.headingDepth++;
this.tag('h' + this.headingDepth, heading);
var className = typeof heading == 'string'
? {'class': heading.toLowerCase().replace(/[^\d\w_]/mg, '-').replace(/-+/gm, '-')}
: null;
var className = null,
anchor = null;
if (typeof heading == 'string') {
var id = heading.
replace(/\(.*\)/mg, '').
replace(/[^\d\w]/mg, '.').
replace(/-+/gm, '-').
replace(/-*$/gm, '');
anchor = {'id': id};
className = {'class': id.toLowerCase().replace(/[._]/mg, '-')};
}
this.tag('h' + this.headingDepth, anchor, heading);
if (content instanceof Array) {
this.ul(content, className, fn);
} else if (fn) {

26
docs/src/ngdoc.js
View file

@ -89,6 +89,7 @@ Doc.prototype = {
var self = this,
IS_URL = /^(https?:\/\/|ftps?:\/\/|mailto:|\.|\/)/,
IS_ANGULAR = /^(api\/)?angular\./,
IS_HASH = /^#/,
parts = trim(text).split(/(<pre>[\s\S]*?<\/pre>|<doc:(\S*).*?>[\s\S]*?<\/doc:\2>)/);
parts.forEach(function(text, i) {
@ -134,13 +135,16 @@ Doc.prototype = {
function(_all, url, title){
var isFullUrl = url.match(IS_URL),
isAngular = url.match(IS_ANGULAR),
absUrl = isFullUrl ? url : self.convertUrlToAbsolute(url);
isHash = url.match(IS_HASH),
absUrl = isHash
? url
: (isFullUrl ? url : self.convertUrlToAbsolute(url));
if (!isFullUrl) self.links.push(absUrl);
return '<a href="' + absUrl + '">' +
(isAngular ? '<code>' : '') +
(title || url).replace(/\n/g, ' ') +
(title || url.replace(/^#/g, '')).replace(/\n/g, ' ') +
(isAngular ? '</code>' : '') +
'</a>';
});
@ -171,7 +175,8 @@ Doc.prototype = {
}
});
flush();
this.shortName = (this.name || '').split(/[\.#]/).pop();
this.name = this.name || '';
this.shortName = this.name.split(this.name.match(/#/) ? /#/ : /\./ ).pop();
this.id = this.id || // if we have an id just use it
(((this.file||'').match(/.*\/([^\/]*)\.ngdoc/)||{})[1]) || // try to extract it from file name
this.name; // default to name
@ -319,7 +324,7 @@ Doc.prototype = {
var self = this;
dom.h('Usage', function() {
dom.code(function() {
dom.text(self.name.split('service.').pop());
dom.text(self.name.split(/\./).pop());
dom.text('(');
self.parameters(dom, ', ');
dom.text(');');
@ -329,6 +334,7 @@ Doc.prototype = {
self.html_usage_this(dom);
self.html_usage_returns(dom);
});
this.method_properties_events(dom);
},
html_usage_property: function(dom){
@ -450,7 +456,7 @@ Doc.prototype = {
dom.html(this.description);
},
html_usage_service: function(dom){
html_usage_object: function(dom){
var self = this;
if (this.param.length) {
@ -467,7 +473,15 @@ Doc.prototype = {
self.html_usage_returns(dom);
});
}
this.method_properties_events(dom);
},
html_usage_service: function(dom) {
this.html_usage_object(dom)
},
method_properties_events: function(dom) {
var self = this;
dom.h('Methods', this.methods, function(method){
var signature = (method.param || []).map(property('name'));
dom.h(method.shortName + '(' + signature.join(', ') + ')', method, function() {
@ -480,7 +494,7 @@ Doc.prototype = {
});
});
dom.h('Properties', this.properties, function(property){
dom.h(property.name, function() {
dom.h(property.shortName, function() {
dom.html(property.description);
dom.h('Example', property.example, dom.html);
});

14
docs/src/templates/docs.css
View file

@ -240,23 +240,25 @@ li {
}
#content-list .level-1 {
font-size: 1.1em;
font-weight: bold;
margin-left: 0em;
}
#content-list .level-2,
#content-list .level-3 {
#content-list .level-2 {
margin-left: 1em;
}
#content-list .level-4 {
#content-list .level-3 {
margin-left: 2em;
}
#content-list .level-5 {
#content-list .level-4 {
margin-left: 3em;
}
#content-list .level-5 {
margin-left: 4em;
}
#content-list a.current {
font-weight: bold;

2
src/Browser.js
View file

@ -24,7 +24,7 @@ var XHR = window.XMLHttpRequest || function() {
* - hide all the global state in the browser caused by the window object
* - abstract away all the browser specific features and inconsistencies
*
* For tests we provide {@link angular.mock.service.$browser mock implementation} of the `$browser`
* For tests we provide {@link angular.module.NG_MOCK.$browser mock implementation} of the `$browser`
* service, which can be used for convenient testing of the application without the interaction with
* the real browser apis.
*/

247
src/Injector.js
View file

@ -9,37 +9,35 @@
* Creates an injector function that can be used for retrieving services as well as for
* dependency injection (see {@link guide/dev_guide.di dependency injection}).
*
* Creating an injector doesn't automatically create all of the `$eager`
* {@link angular.service services}. You have to call `injector.eager()` to initialize them.
* @param {<string, function()>} modules... A list of module functions or their aliases. See
* {@link angular.module}. The `NG` module must be explicitly added.
* @returns {function()} Injector function. See {@link angular.module.AUTO.$injector $injector}.
*
* @param {Object.<string, function()>=} [factories=angular.service] Map of the service factory
* functions.
* @returns {function()} Injector function:
* @example
* Typical usage
* <pre>
* // create an injector
* var $injector = angular.injector('NG');
*
* * `injector(serviceName)`:
* * `serviceName` - `{string=}` - Name of the service to retrieve.
*
* The injector function also has these properties:
*
* * An `invoke` property which can be used to invoke methods with dependency-injected arguments.
* `injector.invoke(self, fn, locals)`
* * `self` - The "`this`" to be used when invoking the function.
* * `fn` - The function to be invoked. The function may have the `$inject` property that
* lists the set of arguments which should be auto-injected.
* (see {@link guide/dev_guide.di dependency injection}).
* * `locals(array)` - Optional array of arguments to pass to the function
* invocation after the injection arguments.
* * An `eager` property which is used to initialize the eager services.
* `injector.eager()`
* // use the injector to kick of your application
* // use the type inference to auto inject arguments, or use implicit injection
* $injector(function($rootScope, $compile, $document){
* $compile($document)($rootScope);
* $rootScope.$digest();
* });
* </pre>
*/
/**
* @returns the $inject property of function. If not found the
* the $inject is computed by looking at the toString of function and
* extracting all arguments which and assuming that they are the
* injection names.
* @ngdoc overview
* @name angular.module.AUTO
* @description
*
* Implicit module which gets automatically added to each {@link angular.module.AUTO.$injector $injector}.
*/
var FN_ARGS = /^function\s*[^\(]*\(([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(.+?)\s*$/;
@ -60,6 +58,207 @@ function inferInjectionArgs(fn) {
}
///////////////////////////////////////
/**
* @ngdoc function
* @name angular.module.AUTO.$injector
* @function
*
* @description
*
* `$injector` function is used to retrieve object instances. Object instances are defined by
* {@link angular.module.AUTO.$provide provider}.
*
* The following always holds true:
*
* <pre>
* var $injector = angular.injector();
* expect($injector('$injector')).toBe($injector);
* expect($injector(function($injector){
* return $injector;
* }).toBe($injector);
* </pre>
*
* # Injection Function Annotation
*
* JavaScript does not have annotations, and annotations are needed for dependency injection. The
* following ways are all valid way of annotating function with injection arguments and are equivalent.
*
* <pre>
* // inferred (only works if code not minified/obfuscated)
* $inject.invoke(function(serviceA){});
*
* // annotated
* function explicit(serviceA) {};
* explicit.$inject = ['serviceA'];
* $inject.invoke(explicit);
*
* // inline
* $inject.invoke(['serviceA', function(serviceA){}]);
* </pre>
*
* ## Inference
*
* In JavaScript calling `toString()` on a function returns the function definition. The definition can then be
* parsed and the function arguments can be extracted. *NOTE:* This does not work with minfication, and obfuscation
* tools since these tools change the argument names.
*
* ## `$inject` Annotation
* By adding a `$inject` property onto a function the injection parameters can be specified.
*
* ## Inline
* As an array of injection names, where the last item in the array is the function to call.
*
* @param {string, function()} argument If the `argument` is:
*
* - `string`: Retrieve an instance of a named object. If object does not exist, use the provider to create
* a new instance. Calling the method repeatedly with the same name will always return the same
* instance.
* - `function`: Invoke the function. This is a short hand for `$injector.`{@link #invoke invoke(null, argument)}.
* @return the object instance or the return value of the invoked function.
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$injector#invoke
* @methodOf angular.module.AUTO.$injector
*
* @description
* Invoke the method and supply the method arguments from the `$injector`.
*
* @param {Object} self The `this` for the invoked method.
* @param {function} fn The function to invoke. The function arguments come form the function annotation.
* @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before
* the `$injector` is consulted.
* @return the value returned by the invoked `fn` function.
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$injector#instantiate
* @methodOf angular.module.AUTO.$injector
* @description
* Create a new instance of JS type. The method takes a constructor function invokes the new operator and supplies
* all of the arguments to the constructor function as specified by the constructor annotation.
*
* @param {function} Type Annotated constructor function.
* @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before
* the `$injector` is consulted.
* @return new instance of `Type`.
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$injector#loadModule
* @methodOf angular.module.AUTO.$injector
* @description
* Load additional modules into the current injector configuration
*
* @param {Array} modules An array of modules, where module is a:
*
* - `string`: look up the module function from {@link angular.module} and then treat as `function`.
* - `function`: execute the module configuration function using
* {@link angular.module.AUTO.$injector#invoke $injector.invoke()}
*/
/**
* @ngdoc object
* @name angular.module.AUTO.$provide
*
* @description
*
* Use `$provide` to register new providers with the `$injector`. The providers are the factories for the instance.
* The providers share the same name as the instance they create with the `Provide` suffixed to them.
*
* A provider is an object with a `$get()` method. The injector calls the `$get` method to create a new instance of
* a service. The Provider can have additional methods which would allow for configuration of the provider.
*
* <pre>
* function GreetProvider() {
* var salutation = 'Hello';
*
* this.salutation = function(text) {
* salutation = text;
* };
*
* this.$get = function() {
* return function (name) {
* return salutation + ' ' + name + '!';
* };
* };
* }
*
* describe('Greeter', function(){
*
* beforeEach(inject(function($provide) {
* $provide.service('greet', GreetProvider);
* });
*
* it('should greet', inject(function(greet) {
* expect(greet('angular')).toEqual('Hello angular!');
* }));
*
* it('should allow configuration of salutation', inject(
* function(greetProvider) {
* greetProvider.salutation('Ahoj');
* },
* function(greet) {
* expect(greet('angular')).toEqual('Ahoj angular!');
* }
* )};
*
* });
* </pre>
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$provide#service
* @methodOf angular.module.AUTO.$provide
* @description
*
* Register a provider for a service. The providers can be retrieved and can have additional configuration methods.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provide'` key.
* @param {(Object|function())} provider If the provider is:
*
* - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
* {@link angular.module.AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.
* - `Constructor`: a new instance of the provider will be created using
* {@link angular.module.AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.
*
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$provide#factory
* @methodOf angular.module.AUTO.$provide
* @description
*
* A short hand for configuring services if only `$get` method is required.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provide'` key.
* @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand for
* `$provide.service(name, {$get:$getFn})`.
*/
/**
* @ngdoc method
* @name angular.module.AUTO.$provide#value
* @methodOf angular.module.AUTO.$provide
* @description
*
* A short hand for configuring services if the `$get` method is a constant.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provide'` key.
* @param {function()} value The $getFn for the instance creation. Internally this is a short hand for
* `$provide.service(name, {$get:function(){ return value; }})`.
*/
function createInjector(modulesToLoad, moduleRegistry) {
var cache = {},
$injector = internalInjector(cache),

315
src/angular-mocks.js vendored
View file

@ -6,69 +6,49 @@
*/
/*
IN THE FINAL BUILD THIS FILE DOESN'T HAVE DIRECT ACCESS TO GLOBAL FUNCTIONS
DEFINED IN Angular.js YOU *MUST* REFER TO THEM VIA angular OBJECT
(e.g. angular.forEach(...)) AND MAKE SURE THAT THE GIVEN FUNCTION IS EXPORTED
TO THE angular NAMESPACE in AngularPublic.js
*/
window.angular = window.angular || {};
angular.module = angular.module || {};
/**
* @ngdoc overview
* @name angular.mock
* @name angular.module.NG_MOCK
* @description
*
* The `angular.mock` object is a namespace for all built-in mock services that ship with angular.
* It automatically replaces real services if the `angular-mocks.js` file is loaded after
* `angular.js` and before any tests.
*
* Built-in mocks:
*
* * {@link angular.mock.service.$browser $browser } - A mock implementation of the browser.
* * {@link angular.mock.service.$exceptionHandler $exceptionHandler } - A mock implementation of
* the angular service exception handler.
* * {@link angular.mock.service.$log $log } - A mock implementation of the angular service log.
* The `NG_MOCK` is an angular module which is used with `NG` module and adds unit-test configuration as well as useful
* mocks to the {@link angular.module.AUTO.$injector $injector}.
*/
window.angular = window.angular || {};
angular.module = angular.module || {};
angular.mock = angular.mock || {};
angular.module.NG_MOCK = ['$provide', function($provide){
$provide.service('$browser', angular.mock.$BrowserProvider);
$provide.service('$exceptionHandler', angular.mock.$ExceptionHandlerProvider);
$provide.service('$log', angular.mock.$LogProvider);
}];
angular.module.NG_MOCK = function($provide){
$provide.service('$browser', angular.module.NG_MOCK.$BrowserProvider);
$provide.service('$exceptionHandler', angular.module.NG_MOCK.$ExceptionHandlerProvider);
$provide.service('$log', angular.module.NG_MOCK.$LogProvider);
};
angular.module.NG_MOCK.$inject = ['$provide'];
/**
* @ngdoc service
* @name angular.mock.service.$browser
* @ngdoc object
* @name angular.module.NG_MOCK.$browser
*
* @description
* This service is a mock implementation of {@link angular.service.$browser}. It provides fake
* This service is a mock implementation of {@link angular.module.NG.$browser}. It provides fake
* implementation for commonly used browser apis that are hard to test, e.g. setTimeout, xhr,
* cookies.
* cookies, etc...
*
* This implementation is automatically available and replaces regular `$browser` service in tests
* when `angular-mocks.js` is loaded.
*
* The api of this service is the same as the real {@link angular.service.$browser $browser}, except
* The api of this service is the same as that of the real {@link angular.module.NG.$browser $browser}, except
* that there are several helper methods available which can be used in tests.
*
* The following apis can be used in tests:
*
* - {@link angular.mock.service.$browser.xhr $browser.xhr} — enables testing of code that uses
* the {@link angular.service.$xhr $xhr service} to make XmlHttpRequests.
* - {@link #xhr} — enables testing of code that uses
* the {@link angular.module.NG.$xhr $xhr service} to make XmlHttpRequests.
* - $browser.defer — enables testing of code that uses
* {@link angular.service.$defer $defer service} for executing functions via the `setTimeout` api.
* {@link angular.module.NG.$defer $defer} for executing functions via the `setTimeout` api.
*/
angular.mock.$BrowserProvider = function(){
angular.module.NG_MOCK.$BrowserProvider = function(){
this.$get = function(){
return new angular.mock.$Browser();
return new angular.module.NG_MOCK.$Browser();
};
};
angular.mock.$Browser = function() {
angular.module.NG_MOCK.$Browser = function() {
var self = this,
expectations = {},
requests = [];
@ -96,22 +76,23 @@ angular.mock.$Browser = function() {
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Generic method for training browser to expect a request in a test and respond to it.
*
* See also convenience methods for browser training:
*
* - {@link angular.mock.service.$browser.xhr.expectGET $browser.xhr.expectGET}
* - {@link angular.mock.service.$browser.xhr.expectPOST $browser.xhr.expectPOST}
* - {@link angular.mock.service.$browser.xhr.expectPUT $browser.xhr.expectPUT}
* - {@link angular.mock.service.$browser.xhr.expectDELETE $browser.xhr.expectDELETE}
* - {@link angular.mock.service.$browser.xhr.expectJSON $browser.xhr.expectJSON}
* - {@link #xhr.expectGET}
* - {@link #xhr.expectPOST}
* - {@link #xhr.expectPUT}
* - {@link #xhr.expectDELETE}
* - {@link #xhr.expectJSON}
*
* To flush pending requests in tests use
* {@link angular.mock.service.$browser.xhr.flush $browser.xhr.flush}.
* {@link #xhr.flush}.
*
* @param {string} method Expected HTTP method.
* @param {string} url Url path for which a request is expected.
@ -120,7 +101,7 @@ angular.mock.$Browser = function() {
* @param {object} headers Key-value pairs of expected headers.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link #xhr.flush flushed}.
*/
self.xhr = function(method, url, data, callback, headers) {
headers = headers || {};
@ -158,8 +139,9 @@ angular.mock.$Browser = function() {
};
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.expectGET
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.expectGET
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Trains browser to expect a `GET` request and respond to it.
@ -167,13 +149,14 @@ angular.mock.$Browser = function() {
* @param {string} url Url path for which a request is expected.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link angular.module.NG_MOCK.$browser.xhr.flush flushed}.
*/
self.xhr.expectGET = angular.bind(self, self.xhr.expect, 'GET');
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.expectPOST
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.expectPOST
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Trains browser to expect a `POST` request and respond to it.
@ -181,13 +164,14 @@ angular.mock.$Browser = function() {
* @param {string} url Url path for which a request is expected.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link angular.module.NG_MOCK.$browser.xhr.flush flushed}.
*/
self.xhr.expectPOST = angular.bind(self, self.xhr.expect, 'POST');
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.expectDELETE
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.expectDELETE
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Trains browser to expect a `DELETE` request and respond to it.
@ -195,13 +179,14 @@ angular.mock.$Browser = function() {
* @param {string} url Url path for which a request is expected.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link angular.module.NG_MOCK.$browser.xhr.flush flushed}.
*/
self.xhr.expectDELETE = angular.bind(self, self.xhr.expect, 'DELETE');
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.expectPUT
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.expectPUT
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Trains browser to expect a `PUT` request and respond to it.
@ -209,13 +194,14 @@ angular.mock.$Browser = function() {
* @param {string} url Url path for which a request is expected.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link angular.module.NG_MOCK.$browser.xhr.flush flushed}.
*/
self.xhr.expectPUT = angular.bind(self, self.xhr.expect, 'PUT');
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.expectJSON
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.expectJSON
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Trains browser to expect a `JSON` request and respond to it.
@ -223,13 +209,14 @@ angular.mock.$Browser = function() {
* @param {string} url Url path for which a request is expected.
* @returns {object} Response configuration object. You can call its `respond()` method to
* configure what should the browser mock return when the response is
* {@link angular.mock.service.$browser.xhr.flush flushed}.
* {@link angular.module.NG_MOCK.$browser.xhr.flush flushed}.
*/
self.xhr.expectJSON = angular.bind(self, self.xhr.expect, 'JSON');
/**
* @ngdoc function
* @name angular.mock.service.$browser.xhr.flush
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#xhr.flush
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Flushes all pending requests and executes xhr callbacks with the trained response as the
@ -277,6 +264,16 @@ angular.mock.$Browser = function() {
};
/**
* @ngdoc method
* @name angular.module.NG_MOCK.$browser#defer.flush
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* Flushes all pending requests and executes the defer callbacks.
*
* @param {number=} number of miliseconds to flush. See {@link #defer.now}
*/
self.defer.flush = function(delay) {
if (angular.isDefined(delay)) {
self.defer.now += delay;
@ -290,17 +287,25 @@ angular.mock.$Browser = function() {
self.deferredFns.shift().fn();
}
};
/**
* @ngdoc property
* @name angular.module.NG_MOCK.$browser#defer.now
* @propertyOf angular.module.NG_MOCK.$browser
*
* @description
* Current milliseconds mock time.
*/
self.$$baseHref = '';
self.baseHref = function() {
return this.$$baseHref;
};
}
angular.mock.$Browser.prototype = {
angular.module.NG_MOCK.$Browser.prototype = {
/**
* @name angular.mock.service.$browser#poll
* @methodOf angular.mock.service.$browser
* @name angular.module.NG_MOCK.$browser#poll
* @methodOf angular.module.NG_MOCK.$browser
*
* @description
* run all fns in pollFns
@ -351,19 +356,45 @@ angular.mock.$Browser.prototype = {
/**
* @ngdoc service
* @name angular.mock.service.$exceptionHandler
* @ngdoc object
* @name angular.module.NG_MOCK.$exceptionHandlerProvider
*
* @description
* Mock implementation of {@link angular.service.$exceptionHandler} that rethrows any error passed
* into `$exceptionHandler`. If any errors are are passed into the handler in tests, it typically
* means that there is a bug in the application or test, so this mock will make these tests fail.
*
* See {@link angular.mock} for more info on angular mocks.
* Configures the mock implementation of {@link angular.module.NG.$exceptionHandler} to rethrow or to log errors passed
* into the `$exceptionHandler`.
*/
angular.mock.$ExceptionHandlerProvider = function(){
/**
* @ngdoc object
* @name angular.module.NG_MOCK.$exceptionHandler
*
* @description
* Mock implementation of {@link angular.module.NG.$exceptionHandler} that rethrows or logs errors passed
* into it. See {@link angular.module.NG_MOCK.$exceptionHandlerProvider $exceptionHandlerProvider} for configuration
* information.
*/
angular.module.NG_MOCK.$ExceptionHandlerProvider = function(){
var handler;
/**
* @ngdoc method
* @name angular.module.NG_MOCK.$exceptionHandlerProvider#mode
* @methodOf angular.module.NG_MOCK.$exceptionHandlerProvider
*
* @description
* Sets the logging mode.
*
* @param {string} mode Mode of operation, defaults to `rethrow`.
*
* - `rethrow`: If any errors are are passed into the handler in tests, it typically
* means that there is a bug in the application or test, so this mock will
* make these tests fail.
* - `log`: Sometimes it is desirable to test that an error is throw, for this case the `log` mode stores the
* error and allows later assertion of it.
* See {@link angular.module.NG_MOCK.$log#assertEmpty assertEmpty()} and
* {@link angular.module.NG_MOCK.$log#reset reset()}
*/
this.mode = function(mode){
switch(mode) {
case 'rethrow':
@ -393,16 +424,15 @@ angular.mock.$ExceptionHandlerProvider = function(){
/**
* @ngdoc service
* @name angular.mock.service.$log
* @name angular.module.NG_MOCK.$log
*
* @description
* Mock implementation of {@link angular.service.$log} that gathers all logged messages in arrays
* Mock implementation of {@link angular.module.NG.$log} that gathers all logged messages in arrays
* (one array per logging level). These arrays are exposed as `logs` property of each of the
* level-specific log function, e.g. for level `error` the array is exposed as `$log.error.logs`.
*
* See {@link angular.mock} for more info on angular mocks.
*/
angular.mock.$LogProvider = function(){
angular.module.NG_MOCK.$LogProvider = function(){
function concat(array1, array2, index) {
return array1.concat(Array.prototype.slice.call(array2, index));
@ -417,14 +447,62 @@ angular.mock.$LogProvider = function(){
error: function() { $log.error.logs.push(concat([], arguments, 0)); }
};
/**
* @ngdoc method
* @name angular.module.NG_MOCK.$log#reset
* @methodOf angular.module.NG_MOCK.$log
*
* @description
* Reset all of the logging arrays to empty.
*/
$log.reset = function (){
/**
* @ngdoc property
* @name angular.module.NG_MOCK.$log#log.logs
* @propertyOf angular.module.NG_MOCK.$log
*
* @description
* Array of logged messages.
*/
$log.log.logs = [];
/**
* @ngdoc property
* @name angular.module.NG_MOCK.$log#warn.logs
* @propertyOf angular.module.NG_MOCK.$log
*
* @description
* Array of logged messages.
*/
$log.warn.logs = [];
/**
* @ngdoc property
* @name angular.module.NG_MOCK.$log#info.logs
* @propertyOf angular.module.NG_MOCK.$log
*
* @description
* Array of logged messages.
*/
$log.info.logs = [];
/**
* @ngdoc property
* @name angular.module.NG_MOCK.$log#error.logs
* @propertyOf angular.module.NG_MOCK.$log
*
* @description
* Array of logged messages.
*/
$log.error.logs = [];
};
$log.assertEmpty = function(){
/**
* @ngdoc method
* @name angular.module.NG_MOCK.$log#assertEmpty
* @methodOf angular.module.NG_MOCK.$log
*
* @description
* Assert that the all of the logging methods have no logged messages. If messages present, an exception is thrown.
*/
$log.assertEmpty = function() {
var errors = [];
angular.forEach(['error', 'warn', 'info', 'log'], function(logLevel) {
angular.forEach($log[logLevel].logs, function(log) {
@ -448,6 +526,12 @@ angular.mock.$LogProvider = function(){
/**
* @ngdoc object
* @name angular.module.NG_MOCK.TzDate
* @description
*
* *NOTE*: this is not an injectable instance, just a globally available mock class of `Date`.
*
* Mock of the Date type which has its timezone specified via constroctor arg.
*
* The main purpose is to create Date-like instances with timezone fixed to the specified timezone
@ -477,7 +561,7 @@ angular.mock.$LogProvider = function(){
* </pre>
*
*/
angular.mock.TzDate = function (offset, timestamp) {
angular.module.NG_MOCK.TzDate = function (offset, timestamp) {
var self = new Date(0);
if (angular.isString(timestamp)) {
var tsStr = timestamp;
@ -580,15 +664,24 @@ angular.mock.TzDate = function (offset, timestamp) {
}
//make "tzDateInstance instanceof Date" return true
angular.mock.TzDate.prototype = Date.prototype;
angular.module.NG_MOCK.TzDate.prototype = Date.prototype;
/**
* Method for serializing common objects into strings, useful for debugging.
* @ngdoc function
* @name angular.module.NG_MOCK.debug
* @description
*
* *NOTE*: this is not an injectable instance, just a globally available function.
*
* Method for serializing common angular objects (scope, elements, etc..) into strings, useful for debugging.
*
* This method is also available on window, where it can be used to display objects on debug console.
*
* @param {*} object - any object to turn into string.
* @return a serialized string of the argument
*/
angular.mock.dump = function(object){
angular.module.NG_MOCK.dump = function(object){
var out;
if (angular.isElement(object)) {
object = angular.element(object);
@ -633,13 +726,57 @@ window.jstestdriver && (function(window){
window.dump = function() {
var args = [];
angular.forEach(arguments, function(arg){
args.push(angular.mock.dump(arg));
args.push(angular.module.NG_MOCK.dump(arg));
});
jstestdriver.console.log.apply(jstestdriver.console, args);
};
})(window);
/**
* @ngdoc function
* @name angular.module.NG_MOCK.inject
* @description
*
* *NOTE*: this is not an injectable instance, just a globally available function on window.
*
* This function wraps a test method into an injectable method. It create one
* {@link angular.module.AUTO.$injector $injector} per test, which is then used for testing.
*
* Here is an example of what a typical jasmine tests looks like with the inject method.
* <pre>
* describe('MyApp', function() {
*
* // Argument inference is used to inject the $provide service
* beforeEach(inject(function($provide, $rootScope) {
* // $provide service is configured as needed
* $provide.value('version', 'v1.0.1');
* $rootScope.value = 123;
* });
*
* // Argument inference is used to inject the $rootScope as well as the version
* it('should provide a version', inject(function($rootScope, version){
* expect(version).toEqual('v1.0.1');
* expect($rootScope.value).toEqual(123);
* });
*
* // The inject can also chain the methods
* it('should override a version and test the new version is injected', inject(
* function($provide) {
* $provide.value('version', 'overridden'); // override version here
* },
* function(version) {
* expect(version).toEqual('overridden');
* }
* ));
*
* });
*
* </pre>
*
* @param {*} fns... any number of functions which will be injected using the injector.
* @return a method
*/
window.jasmine && (function(window){
window.inject = function (){
var blockFns = Array.prototype.slice.call(arguments, 0);

2
src/apis.js
View file

@ -10,7 +10,7 @@
* that is also assigned to the $$hashKey property of the object.
*
* @param obj
* @returns {String} hash string such that the same input will have the same hash string.
* @returns {string} hash string such that the same input will have the same hash string.
* The resulting string key is in 'type:hashKey' format.
*/
function hashKey(obj) {

6
src/scenario/Application.js
View file

@ -44,8 +44,8 @@ angular.scenario.Application.prototype.getWindow_ = function() {
*
* @param {string} url The URL. If it begins with a # then only the
* hash of the page is changed.
* @param {Function} loadFn function($window, $document) Called when frame loads.
* @param {Function} errorFn function(error) Called if any error when loading.
* @param {function()} loadFn function($window, $document) Called when frame loads.
* @param {function()} errorFn function(error) Called if any error when loading.
*/
angular.scenario.Application.prototype.navigateTo = function(url, loadFn, errorFn) {
var self = this;
@ -78,7 +78,7 @@ angular.scenario.Application.prototype.navigateTo = function(url, loadFn, errorF
* Executes a function in the context of the tested application. Will wait
* for all pending angular xhr requests before executing.
*
* @param {Function} action The callback to execute. function($window, $document)
* @param {function()} action The callback to execute. function($window, $document)
* $document is a jQuery wrapped document.
*/
angular.scenario.Application.prototype.executeAction = function(action) {

12
src/scenario/Describe.js
View file

@ -45,7 +45,7 @@ angular.scenario.Describe.specId = 0;
/**
* Defines a block to execute before each it or nested describe.
*
* @param {Function} body Body of the block.
* @param {function()} body Body of the block.
*/
angular.scenario.Describe.prototype.beforeEach = function(body) {
this.beforeEachFns.push(body);
@ -54,7 +54,7 @@ angular.scenario.Describe.prototype.beforeEach = function(body) {
/**
* Defines a block to execute after each it or nested describe.
*
* @param {Function} body Body of the block.
* @param {function()} body Body of the block.
*/
angular.scenario.Describe.prototype.afterEach = function(body) {
this.afterEachFns.push(body);
@ -64,7 +64,7 @@ angular.scenario.Describe.prototype.afterEach = function(body) {
* Creates a new describe block that's a child of this one.
*
* @param {string} name Name of the block. Appended to the parent block's name.
* @param {Function} body Body of the block.
* @param {function()} body Body of the block.
*/
angular.scenario.Describe.prototype.describe = function(name, body) {
var child = new angular.scenario.Describe(name, this);
@ -76,7 +76,7 @@ angular.scenario.Describe.prototype.describe = function(name, body) {
* Same as describe() but makes ddescribe blocks the only to run.
*
* @param {string} name Name of the test.
* @param {Function} body Body of the block.
* @param {function()} body Body of the block.
*/
angular.scenario.Describe.prototype.ddescribe = function(name, body) {
var child = new angular.scenario.Describe(name, this);
@ -94,7 +94,7 @@ angular.scenario.Describe.prototype.xdescribe = angular.noop;
* Defines a test.
*
* @param {string} name Name of the test.
* @param {Function} vody Body of the block.
* @param {function()} vody Body of the block.
*/
angular.scenario.Describe.prototype.it = function(name, body) {
this.its.push({
@ -112,7 +112,7 @@ angular.scenario.Describe.prototype.it = function(name, body) {
* Same as it() but makes iit tests the only test to run.
*
* @param {string} name Name of the test.
* @param {Function} body Body of the block.
* @param {function()} body Body of the block.
*/
angular.scenario.Describe.prototype.iit = function(name, body) {
this.it.apply(this, arguments);

8
src/scenario/Future.js
View file

@ -4,8 +4,8 @@
* A future action in a spec.
*
* @param {string} name of the future action
* @param {Function} future callback(error, result)
* @param {Function} Optional. function that returns the file/line number.
* @param {function()} future callback(error, result)
* @param {function()} Optional. function that returns the file/line number.
*/
angular.scenario.Future = function(name, behavior, line) {
this.name = name;
@ -19,7 +19,7 @@ angular.scenario.Future = function(name, behavior, line) {
/**
* Executes the behavior of the closure.
*
* @param {Function} doneFn Callback function(error, result)
* @param {function()} doneFn Callback function(error, result)
*/
angular.scenario.Future.prototype.execute = function(doneFn) {
var self = this;
@ -40,7 +40,7 @@ angular.scenario.Future.prototype.execute = function(doneFn) {
/**
* Configures the future to convert it's final with a function fn(value)
*
* @param {Function} fn function(value) that returns the parsed value
* @param {function()} fn function(value) that returns the parsed value
*/
angular.scenario.Future.prototype.parsedWith = function(fn) {
this.parser = fn;

2
src/scenario/ObjectModel.js
View file

@ -121,7 +121,7 @@ angular.scenario.ObjectModel = function(runner) {
* Adds a listener for an event.
*
* @param {string} eventName Name of the event to add a handler for
* @param {Function} listener Function that will be called when event is fired
* @param {function()} listener Function that will be called when event is fired
*/
angular.scenario.ObjectModel.prototype.on = function(eventName, listener) {
eventName = eventName.toLowerCase();

12
src/scenario/Runner.js
View file

@ -61,7 +61,7 @@ angular.scenario.Runner.prototype.on = function(eventName, listener) {
* @see Describe.js
*
* @param {string} name Name of the block
* @param {Function} body Body of the block
* @param {function()} body Body of the block
*/
angular.scenario.Runner.prototype.describe = function(name, body) {
var self = this;
@ -82,7 +82,7 @@ angular.scenario.Runner.prototype.describe = function(name, body) {
* @see Describe.js
*
* @param {string} name Name of the block
* @param {Function} body Body of the block
* @param {function()} body Body of the block
*/
angular.scenario.Runner.prototype.ddescribe = function(name, body) {
var self = this;
@ -103,7 +103,7 @@ angular.scenario.Runner.prototype.ddescribe = function(name, body) {
* @see Describe.js
*
* @param {string} name Name of the block
* @param {Function} body Body of the block
* @param {function()} body Body of the block
*/
angular.scenario.Runner.prototype.it = function(name, body) {
this.currentDescribe.it(name, body);
@ -115,7 +115,7 @@ angular.scenario.Runner.prototype.it = function(name, body) {
* @see Describe.js
*
* @param {string} name Name of the block
* @param {Function} body Body of the block
* @param {function()} body Body of the block
*/
angular.scenario.Runner.prototype.iit = function(name, body) {
this.currentDescribe.iit(name, body);
@ -127,7 +127,7 @@ angular.scenario.Runner.prototype.iit = function(name, body) {
*
* @see Describe.js
*
* @param {Function} Callback to execute
* @param {function()} Callback to execute
*/
angular.scenario.Runner.prototype.beforeEach = function(body) {
this.currentDescribe.beforeEach(body);
@ -139,7 +139,7 @@ angular.scenario.Runner.prototype.beforeEach = function(body) {
*
* @see Describe.js
*
* @param {Function} Callback to execute
* @param {function()} Callback to execute
*/
angular.scenario.Runner.prototype.afterEach = function(body) {
this.currentDescribe.afterEach(body);

10
src/scenario/Scenario.js
View file

@ -13,7 +13,7 @@ angular.scenario = angular.scenario || {};
* Defines a new output format.
*
* @param {string} name the name of the new output format
* @param {Function} fn function(context, runner) that generates the output
* @param {function()} fn function(context, runner) that generates the output
*/
angular.scenario.output = angular.scenario.output || function(name, fn) {
angular.scenario.output[name] = fn;
@ -29,7 +29,7 @@ angular.scenario.output = angular.scenario.output || function(name, fn) {
* functions.
*
* @param {string} name The name of the statement
* @param {Function} fn Factory function(), return a function for
* @param {function()} fn Factory function(), return a function for
* the statement.
*/
angular.scenario.dsl = angular.scenario.dsl || function(name, fn) {
@ -65,7 +65,7 @@ angular.scenario.dsl = angular.scenario.dsl || function(name, fn) {
* created for you.
*
* @param {string} name The name of the matcher
* @param {Function} fn The matching function(expected).
* @param {function()} fn The matching function(expected).
*/
angular.scenario.matcher = angular.scenario.matcher || function(name, fn) {
angular.scenario.matcher[name] = function(expected) {
@ -148,8 +148,8 @@ angular.scenario.setUpAndRun = function(config) {
* continueFunction to continute iterating.
*
* @param {Array} list list to iterate over
* @param {Function} iterator Callback function(value, continueFunction)
* @param {Function} done Callback function(error, result) called when
* @param {function()} iterator Callback function(value, continueFunction)
* @param {function()} done Callback function(error, result) called when
* iteration finishes or an error occurs.
*/
function asyncForEach(list, iterator, done) {

10
src/scenario/SpecRunner.js
View file

@ -18,7 +18,7 @@ angular.scenario.SpecRunner = function() {
* based on the describe nesting.
*
* @param {Object} spec A spec object
* @param {Function} specDone function that is called when the spec finshes. Function(error, index)
* @param {function()} specDone function that is called when the spec finshes. Function(error, index)
*/
angular.scenario.SpecRunner.prototype.run = function(spec, specDone) {
var self = this;
@ -85,8 +85,8 @@ angular.scenario.SpecRunner.prototype.run = function(spec, specDone) {
* Note: Do not pass line manually. It happens automatically.
*
* @param {string} name Name of the future
* @param {Function} behavior Behavior of the future
* @param {Function} line fn() that returns file/line number
* @param {function()} behavior Behavior of the future
* @param {function()} line fn() that returns file/line number
*/
angular.scenario.SpecRunner.prototype.addFuture = function(name, behavior, line) {
var future = new angular.scenario.Future(name, angular.bind(this, behavior), line);
@ -100,8 +100,8 @@ angular.scenario.SpecRunner.prototype.addFuture = function(name, behavior, line)
* Note: Do not pass line manually. It happens automatically.
*
* @param {string} name Name of the future
* @param {Function} behavior Behavior of the future
* @param {Function} line fn() that returns file/line number
* @param {function()} behavior Behavior of the future
* @param {function()} line fn() that returns file/line number
*/
angular.scenario.SpecRunner.prototype.addFutureAction = function(name, behavior, line) {
var self = this;

2
src/scenario/output/Html.js
View file

@ -160,7 +160,7 @@ angular.scenario.output('html', function(context, runner, model) {
* Add an error to a step.
*
* @param {Object} The JQuery wrapped context
* @param {Function} fn() that should return the file/line number of the error
* @param {function()} fn() that should return the file/line number of the error
* @param {Object} the error.
*/
function addError(context, line, error) {

2
src/service/exceptionHandler.js
View file

@ -11,7 +11,7 @@
* the browser console.
*
* In unit tests, if `angular-mocks.js` is loaded, this service is overriden by
* {@link angular.mock.service.$exceptionHandler mock $exceptionHandler}
* {@link angular.module.NG_MOCK.$exceptionHandler mock $exceptionHandler}
*
* @example
*/

4
src/service/formFactory.js
View file

@ -180,7 +180,7 @@ function $FormFactoryProvider() {
* Upon receiving the `$valid` event from the widget update the `$error`, `$valid` and `$invalid`
* properties of both the widget as well as the from.
*
* @param {String} validationKey The validation key to be used when updating the `$error` object.
* @param {string} validationKey The validation key to be used when updating the `$error` object.
* The validation key is what will allow the template to bind to a specific validation error
* such as `<div ng:show="form.$error.KEY">error for key</div>`.
*/
@ -194,7 +194,7 @@ function $FormFactoryProvider() {
* Upon receiving the `$invalid` event from the widget update the `$error`, `$valid` and `$invalid`
* properties of both the widget as well as the from.
*
* @param {String} validationKey The validation key to be used when updating the `$error` object.
* @param {string} validationKey The validation key to be used when updating the `$error` object.
* The validation key is what will allow the template to bind to a specific validation error
* such as `<div ng:show="form.$error.KEY">error for key</div>`.
*/

52
test/angular-mocksSpec.js vendored
View file

@ -8,95 +8,95 @@ describe('mocks', function() {
}
it('should look like a Date', function() {
var date = new angular.mock.TzDate(0,0);
var date = new angular.module.NG_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);
expect(new angular.module.NG_MOCK.TzDate(0, 0).getTime()).toBe(0);
expect(new angular.module.NG_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);
expect(new angular.module.NG_MOCK.TzDate(0, '1970-01-01T00:00:00.000Z').getTime()).toBe(0);
expect(new angular.module.NG_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);
var t0 = new angular.module.NG_MOCK.TzDate(-3, 0);
expect(t0.toLocaleDateString()).toMatch('1970');
//0 in +0h
var t1 = new angular.mock.TzDate(0, 0);
var t1 = new angular.module.NG_MOCK.TzDate(0, 0);
expect(t1.toLocaleDateString()).toMatch('1970');
//0 in +3h
var t2 = new angular.mock.TzDate(3, 0);
var t2 = new angular.module.NG_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);
var t0 = new angular.module.NG_MOCK.TzDate(-3, 0);
expect(t0.getHours()).toBe(3);
//0 in +0h
var t1 = new angular.mock.TzDate(0, 0);
var t1 = new angular.module.NG_MOCK.TzDate(0, 0);
expect(t1.getHours()).toBe(0);
//0 in +3h
var t2 = new angular.mock.TzDate(3, 0);
var t2 = new angular.module.NG_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));
var t0 = new angular.module.NG_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));
var t0a = new angular.module.NG_MOCK.TzDate(-3.25, minutes(15));
expect(t0a.getMinutes()).toBe(30);
//0 in +0h
var t1 = new angular.mock.TzDate(0, minutes(0));
var t1 = new angular.module.NG_MOCK.TzDate(0, minutes(0));
expect(t1.getMinutes()).toBe(0);
//0:15 in +0h
var t1a = new angular.mock.TzDate(0, minutes(15));
var t1a = new angular.module.NG_MOCK.TzDate(0, minutes(15));
expect(t1a.getMinutes()).toBe(15);
//0:15 in +3h
var t2 = new angular.mock.TzDate(3, minutes(15));
var t2 = new angular.module.NG_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));
var t2a = new angular.module.NG_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);
var t0 = new angular.module.NG_MOCK.TzDate(-3, 0);
expect(t0.getSeconds()).toBe(0);
//0 in +0h
var t1 = new angular.mock.TzDate(0, 0);
var t1 = new angular.module.NG_MOCK.TzDate(0, 0);
expect(t1.getSeconds()).toBe(0);
//0 in +3h
var t2 = new angular.mock.TzDate(3, 0);
var t2 = new angular.module.NG_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');
var newYearInBratislava = new angular.module.NG_MOCK.TzDate(-1, '2009-12-31T23:00:00.000Z');
expect(newYearInBratislava.getTimezoneOffset()).toBe(-60);
expect(newYearInBratislava.getFullYear()).toBe(2010);
expect(newYearInBratislava.getMonth()).toBe(0);
@ -108,7 +108,7 @@ describe('mocks', function() {
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');
var date1 = new angular.module.NG_MOCK.TzDate(-1, '2009-12-31T23:00:00.000Z');
expect(date1.getUTCFullYear()).toBe(2009);
expect(date1.getUTCMonth()).toBe(11);
expect(date1.getUTCDate()).toBe(31);
@ -118,7 +118,7 @@ describe('mocks', function() {
//from when created from millis
var date2 = new angular.mock.TzDate(-1, date1.getTime());
var date2 = new angular.module.NG_MOCK.TzDate(-1, date1.getTime());
expect(date2.getUTCFullYear()).toBe(2009);
expect(date2.getUTCMonth()).toBe(11);
expect(date2.getUTCDate()).toBe(31);
@ -129,7 +129,7 @@ describe('mocks', function() {
it('should throw error when no third param but toString called', function() {
expect(function() { new angular.mock.TzDate(0,0).toString(); }).
expect(function() { new angular.module.NG_MOCK.TzDate(0,0).toString(); }).
toThrow('Method \'toString\' is not implemented in the TzDate mock');
});
});
@ -290,8 +290,8 @@ describe('mocks', function() {
});
describe('angular.mock.debug', function(){
var d = angular.mock.dump;
describe('angular.module.NG_MOCK.dump', function(){
var d = angular.module.NG_MOCK.dump;
it('should serialize primitive types', function(){

2
test/matchers.js
View file

@ -95,7 +95,7 @@ beforeEach(function() {
toHaveClass: function(clazz) {
this.message = function() {
return "Expected '" + angular.mock.dump(this.actual) + "' to have class '" + clazz + "'.";
return "Expected '" + angular.module.NG_MOCK.dump(this.actual) + "' to have class '" + clazz + "'.";
};
return this.actual.hasClass ?
this.actual.hasClass(clazz) :

4
test/scenario/RunnerSpec.js
View file

@ -46,8 +46,8 @@ describe('angular.scenario.Runner', function() {
runner.createSpecRunner_ = function(scope) {
return scope.$new(MockSpecRunner);
};
runner.on('SpecError', angular.mock.rethrow);
runner.on('StepError', angular.mock.rethrow);
runner.on('SpecError', angular.module.NG_MOCK.rethrow);
runner.on('StepError', angular.module.NG_MOCK.rethrow);
});
afterEach(function() {

2
test/service/cookiesSpec.js
View file

@ -3,7 +3,7 @@
describe('$cookies', function() {
beforeEach(inject(function($provide) {
$provide.factory('$browser', function(){
return angular.extend(new angular.mock.$Browser(), {cookieHash: {preexisting:'oldCookie'}});
return angular.extend(new angular.module.NG_MOCK.$Browser(), {cookieHash: {preexisting:'oldCookie'}});
});
}));

8
test/service/filter/filtersSpec.js
View file

@ -187,10 +187,10 @@ describe('filters', function() {
describe('date', function() {
var morning = new angular.mock.TzDate(+5, '2010-09-03T12:05:08.000Z'); //7am
var noon = new angular.mock.TzDate(+5, '2010-09-03T17:05:08.000Z'); //12pm
var midnight = new angular.mock.TzDate(+5, '2010-09-03T05:05:08.000Z'); //12am
var earlyDate = new angular.mock.TzDate(+5, '0001-09-03T05:05:08.000Z');
var morning = new angular.module.NG_MOCK.TzDate(+5, '2010-09-03T12:05:08.000Z'); //7am
var noon = new angular.module.NG_MOCK.TzDate(+5, '2010-09-03T17:05:08.000Z'); //12pm
var midnight = new angular.module.NG_MOCK.TzDate(+5, '2010-09-03T05:05:08.000Z'); //12am
var earlyDate = new angular.module.NG_MOCK.TzDate(+5, '0001-09-03T05:05:08.000Z');
var date;

2
test/service/logSpec.js
View file

@ -13,7 +13,7 @@ describe('$log', function() {
$window = {};
logger = '';
$provide.service('$log', $LogProvider);
$provide.value('$exceptionHandler', angular.mock.rethrow);
$provide.value('$exceptionHandler', angular.module.NG_MOCK.rethrow);
$provide.value('$window', $window);
}));

6
test/testabilityPatch.js
View file

@ -174,10 +174,12 @@ function isCssVisible(node) {
}
function assertHidden(node) {
assertFalse("Node should be hidden but vas visible: " + angular.mock.dump(node), isCssVisible(node));
assertFalse("Node should be hidden but vas visible: " +
angular.module.NG_MOCK.dump(node), isCssVisible(node));
}
function assertVisible(node) {
assertTrue("Node should be visible but vas hidden: " + angular.mock.dump(node), isCssVisible(node));
assertTrue("Node should be visible but vas hidden: " +
angular.module.NG_MOCK.dump(node), isCssVisible(node));
}