Javascript 为什么可以'；I spyOn（）注入服务中的某些函数？

我正在测试我的一个组件，它调用多个服务。我一直在注入服务，并使用

spyOn（）

模拟假函数调用

我的问题是，在此服务上调用特定函数会产生错误

error:

。对于同一服务中的其他函数，我可以

spyOn（）

BasketController

依赖于

ThingService

的一些相关代码片段：

编辑：清除代码

单元测试

describe("BasketController test", () => {
    let $componentController: ng.IComponentControllerService;
    let $scope: ng.IRootScopeService;
    let BasketService;
    let ctrl;
    let ThingService: ThingService;

    // Injections and controller
    beforeEach(() => {
        angular.mock.module("myModule");

        angular.mock.inject(
            (_$componentController_: ng.IComponentControllerService,
                _$rootScope_: ng.IRootScopeService,
                _BasketService_: BasketService,
                _ThingService_: ThingService
            ) => {
                $componentController = _$componentController_;
                $scope = _$rootScope_;
                BasketService = _BasketService_;
                ThingService = _ThingService_;
            }
        );

        ctrl = $componentController('basket',
            {
                '$scope': $scope,
                'BasketService': BasketService,
                'ThingService': ThingService
            }
        );

        spyOn(ThingService, 'refreshThings').and.callFake(() => {
        });
    });

    it('should be testable', () => {
        expect(ctrl).toBeDefined();
    });

控制器

export class BasketController {
    static $inject = ["BasketService", "$state", "AlertService", "$filter", "ThingService"];

    constructor(_BasketService_: BasketService,
        private $state: ng.ui.IStateService,
        private AlertService: AlertService,
        private $filter,
        private ThingService: ThingService) {
            this.BasketService = _BasketService_;
    }

    BasketService: BasketService;
    headerData: Object;
    basketForm: ng.IFormController;
    basket: Basket;
    basketList: Array<Basket>;
    selectAll: boolean;

    toolbarButtons: any;
    columns: [string];
    itemFormatter: any;
    self: any;

    $onInit() {
        // GETs baskets from the service
        this.ThingService.refreshThings();
    }
}

导出类BasketController{
静态$inject=[“BasketService”、“$state”、“AlertService”、“$filter”、“ThingService”]；
建造商（_BasketService）uu：BasketService，
私有$state:ng.ui.IStateService，
私人警报服务：警报服务，
私人$filter，
私人ThingService：ThingService）{
this.BasketService=\u BasketService；
}
篮球服务：篮球服务；
headerData：对象；
篮筐形式：ng.1；
篮子：篮子；
篮表：数组；
selectAll：布尔型；
工具栏按钮：任意；
列：[字符串]；
itemFormatter：任何；
自我：任何；
$onInit（）{
//从服务中获取篮子
此.ThingService.refreshThings（）；
}
}

注入式服务

export class ThingService {

    static $inject = ["ApiHttpService", "$q", "AlertService", "StatusThingService"];
    currentThing: Thing;
    thingList: Array<Thing>;

    constructor(private ApiHttpService: IHttpService,
        private $q: ng.IQService,
        private AlertService: AlertService,
        private StatusThingService: StatusThingService) {
    }

    $onInit() {
    }

    getThing(href:string) {

        let defer = this.$q.defer();

        this.ApiHttpService.get(href).then(
            (res:GetThing) => {
                defer.resolve(res);
            },
            (res) => {
                defer.reject(res);
            }
        );

        return defer.promise;
    }

    getAllThings() {

        let defer = this.$q.defer();

        this.ApiHttpService.get("/api/Thing").then(
            (res:Array<GetThing>) => {
                defer.resolve(res);
            },
            (res) => {
                defer.reject(res);
            }
        );

        return defer.promise;
    }

    refreshThings() {
        this.thingList = [];

        this.getAllThings().then(
            (res:Array<GetThing>) => {

                for(let getTemp of res) {
                    let thing = new Thing();
                    thing.fromGet(getTemp);
                    this.thingList.push(thing);
                }
            },
            (res) => {
                console.error("Unable to refresh things");
            }
        );
    }

}

Main.module.service("ThingService", ThingService);

导出类ThingService{
静态$inject=[“ApiHttpService”、“$q”、“AlertService”、“StatusThingService”]；
当前事物：事物；
thingList：数组；
建造商（专用APIHTPService:IHttpService，
私人$q:ng.IQ服务，
私人警报服务：警报服务，
专用StatusThingService:StatusThingService）{
}
$onInit（）{
}
获取（href:string）{
设defer=this.$q.defer（）；
这个.apittpservice.get（href）(
（res:getting）=>{
延迟.解决（res）；
},
（res）=>{
延迟、拒绝（res）；
}
);
回报、承诺；
}
getAllThings（）{
设defer=this.$q.defer（）；
这个.apittpservice.get（“/api/Thing”）。然后(
（res:Array）=>{
延迟.解决（res）；
},
（res）=>{
延迟、拒绝（res）；
}
);
回报、承诺；
}
更新内容（）{
this.thingList=[]；
这个。getAllThings（）。然后(
（res:Array）=>{
for（让我们从res中获取temp）{
让事物=新事物（）；
thing.fromGet（getTemp）；
这个。物品清单。推（东西）；
}
},
（res）=>{
控制台错误（“无法刷新内容”）；
}
);
}
}
Main.module.service（“ThingService”，ThingService）；

同样，尝试监视refreshThings会导致错误

error:：refreshThings（）方法不存在

，而监视服务中的任何其他函数都可以正常工作

---

真的是我的头巾，所以任何帮助都非常感谢。谢谢

我不知道Angular，但是

ThingService

看起来像一个构造函数/类，所以你可以尝试监视原型，比如

spyOn（ThingService.prototype，'refreshThings'）