test: Add unit test for addPolicyService to cover the basic fail and success scenarios.

src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java

@@ -64,7 +64,7 @@ public class PolicyRuleBasic {
             this.booleanOperator = BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_UNDEFINED;
             this.policyRuleActions = new ArrayList<PolicyRuleAction>();
             this.isValid = false;
-            this.exceptionMessage = e.toString();
+            this.exceptionMessage = e.getMessage();
         }
     }
 

src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java

@@ -50,7 +50,7 @@ public class PolicyRuleService {
             this.serviceId = new ServiceId("", "");
             this.deviceIds = new ArrayList<String>();
             this.isValid = false;
-            this.exceptionMessage = e.toString();
+            this.exceptionMessage = e.getMessage();
         }
     }
 

src/policy/src/test/java/org/etsi/tfs/policy/PolicyGrpcServiceTest.java

+/*
+* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package org.etsi.tfs.policy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import context.ContextOuterClass;
+import context.ContextOuterClass.Uuid;
+import io.quarkus.grpc.GrpcClient;
+import io.quarkus.test.junit.QuarkusTest;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.inject.Inject;
+import monitoring.Monitoring.KpiId;
+import org.etsi.tfs.policy.monitoring.model.FloatKpiValue;
+import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
+import org.jboss.logging.Logger;
+import org.junit.jupiter.api.Test;
+import policy.Policy;
+import policy.Policy.PolicyRuleBasic;
+import policy.Policy.PolicyRuleStateEnum;
+import policy.PolicyAction;
+import policy.PolicyAction.PolicyRuleActionEnum;
+import policy.PolicyCondition;
+import policy.PolicyCondition.BooleanOperator;
+import policy.PolicyCondition.NumericalOperator;
+import policy.PolicyCondition.PolicyRuleCondition;
+import policy.PolicyService;
+
+@QuarkusTest
+class PolicyGrpcServiceTest {
+    private static final Logger LOGGER = Logger.getLogger(PolicyGrpcServiceTest.class);
+
+    @GrpcClient PolicyService client;
+    private final Serializer serializer;
+
+    @Inject
+    PolicyGrpcServiceTest(Serializer serializer) {
+        this.serializer = serializer;
+    }
+
+    private context.ContextOuterClass.ServiceId createContextServiceId() {
+        final var contextIdUuid = serializer.serializeUuid("571eabc1-0f59-48da-b608-c45876c3fa8a");
+
+        final var serviceIdUuid = serializer.serializeUuid("123456789");
+
+        context.ContextOuterClass.ContextId contextId =
+                context.ContextOuterClass.ContextId.newBuilder().setContextUuid(contextIdUuid).build();
+
+        return context.ContextOuterClass.ServiceId.newBuilder()
+                .setContextId(contextId)
+                .setServiceUuid(serviceIdUuid)
+                .build();
+    }
+
+    private PolicyRuleBasic createPolicyRuleBasic() {
+        final var expectedPolicyRuleIdUuid =
+                serializer.serializeUuid("571eabc1-0f59-48da-b608-c45876c3fa8a");
+
+        final var expectedPolicyRuleId =
+                Policy.PolicyRuleId.newBuilder().setUuid(expectedPolicyRuleIdUuid).build();
+
+        final var expectedPolicyRuleState =
+                Policy.PolicyRuleState.newBuilder()
+                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED)
+                        .build();
+
+        final var expectedFirstKpiValue = new IntegerKpiValue(22);
+        final var expectedSecondKpiValue = new FloatKpiValue(69.1f);
+
+        final var serializedExpectedFirstKpiValue = serializer.serialize(expectedFirstKpiValue);
+        final var serializedExpectedSecondKpiValue = serializer.serialize(expectedSecondKpiValue);
+
+        final var firstExpectedPolicyRuleCondition =
+                PolicyRuleCondition.newBuilder()
+                        .setKpiId(
+                                KpiId.newBuilder()
+                                        .setKpiId(
+                                                Uuid.newBuilder().setUuid("79e49ba3-a7b4-4b4b-8aaa-28b05c6f888e").build()))
+                        .setNumericalOperator(NumericalOperator.POLICYRULE_CONDITION_NUMERICAL_EQUAL)
+                        .setKpiValue(serializedExpectedFirstKpiValue)
+                        .build();
+
+        final var secondExpectedPolicyRuleCondition =
+                PolicyCondition.PolicyRuleCondition.newBuilder()
+                        .setKpiId(
+                                KpiId.newBuilder()
+                                        .setKpiId(
+                                                Uuid.newBuilder().setUuid("eae900e5-2703-467d-82f2-97aae8b55c15").build()))
+                        .setNumericalOperator(NumericalOperator.POLICYRULE_CONDITION_NUMERICAL_GREATER_THAN)
+                        .setKpiValue(serializedExpectedSecondKpiValue)
+                        .build();
+
+        final var expectedPolicyRuleConditions =
+                List.of(firstExpectedPolicyRuleCondition, secondExpectedPolicyRuleCondition);
+
+        org.etsi.tfs.policy.model.PolicyRuleActionConfig policyRuleActionConfig_1 =
+                new org.etsi.tfs.policy.model.PolicyRuleActionConfig("paramater1", "parameter2");
+        final var serializedPolicyRuleActionConfigList_1 =
+                serializer.serialize(policyRuleActionConfig_1);
+
+        org.etsi.tfs.policy.model.PolicyRuleActionConfig policyRuleActionConfig_2 =
+                new org.etsi.tfs.policy.model.PolicyRuleActionConfig("paramater3", "parameter4");
+        final var serializedPolicyRuleActionConfigList_2 =
+                serializer.serialize(policyRuleActionConfig_2);
+
+        final var firstExpectedPolicyRuleAction =
+                PolicyAction.PolicyRuleAction.newBuilder()
+                        .setAction(PolicyAction.PolicyRuleActionEnum.POLICYRULE_ACTION_ADD_SERVICE_CONFIGRULE)
+                        .addActionConfig(serializedPolicyRuleActionConfigList_1)
+                        .build();
+
+        final var secondExpectedPolicyRuleAction =
+                PolicyAction.PolicyRuleAction.newBuilder()
+                        .setAction(PolicyRuleActionEnum.POLICYRULE_ACTION_ADD_SERVICE_CONSTRAINT)
+                        .addActionConfig(serializedPolicyRuleActionConfigList_2)
+                        .build();
+
+        final var expectedPolicyRuleActions =
+                List.of(firstExpectedPolicyRuleAction, secondExpectedPolicyRuleAction);
+
+        return PolicyRuleBasic.newBuilder()
+                .setPolicyRuleId(expectedPolicyRuleId)
+                .setPolicyRuleState(expectedPolicyRuleState)
+                .addAllConditionList(expectedPolicyRuleConditions)
+                .setBooleanOperator(BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR)
+                .addAllActionList(expectedPolicyRuleActions)
+                .build();
+    }
+
+    // @Test
+    // void shouldAddPolicyService() throws ExecutionException, InterruptedException, TimeoutException
+    // {
+    //    CompletableFuture<String> message = new CompletableFuture<>();
+
+    //    final var policyRuleBasic = createPolicyRuleBasic();
+
+    //    final var expectedPolicyRuleState = policyRuleBasic.getPolicyRuleState();
+
+    //    final var serviceId = createContextServiceId();
+
+    //    final var expectedDeviceIdUuid1 =
+    //            serializer.serializeUuid("20db867c-772d-4872-9179-244ecafb3257");
+
+    //    final var expectedDeviceId1 =
+    //
+    // ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(expectedDeviceIdUuid1).build();
+
+    //    final var deviceIds = List.of(expectedDeviceId1);
+    //    final var policyRuleService =
+    //            Policy.PolicyRuleService.newBuilder()
+    //                    .setPolicyRuleBasic(policyRuleBasic)
+    //                    .setServiceId(serviceId)
+    //                    .addAllDeviceList(deviceIds)
+    //                    .build();
+
+    //    client
+    //            .policyAddService(policyRuleService)
+    //            .subscribe()
+    //            .with(policyRuleState ->
+    // message.complete(policyRuleState.getPolicyRuleState().toString()));
+
+    //    assertThat(message.get(5, TimeUnit.SECONDS))
+    //            .isEqualTo(expectedPolicyRuleState.getPolicyRuleState().toString());
+    // }
+
+    // @Test
+    // void shouldAddPolicyDevice() throws ExecutionException, InterruptedException, TimeoutException
+    // {
+    //    CompletableFuture<String> message = new CompletableFuture<>();
+
+    //    final var expectedDeviceIdUuid1 =
+    //            serializer.serializeUuid("20db867c-772d-4872-9179-244ecafb3257");
+    //    final var expectedDeviceIdUuid2 =
+    //            serializer.serializeUuid("095974ac-d757-412d-b317-bcf355220aa9");
+
+    //    final var expectedDeviceId1 =
+    //
+    // ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(expectedDeviceIdUuid1).build();
+    //    final var expectedDeviceId2 =
+    //
+    // ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(expectedDeviceIdUuid2).build();
+
+    //    final var policyRuleBasic = createPolicyRuleBasic();
+    //    final var deviceIds = List.of(expectedDeviceId1, expectedDeviceId2);
+
+    //    final var expectedPolicyRuleState = policyRuleBasic.getPolicyRuleState();
+
+    //    final var policyRuleDevice =
+    //            Policy.PolicyRuleDevice.newBuilder()
+    //                    .setPolicyRuleBasic(policyRuleBasic)
+    //                    .addAllDeviceList(deviceIds)
+    //                    .build();
+
+    //    client
+    //            .policyAddDevice(policyRuleDevice)
+    //            .subscribe()
+    //            .with(policyRuleState ->
+    // message.complete(policyRuleState.getPolicyRuleState().toString()));
+
+    //    assertThat(message.get(5, TimeUnit.SECONDS))
+    //            .isEqualTo(expectedPolicyRuleState.getPolicyRuleState().toString());
+    // }
+
+    @Test
+    void shouldUpdatePolicyServiceReturnFailedState()
+            throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<String> message = new CompletableFuture<>();
+
+        final var expectedPolicyRuleState =
+                Policy.PolicyRuleState.newBuilder()
+                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED)
+                        .build();
+
+        final var policyRuleBasic =
+                PolicyRuleBasic.newBuilder().setPolicyRuleState(expectedPolicyRuleState).build();
+        final var policyRuleService =
+                Policy.PolicyRuleService.newBuilder().setPolicyRuleBasic(policyRuleBasic).build();
+
+        client
+                .policyUpdateService(policyRuleService)
+                .subscribe()
+                .with(policyRuleState -> message.complete(policyRuleState.getPolicyRuleState().toString()));
+
+        assertThat(message.get(5, TimeUnit.SECONDS))
+                .isEqualTo(expectedPolicyRuleState.getPolicyRuleState().toString());
+    }
+
+    @Test
+    void shouldUpdatePolicyDeviceReturnFailedState()
+            throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<String> message = new CompletableFuture<>();
+
+        final var expectedDeviceIdUuid =
+                serializer.serializeUuid("20db867c-772d-4872-9179-244ecafb3257");
+
+        final var expectedDeviceId =
+                ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(expectedDeviceIdUuid).build();
+
+        final var expectedPolicyRuleState =
+                Policy.PolicyRuleState.newBuilder()
+                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED)
+                        .build();
+
+        final var policyRuleBasic =
+                PolicyRuleBasic.newBuilder().setPolicyRuleState(expectedPolicyRuleState).build();
+        final var deviceIds = List.of(expectedDeviceId);
+        final var policyRuleDevice =
+                Policy.PolicyRuleDevice.newBuilder()
+                        .setPolicyRuleBasic(policyRuleBasic)
+                        .addAllDeviceList(deviceIds)
+                        .build();
+
+        client
+                .policyUpdateDevice(policyRuleDevice)
+                .subscribe()
+                .with(policyRuleState -> message.complete(policyRuleState.getPolicyRuleState().toString()));
+
+        assertThat(message.get(5, TimeUnit.SECONDS))
+                .isEqualTo(expectedPolicyRuleState.getPolicyRuleState().toString());
+    }
+
+    // TODO: Disable shouldDeletePolicy test until mock context service
+    //     @Test
+    //     void shouldDeletePolicy() throws ExecutionException, InterruptedException, TimeoutException
+    // {
+    //         CompletableFuture<String> message = new CompletableFuture<>();
+
+    //         final var uuid =
+    //                 ContextOuterClass.Uuid.newBuilder()
+    //
+    // .setUuid(UUID.fromString("0f14d0ab-9608-7862-a9e4-5ed26688389b").toString())
+    //                         .build();
+    //         final var policyRuleId = Policy.PolicyRuleId.newBuilder().setUuid(uuid).build();
+
+    //         final var expectedPolicyRuleState =
+    //                 Policy.PolicyRuleState.newBuilder()
+    //                         .setPolicyRuleState(PolicyRuleStateEnum.POLICY_REMOVED)
+    //                         .build();
+
+    //         client
+    //                 .policyDelete(policyRuleId)
+    //                 .subscribe()
+    //                 .with(policyRuleState ->
+    // message.complete(policyRuleState.getPolicyRuleState().toString()));
+
+    //         assertThat(message.get(5, TimeUnit.SECONDS))
+    //                 .isEqualTo(expectedPolicyRuleState.getPolicyRuleState().toString());
+    //     }
+
+    @Test
+    void shouldGetPolicyService() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<String> message = new CompletableFuture<>();
+
+        final var uuid =
+                ContextOuterClass.Uuid.newBuilder()
+                        .setUuid(UUID.fromString("0f14d0ab-9608-7862-a9e4-5ed26688389b").toString())
+                        .build();
+        final var policyRuleId = Policy.PolicyRuleId.newBuilder().setUuid(uuid).build();
+
+        client
+                .getPolicyService(policyRuleId)
+                .subscribe()
+                .with(
+                        policyRuleService -> {
+                            LOGGER.infof(
+                                    "Getting policy with ID: %s",
+                                    policyRuleService.getPolicyRuleBasic().getPolicyRuleId().getUuid());
+                            message.complete(
+                                    policyRuleService.getPolicyRuleBasic().getPolicyRuleId().getUuid().getUuid());
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS)).isEqualTo(policyRuleId.getUuid().getUuid());
+    }
+
+    @Test
+    void shouldGetPolicyDevice() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<String> message = new CompletableFuture<>();
+
+        final var uuid =
+                ContextOuterClass.Uuid.newBuilder()
+                        .setUuid(UUID.fromString("0f14d0ab-9608-7862-a9e4-5ed26688389b").toString())
+                        .build();
+        final var policyRuleId = Policy.PolicyRuleId.newBuilder().setUuid(uuid).build();
+
+        client
+                .getPolicyDevice(policyRuleId)
+                .subscribe()
+                .with(
+                        policyRuleService -> {
+                            LOGGER.infof(
+                                    "Getting policy with ID: %s",
+                                    policyRuleService.getPolicyRuleBasic().getPolicyRuleId().getUuid());
+                            message.complete(
+                                    policyRuleService.getPolicyRuleBasic().getPolicyRuleId().getUuid().getUuid());
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS)).isEqualTo(policyRuleId.getUuid().getUuid());
+    }
+
+    @Test
+    void shouldGetPolicyByServiceId()
+            throws ExecutionException, InterruptedException, TimeoutException {
+
+        CompletableFuture<String> message = new CompletableFuture<>();
+
+        final var uuid =
+                ContextOuterClass.Uuid.newBuilder()
+                        .setUuid(UUID.fromString("0f14d0ab-9608-7862-a9e4-5ed26688389b").toString())
+                        .build();
+        final var serviceId = ContextOuterClass.ServiceId.newBuilder().setServiceUuid(uuid).build();
+
+        client
+                .getPolicyByServiceId(serviceId)
+                .subscribe()
+                .with(
+                        policyRuleList -> {
+                            LOGGER.infof("Getting policyRuleList with ID: %s", policyRuleList);
+                            message.complete(policyRuleList.toString());
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS)).isEmpty();
+    }
+}

src/policy/target/kubernetes/kubernetes.yml

----
-apiVersion: v1
-kind: Service
-metadata:
-  annotations:
-    app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
-    app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
-    prometheus.io/scrape: "true"
-    prometheus.io/path: /q/metrics
-    prometheus.io/port: "8080"
-    prometheus.io/scheme: http
-  labels:
-    app.kubernetes.io/name: policyservice
-    app: policyservice
-  name: policyservice
-spec:
-  ports:
-    - name: http
-      port: 9192
-      targetPort: 8080
-    - name: grpc-server
-      port: 6060
-      targetPort: 6060
-  selector:
-    app.kubernetes.io/name: policyservice
-  type: ClusterIP
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  annotations:
-    app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
-    app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
-    prometheus.io/scrape: "true"
-    prometheus.io/path: /q/metrics
-    prometheus.io/port: "8080"
-    prometheus.io/scheme: http
-  labels:
-    app: policyservice
-    app.kubernetes.io/name: policyservice
-  name: policyservice
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app.kubernetes.io/name: policyservice
-  template:
-    metadata:
-      annotations:
-        app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
-        app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
-        prometheus.io/scrape: "true"
-        prometheus.io/path: /q/metrics
-        prometheus.io/port: "8080"
-        prometheus.io/scheme: http
-      labels:
-        app: policyservice
-        app.kubernetes.io/name: policyservice
-    spec:
-      containers:
-        - env:
-            - name: KUBERNETES_NAMESPACE
-              valueFrom:
-                fieldRef:
-                  fieldPath: metadata.namespace
-            - name: SERVICE_SERVICE_HOST
-              value: serviceservice
-            - name: MONITORING_SERVICE_HOST
-              value: monitoringservice
-            - name: CONTEXT_SERVICE_HOST
-              value: contextservice
-          image: labs.etsi.org:5050/tfs/controller/policy:0.1.0
-          imagePullPolicy: Always
-          livenessProbe:
-            failureThreshold: 3
-            httpGet:
-              path: /q/health/live
-              port: 8080
-              scheme: HTTP
-            initialDelaySeconds: 2
-            periodSeconds: 10
-            successThreshold: 1
-            timeoutSeconds: 10
-          name: policyservice
-          ports:
-            - containerPort: 8080
-              name: http
-              protocol: TCP
-            - containerPort: 6060
-              name: grpc-server
-              protocol: TCP
-          readinessProbe:
-            failureThreshold: 3
-            httpGet:
-              path: /q/health/ready
-              port: 8080
-              scheme: HTTP
-            initialDelaySeconds: 2
-            periodSeconds: 10
-            successThreshold: 1
-            timeoutSeconds: 10
-          resources:
-            limits:
-              cpu: 500m
-              memory: 2048Mi
-            requests:
-              cpu: 50m
-              memory: 512Mi