Merge pull request #386 from zhenlineo/1.7-test-with-remote-cluster

Run performance test with a remote cluster.

Author: zhenlineo

test/env.py

@@ -25,6 +25,9 @@
 # Full path of a server package to be used for integration testing
 NEO4J_SERVER_PACKAGE = getenv("NEO4J_SERVER_PACKAGE")
 
+# An existing remote server at this URI
+NEO4J_SERVER_URI = getenv("NEO4J_URI")
+
 # Name of a user for the currently running server
 NEO4J_USER = getenv("NEO4J_USER")
 

test/performance/test_results.py

@@ -24,7 +24,7 @@
 from pytest import mark
 
 from neo4j import GraphDatabase
-from .tools import GraphDatabaseServer
+from .tools import RemoteGraphDatabaseServer
 
 
 class ReadWorkload(object):
@@ -34,9 +34,9 @@ class ReadWorkload(object):
 
     @classmethod
     def setup_class(cls):
-        cls.server = server = GraphDatabaseServer()
+        cls.server = server = RemoteGraphDatabaseServer()
         server.start()
-        cls.driver = GraphDatabase.driver(server.bolt_uri, auth=server.auth_token)
+        cls.driver = GraphDatabase.driver(server.server_uri, auth=server.auth_token, encrypted=server.encrypted)
 
     @classmethod
     def teardown_class(cls):
@@ -53,10 +53,6 @@ def runner():
 
 class TestReadWorkload(ReadWorkload):
 
-    @staticmethod
-    def test_cypher(width):
-        return "UNWIND range(1, $count) AS _ RETURN {}".format(", ".join("$x AS x{}".format(i) for i in range(width)))
-
     @staticmethod
     def uow(record_count, record_width, value):
 

test/performance/tools.py

@@ -27,6 +27,7 @@
 from unittest import TestCase, SkipTest
 from shutil import copyfile
 from sys import exit, stderr
+
 try:
     from urllib.request import urlretrieve
 except ImportError:
@@ -37,23 +38,7 @@
 from neo4j import GraphDatabase
 from neo4j.exceptions import AuthError
 
-from test.env import NEO4J_SERVER_PACKAGE, NEO4J_USER, NEO4J_PASSWORD
-from test.integration.tools import ServerVersion
-
-
-def copy_dist(source, target):
-    if isfile(target) and "SNAPSHOT" not in basename(source):
-        return target
-    try:
-        makedirs(dirname(target))
-    except OSError:
-        pass
-    if source.startswith("http:"):
-        stderr.write("Downloading package from {}\n".format(source))
-        urlretrieve(source, target)
-        return target
-    else:
-        return copyfile(source, target)
+from test.env import NEO4J_USER, NEO4J_PASSWORD, NEO4J_SERVER_URI
 
 
 def is_listening(address):
@@ -67,65 +52,10 @@ def is_listening(address):
         return True
 
 
-class GraphDatabaseServer(object):
-
-    bolt_port = 7687
-    bolt_address = ("localhost", bolt_port)
-
-    bolt_uri = "bolt://%s:%d" % bolt_address
-    bolt_routing_uri = "bolt+routing://%s:%d" % bolt_address
-
-    user = NEO4J_USER or "test"
-    password = NEO4J_PASSWORD or "test"
-    auth_token = (user, password)
-
-    controller = None
-    dist_path = path_join(dirname(__file__), "dist")
-    run_path = path_join(dirname(__file__), "run")
-
-    server_package = NEO4J_SERVER_PACKAGE
-    local_server_package = path_join(dist_path, basename(server_package)) if server_package else None
-
-    @classmethod
-    def server_version_info(cls):
-        with GraphDatabase.driver(cls.bolt_uri, auth=cls.auth_token) as driver:
-            with driver.session() as session:
-                full_version = session.run("RETURN 1").summary().server.version
-                return ServerVersion.from_str(full_version)
-
-    @classmethod
-    def at_least_version(cls, major, minor):
-        return cls.server_version_info().at_least_version(major, minor)
-
-    @classmethod
-    def delete_known_hosts_file(cls):
-        known_hosts = path_join(expanduser("~"), ".neo4j", "known_hosts")
-        if isfile(known_hosts):
-            remove(known_hosts)
-
-    @classmethod
-    def _start_server(cls, package):
-        try:
-            makedirs(cls.run_path)
-        except OSError:
-            pass
-        if platform.system() == "Windows":
-            controller_class = WindowsController
-        else:
-            controller_class = UnixController
-        home = realpath(controller_class.extract(package, cls.run_path))
-        cls.controller = controller_class(home, 1)
-        if NEO4J_USER is None:
-            cls.controller.create_user(cls.user, cls.password)
-            cls.controller.set_user_role(cls.user, "admin")
-        cls.controller.start()
-
-    @classmethod
-    def _stop_server(cls):
-        if cls.controller is not None:
-            cls.controller.stop()
-            if NEO4J_USER is None:
-                pass  # TODO: delete user
+class RemoteGraphDatabaseServer(object):
+    server_uri = NEO4J_SERVER_URI or "bolt://localhost:7687"
+    auth_token = (NEO4J_USER or "neo4j", NEO4J_PASSWORD)
+    encrypted = NEO4J_SERVER_URI is not None
 
     def __enter__(self):
         self.start()
@@ -136,22 +66,15 @@ def __exit__(self, exc_type, exc_value, traceback):
 
     @classmethod
     def start(cls):
-        if is_listening(cls.bolt_address):
-            stderr.write("Using existing server listening on port {}\n".format(cls.bolt_port))
-            with GraphDatabase.driver(cls.bolt_uri, auth=cls.auth_token) as driver:
-                try:
-                    with driver.session():
-                        pass
-                except AuthError as error:
-                    stderr.write("{}\n".format(error))
-                    exit(1)
-            return
-        if cls.server_package is None:
-            raise RuntimeError("No Neo4j server available for %s" % cls.__name__)
-        stderr.write("Using server from package {}\n".format(cls.server_package))
-        package = copy_dist(cls.server_package, cls.local_server_package)
-        cls._start_server(package)
+        with GraphDatabase.driver(cls.server_uri, auth=cls.auth_token, encrypted=cls.encrypted) as driver:
+            try:
+                with driver.session():
+                    print("Using existing remote server {}\n".format(cls.server_uri))
+                    return
+            except AuthError as error:
+                raise RuntimeError("Failed to authenticate (%s)" % error)
+        raise SkipTest("No remote Neo4j server available for %s" % cls.__name__)
 
     @classmethod
     def stop(cls):
-        cls._stop_server()
+        pass

tox-performance.ini

@@ -0,0 +1,17 @@
+[tox]
+envlist =
+    py34
+    py35
+    py36
+
+[testenv]
+passenv =
+    NEO4J_USER
+    NEO4J_PASSWORD
+    NEO4J_URI
+commands =
+    python setup.py develop
+    pip install --upgrade -r {toxinidir}/test/requirements.txt
+    coverage erase
+    coverage run -m pytest -v {posargs} test/performance
+    coverage report

tox.ini

@@ -15,9 +15,10 @@ passenv =
     TEAMCITY_USER
     TEAMCITY_PASSWORD
     JAVA_HOME
+    NEO4J_URI
 commands =
     python setup.py develop
     pip install --upgrade -r {toxinidir}/test/requirements.txt
     coverage erase
-    coverage run -m pytest -v {posargs} test/unit test/stub test/integration #test/performance
-    coverage report
+    coverage run -m pytest -v {posargs} test/unit test/stub test/integration
+    coverage report