diff --git a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeIndexFacadeTest.java b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeIndexFacadeTest.java
index 465432a4a70c8..bf4df1e35baac 100644
--- a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeIndexFacadeTest.java
+++ b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeIndexFacadeTest.java
@@ -23,14 +23,12 @@
 
 import org.neo4j.graphdb.index.Index;
 
-import static org.neo4j.graphdb.NodeIndexFacadeMethods.ALL_NODE_INDEX_FACADE_METHODS;
-
 public class MandatoryTransactionsForNodeIndexFacadeTest extends AbstractMandatoryTransactionsTest<Index<Node>>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnNodeIndexFacade()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_NODE_INDEX_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), NodeIndexFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipIndexFacadeTest.java b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipIndexFacadeTest.java
index e0a79f2cff80c..13c922f0cdc5b 100644
--- a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipIndexFacadeTest.java
+++ b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipIndexFacadeTest.java
@@ -23,14 +23,12 @@
 
 import org.neo4j.graphdb.index.RelationshipIndex;
 
-import static org.neo4j.graphdb.RelationshipIndexFacadeMethods.ALL_RELATIONSHIP_INDEX_FACADE_METHODS;
-
 public class MandatoryTransactionsForRelationshipIndexFacadeTest extends AbstractMandatoryTransactionsTest<RelationshipIndex>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnRelationshipIndexFacade()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_RELATIONSHIP_INDEX_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), RelationshipIndexFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/NodeIndexFacadeMethods.java b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/NodeIndexFacadeMethods.java
index 3daa158c21a4d..1b224b1f1e03c 100644
--- a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/NodeIndexFacadeMethods.java
+++ b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/NodeIndexFacadeMethods.java
@@ -19,37 +19,38 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.index.Index;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.index.Index;
 
-public class NodeIndexFacadeMethods
+public enum NodeIndexFacadeMethods implements Consumer<Index<Node>>
 {
-    private static final FacadeMethod<Index<Node>> GET = new FacadeMethod<>( "IndexHits<T> get( String key, Object value )", self -> self.get( "foo", "bar" ) );
-    private static final FacadeMethod<Index<Node>> QUERY_BY_KEY = new FacadeMethod<>( "IndexHits<T> query( String key, Object queryOrQueryObject )", self -> self.query( "foo", "bar" ) );
-    private static final FacadeMethod<Index<Node>> QUERY = new FacadeMethod<>( "IndexHits<T> query( Object queryOrQueryObject )", self -> self.query( "foo" ) );
-    private static final FacadeMethod<Index<Node>> ADD = new FacadeMethod<>( "void add( T entity, String key, Object value )", self -> self.add( null, "foo", 42 ) );
-    private static final FacadeMethod<Index<Node>> REMOVE_BY_KEY_AND_VALUE = new FacadeMethod<>( "void remove( T entity, String key, Object value )", self -> self.remove( null, "foo", 42 ) );
-    private static final FacadeMethod<Index<Node>> REMOVE_BY_KEY = new FacadeMethod<>( "void remove( T entity, String key )", self -> self.remove( null, "foo" ) );
-    private static final FacadeMethod<Index<Node>> REMOVE = new FacadeMethod<>( "void remove( T entity )", self -> self.remove( null ) );
-    private static final FacadeMethod<Index<Node>> DELETE = new FacadeMethod<>( "void delete()", Index::delete );
-    private static final FacadeMethod<Index<Node>> PUT_IF_ABSENT = new FacadeMethod<>( "T putIfAbsent( T entity, String key, Object value )", self -> self.putIfAbsent( null, "foo", 42 ) );
+    GET( new FacadeMethod<>( "IndexHits<T> get( String key, Object value )", self -> self.get( "foo", "bar" ) ) ),
+    QUERY_BY_KEY( new FacadeMethod<>( "IndexHits<T> query( String key, Object queryOrQueryObject )", self -> self.query( "foo", "bar" ) ) ),
+    QUERY( new FacadeMethod<>( "IndexHits<T> query( Object queryOrQueryObject )", self -> self.query( "foo" ) ) ),
+    ADD( new FacadeMethod<>( "void add( T entity, String key, Object value )", self -> self.add( null, "foo", 42 ) ) ),
+    REMOVE_BY_KEY_AND_VALUE( new FacadeMethod<>( "void remove( T entity, String key, Object value )", self -> self.remove( null, "foo", 42 ) ) ),
+    REMOVE_BY_KEY( new FacadeMethod<>( "void remove( T entity, String key )", self -> self.remove( null, "foo" ) ) ),
+    REMOVE( new FacadeMethod<>( "void remove( T entity )", self -> self.remove( null ) ) ),
+    DELETE( new FacadeMethod<>( "void delete()", Index::delete ) ),
+    PUT_IF_ABSENT( new FacadeMethod<>( "T putIfAbsent( T entity, String key, Object value )", self -> self.putIfAbsent( null, "foo", 42 ) ) );
+
+    private final FacadeMethod<Index<Node>> facadeMethod;
+
+    NodeIndexFacadeMethods( FacadeMethod<Index<Node>> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<Index<Node>>> ALL_NODE_INDEX_FACADE_METHODS = unmodifiableCollection(
-            asList(
-                    GET,
-                    QUERY_BY_KEY,
-                    QUERY,
-                    ADD,
-                    REMOVE_BY_KEY_AND_VALUE,
-                    REMOVE_BY_KEY,
-                    REMOVE,
-                    DELETE,
-                    PUT_IF_ABSENT
-            ) );
+    @Override
+    public void accept( Index<Node> nodeIndex )
+    {
+        facadeMethod.accept( nodeIndex );
+    }
 
-    private NodeIndexFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/RelationshipIndexFacadeMethods.java b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/RelationshipIndexFacadeMethods.java
index 9fe7a6e3b953a..471d328987ed7 100644
--- a/community/community-it/index-it/src/test/java/org/neo4j/graphdb/RelationshipIndexFacadeMethods.java
+++ b/community/community-it/index-it/src/test/java/org/neo4j/graphdb/RelationshipIndexFacadeMethods.java
@@ -19,44 +19,45 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.index.RelationshipIndex;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.index.RelationshipIndex;
 
-public class RelationshipIndexFacadeMethods
+public enum RelationshipIndexFacadeMethods implements Consumer<RelationshipIndex>
 {
-    private static final FacadeMethod<RelationshipIndex> GET_WITH_FILTER = new FacadeMethod<>( "IndexHits<Relationship> get( String key, Object valueOrNull, Node startNodeOrNull, Node endNodeOrNull )", ri -> ri.get( "foo", 42, null, null ) );
-    private static final FacadeMethod<RelationshipIndex> QUERY_BY_KEY_WITH_FILTER = new FacadeMethod<>( "IndexHits<Relationship> query( String key, Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull )", ri -> ri.query( "foo", 42, null, null ) );
-    private static final FacadeMethod<RelationshipIndex> QUERY_WITH_FILTER = new FacadeMethod<>( "IndexHits<Relationship> query( Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull )", ri -> ri.query( 42, null, null ) );
-    private static final FacadeMethod<RelationshipIndex> GET = new FacadeMethod<>( "IndexHits<T> get( String key, Object value )", ri -> ri.get( "foo", "bar" ) );
-    private static final FacadeMethod<RelationshipIndex> QUERY_BY_KEY = new FacadeMethod<>( "IndexHits<T> query( String key, Object queryOrQueryObject )", ri -> ri.query( "foo", "bar" ) );
-    private static final FacadeMethod<RelationshipIndex> QUERY = new FacadeMethod<>( "IndexHits<T> query( Object queryOrQueryObject )", ri -> ri.query( "foo" ) );
-    private static final FacadeMethod<RelationshipIndex> ADD = new FacadeMethod<>( "void add( T entity, String key, Object value )", ri -> ri.add( null, "foo", 42 ) );
-    private static final FacadeMethod<RelationshipIndex> REMOVE_BY_KEY_AND_VALUE = new FacadeMethod<>( "void remove( T entity, String key, Object value )", ri -> ri.remove( null, "foo", 42 ) );
-    private static final FacadeMethod<RelationshipIndex> REMOVE_BY_KEY = new FacadeMethod<>( "void remove( T entity, String key )", ri -> ri.remove( null, "foo" ) );
-    private static final FacadeMethod<RelationshipIndex> REMOVE = new FacadeMethod<>( "void remove( T entity )", ri -> ri.remove( null ) );
-    private static final FacadeMethod<RelationshipIndex> DELETE = new FacadeMethod<>( "void delete()", RelationshipIndex::delete );
-    private static final FacadeMethod<RelationshipIndex> PUT_IF_ABSENT = new FacadeMethod<>( "T putIfAbsent( T entity, String key, Object value )", ri -> ri.putIfAbsent( null, "foo", 42 ) );
+    GET_WITH_FILTER( new FacadeMethod<>( "IndexHits<Relationship> get( String key, Object valueOrNull, Node startNodeOrNull, Node endNodeOrNull )",
+            ri -> ri.get( "foo", 42, null, null ) ) ),
+    QUERY_BY_KEY_WITH_FILTER(
+            new FacadeMethod<>( "IndexHits<Relationship> query( String key, Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull )",
+                    ri -> ri.query( "foo", 42, null, null ) ) ),
+    QUERY_WITH_FILTER( new FacadeMethod<>( "IndexHits<Relationship> query( Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull )",
+            ri -> ri.query( 42, null, null ) ) ),
+    GET( new FacadeMethod<>( "IndexHits<T> get( String key, Object value )", ri -> ri.get( "foo", "bar" ) ) ),
+    QUERY_BY_KEY( new FacadeMethod<>( "IndexHits<T> query( String key, Object queryOrQueryObject )", ri -> ri.query( "foo", "bar" ) ) ),
+    QUERY( new FacadeMethod<>( "IndexHits<T> query( Object queryOrQueryObject )", ri -> ri.query( "foo" ) ) ),
+    ADD( new FacadeMethod<>( "void add( T entity, String key, Object value )", ri -> ri.add( null, "foo", 42 ) ) ),
+    REMOVE_BY_KEY_AND_VALUE( new FacadeMethod<>( "void remove( T entity, String key, Object value )", ri -> ri.remove( null, "foo", 42 ) ) ),
+    REMOVE_BY_KEY( new FacadeMethod<>( "void remove( T entity, String key )", ri -> ri.remove( null, "foo" ) ) ),
+    REMOVE( new FacadeMethod<>( "void remove( T entity )", ri -> ri.remove( null ) ) ),
+    DELETE( new FacadeMethod<>( "void delete()", RelationshipIndex::delete ) ),
+    PUT_IF_ABSENT( new FacadeMethod<>( "T putIfAbsent( T entity, String key, Object value )", ri -> ri.putIfAbsent( null, "foo", 42 ) ) );
+
+    private final FacadeMethod<RelationshipIndex> facadeMethod;
+
+    RelationshipIndexFacadeMethods( FacadeMethod<RelationshipIndex> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<RelationshipIndex>> ALL_RELATIONSHIP_INDEX_FACADE_METHODS =
-            unmodifiableCollection(
-                    asList(
-                            GET_WITH_FILTER,
-                            QUERY_BY_KEY_WITH_FILTER,
-                            QUERY_WITH_FILTER,
-                            GET,
-                            QUERY_BY_KEY,
-                            QUERY,
-                            ADD,
-                            REMOVE_BY_KEY_AND_VALUE,
-                            REMOVE_BY_KEY,
-                            REMOVE,
-                            DELETE,
-                            PUT_IF_ABSENT
-                    ) );
+    @Override
+    public void accept( RelationshipIndex relationshipIndex )
+    {
+        facadeMethod.accept( relationshipIndex );
+    }
 
-    private RelationshipIndexFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/AbstractMandatoryTransactionsTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/AbstractMandatoryTransactionsTest.java
index bf95317753102..d0e689b33551b 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/AbstractMandatoryTransactionsTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/AbstractMandatoryTransactionsTest.java
@@ -60,13 +60,13 @@ public void obtainEntityInTerminatedTransaction( Consumer<T> f )
 
     protected abstract T obtainEntityInTransaction( GraphDatabaseService graphDatabaseService );
 
-    public static <T> void assertFacadeMethodsThrowNotInTransaction( T entity, Iterable<FacadeMethod<T>> methods )
+    public static <T> void assertFacadeMethodsThrowNotInTransaction( T entity, Consumer<T>[] methods )
     {
-        for ( FacadeMethod<T> method : methods )
+        for ( Consumer<T> method : methods )
         {
             try
             {
-                method.call( entity );
+                method.accept( entity );
 
                 fail( "Transactions are mandatory, also for reads: " + method );
             }
@@ -77,15 +77,15 @@ public static <T> void assertFacadeMethodsThrowNotInTransaction( T entity, Itera
         }
     }
 
-    public void assertFacadeMethodsThrowAfterTerminate( Iterable<FacadeMethod<T>> methods )
+    public void assertFacadeMethodsThrowAfterTerminate( Consumer<T>[] methods )
     {
-        for ( final FacadeMethod<T> method : methods )
+        for ( final Consumer<T> method : methods )
         {
             obtainEntityInTerminatedTransaction( entity ->
             {
                 try
                 {
-                    method.call( entity );
+                    method.accept( entity );
 
                     fail( "Transaction was terminated, yet not exception thrown in: " + method );
                 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintCreatorFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintCreatorFacadeMethods.java
index d9c18d26f7c7c..6fdfc121874f3 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintCreatorFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintCreatorFacadeMethods.java
@@ -19,23 +19,31 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.schema.ConstraintCreator;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.schema.ConstraintCreator;
 
-public class ConstraintCreatorFacadeMethods
+public enum ConstraintCreatorFacadeMethods implements Consumer<ConstraintCreator>
 {
-    private static final FacadeMethod<ConstraintCreator> UNIQUE = new FacadeMethod<>( "ConstraintCreator assertPropertyIsUnique()", self -> self.assertPropertyIsUnique( "property" ) );
-    private static final FacadeMethod<ConstraintCreator> CREATE = new FacadeMethod<>( "ConstraintDefinition create()", ConstraintCreator::create );
+    UNIQUE( new FacadeMethod<>( "ConstraintCreator assertPropertyIsUnique()", self -> self.assertPropertyIsUnique( "property" ) ) ),
+    CREATE( new FacadeMethod<>( "ConstraintDefinition create()", ConstraintCreator::create ) );
+
+    private final FacadeMethod<ConstraintCreator> facadeMethod;
+
+    ConstraintCreatorFacadeMethods( FacadeMethod<ConstraintCreator> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<ConstraintCreator>> ALL_CONSTRAINT_CREATOR_FACADE_METHODS =
-            unmodifiableCollection( asList(
-                    UNIQUE,
-                    CREATE
-            ) );
+    @Override
+    public void accept( ConstraintCreator constraintCreator )
+    {
+        facadeMethod.accept( constraintCreator );
+    }
 
-    private ConstraintCreatorFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintDefinitionFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintDefinitionFacadeMethods.java
index 4fcdad3246801..4dc849d78509c 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintDefinitionFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/ConstraintDefinitionFacadeMethods.java
@@ -19,30 +19,35 @@
  */
 package org.neo4j.graphdb;
 
+import java.util.function.Consumer;
+
 import org.neo4j.graphdb.schema.ConstraintDefinition;
 import org.neo4j.graphdb.schema.ConstraintType;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
-
-public class ConstraintDefinitionFacadeMethods
+public enum ConstraintDefinitionFacadeMethods implements Consumer<ConstraintDefinition>
 {
-    private static final FacadeMethod<ConstraintDefinition> GET_LABEL = new FacadeMethod<>( "Label getLabel()", ConstraintDefinition::getLabel );
-    private static final FacadeMethod<ConstraintDefinition> GET_RELATIONSHIP_TYPE = new FacadeMethod<>( "RelationshipType getRelationshipType()", ConstraintDefinition::getRelationshipType );
-    private static final FacadeMethod<ConstraintDefinition> DROP = new FacadeMethod<>( "void drop()", ConstraintDefinition::drop );
-    private static final FacadeMethod<ConstraintDefinition> IS_CONSTRAINT_TYPE = new FacadeMethod<>( "boolean isConstraintType( ConstraintType type )", self -> self.isConstraintType( ConstraintType.UNIQUENESS ) );
-    private static final FacadeMethod<ConstraintDefinition> GET_PROPERTY_KEYS = new FacadeMethod<>( "Iterable<String> getPropertyKeys()", ConstraintDefinition::getPropertyKeys );
+    GET_LABEL( new FacadeMethod<>( "Label getLabel()", ConstraintDefinition::getLabel ) ),
+    GET_RELATIONSHIP_TYPE( new FacadeMethod<>( "RelationshipType getRelationshipType()", ConstraintDefinition::getRelationshipType ) ),
+    DROP( new FacadeMethod<>( "void drop()", ConstraintDefinition::drop ) ),
+    IS_CONSTRAINT_TYPE( new FacadeMethod<>( "boolean isConstraintType( ConstraintType type )", self -> self.isConstraintType( ConstraintType.UNIQUENESS ) ) ),
+    GET_PROPERTY_KEYS( new FacadeMethod<>( "Iterable<String> getPropertyKeys()", ConstraintDefinition::getPropertyKeys ) );
+
+    private final FacadeMethod<ConstraintDefinition> facadeMethod;
+
+    ConstraintDefinitionFacadeMethods( FacadeMethod<ConstraintDefinition> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<ConstraintDefinition>> ALL_CONSTRAINT_DEFINITION_FACADE_METHODS =
-            unmodifiableCollection( asList(
-                    GET_LABEL,
-                    GET_RELATIONSHIP_TYPE,
-                    GET_PROPERTY_KEYS,
-                    DROP,
-                    IS_CONSTRAINT_TYPE
-            ) );
+    @Override
+    public void accept( ConstraintDefinition constraintDefinition )
+    {
+        facadeMethod.accept( constraintDefinition );
+    }
 
-    private ConstraintDefinitionFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/GraphDatabaseServiceFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/GraphDatabaseServiceFacadeMethods.java
index 6814dc3af1a00..4c84a77bcd6ca 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/GraphDatabaseServiceFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/GraphDatabaseServiceFacadeMethods.java
@@ -19,53 +19,50 @@
  */
 package org.neo4j.graphdb;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import java.util.function.Consumer;
+
 import static org.neo4j.graphdb.FacadeMethod.consume;
 import static org.neo4j.graphdb.Label.label;
-import static org.neo4j.helpers.collection.Iterators.loop;
 
 /**
  * Test convenience: all the methods on GraphDatabaseService, callable using generic interface
  */
-public class GraphDatabaseServiceFacadeMethods
+public enum GraphDatabaseServiceFacadeMethods implements Consumer<GraphDatabaseService>
 {
-    static final FacadeMethod<GraphDatabaseService> CREATE_NODE = new FacadeMethod<>( "Node createNode()", GraphDatabaseService::createNode );
-    static final FacadeMethod<GraphDatabaseService> CREATE_NODE_WITH_LABELS = new FacadeMethod<>( "Node createNode( Label... labels )", gds -> gds.createNode( label( "FOO" ) ) );
-    static final FacadeMethod<GraphDatabaseService> GET_NODE_BY_ID = new FacadeMethod<>( "Node getNodeById( long id )", gds -> gds.getNodeById( 42 ) );
-    static final FacadeMethod<GraphDatabaseService> GET_RELATIONSHIP_BY_ID = new FacadeMethod<>( "Relationship getRelationshipById( long id )", gds -> gds.getRelationshipById( 42 ) );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_NODES = new FacadeMethod<>( "Iterable<Node> getAllNodes()", gds -> consume( gds.getAllNodes() ) );
-    static final FacadeMethod<GraphDatabaseService> FIND_NODES_BY_LABEL_AND_PROPERTY_DEPRECATED = new FacadeMethod<>(
-                "ResourceIterator<Node> findNodeByLabelAndProperty( Label label, String key, Object value )", gds -> consume( gds.findNodes( label( "bar" ), "baz", 23 ) ) );
-    static final FacadeMethod<GraphDatabaseService> FIND_NODES_BY_LABEL = new FacadeMethod<>(
-                    "ResourceIterator<Node> findNodes( Label label )", gds -> consume( gds.findNodes( label( "bar" ) ) ) );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_LABELS = new FacadeMethod<>( "Iterable<Label> getAllLabels()", GraphDatabaseService::getAllLabels );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_LABELS_IN_USE = new FacadeMethod<>( "Iterable<Label> getAllLabelsInUse()", GraphDatabaseService::getAllLabelsInUse );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_RELATIONSHIP_TYPES = new FacadeMethod<>( "Iterable<RelationshipType> getAllRelationshipTypes()", GraphDatabaseService::getAllRelationshipTypes );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_RELATIONSHIP_TYPES_IN_USE = new FacadeMethod<>( "Iterable<RelationshipType> getAllRelationshipTypesInUse()", GraphDatabaseService::getAllRelationshipTypesInUse );
-    static final FacadeMethod<GraphDatabaseService> GET_ALL_PROPERTY_KEYS = new FacadeMethod<>( "Iterable<String> getAllPropertyKeys()", GraphDatabaseService::getAllPropertyKeys );
-    static final FacadeMethod<GraphDatabaseService> SCHEMA = new FacadeMethod<>( "Schema schema()", GraphDatabaseService::schema );
-    static final FacadeMethod<GraphDatabaseService> INDEX = new FacadeMethod<>( "IndexManager index()", GraphDatabaseService::index );
+    CREATE_NODE( new FacadeMethod<>( "Node createNode()", GraphDatabaseService::createNode ) ),
+    CREATE_NODE_WITH_LABELS( new FacadeMethod<>( "Node createNode( Label... labels )", gds -> gds.createNode( label( "FOO" ) ) ) ),
+    GET_NODE_BY_ID( new FacadeMethod<>( "Node getNodeById( long id )", gds -> gds.getNodeById( 42 ) ) ),
+    GET_RELATIONSHIP_BY_ID( new FacadeMethod<>( "Relationship getRelationshipById( long id )", gds -> gds.getRelationshipById( 42 ) ) ),
+    GET_ALL_NODES( new FacadeMethod<>( "Iterable<Node> getAllNodes()", gds -> consume( gds.getAllNodes() ) ) ),
+    FIND_NODES_BY_LABEL_AND_PROPERTY_DEPRECATED(
+            new FacadeMethod<>( "ResourceIterator<Node> findNodeByLabelAndProperty( Label label, String key, Object value )",
+                    gds -> consume( gds.findNodes( label( "bar" ), "baz", 23 ) ) ) ),
+    FIND_NODES_BY_LABEL( new FacadeMethod<>( "ResourceIterator<Node> findNodes( Label label )", gds -> consume( gds.findNodes( label( "bar" ) ) ) ) ),
+    GET_ALL_LABELS( new FacadeMethod<>( "Iterable<Label> getAllLabels()", GraphDatabaseService::getAllLabels ) ),
+    GET_ALL_LABELS_IN_USE( new FacadeMethod<>( "Iterable<Label> getAllLabelsInUse()", GraphDatabaseService::getAllLabelsInUse ) ),
+    GET_ALL_RELATIONSHIP_TYPES( new FacadeMethod<>( "Iterable<RelationshipType> getAllRelationshipTypes()", GraphDatabaseService::getAllRelationshipTypes ) ),
+    GET_ALL_RELATIONSHIP_TYPES_IN_USE(
+            new FacadeMethod<>( "Iterable<RelationshipType> getAllRelationshipTypesInUse()", GraphDatabaseService::getAllRelationshipTypesInUse ) ),
+    GET_ALL_PROPERTY_KEYS( new FacadeMethod<>( "Iterable<String> getAllPropertyKeys()", GraphDatabaseService::getAllPropertyKeys ) ),
+    SCHEMA( new FacadeMethod<>( "Schema schema()", GraphDatabaseService::schema ) ),
+    INDEX( new FacadeMethod<>( "IndexManager index()", GraphDatabaseService::index ) );
+
+    private final FacadeMethod<GraphDatabaseService> facadeMethod;
 
-    static final Iterable<FacadeMethod<GraphDatabaseService>> ALL_NON_TRANSACTIONAL_GRAPH_DATABASE_METHODS =
-        unmodifiableCollection( asList(
-                CREATE_NODE,
-                CREATE_NODE_WITH_LABELS,
-                GET_NODE_BY_ID,
-                GET_RELATIONSHIP_BY_ID,
-                GET_ALL_NODES,
-                FIND_NODES_BY_LABEL_AND_PROPERTY_DEPRECATED,
-                FIND_NODES_BY_LABEL,
-                GET_ALL_LABELS,
-                GET_ALL_LABELS_IN_USE,
-                GET_ALL_RELATIONSHIP_TYPES,
-                GET_ALL_RELATIONSHIP_TYPES_IN_USE,
-                GET_ALL_PROPERTY_KEYS,
-                SCHEMA,
-                INDEX
-        ) );
+    GraphDatabaseServiceFacadeMethods( FacadeMethod<GraphDatabaseService> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
+
+    @Override
+    public void accept( GraphDatabaseService graphDatabaseService )
+    {
+        facadeMethod.accept( graphDatabaseService );
+    }
 
-    private GraphDatabaseServiceFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexCreatorFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexCreatorFacadeMethods.java
index d42e04cba2a76..c5e9eeba7fb5c 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexCreatorFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexCreatorFacadeMethods.java
@@ -19,23 +19,31 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.schema.IndexCreator;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.schema.IndexCreator;
 
-public class IndexCreatorFacadeMethods
+public enum IndexCreatorFacadeMethods implements Consumer<IndexCreator>
 {
-    private static final FacadeMethod<IndexCreator> ON = new FacadeMethod<>( "IndexCreator on( String propertyKey )", self -> self.on( "property" ) );
-    private static final FacadeMethod<IndexCreator> CREATE = new FacadeMethod<>( "IndexDefinition create()", IndexCreator::create );
+    ON( new FacadeMethod<>( "IndexCreator on( String propertyKey )", self -> self.on( "property" ) ) ),
+    CREATE( new FacadeMethod<>( "IndexDefinition create()", IndexCreator::create ) );
+
+    private final FacadeMethod<IndexCreator> facadeMethod;
+
+    IndexCreatorFacadeMethods( FacadeMethod<IndexCreator> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<IndexCreator>> ALL_INDEX_CREATOR_FACADE_METHODS =
-        unmodifiableCollection( asList(
-                ON,
-                CREATE
-        ) );
+    @Override
+    public void accept( IndexCreator indexCreator )
+    {
+        facadeMethod.accept( indexCreator );
+    }
 
-    private IndexCreatorFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexDefinitionFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexDefinitionFacadeMethods.java
index 71c27c52efb5f..0da968a4d52bf 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexDefinitionFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexDefinitionFacadeMethods.java
@@ -19,24 +19,33 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.schema.IndexDefinition;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.schema.IndexDefinition;
 
-public class IndexDefinitionFacadeMethods
+public enum IndexDefinitionFacadeMethods implements Consumer<IndexDefinition>
 {
-    private static final FacadeMethod<IndexDefinition> GET_LABEL = new FacadeMethod<>( "Label getLabel()", IndexDefinition::getLabel );
-    private static final FacadeMethod<IndexDefinition> GET_PROPERTY_KEYS =
-            new FacadeMethod<>( "Iterable<String> getPropertyKeys()", IndexDefinition::getPropertyKeys );
-    private static final FacadeMethod<IndexDefinition> DROP = new FacadeMethod<>( "void drop()", IndexDefinition::drop );
-    private static final FacadeMethod<IndexDefinition> IS_CONSTRAINT_INDEX =
-            new FacadeMethod<>( "boolean isConstraintIndex()", IndexDefinition::isConstraintIndex );
+    GET_LABEL( new FacadeMethod<>( "Label getLabel()", IndexDefinition::getLabel ) ),
+    GET_PROPERTY_KEYS( new FacadeMethod<>( "Iterable<String> getPropertyKeys()", IndexDefinition::getPropertyKeys ) ),
+    DROP( new FacadeMethod<>( "void drop()", IndexDefinition::drop ) ),
+    IS_CONSTRAINT_INDEX( new FacadeMethod<>( "boolean isConstraintIndex()", IndexDefinition::isConstraintIndex ) );
+
+    private final FacadeMethod<IndexDefinition> facadeMethod;
+
+    IndexDefinitionFacadeMethods( FacadeMethod<IndexDefinition> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<IndexDefinition>> ALL_INDEX_DEFINITION_FACADE_METHODS =
-            unmodifiableCollection( asList( GET_LABEL, GET_PROPERTY_KEYS, DROP, IS_CONSTRAINT_INDEX ) );
+    @Override
+    public void accept( IndexDefinition indexDefinition )
+    {
+        facadeMethod.accept( indexDefinition );
+    }
 
-    private IndexDefinitionFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexManagerFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexManagerFacadeMethods.java
index 24f84d8f38d4d..df07a2740a2f2 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexManagerFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/IndexManagerFacadeMethods.java
@@ -19,35 +19,39 @@
  */
 package org.neo4j.graphdb;
 
-import org.neo4j.graphdb.index.IndexManager;
+import java.util.function.Consumer;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import org.neo4j.graphdb.index.IndexManager;
 
-public class IndexManagerFacadeMethods
+public enum IndexManagerFacadeMethods implements Consumer<IndexManager>
 {
-    private static final FacadeMethod<IndexManager> EXISTS_FOR_NODES = new FacadeMethod<>( "boolean existsForNodes( String indexName )", self -> self.existsForNodes( "foo" ) );
-    private static final FacadeMethod<IndexManager> FOR_NODES = new FacadeMethod<>( "Index<Node> forNodes( String indexName )", self -> self.forNodes( "foo" ) );
-    private static final FacadeMethod<IndexManager> FOR_NODES_WITH_CONFIG = new FacadeMethod<>( "Index<Node> forNodes( String indexName, Map<String, String> customConfiguration )", self -> self.forNodes( "foo", null ) );
-    private static final FacadeMethod<IndexManager> NODE_INDEX_NAMES = new FacadeMethod<>( "String[] nodeIndexNames()", IndexManager::nodeIndexNames );
-    private static final FacadeMethod<IndexManager> EXISTS_FOR_RELATIONSHIPS = new FacadeMethod<>( "boolean existsForRelationships( String indexName )", self -> self.existsForRelationships( "foo" ) );
-    private static final FacadeMethod<IndexManager> FOR_RELATIONSHIPS = new FacadeMethod<>( "RelationshipIndex forRelationships( String indexName )", self -> self.forRelationships( "foo" ) );
-    private static final FacadeMethod<IndexManager> FOR_RELATIONSHIPS_WITH_CONFIG = new FacadeMethod<>( "RelationshipIndex forRelationships( String indexName, Map<String, String> customConfiguration )", self -> self.forRelationships( "foo", null ) );
-    private static final FacadeMethod<IndexManager> RELATIONSHIP_INDEX_NAMES = new FacadeMethod<>( "String[] relationshipIndexNames()", IndexManager::relationshipIndexNames );
+    EXISTS_FOR_NODES( new FacadeMethod<>( "boolean existsForNodes( String indexName )", self -> self.existsForNodes( "foo" ) ) ),
+    FOR_NODES( new FacadeMethod<>( "Index<Node> forNodes( String indexName )", self -> self.forNodes( "foo" ) ) ),
+    FOR_NODES_WITH_CONFIG(
+            new FacadeMethod<>( "Index<Node> forNodes( String indexName, Map<String, String> customConfiguration )", self -> self.forNodes( "foo", null ) ) ),
+    NODE_INDEX_NAMES( new FacadeMethod<>( "String[] nodeIndexNames()", IndexManager::nodeIndexNames ) ),
+    EXISTS_FOR_RELATIONSHIPS( new FacadeMethod<>( "boolean existsForRelationships( String indexName )", self -> self.existsForRelationships( "foo" ) ) ),
+    FOR_RELATIONSHIPS( new FacadeMethod<>( "RelationshipIndex forRelationships( String indexName )", self -> self.forRelationships( "foo" ) ) ),
+    FOR_RELATIONSHIPS_WITH_CONFIG( new FacadeMethod<>( "RelationshipIndex forRelationships( String indexName, Map<String, String> customConfiguration )",
+            self -> self.forRelationships( "foo", null ) ) ),
+    RELATIONSHIP_INDEX_NAMES( new FacadeMethod<>( "String[] relationshipIndexNames()", IndexManager::relationshipIndexNames ) );
+
+    private final FacadeMethod<IndexManager> facadeMethod;
+
+    IndexManagerFacadeMethods( FacadeMethod<IndexManager> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<IndexManager>> ALL_INDEX_MANAGER_FACADE_METHODS =
-            unmodifiableCollection( asList(
-                    EXISTS_FOR_NODES,
-                    FOR_NODES,
-                    FOR_NODES_WITH_CONFIG,
-                    NODE_INDEX_NAMES,
-                    EXISTS_FOR_RELATIONSHIPS,
-                    FOR_RELATIONSHIPS,
-                    FOR_RELATIONSHIPS_WITH_CONFIG,
-                    RELATIONSHIP_INDEX_NAMES
-            ) );
+    @Override
+    public void accept( IndexManager indexManager )
+    {
+        facadeMethod.accept( indexManager );
+    }
 
-    private IndexManagerFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintCreatorTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintCreatorTest.java
index f19a1e4b29d48..fb74db9c27afc 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintCreatorTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintCreatorTest.java
@@ -23,21 +23,19 @@
 
 import org.neo4j.graphdb.schema.ConstraintCreator;
 
-import static org.neo4j.graphdb.ConstraintCreatorFacadeMethods.ALL_CONSTRAINT_CREATOR_FACADE_METHODS;
-
 public class MandatoryTransactionsForConstraintCreatorTest
     extends AbstractMandatoryTransactionsTest<ConstraintCreator>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsConstraintCreators()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_CONSTRAINT_CREATOR_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ConstraintCreatorFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsConstraintCreators()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_CONSTRAINT_CREATOR_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( ConstraintCreatorFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintDefinitionTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintDefinitionTest.java
index 6f1ef67ca030b..e3dce0d5c3fdc 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintDefinitionTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForConstraintDefinitionTest.java
@@ -23,22 +23,19 @@
 
 import org.neo4j.graphdb.schema.ConstraintDefinition;
 
-import static org.neo4j.graphdb.ConstraintDefinitionFacadeMethods.ALL_CONSTRAINT_DEFINITION_FACADE_METHODS;
-
-
 public class MandatoryTransactionsForConstraintDefinitionTest
     extends AbstractMandatoryTransactionsTest<ConstraintDefinition>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnIndexDefinitions()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_CONSTRAINT_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ConstraintDefinitionFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnIndexDefinitions()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_CONSTRAINT_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( ConstraintDefinitionFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForGraphDatabaseServiceTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForGraphDatabaseServiceTest.java
index 7a7a8b59c5d10..8687b9c87d554 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForGraphDatabaseServiceTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForGraphDatabaseServiceTest.java
@@ -21,21 +21,19 @@
 
 import org.junit.Test;
 
-import static org.neo4j.graphdb.GraphDatabaseServiceFacadeMethods.ALL_NON_TRANSACTIONAL_GRAPH_DATABASE_METHODS;
-
 public class MandatoryTransactionsForGraphDatabaseServiceTest extends
         AbstractMandatoryTransactionsTest<GraphDatabaseService>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnGraphDatabaseService()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_NON_TRANSACTIONAL_GRAPH_DATABASE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), GraphDatabaseServiceFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnGraphDatabaseService()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_NON_TRANSACTIONAL_GRAPH_DATABASE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( GraphDatabaseServiceFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexCreatorTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexCreatorTest.java
index 1231dd6ee3f60..ef030bcb1c3ab 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexCreatorTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexCreatorTest.java
@@ -23,21 +23,19 @@
 
 import org.neo4j.graphdb.schema.IndexCreator;
 
-import static org.neo4j.graphdb.IndexCreatorFacadeMethods.ALL_INDEX_CREATOR_FACADE_METHODS;
-
 public class MandatoryTransactionsForIndexCreatorTest
     extends AbstractMandatoryTransactionsTest<IndexCreator>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnIndexCreators()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_INDEX_CREATOR_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), IndexCreatorFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnIndexCreators()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_INDEX_CREATOR_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( IndexCreatorFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexDefinitionTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexDefinitionTest.java
index 4f5219a5ffebe..895085cd87fab 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexDefinitionTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexDefinitionTest.java
@@ -23,21 +23,18 @@
 
 import org.neo4j.graphdb.schema.IndexDefinition;
 
-import static org.neo4j.graphdb.IndexDefinitionFacadeMethods.ALL_INDEX_DEFINITION_FACADE_METHODS;
-
-public class MandatoryTransactionsForIndexDefinitionTest
-    extends AbstractMandatoryTransactionsTest<IndexDefinition>
+public class MandatoryTransactionsForIndexDefinitionTest extends AbstractMandatoryTransactionsTest<IndexDefinition>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnIndexDefinitions()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_INDEX_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), IndexDefinitionFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnIndexDefinitions()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_INDEX_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( IndexDefinitionFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexManagerFacadeTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexManagerFacadeTest.java
index f225a1eb5d537..7e55f1b28889c 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexManagerFacadeTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForIndexManagerFacadeTest.java
@@ -23,20 +23,18 @@
 
 import org.neo4j.graphdb.index.IndexManager;
 
-import static org.neo4j.graphdb.IndexManagerFacadeMethods.ALL_INDEX_MANAGER_FACADE_METHODS;
-
 public class MandatoryTransactionsForIndexManagerFacadeTest extends AbstractMandatoryTransactionsTest<IndexManager>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnIndexManagerFacade()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_INDEX_MANAGER_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), IndexManagerFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnIndexManagerFacade()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_INDEX_MANAGER_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( IndexManagerFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeTest.java
index 0571be4900732..624e2aba958e1 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForNodeTest.java
@@ -21,20 +21,18 @@
 
 import org.junit.Test;
 
-import static org.neo4j.graphdb.NodeFacadeMethods.ALL_NODE_FACADE_METHODS;
-
 public class MandatoryTransactionsForNodeTest extends AbstractMandatoryTransactionsTest<Node>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnNode()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_NODE_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), NodeFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnNode()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_NODE_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( NodeFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipTest.java
index c451940fb4a4a..9d47d9f8dc133 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForRelationshipTest.java
@@ -21,7 +21,6 @@
 
 import org.junit.Test;
 
-import static org.neo4j.graphdb.RelationshipFacadeMethods.ALL_RELATIONSHIP_FACADE_METHODS;
 import static org.neo4j.graphdb.RelationshipType.withName;
 
 public class MandatoryTransactionsForRelationshipTest extends AbstractMandatoryTransactionsTest<Relationship>
@@ -29,13 +28,13 @@ public class MandatoryTransactionsForRelationshipTest extends AbstractMandatoryT
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnRelationshipFacade()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_RELATIONSHIP_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), RelationshipFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnRelationshipFacade()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_RELATIONSHIP_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( RelationshipFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForSchemaTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForSchemaTest.java
index 0679f5d19972b..1d78fbaa8692f 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForSchemaTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForSchemaTest.java
@@ -23,20 +23,18 @@
 
 import org.neo4j.graphdb.schema.Schema;
 
-import static org.neo4j.graphdb.SchemaFacadeMethods.ALL_SCHEMA_FACADE_METHODS;
-
 public class MandatoryTransactionsForSchemaTest extends AbstractMandatoryTransactionsTest<Schema>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnSchema()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_SCHEMA_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), SchemaFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnSchema()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_SCHEMA_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( SchemaFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForUniquenessConstraintDefinitionTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForUniquenessConstraintDefinitionTest.java
index 0e5b8fcce5bd5..00a499a17b8b8 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForUniquenessConstraintDefinitionTest.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/MandatoryTransactionsForUniquenessConstraintDefinitionTest.java
@@ -23,21 +23,19 @@
 
 import org.neo4j.graphdb.schema.ConstraintDefinition;
 
-import static org.neo4j.graphdb.ConstraintDefinitionFacadeMethods.ALL_CONSTRAINT_DEFINITION_FACADE_METHODS;
-
 public class MandatoryTransactionsForUniquenessConstraintDefinitionTest
     extends AbstractMandatoryTransactionsTest<ConstraintDefinition>
 {
     @Test
     public void shouldRequireTransactionsWhenCallingMethodsOnUniquenessConstraintDefinitions()
     {
-        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ALL_CONSTRAINT_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowNotInTransaction( obtainEntity(), ConstraintDefinitionFacadeMethods.values() );
     }
 
     @Test
     public void shouldTerminateWhenCallingMethodsOnUniquenessConstraintDefinitions()
     {
-        assertFacadeMethodsThrowAfterTerminate( ALL_CONSTRAINT_DEFINITION_FACADE_METHODS );
+        assertFacadeMethodsThrowAfterTerminate( ConstraintDefinitionFacadeMethods.values() );
     }
 
     @Override
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/NodeFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/NodeFacadeMethods.java
index 8ad0cd82f943a..f21323f8c09cf 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/NodeFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/NodeFacadeMethods.java
@@ -19,69 +19,64 @@
  */
 package org.neo4j.graphdb;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import java.util.function.Consumer;
+
 import static org.neo4j.graphdb.Direction.BOTH;
+import static org.neo4j.graphdb.FacadeMethod.BAR;
+import static org.neo4j.graphdb.FacadeMethod.FOO;
+import static org.neo4j.graphdb.FacadeMethod.QUUX;
 import static org.neo4j.graphdb.FacadeMethod.consume;
-import static org.neo4j.graphdb.Label.label;
-import static org.neo4j.graphdb.RelationshipType.withName;
 
-@SuppressWarnings( "UnusedDeclaration" )
-public class NodeFacadeMethods
+public enum NodeFacadeMethods implements Consumer<Node>
 {
-    private static final RelationshipType FOO = withName( "foo" );
-    private static final RelationshipType BAR = withName( "bar" );
-    private static final Label QUUX = label( "quux" );
+    HAS_PROPERTY( new FacadeMethod<>( "boolean hasProperty( String key )", n -> n.hasProperty( "foo" ) ) ),
+    GET_PROPERTY( new FacadeMethod<>( "Object getProperty( String key )", n -> n.getProperty( "foo" ) ) ),
+    GET_PROPERTY_WITH_DEFAULT( new FacadeMethod<>( "Object getProperty( String key, Object defaultValue )", n -> n.getProperty( "foo", 42 ) ) ),
+    SET_PROPERTY( new FacadeMethod<>( "void setProperty( String key, Object value )", n -> n.setProperty( "foo", 42 ) ) ),
+    REMOVE_PROPERTY( new FacadeMethod<>( "Object removeProperty( String key )", n -> n.removeProperty( "foo" ) ) ),
+    GET_PROPERTY_KEYS( new FacadeMethod<>( "Iterable<String> getPropertyKeys()", n -> consume( n.getPropertyKeys() ) ) ),
+    DELETE( new FacadeMethod<>( "void delete()", Node::delete ) ),
+    GET_RELATIONSHIPS( new FacadeMethod<>( "Iterable<Relationship> getRelationships()", n -> consume( n.getRelationships() ) ) ),
+    HAS_RELATIONSHIP( new FacadeMethod<>( "boolean hasRelationship()", Node::hasRelationship ) ),
+    GET_RELATIONSHIPS_BY_TYPE(
+            new FacadeMethod<>( "Iterable<Relationship> getRelationships( RelationshipType... types )", n -> consume( n.getRelationships( FOO, BAR ) ) ) ),
+    GET_RELATIONSHIPS_BY_DIRECTION_AND_TYPES( new FacadeMethod<>( "Iterable<Relationship> getRelationships( Direction direction, RelationshipType... types )",
+            n -> consume( n.getRelationships( BOTH, FOO, BAR ) ) ) ),
+    HAS_RELATIONSHIP_BY_TYPE( new FacadeMethod<>( "boolean hasRelationship( RelationshipType... types )", n -> n.hasRelationship( FOO ) ) ),
+    HAS_RELATIONSHIP_BY_DIRECTION_AND_TYPE(
+            new FacadeMethod<>( "boolean hasRelationship( Direction direction, RelationshipType... types )", n -> n.hasRelationship( BOTH, FOO ) ) ),
+    GET_RELATIONSHIPS_BY_DIRECTION(
+            new FacadeMethod<>( "Iterable<Relationship> getRelationships( Direction dir )", n -> consume( n.getRelationships( BOTH ) ) ) ),
+    HAS_RELATIONSHIP_BY_DIRECTION( new FacadeMethod<>( "boolean hasRelationship( Direction dir )", n -> n.hasRelationship( BOTH ) ) ),
+    GET_RELATIONSHIPS_BY_TYPE_AND_DIRECTION( new FacadeMethod<>( "Iterable<Relationship> getRelationships( RelationshipType type, Direction dir )",
+            n -> consume( n.getRelationships( FOO, BOTH ) ) ) ),
+    HAS_RELATIONSHIP_BY_TYPE_AND_DIRECTION(
+            new FacadeMethod<>( "boolean hasRelationship( RelationshipType type, Direction dir )", n -> n.hasRelationship( FOO, BOTH ) ) ),
+    GET_SINGLE_RELATIONSHIP(
+            new FacadeMethod<>( "Relationship getSingleRelationship( RelationshipType type, Direction dir )", n -> n.getSingleRelationship( FOO, BOTH ) ) ),
+    CREATE_RELATIONSHIP_TO(
+            new FacadeMethod<>( "Relationship createRelationshipTo( Node otherNode, RelationshipType type )", n -> n.createRelationshipTo( n, FOO ) ) ),
+    ADD_LABEL( new FacadeMethod<>( "void addLabel( Label label )", n -> n.addLabel( QUUX ) ) ),
+    REMOVE_LABEL( new FacadeMethod<>( "void removeLabel( Label label )", n -> n.removeLabel( QUUX ) ) ),
+    HAS_LABEL( new FacadeMethod<>( "boolean hasLabel( Label label )", n -> n.hasLabel( QUUX ) ) ),
+    GET_LABELS( new FacadeMethod<>( "ResourceIterable<Label> getLabels()", n -> consume( n.getLabels() ) ) );
+
+    private final FacadeMethod<Node> facadeMethod;
 
-    private static final FacadeMethod<Node> HAS_PROPERTY = new FacadeMethod<>( "boolean hasProperty( String key )", n -> n.hasProperty( "foo" ) );
-    private static final FacadeMethod<Node> GET_PROPERTY = new FacadeMethod<>( "Object getProperty( String key )", n -> n.getProperty( "foo" ) );
-    private static final FacadeMethod<Node> GET_PROPERTY_WITH_DEFAULT = new FacadeMethod<>( "Object getProperty( String key, Object defaultValue )", n -> n.getProperty( "foo", 42 ) );
-    private static final FacadeMethod<Node> SET_PROPERTY = new FacadeMethod<>( "void setProperty( String key, Object value )", n -> n.setProperty( "foo", 42 ) );
-    private static final FacadeMethod<Node> REMOVE_PROPERTY = new FacadeMethod<>( "Object removeProperty( String key )", n -> n.removeProperty( "foo" ) );
-    private static final FacadeMethod<Node> GET_PROPERTY_KEYS = new FacadeMethod<>( "Iterable<String> getPropertyKeys()", n -> consume( n.getPropertyKeys() ) );
-    private static final FacadeMethod<Node> DELETE = new FacadeMethod<>( "void delete()", Node::delete );
-    private static final FacadeMethod<Node> GET_RELATIONSHIPS = new FacadeMethod<>( "Iterable<Relationship> getRelationships()", n -> consume( n.getRelationships() ) );
-    private static final FacadeMethod<Node> HAS_RELATIONSHIP = new FacadeMethod<>( "boolean hasRelationship()", Node::hasRelationship );
-    private static final FacadeMethod<Node> GET_RELATIONSHIPS_BY_TYPE = new FacadeMethod<>( "Iterable<Relationship> getRelationships( RelationshipType... types )", n -> consume( n.getRelationships( FOO, BAR ) ) );
-    private static final FacadeMethod<Node> GET_RELATIONSHIPS_BY_DIRECTION_AND_TYPES = new FacadeMethod<>( "Iterable<Relationship> getRelationships( Direction direction, RelationshipType... types )", n -> consume( n.getRelationships( BOTH, FOO, BAR ) ) );
-    private static final FacadeMethod<Node> HAS_RELATIONSHIP_BY_TYPE = new FacadeMethod<>( "boolean hasRelationship( RelationshipType... types )", n -> n.hasRelationship( FOO ) );
-    private static final FacadeMethod<Node> HAS_RELATIONSHIP_BY_DIRECTION_AND_TYPE = new FacadeMethod<>( "boolean hasRelationship( Direction direction, RelationshipType... types )", n -> n.hasRelationship( BOTH, FOO ) );
-    private static final FacadeMethod<Node> GET_RELATIONSHIPS_BY_DIRECTION = new FacadeMethod<>( "Iterable<Relationship> getRelationships( Direction dir )", n -> consume( n.getRelationships( BOTH ) ) );
-    private static final FacadeMethod<Node> HAS_RELATIONSHIP_BY_DIRECTION = new FacadeMethod<>( "boolean hasRelationship( Direction dir )", n -> n.hasRelationship( BOTH ) );
-    private static final FacadeMethod<Node> GET_RELATIONSHIPS_BY_TYPE_AND_DIRECTION = new FacadeMethod<>( "Iterable<Relationship> getRelationships( RelationshipType type, Direction dir )", n -> consume( n.getRelationships( FOO, BOTH ) ) );
-    private static final FacadeMethod<Node> HAS_RELATIONSHIP_BY_TYPE_AND_DIRECTION = new FacadeMethod<>( "boolean hasRelationship( RelationshipType type, Direction dir )", n -> n.hasRelationship( FOO, BOTH ) );
-    private static final FacadeMethod<Node> GET_SINGLE_RELATIONSHIP = new FacadeMethod<>( "Relationship getSingleRelationship( RelationshipType type, Direction dir )", n -> n.getSingleRelationship( FOO, BOTH ) );
-    private static final FacadeMethod<Node> CREATE_RELATIONSHIP_TO = new FacadeMethod<>( "Relationship createRelationshipTo( Node otherNode, RelationshipType type )", n -> n.createRelationshipTo( n, FOO ) );
-    private static final FacadeMethod<Node> ADD_LABEL = new FacadeMethod<>( "void addLabel( Label label )", n -> n.addLabel( QUUX ) );
-    private static final FacadeMethod<Node> REMOVE_LABEL = new FacadeMethod<>( "void removeLabel( Label label )", n -> n.removeLabel( QUUX ) );
-    private static final FacadeMethod<Node> HAS_LABEL = new FacadeMethod<>( "boolean hasLabel( Label label )", n -> n.hasLabel( QUUX ) );
-    private static final FacadeMethod<Node> GET_LABELS = new FacadeMethod<>( "ResourceIterable<Label> getLabels()", n -> consume( n.getLabels() ) );
+    NodeFacadeMethods( FacadeMethod<Node> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<Node>> ALL_NODE_FACADE_METHODS = unmodifiableCollection( asList(
-        HAS_PROPERTY,
-        GET_PROPERTY,
-        GET_PROPERTY_WITH_DEFAULT,
-        SET_PROPERTY,
-        REMOVE_PROPERTY,
-        GET_PROPERTY_KEYS,
-        DELETE, GET_RELATIONSHIPS,
-        HAS_RELATIONSHIP,
-        GET_RELATIONSHIPS_BY_TYPE,
-        GET_RELATIONSHIPS_BY_DIRECTION_AND_TYPES,
-        HAS_RELATIONSHIP_BY_TYPE,
-        HAS_RELATIONSHIP_BY_DIRECTION_AND_TYPE,
-        GET_RELATIONSHIPS_BY_DIRECTION,
-        HAS_RELATIONSHIP_BY_DIRECTION,
-        GET_RELATIONSHIPS_BY_TYPE_AND_DIRECTION,
-        HAS_RELATIONSHIP_BY_TYPE_AND_DIRECTION,
-        GET_SINGLE_RELATIONSHIP, CREATE_RELATIONSHIP_TO,
-        ADD_LABEL,
-        REMOVE_LABEL,
-        HAS_LABEL,
-        GET_LABELS
-    ) );
+    @Override
+    public void accept( Node node )
+    {
+        facadeMethod.accept( node );
+    }
 
-    private NodeFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/RelationshipFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/RelationshipFacadeMethods.java
index 7a85eea0d5fef..b653ec55c42c9 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/RelationshipFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/RelationshipFacadeMethods.java
@@ -19,49 +19,46 @@
  */
 package org.neo4j.graphdb;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
+import java.util.function.Consumer;
+
 import static org.neo4j.graphdb.FacadeMethod.consume;
 import static org.neo4j.graphdb.RelationshipType.withName;
 
-@SuppressWarnings( "UnusedDeclaration" )
-public class RelationshipFacadeMethods
+public enum RelationshipFacadeMethods implements Consumer<Relationship>
 {
-    private static final FacadeMethod<Relationship> HAS_PROPERTY = new FacadeMethod<>( "boolean hasProperty( String key )", r -> r.hasProperty( "foo" ) );
-    private static final FacadeMethod<Relationship> GET_PROPERTY = new FacadeMethod<>( "Object getProperty( String key )", r -> r.getProperty( "foo" ) );
-    private static final FacadeMethod<Relationship> GET_PROPERTY_WITH_DEFAULT = new FacadeMethod<>( "Object getProperty( String key, Object defaultValue )", r -> r.getProperty( "foo", 42 ) );
-    private static final FacadeMethod<Relationship> SET_PROPERTY = new FacadeMethod<>( "void setProperty( String key, Object value )", r -> r.setProperty( "foo", 42 ) );
-    private static final FacadeMethod<Relationship> REMOVE_PROPERTY = new FacadeMethod<>( "Object removeProperty( String key )", r -> r.removeProperty( "foo" ) );
-    private static final FacadeMethod<Relationship> GET_PROPERTY_KEYS = new FacadeMethod<>( "Iterable<String> getPropertyKeys()", r -> consume( r.getPropertyKeys() ) );
-    private static final FacadeMethod<Relationship> DELETE = new FacadeMethod<>( "void delete()", Relationship::delete );
-    private static final FacadeMethod<Relationship> GET_START_NODE = new FacadeMethod<>( "Node getStartNode()", Relationship::getStartNode );
-    private static final FacadeMethod<Relationship> GET_START_NODE_ID = new FacadeMethod<>( "Node getStartNode()", Relationship::getStartNodeId );
-    private static final FacadeMethod<Relationship> GET_END_NODE = new FacadeMethod<>( "Node getEndNode()", Relationship::getEndNode );
-    private static final FacadeMethod<Relationship> GET_END_NODE_ID = new FacadeMethod<>( "Node getEndNode()", Relationship::getEndNodeId );
-    private static final FacadeMethod<Relationship> GET_OTHER_NODE = new FacadeMethod<>( "Node getOtherNode( Node node )", r -> r.getOtherNode( null ) );
-    private static final FacadeMethod<Relationship> GET_OTHER_NODE_ID = new FacadeMethod<>( "Node getOtherNode( Node node )", r -> r.getOtherNodeId( 42 ) );
-    private static final FacadeMethod<Relationship> GET_NODES = new FacadeMethod<>( "Node[] getNodes()", Relationship::getNodes );
-    private static final FacadeMethod<Relationship> GET_TYPE = new FacadeMethod<>( "RelationshipType getType()", Relationship::getType );
-    private static final FacadeMethod<Relationship> IS_TYPE = new FacadeMethod<>( "boolean isType( RelationshipType type )", r -> r.isType( withName( "foo" ) ) );
+    HAS_PROPERTY( new FacadeMethod<>( "boolean hasProperty( String key )", r -> r.hasProperty( "foo" ) ) ),
+    GET_PROPERTY( new FacadeMethod<>( "Object getProperty( String key )", r -> r.getProperty( "foo" ) ) ),
+    GET_PROPERTY_WITH_DEFAULT( new FacadeMethod<>( "Object getProperty( String key, Object defaultValue )", r -> r.getProperty( "foo", 42 ) ) ),
+    SET_PROPERTY( new FacadeMethod<>( "void setProperty( String key, Object value )", r -> r.setProperty( "foo", 42 ) ) ),
+    REMOVE_PROPERTY( new FacadeMethod<>( "Object removeProperty( String key )", r -> r.removeProperty( "foo" ) ) ),
+    GET_PROPERTY_KEYS( new FacadeMethod<>( "Iterable<String> getPropertyKeys()", r -> consume( r.getPropertyKeys() ) ) ),
+    DELETE( new FacadeMethod<>( "void delete()", Relationship::delete ) ),
+    GET_START_NODE( new FacadeMethod<>( "Node getStartNode()", Relationship::getStartNode ) ),
+    GET_START_NODE_ID( new FacadeMethod<>( "Node getStartNode()", Relationship::getStartNodeId ) ),
+    GET_END_NODE( new FacadeMethod<>( "Node getEndNode()", Relationship::getEndNode ) ),
+    GET_END_NODE_ID( new FacadeMethod<>( "Node getEndNode()", Relationship::getEndNodeId ) ),
+    GET_OTHER_NODE( new FacadeMethod<>( "Node getOtherNode( Node node )", r -> r.getOtherNode( null ) ) ),
+    GET_OTHER_NODE_ID( new FacadeMethod<>( "Node getOtherNode( Node node )", r -> r.getOtherNodeId( 42 ) ) ),
+    GET_NODES( new FacadeMethod<>( "Node[] getNodes()", Relationship::getNodes ) ),
+    GET_TYPE( new FacadeMethod<>( "RelationshipType getType()", Relationship::getType ) ),
+    IS_TYPE( new FacadeMethod<>( "boolean isType( RelationshipType type )", r -> r.isType( withName( "foo" ) ) ) );
+
+    private final FacadeMethod<Relationship> facadeMethod;
 
-    static final Iterable<FacadeMethod<Relationship>> ALL_RELATIONSHIP_FACADE_METHODS = unmodifiableCollection( asList(
-        HAS_PROPERTY,
-        GET_PROPERTY,
-        GET_PROPERTY_WITH_DEFAULT,
-        SET_PROPERTY,
-        REMOVE_PROPERTY,
-        GET_PROPERTY_KEYS,
-        DELETE,
-        GET_START_NODE,
-        GET_END_NODE,
-        GET_OTHER_NODE,
-        GET_OTHER_NODE_ID,
-        GET_NODES,
-        GET_TYPE,
-        IS_TYPE
-    ) );
+    RelationshipFacadeMethods( FacadeMethod<Relationship> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
+
+    @Override
+    public void accept( Relationship relationship )
+    {
+        facadeMethod.accept( relationship );
+    }
 
-    private RelationshipFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/SchemaFacadeMethods.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/SchemaFacadeMethods.java
index 77fa5250791cd..e806637ded14b 100644
--- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/SchemaFacadeMethods.java
+++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/SchemaFacadeMethods.java
@@ -20,45 +20,43 @@
 package org.neo4j.graphdb;
 
 import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 
-import org.neo4j.graphdb.schema.IndexDefinition;
 import org.neo4j.graphdb.schema.Schema;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableCollection;
-import static org.mockito.Mockito.mock;
+import static org.neo4j.graphdb.FacadeMethod.INDEX_DEFINITION;
+import static org.neo4j.graphdb.FacadeMethod.LABEL;
 
-public class SchemaFacadeMethods
+public enum SchemaFacadeMethods implements Consumer<Schema>
 {
-    private static final Label LABEL = Label.label( "Label" );
-
-    private static final IndexDefinition INDEX_DEFINITION = mock( IndexDefinition.class );
-
-    private static final FacadeMethod<Schema> INDEX_FOR = new FacadeMethod<>( "IndexCreator indexFor( Label label )", s -> s.indexFor( LABEL ) );
-    private static final FacadeMethod<Schema> GET_INDEXES_BY_LABEL = new FacadeMethod<>( "Iterable<IndexDefinition> getIndexes( Label label )", s -> s.getIndexes( LABEL ) );
-    private static final FacadeMethod<Schema> GET_INDEXES = new FacadeMethod<>( "Iterable<IndexDefinition> getIndexes()", Schema::getIndexes );
-    private static final FacadeMethod<Schema> GET_INDEX_STATE = new FacadeMethod<>( "IndexState getIndexState( IndexDefinition index )", s -> s.getIndexState( INDEX_DEFINITION ) );
-    private static final FacadeMethod<Schema> GET_INDEX_FAILURE = new FacadeMethod<>( "String getIndexFailure( IndexDefinition index )", s -> s.getIndexFailure( INDEX_DEFINITION ) );
-    private static final FacadeMethod<Schema> CONSTRAINT_FOR = new FacadeMethod<>( "ConstraintCreator constraintFor( Label label )", s -> s.constraintFor( LABEL ) );
-    private static final FacadeMethod<Schema> GET_CONSTRAINTS_BY_LABEL = new FacadeMethod<>( "Iterable<ConstraintDefinition> getConstraints( Label label )", s -> s.getConstraints( LABEL ) );
-    private static final FacadeMethod<Schema> GET_CONSTRAINTS = new FacadeMethod<>( "Iterable<ConstraintDefinition> getConstraints()", Schema::getConstraints );
-    private static final FacadeMethod<Schema> AWAIT_INDEX_ONLINE = new FacadeMethod<>( "void awaitIndexOnline( IndexDefinition index, long duration, TimeUnit unit )", s -> s.awaitIndexOnline( INDEX_DEFINITION, 1L, TimeUnit.SECONDS ) );
-    private static final FacadeMethod<Schema> AWAIT_INDEXES_ONLINE = new FacadeMethod<>( "void awaitIndexesOnline( long duration, TimeUnit unit )", s -> s.awaitIndexesOnline( 1L, TimeUnit.SECONDS ) );
+    INDEX_FOR( new FacadeMethod<>( "IndexCreator indexFor( Label label )", s -> s.indexFor( LABEL ) ) ),
+    GET_INDEXES_BY_LABEL( new FacadeMethod<>( "Iterable<IndexDefinition> getIndexes( Label label )", s -> s.getIndexes( LABEL ) ) ),
+    GET_INDEXES( new FacadeMethod<>( "Iterable<IndexDefinition> getIndexes()", Schema::getIndexes ) ),
+    GET_INDEX_STATE( new FacadeMethod<>( "IndexState getIndexState( IndexDefinition index )", s -> s.getIndexState( INDEX_DEFINITION ) ) ),
+    GET_INDEX_FAILURE( new FacadeMethod<>( "String getIndexFailure( IndexDefinition index )", s -> s.getIndexFailure( INDEX_DEFINITION ) ) ),
+    CONSTRAINT_FOR( new FacadeMethod<>( "ConstraintCreator constraintFor( Label label )", s -> s.constraintFor( LABEL ) ) ),
+    GET_CONSTRAINTS_BY_LABEL( new FacadeMethod<>( "Iterable<ConstraintDefinition> getConstraints( Label label )", s -> s.getConstraints( LABEL ) ) ),
+    GET_CONSTRAINTS( new FacadeMethod<>( "Iterable<ConstraintDefinition> getConstraints()", Schema::getConstraints ) ),
+    AWAIT_INDEX_ONLINE( new FacadeMethod<>( "void awaitIndexOnline( IndexDefinition index, long duration, TimeUnit unit )",
+            s -> s.awaitIndexOnline( INDEX_DEFINITION, 1L, TimeUnit.SECONDS ) ) ),
+    AWAIT_INDEXES_ONLINE( new FacadeMethod<>( "void awaitIndexesOnline( long duration, TimeUnit unit )", s -> s.awaitIndexesOnline( 1L, TimeUnit.SECONDS ) ) );
+
+    private final FacadeMethod<Schema> facadeMethod;
+
+    SchemaFacadeMethods( FacadeMethod<Schema> facadeMethod )
+    {
+        this.facadeMethod = facadeMethod;
+    }
 
-    static final Iterable<FacadeMethod<Schema>> ALL_SCHEMA_FACADE_METHODS = unmodifiableCollection( asList(
-        INDEX_FOR,
-        GET_INDEXES_BY_LABEL,
-        GET_INDEXES,
-        GET_INDEX_STATE,
-        GET_INDEX_FAILURE,
-        CONSTRAINT_FOR,
-        GET_CONSTRAINTS_BY_LABEL,
-        GET_CONSTRAINTS,
-        AWAIT_INDEX_ONLINE,
-        AWAIT_INDEXES_ONLINE
-    ) );
+    @Override
+    public void accept( Schema schema )
+    {
+        facadeMethod.accept( schema );
+    }
 
-    private SchemaFacadeMethods()
+    @Override
+    public String toString()
     {
+        return facadeMethod.toString();
     }
 }
diff --git a/community/kernel/src/test/java/org/neo4j/graphdb/FacadeMethod.java b/community/kernel/src/test/java/org/neo4j/graphdb/FacadeMethod.java
index 4ea9c49fa1e91..83ad760460219 100644
--- a/community/kernel/src/test/java/org/neo4j/graphdb/FacadeMethod.java
+++ b/community/kernel/src/test/java/org/neo4j/graphdb/FacadeMethod.java
@@ -22,10 +22,21 @@
 import java.util.Iterator;
 import java.util.function.Consumer;
 
+import org.neo4j.graphdb.schema.IndexDefinition;
+
 import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.neo4j.graphdb.Label.label;
+import static org.neo4j.graphdb.RelationshipType.withName;
 
-public class FacadeMethod<T>
+public class FacadeMethod<T> implements Consumer<T>
 {
+    public static final Label LABEL = Label.label( "Label" );
+    public static final RelationshipType FOO = withName( "foo" );
+    public static final RelationshipType BAR = withName( "bar" );
+    public static final Label QUUX = label( "quux" );
+    public static final IndexDefinition INDEX_DEFINITION = mock( IndexDefinition.class );
+
     private final String methodSignature;
     private final Consumer<T> callable;
 
@@ -35,6 +46,12 @@ public FacadeMethod( String methodSignature, Consumer<T> callable )
         this.callable = callable;
     }
 
+    @Override
+    public void accept( T t )
+    {
+        callable.accept( t );
+    }
+
     public void call( T self )
     {
         callable.accept( self );