org.apache.tinkerpop.gremlin

## Class AbstractGraphProvider

- java.lang.Object
- - org.apache.tinkerpop.gremlin.AbstractGraphProvider

- All Implemented Interfaces:
    GraphProvider

      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)

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.GraphProvider

      `GraphProvider.Descriptor, GraphProvider.TestListener`

  - ### Field Summary

    - ### Fields inherited from interface org.apache.tinkerpop.gremlin.GraphProvider

      `CORE_IMPLEMENTATIONS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractGraphProvider()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected String` | `cleanParameters(String methodName)`
    `protected static void` | `deleteDirectory(File directory)` Helper method for those building `GraphProvider` implementations that need to clean directories between test runs.
    `abstract Map<String,Object>` | `getBaseConfiguration(String graphName, Class<?> test, String testMethodName, LoadGraphWith.GraphData loadGraphWith)` Provides a basic configuration for a particular `Graph` instance and used the `graphName` to ensure that the instance is unique.
    `void` | `loadGraphData(Graph graph, LoadGraphWith loadGraphWith, Class testClass, String testName)` Tests are annotated with a `LoadGraphWith` annotation.
    `protected String` | `makeTestDirectory(String graphName, Class<?> test, String testMethodName)` Utility method to help produce an appropriate unique directory for a test.
    `Configuration` | `newGraphConfiguration(String graphName, Class<?> test, String testMethodName, Map<String,Object> configurationOverrides, LoadGraphWith.GraphData loadGraphWith)` 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.
    `protected void` | `readIntoGraph(Graph g, String path)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.GraphProvider

      `clear, clear, convertId, convertLabel, getGraphComputer, getImplementations, getTestListener, getWorkingDirectory, newGraphConfiguration, openTestGraph, standardGraphConfiguration, standardTestGraph, traversal, traversal`

- - ### 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 used 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.
      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 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.

    - #### makeTestDirectory

          protected String makeTestDirectory(String graphName,
                                             Class<?> test,
                                             String testMethodName)

      Utility method to help produce an appropriate unique directory for a test. Designed to be called from `getBaseConfiguration(String, Class, String, LoadGraphWith.GraphData)` for those graph providers that need a data directory for their `Graph` implementations.

    - #### cleanParameters

          protected String cleanParameters(String methodName)

    - #### readIntoGraph

          protected void readIntoGraph(Graph g,
                                       String path)
                                throws IOException

      Throws:
        `IOException`

Copyright © 2013–2018 Apache Software Foundation. All rights reserved.