BAEL-8167 - Comparing Java Stream and Flux fromIterable (#18385)

* BAEL-8167 - Comparing Java Stream and Flux.fromIterable()

* BAEL-8167 - Comparing Java Stream and Flux.fromIterable()

* Moved classes to the rearranged module under spring-reactive-modules

* Deleted from local project spring-webflux/src/test/java/com/baeldung/spring/streamvsfluxfromiterable directory

Author: rajnikantpandey50

spring-reactive-modules/spring-webflux/src/test/java/com/baeldung/spring/streamvsfluxfromiterable/FluxFromIterableUnitTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.spring.streamvsfluxfromiterable;
+
+import java.time.Duration;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import reactor.core.publisher.Flux;
+import reactor.test.StepVerifier;
+import reactor.test.scheduler.VirtualTimeScheduler;
+
+@SuppressWarnings("unchecked")
+public class FluxFromIterableUnitTest {
+
+    @Test
+    void givenList_whenProcessedWithFlux_thenReturnDoubledEvenNumbers() {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+        Flux<Integer> fluxPipeline = Flux.fromIterable(numbers)
+          .filter(n -> n % 2 == 0)
+          .map(n -> n * 2);
+
+        StepVerifier.create(fluxPipeline)
+          .expectNext(4, 16);
+    }
+
+    @Test
+    void givenList_whenProcessingTakesLongerThanEmission_thenEmittedBeforeProcessing() {
+        VirtualTimeScheduler.set(VirtualTimeScheduler.create());
+
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+        Flux<Integer> sourceFlux = Flux.fromIterable(numbers)
+          .delayElements(Duration.ofMillis(500));
+
+        Flux<Integer> processedFlux = sourceFlux.flatMap(n -> Flux.just(n * n)
+          .delayElements(Duration.ofSeconds(1)));
+
+        StepVerifier.withVirtualTime(() -> Flux.merge(sourceFlux, processedFlux))
+          .expectSubscription()
+          .expectNoEvent(Duration.ofMillis(500))
+          .thenAwait(Duration.ofMillis(500 * 5))
+          .expectNextCount(7)
+          .thenAwait(Duration.ofMillis(5000))
+          .expectNextCount(3)
+          .verifyComplete();
+
+    }
+
+    @Test
+    void givenList_whenDividedByZeroInFlux_thenReturnFallbackValue() {
+        List<Integer> numbers = List.of(1, 2, 0, 4, 5);
+        Flux<Integer> flux = Flux.fromIterable(numbers)
+          .map(n -> 10 / n)
+          .onErrorResume(e -> Flux.just(-1));
+
+        StepVerifier.create(flux)
+          .expectNext(10, 5, -1)
+          .verifyComplete();
+    }
+
+    @Test
+    void givenFlux_whenMultipleSubscribers_thenEachReceivesData() {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+        Flux<Integer> flux = Flux.fromIterable(numbers)
+          .map(n -> n * 2);
+
+        StepVerifier.create(flux)
+          .expectNext(2, 4, 6, 8, 10)
+          .verifyComplete();
+
+        StepVerifier.create(flux)
+          .expectNext(2, 4, 6, 8, 10)
+          .verifyComplete();
+    }
+
+}

spring-reactive-modules/spring-webflux/src/test/java/com/baeldung/spring/streamvsfluxfromiterable/JavaStreamUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.spring.streamvsfluxfromiterable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+
+@SuppressWarnings("unchecked")
+public class JavaStreamUnitTest {
+
+    @Test
+    void givenList_whenProcessedWithStream_thenReturnDoubledEvenNumbers() {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+
+        List<Integer> doubledEvenNumbers = numbers.stream()
+          .filter(n -> n % 2 == 0)
+          .map(n -> n * n)
+          .toList();
+        assertEquals(List.of(4, 16), doubledEvenNumbers);
+    }
+
+    @Test
+    void givenList_whenNoTerminalOperator_thenNoResponse() {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+        Function<Integer, Integer> mockMapper = mock(Function.class);
+        Stream<Integer> streamPipeline = numbers.stream()
+          .map(mockMapper);
+        verifyNoInteractions(mockMapper);
+
+        List<Integer> mappedList = streamPipeline.toList();
+        verify(mockMapper, times(5));
+    }
+
+    @Test
+    void givenList_whenDividedByZeroInStream_thenThrowException() {
+        List<Integer> numbers = List.of(1, 2, 0, 4, 5);
+        assertThrows(ArithmeticException.class, () -> numbers.stream()
+          .map(n -> 10 / n)
+          .toList());
+    }
+
+    @Test
+    void givenStream_whenReused_thenThrowException() {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+        Stream<Integer> doubleStream = numbers.stream()
+          .map(n -> n * 2);
+
+        assertEquals(List.of(2, 4, 6, 8, 10), doubleStream.toList());
+
+        assertThrows(IllegalStateException.class, doubleStream::toList);
+    }
+
+}