X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=webapp-frontend%2Fsrc%2Fapp%2Fservices%2Fpolicy%2Fpolicy.service.spec.ts;h=71fd62e2833b7fd963db090be8cb7577426b44f2;hb=b5b007356c7bd5bf9f4b99be9d748310dcf3987e;hp=15f849cf9408b825638a40f378bab84a47737978;hpb=a3e5b2cc0eaf68e4f167cbf6cb39a6e154457678;p=portal%2Fnonrtric-controlpanel.git

diff --git a/webapp-frontend/src/app/services/policy/policy.service.spec.ts b/webapp-frontend/src/app/services/policy/policy.service.spec.ts
index 15f849c..71fd62e 100644
--- a/webapp-frontend/src/app/services/policy/policy.service.spec.ts
+++ b/webapp-frontend/src/app/services/policy/policy.service.spec.ts
@@ -17,92 +17,185 @@
  * 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, PolicyType } 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 basePath = 'api/policy';
+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', () => {
-    let expectedPolicytypes: PolicyType[];
+  describe("#getPolicyTypes", () => {
+    let expectedPolicytypes: PolicyTypes;
+    let emptyPolicyType: PolicyTypes;
 
     beforeEach(() => {
-      policyService = TestBed.get(PolicyService);
-      httpTestingController = TestBed.get(HttpTestingController);
-      expectedPolicytypes = [
-        { name: '1', schema: '{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"description\":\"Type 2 policy type\",\"additionalProperties\":false,\"title\":\"2\",\"type\":\"object\",\"properties\":{\"qosObjectives\":{\"additionalProperties\":false,\"type\":\"object\",\"properties\":{\"priorityLevel\":{\"type\":\"number\"}},\"required\":[\"priorityLevel\"]},\"scope\":{\"additionalProperties\":false,\"type\":\"object\",\"properties\":{\"qosId\":{\"type\":\"string\"},\"ueId\":{\"type\":\"string\"}},\"required\":[\"ueId\",\"qosId\"]}},\"required\":[\"scope\",\"qosObjectives\"]}' },
-        { name: '2', schema: '{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"description\":\"Type 1 policy type\",\"additionalProperties\":false,\"title\":\"1\",\"type\":\"object\",\"properties\":{\"qosObjectives\":{\"additionalProperties\":false,\"type\":\"object\",\"properties\":{\"priorityLevel\":{\"type\":\"number\"}},\"required\":[\"priorityLevel\"]},\"scope\":{\"additionalProperties\":false,\"type\":\"object\",\"properties\":{\"qosId\":{\"type\":\"string\"},\"ueId\":{\"type\":\"string\"}},\"required\":[\"ueId\",\"qosId\"]}},\"required\":[\"scope\",\"qosObjectives\"]}' },
-      ] as PolicyType[];
+      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
+    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
       );
+      expect(req.request.method).toEqual("GET");
 
-      const req = httpTestingController.expectOne(basePath + '/' + policyService.policyTypePath);
-      expect(req.request.method).toEqual('GET');
-
-      req.flush(expectedPolicytypes); //Return expectedEmps
+      req.flush(expectedPolicytypes);
     });
 
     //Policy Type Test Case 2:
-    it('should return no policy types', () => {
-      policyService.getPolicyTypes().subscribe(
-        policytypes => expect(policytypes.length).toEqual(0, 'should return empty array of Policy Types'),
-        fail
-      );
+    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 + '/' + policyService.policyTypePath);
-      req.flush([]); //Return empty data
+      const req = httpTestingController.expectOne(
+        basePath + apiVersion2 + "/" + policyService.policyTypesPath
+      );
+      req.flush(emptyPolicyType); //Return empty data
     });
   });
-  describe('#getPolicyInstance', () => {
-    let expectedPolicyInstances: PolicyInstance[];
-    let policyTypeId: string;
+  describe("#getPolicyInstances", () => {
+    let expectedPolicyInstances: PolicyInstances;
+    let emptyPolicyInstances: PolicyInstances;
+    let policyTypeId = "1";
     beforeEach(() => {
-      policyService = TestBed.get(PolicyService);
-      httpTestingController = TestBed.get(HttpTestingController);
-      expectedPolicyInstances = [
-        { id: '2000', json: '{"scope": {"ueId": "ue3100","qosId": "qos3100"},"qosObjectives": {"priorityLevel": 3100}}', service: 'service1', lastModified: '2020-12-08T21:12:43.719084Z' }
-      ] as PolicyInstance[];
-      policyTypeId = "1";
+      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.getPolicyInstances(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 + '/' + policyService.policyPath + '?type=' + policyTypeId);
-      expect(req.request.method).toEqual('GET');
-      req.flush(expectedPolicyInstances); //Return expectedEmps
+      expect(req.request.method).toEqual("GET");
+      req.flush(expectedPolicyInstances);
     });
 
     //Policy Instances Test Case 2:
-    it('should return no policy instances', () => {
-      policyService.getPolicyInstances(policyTypeId).subscribe(
-        policyinstances => expect(policyinstances.length).toEqual(0, 'should return empty array of Policy Isntances'),
-        fail
+    emptyPolicyInstances = {
+      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
+        );
+      const req = httpTestingController.expectOne(
+        basePath +
+          apiVersion2 +
+          "/" +
+          policyService.policyPath +
+          "?" +
+          "policytype_id=" +
+          policyTypeId
+      );
+      req.flush(emptyPolicyInstances); //Return empty data
+    });
+  });
+
+  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
       );
-      const req = httpTestingController.expectOne(basePath + '/' + policyService.policyPath + '?type=' + policyTypeId);
-      req.flush([]); //Return empty data
+      expect(req.request.method).toEqual("GET");
+      req.flush(expectedPolicyInstance);
     });
   });
 });