1 files changed, 56 insertions, 56 deletions
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/NodeRepositoryTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/NodeRepositoryTest.java
index 0617884d227..5f357b9e4b0 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/NodeRepositoryTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/NodeRepositoryTest.java
@@ -32,19 +32,19 @@ public class NodeRepositoryTest {
     @Test
     public void add_and_remove() {
         NodeRepositoryTester tester = new NodeRepositoryTester();
-        assertEquals(0, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(0, tester.nodeRepository().getNodes().size());
 
         tester.addHost("id1", "host1", "default", NodeType.host);
         tester.addHost("id2", "host2", "default", NodeType.host);
         tester.addHost("id3", "host3", "default", NodeType.host);
 
-        assertEquals(3, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(3, tester.nodeRepository().getNodes().size());
         
-        tester.nodeRepository().nodes().park("host2", true, Agent.system, "Parking to unit test");
-        tester.nodeRepository().nodes().removeRecursively("host2");
+        tester.nodeRepository().park("host2", true, Agent.system, "Parking to unit test");
+        tester.nodeRepository().removeRecursively("host2");
 
-        assertEquals(3, tester.nodeRepository().nodes().getNodes().size());
-        assertEquals(1, tester.nodeRepository().nodes().getNodes(Node.State.deprovisioned).size());
+        assertEquals(3, tester.nodeRepository().getNodes().size());
+        assertEquals(1, tester.nodeRepository().getNodes(Node.State.deprovisioned).size());
     }
 
     @Test
@@ -53,14 +53,14 @@ public class NodeRepositoryTest {
         tester.addHost("id1", "host1", "docker", NodeType.tenant);
 
         try {
-            tester.nodeRepository().nodes().removeRecursively("host1"); // host1 is in state provisioned
+            tester.nodeRepository().removeRecursively("host1"); // host1 is in state provisioned
             fail("Should not be able to delete docker container node by itself in state provisioned");
         } catch (IllegalArgumentException ignored) {
             // Expected
         }
 
-        tester.nodeRepository().nodes().setReady("host1", Agent.system, getClass().getSimpleName());
-        tester.nodeRepository().nodes().removeRecursively("host1");
+        tester.nodeRepository().setReady("host1", Agent.system, getClass().getSimpleName());
+        tester.nodeRepository().removeRecursively("host1");
     }
 
     @Test
@@ -74,14 +74,14 @@ public class NodeRepositoryTest {
         tester.setNodeState("host2", Node.State.dirty);
         tester.setNodeState("cfg1", Node.State.dirty);
 
-        tester.nodeRepository().nodes().markNodeAvailableForNewAllocation("host1", Agent.system, getClass().getSimpleName());
-        assertEquals(Node.State.ready, tester.nodeRepository().nodes().getNode("host1").get().state());
+        tester.nodeRepository().markNodeAvailableForNewAllocation("host1", Agent.system, getClass().getSimpleName());
+        assertEquals(Node.State.ready, tester.nodeRepository().getNode("host1").get().state());
 
-        tester.nodeRepository().nodes().markNodeAvailableForNewAllocation("host2", Agent.system, getClass().getSimpleName());
-        assertFalse(tester.nodeRepository().nodes().getNode("host2").isPresent());
+        tester.nodeRepository().markNodeAvailableForNewAllocation("host2", Agent.system, getClass().getSimpleName());
+        assertFalse(tester.nodeRepository().getNode("host2").isPresent());
 
-        tester.nodeRepository().nodes().markNodeAvailableForNewAllocation("cfg1", Agent.system, getClass().getSimpleName());
-        assertEquals(Node.State.ready, tester.nodeRepository().nodes().getNode("cfg1").get().state());
+        tester.nodeRepository().markNodeAvailableForNewAllocation("cfg1", Agent.system, getClass().getSimpleName());
+        assertEquals(Node.State.ready, tester.nodeRepository().getNode("cfg1").get().state());
     }
 
     @Test
@@ -92,17 +92,17 @@ public class NodeRepositoryTest {
         tester.setNodeState("host1", Node.State.dirty);
         tester.setNodeState("host2", Node.State.dirty);
 
-        Node node2 = tester.nodeRepository().nodes().getNode("host2").orElseThrow();
+        Node node2 = tester.nodeRepository().getNode("host2").orElseThrow();
         var reportsBuilder = new Reports.Builder(node2.reports());
         reportsBuilder.setReport(Report.basicReport("reportId", Report.Type.HARD_FAIL, Instant.EPOCH, "hardware failure"));
         node2 = node2.with(reportsBuilder.build());
-        tester.nodeRepository().nodes().write(node2, () -> {});
+        tester.nodeRepository().write(node2, () -> {});
 
-        tester.nodeRepository().nodes().markNodeAvailableForNewAllocation("host1", Agent.system, getClass().getSimpleName());
-        assertEquals(Node.State.ready, tester.nodeRepository().nodes().getNode("host1").get().state());
+        tester.nodeRepository().markNodeAvailableForNewAllocation("host1", Agent.system, getClass().getSimpleName());
+        assertEquals(Node.State.ready, tester.nodeRepository().getNode("host1").get().state());
 
         try {
-            tester.nodeRepository().nodes().markNodeAvailableForNewAllocation("host2", Agent.system, getClass().getSimpleName());
+            tester.nodeRepository().markNodeAvailableForNewAllocation("host2", Agent.system, getClass().getSimpleName());
             fail();
         } catch (IllegalArgumentException e) {
             assertTrue(e.getMessage().contains("hardware failure"));
@@ -120,29 +120,29 @@ public class NodeRepositoryTest {
         tester.addNode("node12", "node12", "host1", "docker", NodeType.tenant);
         tester.addNode("node20", "node20", "host2", "docker", NodeType.tenant);
         tester.setNodeState("node11", Node.State.active);
-        assertEquals(6, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(6, tester.nodeRepository().getNodes().size());
 
         try {
-            tester.nodeRepository().nodes().removeRecursively("host1");
+            tester.nodeRepository().removeRecursively("host1");
             fail("Should not be able to delete host node, one of the children is in state active");
         } catch (IllegalArgumentException ignored) {
             // Expected
         }
-        assertEquals(6, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(6, tester.nodeRepository().getNodes().size());
 
         // Should be OK to delete host2 as both host2 and its only child, node20, are in state provisioned
-        tester.nodeRepository().nodes().removeRecursively("host2");
-        assertEquals(5, tester.nodeRepository().nodes().getNodes().size());
-        assertEquals(Node.State.deprovisioned, tester.nodeRepository().nodes().getNode("host2").get().state());
+        tester.nodeRepository().removeRecursively("host2");
+        assertEquals(5, tester.nodeRepository().getNodes().size());
+        assertEquals(Node.State.deprovisioned, tester.nodeRepository().getNode("host2").get().state());
 
         // Now node10 is in provisioned, set node11 to failed and node12 to ready, and it should be OK to delete host1
-        tester.nodeRepository().nodes().fail("node11", Agent.system, getClass().getSimpleName());
-        tester.nodeRepository().nodes().setReady("node12", Agent.system, getClass().getSimpleName());
-        tester.nodeRepository().nodes().removeRecursively("node12"); // Remove one of the children first instead
-        assertEquals(4, tester.nodeRepository().nodes().getNodes().size());
-        tester.nodeRepository().nodes().removeRecursively("host1");
-        assertEquals(Node.State.deprovisioned, tester.nodeRepository().nodes().getNode("host1").get().state());
-        assertEquals(IP.Config.EMPTY.primary(), tester.nodeRepository().nodes().getNode("host1").get().ipConfig().primary());
+        tester.nodeRepository().fail("node11", Agent.system, getClass().getSimpleName());
+        tester.nodeRepository().setReady("node12", Agent.system, getClass().getSimpleName());
+        tester.nodeRepository().removeRecursively("node12"); // Remove one of the children first instead
+        assertEquals(4, tester.nodeRepository().getNodes().size());
+        tester.nodeRepository().removeRecursively("host1");
+        assertEquals(Node.State.deprovisioned, tester.nodeRepository().getNode("host1").get().state());
+        assertEquals(IP.Config.EMPTY.primary(), tester.nodeRepository().getNode("host1").get().ipConfig().primary());
     }
 
     @Test
@@ -155,20 +155,20 @@ public class NodeRepositoryTest {
         tester.addNode("id2", cfg1, cfghost1, "docker", NodeType.config);
         tester.setNodeState(cfghost1, Node.State.active);
         tester.setNodeState(cfg1, Node.State.active);
-        assertEquals(2, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(2, tester.nodeRepository().getNodes().size());
 
         try {
-            tester.nodeRepository().nodes().removeRecursively(cfghost1);
+            tester.nodeRepository().removeRecursively(cfghost1);
             fail("Should not be able to delete host node, one of the children is in state active");
         } catch (IllegalArgumentException ignored) { }
-        assertEquals(2, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(2, tester.nodeRepository().getNodes().size());
 
         // Fail host and container
-        tester.nodeRepository().nodes().failRecursively(cfghost1, Agent.system, getClass().getSimpleName());
+        tester.nodeRepository().failRecursively(cfghost1, Agent.system, getClass().getSimpleName());
 
         // Remove recursively
-        tester.nodeRepository().nodes().removeRecursively(cfghost1);
-        assertEquals(0, tester.nodeRepository().nodes().list().not().state(Node.State.deprovisioned).size());
+        tester.nodeRepository().removeRecursively(cfghost1);
+        assertEquals(0, tester.nodeRepository().list().not().state(Node.State.deprovisioned).size());
     }
 
     @Test
@@ -179,29 +179,29 @@ public class NodeRepositoryTest {
         tester.clock().advance(Duration.ofSeconds(1));
         tester.addHost("id1", "host1", "default", NodeType.host);
         tester.addHost("id2", "host2", "default", NodeType.host);
-        assertFalse(tester.nodeRepository().nodes().getNode("host1").get().history().hasEventAfter(History.Event.Type.deprovisioned, testStart));
+        assertFalse(tester.nodeRepository().getNode("host1").get().history().hasEventAfter(History.Event.Type.deprovisioned, testStart));
 
         // Set host 1 properties and deprovision it
-        try (var lock = tester.nodeRepository().nodes().lockAndGetRequired("host1")) {
+        try (var lock = tester.nodeRepository().lockAndGetRequired("host1")) {
             Node host1 = lock.node().withWantToRetire(true, true, Agent.system, tester.nodeRepository().clock().instant());
             host1 = host1.withFirmwareVerifiedAt(tester.clock().instant());
             host1 = host1.with(host1.status().withIncreasedFailCount());
             host1 = host1.with(host1.reports().withReport(Report.basicReport("id", Report.Type.HARD_FAIL, tester.clock().instant(), "Test report")));
-            tester.nodeRepository().nodes().write(host1, lock);
+            tester.nodeRepository().write(host1, lock);
         }
-        tester.nodeRepository().nodes().removeRecursively("host1");
+        tester.nodeRepository().removeRecursively("host1");
 
         // Host 1 is deprovisioned and unwanted properties are cleared
-        Node host1 = tester.nodeRepository().nodes().getNode("host1").get();
+        Node host1 = tester.nodeRepository().getNode("host1").get();
         assertEquals(Node.State.deprovisioned, host1.state());
         assertTrue(host1.history().hasEventAfter(History.Event.Type.deprovisioned, testStart));
 
         // Adding it again preserves some information from the deprovisioned host and removes it
         tester.addHost("id2", "host1", "default", NodeType.host);
-        host1 = tester.nodeRepository().nodes().getNode("host1").get();
+        host1 = tester.nodeRepository().getNode("host1").get();
         assertEquals("This is the newly added node", "id2", host1.id());
         assertFalse("The old 'host1' is removed",
-                    tester.nodeRepository().nodes().getNode("host1", Node.State.deprovisioned).isPresent());
+                    tester.nodeRepository().getNode("host1", Node.State.deprovisioned).isPresent());
         assertFalse("Not transferred from deprovisioned host", host1.status().wantToRetire());
         assertFalse("Not transferred from deprovisioned host", host1.status().wantToDeprovision());
         assertTrue("Transferred from deprovisioned host", host1.history().hasEventAfter(History.Event.Type.deprovisioned, testStart));
@@ -225,15 +225,15 @@ public class NodeRepositoryTest {
         tester.setNodeState("node12", Node.State.active);
         tester.setNodeState("node20", Node.State.failed);
 
-        assertEquals(6, tester.nodeRepository().nodes().getNodes().size());
+        assertEquals(6, tester.nodeRepository().getNodes().size());
 
         // Should be OK to dirty host2 as it is in provisioned and its only child is in failed
-        tester.nodeRepository().nodes().deallocateRecursively("host2", Agent.system, NodeRepositoryTest.class.getSimpleName());
+        tester.nodeRepository().deallocateRecursively("host2", Agent.system, NodeRepositoryTest.class.getSimpleName());
         assertEquals(asSet("host2", "node20"), filterNodes(tester, node -> node.state() == Node.State.dirty));
 
         // Cant dirty host1, node11 is ready and node12 is active
         try {
-            tester.nodeRepository().nodes().deallocateRecursively("host1", Agent.system, NodeRepositoryTest.class.getSimpleName());
+            tester.nodeRepository().deallocateRecursively("host1", Agent.system, NodeRepositoryTest.class.getSimpleName());
             fail("Should not be able to dirty host1");
         } catch (IllegalArgumentException ignored) { } // Expected;
 
@@ -248,27 +248,27 @@ public class NodeRepositoryTest {
         String reason = NodeRepositoryTest.class.getSimpleName();
 
         try {
-            tester.nodeRepository().nodes().breakfixRecursively("node1", Agent.system, reason);
+            tester.nodeRepository().breakfixRecursively("node1", Agent.system, reason);
             fail("Should not be able to breakfix tenant node");
         } catch (IllegalArgumentException ignored) {}
 
         try {
-            tester.nodeRepository().nodes().breakfixRecursively("host1", Agent.system, reason);
+            tester.nodeRepository().breakfixRecursively("host1", Agent.system, reason);
             fail("Should not be able to breakfix host in state not in [parked, failed]");
         } catch (IllegalArgumentException ignored) {}
 
         tester.setNodeState("host1", Node.State.failed);
         tester.setNodeState("node1", Node.State.active);
         try {
-            tester.nodeRepository().nodes().breakfixRecursively("host1", Agent.system, reason);
+            tester.nodeRepository().breakfixRecursively("host1", Agent.system, reason);
             fail("Should not be able to breakfix host with active tenant node");
         } catch (IllegalArgumentException ignored) {}
 
         tester.setNodeState("node1", Node.State.failed);
-        tester.nodeRepository().nodes().breakfixRecursively("host1", Agent.system, reason);
+        tester.nodeRepository().breakfixRecursively("host1", Agent.system, reason);
 
-        assertEquals(1, tester.nodeRepository().nodes().getNodes().size());
-        Node node = tester.nodeRepository().nodes().getNodes().get(0);
+        assertEquals(1, tester.nodeRepository().getNodes().size());
+        Node node = tester.nodeRepository().getNodes().get(0);
         assertEquals("host1", node.hostname());
         assertEquals(Node.State.breakfixed, node.state());
     }
@@ -278,7 +278,7 @@ public class NodeRepositoryTest {
     }
 
     private static Set<String> filterNodes(NodeRepositoryTester tester, Predicate<Node> filter) {
-        return tester.nodeRepository().nodes()
+        return tester.nodeRepository()
                 .getNodes().stream()
                 .filter(filter)
                 .map(Node::hostname)