org.apache.tinkerpop.gremlin

## Class GraphManager.ManagedGraphProvider

- java.lang.Object
- - org.apache.tinkerpop.gremlin.GraphManager.ManagedGraphProvider

- All Implemented Interfaces:
    AutoCloseable, GraphProvider
  Enclosing class:
    GraphManager

      public static class GraphManager.ManagedGraphProvider
      extends Object
      implements GraphProvider, AutoCloseable

  This class provides a way to intercepts calls to `Graph` implementation's `GraphProvider` instances. When `openTestGraph(Configuration)` is called the created object is stored in a list and when tests are complete the `tryClearGraphs()` is called. When this is called, an attempt is made to close all open graphs.

- - ### 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
    `ManagedGraphProvider(GraphProvider innerGraphProvider)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear(Configuration configuration)` If possible (usually with persisted graph) clear the space on disk given the configuration that would be used to construct the graph.
    `void` | `clear(Graph graph, Configuration configuration)` Clears a `Graph` of all data and settings.
    `void` | `close()`
    `Object` | `convertId(Object id, Class<? extends Element> c)` Converts an identifier from a test to an identifier accepted by the `Graph` instance.
    `String` | `convertLabel(String label)` Converts an label from a test to an label accepted by the Graph instance.
    `GraphComputer` | `getGraphComputer(Graph graph)` Create a `GraphComputer` from the `Graph` instance.
    `Set<Class>` | `getImplementations()` Get the set of concrete implementations of certain classes and interfaces utilized by the test suite.
    `Optional<Graph.Features>` | `getStaticFeatures()` Gets a `Graph.Features` implementation that contains graph feature configuration that will never change from execution to execution of the tests given this current `GraphProvider` implementation.
    `Optional<GraphProvider.TestListener>` | `getTestListener()` Returns a `GraphProvider.TestListener` implementation that provides feedback to the `GraphProvider` implementation.
    `String` | `getWorkingDirectory()` Helper method for those build `GraphProvider` implementations that need a standard working directory for tests (e.g.
    `void` | `loadGraphData(Graph graph, LoadGraphWith loadGraphWith, Class testClass, String testName)` Tests are annotated with a `LoadGraphWith` annotation.
    `Configuration` | `newGraphConfiguration(String graphName, Class<?> test, String testMethodName, 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.
    `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.
    `Graph` | `openTestGraph(Configuration config)` Creates a new `Graph` instance from the `Configuration` object using `GraphFactory`.
    `Configuration` | `standardGraphConfiguration(Class<?> test, String testMethodName, LoadGraphWith.GraphData loadGraphWith)` Gets the `Configuration` object that can construct a `Graph` instance from `GraphFactory`.
    `Graph` | `standardTestGraph(Class<?> test, String testMethodName, LoadGraphWith.GraphData loadGraphWith)` Creates a new `Graph` instance using the default `org.apache.commons.configuration.Configuration` from `GraphProvider.standardGraphConfiguration(Class, String, LoadGraphWith.GraphData)`.
    `GraphTraversalSource` | `traversal(Graph graph)` Create a `GraphTraversalSource` from a `Graph` instance.
    `GraphTraversalSource` | `traversal(Graph graph, TraversalStrategy... strategies)` Create a `GraphTraversalSource` from a `Graph` instance.
    `void` | `tryClearGraphs()`

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

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

- - ### Constructor Detail

    - #### ManagedGraphProvider

          public ManagedGraphProvider(GraphProvider innerGraphProvider)

  - ### Method Detail

    - #### tryClearGraphs

          public void tryClearGraphs()

    - #### getWorkingDirectory

          public String getWorkingDirectory()

      Description copied from interface: `GraphProvider`
      Helper method for those build `GraphProvider` implementations that need a standard working directory for tests (e.g. graphs that persist data to disk). Typically, there is no need to override the default behavior of this method and if it is overridden, it is usually best to continue to use the `TestHelper` to produce the working directory as it will create the path in the appropriate build directories.
      Specified by:
        `getWorkingDirectory` in interface `GraphProvider`
      Returns:
        UNIX-formatted absolute directory path

    - #### traversal

          public GraphTraversalSource traversal(Graph graph)

      Description copied from interface: `GraphProvider`
      Create a `GraphTraversalSource` from a `Graph` instance. The default implementation does not use `GraphComputer` so providers should override as necessary if their implementation is testing something that requires a different engine type, like `GraphComputer`.
      Specified by:
        `traversal` in interface `GraphProvider`

    - #### traversal

          public GraphTraversalSource traversal(Graph graph,
                                                TraversalStrategy... strategies)

      Description copied from interface: `GraphProvider`
      Create a `GraphTraversalSource` from a `Graph` instance. The default implementation does not use `GraphComputer` so providers should override as necessary if their implementation is testing something that requires a different engine type, like `GraphComputer`.

      Implementations should apply strategies as necessary to the `GraphTraversalSource` before calling it's `create` method.
      Specified by:
        `traversal` in interface `GraphProvider`

    - #### getGraphComputer

          public GraphComputer getGraphComputer(Graph graph)

      Description copied from interface: `GraphProvider`
      Create a `GraphComputer` from the `Graph` instance. The default implementation simply calls `graph.compute()`.
      Specified by:
        `getGraphComputer` in interface `GraphProvider`
      Parameters:
        `graph` - the graph to get the graph computer from
      Returns:
        a new graph computer

    - #### standardTestGraph

          public Graph standardTestGraph(Class<?> test,
                                         String testMethodName,
                                         LoadGraphWith.GraphData loadGraphWith)

      Description copied from interface: `GraphProvider`
      Creates a new `Graph` instance using the default `org.apache.commons.configuration.Configuration` from `GraphProvider.standardGraphConfiguration(Class, String, LoadGraphWith.GraphData)`.
      Specified by:
        `standardTestGraph` in interface `GraphProvider`

    - #### openTestGraph

          public Graph openTestGraph(Configuration config)

      Description copied from interface: `GraphProvider`
      Creates a new `Graph` instance from the `Configuration` object using `GraphFactory`. The assumption here is that the `Configuration` has been created by one of the `GraphProvider.newGraphConfiguration(String, Class, String, LoadGraphWith.GraphData)` methods and has therefore already been modified by the implementation as necessary for `Graph` creation.
      Specified by:
        `openTestGraph` in interface `GraphProvider`

    - #### standardGraphConfiguration

          public Configuration standardGraphConfiguration(Class<?> test,
                                                          String testMethodName,
                                                          LoadGraphWith.GraphData loadGraphWith)

      Description copied from interface: `GraphProvider`
      Gets the `Configuration` object that can construct a `Graph` instance from `GraphFactory`. Note that this method should create a `Graph` using the `graphName` of "standard", meaning it should always return a configuration instance that generates the same `Graph` from the `GraphFactory`.
      Specified by:
        `standardGraphConfiguration` in interface `GraphProvider`

    - #### clear

          public void clear(Configuration configuration)
                     throws Exception

      Description copied from interface: `GraphProvider`
      If possible (usually with persisted graph) clear the space on disk given the configuration that would be used to construct the graph. The default implementation simply calls `#clear(Graph, org.apache.commons.configuration.Configuration)` with a null graph argument.

      Implementations should be able to accept an argument of null for the `org.apache.commons.configuration.Configuration` as well, and a proper handling is needed. Otherwise, a NullPointerException may be thrown.
      Specified by:
        `clear` in interface `GraphProvider`
      Throws:
        `Exception`

    - #### clear

          public void clear(Graph graph,
                            Configuration configuration)
                     throws Exception

      Description copied from interface: `GraphProvider`
      Clears a `Graph` of all data and settings. Implementations will have different ways of handling this. It is typically expected that `Graph.close()` will be called and open transactions will be closed. For a brute force approach, implementers can simply delete data directories provided in the configuration. Implementers may choose a more elegant approach if it exists.

      Implementations should be able to accept an argument of null for the `Graph`, in which case the only action that can be performed is a clear given the configuration. The method will typically be called this way as clean up task on setup to ensure that a persisted graph has a clear space to create a test graph.

      Implementations should be able to accept an argument of null for the `org.apache.commons.configuration.Configuration` as well, and a proper handling is needed. Otherwise, a NullPointerException may be thrown.

      Calls to this method may occur multiple times for a specific test. Develop this method to be idempotent.
      Specified by:
        `clear` in interface `GraphProvider`
      Throws:
        `Exception`

    - #### convertId

          public Object convertId(Object id,
                                  Class<? extends Element> c)

      Description copied from interface: `GraphProvider`
      Converts an identifier from a test to an identifier accepted by the `Graph` instance. Test that try to utilize an Element identifier will pass it to this method before usage. This method should be sure to be consistent in the return value such that calling it with "x" should always return the same transformed value.
      Specified by:
        `convertId` in interface `GraphProvider`

    - #### convertLabel

          public String convertLabel(String label)

      Description copied from interface: `GraphProvider`
      Converts an label from a test to an label accepted by the Graph instance. Test that try to utilize a label will pass it to this method before usage.
      Specified by:
        `convertLabel` in interface `GraphProvider`

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

    - #### newGraphConfiguration

          public Configuration newGraphConfiguration(String graphName,
                                                     Class<?> test,
                                                     String testMethodName,
                                                     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
        `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

    - #### getImplementations

          public Set<Class> getImplementations()

      Description copied from interface: `GraphProvider`
      Get the set of concrete implementations of certain classes and interfaces utilized by the test suite. This method should return any implementations or extensions of the following interfaces or classes:
      - `Edge`
      - `Element`
      - `DefaultGraphTraversal`
      - `Graph`
      - `Graph.Variables`
      - `GraphTraversal`
      - `B_LP_O_P_S_SE_SL_Traverser`
      - `Property`
      - `B_O_S_SE_SL_Traverser`
      - `Traversal`
      - `Traverser`
      - `Vertex`
      - `VertexProperty`

      The test suite only enforces registration of the following core structure interfaces (i.e. these classes must be registered or the tests will fail to execute):
      - `Edge`
      - `Element`
      - `Graph`
      - `Graph.Variables`
      - `Property`
      - `Vertex`
      - `VertexProperty`

      The remaining interfaces and classes should be registered however as failure to do so, might cause failures in the Groovy environment testing suite.

      Internally speaking, tests that make use of this method should bind in `GraphProvider.CORE_IMPLEMENTATIONS` to the `Set` because these represent `gremlin-core` implementations that are likely not registered by the vendor implementations.
      Specified by:
        `getImplementations` in interface `GraphProvider`

    - #### getTestListener

          public Optional<GraphProvider.TestListener> getTestListener()

      Description copied from interface: `GraphProvider`
      Returns a `GraphProvider.TestListener` implementation that provides feedback to the `GraphProvider` implementation. By default, this returns an empty listener.
      Specified by:
        `getTestListener` in interface `GraphProvider`

    - #### close

          public void close()
                     throws Exception

      Specified by:
        `close` in interface `AutoCloseable`
      Throws:
        `Exception`

    - #### getStaticFeatures

          public Optional<Graph.Features> getStaticFeatures()

      Description copied from interface: `GraphProvider`
      Gets a `Graph.Features` implementation that contains graph feature configuration that will never change from execution to execution of the tests given this current `GraphProvider` implementation. Implementing this method will allow the test suite to avoid creation of a `Graph` instance and thus speed up the execution of tests if that creation process is expensive. It is important that this static set of features be representative of what the `Graph` instance produced by this `GraphProvider` can actually do or else the cost of `Graph` instantiation will be incurred when it doesn't need to be. It is also important that this method be faster than the cost of `Graph` creation in the first place or there really won't be any difference in execution speed. In cases where some features are static and others are not, simply throw an `UnsupportedOperationException` from those features to let the test suite know that it cannot rely on them and the test suite will revert to using a constructed `Graph` instance.
      Specified by:
        `getStaticFeatures` in interface `GraphProvider`

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