tests added

kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/integration/odd/SchemaReferencesResolver.java

@@ -5,6 +5,8 @@ import com.google.common.collect.ImmutableSet;
 import com.provectus.kafka.ui.sr.api.KafkaSrClientApi;
 import com.provectus.kafka.ui.sr.model.SchemaReference;
 import java.util.List;
+import java.util.Optional;
+import javax.annotation.Nullable;
 import reactor.core.publisher.Mono;
 
 // logic copied from AbstractSchemaProvider:resolveReferences
@@ -18,11 +20,8 @@ class SchemaReferencesResolver {
   }
 
   Mono<ImmutableMap<String, String>> resolve(List<SchemaReference> refs) {
-    return resolveReferences(
-        refs == null ? List.of() : refs,
-        new Resolving(ImmutableMap.of(), ImmutableSet.of())).map(
-        Resolving::resolved
-    );
+    return resolveReferences(refs, new Resolving(ImmutableMap.of(), ImmutableSet.of()))
+        .map(Resolving::resolved);
   }
 
   private record Resolving(ImmutableMap<String, String> resolved, ImmutableSet<String> visited) {
@@ -36,9 +35,9 @@ class SchemaReferencesResolver {
     }
   }
 
-  private Mono<Resolving> resolveReferences(List<SchemaReference> references, Resolving initState) {
+  private Mono<Resolving> resolveReferences(@Nullable List<SchemaReference> refs, Resolving initState) {
     Mono<Resolving> result = Mono.just(initState);
-    for (SchemaReference reference : references) {
+    for (SchemaReference reference : Optional.ofNullable(refs).orElse(List.of())) {
       result = result.flatMap(state -> {
         if (state.visited().contains(reference.getName())) {
           return Mono.just(state);
@@ -47,8 +46,7 @@ class SchemaReferencesResolver {
           return client.getSubjectVersion(reference.getSubject(), String.valueOf(reference.getVersion()), true)
               .flatMap(subj ->
                   resolveReferences(subj.getReferences(), newState)
-                      .map(withNewRefs -> withNewRefs.resolve(reference.getName(), subj.getSchema()))
-              );
+                      .map(withNewRefs -> withNewRefs.resolve(reference.getName(), subj.getSchema())));
         }
       });
     }

kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/integration/odd/SchemaReferencesResolverTest.java

@@ -11,6 +11,7 @@ import com.provectus.kafka.ui.sr.model.SchemaSubject;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
 
 class SchemaReferencesResolverTest {
 
@@ -19,7 +20,7 @@ class SchemaReferencesResolverTest {
   private final SchemaReferencesResolver schemaReferencesResolver = new SchemaReferencesResolver(srClientMock);
 
   @Test
-  void test() {
+  void resolvesRefsUsingSrClient() {
     mockSrCall("sub1", 1,
         new SchemaSubject()
             .schema("schema1"));
@@ -46,26 +47,36 @@ class SchemaReferencesResolverTest {
         new SchemaSubject()
             .schema("schema2_1_1"));
 
-    var result = schemaReferencesResolver.resolve(
+    var resolvedRefsMono = schemaReferencesResolver.resolve(
         List.of(
             new SchemaReference().name("ref1").subject("sub1").version(1),
-            new SchemaReference().name("ref2").subject("sub2").version(1)
-        )
-    );
+            new SchemaReference().name("ref2").subject("sub2").version(1)));
 
-    assertThat(result.block())
-        .containsExactlyEntriesOf(
-            // checking map should be ordered
-            ImmutableMap.<String, String>builder()
-                .put("ref1", "schema1")
-                .put("ref2_1_1", "schema2_1_1")
-                .put("ref2_1", "schema2_1")
-                .put("ref2_2", "schema1")
-                .put("ref2", "schema2")
-                .build()
-        );
+    StepVerifier.create(resolvedRefsMono)
+        .assertNext(refs ->
+            assertThat(refs)
+                .containsExactlyEntriesOf(
+                    // checking map should be ordered
+                    ImmutableMap.<String, String>builder()
+                        .put("ref1", "schema1")
+                        .put("ref2_1_1", "schema2_1_1")
+                        .put("ref2_1", "schema2_1")
+                        .put("ref2_2", "schema1")
+                        .put("ref2", "schema2")
+                        .build()))
+        .verifyComplete();
   }
 
+  @Test
+  void returnsEmptyMapOnEmptyInputs() {
+    StepVerifier.create(schemaReferencesResolver.resolve(null))
+        .assertNext(map -> assertThat(map).isEmpty())
+        .verifyComplete();
+
+    StepVerifier.create(schemaReferencesResolver.resolve(List.of()))
+        .assertNext(map -> assertThat(map).isEmpty())
+        .verifyComplete();
+  }
 
   private void mockSrCall(String subject, int version, SchemaSubject subjectToReturn) {
     when(srClientMock.getSubjectVersion(subject, version + "", true))