437 | *
438 | */
439 | angular.mock.TzDate = function (offset, timestamp) {
440 | var self = new Date(0);
441 | if (angular.isString(timestamp)) {
442 | var tsStr = timestamp;
443 |
444 | self.origDate = jsonStringToDate(timestamp);
445 |
446 | timestamp = self.origDate.getTime();
447 | if (isNaN(timestamp))
448 | throw {
449 | name: "Illegal Argument",
450 | message: "Arg '" + tsStr + "' passed into TzDate constructor is not a valid date string"
451 | };
452 | } else {
453 | self.origDate = new Date(timestamp);
454 | }
455 |
456 | var localOffset = new Date(timestamp).getTimezoneOffset();
457 | self.offsetDiff = localOffset*60*1000 - offset*1000*60*60;
458 | self.date = new Date(timestamp + self.offsetDiff);
459 |
460 | self.getTime = function() {
461 | return self.date.getTime() - self.offsetDiff;
462 | };
463 |
464 | self.toLocaleDateString = function() {
465 | return self.date.toLocaleDateString();
466 | };
467 |
468 | self.getFullYear = function() {
469 | return self.date.getFullYear();
470 | };
471 |
472 | self.getMonth = function() {
473 | return self.date.getMonth();
474 | };
475 |
476 | self.getDate = function() {
477 | return self.date.getDate();
478 | };
479 |
480 | self.getHours = function() {
481 | return self.date.getHours();
482 | };
483 |
484 | self.getMinutes = function() {
485 | return self.date.getMinutes();
486 | };
487 |
488 | self.getSeconds = function() {
489 | return self.date.getSeconds();
490 | };
491 |
492 | self.getTimezoneOffset = function() {
493 | return offset * 60;
494 | };
495 |
496 | self.getUTCFullYear = function() {
497 | return self.origDate.getUTCFullYear();
498 | };
499 |
500 | self.getUTCMonth = function() {
501 | return self.origDate.getUTCMonth();
502 | };
503 |
504 | self.getUTCDate = function() {
505 | return self.origDate.getUTCDate();
506 | };
507 |
508 | self.getUTCHours = function() {
509 | return self.origDate.getUTCHours();
510 | };
511 |
512 | self.getUTCMinutes = function() {
513 | return self.origDate.getUTCMinutes();
514 | };
515 |
516 | self.getUTCSeconds = function() {
517 | return self.origDate.getUTCSeconds();
518 | };
519 |
520 | self.getUTCMilliseconds = function() {
521 | return self.origDate.getUTCMilliseconds();
522 | };
523 |
524 | self.getDay = function() {
525 | return self.date.getDay();
526 | };
527 |
528 | // provide this method only on browsers that already have it
529 | if (self.toISOString) {
530 | self.toISOString = function() {
531 | return padNumber(self.origDate.getUTCFullYear(), 4) + '-' +
532 | padNumber(self.origDate.getUTCMonth() + 1, 2) + '-' +
533 | padNumber(self.origDate.getUTCDate(), 2) + 'T' +
534 | padNumber(self.origDate.getUTCHours(), 2) + ':' +
535 | padNumber(self.origDate.getUTCMinutes(), 2) + ':' +
536 | padNumber(self.origDate.getUTCSeconds(), 2) + '.' +
537 | padNumber(self.origDate.getUTCMilliseconds(), 3) + 'Z'
538 | }
539 | }
540 |
541 | //hide all methods not implemented in this mock that the Date prototype exposes
542 | var unimplementedMethods = ['getMilliseconds', 'getUTCDay',
543 | 'getYear', 'setDate', 'setFullYear', 'setHours', 'setMilliseconds',
544 | 'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate', 'setUTCFullYear',
545 | 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds',
546 | 'setYear', 'toDateString', 'toGMTString', 'toJSON', 'toLocaleFormat', 'toLocaleString',
547 | 'toLocaleTimeString', 'toSource', 'toString', 'toTimeString', 'toUTCString', 'valueOf'];
548 |
549 | angular.forEach(unimplementedMethods, function(methodName) {
550 | self[methodName] = function() {
551 | throw Error("Method '" + methodName + "' is not implemented in the TzDate mock");
552 | };
553 | });
554 |
555 | return self;
556 | };
557 |
558 | //make "tzDateInstance instanceof Date" return true
559 | angular.mock.TzDate.prototype = Date.prototype;
560 | })();
561 |
562 |
563 | /**
564 | * @ngdoc function
565 | * @name angular.mock.debug
566 | * @description
567 | *
568 | * *NOTE*: this is not an injectable instance, just a globally available function.
569 | *
570 | * Method for serializing common angular objects (scope, elements, etc..) into strings, useful for debugging.
571 | *
572 | * This method is also available on window, where it can be used to display objects on debug console.
573 | *
574 | * @param {*} object - any object to turn into string.
575 | * @return {string} a serialized string of the argument
576 | */
577 | angular.mock.dump = function(object) {
578 | return serialize(object);
579 |
580 | function serialize(object) {
581 | var out;
582 |
583 | if (angular.isElement(object)) {
584 | object = angular.element(object);
585 | out = angular.element('');
586 | angular.forEach(object, function(element) {
587 | out.append(angular.element(element).clone());
588 | });
589 | out = out.html();
590 | } else if (angular.isArray(object)) {
591 | out = [];
592 | angular.forEach(object, function(o) {
593 | out.push(serialize(o));
594 | });
595 | out = '[ ' + out.join(', ') + ' ]';
596 | } else if (angular.isObject(object)) {
597 | if (angular.isFunction(object.$eval) && angular.isFunction(object.$apply)) {
598 | out = serializeScope(object);
599 | } else if (object instanceof Error) {
600 | out = object.stack || ('' + object.name + ': ' + object.message);
601 | } else {
602 | out = angular.toJson(object, true);
603 | }
604 | } else {
605 | out = String(object);
606 | }
607 |
608 | return out;
609 | }
610 |
611 | function serializeScope(scope, offset) {
612 | offset = offset || ' ';
613 | var log = [offset + 'Scope(' + scope.$id + '): {'];
614 | for ( var key in scope ) {
615 | if (scope.hasOwnProperty(key) && !key.match(/^(\$|this)/)) {
616 | log.push(' ' + key + ': ' + angular.toJson(scope[key]));
617 | }
618 | }
619 | var child = scope.$$childHead;
620 | while(child) {
621 | log.push(serializeScope(child, offset + ' '));
622 | child = child.$$nextSibling;
623 | }
624 | log.push('}');
625 | return log.join('\n' + offset);
626 | }
627 | };
628 |
629 | /**
630 | * @ngdoc object
631 | * @name ngMock.$httpBackend
632 | * @description
633 | * Fake HTTP backend implementation suitable for unit testing application that use the
634 | * {@link ng.$http $http service}.
635 | *
636 | * *Note*: For fake http backend implementation suitable for end-to-end testing or backend-less
637 | * development please see {@link ngMockE2E.$httpBackend e2e $httpBackend mock}.
638 | *
639 | * During unit testing, we want our unit tests to run quickly and have no external dependencies so
640 | * we don’t want to send {@link https://developer.mozilla.org/en/xmlhttprequest XHR} or
641 | * {@link http://en.wikipedia.org/wiki/JSONP JSONP} requests to a real server. All we really need is
642 | * to verify whether a certain request has been sent or not, or alternatively just let the
643 | * application make requests, respond with pre-trained responses and assert that the end result is
644 | * what we expect it to be.
645 | *
646 | * This mock implementation can be used to respond with static or dynamic responses via the
647 | * `expect` and `when` apis and their shortcuts (`expectGET`, `whenPOST`, etc).
648 | *
649 | * When an Angular application needs some data from a server, it calls the $http service, which
650 | * sends the request to a real server using $httpBackend service. With dependency injection, it is
651 | * easy to inject $httpBackend mock (which has the same API as $httpBackend) and use it to verify
652 | * the requests and respond with some testing data without sending a request to real server.
653 | *
654 | * There are two ways to specify what test data should be returned as http responses by the mock
655 | * backend when the code under test makes http requests:
656 | *
657 | * - `$httpBackend.expect` - specifies a request expectation
658 | * - `$httpBackend.when` - specifies a backend definition
659 | *
660 | *
661 | * # Request Expectations vs Backend Definitions
662 | *
663 | * Request expectations provide a way to make assertions about requests made by the application and
664 | * to define responses for those requests. The test will fail if the expected requests are not made
665 | * or they are made in the wrong order.
666 | *
667 | * Backend definitions allow you to define a fake backend for your application which doesn't assert
668 | * if a particular request was made or not, it just returns a trained response if a request is made.
669 | * The test will pass whether or not the request gets made during testing.
670 | *
671 | *
672 | *
673 | *
Request expectations
Backend definitions
674 | *
675 | *
Syntax
676 | *
.expect(...).respond(...)
677 | *
.when(...).respond(...)
678 | *
679 | *
680 | *
Typical usage
681 | *
strict unit tests
682 | *
loose (black-box) unit testing
683 | *
684 | *
685 | *
Fulfills multiple requests
686 | *
NO
687 | *
YES
688 | *
689 | *
690 | *
Order of requests matters
691 | *
YES
692 | *
NO
693 | *
694 | *
695 | *
Request required
696 | *
YES
697 | *
NO
698 | *
699 | *
700 | *
Response required
701 | *
optional (see below)
702 | *
YES
703 | *
704 | *
705 | *
706 | * In cases where both backend definitions and request expectations are specified during unit
707 | * testing, the request expectations are evaluated first.
708 | *
709 | * If a request expectation has no response specified, the algorithm will search your backend
710 | * definitions for an appropriate response.
711 | *
712 | * If a request didn't match any expectation or if the expectation doesn't have the response
713 | * defined, the backend definitions are evaluated in sequential order to see if any of them match
714 | * the request. The response from the first matched definition is returned.
715 | *
716 | *
717 | * # Flushing HTTP requests
718 | *
719 | * The $httpBackend used in production, always responds to requests with responses asynchronously.
720 | * If we preserved this behavior in unit testing, we'd have to create async unit tests, which are
721 | * hard to write, follow and maintain. At the same time the testing mock, can't respond
722 | * synchronously because that would change the execution of the code under test. For this reason the
723 | * mock $httpBackend has a `flush()` method, which allows the test to explicitly flush pending
724 | * requests and thus preserving the async api of the backend, while allowing the test to execute
725 | * synchronously.
726 | *
727 | *
728 | * # Unit testing with mock $httpBackend
729 | *
730 | *
731 | // controller
732 | function MyController($scope, $http) {
733 | $http.get('/auth.py').success(function(data) {
734 | $scope.user = data;
735 | });
736 |
737 | this.saveMessage = function(message) {
738 | $scope.status = 'Saving...';
739 | $http.post('/add-msg.py', message).success(function(response) {
740 | $scope.status = '';
741 | }).error(function() {
742 | $scope.status = 'ERROR!';
743 | });
744 | };
745 | }
746 |
747 | // testing controller
748 | var $http;
749 |
750 | beforeEach(inject(function($injector) {
751 | $httpBackend = $injector.get('$httpBackend');
752 |
753 | // backend definition common for all tests
754 | $httpBackend.when('GET', '/auth.py').respond({userId: 'userX'}, {'A-Token': 'xxx'});
755 | }));
756 |
757 |
758 | afterEach(function() {
759 | $httpBackend.verifyNoOutstandingExpectation();
760 | $httpBackend.verifyNoOutstandingRequest();
761 | });
762 |
763 |
764 | it('should fetch authentication token', function() {
765 | $httpBackend.expectGET('/auth.py');
766 | var controller = scope.$new(MyController);
767 | $httpBackend.flush();
768 | });
769 |
770 |
771 | it('should send msg to server', function() {
772 | // now you don’t care about the authentication, but
773 | // the controller will still send the request and
774 | // $httpBackend will respond without you having to
775 | // specify the expectation and response for this request
776 | $httpBackend.expectPOST('/add-msg.py', 'message content').respond(201, '');
777 |
778 | var controller = scope.$new(MyController);
779 | $httpBackend.flush();
780 | controller.saveMessage('message content');
781 | expect(controller.status).toBe('Saving...');
782 | $httpBackend.flush();
783 | expect(controller.status).toBe('');
784 | });
785 |
786 |
787 | it('should send auth header', function() {
788 | $httpBackend.expectPOST('/add-msg.py', undefined, function(headers) {
789 | // check if the header was send, if it wasn't the expectation won't
790 | // match the request and the test will fail
791 | return headers['Authorization'] == 'xxx';
792 | }).respond(201, '');
793 |
794 | var controller = scope.$new(MyController);
795 | controller.saveMessage('whatever');
796 | $httpBackend.flush();
797 | });
798 |
799 | */
800 | angular.mock.$HttpBackendProvider = function() {
801 | this.$get = [createHttpBackendMock];
802 | };
803 |
804 | /**
805 | * General factory function for $httpBackend mock.
806 | * Returns instance for unit testing (when no arguments specified):
807 | * - passing through is disabled
808 | * - auto flushing is disabled
809 | *
810 | * Returns instance for e2e testing (when `$delegate` and `$browser` specified):
811 | * - passing through (delegating request to real backend) is enabled
812 | * - auto flushing is enabled
813 | *
814 | * @param {Object=} $delegate Real $httpBackend instance (allow passing through if specified)
815 | * @param {Object=} $browser Auto-flushing enabled if specified
816 | * @return {Object} Instance of $httpBackend mock
817 | */
818 | function createHttpBackendMock($delegate, $browser) {
819 | var definitions = [],
820 | expectations = [],
821 | responses = [],
822 | responsesPush = angular.bind(responses, responses.push);
823 |
824 | function createResponse(status, data, headers) {
825 | if (angular.isFunction(status)) return status;
826 |
827 | return function() {
828 | return angular.isNumber(status)
829 | ? [status, data, headers]
830 | : [200, status, data];
831 | };
832 | }
833 |
834 | // TODO(vojta): change params to: method, url, data, headers, callback
835 | function $httpBackend(method, url, data, callback, headers) {
836 | var xhr = new MockXhr(),
837 | expectation = expectations[0],
838 | wasExpected = false;
839 |
840 | function prettyPrint(data) {
841 | return (angular.isString(data) || angular.isFunction(data) || data instanceof RegExp)
842 | ? data
843 | : angular.toJson(data);
844 | }
845 |
846 | if (expectation && expectation.match(method, url)) {
847 | if (!expectation.matchData(data))
848 | throw Error('Expected ' + expectation + ' with different data\n' +
849 | 'EXPECTED: ' + prettyPrint(expectation.data) + '\nGOT: ' + data);
850 |
851 | if (!expectation.matchHeaders(headers))
852 | throw Error('Expected ' + expectation + ' with different headers\n' +
853 | 'EXPECTED: ' + prettyPrint(expectation.headers) + '\nGOT: ' +
854 | prettyPrint(headers));
855 |
856 | expectations.shift();
857 |
858 | if (expectation.response) {
859 | responses.push(function() {
860 | var response = expectation.response(method, url, data, headers);
861 | xhr.$$respHeaders = response[2];
862 | callback(response[0], response[1], xhr.getAllResponseHeaders());
863 | });
864 | return;
865 | }
866 | wasExpected = true;
867 | }
868 |
869 | var i = -1, definition;
870 | while ((definition = definitions[++i])) {
871 | if (definition.match(method, url, data, headers || {})) {
872 | if (definition.response) {
873 | // if $browser specified, we do auto flush all requests
874 | ($browser ? $browser.defer : responsesPush)(function() {
875 | var response = definition.response(method, url, data, headers);
876 | xhr.$$respHeaders = response[2];
877 | callback(response[0], response[1], xhr.getAllResponseHeaders());
878 | });
879 | } else if (definition.passThrough) {
880 | $delegate(method, url, data, callback, headers);
881 | } else throw Error('No response defined !');
882 | return;
883 | }
884 | }
885 | throw wasExpected ?
886 | Error('No response defined !') :
887 | Error('Unexpected request: ' + method + ' ' + url + '\n' +
888 | (expectation ? 'Expected ' + expectation : 'No more request expected'));
889 | }
890 |
891 | /**
892 | * @ngdoc method
893 | * @name ngMock.$httpBackend#when
894 | * @methodOf ngMock.$httpBackend
895 | * @description
896 | * Creates a new backend definition.
897 | *
898 | * @param {string} method HTTP method.
899 | * @param {string|RegExp} url HTTP url.
900 | * @param {(string|RegExp)=} data HTTP request body.
901 | * @param {(Object|function(Object))=} headers HTTP headers or function that receives http header
902 | * object and returns true if the headers match the current definition.
903 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
904 | * request is handled.
905 | *
906 | * - respond – `{function([status,] data[, headers])|function(function(method, url, data, headers)}`
907 | * – The respond method takes a set of static data to be returned or a function that can return
908 | * an array containing response status (number), response data (string) and response headers
909 | * (Object).
910 | */
911 | $httpBackend.when = function(method, url, data, headers) {
912 | var definition = new MockHttpExpectation(method, url, data, headers),
913 | chain = {
914 | respond: function(status, data, headers) {
915 | definition.response = createResponse(status, data, headers);
916 | }
917 | };
918 |
919 | if ($browser) {
920 | chain.passThrough = function() {
921 | definition.passThrough = true;
922 | };
923 | }
924 |
925 | definitions.push(definition);
926 | return chain;
927 | };
928 |
929 | /**
930 | * @ngdoc method
931 | * @name ngMock.$httpBackend#whenGET
932 | * @methodOf ngMock.$httpBackend
933 | * @description
934 | * Creates a new backend definition for GET requests. For more info see `when()`.
935 | *
936 | * @param {string|RegExp} url HTTP url.
937 | * @param {(Object|function(Object))=} headers HTTP headers.
938 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
939 | * request is handled.
940 | */
941 |
942 | /**
943 | * @ngdoc method
944 | * @name ngMock.$httpBackend#whenHEAD
945 | * @methodOf ngMock.$httpBackend
946 | * @description
947 | * Creates a new backend definition for HEAD requests. For more info see `when()`.
948 | *
949 | * @param {string|RegExp} url HTTP url.
950 | * @param {(Object|function(Object))=} headers HTTP headers.
951 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
952 | * request is handled.
953 | */
954 |
955 | /**
956 | * @ngdoc method
957 | * @name ngMock.$httpBackend#whenDELETE
958 | * @methodOf ngMock.$httpBackend
959 | * @description
960 | * Creates a new backend definition for DELETE requests. For more info see `when()`.
961 | *
962 | * @param {string|RegExp} url HTTP url.
963 | * @param {(Object|function(Object))=} headers HTTP headers.
964 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
965 | * request is handled.
966 | */
967 |
968 | /**
969 | * @ngdoc method
970 | * @name ngMock.$httpBackend#whenPOST
971 | * @methodOf ngMock.$httpBackend
972 | * @description
973 | * Creates a new backend definition for POST requests. For more info see `when()`.
974 | *
975 | * @param {string|RegExp} url HTTP url.
976 | * @param {(string|RegExp)=} data HTTP request body.
977 | * @param {(Object|function(Object))=} headers HTTP headers.
978 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
979 | * request is handled.
980 | */
981 |
982 | /**
983 | * @ngdoc method
984 | * @name ngMock.$httpBackend#whenPUT
985 | * @methodOf ngMock.$httpBackend
986 | * @description
987 | * Creates a new backend definition for PUT requests. For more info see `when()`.
988 | *
989 | * @param {string|RegExp} url HTTP url.
990 | * @param {(string|RegExp)=} data HTTP request body.
991 | * @param {(Object|function(Object))=} headers HTTP headers.
992 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
993 | * request is handled.
994 | */
995 |
996 | /**
997 | * @ngdoc method
998 | * @name ngMock.$httpBackend#whenJSONP
999 | * @methodOf ngMock.$httpBackend
1000 | * @description
1001 | * Creates a new backend definition for JSONP requests. For more info see `when()`.
1002 | *
1003 | * @param {string|RegExp} url HTTP url.
1004 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1005 | * request is handled.
1006 | */
1007 | createShortMethods('when');
1008 |
1009 |
1010 | /**
1011 | * @ngdoc method
1012 | * @name ngMock.$httpBackend#expect
1013 | * @methodOf ngMock.$httpBackend
1014 | * @description
1015 | * Creates a new request expectation.
1016 | *
1017 | * @param {string} method HTTP method.
1018 | * @param {string|RegExp} url HTTP url.
1019 | * @param {(string|RegExp)=} data HTTP request body.
1020 | * @param {(Object|function(Object))=} headers HTTP headers or function that receives http header
1021 | * object and returns true if the headers match the current expectation.
1022 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1023 | * request is handled.
1024 | *
1025 | * - respond – `{function([status,] data[, headers])|function(function(method, url, data, headers)}`
1026 | * – The respond method takes a set of static data to be returned or a function that can return
1027 | * an array containing response status (number), response data (string) and response headers
1028 | * (Object).
1029 | */
1030 | $httpBackend.expect = function(method, url, data, headers) {
1031 | var expectation = new MockHttpExpectation(method, url, data, headers);
1032 | expectations.push(expectation);
1033 | return {
1034 | respond: function(status, data, headers) {
1035 | expectation.response = createResponse(status, data, headers);
1036 | }
1037 | };
1038 | };
1039 |
1040 |
1041 | /**
1042 | * @ngdoc method
1043 | * @name ngMock.$httpBackend#expectGET
1044 | * @methodOf ngMock.$httpBackend
1045 | * @description
1046 | * Creates a new request expectation for GET requests. For more info see `expect()`.
1047 | *
1048 | * @param {string|RegExp} url HTTP url.
1049 | * @param {Object=} headers HTTP headers.
1050 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1051 | * request is handled. See #expect for more info.
1052 | */
1053 |
1054 | /**
1055 | * @ngdoc method
1056 | * @name ngMock.$httpBackend#expectHEAD
1057 | * @methodOf ngMock.$httpBackend
1058 | * @description
1059 | * Creates a new request expectation for HEAD requests. For more info see `expect()`.
1060 | *
1061 | * @param {string|RegExp} url HTTP url.
1062 | * @param {Object=} headers HTTP headers.
1063 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1064 | * request is handled.
1065 | */
1066 |
1067 | /**
1068 | * @ngdoc method
1069 | * @name ngMock.$httpBackend#expectDELETE
1070 | * @methodOf ngMock.$httpBackend
1071 | * @description
1072 | * Creates a new request expectation for DELETE requests. For more info see `expect()`.
1073 | *
1074 | * @param {string|RegExp} url HTTP url.
1075 | * @param {Object=} headers HTTP headers.
1076 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1077 | * request is handled.
1078 | */
1079 |
1080 | /**
1081 | * @ngdoc method
1082 | * @name ngMock.$httpBackend#expectPOST
1083 | * @methodOf ngMock.$httpBackend
1084 | * @description
1085 | * Creates a new request expectation for POST requests. For more info see `expect()`.
1086 | *
1087 | * @param {string|RegExp} url HTTP url.
1088 | * @param {(string|RegExp)=} data HTTP request body.
1089 | * @param {Object=} headers HTTP headers.
1090 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1091 | * request is handled.
1092 | */
1093 |
1094 | /**
1095 | * @ngdoc method
1096 | * @name ngMock.$httpBackend#expectPUT
1097 | * @methodOf ngMock.$httpBackend
1098 | * @description
1099 | * Creates a new request expectation for PUT requests. For more info see `expect()`.
1100 | *
1101 | * @param {string|RegExp} url HTTP url.
1102 | * @param {(string|RegExp)=} data HTTP request body.
1103 | * @param {Object=} headers HTTP headers.
1104 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1105 | * request is handled.
1106 | */
1107 |
1108 | /**
1109 | * @ngdoc method
1110 | * @name ngMock.$httpBackend#expectPATCH
1111 | * @methodOf ngMock.$httpBackend
1112 | * @description
1113 | * Creates a new request expectation for PATCH requests. For more info see `expect()`.
1114 | *
1115 | * @param {string|RegExp} url HTTP url.
1116 | * @param {(string|RegExp)=} data HTTP request body.
1117 | * @param {Object=} headers HTTP headers.
1118 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1119 | * request is handled.
1120 | */
1121 |
1122 | /**
1123 | * @ngdoc method
1124 | * @name ngMock.$httpBackend#expectJSONP
1125 | * @methodOf ngMock.$httpBackend
1126 | * @description
1127 | * Creates a new request expectation for JSONP requests. For more info see `expect()`.
1128 | *
1129 | * @param {string|RegExp} url HTTP url.
1130 | * @returns {requestHandler} Returns an object with `respond` method that control how a matched
1131 | * request is handled.
1132 | */
1133 | createShortMethods('expect');
1134 |
1135 |
1136 | /**
1137 | * @ngdoc method
1138 | * @name ngMock.$httpBackend#flush
1139 | * @methodOf ngMock.$httpBackend
1140 | * @description
1141 | * Flushes all pending requests using the trained responses.
1142 | *
1143 | * @param {number=} count Number of responses to flush (in the order they arrived). If undefined,
1144 | * all pending requests will be flushed. If there are no pending requests when the flush method
1145 | * is called an exception is thrown (as this typically a sign of programming error).
1146 | */
1147 | $httpBackend.flush = function(count) {
1148 | if (!responses.length) throw Error('No pending request to flush !');
1149 |
1150 | if (angular.isDefined(count)) {
1151 | while (count--) {
1152 | if (!responses.length) throw Error('No more pending request to flush !');
1153 | responses.shift()();
1154 | }
1155 | } else {
1156 | while (responses.length) {
1157 | responses.shift()();
1158 | }
1159 | }
1160 | $httpBackend.verifyNoOutstandingExpectation();
1161 | };
1162 |
1163 |
1164 | /**
1165 | * @ngdoc method
1166 | * @name ngMock.$httpBackend#verifyNoOutstandingExpectation
1167 | * @methodOf ngMock.$httpBackend
1168 | * @description
1169 | * Verifies that all of the requests defined via the `expect` api were made. If any of the
1170 | * requests were not made, verifyNoOutstandingExpectation throws an exception.
1171 | *
1172 | * Typically, you would call this method following each test case that asserts requests using an
1173 | * "afterEach" clause.
1174 | *
1175 | *