refactor(automation): add DeviceRole (de)serialization (19ec3808) · Commits · TFS / controller

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

+88 −5

Original line number	Diff line number	Diff line
		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

+1 −0

Original line number	Diff line number	Diff line
		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

deleted100644 → 0

+0 −21

Original line number	Diff line number	Diff line
		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

+31 −26

Original line number	Diff line number	Diff line
		@@ -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

+136 −8

Original line number	Diff line number	Diff line
		@@ -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));