446 lines
24 KiB
TypeScript
446 lines
24 KiB
TypeScript
import { ReactiveFormsModule } from '@angular/forms';
|
|
import { TestBed } from '@angular/core/testing';
|
|
import { RouterTestingModule } from '@angular/router/testing';
|
|
import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
|
|
import { NO_ERRORS_SCHEMA } from '@angular/core';
|
|
import { CreditApplicationDaoService } from './credit-application-dao.service';
|
|
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
|
|
import { CreditApplicationService } from './credit-application.service';
|
|
import { configureTestSuite } from 'ng-bullet';
|
|
import { LoanType, LoanTypeSet } from './loan-type';
|
|
import { LoanTitle } from './loan-type/loan-title';
|
|
import { CreditApplicationValues } from './credit-application-values';
|
|
import { of } from 'rxjs';
|
|
import { apiTranslatorPreTranslate } from '../testing/shared-mocks/api-translator-pre-post';
|
|
import { EthnicityInformation } from '../loan-wizard/field-groups/hmda/ethnicity-information';
|
|
import { GenderInformation } from '../loan-wizard/field-groups/hmda/gender-information';
|
|
import { RaceInformation } from '../loan-wizard/field-groups/hmda/race-information';
|
|
import { BorrowerType } from './borrower-type';
|
|
import { EmploymentInformation } from '../loan-wizard/field-groups/employment/employment-information';
|
|
import { IncomeInformation } from '../loan-wizard/field-groups/employment/income-information';
|
|
import { AlimonyInformation } from '../loan-wizard/field-groups/employment/alimony-information';
|
|
import { CreditApplication, SpouseType, TattleIndividual } from './credit-application';
|
|
import { AddressInformation } from '../loan-wizard/field-groups/address/address-information';
|
|
import { ResidenceInformation } from '../loan-wizard/field-groups/address/residence-information';
|
|
import { PersonalInformation } from '../loan-wizard/field-groups/personal/personal-information';
|
|
import { IsFullInfoSpouse } from '../loan-wizard/field-groups/spouse-type/is-full-info-spouse-information';
|
|
import { PhoneTypeEnum, PropertyTypeEnum } from './api-models/api-enums';
|
|
import { MembershipInformation } from '../loan-wizard/field-groups/member/membership-information';
|
|
import { primaryAndCoApplicationAddressSameApplication } from '../testing/shared-mocks/broken-applications';
|
|
import { ConfigurationService } from './configuration/configuration.service';
|
|
import { UiSettings } from './configuration/ui-settings';
|
|
import { DefaultSettings } from './configuration/default-settings.mock';
|
|
|
|
describe('CreditApplicationService', () => {
|
|
|
|
let creditApplicationService: CreditApplicationService;
|
|
let creditApplicationDaoService: CreditApplicationDaoService;
|
|
let httpMock: HttpTestingController;
|
|
|
|
configureTestSuite(() => {
|
|
TestBed.configureTestingModule({
|
|
imports: [
|
|
RouterTestingModule,
|
|
NgbModule.forRoot(),
|
|
ReactiveFormsModule,
|
|
HttpClientTestingModule
|
|
],
|
|
schemas: [
|
|
NO_ERRORS_SCHEMA
|
|
],
|
|
declarations: [],
|
|
providers: [
|
|
CreditApplicationDaoService
|
|
]
|
|
});
|
|
});
|
|
|
|
beforeEach(() => {
|
|
creditApplicationService = TestBed.get(CreditApplicationService);
|
|
creditApplicationDaoService = TestBed.get(CreditApplicationDaoService);
|
|
httpMock = TestBed.get(HttpTestingController);
|
|
creditApplicationService.setLoanType(LoanTypeSet[0].id);
|
|
});
|
|
|
|
it('should create', () => {
|
|
expect(creditApplicationService).toBeTruthy();
|
|
});
|
|
|
|
it('should save term of loan for equity member', () => {
|
|
creditApplicationService.setLoanType(LoanTypeSet[4].id);
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.callThrough();
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
const testStub = {
|
|
'applicantType': CreditApplicationValues.CHOICE_NO,
|
|
'limitRequested': '1000',
|
|
'termOfLoan': 120,
|
|
'maritalStatus': CreditApplicationValues.CHOICE_NO,
|
|
'clientMessage': 'test message'
|
|
};
|
|
creditApplicationService.saveEquityMemberInformation(testStub);
|
|
const creditApplication = creditApplicationService.getFullCreditApplication();
|
|
expect(creditApplicationService.getFullCreditApplication).toHaveBeenCalled();
|
|
expect(creditApplication.termOfLoan).toBeGreaterThanOrEqual(120);
|
|
expect(creditApplication.clientMessage).toEqual(testStub.clientMessage);
|
|
});
|
|
|
|
it('should save HMDA information', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
const ethnicity: EthnicityInformation = {
|
|
cuban: true,
|
|
otherHispanicLatinoText: 'San Lorenzoan'
|
|
};
|
|
const sex: GenderInformation = {
|
|
male: true,
|
|
female: true
|
|
};
|
|
const race: RaceInformation = {
|
|
filipino: true,
|
|
americanIndianAlaskaNativeText: 'False Karass'
|
|
};
|
|
const hmda = {
|
|
ethnicityInformation: ethnicity,
|
|
genderInformation: sex,
|
|
raceInformation: race
|
|
};
|
|
creditApplicationService.saveHMDAInformation(hmda, BorrowerType.CO_BORROWER);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[1].ethnicityInformation).toEqual(ethnicity);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[1].genderInformation).toEqual(sex);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[1].raceInformation).toEqual(race);
|
|
});
|
|
|
|
it('should set loantype if existing credit application has different loantype', () => {
|
|
const result = creditApplicationService.shouldSetupCreditApplication(LoanTypeSet[1]);
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should NOT set loantype if existing credit application has same loantype', () => {
|
|
const result = creditApplicationService.shouldSetupCreditApplication(LoanTypeSet[0]);
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should save and process employment/income information, only once', () => {
|
|
const testEmploymentInformation: Array<EmploymentInformation> = [{
|
|
employerName: 'emp1',
|
|
employmentType: '3',
|
|
jobTitle: 'senior qa',
|
|
salary: 5000,
|
|
schedule: 'Hourly',
|
|
employmentLengthYears: 5,
|
|
employmentLengthMonths: 0,
|
|
workPhoneNumber: ''
|
|
}];
|
|
const testIncomeInformation: Array<IncomeInformation> = [{
|
|
incomeName: 'Pension',
|
|
amount: 4000
|
|
},
|
|
{
|
|
incomeName: 'Gambling',
|
|
amount: 10000
|
|
},
|
|
{
|
|
incomeName: 'Check from parents',
|
|
amount: 20000
|
|
}];
|
|
const testAlimonyInformaiton: AlimonyInformation = {
|
|
childSupportAmount: 3000
|
|
};
|
|
spyOn(creditApplicationService, 'saveEmploymentInformation').and.callThrough();
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
creditApplicationService.saveAllEmploymentInformation(
|
|
testEmploymentInformation, testIncomeInformation, testAlimonyInformaiton, BorrowerType.PRIMARY_BORROWER);
|
|
// Bug #840, Make sure calling twice doesn't ADD
|
|
creditApplicationService.saveAllEmploymentInformation(
|
|
testEmploymentInformation, testIncomeInformation, testAlimonyInformaiton, BorrowerType.PRIMARY_BORROWER);
|
|
const employmentInfo = creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].employmentInformation;
|
|
const otherIncome = creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].otherIncomeInformation;
|
|
const alimony = creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].alimonyInformation;
|
|
expect(creditApplicationService.getFullCreditApplication().page.hasEmployment).toBe(true);
|
|
expect(employmentInfo).toBeTruthy();
|
|
expect(employmentInfo.length).toEqual(1); // Called twice, should only be one.
|
|
expect(employmentInfo[0].jobTitle).toEqual('senior qa');
|
|
expect(employmentInfo[0].employerName).toEqual('emp1');
|
|
expect(employmentInfo[0].salary).toEqual(5000);
|
|
expect(otherIncome[0].amount).toEqual(4000);
|
|
expect(otherIncome[0].incomeName).toBe('Pension');
|
|
expect(otherIncome[1].amount).toEqual(10000);
|
|
expect(otherIncome[1].incomeName).toBe('Gambling');
|
|
expect(otherIncome[2].amount).toEqual(20000);
|
|
expect(otherIncome[2].incomeName).toBe('Check from parents');
|
|
expect(alimony.childSupportAmount).toEqual(3000);
|
|
});
|
|
|
|
// tslint:disable-next-line:max-line-length
|
|
it('should remove spouseType from a fullInfoBorrower who has changed state of residence such that spouse information is not required', () => {
|
|
const marriedPrimaryApplication: CreditApplication = apiTranslatorPreTranslate;
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].fullInfoSpouse = apiTranslatorPreTranslate.fullInfoBorrowers[1];
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].spouseType = SpouseType.FullInfoSpouse;
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
const addressInformation: AddressInformation = marriedPrimaryApplication.fullInfoBorrowers[0].addressInformation;
|
|
addressInformation.state = 'IL';
|
|
creditApplicationService.saveAllAddressInformation(BorrowerType.PRIMARY_BORROWER, addressInformation);
|
|
expect(creditApplicationService.getFullCreditApplication().page.hasAddress).toBe(true);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].spouseType).toBeFalsy();
|
|
// This is an 'after' hook
|
|
addressInformation.state = CreditApplicationValues.STATE_REQUIRED_COAPP;
|
|
creditApplicationService.saveAllAddressInformation(BorrowerType.PRIMARY_BORROWER, addressInformation);
|
|
});
|
|
|
|
it('should save address and residence history', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
const addressInformation: AddressInformation = apiTranslatorPreTranslate.fullInfoBorrowers[0].addressInformation;
|
|
const residenceInformation: ResidenceInformation = apiTranslatorPreTranslate.fullInfoBorrowers[0].residenceInformation;
|
|
const priorAddress: Array<AddressInformation> = [apiTranslatorPreTranslate.fullInfoBorrowers[1].addressInformation];
|
|
const priorResidence: Array<ResidenceInformation> = [apiTranslatorPreTranslate.fullInfoBorrowers[1].residenceInformation];
|
|
creditApplicationService.saveAddressAndResidenceInformation({
|
|
addressInfo: addressInformation,
|
|
residenceInfo: residenceInformation,
|
|
priorAddressInfo: priorAddress,
|
|
priorResidenceInfo: priorResidence
|
|
}, BorrowerType.CO_BORROWER);
|
|
const result = creditApplicationService.getFullCreditApplication();
|
|
expect(result.fullInfoBorrowers[1].addressInformation).toEqual(addressInformation);
|
|
expect(result.fullInfoBorrowers[1].residenceInformation).toEqual(residenceInformation);
|
|
expect(result.fullInfoBorrowers[1].priorAddressInformation).toEqual(priorAddress);
|
|
expect(result.fullInfoBorrowers[1].priorResidenceInformation).toEqual(priorResidence);
|
|
});
|
|
|
|
it('should save mailing address when it differs from current address', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
const PRIMARY = 0;
|
|
const mailingAddress = {
|
|
addressLine1: '200 S Wacker',
|
|
addressLine2: 'Dr # 3600',
|
|
zipcode: '60606',
|
|
city: 'Chicago',
|
|
state: 'IL'
|
|
};
|
|
apiTranslatorPreTranslate.fullInfoBorrowers[PRIMARY].residenceInformation.isMailingAddressSame = false;
|
|
apiTranslatorPreTranslate.fullInfoBorrowers[PRIMARY].mailingAddressInformation = mailingAddress;
|
|
const addressInformation: AddressInformation = apiTranslatorPreTranslate.fullInfoBorrowers[PRIMARY].addressInformation;
|
|
const residenceInformation: ResidenceInformation = apiTranslatorPreTranslate.fullInfoBorrowers[PRIMARY].residenceInformation;
|
|
const mailingInformation: AddressInformation = apiTranslatorPreTranslate.fullInfoBorrowers[PRIMARY].mailingAddressInformation;
|
|
creditApplicationService.saveAddressAndResidenceInformation({
|
|
addressInfo: addressInformation,
|
|
residenceInfo: residenceInformation,
|
|
mailingInfo: mailingInformation
|
|
}, BorrowerType.PRIMARY_BORROWER);
|
|
const result = creditApplicationService.getFullCreditApplication();
|
|
expect(result.fullInfoBorrowers[PRIMARY].addressInformation).toEqual(addressInformation);
|
|
expect(result.fullInfoBorrowers[PRIMARY].mailingAddressInformation).toEqual(mailingInformation);
|
|
expect(result.fullInfoBorrowers[PRIMARY].residenceInformation).toEqual(residenceInformation);
|
|
});
|
|
|
|
it('should determine if there is enough data to save ', () => {
|
|
const application = creditApplicationService.getFullCreditApplication();
|
|
application.fullInfoBorrowers[0].personalInformation.firstName = 'Bob';
|
|
application.fullInfoBorrowers[0].addressInformation.addressLine1 = '1235 Maple Ave';
|
|
const result = creditApplicationService.hasMinimumSaveInformation();
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should nullify previously entered spouse information when an applicant changes their marital status from YES to NO', () => {
|
|
const marriedPrimaryApplication: CreditApplication = apiTranslatorPreTranslate;
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].fullInfoSpouse = apiTranslatorPreTranslate.fullInfoBorrowers[1];
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].spouseType = SpouseType.FullInfoSpouse;
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].spouseType).toBe(SpouseType.FullInfoSpouse);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].fullInfoSpouse).toBeTruthy();
|
|
const personalInfo: PersonalInformation = {
|
|
firstName: 'Someone',
|
|
lastName: 'who changed their mind',
|
|
dateOfBirth: 'about being married',
|
|
primaryPhoneNumber: 'after already',
|
|
primaryPhoneNumberType: PhoneTypeEnum.Mobile,
|
|
socialSecurityNumber: 'submitting a bunch of information about an imaginary spouse',
|
|
email: 'notMarried@forever_alone.com',
|
|
maritalStatus: CreditApplicationValues.CHOICE_NO
|
|
};
|
|
creditApplicationService.savePersonalInformation(personalInfo, BorrowerType.PRIMARY_BORROWER);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].spouseType).toBeFalsy();
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].fullInfoSpouse).toBeFalsy();
|
|
});
|
|
|
|
it('should nullify previously entered spouse information when an applicant changes their marital status from NO to co-applicant', () => {
|
|
const marriedPrimaryApplication: CreditApplication = apiTranslatorPreTranslate;
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].fullInfoSpouse = apiTranslatorPreTranslate.fullInfoBorrowers[1];
|
|
marriedPrimaryApplication.fullInfoBorrowers[0].spouseType = SpouseType.FullInfoSpouse;
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].spouseType).toBe(SpouseType.FullInfoSpouse);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].fullInfoSpouse).toBeTruthy();
|
|
const personalInfo: PersonalInformation = {
|
|
firstName: 'Someone',
|
|
lastName: 'who changed their mind',
|
|
dateOfBirth: 'about being married',
|
|
primaryPhoneNumber: 'after already',
|
|
primaryPhoneNumberType: PhoneTypeEnum.Mobile,
|
|
socialSecurityNumber: 'submitting a bunch of information about an imaginary spouse',
|
|
email: 'notMarried@forever_alone.com',
|
|
maritalStatus: CreditApplicationValues.CHOICE_YES,
|
|
coApplicantSpouse: CreditApplicationValues.CHOICE_YES
|
|
};
|
|
creditApplicationService.savePersonalInformation(personalInfo, BorrowerType.PRIMARY_BORROWER);
|
|
expect(creditApplicationService.getFullCreditApplication().page.hasPersonal).toBe(true);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].spouseType).toBeFalsy();
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].fullInfoSpouse).toBeFalsy();
|
|
});
|
|
|
|
it('should save tattle spouse information', () => {
|
|
const marriedPrimaryApplication: CreditApplication = apiTranslatorPreTranslate;
|
|
const tattleSpouse: TattleIndividual = {
|
|
personalInformation: {
|
|
firstName: 'Tattly',
|
|
lastName: 'McSpouseface'
|
|
}
|
|
};
|
|
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
creditApplicationService.saveTattleSpouseInformation(tattleSpouse, BorrowerType.PRIMARY_BORROWER_SPOUSE);
|
|
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].tattleSpouse).toBeTruthy();
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].tattleSpouse).toEqual(tattleSpouse);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[0].fullInfoSpouse).toBeFalsy();
|
|
});
|
|
|
|
it('should set spouseType information', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
const spouseType: IsFullInfoSpouse = {
|
|
isFullInfoSpouse: CreditApplicationValues.CHOICE_YES
|
|
};
|
|
creditApplicationService.saveSpouseTypeInformation(spouseType, BorrowerType.PRIMARY_BORROWER);
|
|
expect(creditApplicationService.getSpouseType(BorrowerType.PRIMARY_BORROWER)).toBe(SpouseType.FullInfoSpouse);
|
|
expect(creditApplicationService.getIndividualGroupValues('addressInformation', BorrowerType.PRIMARY_BORROWER_SPOUSE)).toBeTruthy();
|
|
});
|
|
|
|
it('should save an application ', () => {
|
|
const application = creditApplicationService.getFullCreditApplication();
|
|
application.fullInfoBorrowers[0].personalInformation.firstName = 'Bob';
|
|
application.fullInfoBorrowers[0].addressInformation.addressLine1 = '1235 Maple Ave';
|
|
spyOn(creditApplicationDaoService, 'saveApplication').and.returnValue(of(true));
|
|
creditApplicationService.saveCreditApplication();
|
|
expect(creditApplicationDaoService.saveApplication).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should gather member information from the application', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
const expectedReturn: MembershipInformation = {
|
|
limitRequested: apiTranslatorPreTranslate.limitRequested,
|
|
applicantType: apiTranslatorPreTranslate.hasCoApplicant,
|
|
livesInMaritalPropertyState: CreditApplicationValues.CHOICE_YES,
|
|
confirmJointCredit: apiTranslatorPreTranslate.confirmJointCredit,
|
|
coApplicantLivesInMaritalPropertyState: CreditApplicationValues.CHOICE_YES,
|
|
purposeOfLoanSignature: apiTranslatorPreTranslate.purposeOfLoanSignature,
|
|
agreementRequirement: undefined
|
|
};
|
|
expect(creditApplicationService.getMemberInformation()).toEqual(expectedReturn);
|
|
});
|
|
|
|
it('should determine that an applicant (or coapplicant) is married', () => {
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(apiTranslatorPreTranslate);
|
|
expect(creditApplicationService.isMarriedApplicant()).toBe(true);
|
|
spyOn(creditApplicationService, 'getIndividualByBorrowerType').and.returnValue({
|
|
personalInformation: {
|
|
maritalStatus: CreditApplicationValues.CHOICE_NO
|
|
}
|
|
});
|
|
expect(creditApplicationService.isMarriedApplicant()).toBe(false);
|
|
});
|
|
|
|
it('should handle situations where applications change their mind about co-applicant spouse', () => {
|
|
const marriedPrimaryApplication: any = primaryAndCoApplicationAddressSameApplication;
|
|
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
expect(creditApplicationService.getFullCreditApplication()
|
|
.fullInfoBorrowers[1].hasSameAddressAsSpouse).toEqual(CreditApplicationValues.CHOICE_YES);
|
|
|
|
const personalInfo: PersonalInformation = Object.assign({},
|
|
primaryAndCoApplicationAddressSameApplication.fullInfoBorrowers[0].personalInformation);
|
|
personalInfo.coApplicantSpouse = CreditApplicationValues.CHOICE_NO;
|
|
creditApplicationService.savePersonalInformation(personalInfo, BorrowerType.PRIMARY_BORROWER);
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers[1].hasSameAddressAsSpouse).toBeNull();
|
|
|
|
});
|
|
|
|
it('should clear stale co-applicant spouse state when switching back to a single applicant', () => {
|
|
const marriedPrimaryApplication: any = JSON.parse(JSON.stringify(primaryAndCoApplicationAddressSameApplication));
|
|
spyOn(creditApplicationService, 'getFullCreditApplication').and.returnValue(marriedPrimaryApplication);
|
|
spyOn(creditApplicationService, 'saveCreditApplication').and.returnValue(of(true));
|
|
|
|
const memberInfo: MembershipInformation = {
|
|
limitRequested: marriedPrimaryApplication.limitRequested,
|
|
applicantType: CreditApplicationValues.CHOICE_NO,
|
|
livesInMaritalPropertyState: CreditApplicationValues.CHOICE_YES,
|
|
confirmJointCredit: null,
|
|
coApplicantLivesInMaritalPropertyState: null,
|
|
purposeOfLoanSignature: null,
|
|
agreementRequirement: undefined
|
|
};
|
|
|
|
creditApplicationService.saveMemberInformation(memberInfo);
|
|
|
|
expect(creditApplicationService.getFullCreditApplication().fullInfoBorrowers.length).toBe(1);
|
|
expect(creditApplicationService.getFullCreditApplication().hasCoApplicantSpouse).toBeNull();
|
|
expect(creditApplicationService.getFullCreditApplication().coApplicantLivesInMaritalPropertyState).toBeNull();
|
|
expect(creditApplicationService.getFullCreditApplication().confirmJointCredit).toBeNull();
|
|
});
|
|
|
|
it('should set Estimated Value & Property Type defaults on HELOC Rate Mod loan type', () => {
|
|
const loanConfigurationService = TestBed.get(ConfigurationService);
|
|
loanConfigurationService.saveConfiguration(DefaultSettings as UiSettings);
|
|
const helocRateMod = LoanTypeSet.find((loanType) => loanType.title === LoanTitle.HELOC_RateMod);
|
|
if (helocRateMod) {
|
|
creditApplicationService.setLoanType(helocRateMod.id);
|
|
} else {
|
|
creditApplicationService.setLoanType(LoanTypeSet[0].id);
|
|
const application = creditApplicationService.getFullCreditApplication();
|
|
application.loanType = {
|
|
...application.loanType,
|
|
title: LoanTitle.HELOC_RateMod
|
|
};
|
|
}
|
|
creditApplicationService.saveCollateralInformation(
|
|
{
|
|
"collateralInformation": {
|
|
"isAddressSame": "yes",
|
|
"estimatedValue": 100000,
|
|
"propertyType": "Duplex",
|
|
"isBeingImproved": "false",
|
|
"isListedForSale": "yes",
|
|
"occupancyType": "OwnerOccupied",
|
|
"hasFirstMortgage": "true",
|
|
"hasSecondMortgage": "false",
|
|
"payoffFirstMortgage": "false",
|
|
"addressLine1": "Fake Street 123",
|
|
"addressLine2": "",
|
|
"zipcode": "66666",
|
|
"city": "Test Town",
|
|
"state": "WI",
|
|
"residenceStatus": "0",
|
|
"residenceTimeYears": "2",
|
|
"residenceTimeMonths": "0",
|
|
"residenceMonthlyPayment": "2000",
|
|
"isMailingAddressSame": true
|
|
}
|
|
}
|
|
);
|
|
const creditApplication = creditApplicationService.getFullCreditApplication();
|
|
expect(creditApplication.loanType.title).toEqual(LoanTitle.HELOC_RateMod);
|
|
expect(creditApplication.collateralInformation.estimatedValue).toEqual(250000);
|
|
expect(creditApplication.collateralInformation.propertyType).toEqual(PropertyTypeEnum[PropertyTypeEnum.SingleFamily]);
|
|
});
|
|
|
|
});
|