OZG-6990 extend grpc util: add more keys and methods

README.md

@@ -4,6 +4,7 @@
 
 ### 4.6.0-SNAPSHOT
 * Update [OZGCloud License Generator](ozgcloud-common-license/readme.md)
+* `GrpcUtil` erweitern: mehr Schlüsseln hinzufügen und Methoden, um diese Schlüssel aus gRPC-Metadaten zu extrahieren.
 
 ### 4.5.0
 * common-lib erweitern: gRPC Server Downloader für binäre Dateien hinzufügen

ozgcloud-common-lib/src/main/java/de/ozgcloud/common/grpc/GrpcUtil.java

@@ -24,10 +24,10 @@
 package de.ozgcloud.common.grpc;
 
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 import io.grpc.Metadata;
@@ -39,8 +39,11 @@ import lombok.NoArgsConstructor;
 public class GrpcUtil {
 
 	public static final Key<byte[]> HEADER_KEY_USER_ID = createKeyOf("USER_ID-bin");
+	public static final Key<byte[]> HEADER_KEY_USER_NAME = createKeyOf("USER_NAME-bin");
 	public static final Key<byte[]> HEADER_KEY_CLIENT_NAME = createKeyOf("CLIENT_NAME-bin");
 	public static final Key<byte[]> HEADER_KEY_REQUEST_ID = createKeyOf("REQUEST_ID-bin");
+	public static final Key<byte[]> HEADER_KEY_ACCESS_LIMITED_ORGAID = createKeyOf("ACCESS_LIMITED_TO_ORGANISATORISCHEEINHEITENID-bin");
+	public static final Key<byte[]> HEADER_KEY_ACCESS_LIMITED = createKeyOf("ACCESS_LIMITED-bin");
 
 	public static Key<String> keyOfString(String key) {
 		return Key.of(key, Metadata.ASCII_STRING_MARSHALLER);
@@ -50,6 +53,30 @@ public class GrpcUtil {
 		return Key.of(key, Metadata.BINARY_BYTE_MARSHALLER);
 	}
 
+	public static Optional<String> getRequestId(Metadata headers) {
+		return getFromHeaders(HEADER_KEY_REQUEST_ID, headers);
+	}
+
+	public static Optional<String> getClientName(Metadata headers) {
+		return getFromHeaders(HEADER_KEY_CLIENT_NAME, headers);
+	}
+
+	public static Optional<String> getUserId(Metadata headers) {
+		return getFromHeaders(HEADER_KEY_USER_ID, headers);
+	}
+
+	public static Optional<String> getUserName(Metadata headers) {
+		return getFromHeaders(HEADER_KEY_USER_NAME, headers);
+	}
+
+	public static List<String> getAccessLimitedOrgaIds(Metadata headers) {
+		return getList(HEADER_KEY_ACCESS_LIMITED_ORGAID, headers);
+	}
+
+	public static Optional<String> getAccessLimited(Metadata headers) {
+		return getFromHeaders(HEADER_KEY_ACCESS_LIMITED, headers);
+	}
+
 	public static Optional<String> getFromHeaders(String key, Metadata headers) {
 		return getFromHeaders(createKeyOf(key), headers);
 	}
@@ -58,14 +85,13 @@ public class GrpcUtil {
 		return Optional.ofNullable(headers.get(key)).map(GrpcUtil::byteToString);
 	}
 
-	public static Collection<String> getCollection(String key, Metadata headers) {
-		final List<String> result = new ArrayList<>();
-		var valuesOptional = Optional.ofNullable(headers.getAll(createKeyOf(key)));
-		valuesOptional.ifPresent(valuesBytes -> result.addAll(StreamSupport.stream(valuesBytes.spliterator(), false)
-				.map(GrpcUtil::byteToString)
-				.toList()));
+	public static List<String> getList(String key, Metadata headers) {
+		return getList(createKeyOf(key), headers);
+	}
 
-		return result;
+	public static List<String> getList(Key<byte[]> key, Metadata headers) {
+		return Optional.ofNullable(headers.getAll(key)).map(valuesBytes -> StreamSupport.stream(valuesBytes.spliterator(), false))
+				.orElseGet(Stream::empty).map(GrpcUtil::byteToString).toList();
 	}
 
 	private static String byteToString(byte[] bytes) {

ozgcloud-common-lib/src/test/java/de/ozgcloud/common/grpc/GrpcUtilTest.java

@@ -2,6 +2,7 @@ package de.ozgcloud.common.grpc;
 
 import static org.assertj.core.api.Assertions.*;
 
+import com.thedeanda.lorem.LoremIpsum;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -9,98 +10,184 @@ import org.junit.jupiter.api.Test;
 
 import io.grpc.Metadata;
 
+import java.util.UUID;
+
 class GrpcUtilTest {
+
 	private static final String KEY_VALUE_BIN = "key_value-bin";
 	private static final String KEY_VALUE_STRING = "key_value";
 	private static final String UNKNOWN_KEY_BIN = "unknown_key-bin";
 
-	@DisplayName("Test Grpc Utility methods")
+	private final Metadata header = new Metadata();
+
+	@DisplayName("Test creation of MetaData keys")
+	@Nested
+	class TestKeyGeneration {
+
+		@Test
+		void shouldCreateBinaryKey() {
+			var key = GrpcUtil.createKeyOf(KEY_VALUE_BIN);
+
+			assertThat(key.name()).isEqualTo(KEY_VALUE_BIN);
+		}
+
+		@Test
+		void shouldThrowExceptionBecauseOfMissingBinSuffix() {
+			assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> GrpcUtil.createKeyOf("key"));
+		}
+
+		@Test
+		void shouldCreateAsciiKey() {
+			var key = GrpcUtil.keyOfString(KEY_VALUE_STRING);
+
+			assertThat(key.name()).isEqualTo(KEY_VALUE_STRING);
+		}
+
+		@Test
+		void shouldThrowExceptionBecauseOfBinSuffix() {
+			assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> GrpcUtil.keyOfString(KEY_VALUE_BIN));
+		}
+	}
+
+	@DisplayName("Test reading values from the grpc header")
+	@Nested
+	class TestReadingFromHeader {
+		private static final String TEST_VALUE = LoremIpsum.getInstance().getWords(1);
+
+		@BeforeEach
+		void initMetadata() {
+			header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE.getBytes());
+		}
+
+		@Test
+		void shouldReadFromHeader() {
+			var value = GrpcUtil.getFromHeaders(KEY_VALUE_BIN, header);
+
+			assertThat(value).contains(TEST_VALUE);
+		}
+
+		@Test
+		void shouldReturnNullOnUnknownKey() {
+			var value = GrpcUtil.getFromHeaders(UNKNOWN_KEY_BIN, header);
+
+			assertThat(value).isEmpty();
+		}
+	}
+
+	@DisplayName("Test reading multiple values of a key from the grpc header")
+	@Nested
+	class TestReadingCollection {
+		private static final String TEST_VALUE_1 = LoremIpsum.getInstance().getWords(1);
+		private static final String TEST_VALUE_2 = LoremIpsum.getInstance().getWords(2);
+
+		@BeforeEach
+		void initMetadata() {
+			header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE_1.getBytes());
+			header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE_2.getBytes());
+		}
+
+		@Test
+		void shouldReadFromHeader() {
+			var values = GrpcUtil.getList(KEY_VALUE_BIN, header);
+
+			assertThat(values).hasSize(2).contains(TEST_VALUE_1, TEST_VALUE_2);
+		}
+
+		@Test
+		void shouldGetEmptyCollectionOnUnknownKey() {
+			var values = GrpcUtil.getList(UNKNOWN_KEY_BIN, header);
+
+			assertThat(values).isEmpty();
+		}
+	}
+
 	@Nested
-	class TestGrpcUtils {
+	class TestGetRequestId {
 
-		@DisplayName("Test creation of MetaData keys")
-		@Nested
-		class TestKeyGeneration {
+		private static final String REQUEST_ID = UUID.randomUUID().toString();
 
-			@Test
-			void shouldCreateBinaryKey() {
-				var key = GrpcUtil.createKeyOf(KEY_VALUE_BIN);
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_REQUEST_ID, REQUEST_ID.getBytes());
 
-				assertThat(key.name()).isEqualTo(KEY_VALUE_BIN);
-			}
+			var result = GrpcUtil.getRequestId(header);
 
-			@Test
-			void shouldThrowExceptionBecauseOfMissingBinSuffix() {
-				assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> GrpcUtil.createKeyOf("key"));
-			}
+			assertThat(result).contains(REQUEST_ID);
+		}
+	}
+
+	@Nested
+	class TestGetClientName {
 
-			@Test
-			void shouldCreateAsciiKey() {
-				var key = GrpcUtil.keyOfString(KEY_VALUE_STRING);
+		private static final String CLIENT_NAME = LoremIpsum.getInstance().getWords(1);
 
-				assertThat(key.name()).isEqualTo(KEY_VALUE_STRING);
-			}
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_CLIENT_NAME, CLIENT_NAME.getBytes());
 
-			@Test
-			void shouldThrowExceptionBecauseOfBinSuffix() {
-				assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> GrpcUtil.keyOfString(KEY_VALUE_BIN));
-			}
+			var result = GrpcUtil.getClientName(header);
+
+			assertThat(result).contains(CLIENT_NAME);
 		}
+	}
 
-		@DisplayName("Test reading values from the grpc header")
-		@Nested
-		class TestReadingFromHeader {
-			private static final String TEST_VALUE = "test-value";
+	@Nested
+	class TestGetUserId {
 
-			private Metadata header = new Metadata();
+		private static final String USER_ID = LoremIpsum.getInstance().getWords(1);
 
-			@BeforeEach
-			void initMetadata() {
-				header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE.getBytes());
-			}
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_USER_ID, USER_ID.getBytes());
 
-			@Test
-			void shouldReadFromHeader() {
-				var value = GrpcUtil.getFromHeaders(KEY_VALUE_BIN, header);
+			var result = GrpcUtil.getUserId(header);
 
-				assertThat(value).contains(TEST_VALUE);
-			}
+			assertThat(result).contains(USER_ID);
+		}
+	}
+
+	@Nested
+	class TestGetUserName {
 
-			@Test
-			void shouldReturnNullOnUnknownKey() {
-				var value = GrpcUtil.getFromHeaders(UNKNOWN_KEY_BIN, header);
+		private static final String USER_NAME = LoremIpsum.getInstance().getWords(1);
 
-				assertThat(value).isEmpty();
-			}
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_USER_NAME, USER_NAME.getBytes());
+
+			var result = GrpcUtil.getUserName(header);
+
+			assertThat(result).contains(USER_NAME);
 		}
+	}
 
-		@DisplayName("Test reading multiple values of a key from the grpc header")
-		@Nested
-		class TestReadingCollection {
-			private static final String TEST_VALUE_1 = "test-value-1";
-			private static final String TEST_VALUE_2 = "test-value-2";
+	@Nested
+	class TestGetAccessLimitedOrgaId {
+
+		private static final String ACCESS_LIMITED_ORGAID = LoremIpsum.getInstance().getWords(1);
 
-			private Metadata header = new Metadata();
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_ACCESS_LIMITED_ORGAID, ACCESS_LIMITED_ORGAID.getBytes());
 
-			@BeforeEach
-			void initMetadata() {
-				header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE_1.getBytes());
-				header.put(GrpcUtil.createKeyOf(KEY_VALUE_BIN), TEST_VALUE_2.getBytes());
-			}
+			var result = GrpcUtil.getAccessLimitedOrgaIds(header);
+
+			assertThat(result).containsExactly(ACCESS_LIMITED_ORGAID);
+		}
+	}
+
+	@Nested
+	class TestGetAccessLimited {
 
-			@Test
-			void shouldReadFromHeader() {
-				var values = GrpcUtil.getCollection(KEY_VALUE_BIN, header);
+		private static final String ACCESS_LIMITED = "access-limited";
 
-				assertThat(values).hasSize(2).contains(TEST_VALUE_1, TEST_VALUE_2);
-			}
+		@Test
+		void shouldCallGetFromHeader() {
+			header.put(GrpcUtil.HEADER_KEY_ACCESS_LIMITED, ACCESS_LIMITED.getBytes());
 
-			@Test
-			void shouldGetEmptyCollectionOnUnknownKey() {
-				var values = GrpcUtil.getCollection(UNKNOWN_KEY_BIN, header);
+			var result = GrpcUtil.getAccessLimited(header);
 
-				assertThat(values).isEmpty();
-			}
+			assertThat(result).contains(ACCESS_LIMITED);
 		}
 	}
 }