Package org.apache.tinkerpop.gremlin

Class AbstractGraphProvider

  • All Implemented Interfaces:
    GraphProvider
    Direct Known Subclasses:
    AbstractFileGraphProvider
    public abstract class AbstractGraphProvider
extends Object
implements GraphProvider
    A basic GraphProvider which simply requires the implementer to supply their base configuration for their Graph instance. Minimally this is just the setting for "gremlin.graph".
    Author:
    Stephen Mallette (http://stephen.genoprime.com)

    • Constructor Detail

      • AbstractGraphProvider

        public AbstractGraphProvider()

    • Method Detail

      • getBaseConfiguration

        public abstract Map<String,​Object> getBaseConfiguration​(String graphName,
                                                              Class<?> test,
                                                              String testMethodName,
                                                              LoadGraphWith.GraphData loadGraphWith)
        Provides a basic configuration for a particular Graph instance and uses the graphName to ensure that the instance is unique. It is up to the Gremlin implementation to determine how best to use the graphName to ensure uniqueness. For example, Neo4j, might use the graphName might be used to create a different sub-directory where the graph is stored.

        The @{code test} and @{code testMethodName} can be used to alter graph configurations for specific tests. For example, a graph that has support for different transaction isolation levels might only support a feature in a specific configuration. Using these arguments, the implementation could detect when a test was being fired that required the database to be configured in a specific isolation level and return a configuration to support that.

        Ultimately, the returned Map should minimally contain a configuration that can be given to a GraphFactory so that it can be instantiated.

        Parameters:
        graphName - a value that represents a unique configuration for a graph
        test - the test class
        testMethodName - the name of the test method
        loadGraphWith - the data set to load and will be null if no data is to be loaded
        Returns:
        a configuration Map that should be unique per the graphName

      • newGraphConfiguration

        public org.apache.commons.configuration2.Configuration newGraphConfiguration​(String graphName,
                                                                             Class<?> test,
                                                                             String testMethodName,
                                                                             Map<String,​Object> configurationOverrides,
                                                                             LoadGraphWith.GraphData loadGraphWith)
        Description copied from interface: GraphProvider
        When implementing this method ensure that a test suite can override any settings EXCEPT the "gremlin.graph" setting which should be defined by the implementer. It should provide a Configuration that will generate a graph unique to that graphName.
        Specified by:
        newGraphConfiguration in interface GraphProvider
        Parameters:
        graphName - a unique test graph name
        test - the test class
        testMethodName - the name of the test
        configurationOverrides - settings to override defaults with.
        loadGraphWith - the data set to load and will be null if no data is to be loaded

      • loadGraphData

        public void loadGraphData​(Graph graph,
                          LoadGraphWith loadGraphWith,
                          Class testClass,
                          String testName)
        Description copied from interface: GraphProvider
        Tests are annotated with a LoadGraphWith annotation. These annotations tell the test what kind of data to preload into the graph instance. It is up to the implementation to load the graph with the data specified by that annotation. This method also represents the place where indices should be configured according the the Graph implementation's API. Implementers can use the testClass and testName arguments to implement test specific configurations to their graphs.
        Specified by:
        loadGraphData in interface GraphProvider
        Parameters:
        graph - the Graph instance to load data into constructed by this GraphProvider
        loadGraphWith - the annotation for the currently running test - this value may be null if no graph data is to be loaded in front of the test.
        testClass - the test class being executed
        testName - the name of the test method being executed

      • deleteDirectory

        protected static void deleteDirectory​(File directory)
        Helper method for those building GraphProvider implementations that need to clean directories between test runs.

      • cleanParameters

        protected String cleanParameters​(String methodName)

      • readIntoGraph

        protected void readIntoGraph​(Graph graph,
                             String path)
                      throws IOException
        Used by the default implementation of loadGraphData(Graph, LoadGraphWith, Class, String) to read the graph from a Kryo file using the default GryoReader implementation. If the default implementation does not work (perhaps a graph implementation needs to register some special IoRegistry then this method or its caller should be overridden to suit the implementation.
        Parameters:
        graph - the graph to load to
        path - the path to the file to load into the graph
        Throws:
        IOException