Merge branch 'OZG-7909-persist-server-data' into 'main'

Ozg 7909 persist server data

See merge request !20

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/AggregationDataTestFactory.java

+package de.ozgcloud.aggregation.data;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.Map;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+public class AggregationDataTestFactory {
+
+	public static final String KOMMUNE = LoremIpsum.getInstance().getWords(1);
+	public static final String ID = GrpcAggregationDataTestFactory.ID;
+	public static final String STATUS = GrpcAggregationDataTestFactory.STATUS;
+	public static final ZonedDateTime EIGNANG_DATUM = ZonedDateTime.parse(GrpcAggregationDataTestFactory.EINGANG_DATUM);
+	public static final String VORGANG_NAME = GrpcAggregationDataTestFactory.VORGANG_NAME;
+	public static final Map<String, Object> PAYLOAD = Map.of(
+			GrpcPropertyTestFactory.STRING_KEY, GrpcPropertyTestFactory.STRING_VALUE,
+			GrpcPropertyTestFactory.LIST_KEY, List.of(GrpcPropertyTestFactory.LIST_VALUE),
+			GrpcPropertyTestFactory.MAP_KEY, Map.of(GrpcPropertyTestFactory.NESTED_MAP_KEY, GrpcPropertyTestFactory.MAP_VALUE));
+
+	public static AggregationData create() {
+		return createBuilder().build();
+	}
+
+	public static AggregationData.AggregationDataBuilder createBuilder() {
+		return AggregationData.builder()
+				.id(ID)
+				.kommune(KOMMUNE)
+				.status(STATUS)
+				.eingangDatum(EIGNANG_DATUM)
+				.vorgangName(VORGANG_NAME)
+				.payload(PAYLOAD);
+	}
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/CustomAggregationDataRepositoryImplTest.java

+package de.ozgcloud.aggregation.data;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.data.mongodb.core.MongoTemplate;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+class CustomAggregationDataRepositoryImplTest {
+
+	@InjectMocks
+	private CustomAggregationDataRepositoryImpl repository;
+	@Mock
+	private MongoTemplate mongoTemplate;
+
+	@Nested
+	class TestSaveInCollection {
+
+		private final AggregationData aggregationData = AggregationDataTestFactory.create();
+		private final String collectionName = LoremIpsum.getInstance().getWords(1);
+
+		@BeforeEach
+		void mock() {
+			when(mongoTemplate.save(any(), any())).thenReturn(aggregationData);
+		}
+
+		@Test
+		void shouldSaveInCollection() {
+			repository.saveInCollection(aggregationData, collectionName);
+
+			verify(mongoTemplate).save(aggregationData, collectionName);
+		}
+
+		@Test
+		void shouldReturnSavedAggregationData() {
+			var result = repository.saveInCollection(aggregationData, collectionName);
+
+			assertThat(result).isSameAs(aggregationData);
+		}
+	}
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcAggregationDataRequestObserverTest.java

+package de.ozgcloud.aggregation.data;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import io.grpc.stub.StreamObserver;
+
+class GrpcAggregationDataRequestObserverTest {
+
+	@InjectMocks
+	private GrpcAggregationDataRequestObserver grpcAggregationDataRequestObserver;
+
+	@Mock
+	private AggregationDataMapper aggregationDataMapper;
+	@Mock
+	private AggregationDataService aggregationDataService;
+	@Mock
+	private StreamObserver<GrpcSendAggregationDataResponse> responseObserver;
+
+	@Nested
+	class TestWithResponseObserver {
+
+		@Test
+		void shouldSetResponseObserver() {
+			var requestObserver = grpcAggregationDataRequestObserver.withResponseObserver(responseObserver);
+
+			assertThat(ReflectionTestUtils.getField(requestObserver, GrpcAggregationDataRequestObserver.class, "responseObserver"))
+					.isEqualTo(responseObserver);
+		}
+	}
+
+	@Nested
+	class TestOnNext {
+
+		@BeforeEach
+		void mock() {
+			when(aggregationDataMapper.fromGrpc(any())).thenReturn(AggregationDataTestFactory.createBuilder().kommune(null).build());
+		}
+
+		@Test
+		void shouldCallAggregationDataMapper() {
+			grpcAggregationDataRequestObserver.onNext(GrpcSendAggregationDataRequestTestFactory.create());
+
+			verify(aggregationDataMapper).fromGrpc(GrpcSendAggregationDataRequestTestFactory.AGGREGATION_DATA);
+		}
+
+		@Test
+		void shouldCallAggregationDataService() {
+			grpcAggregationDataRequestObserver.onNext(GrpcSendAggregationDataRequestTestFactory.create());
+
+			verify(aggregationDataService).save(AggregationDataTestFactory.create(), GrpcSendAggregationDataRequestTestFactory.MAPPING_NAME);
+		}
+	}
+
+	@Nested
+	class TestOnError {
+
+		@BeforeEach
+		void init() {
+			grpcAggregationDataRequestObserver.withResponseObserver(responseObserver);
+		}
+
+		@Test
+		void shouldCallResponseObserverOnError() {
+			var error = new RuntimeException("Test error");
+
+			grpcAggregationDataRequestObserver.onError(error);
+
+			verify(responseObserver).onError(error);
+		}
+	}
+
+	@Nested
+	class TestOnCompleted {
+
+		@BeforeEach
+		void init() {
+			grpcAggregationDataRequestObserver.withResponseObserver(responseObserver);
+		}
+
+		@Test
+		void shouldCallOnNext() {
+			grpcAggregationDataRequestObserver.onCompleted();
+
+			verify(responseObserver).onNext(GrpcSendAggregationDataResponse.getDefaultInstance());
+		}
+
+		@Test
+		void shouldCallResponseObserverOnCompleted() {
+			grpcAggregationDataRequestObserver.onCompleted();
+
+			verify(responseObserver).onCompleted();
+		}
+	}
+
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcAggregationDataTestFactory.java

+package de.ozgcloud.aggregation.data;
+
+import java.time.ZonedDateTime;
+import java.util.UUID;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.aggregation.data.GrpcAggregationData.Builder;
+
+public class GrpcAggregationDataTestFactory {
+
+	public static final GrpcObject PAYLOAD = GrpcObjectTestFactory.create();
+	public static final String STATUS = LoremIpsum.getInstance().getWords(1);
+	public static final String ID = UUID.randomUUID().toString();
+	public static final String EINGANG_DATUM = ZonedDateTime.now().toString();
+	public static final String VORGANG_NAME = LoremIpsum.getInstance().getWords(1);
+
+	public static GrpcAggregationData create() {
+		return createBuilder().build();
+	}
+
+	public static Builder createBuilder() {
+		return GrpcAggregationData.newBuilder()
+				.setId(ID)
+				.setStatus(STATUS)
+				.setEingangDatum(EINGANG_DATUM)
+				.setVorgangName(VORGANG_NAME)
+				.setPayload(PAYLOAD);
+	}
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcObjectMapperTest.java

+package de.ozgcloud.aggregation.data;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mapstruct.factory.Mappers;
+
+class GrpcObjectMapperTest {
+
+	private final GrpcObjectMapper grpcObjectMapper = Mappers.getMapper(GrpcObjectMapper.class);
+
+	@Nested
+	class TestToMap {
+
+		@Test
+		void shouldMapGrpcObjectToMap() {
+			var map = grpcObjectMapper.toMap(GrpcObjectTestFactory.create());
+
+			assertThat(map).usingRecursiveComparison().isEqualTo(AggregationDataTestFactory.PAYLOAD);
+		}
+	}
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcObjectTestFactory.java

+package de.ozgcloud.aggregation.data;
+
+import de.ozgcloud.aggregation.data.GrpcObject.Builder;
+
+public class GrpcObjectTestFactory {
+
+	public static GrpcObject create() {
+		return createBuilder().build();
+	}
+
+	private static Builder createBuilder() {
+		return GrpcObject.newBuilder()
+				.addProperties(GrpcPropertyTestFactory.createStringProperty())
+				.addProperties(GrpcPropertyTestFactory.createListProperty())
+				.addProperties(GrpcPropertyTestFactory.creatMapProperty());
+	}
+
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcPropertyTestFactory.java

+package de.ozgcloud.aggregation.data;
+
+public class GrpcPropertyTestFactory {
+
+    public static final String STRING_VALUE = "stringValue";
+    public static final String STRING_KEY = "stringKey";
+    public static final String LIST_VALUE = "listValue";
+    public static final String LIST_KEY = "listKey";
+    public static final String MAP_VALUE = "mapValue";
+    public static final String MAP_KEY = "mapKey";
+    public static final String NESTED_MAP_KEY = "nestedMapKey";
+
+    public static GrpcProperty createStringProperty() {
+        return GrpcProperty.newBuilder()
+                .setKey(STRING_KEY)
+                .setValue(GrpcElement.newBuilder()
+                        .setStringValue(STRING_VALUE)
+                        .build())
+                .build();
+    }
+
+    public static GrpcProperty createListProperty() {
+        return GrpcProperty.newBuilder()
+                .setKey(LIST_KEY)
+                .setValue(GrpcElement.newBuilder()
+                        .setListValue(GrpcElementList.newBuilder()
+                                .addElements(GrpcElement.newBuilder()
+                                        .setStringValue(LIST_VALUE)
+                                        .build())
+                                .build())
+                        .build())
+                .build();
+    }
+
+    public static GrpcProperty creatMapProperty() {
+        return GrpcProperty.newBuilder()
+                .setKey(MAP_KEY)
+                .setValue(GrpcElement.newBuilder()
+                        .setObjectValue(GrpcObject.newBuilder()
+                                .addProperties(GrpcProperty.newBuilder()
+                                        .setKey(NESTED_MAP_KEY)
+                                        .setValue(GrpcElement.newBuilder().setStringValue(MAP_VALUE).build())
+                                        .build())
+                                .build())
+                        .build())
+                .build();
+    }
+
+}

aggregation-manager-server/src/test/java/de/ozgcloud/aggregation/data/GrpcSendAggregationDataRequestTestFactory.java

+package de.ozgcloud.aggregation.data;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.aggregation.data.GrpcSendAggregationDataRequest.Builder;
+
+public class GrpcSendAggregationDataRequestTestFactory {
+
+	public static final GrpcAggregationData AGGREGATION_DATA = GrpcAggregationDataTestFactory.create();
+	public static final String MANDANT = AggregationDataTestFactory.KOMMUNE;
+	public static final String MAPPING_NAME = LoremIpsum.getInstance().getWords(1);
+
+	public static GrpcSendAggregationDataRequest create() {
+		return createBuilder()
+				.build();
+	}
+
+	public static Builder createBuilder() {
+		return GrpcSendAggregationDataRequest.newBuilder()
+				.addAggregationData(AGGREGATION_DATA)
+				.setMandant(MANDANT)
+				.setName(MAPPING_NAME);
+	}
+}

aggregation-manager-server/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension

+org.mockito.junit.jupiter.MockitoExtension
\ No newline at end of file

aggregation-manager-server/src/test/resources/junit-platform.properties

+junit.jupiter.extensions.autodetection.enabled = true
\ No newline at end of file