/**
 * @license Angular v8.0.0-beta.10+1.sha-a28b3e3
 * (c) 2010-2019 Google LLC. https://angular.io/
 * License: MIT
 */

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/http'), require('rxjs'), require('rxjs/operators')) :
    typeof define === 'function' && define.amd ? define('@angular/http/testing', ['exports', '@angular/core', '@angular/http', 'rxjs', 'rxjs/operators'], factory) :
    (global = global || self, factory((global.ng = global.ng || {}, global.ng.http = global.ng.http || {}, global.ng.http.testing = {}), global.ng.core, global.ng.http, global.rxjs, global.rxjs.operators));
}(this, function (exports, core, http, rxjs, operators) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */

    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }

    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
    }

    /**
     * @license
     * Copyright Google Inc. All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
    /**
     *
     * Mock Connection to represent a {@link Connection} for tests.
     *
     * @usageNotes
     * ### Example of `mockRespond()`
     *
     * ```
     * var connection;
     * backend.connections.subscribe(c => connection = c);
     * http.request('data.json').subscribe(res => console.log(res.text()));
     * connection.mockRespond(new Response(new ResponseOptions({ body: 'fake response' }))); //logs
     * 'fake response'
     * ```
     *
     * ### Example of `mockError()`
     *
     * ```
     * var connection;
     * backend.connections.subscribe(c => connection = c);
     * http.request('data.json').subscribe(res => res, err => console.log(err)));
     * connection.mockError(new Error('error'));
     * ```
     *
     * @deprecated see https://angular.io/guide/http
     * @publicApi
     */
    var MockConnection = /** @class */ (function () {
        function MockConnection(req) {
            this.response = new rxjs.ReplaySubject(1).pipe(operators.take(1));
            this.readyState = http.ReadyState.Open;
            this.request = req;
        }
        /**
         * Sends a mock response to the connection. This response is the value that is emitted to the
         * {@link EventEmitter} returned by {@link Http}.
         *
         */
        MockConnection.prototype.mockRespond = function (res) {
            if (this.readyState === http.ReadyState.Done || this.readyState === http.ReadyState.Cancelled) {
                throw new Error('Connection has already been resolved');
            }
            this.readyState = http.ReadyState.Done;
            this.response.next(res);
            this.response.complete();
        };
        /**
         * Not yet implemented!
         *
         * Sends the provided {@link Response} to the `downloadObserver` of the `Request`
         * associated with this connection.
         */
        MockConnection.prototype.mockDownload = function (res) {
            // this.request.downloadObserver.onNext(res);
            // if (res.bytesLoaded === res.totalBytes) {
            //   this.request.downloadObserver.onCompleted();
            // }
        };
        // TODO(jeffbcross): consider using Response type
        /**
         * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
         * returned
         * from {@link Http}.
         *
         */
        MockConnection.prototype.mockError = function (err) {
            // Matches ResourceLoader semantics
            this.readyState = http.ReadyState.Done;
            this.response.error(err);
        };
        return MockConnection;
    }());
    /**
     * A mock backend for testing the {@link Http} service.
     *
     * This class can be injected in tests, and should be used to override providers
     * to other backends, such as {@link XHRBackend}.
     *
     * @usageNotes
     * ### Example
     *
     * ```
     * import {Injectable, Injector} from '@angular/core';
     * import {async, fakeAsync, tick} from '@angular/core/testing';
     * import {BaseRequestOptions, ConnectionBackend, Http, RequestOptions} from '@angular/http';
     * import {Response, ResponseOptions} from '@angular/http';
     * import {MockBackend, MockConnection} from '@angular/http/testing';
     *
     * const HERO_ONE = 'HeroNrOne';
     * const HERO_TWO = 'WillBeAlwaysTheSecond';
     *
     * @Injectable()
     * class HeroService {
     *   constructor(private http: Http) {}
     *
     *   getHeroes(): Promise<String[]> {
     *     return this.http.get('myservices.de/api/heroes')
     *         .toPromise()
     *         .then(response => response.json().data)
     *         .catch(e => this.handleError(e));
     *   }
     *
     *   private handleError(error: any): Promise<any> {
     *     console.error('An error occurred', error);
     *     return Promise.reject(error.message || error);
     *   }
     * }
     *
     * describe('MockBackend HeroService Example', () => {
     *   beforeEach(() => {
     *     this.injector = Injector.create([
     *       {provide: ConnectionBackend, useClass: MockBackend},
     *       {provide: RequestOptions, useClass: BaseRequestOptions},
     *       Http,
     *       HeroService,
     *     ]);
     *     this.heroService = this.injector.get(HeroService);
     *     this.backend = this.injector.get(ConnectionBackend) as MockBackend;
     *     this.backend.connections.subscribe((connection: any) => this.lastConnection = connection);
     *   });
     *
     *   it('getHeroes() should query current service url', () => {
     *     this.heroService.getHeroes();
     *     expect(this.lastConnection).toBeDefined('no http service connection at all?');
     *     expect(this.lastConnection.request.url).toMatch(/api\/heroes$/, 'url invalid');
     *   });
     *
     *   it('getHeroes() should return some heroes', fakeAsync(() => {
     *        let result: String[];
     *        this.heroService.getHeroes().then((heroes: String[]) => result = heroes);
     *        this.lastConnection.mockRespond(new Response(new ResponseOptions({
     *          body: JSON.stringify({data: [HERO_ONE, HERO_TWO]}),
     *        })));
     *        tick();
     *        expect(result.length).toEqual(2, 'should contain given amount of heroes');
     *        expect(result[0]).toEqual(HERO_ONE, ' HERO_ONE should be the first hero');
     *        expect(result[1]).toEqual(HERO_TWO, ' HERO_TWO should be the second hero');
     *      }));
     *
     *   it('getHeroes() while server is down', fakeAsync(() => {
     *        let result: String[];
     *        let catchedError: any;
     *        this.heroService.getHeroes()
     *            .then((heroes: String[]) => result = heroes)
     *            .catch((error: any) => catchedError = error);
     *        this.lastConnection.mockError(new Response(new ResponseOptions({
     *          status: 404,
     *          statusText: 'URL not Found',
     *        })));
     *        tick();
     *        expect(result).toBeUndefined();
     *        expect(catchedError).toBeDefined();
     *      }));
     * });
     * ```
     *
     * @deprecated see https://angular.io/guide/http
     * @publicApi
     */
    var MockBackend = /** @class */ (function () {
        function MockBackend() {
            var _this = this;
            this.connectionsArray = [];
            this.connections = new rxjs.Subject();
            this.connections.subscribe(function (connection) { return _this.connectionsArray.push(connection); });
            this.pendingConnections = new rxjs.Subject();
        }
        /**
         * Checks all connections, and raises an exception if any connection has not received a response.
         *
         * This method only exists in the mock implementation, not in real Backends.
         */
        MockBackend.prototype.verifyNoPendingRequests = function () {
            var pending = 0;
            this.pendingConnections.subscribe(function (c) { return pending++; });
            if (pending > 0)
                throw new Error(pending + " pending connections to be resolved");
        };
        /**
         * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve
         * connections, if it's expected that there are connections that have not yet received a response.
         *
         * This method only exists in the mock implementation, not in real Backends.
         */
        MockBackend.prototype.resolveAllConnections = function () { this.connections.subscribe(function (c) { return c.readyState = 4; }); };
        /**
         * Creates a new {@link MockConnection}. This is equivalent to calling `new
         * MockConnection()`, except that it also will emit the new `Connection` to the `connections`
         * emitter of this `MockBackend` instance. This method will usually only be used by tests
         * against the framework itself, not by end-users.
         */
        MockBackend.prototype.createConnection = function (req) {
            if (!req || !(req instanceof http.Request)) {
                throw new Error("createConnection requires an instance of Request, got " + req);
            }
            var connection = new MockConnection(req);
            this.connections.next(connection);
            return connection;
        };
        MockBackend = __decorate([
            core.Injectable(),
            __metadata("design:paramtypes", [])
        ], MockBackend);
        return MockBackend;
    }());

    /**
     * @license
     * Copyright Google Inc. All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */

    /**
     * @license
     * Copyright Google Inc. All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */

    /**
     * @license
     * Copyright Google Inc. All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */

    /**
     * Generated bundle index. Do not edit.
     */

    exports.MockConnection = MockConnection;
    exports.MockBackend = MockBackend;

    Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=http-testing.umd.js.map