Angular2/Jasmine：监视单元测试方法不'；看不到被调用的方法

我在检测间谍方面遇到了问题，我调用了一个函数。这是服务的单元测试。 我尝试了两种不同的方法：TestBed.get-on方法（在“it应该只检查状态”中）和spy-on注入的虚拟类（“it应该登录到facebook未知”），但这两种方法似乎都不起作用 我已经做了一些打印，看看是否使用了该方法，并显示了。 这是一个规范文件：

import { TestBed, inject, async } from '@angular/core/testing';

import {FacebookServiceMock } from './../test-helpers/facebook-service-mock';
import { SocialsServiceDummy } from './../test-helpers/socialsServiceDummy';
import { ErrorDouble } from './../test-helpers/errorDouble';

import { ErrorsService } from './../../app/services/errors.service';
import { social_config, SocialConfig, SOCIAL_CONFIG } from './../../app/socials/social-config';
import { SocialsService } from './../../app/services/socials.service';
import { FacebookLoginService } from './../../app/services/facebook-login.service';
import { FacebookService } from 'ngx-facebook';

describe('Facebook-login-service test', () => {
    let socialsServiceSpy: any;

    beforeEach(async(() => {
        TestBed.configureTestingModule({
            providers: [
                FacebookLoginService,
                { provide: FacebookService, useFactory: () => { return new FacebookServiceMock() }},
                { provide: SocialsService, useFactory: () => {  return new SocialsServiceDummy() }},
                { provide: ErrorsService, useFactory: () => { return new ErrorDouble() } },
                { provide: social_config, useValue: SOCIAL_CONFIG }
            ]
        });


    });

    beforeEach(() => {
        socialsServiceSpy = TestBed.get(SocialsService);
        spyOn(socialsServiceSpy, 'updateAccount');

    });

    afterEach(()=>{
        TestBed.resetTestingModule();

    });

    it('should login unknown to facebook',
        async(inject([FacebookLoginService, FacebookService, SocialsService, ErrorsService, social_config], (facebookLoginService, FacebookServiceMock, SocialsServiceDummy, ErrorDouble, SOCIAL_CONFIG) => {
                let mockReturn = {
                    status: "unknown",
                    authResponse: {
                        userID: '123456',
                        accessToken: 'token',
                        expiresIn: 3600
                    }
                };

                spyOn(FacebookServiceMock, 'getLoginStatus').and.returnValue(Promise.resolve(mockReturn));
                spyOn(SocialsServiceDummy, 'addNewSocialAccount').and.callThrough();
                spyOn(facebookLoginService, 'loginToFacebook').and.callThrough();

                facebookLoginService.checkLoginStatus();
                expect(facebookLoginService.loginToFacebook).toHaveBeenCalled();
                expect(SocialsServiceDummy.addNewSocialAccount).toHaveBeenCalledWith('facebook', mockReturn.authResponse.userID, mockReturn.authResponse.accessToken, mockReturn.authResponse.expiresIn);
            })
        ));

    it('should check only status',
        async(inject([FacebookLoginService, FacebookService, SocialsService, ErrorsService, social_config], (facebookLoginService, FacebookServiceMock, SocialsServiceDummy, ErrorDouble, SOCIAL_CONFIG) => {
                let mockReturn = {
                    status: "connected",
                    authResponse: {
                        userID: '123456',
                        accessToken: 'token',
                        expiresIn: 3600
                    }
                };
                spyOn(FacebookServiceMock, 'getLoginStatus').and.returnValue(Promise.resolve(mockReturn));
               // spyOn(SocialsServiceDummy, 'updateAccount').and.callThrough();

                facebookLoginService.checkLoginStatus();
                expect(socialsServiceSpy.updateAccount).toHaveBeenCalledWith('facebook', mockReturn.authResponse.userID, mockReturn.authResponse.accessToken, mockReturn.authResponse.expiresIn);


            })
        ));
});

FacebookLoginService如下所示：

/**
 * Created by Daniel on 2017-06-19.
 */
import { Injectable, Inject } from '@angular/core';
import { Subject } from 'rxjs/Subject';
import { FacebookService, LoginResponse, LoginOptions } from 'ngx-facebook';
import { ErrorsService } from './errors.service';
import { social_config, SocialConfig } from './../socials/social-config';
import { NewSocialAccount } from './../shared/models/new-social-account';
import { SocialsService } from "./socials.service";

@Injectable()

export class FacebookLoginService {
    private loginOptions : LoginOptions = {
        scope: this.socialConfig.facebook.scope
    }

    private attemptToLogin =  new Subject<boolean>()
    private newSocialAccount =  new Subject<any>();

    login$ = this.attemptToLogin.asObservable();
    newSocial$ = this.newSocialAccount.asObservable();

    constructor(
        private facebookService: FacebookService,
        private socialsService: SocialsService,
        private errorsService: ErrorsService,
        @Inject(social_config) private socialConfig: SocialConfig
    ) {}

    initSocials() : void {
        this.facebookService.init({appId: this.socialConfig.facebook.appId, version: this.socialConfig.facebook.version});
    }

    checkLoginStatus() : void{
        this.facebookService.getLoginStatus().then(
            (res) => {
                if(res.status == "connected") {
                    const updatedAccount = this.createNewAccountObject('facebook', res.authResponse.userID, res.authResponse.accessToken, res.authResponse.expiresIn);
                    this.socialsService.updateAccount(updatedAccount).then(
                        () => {
                            this.attemptToLogin.next(true);
                        },
                        error => {
                            this.errorsService.startErrorAction(error);
                        }
                    )
                } else {
                   this.loginToFacebook();
                }
            },
            error => {
                alert('Unable to connect with Facebook. Please try later');
            }
        )
    }

    loginToFacebook() : void {
        this.facebookService.login(this.loginOptions).then(
            (res: LoginResponse) => {
                const newAccount = this.createNewAccountObject('facebook', res.authResponse.userID, res.authResponse.accessToken, res.authResponse.expiresIn);
                this.socialsService.addNewSocialAccount(newAccount).then(
                    (res) => {
                        this.confirmLoginNewSocialAccount(res, 'facebook');
                    },
                    error => {
                        this.errorsService.startErrorAction(error);
                    }
                )
            },
            error => {
                alert('Unable to connect with Facebook. Please try later');
            }
        )

    }

    logout(): void {
        this.facebookService.logout();
    }

    private createNewAccountObject(socialStr: string, userStr: string, tokenStr: string, expiresNr: number): NewSocialAccount {
            return {
                social: socialStr,
                userID: userStr,
                token: tokenStr,
                expires:  expiresNr
            };
        }

    private confirmLoginNewSocialAccount(response: any, accountType: string) {
        this.newSocialAccount.next({login: response.login, social: accountType});

    }
}

/**
*丹尼尔于2017年6月19日创作。
*/
从“@angular/core”导入{Injectable，injection}；
从'rxjs/Subject'导入{Subject}；
从“ngx facebook”导入{FacebookService、LoginResponse、LoginOptions}；
从“./errors.service”导入{ErrorsService}；
从“/../socials/social-config”导入{social_-config，SocialConfig}；
从“/../shared/models/new social account”导入{NewSocialAccount}；
从“/socials.service”导入{socialservice}；
@可注射（）
导出类FacebookLoginService{
私人登录选项：登录选项={
范围：this.socialConfig.facebook.scope
}
私有attemptologin=新主题（）
private newSocialAccount=新主题（）；
login$=this.attemptologin.asObservable（）；
newSocial$=this.newSocialAccount.asObservable（）；
建造师(
私人facebookService:facebookService，
私人社会服务：社会服务，
私人错误服务：错误服务，
@注入（社会配置）私有社会配置：社会配置
) {}
initSocials（）：void{
this.facebookService.init（{appId:this.socialConfig.facebook.appId，版本：this.socialConfig.facebook.version}）；
}
checkLoginStatus（）：void{
这是.facebookService.getLoginStatus（）。然后(
（res）=>{
如果（资源状态==“已连接”）{
const updateAccount=this.createNewAccountObject（'facebook'，res.authResponse.userID，res.authResponse.accessToken，res.authResponse.expiresIn）；
这个.socialService.updateAccount（updateAccount）。然后(
() => {
this.attemptologin.next（true）；
},
错误=>{
此.errorsService.startErrorAction（错误）；
}
)
}否则{
this.loginToFacebook（）；
}
},
错误=>{
警报（“无法连接到Facebook，请稍后再试”）；
}
)
}
loginToFacebook（）：void{
this.facebookService.login（this.loginOptions）。然后(
（res:LoginResponse）=>{
const newAccount=this.createNewAccountObject（'facebook'，res.authResponse.userID，res.authResponse.accessToken，res.authResponse.expiresIn）；
这个.socialservice.addNewSocialAccount（newAccount）。然后(
（res）=>{
confirmLoginNewSocialAccount（res，“facebook”）；
},
错误=>{
此.errorsService.startErrorAction（错误）；
}
)
},
错误=>{
警报（“无法连接到Facebook，请稍后再试”）；
}
)
}
注销（）：void{
这个.facebookService.logout（）；
}
私有createNewAccountObject（socialStr:string，userStr:string，tokenStr:string，expiresNr:number）：NewSocialCount{
返回{
社会的：社会的，
userID:userStr，
token:tokenStr，
expires:expiresNr
};
}
私有confirmLoginNewSocialCount（响应：任意，帐户类型：字符串）{
this.newSocialAccount.next（{login:response.login，social:accountType}）；
}
}

这是来自社会服务的虚拟文件

import { SocialAccount} from './../../app/shared/models/social-account';
import { NewSocialAccount} from './../../app/shared/models/new-social-account';

export class SocialsServiceDummy {

    getSocials(): Promise<SocialAccount[]> {
      let socials =  [

      ];
      return Promise.resolve(socials);
    }

    addNewSocialAccount(newAccount: NewSocialAccount) : Promise<any>{
      let social4 = {login: 'facebook', userId: '1fsdf42343', token: 'some_token', expire: 3600};
      return Promise.resolve(social4);
    }

    deleteAccount(id: number): Promise<void> {
      return Promise.resolve(null);
    }

    updateAccount(account: SocialAccount ):  Promise<void>{
        return Promise.resolve(null);
    }

}

从“/../app/shared/models/SocialAccount”导入{SocialAccount}；
从“/../app/shared/models/new socialaccount”导入{NewSocialAccount}；
导出类SocialServiceDummy{
getSocials（）：承诺{
让社会=[
];
回报承诺。解决（社交）；
}
addNewSocialAccount（newAccount:NewSocialAccount）：承诺{
让social4={login:'facebook'，userId:'1fsdf42343'，token:'some_token'，过期：3600}；
回报承诺。解决（社会4）；
}
删除帐户（id:编号）：承诺{
返回承诺。解析（空）；
}
updateAccount（帐户：SocialAccount）：承诺{
返回承诺。解析（空）；
}
}

我已经从FacebookServiceMock辞职，只将其用作注入存根，并从spy返回结果。 错误双精度和社交配置也是存根

我很高兴能在我做错了什么方面得到一些帮助

---

干杯。

我用的是

spyOn

差异。也许这样行得通：

let spy = spyOn(new Date(), 'toString');
expect(spy.calls.count()>0).toBeTruthy();