374 | * $log.log('Some Error');
375 | * var first = $log.error.logs.unshift();
376 | *
377 | */
378 | $log.error.logs = [];
379 | };
380 |
381 | /**
382 | * @ngdoc method
383 | * @name ngMock.$log#assertEmpty
384 | * @methodOf ngMock.$log
385 | *
386 | * @description
387 | * Assert that the all of the logging methods have no logged messages. If messages present, an exception is thrown.
388 | */
389 | $log.assertEmpty = function() {
390 | var errors = [];
391 | angular.forEach(['error', 'warn', 'info', 'log'], function(logLevel) {
392 | angular.forEach($log[logLevel].logs, function(log) {
393 | angular.forEach(log, function (logItem) {
394 | errors.push('MOCK $log (' + logLevel + '): ' + String(logItem) + '\n' + (logItem.stack || ''));
395 | });
396 | });
397 | });
398 | if (errors.length) {
399 | errors.unshift("Expected $log to be empty! Either a message was logged unexpectedly, or an expected " +
400 | "log message was not checked and removed:");
401 | errors.push('');
402 | throw new Error(errors.join('\n---------\n'));
403 | }
404 | };
405 |
406 | $log.reset();
407 | return $log;
408 | };
409 | };
410 |
411 |
412 | (function() {
413 | var R_ISO8061_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?:\:?(\d\d)(?:\:?(\d\d)(?:\.(\d{3}))?)?)?(Z|([+-])(\d\d):?(\d\d)))?$/;
414 |
415 | function jsonStringToDate(string) {
416 | var match;
417 | if (match = string.match(R_ISO8061_STR)) {
418 | var date = new Date(0),
419 | tzHour = 0,
420 | tzMin = 0;
421 | if (match[9]) {
422 | tzHour = int(match[9] + match[10]);
423 | tzMin = int(match[9] + match[11]);
424 | }
425 | date.setUTCFullYear(int(match[1]), int(match[2]) - 1, int(match[3]));
426 | date.setUTCHours(int(match[4]||0) - tzHour, int(match[5]||0) - tzMin, int(match[6]||0), int(match[7]||0));
427 | return date;
428 | }
429 | return string;
430 | }
431 |
432 | function int(str) {
433 | return parseInt(str, 10);
434 | }
435 |
436 | function padNumber(num, digits, trim) {
437 | var neg = '';
438 | if (num < 0) {
439 | neg = '-';
440 | num = -num;
441 | }
442 | num = '' + num;
443 | while(num.length < digits) num = '0' + num;
444 | if (trim)
445 | num = num.substr(num.length - digits);
446 | return neg + num;
447 | }
448 |
449 |
450 | /**
451 | * @ngdoc object
452 | * @name angular.mock.TzDate
453 | * @description
454 | *
455 | * *NOTE*: this is not an injectable instance, just a globally available mock class of `Date`.
456 | *
457 | * Mock of the Date type which has its timezone specified via constructor arg.
458 | *
459 | * The main purpose is to create Date-like instances with timezone fixed to the specified timezone
460 | * offset, so that we can test code that depends on local timezone settings without dependency on
461 | * the time zone settings of the machine where the code is running.
462 | *
463 | * @param {number} offset Offset of the *desired* timezone in hours (fractions will be honored)
464 | * @param {(number|string)} timestamp Timestamp representing the desired time in *UTC*
465 | *
466 | * @example
467 | * !!!! WARNING !!!!!
468 | * This is not a complete Date object so only methods that were implemented can be called safely.
469 | * To make matters worse, TzDate instances inherit stuff from Date via a prototype.
470 | *
471 | * We do our best to intercept calls to "unimplemented" methods, but since the list of methods is
472 | * incomplete we might be missing some non-standard methods. This can result in errors like:
473 | * "Date.prototype.foo called on incompatible Object".
474 | *
475 | *
484 | *
485 | */
486 | angular.mock.TzDate = function (offset, timestamp) {
487 | var self = new Date(0);
488 | if (angular.isString(timestamp)) {
489 | var tsStr = timestamp;
490 |
491 | self.origDate = jsonStringToDate(timestamp);
492 |
493 | timestamp = self.origDate.getTime();
494 | if (isNaN(timestamp))
495 | throw {
496 | name: "Illegal Argument",
497 | message: "Arg '" + tsStr + "' passed into TzDate constructor is not a valid date string"
498 | };
499 | } else {
500 | self.origDate = new Date(timestamp);
501 | }
502 |
503 | var localOffset = new Date(timestamp).getTimezoneOffset();
504 | self.offsetDiff = localOffset*60*1000 - offset*1000*60*60;
505 | self.date = new Date(timestamp + self.offsetDiff);
506 |
507 | self.getTime = function() {
508 | return self.date.getTime() - self.offsetDiff;
509 | };
510 |
511 | self.toLocaleDateString = function() {
512 | return self.date.toLocaleDateString();
513 | };
514 |
515 | self.getFullYear = function() {
516 | return self.date.getFullYear();
517 | };
518 |
519 | self.getMonth = function() {
520 | return self.date.getMonth();
521 | };
522 |
523 | self.getDate = function() {
524 | return self.date.getDate();
525 | };
526 |
527 | self.getHours = function() {
528 | return self.date.getHours();
529 | };
530 |
531 | self.getMinutes = function() {
532 | return self.date.getMinutes();
533 | };
534 |
535 | self.getSeconds = function() {
536 | return self.date.getSeconds();
537 | };
538 |
539 | self.getTimezoneOffset = function() {
540 | return offset * 60;
541 | };
542 |
543 | self.getUTCFullYear = function() {
544 | return self.origDate.getUTCFullYear();
545 | };
546 |
547 | self.getUTCMonth = function() {
548 | return self.origDate.getUTCMonth();
549 | };
550 |
551 | self.getUTCDate = function() {
552 | return self.origDate.getUTCDate();
553 | };
554 |
555 | self.getUTCHours = function() {
556 | return self.origDate.getUTCHours();
557 | };
558 |
559 | self.getUTCMinutes = function() {
560 | return self.origDate.getUTCMinutes();
561 | };
562 |
563 | self.getUTCSeconds = function() {
564 | return self.origDate.getUTCSeconds();
565 | };
566 |
567 | self.getUTCMilliseconds = function() {
568 | return self.origDate.getUTCMilliseconds();
569 | };
570 |
571 | self.getDay = function() {
572 | return self.date.getDay();
573 | };
574 |
575 | // provide this method only on browsers that already have it
576 | if (self.toISOString) {
577 | self.toISOString = function() {
578 | return padNumber(self.origDate.getUTCFullYear(), 4) + '-' +
579 | padNumber(self.origDate.getUTCMonth() + 1, 2) + '-' +
580 | padNumber(self.origDate.getUTCDate(), 2) + 'T' +
581 | padNumber(self.origDate.getUTCHours(), 2) + ':' +
582 | padNumber(self.origDate.getUTCMinutes(), 2) + ':' +
583 | padNumber(self.origDate.getUTCSeconds(), 2) + '.' +
584 | padNumber(self.origDate.getUTCMilliseconds(), 3) + 'Z'
585 | }
586 | }
587 |
588 | //hide all methods not implemented in this mock that the Date prototype exposes
589 | var unimplementedMethods = ['getMilliseconds', 'getUTCDay',
590 | 'getYear', 'setDate', 'setFullYear', 'setHours', 'setMilliseconds',
591 | 'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate', 'setUTCFullYear',
592 | 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds',
593 | 'setYear', 'toDateString', 'toGMTString', 'toJSON', 'toLocaleFormat', 'toLocaleString',
594 | 'toLocaleTimeString', 'toSource', 'toString', 'toTimeString', 'toUTCString', 'valueOf'];
595 |
596 | angular.forEach(unimplementedMethods, function(methodName) {
597 | self[methodName] = function() {
598 | throw Error("Method '" + methodName + "' is not implemented in the TzDate mock");
599 | };
600 | });
601 |
602 | return self;
603 | };
604 |
605 | //make "tzDateInstance instanceof Date" return true
606 | angular.mock.TzDate.prototype = Date.prototype;
607 | })();
608 |
609 |
610 | /**
611 | * @ngdoc function
612 | * @name angular.mock.dump
613 | * @description
614 | *
615 | * *NOTE*: this is not an injectable instance, just a globally available function.
616 | *
617 | * Method for serializing common angular objects (scope, elements, etc..) into strings, useful for debugging.
618 | *
619 | * This method is also available on window, where it can be used to display objects on debug console.
620 | *
621 | * @param {*} object - any object to turn into string.
622 | * @return {string} a serialized string of the argument
623 | */
624 | angular.mock.dump = function(object) {
625 | return serialize(object);
626 |
627 | function serialize(object) {
628 | var out;
629 |
630 | if (angular.isElement(object)) {
631 | object = angular.element(object);
632 | out = angular.element('');
633 | angular.forEach(object, function(element) {
634 | out.append(angular.element(element).clone());
635 | });
636 | out = out.html();
637 | } else if (angular.isArray(object)) {
638 | out = [];
639 | angular.forEach(object, function(o) {
640 | out.push(serialize(o));
641 | });
642 | out = '[ ' + out.join(', ') + ' ]';
643 | } else if (angular.isObject(object)) {
644 | if (angular.isFunction(object.$eval) && angular.isFunction(object.$apply)) {
645 | out = serializeScope(object);
646 | } else if (object instanceof Error) {
647 | out = object.stack || ('' + object.name + ': ' + object.message);
648 | } else {
649 | out = angular.toJson(object, true);
650 | }
651 | } else {
652 | out = String(object);
653 | }
654 |
655 | return out;
656 | }
657 |
658 | function serializeScope(scope, offset) {
659 | offset = offset || ' ';
660 | var log = [offset + 'Scope(' + scope.$id + '): {'];
661 | for ( var key in scope ) {
662 | if (scope.hasOwnProperty(key) && !key.match(/^(\$|this)/)) {
663 | log.push(' ' + key + ': ' + angular.toJson(scope[key]));
664 | }
665 | }
666 | var child = scope.$$childHead;
667 | while(child) {
668 | log.push(serializeScope(child, offset + ' '));
669 | child = child.$$nextSibling;
670 | }
671 | log.push('}');
672 | return log.join('\n' + offset);
673 | }
674 | };
675 |
676 | /**
677 | * @ngdoc object
678 | * @name ngMock.$httpBackend
679 | * @description
680 | * Fake HTTP backend implementation suitable for unit testing applications that use the
681 | * {@link ng.$http $http service}.
682 | *
683 | * *Note*: For fake HTTP backend implementation suitable for end-to-end testing or backend-less
684 | * development please see {@link ngMockE2E.$httpBackend e2e $httpBackend mock}.
685 | *
686 | * During unit testing, we want our unit tests to run quickly and have no external dependencies so
687 | * we don’t want to send {@link https://developer.mozilla.org/en/xmlhttprequest XHR} or
688 | * {@link http://en.wikipedia.org/wiki/JSONP JSONP} requests to a real server. All we really need is
689 | * to verify whether a certain request has been sent or not, or alternatively just let the
690 | * application make requests, respond with pre-trained responses and assert that the end result is
691 | * what we expect it to be.
692 | *
693 | * This mock implementation can be used to respond with static or dynamic responses via the
694 | * `expect` and `when` apis and their shortcuts (`expectGET`, `whenPOST`, etc).
695 | *
696 | * When an Angular application needs some data from a server, it calls the $http service, which
697 | * sends the request to a real server using $httpBackend service. With dependency injection, it is
698 | * easy to inject $httpBackend mock (which has the same API as $httpBackend) and use it to verify
699 | * the requests and respond with some testing data without sending a request to real server.
700 | *
701 | * There are two ways to specify what test data should be returned as http responses by the mock
702 | * backend when the code under test makes http requests:
703 | *
704 | * - `$httpBackend.expect` - specifies a request expectation
705 | * - `$httpBackend.when` - specifies a backend definition
706 | *
707 | *
708 | * # Request Expectations vs Backend Definitions
709 | *
710 | * Request expectations provide a way to make assertions about requests made by the application and
711 | * to define responses for those requests. The test will fail if the expected requests are not made
712 | * or they are made in the wrong order.
713 | *
714 | * Backend definitions allow you to define a fake backend for your application which doesn't assert
715 | * if a particular request was made or not, it just returns a trained response if a request is made.
716 | * The test will pass whether or not the request gets made during testing.
717 | *
718 | *
719 | *
720 | *
Request expectations
Backend definitions
721 | *
722 | *
Syntax
723 | *
.expect(...).respond(...)
724 | *
.when(...).respond(...)
725 | *
726 | *
727 | *
Typical usage
728 | *
strict unit tests
729 | *
loose (black-box) unit testing
730 | *
731 | *
732 | *
Fulfills multiple requests
733 | *
NO
734 | *
YES
735 | *
736 | *
737 | *
Order of requests matters
738 | *
YES
739 | *
NO
740 | *
741 | *
742 | *
Request required
743 | *
YES
744 | *
NO
745 | *
746 | *
747 | *
Response required
748 | *
optional (see below)
749 | *
YES
750 | *
751 | *
752 | *
753 | * In cases where both backend definitions and request expectations are specified during unit
754 | * testing, the request expectations are evaluated first.
755 | *
756 | * If a request expectation has no response specified, the algorithm will search your backend
757 | * definitions for an appropriate response.
758 | *
759 | * If a request didn't match any expectation or if the expectation doesn't have the response
760 | * defined, the backend definitions are evaluated in sequential order to see if any of them match
761 | * the request. The response from the first matched definition is returned.
762 | *
763 | *
764 | * # Flushing HTTP requests
765 | *
766 | * The $httpBackend used in production, always responds to requests with responses asynchronously.
767 | * If we preserved this behavior in unit testing, we'd have to create async unit tests, which are
768 | * hard to write, follow and maintain. At the same time the testing mock, can't respond
769 | * synchronously because that would change the execution of the code under test. For this reason the
770 | * mock $httpBackend has a `flush()` method, which allows the test to explicitly flush pending
771 | * requests and thus preserving the async api of the backend, while allowing the test to execute
772 | * synchronously.
773 | *
774 | *
775 | * # Unit testing with mock $httpBackend
776 | * The following code shows how to setup and use the mock backend in unit testing a controller.
777 | * First we create the controller under test
778 | *
779 |