* limitations under the License.
* ========================LICENSE_END===================================
*/
-import { TestBed } from '@angular/core/testing';
+import { TestBed } from "@angular/core/testing";
-import { PolicyService } from './policy.service';
-import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing'
-import { PolicyInstance, PolicyInstances, PolicyTypes } from '../../interfaces/policy.types';
+import { PolicyService } from "./policy.service";
+import {
+ HttpClientTestingModule,
+ HttpTestingController,
+} from "@angular/common/http/testing";
+import {
+ PolicyInstance,
+ PolicyInstances,
+ PolicyTypes,
+} from "@interfaces/policy.types";
-describe('PolicyService', () => {
- let apiVersion2 = 'v2'
- let basePath = '';
+describe("PolicyService", () => {
+ let apiVersion2 = "v2";
+ let basePath = "/a1-policy/";
let policyService: PolicyService;
let httpTestingController: HttpTestingController;
- beforeEach(() => TestBed.configureTestingModule({
- imports: [HttpClientTestingModule],
- providers: [
- PolicyService
- ],
- }));
+ beforeEach(() =>
+ TestBed.configureTestingModule({
+ imports: [HttpClientTestingModule],
+ providers: [PolicyService],
+ })
+ );
afterEach(() => {
httpTestingController.verify();
});
- describe('#getPolicyTypes', () => {
+ describe("#getPolicyTypes", () => {
let expectedPolicytypes: PolicyTypes;
let emptyPolicyType: PolicyTypes;
beforeEach(() => {
- policyService = TestBed.get(PolicyService);
- httpTestingController = TestBed.get(HttpTestingController);
+ policyService = TestBed.inject(PolicyService);
+ httpTestingController = TestBed.inject(HttpTestingController);
expectedPolicytypes = {
- "policytype_ids": [
- "",
- "1"
- ]
+ policytype_ids: ["", "1"],
} as PolicyTypes;
});
//Policy Type Test Case 1:
- it('should return all policy types', () => {
- policyService.getPolicyTypes().subscribe(
- policytypes => expect(policytypes).toEqual(expectedPolicytypes, 'should return expected PolicyTypes'),
- fail
+ it("should return all policy types", () => {
+ policyService
+ .getPolicyTypes()
+ .subscribe(
+ (policytypes) =>
+ expect(policytypes).toEqual(
+ expectedPolicytypes,
+ "should return expected PolicyTypes"
+ ),
+ fail
+ );
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyTypesPath
);
-
- const req = httpTestingController.expectOne(basePath + apiVersion2 + '/' + policyService.policyTypesPath);
- expect(req.request.method).toEqual('GET');
+ expect(req.request.method).toEqual("GET");
req.flush(expectedPolicytypes);
});
//Policy Type Test Case 2:
emptyPolicyType = {
- "policytype_ids": [
- ]
+ policytype_ids: [],
} as PolicyTypes;
- it('should return no policy types', () => {
- policyService.getPolicyTypes().subscribe(
- policytypes => expect(policytypes).toEqual(emptyPolicyType, 'should return empty array of Policy Types'),
- fail
- );
+ it("should return no policy types", () => {
+ policyService
+ .getPolicyTypes()
+ .subscribe(
+ (policytypes) =>
+ expect(policytypes).toEqual(
+ emptyPolicyType,
+ "should return empty array of Policy Types"
+ ),
+ fail
+ );
- const req = httpTestingController.expectOne(basePath + apiVersion2 + '/' + policyService.policyTypesPath);
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyTypesPath
+ );
req.flush(emptyPolicyType); //Return empty data
});
});
- describe('#getPolicyInstances', () => {
+ describe("#getPolicyInstances", () => {
let expectedPolicyInstances: PolicyInstances;
let emptyPolicyInstances: PolicyInstances;
- let policyTypeId = '1';
+ let policyTypeId = "1";
beforeEach(() => {
- policyService = TestBed.get(PolicyService);
- httpTestingController = TestBed.get(HttpTestingController);
+ policyService = TestBed.inject(PolicyService);
+ httpTestingController = TestBed.inject(HttpTestingController);
expectedPolicyInstances = {
- "policy_ids": [
- "2100",
- "2000"
- ]
+ policy_ids: ["2100", "2000"],
} as PolicyInstances;
});
//Policy Instances Test Case 1:
- it('should return all policy instances', () => {
- policyService.getPolicyInstancesByType(policyTypeId).subscribe(
- policyinstances => expect(policyinstances).toEqual(expectedPolicyInstances, 'should return expected Policy Instances'),
- fail
+ it("should return all policy instances", () => {
+ policyService
+ .getPolicyInstancesByType(policyTypeId)
+ .subscribe(
+ (policyinstances) =>
+ expect(policyinstances).toEqual(
+ expectedPolicyInstances,
+ "should return expected Policy Instances"
+ ),
+ fail
+ );
+ const req = httpTestingController.expectOne(
+ basePath +
+ apiVersion2 +
+ "/" +
+ policyService.policyPath +
+ "?" +
+ "policytype_id=" +
+ policyTypeId
);
- const req = httpTestingController.expectOne(basePath + apiVersion2 + '/' + policyService.policyPath + '?' + 'policytype_id=' + policyTypeId);
- expect(req.request.method).toEqual('GET');
+ expect(req.request.method).toEqual("GET");
req.flush(expectedPolicyInstances);
});
//Policy Instances Test Case 2:
emptyPolicyInstances = {
- "policy_ids": [
- ]
+ policy_ids: [],
} as PolicyInstances;
- it('should return no policy instances', () => {
- policyService.getPolicyInstancesByType(policyTypeId).subscribe(
- policyinstances => expect(policyinstances.policy_ids.length).toEqual(0, 'should return empty array of Policy Instances'),
- fail
+ it("should return no policy instances", () => {
+ policyService
+ .getPolicyInstancesByType(policyTypeId)
+ .subscribe(
+ (policyinstances) =>
+ expect(policyinstances.policy_ids.length).toEqual(
+ 0,
+ "should return empty array of Policy Instances"
+ ),
+ fail
+ );
+ const req = httpTestingController.expectOne(
+ basePath +
+ apiVersion2 +
+ "/" +
+ policyService.policyPath +
+ "?" +
+ "policytype_id=" +
+ policyTypeId
);
- const req = httpTestingController.expectOne(basePath + apiVersion2 + '/' + policyService.policyPath + '?' + 'policytype_id=' + policyTypeId);
req.flush(emptyPolicyInstances); //Return empty data
});
});
- describe('#getPolicyInstance', () => {
+ describe("#getPolicyInstance", () => {
let expectedPolicyInstance: PolicyInstance;
let emptyPolicyInstances: PolicyInstances;
let policyId = "2000";
beforeEach(() => {
- policyService = TestBed.get(PolicyService);
- httpTestingController = TestBed.get(HttpTestingController);
+ policyService = TestBed.inject(PolicyService);
+ httpTestingController = TestBed.inject(HttpTestingController);
expectedPolicyInstance = {
- "policy_id": "2000",
- "policytype_id": "1",
- "ric_id": "ric1",
- "policy_data": "",
- "service_id": "service1",
- "lastModified": ""
+ policy_id: "2000",
+ policytype_id: "1",
+ ric_id: "ric1",
+ policy_data: "",
+ service_id: "service1",
+ lastModified: "",
} as PolicyInstance;
});
//Policy Instances Test Case 1:
- it('should return one policy instance', () => {
- policyService.getPolicyInstance(policyId).subscribe(
- policyinstance => expect(policyinstance).toEqual(expectedPolicyInstance, 'should return expected Policy Instances'),
- fail
+ it("should return one policy instance", () => {
+ policyService
+ .getPolicyInstance(policyId)
+ .subscribe(
+ (policyinstance) =>
+ expect(policyinstance).toEqual(
+ expectedPolicyInstance,
+ "should return expected Policy Instances"
+ ),
+ fail
+ );
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyPath + "/" + policyId
);
- const req = httpTestingController.expectOne(basePath + apiVersion2 + '/' + policyService.policyPath + '/' + policyId);
- expect(req.request.method).toEqual('GET');
+ expect(req.request.method).toEqual("GET");
req.flush(expectedPolicyInstance);
});
});