HttpTestingController,
} from "@angular/common/http/testing";
import {
+ CreatePolicyInstance,
PolicyInstance,
PolicyInstances,
+ PolicyStatus,
+ PolicyType,
PolicyTypes,
} from "@interfaces/policy.types";
+import { Ric, Rics } from "@app/interfaces/ric";
describe("PolicyService", () => {
let apiVersion2 = "v2";
})
);
+ beforeEach(() => {
+ policyService = TestBed.inject(PolicyService);
+ httpTestingController = TestBed.inject(HttpTestingController);
+ });
+
afterEach(() => {
httpTestingController.verify();
});
- describe("#getPolicyTypes", () => {
- let expectedPolicytypes: PolicyTypes;
- let emptyPolicyType: PolicyTypes;
-
- beforeEach(() => {
- policyService = TestBed.inject(PolicyService);
- httpTestingController = TestBed.inject(HttpTestingController);
- expectedPolicytypes = {
- 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
- );
- const req = httpTestingController.expectOne(
- basePath + apiVersion2 + "/" + policyService.policyTypesPath
+ it("#getPolicyTypes should return policy types", () => {
+ const expectedPolicytypes = {
+ policytype_ids: ["", "1"],
+ } as PolicyTypes;
+
+ policyService
+ .getPolicyTypes()
+ .subscribe(
+ (policytypes) =>
+ expect(policytypes).toEqual(
+ expectedPolicytypes,
+ "should return expected PolicyTypes"
+ ),
+ fail
);
- expect(req.request.method).toEqual("GET");
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyTypesPath
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedPolicytypes);
+ });
- req.flush(expectedPolicytypes);
- });
+ it("#getPolicyType", () => {
+ const policyTypeId = "1";
+ const expectedPolicyType = { policy_schema: "schema" } as PolicyType;
- //Policy Type Test Case 2:
- emptyPolicyType = {
- 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
- );
-
- const req = httpTestingController.expectOne(
- basePath + apiVersion2 + "/" + policyService.policyTypesPath
+ policyService
+ .getPolicyType(policyTypeId)
+ .subscribe(
+ (policyType) =>
+ expect(policyType).toEqual(
+ expectedPolicyType,
+ "should return expected policy type"
+ ),
+ fail
);
- req.flush(emptyPolicyType); //Return empty data
- });
+
+ const req = httpTestingController.expectOne(
+ basePath +
+ apiVersion2 +
+ "/" +
+ policyService.policyTypesPath +
+ "/" +
+ policyTypeId
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedPolicyType);
});
- describe("#getPolicyInstances", () => {
- let expectedPolicyInstances: PolicyInstances;
- let emptyPolicyInstances: PolicyInstances;
- let policyTypeId = "1";
- beforeEach(() => {
- policyService = TestBed.inject(PolicyService);
- httpTestingController = TestBed.inject(HttpTestingController);
- expectedPolicyInstances = {
- 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
- );
- const req = httpTestingController.expectOne(
- basePath +
- apiVersion2 +
- "/" +
- policyService.policyPath +
- "?" +
- "policytype_id=" +
- policyTypeId
- );
- expect(req.request.method).toEqual("GET");
- req.flush(expectedPolicyInstances);
- });
- //Policy Instances Test Case 2:
- emptyPolicyInstances = {
- policy_ids: [],
+ it("#getPolicyInstancesByType should return policy instances", () => {
+ const policyTypeId = "1";
+ const expectedPolicyInstances = {
+ policy_ids: ["2100", "2000"],
} 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
- );
- const req = httpTestingController.expectOne(
- basePath +
- apiVersion2 +
- "/" +
- policyService.policyPath +
- "?" +
- "policytype_id=" +
- policyTypeId
+
+ 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
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedPolicyInstances);
+ });
+
+ it("#getPolicyInstance should return one policy instance", () => {
+ const policyId = "2000";
+ const expectedPolicyInstance = {
+ policy_id: "2000",
+ policytype_id: "1",
+ ric_id: "ric1",
+ policy_data: "",
+ service_id: "service1",
+ lastModified: "",
+ } as PolicyInstance;
+
+ policyService
+ .getPolicyInstance(policyId)
+ .subscribe(
+ (policyinstance) =>
+ expect(policyinstance).toEqual(
+ expectedPolicyInstance,
+ "should return expected Policy Instances"
+ ),
+ fail
+ );
+
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyPath + "/" + policyId
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedPolicyInstance);
+ });
+
+ it("#getPolicyStatus should return policy status", () => {
+ const policyId = "2000";
+ const expectedPolicyStatus = {
+ last_modified: "modified",
+ } as PolicyStatus;
+
+ policyService
+ .getPolicyStatus(policyId)
+ .subscribe(
+ (policyinstance) =>
+ expect(policyinstance).toEqual(
+ expectedPolicyStatus,
+ "should return expected Policy status"
+ ),
+ fail
+ );
+
+ const req = httpTestingController.expectOne(
+ basePath +
+ apiVersion2 +
+ "/" +
+ policyService.policyPath +
+ "/" +
+ policyId +
+ "/status"
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedPolicyStatus);
+ });
+
+ it("#putPolicy should return ok response", () => {
+ const createPolicyInstance = { policy_id: "2000" } as CreatePolicyInstance;
+
+ policyService
+ .putPolicy(createPolicyInstance)
+ .subscribe(
+ (response) =>
+ expect(response.status).toEqual(
+ 200,
+ "should return expected response"
+ ),
+ fail
+ );
+
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyPath
+ );
+ expect(req.request.method).toEqual("PUT");
+
+ req.flush(200);
+ });
+
+ it("#deletePolicy should return ok response", () => {
+ const policyId = "2000";
+
+ policyService
+ .deletePolicy(policyId)
+ .subscribe(
+ (response) =>
+ expect(response.status).toEqual(
+ 200,
+ "should return expected response"
+ ),
+ fail
);
- req.flush(emptyPolicyInstances); //Return empty data
- });
+
+ const req = httpTestingController.expectOne(
+ basePath + apiVersion2 + "/" + policyService.policyPath + "/2000"
+ );
+ expect(req.request.method).toEqual("DELETE");
+
+ req.flush(200);
});
- describe("#getPolicyInstance", () => {
- let expectedPolicyInstance: PolicyInstance;
- let emptyPolicyInstances: PolicyInstances;
- let policyId = "2000";
- beforeEach(() => {
- policyService = TestBed.inject(PolicyService);
- httpTestingController = TestBed.inject(HttpTestingController);
- expectedPolicyInstance = {
- 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
- );
- const req = httpTestingController.expectOne(
- basePath + apiVersion2 + "/" + policyService.policyPath + "/" + policyId
+ it("#getRics should return rics", () => {
+ const policyTypeId = "2000";
+ const expectedRic = { ric_id: "1" } as Ric;
+ const expectedRics = {
+ rics: [expectedRic],
+ } as Rics;
+
+ policyService
+ .getRics(policyTypeId)
+ .subscribe(
+ (rics) =>
+ expect(rics).toEqual(
+ expectedRics,
+ "should return expected Rics"
+ ),
+ fail
);
- expect(req.request.method).toEqual("GET");
- req.flush(expectedPolicyInstance);
- });
+
+ const req = httpTestingController.expectOne(
+ basePath +
+ apiVersion2 +
+ "/rics?policytype_id=2000"
+ );
+ expect(req.request.method).toEqual("GET");
+
+ req.flush(expectedRics);
});
});