Merge branch 'feat/add-ztpAdd-bind-and-serializer' into 'develop'

Feat/add ztp add bind and serializer

See merge request teraflow-h2020/controller!82

src/automation/pom.xml

@@ -5,7 +5,7 @@
 
   <groupId>eu.teraflow</groupId>
   <artifactId>automation</artifactId>
-  <version>0.1.0</version>
+  <version>0.2.0</version>
   <name>TeraFlow Automation Component</name>
   <description>TeraFlow Automation Component</description>
 

src/automation/src/main/java/eu/teraflow/automation/AutomationGatewayImpl.java

@@ -2,6 +2,8 @@ package eu.teraflow.automation;
 
 import automation.Automation;
 import context.ContextOuterClass;
+import eu.teraflow.automation.device.model.Device;
+import eu.teraflow.automation.model.DeviceRoleId;
 import io.quarkus.grpc.GrpcService;
 import io.smallrye.mutiny.Uni;
 import javax.inject.Inject;
@@ -32,18 +34,13 @@ public class AutomationGatewayImpl implements AutomationGateway {
 
     @Override
     public Uni<Automation.DeviceRoleState> ztpAdd(Automation.DeviceRole request) {
+        final var devRoleId = request.getDevRoleId().getDevRoleId().getUuid();
         final var deviceId = serializer.deserialize(request.getDevRoleId().getDevId());
 
-        // TODO tie this with return
-        automationService.addDevice(deviceId);
-
-        // TODO Set all fields of device role state (create models, serializer)
-        return Uni.createFrom()
-                .item(
-                        () ->
-                                Automation.DeviceRoleState.newBuilder()
-                                        .setDevRoleId(request.getDevRoleId())
-                                        .build());
+        return automationService
+                .addDevice(deviceId)
+                .onItem()
+                .transform( device -> transformToDeviceRoleState(device, devRoleId));
     }
 
     @Override
@@ -70,4 +67,16 @@ public class AutomationGatewayImpl implements AutomationGateway {
     public Uni<Automation.DeviceDeletionResult> ztpDeleteAll(Automation.Empty empty) {
         return Uni.createFrom().item(() -> Automation.DeviceDeletionResult.newBuilder().build());
     }
-}
+
+    // TODO When `DeviceRoleState` domain object will be created, move this method to Serializer class and create related tests
+    private Automation.DeviceRoleState transformToDeviceRoleState(Device device, String devRoleId){
+
+        final var deviceRoleId = new DeviceRoleId(devRoleId, device.getDeviceId());
+        final var serializeDeviceRoleId = serializer.serialize(deviceRoleId);
+
+        return Automation.DeviceRoleState.newBuilder()
+                .setDevRoleId(serializeDeviceRoleId)
+                .setDevRoleState(Automation.ZtpDeviceState.ZTP_DEV_STATE_CREATED)
+                .build();
+    }
+}
\ No newline at end of file

src/automation/src/main/java/eu/teraflow/automation/Serializer.java

 package eu.teraflow.automation;
 
+import automation.Automation;
 import context.ContextOuterClass;
 import context.ContextOuterClass.DeviceId;
 import context.ContextOuterClass.DeviceOperationalStatusEnum;
@@ -12,20 +13,98 @@ import eu.teraflow.automation.device.model.Device;
 import eu.teraflow.automation.device.model.DeviceConfig;
 import eu.teraflow.automation.device.model.DeviceEvent;
 import eu.teraflow.automation.device.model.DeviceOperationalStatus;
+import eu.teraflow.automation.model.DeviceRole;
+import eu.teraflow.automation.model.DeviceRoleId;
+import eu.teraflow.automation.model.DeviceRoleType;
 import java.util.stream.Collectors;
 import javax.inject.Singleton;
 
 @Singleton
 public class Serializer {
 
+    public DeviceId serializeDeviceId(String expectedDeviceId) {
+        final var builder = DeviceId.newBuilder();
+        final var uuid = serializeUuid(expectedDeviceId);
+
+        builder.setDeviceUuid(uuid);
+
+        return builder.build();
+    }
+
     public String deserialize(DeviceId deviceId) {
         return deviceId.getDeviceUuid().getUuid();
     }
 
-    public DeviceId serializeDeviceId(String expectedDeviceId) {
-        final var uuid = Uuid.newBuilder().setUuid(expectedDeviceId).build();
+    public Automation.DeviceRoleId serialize(DeviceRoleId deviceRoleId) {
+        final var builder = Automation.DeviceRoleId.newBuilder();
+
+        final var deviceRoleDevRoleId = deviceRoleId.getId();
+        final var deviceRoleDeviceId = deviceRoleId.getDeviceId();
+
+        final var deviceRoleDevRoleIdUuid = serializeUuid(deviceRoleDevRoleId);
+        final var deviceRoleDeviceIdUuid = serializeUuid(deviceRoleDeviceId);
+
+        final var deviceId = DeviceId.newBuilder().setDeviceUuid(deviceRoleDeviceIdUuid);
+
+        builder.setDevRoleId(deviceRoleDevRoleIdUuid);
+        builder.setDevId(deviceId);
+
+        return builder.build();
+    }
+
+    public DeviceRoleId deserialize(Automation.DeviceRoleId deviceRoleId) {
+        final var devRoleId = deserialize(deviceRoleId.getDevRoleId());
+        final var devId = deserialize(deviceRoleId.getDevId());
+
+        return new DeviceRoleId(devRoleId, devId);
+    }
+
+    public Automation.DeviceRoleType serialize(DeviceRoleType deviceRoleType) {
+        switch (deviceRoleType) {
+            case NONE:
+                return Automation.DeviceRoleType.NONE;
+            case DEV_OPS:
+                return Automation.DeviceRoleType.DEV_OPS;
+            case DEV_CONF:
+                return Automation.DeviceRoleType.DEV_CONF;
+            case PIPELINE_CONF:
+                return Automation.DeviceRoleType.PIPELINE_CONF;
+            default:
+                return Automation.DeviceRoleType.UNRECOGNIZED;
+        }
+    }
+
+    public DeviceRoleType deserialize(Automation.DeviceRoleType serializedDeviceRoleType) {
+        switch (serializedDeviceRoleType) {
+            case DEV_OPS:
+                return DeviceRoleType.DEV_OPS;
+            case DEV_CONF:
+                return DeviceRoleType.DEV_CONF;
+            case PIPELINE_CONF:
+                return DeviceRoleType.PIPELINE_CONF;
+            case NONE:
+            case UNRECOGNIZED:
+            default:
+                return DeviceRoleType.NONE;
+        }
+    }
+
+    public Automation.DeviceRole serialize(DeviceRole deviceRole) {
+        final var builder = Automation.DeviceRole.newBuilder();
+        final var serializedDeviceRoleId = serialize(deviceRole.getDeviceRoleId());
+        final var serializedDeviceRoleType = serialize(deviceRole.getType());
+
+        builder.setDevRoleId(serializedDeviceRoleId);
+        builder.setDevRoleType(serializedDeviceRoleType);
+
+        return builder.build();
+    }
+
+    public DeviceRole deserialize(Automation.DeviceRole deviceRole) {
+        final var deviceRoleId = deserialize(deviceRole.getDevRoleId());
+        final var deviceRoleType = deserialize(deviceRole.getDevRoleType());
 
-        return ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(uuid).build();
+        return new DeviceRole(deviceRoleId, deviceRoleType);
     }
 
     public ContextOuterClass.EventTypeEnum serialize(EventTypeEnum eventTypeEnum) {
@@ -77,8 +156,10 @@ public class Serializer {
 
     public ContextOuterClass.DeviceEvent serialize(DeviceEvent deviceEvent) {
         final var builder = ContextOuterClass.DeviceEvent.newBuilder();
+        final var deviceIdUuid = serializeUuid(deviceEvent.getDeviceId());
+        final var deviceId = DeviceId.newBuilder().setDeviceUuid(deviceIdUuid);
 
-        builder.setDeviceId(serializeDeviceId(deviceEvent.getDeviceId()));
+        builder.setDeviceId(deviceId);
         builder.setEvent(serialize(deviceEvent.getEvent()));
 
         return builder.build();
@@ -180,8 +261,10 @@ public class Serializer {
 
     public ContextOuterClass.Device serialize(Device device) {
         final var builder = ContextOuterClass.Device.newBuilder();
+        final var deviceIdUuid = serializeUuid(device.getDeviceId());
+        final var deviceId = DeviceId.newBuilder().setDeviceUuid(deviceIdUuid);
 
-        builder.setDeviceId(serializeDeviceId(device.getDeviceId()));
+        builder.setDeviceId(deviceId);
         builder.setDeviceType(device.getDeviceType());
         builder.setDeviceConfig(serialize(device.getDeviceConfig()));
         builder.setDeviceOperationalStatus(serialize(device.getDeviceOperationalStatus()));

src/automation/src/main/java/eu/teraflow/automation/device/DeviceGatewayImpl.java

 package eu.teraflow.automation.device;
 
+import context.ContextOuterClass;
 import device.DeviceService;
 import eu.teraflow.automation.Serializer;
 import eu.teraflow.automation.device.model.Device;

src/automation/src/main/java/eu/teraflow/automation/model/DeviceRoleState.java

-package eu.teraflow.automation.model;
-
-public class DeviceRoleState {
-
-    private final DeviceRoleId deviceRoleId;
-    private final DeviceState deviceState;
-
-    public DeviceRoleState(DeviceRoleId deviceRoleId, DeviceState deviceState) {
-
-        this.deviceRoleId = deviceRoleId;
-        this.deviceState = deviceState;
-    }
-
-    public DeviceRoleId getDeviceRoleId() {
-        return deviceRoleId;
-    }
-
-    public DeviceState getDeviceState() {
-        return deviceState;
-    }
-}

src/automation/src/test/java/eu/teraflow/automation/AutomationServiceTest.java

@@ -3,14 +3,15 @@ package eu.teraflow.automation;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import automation.Automation;
-import automation.Automation.DeviceRole;
-import automation.Automation.DeviceRoleId;
 import automation.AutomationService;
 import context.ContextOuterClass;
+import eu.teraflow.automation.model.DeviceRole;
+import eu.teraflow.automation.model.DeviceRoleId;
 import eu.teraflow.automation.context.ContextGateway;
 import eu.teraflow.automation.device.DeviceGateway;
 import eu.teraflow.automation.device.model.*;
 import eu.teraflow.automation.device.model.Device;
+import eu.teraflow.automation.model.DeviceRoleType;
 import io.quarkus.grpc.GrpcClient;
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.mockito.InjectMock;
@@ -61,15 +62,11 @@ class AutomationServiceTest {
         Mockito.when(deviceGateway.configureDevice(Mockito.any()))
                 .thenReturn(Uni.createFrom().item(DEVICE_ID));
 
-        // TODO 1. add (de)serialization for device role (and its components) in serializer module
-        // TODO 2. use it here
-        final var serializedDeviceRoleId =
-                DeviceRoleId.newBuilder()
-                        .setDevRoleId(serializer.serializeUuid(DEVICE_ROLE_ID))
-                        .setDevId(serializer.serializeDeviceId(DEVICE_ID))
-                        .build();
-        final var serializedDeviceRole =
-                DeviceRole.newBuilder().setDevRoleId(serializedDeviceRoleId).build();
+        final var deviceRoleId = new DeviceRoleId(DEVICE_ROLE_ID, DEVICE_ID);
+        final var deviceRoleType = DeviceRoleType.DEV_OPS;
+        final var deviceRole = new DeviceRole(deviceRoleId, deviceRoleType);
+        final var serializedDeviceRole = serializer.serialize(deviceRole);
+
         client
                 .ztpAdd(serializedDeviceRole)
                 .subscribe()
@@ -78,6 +75,10 @@ class AutomationServiceTest {
                             LOGGER.infof("Received %s", deviceRoleState);
                             final var devRoleId = deviceRoleState.getDevRoleId();
 
+                            final var deviceRoleIdUuid = serializer.deserialize(devRoleId);
+
+                            assertThat(deviceRoleIdUuid.getId()).isEqualTo(DEVICE_ROLE_ID);
+
                             final var deviceId = serializer.deserialize(devRoleId.getDevId());
                             assertThat(deviceId).isEqualTo(DEVICE_ID);
 
@@ -90,40 +91,45 @@ class AutomationServiceTest {
     @Test
     void shouldUpdateDeviceRole() throws ExecutionException, InterruptedException, TimeoutException {
         CompletableFuture<String> message = new CompletableFuture<>();
-        final var UUID_VALUE = "0f14d0ab-9605-7862-a9e4-5ed26688389b";
+        final var DEVICE_ID = "0f14d0ab-9608-7862-a9e4-5ed26688389b";
+        final var DEVICE_ROLE_ID = "0f14d0ab-9608-7862-a9e4-5ed26688389a";
 
-        final var uuid = serializer.serializeUuid(UUID_VALUE);
-        final var deviceRoleId = DeviceRoleId.newBuilder().setDevRoleId(uuid).build();
-        final var deviceRole = DeviceRole.newBuilder().setDevRoleId(deviceRoleId).build();
+        final var deviceRoleId = new DeviceRoleId(DEVICE_ROLE_ID, DEVICE_ID);
+        final var deviceRoleType = DeviceRoleType.DEV_CONF;
+        final var deviceRole = new DeviceRole(deviceRoleId, deviceRoleType);
+        final var serializedDeviceRole = serializer.serialize(deviceRole);
 
         client
-                .ztpUpdate(deviceRole)
+                .ztpUpdate(serializedDeviceRole)
                 .subscribe()
                 .with(
                         deviceRoleState -> {
                             LOGGER.infof("Received response %s", deviceRoleState);
                             message.complete(deviceRoleState.getDevRoleId().toString());
                         });
-        assertThat(message.get(5, TimeUnit.SECONDS)).contains(UUID_VALUE);
+        assertThat(message.get(5, TimeUnit.SECONDS)).contains(DEVICE_ID);
     }
 
     @Test
     void shouldGetDeviceRole() throws ExecutionException, InterruptedException, TimeoutException {
         CompletableFuture<String> message = new CompletableFuture<>();
-        final var UUID_VALUE = "0f14d0ab-9605-7862-a9e4-5ed26688389b";
+        final var DEVICE_ID = "0f14d0ab-9608-7862-a9e4-5ed26688389b";
+        final var DEVICE_ROLE_ID = "0f14d0ab-9608-7862-a9e4-5ed26688389a";
 
-        final var uuid = serializer.serializeUuid(UUID_VALUE);
-        final var deviceRoleId = DeviceRoleId.newBuilder().setDevRoleId(uuid).build();
+        final var deviceRoleId = new DeviceRoleId(DEVICE_ROLE_ID, DEVICE_ID);
+        final var serializeDeviceRoleId = serializer.serialize(deviceRoleId);
 
         client
-                .ztpGetDeviceRole(deviceRoleId)
+                .ztpGetDeviceRole(serializeDeviceRoleId)
                 .subscribe()
                 .with(
                         deviceRole -> {
                             LOGGER.infof("Received response %s", deviceRole);
+                            assertThat(deviceRole.getDevRoleId().getDevId().getDeviceUuid().getUuid())
+                                    .isEqualTo(DEVICE_ID);
                             message.complete(deviceRole.getDevRoleId().toString());
                         });
-        assertThat(message.get(5, TimeUnit.SECONDS)).contains(UUID_VALUE);
+        assertThat(message.get(5, TimeUnit.SECONDS)).contains(DEVICE_ROLE_ID);
     }
 
     @Test
@@ -131,8 +137,7 @@ class AutomationServiceTest {
             throws ExecutionException, InterruptedException, TimeoutException {
         CompletableFuture<String> message = new CompletableFuture<>();
 
-        final var uuid = serializer.serializeUuid("0f14d0ab-9605-7862-a9e4-5ed26688389b");
-        final var deviceId = ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(uuid).build();
+        final var deviceId = serializer.serializeDeviceId("0f14d0ab-9605-7862-a9e4-5ed26688389b");
 
         client
                 .ztpGetDeviceRolesByDeviceId(deviceId)
@@ -151,8 +156,8 @@ class AutomationServiceTest {
         final var UUID_VALUE = "0f14d0ab-9605-7862-a9e4-5ed26688389b";
 
         final var uuid = serializer.serializeUuid(UUID_VALUE);
-        final var deviceRoleId = DeviceRoleId.newBuilder().setDevRoleId(uuid).build();
-        final var deviceRole = DeviceRole.newBuilder().setDevRoleId(deviceRoleId).build();
+        final var deviceRoleId = Automation.DeviceRoleId.newBuilder().setDevRoleId(uuid).build();
+        final var deviceRole = Automation.DeviceRole.newBuilder().setDevRoleId(deviceRoleId).build();
 
         client
                 .ztpDelete(deviceRole)

src/automation/src/test/java/eu/teraflow/automation/SerializerTest.java

@@ -2,6 +2,7 @@ package eu.teraflow.automation;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import automation.Automation;
 import context.ContextOuterClass;
 import context.ContextOuterClass.DeviceId;
 import context.ContextOuterClass.DeviceOperationalStatusEnum;
@@ -14,6 +15,9 @@ import eu.teraflow.automation.device.model.Device;
 import eu.teraflow.automation.device.model.DeviceConfig;
 import eu.teraflow.automation.device.model.DeviceEvent;
 import eu.teraflow.automation.device.model.DeviceOperationalStatus;
+import eu.teraflow.automation.model.DeviceRole;
+import eu.teraflow.automation.model.DeviceRoleId;
+import eu.teraflow.automation.model.DeviceRoleType;
 import io.quarkus.test.junit.QuarkusTest;
 import java.util.List;
 import java.util.stream.Stream;
@@ -30,25 +34,143 @@ class SerializerTest {
 
     @Test
     void shouldSerializeDeviceId() {
-        final var expectedId = "expectedDeviceId";
-        final var expectedUuid = Uuid.newBuilder().setUuid(expectedId).build();
-        final var expectedDeviceId = DeviceId.newBuilder().setDeviceUuid(expectedUuid).build();
+        final var expectedDeviceId = "expectedDeviceId";
 
-        final var serializedDeviceId = serializer.serializeDeviceId("expectedDeviceId");
+        final var deviceIdUuid = serializer.serializeUuid(expectedDeviceId);
+        final var deviceId = ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(deviceIdUuid).build();
 
-        assertThat(serializedDeviceId).usingRecursiveComparison().isEqualTo(expectedDeviceId);
+        final var serializedDeviceId = serializer.serializeDeviceId(expectedDeviceId);
+
+        assertThat(serializedDeviceId).usingRecursiveComparison().isEqualTo(deviceId);
     }
 
     @Test
     void shouldDeserializeDeviceId() {
         final var expectedDeviceId = "expectedDeviceId";
 
-        final var serializedDeviceId = serializer.serializeDeviceId("expectedDeviceId");
+        final var serializedDeviceIdUuid = serializer.serializeUuid("expectedDeviceId");
+        final var serializedDeviceId = DeviceId.newBuilder().setDeviceUuid(serializedDeviceIdUuid).build();
+
         final var deviceId = serializer.deserialize(serializedDeviceId);
 
         assertThat(deviceId).isEqualTo(expectedDeviceId);
     }
 
+    @Test
+    void shouldSerializeDeviceRoleId() {
+        final var expectedDevRoleId = "expectedDevRoleId";
+        final var expectedDeviceId = "expectedDeviceId";
+
+        final var deviceRoleId = new DeviceRoleId(expectedDevRoleId, expectedDeviceId);
+        final var serializedDeviceRoleIdUuid = serializer.serializeUuid(expectedDevRoleId);
+        final var serializedDeviceRoleDeviceIdUuid = serializer.serializeUuid(expectedDeviceId);
+        final var serializedDeviceRoleDeviceId = ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(serializedDeviceRoleDeviceIdUuid).build();
+
+        final var expectedDeviceRoleId =
+                Automation.DeviceRoleId.newBuilder()
+                        .setDevRoleId(serializedDeviceRoleIdUuid)
+                        .setDevId(serializedDeviceRoleDeviceId)
+                        .build();
+
+        final var serializedDevRoleId =
+                serializer.serialize(deviceRoleId);
+
+        assertThat(serializedDevRoleId).usingRecursiveComparison().isEqualTo(expectedDeviceRoleId);
+    }
+
+    @Test
+    void shouldDeserializeDeviceRoleId() {
+        final var expectedDevRoleId = "expectedDevRoleId";
+        final var expectedDeviceId = "expectedDeviceId";
+
+        final var expectedDeviceRoleId = new DeviceRoleId(expectedDevRoleId, expectedDeviceId);
+
+        final var serializedDeviceRoleId = serializer.serialize(expectedDeviceRoleId);
+        final var deviceRoleId = serializer.deserialize(serializedDeviceRoleId);
+
+        assertThat(deviceRoleId).usingRecursiveComparison().isEqualTo(expectedDeviceRoleId);
+    }
+
+    private static Stream<Arguments> provideDeviceRoleType() {
+        return Stream.of(
+                Arguments.of(DeviceRoleType.DEV_OPS, Automation.DeviceRoleType.DEV_OPS),
+                Arguments.of(DeviceRoleType.DEV_CONF, Automation.DeviceRoleType.DEV_CONF),
+                Arguments.of(DeviceRoleType.NONE, Automation.DeviceRoleType.NONE),
+                Arguments.of(DeviceRoleType.PIPELINE_CONF, Automation.DeviceRoleType.PIPELINE_CONF));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideDeviceRoleType")
+    void shouldSerializeDeviceRoleType(
+            DeviceRoleType deviceRoleType, Automation.DeviceRoleType expectedSerializedType) {
+        final var serializedType = serializer.serialize(deviceRoleType);
+        assertThat(serializedType.getNumber()).isEqualTo(expectedSerializedType.getNumber());
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideDeviceRoleType")
+    void shouldDeserializeDeviceRoleType(
+            DeviceRoleType expectedDeviceRoleType,
+            Automation.DeviceRoleType serializedDeviceRoleTypeType) {
+
+        final var deviceRoleType = serializer.deserialize(serializedDeviceRoleTypeType);
+
+        assertThat(deviceRoleType).isEqualTo(expectedDeviceRoleType);
+    }
+
+    @Test
+    void shouldSerializeDeviceRole() {
+        final var expectedDevRoleId = "expectedDevRoleId";
+        final var expectedDeviceId = "expectedDeviceId";
+
+        final var serializedDeviceRoleDevRoleIdUuid = serializer.serializeUuid(expectedDevRoleId);
+        final var serializedDeviceRoleDeviceId = serializer.serializeDeviceId(expectedDeviceId);
+
+        final var expectedDeviceRoleId = Automation.DeviceRoleId.newBuilder()
+                .setDevRoleId(serializedDeviceRoleDevRoleIdUuid)
+                .setDevId(serializedDeviceRoleDeviceId)
+                .build();
+
+        final var expectedDeviceRoleType = Automation.DeviceRoleType.PIPELINE_CONF;
+
+        final var expectedDeviceRole = Automation.DeviceRole.newBuilder()
+                .setDevRoleId(expectedDeviceRoleId)
+                .setDevRoleType(expectedDeviceRoleType)
+                .build();
+
+        final var deviceRoleId = new DeviceRoleId(expectedDevRoleId,expectedDeviceId);
+        final var deviceRoleType = DeviceRoleType.PIPELINE_CONF;
+
+        final var deviceRole = new DeviceRole(deviceRoleId, deviceRoleType);
+        final var serializedDeviceRole = serializer.serialize(deviceRole);
+
+        assertThat(serializedDeviceRole).usingRecursiveComparison().isEqualTo(expectedDeviceRole);
+    }
+
+    @Test
+    void shouldDeserializeDeviceRole() {
+        final var expectedDevRoleId = "expectedDevRoleId";
+        final var expectedDeviceId = "expectedDeviceId";
+
+        final var expectedDeviceRoleId = new DeviceRoleId(expectedDevRoleId, expectedDeviceId);
+        final var expectedDeviceRoleType = DeviceRoleType.NONE;
+
+        final var expectedDeviceRole = new DeviceRole(expectedDeviceRoleId, expectedDeviceRoleType);
+
+        final var serializedDeviceRoleId = serializer.serialize(expectedDeviceRoleId);
+        final var serializedDeviceRoleType = serializer.serialize(expectedDeviceRoleType);
+
+        final var serializedDeviceRole =
+                Automation.DeviceRole.newBuilder()
+                        .setDevRoleId(serializedDeviceRoleId)
+                        .setDevRoleType(serializedDeviceRoleType)
+                        .build();
+
+        final var deviceRole = serializer.deserialize(serializedDeviceRole);
+
+        assertThat(deviceRole).usingRecursiveComparison().isEqualTo(expectedDeviceRole);
+    }
+
     private static Stream<Arguments> provideEventTypeEnum() {
         return Stream.of(
                 Arguments.of(EventTypeEnum.CREATE, ContextOuterClass.EventTypeEnum.EVENTTYPE_CREATE),
@@ -302,7 +424,10 @@ class SerializerTest {
         final var expectedDeviceConfig =
                 ContextOuterClass.DeviceConfig.newBuilder().addConfigRules(expectedConfigRule).build();
         final var deviceBuilder = ContextOuterClass.Device.newBuilder();
-        deviceBuilder.setDeviceId(serializer.serializeDeviceId("deviceId"));
+
+        final var serializedDeviceId = serializer.serializeDeviceId("deviceId");
+
+        deviceBuilder.setDeviceId(serializedDeviceId);
         deviceBuilder.setDeviceType("deviceType");
         deviceBuilder.setDeviceConfig(expectedDeviceConfig);
         deviceBuilder.setDeviceOperationalStatus(serializer.serialize(DeviceOperationalStatus.ENABLED));
@@ -334,8 +459,11 @@ class SerializerTest {
                         .build();
         final var deviceConfig =
                 ContextOuterClass.DeviceConfig.newBuilder().addConfigRules(configRule).build();
+
+        final var serializedDeviceId = serializer.serializeDeviceId("deviceId");
+
         final var deviceBuilder = ContextOuterClass.Device.newBuilder();
-        deviceBuilder.setDeviceId(serializer.serializeDeviceId("deviceId"));
+        deviceBuilder.setDeviceId(serializedDeviceId);
         deviceBuilder.setDeviceType("deviceType");
         deviceBuilder.setDeviceConfig(deviceConfig);
         deviceBuilder.setDeviceOperationalStatus(serializer.serialize(DeviceOperationalStatus.ENABLED));

src/automation/target/kubernetes/kubernetes.yml

@@ -3,20 +3,20 @@ apiVersion: v1
 kind: Service
 metadata:
   annotations:
-    app.quarkus.io/commit-id: 500a0a232ec361b669b48cc432e9bd9c332eae8b
-    app.quarkus.io/build-timestamp: 2022-02-11 - 10:27:21 +0000
+    app.quarkus.io/commit-id: 644f8ea4385acb720eab7317de057f9d1d8ebfe6
+    app.quarkus.io/build-timestamp: 2022-02-14 - 10:21:58 +0000
   labels:
     app.kubernetes.io/name: automationservice
     app: automationservice
   name: automationservice
 spec:
   ports:
-    - name: grpc-server
-      port: 9999
-      targetPort: 9999
     - name: http
       port: 8080
       targetPort: 8080
+    - name: grpc-server
+      port: 9999
+      targetPort: 9999
   selector:
     app.kubernetes.io/name: automationservice
   type: ClusterIP
@@ -25,8 +25,8 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   annotations:
-    app.quarkus.io/commit-id: 500a0a232ec361b669b48cc432e9bd9c332eae8b
-    app.quarkus.io/build-timestamp: 2022-02-11 - 10:27:21 +0000
+    app.quarkus.io/commit-id: 644f8ea4385acb720eab7317de057f9d1d8ebfe6
+    app.quarkus.io/build-timestamp: 2022-02-14 - 10:21:58 +0000
   labels:
     app: automationservice
     app.kubernetes.io/name: automationservice
@@ -39,8 +39,8 @@ spec:
   template:
     metadata:
       annotations:
-        app.quarkus.io/commit-id: 500a0a232ec361b669b48cc432e9bd9c332eae8b
-        app.quarkus.io/build-timestamp: 2022-02-11 - 10:27:21 +0000
+        app.quarkus.io/commit-id: 644f8ea4385acb720eab7317de057f9d1d8ebfe6
+        app.quarkus.io/build-timestamp: 2022-02-14 - 10:21:58 +0000
       labels:
         app: automationservice
         app.kubernetes.io/name: automationservice
@@ -51,11 +51,11 @@ spec:
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.namespace
-            - name: CONTEXT_SERVICE_HOST
-              value: contextservice
             - name: DEVICE_SERVICE_HOST
               value: deviceservice
-          image: registry.gitlab.com/teraflow-h2020/controller/automation:0.1.0
+            - name: CONTEXT_SERVICE_HOST
+              value: contextservice
+          image: registry.gitlab.com/teraflow-h2020/controller/automation:0.2.0
           imagePullPolicy: Always
           livenessProbe:
             failureThreshold: 3
@@ -69,12 +69,12 @@ spec:
             timeoutSeconds: 10
           name: automationservice
           ports:
-            - containerPort: 9999
-              name: grpc-server
-              protocol: TCP
             - containerPort: 8080
               name: http
               protocol: TCP
+            - containerPort: 9999
+              name: grpc-server
+              protocol: TCP
           readinessProbe:
             failureThreshold: 3
             httpGet: