SmokeTest.kt etc

Co-authored-by: Ioannis Panagiotas <ioannis.panagiotas@neo4j.com>

Author: AlfredClemedtson

doc/modules/ROOT/pages/operations-reference/algorithm-references.adoc

@@ -227,10 +227,11 @@
 | `gds.louvain.stream.estimate` label:procedure[Procedure]
 | `gds.louvain.stats` label:procedure[Procedure]
 | `gds.louvain.stats.estimate` label:procedure[Procedure]
-.3+<.^|Max flow
+.4+<.^|Max flow
 | `gds.maxFlow.mutate` label:procedure[Procedure]
 | `gds.maxFlow.stats` label:procedure[Procedure]
 | `gds.maxFlow.stream` label:procedure[Procedure]
+| `gds.maxFlow.write` label:procedure[Procedure]
 .4+<.^|xref:algorithms/approx-max-k-cut.adoc[Approximate Maximum k-cut]
 | `gds.maxkcut.mutate` label:procedure[Procedure]
 | `gds.maxkcut.mutate.estimate` label:procedure[Procedure]

open-packaging/src/test/java/org/neo4j/gds/OpenGdsProcedureSmokeTest.java

@@ -472,6 +472,7 @@ class OpenGdsProcedureSmokeTest extends BaseProcTest {
         "gds.maxFlow.mutate",
         "gds.maxFlow.stats",
         "gds.maxFlow.stream",
+        "gds.maxFlow.write",
 
         "gds.nodeSimilarity.mutate",
         "gds.nodeSimilarity.mutate.estimate",
@@ -633,7 +634,7 @@ void countShouldMatch() {
         );
 
         // If you find yourself updating this count, please also update the count in SmokeTest.kt
-        int expectedCount = 471;
+        int expectedCount = 472;
         assertEquals(
             expectedCount,
             returnedRows,

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/PushbackPathFindingProcedureFacade.java

@@ -281,7 +281,7 @@ public Stream<MaxFlowStatsResult> maxFlowStats(String graphName, Map<String, Obj
 
     @Override
     public Stream<MaxFlowWriteResult> maxFlowWrite(String graphName, Map<String, Object> configuration) {
-        return Stream.empty();
+        return writeProcedureFacade.maxFlow(graphName, configuration);
     }
 
     @Override

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/write/MaxFlowWriteResultTransformer.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.procedures.algorithms.pathfinding.write;
+
+import org.neo4j.gds.api.Graph;
+import org.neo4j.gds.api.GraphStore;
+import org.neo4j.gds.api.ResultStore;
+import org.neo4j.gds.core.utils.progress.JobId;
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.pathfinding.MaxFlowWriteStep;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowWriteResult;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+import org.neo4j.gds.results.ResultTransformer;
+
+import java.util.Map;
+import java.util.stream.Stream;
+
+public class MaxFlowWriteResultTransformer implements ResultTransformer<TimedAlgorithmResult<FlowResult>, Stream<MaxFlowWriteResult>> {
+
+    private final MaxFlowWriteStep writeStep;
+    private final Graph graph;
+    private final GraphStore graphStore;
+    @Deprecated(forRemoval = true)
+    private final ResultStore resultStore;
+    private final JobId jobId;
+    private final Map<String, Object> configuration;
+
+    public MaxFlowWriteResultTransformer(
+        MaxFlowWriteStep writeStep,
+        Graph graph,
+        GraphStore graphStore,
+        ResultStore resultStore,
+        JobId jobId,
+        Map<String, Object> configuration
+    ) {
+        this.writeStep = writeStep;
+        this.graph = graph;
+        this.graphStore = graphStore;
+        this.resultStore = resultStore;
+        this.jobId = jobId;
+        this.configuration = configuration;
+    }
+
+    @Override
+    public Stream<MaxFlowWriteResult> apply(TimedAlgorithmResult<FlowResult> algorithmResult) {
+
+        var result = algorithmResult.result();
+        var writeRelationshipsMetadata = WriteStepExecute.executeWriteRelationshipStep(
+            writeStep,
+            graph,
+            graphStore,
+            jobId,
+            result,
+            resultStore
+        );
+        return Stream.of(
+            new MaxFlowWriteResult(
+                0,
+                algorithmResult.computeMillis(),
+                writeRelationshipsMetadata.writeMillis(),
+                writeRelationshipsMetadata.relationshipsWritten(),
+                result.totalFlow(),
+                configuration
+            )
+        );
+    }
+
+}

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/write/MaxFlowWriteResultTransformerBuilder.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.procedures.algorithms.pathfinding.write;
+
+import org.neo4j.gds.core.loading.GraphResources;
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.maxflow.MaxFlowWriteConfig;
+import org.neo4j.gds.pathfinding.MaxFlowWriteStep;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowWriteResult;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+import org.neo4j.gds.results.ResultTransformer;
+import org.neo4j.gds.results.ResultTransformerBuilder;
+
+import java.util.stream.Stream;
+
+class MaxFlowWriteResultTransformerBuilder implements ResultTransformerBuilder<TimedAlgorithmResult<FlowResult>, Stream<MaxFlowWriteResult>> {
+   private final MaxFlowWriteStep writeStep;
+   private final MaxFlowWriteConfig config;
+
+    MaxFlowWriteResultTransformerBuilder(MaxFlowWriteStep writeStep, MaxFlowWriteConfig config) {
+        this.writeStep = writeStep;
+        this.config = config;
+    }
+
+
+    @Override
+    public ResultTransformer<TimedAlgorithmResult<FlowResult>, Stream<MaxFlowWriteResult>> build(GraphResources graphResources) {
+        return new MaxFlowWriteResultTransformer(
+            writeStep,
+            graphResources.graph(),
+            graphResources.graphStore(),
+            graphResources.resultStore(),
+            config.jobId(),
+            config.toMap()
+        );
+    }
+
+}

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/write/PushbackPathFindingWriteProcedureFacade.java

@@ -25,8 +25,10 @@
 import org.neo4j.gds.applications.algorithms.machinery.WriteRelationshipService;
 import org.neo4j.gds.kspanningtree.KSpanningTreeWriteConfig;
 import org.neo4j.gds.logging.Log;
+import org.neo4j.gds.maxflow.MaxFlowWriteConfig;
 import org.neo4j.gds.pathfinding.BellmanFordWriteStep;
 import org.neo4j.gds.pathfinding.KSpanningTreeWriteStep;
+import org.neo4j.gds.pathfinding.MaxFlowWriteStep;
 import org.neo4j.gds.pathfinding.PathFindingComputeBusinessFacade;
 import org.neo4j.gds.pathfinding.PrizeCollectingSteinerTreeWriteStep;
 import org.neo4j.gds.pathfinding.ShortestPathWriteStep;
@@ -42,6 +44,7 @@
 import org.neo4j.gds.procedures.algorithms.configuration.UserSpecificConfigurationParser;
 import org.neo4j.gds.procedures.algorithms.pathfinding.BellmanFordWriteResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.KSpanningTreeWriteResult;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowWriteResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.PrizeCollectingSteinerTreeWriteResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.SpanningTreeWriteResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.SteinerWriteResult;
@@ -166,6 +169,30 @@ public Stream<KSpanningTreeWriteResult> kSpanningTree(
         ).join();
     }
 
+    public Stream<MaxFlowWriteResult> maxFlow(String graphName, Map<String, Object> configuration) {
+        var config = configurationParser.parseConfiguration(
+            configuration,
+            MaxFlowWriteConfig::of
+        );
+
+        var writeStep = new MaxFlowWriteStep(
+            writeRelationshipService,
+            config.writeRelationshipType(),
+            config.writeProperty(),
+            config::resolveResultStore,
+            config.jobId()
+        );
+
+        return businessFacade.maxFlow(
+            GraphName.parse(graphName),
+            config.toGraphParameters(),
+            config.relationshipWeightProperty(),
+            config.toParameters(),
+            config.jobId(),
+            config.logProgress(),
+            new MaxFlowWriteResultTransformerBuilder(writeStep, config)
+        ).join();
+    }
 
     public Stream<PrizeCollectingSteinerTreeWriteResult> pcst(
         String graphName,

procedures/pushback-procedures-facade/src/test/java/org/neo4j/gds/procedures/algorithms/pathfinding/PushbackPathFindingProcedureFacadeTest.java

@@ -353,6 +353,13 @@ void kSpanningTreeWrite() {
             verifyNoInteractions(mutateFacadeMock, statsFacadeMock, streamFacadeMock);
         }
 
+        @Test
+        void maxFlowWrite() {
+            facade.maxFlowWrite(graphName, config);
+            verify(writeFacadeMock).maxFlow(graphName, config);
+            verifyNoInteractions(mutateFacadeMock, statsFacadeMock, streamFacadeMock);
+        }
+
         @Test
         void prizeCollectingSteinerTreeWrite() {
             facade.prizeCollectingSteinerTreeWrite(graphName, config);

procedures/pushback-procedures-facade/src/test/java/org/neo4j/gds/procedures/algorithms/pathfinding/write/MaxFlowWriteResultTransformerTest.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.procedures.algorithms.pathfinding.write;
+
+import org.junit.jupiter.api.Test;
+import org.neo4j.gds.api.Graph;
+import org.neo4j.gds.api.GraphStore;
+import org.neo4j.gds.api.ResultStore;
+import org.neo4j.gds.applications.algorithms.metadata.RelationshipsWritten;
+import org.neo4j.gds.core.utils.progress.JobId;
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.pathfinding.MaxFlowWriteStep;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+class MaxFlowWriteResultTransformerTest {
+
+    @Test
+    void shouldTransformToWriteResult() {
+        var config = Map.<String, Object>of("foo", "bar");
+        var graph = mock(Graph.class);
+        var graphStore = mock(GraphStore.class);
+        var resultStore = mock(ResultStore.class);
+        var jobId = new JobId();
+        var writeStep = mock(MaxFlowWriteStep.class);
+
+        var algoResult = mock(FlowResult.class);
+        when(algoResult.totalFlow()).thenReturn(3D);
+
+        var relationshipsWritten = new RelationshipsWritten(5L);
+        when(writeStep.execute(any(), any(), any(), any(), any())).thenReturn(relationshipsWritten);
+
+        var timedResult = new TimedAlgorithmResult<>(algoResult, 123L);
+
+        var transformer = new MaxFlowWriteResultTransformer(writeStep, graph, graphStore, resultStore, jobId, config);
+
+        var resultStream = transformer.apply(timedResult);
+        var result = resultStream.findFirst().orElseThrow();
+
+        assertThat(result.preProcessingMillis()).isZero();
+        assertThat(result.computeMillis()).isEqualTo(123L);
+        assertThat(result.writeMillis()).isNotNegative();
+        assertThat(result.configuration()).isEqualTo(config);
+        assertThat(result.totalFlow()).isEqualTo(3D);
+
+        assertThat(result.relationshipsWritten()).isEqualTo(5L);
+
+        verify(writeStep, times(1)).execute(graph, graphStore, resultStore, algoResult, jobId);
+        verifyNoMoreInteractions(writeStep);
+    }
+
+    @Test
+    void shouldTransformEmptyResultToWriteResult() {
+        var config = Map.<String, Object>of("boo", "foo");
+        var graph = mock(Graph.class);
+        var graphStore = mock(GraphStore.class);
+        var resultStore = mock(ResultStore.class);
+        var jobId = new JobId();
+        var writeStep = mock(MaxFlowWriteStep.class);
+        when(writeStep.execute(any(), any(), any(), any(), any())).thenReturn(new RelationshipsWritten(0L));
+
+        var algoResult = FlowResult.EMPTY;
+
+        var timedResult = new TimedAlgorithmResult<>(algoResult, 123L);
+
+        var transformer = new MaxFlowWriteResultTransformer(writeStep, graph, graphStore, resultStore, jobId, config);
+
+        var resultStream = transformer.apply(timedResult);
+        var result = resultStream.findFirst().orElseThrow();
+
+        assertThat(result.preProcessingMillis()).isZero();
+        assertThat(result.computeMillis()).isEqualTo(123L);
+        assertThat(result.writeMillis()).isNotNegative();
+        assertThat(result.configuration()).isEqualTo(config);
+        assertThat(result.totalFlow()).isEqualTo(0d);
+        assertThat(result.relationshipsWritten()).isEqualTo(0);
+    }
+}