def test_spark_analytic_query(self):
generate_classic(self.session)
spark_master = find_spark_master(self.session)
# Run multipltle times to ensure we don't round robin
for i in range(3):
to_run = SimpleGraphStatement("g.V().count()")
rs = self.session.execute_graph(to_run, execution_profile=EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT)
self.assertEqual(rs[0].value, 6)
self.assertEqual(rs.response_future._current_host.address, spark_master)
def test_graph_classic_path(self):
"""
Test to validate that the path version of the result type is generated correctly. It also
tests basic path results as that is not covered elsewhere
@since 1.0.0
@jira_ticket PYTHON-479
@expected_result path object should be unpacked correctly including all nested edges and verticies
@test_category dse graph
"""
generate_classic(self.session)
rs = self.session.execute_graph("g.V().hasLabel('person').has('name', 'marko').as('a').outE('knows').inV().as('c', 'd').outE('created').as('e', 'f', 'g').inV().path()")
rs_list = list(rs)
self.assertEqual(len(rs_list), 2)
for result in rs_list:
path = result.as_path()
validate_path_result_type(self, path)
def test_graph_profile(self):
"""
Test verifying various aspects of graph config properties.
@since 1.0.0
@jira_ticket PYTHON-570
@test_category dse graph
"""
generate_classic(self.session)
# Create variou execution policies
exec_dif_factory = GraphExecutionProfile(row_factory=single_object_row_factory)
exec_dif_factory.graph_options.graph_name = self.graph_name
exec_dif_lbp = GraphExecutionProfile(load_balancing_policy=WhiteListRoundRobinPolicy(['127.0.0.1']))
exec_dif_lbp.graph_options.graph_name = self.graph_name
exec_bad_lbp = GraphExecutionProfile(load_balancing_policy=WhiteListRoundRobinPolicy(['127.0.0.2']))
exec_dif_lbp.graph_options.graph_name = self.graph_name
exec_short_timeout = GraphExecutionProfile(request_timeout=1, load_balancing_policy=WhiteListRoundRobinPolicy(['127.0.0.1']))
exec_short_timeout.graph_options.graph_name = self.graph_name
# Add a single exection policy on cluster creation
local_cluster = Cluster(protocol_version=PROTOCOL_VERSION, execution_profiles={"exec_dif_factory": exec_dif_factory})
local_session = local_cluster.connect()
rs1 = self.session.execute_graph('g.V()')
rs2 = local_session.execute_graph('g.V()', execution_profile='exec_dif_factory')
# Verify default and non default policy works
self.assertFalse(isinstance(rs2[0], Vertex))
self.assertTrue(isinstance(rs1[0], Vertex))
# Add other policies validate that lbp are honored
local_cluster.add_execution_profile("exec_dif_ldp", exec_dif_lbp)
local_session.execute_graph('g.V()', execution_profile="exec_dif_ldp")
local_cluster.add_execution_profile("exec_bad_lbp", exec_bad_lbp)
with self.assertRaises(NoHostAvailable):
local_session.execute_graph('g.V()', execution_profile="exec_bad_lbp")
# Try with missing EP
with self.assertRaises(ValueError):
local_session.execute_graph('g.V()', execution_profile='bad_exec_profile')
# Validate that timeout is honored
local_cluster.add_execution_profile("exec_short_timeout", exec_short_timeout)
with self.assertRaises(OperationTimedOut):
local_session.execute_graph('java.util.concurrent.TimeUnit.MILLISECONDS.sleep(2000L);', execution_profile='exec_short_timeout')
def test_classic_graph(self):
"""
Test to validate that basic graph generation, and vertex and edges are surfaced correctly
Creates a simple classic tinkerpot graph, and iterates over the the vertices and edges
ensureing that each one is correct. See reference graph here
http://www.tinkerpop.com/docs/3.0.0.M1/
@since 1.0.0
@jira_ticket PYTHON-457
@expected_result graph should generate and all vertices and edge results should be
@test_category dse graph
"""
generate_classic(self.session)
rs = self.session.execute_graph('g.V()')
for vertex in rs:
validate_classic_vertex(self, vertex)
rs = self.session.execute_graph('g.E()')
for edge in rs:
validate_classic_edge(self, edge)
def test_connect_with_kerberos_and_graph(self):
"""
This tests will attempt to authenticate with a user and execute a graph query
@since 1.0.0
@jira_ticket PYTHON-457
@test_category dse auth
@expected_result Client should be able to connect and run a basic graph query with authentication
"""
self.refresh_kerberos_tickets(self.cassandra_keytab, "*****@*****.**", self.krb_conf)
auth_provider = DSEGSSAPIAuthProvider(service='dse', qops=["auth"])
rs = self.connect_and_query(auth_provider)
self.assertIsNotNone(rs)
reset_graph(self.session, self._testMethodName.lower())
profiles = self.cluster.profile_manager.profiles
profiles[EXEC_PROFILE_GRAPH_DEFAULT].graph_options.graph_name = self._testMethodName.lower()
generate_classic(self.session)
rs = self.session.execute_graph('g.V()')
self.assertIsNotNone(rs)
def test_basic_query(self):
"""
Test to validate that basic graph query results can be executed with a sane result set.
Creates a simple classic tinkerpot graph, and attempts to find all vertices
related the vertex marco, that have a label of knows.
See reference graph here
http://www.tinkerpop.com/docs/3.0.0.M1/
@since 1.0.0
@jira_ticket PYTHON-457
@expected_result graph should find two vertices related to marco via 'knows' edges.
@test_category dse graph
"""
generate_classic(self.session)
rs = self.session.execute_graph('''g.V().has('name','marko').out('knows').values('name')''')
self.assertFalse(rs.has_more_pages)
results_list = [result.value for result in rs.current_rows]
self.assertEqual(len(results_list), 2)
self.assertIn('vadas', results_list)
self.assertIn('josh', results_list)
def test_result_forms(self):
"""
Test to validate that geometric types function correctly
Creates a very simple graph, and tries to insert a simple point type
@since 1.0.0
@jira_ticket DSP-8087
@expected_result json types assoicated with insert is parsed correctly
@test_category dse graph
"""
generate_classic(self.session)
rs = list(self.session.execute_graph('g.V()'))
self.assertGreater(len(rs), 0, "Result set was empty this was not expected")
for v in rs:
validate_classic_vertex(self, v)
rs = list(self.session.execute_graph('g.E()'))
self.assertGreater(len(rs), 0, "Result set was empty this was not expected")
for e in rs:
validate_classic_edge(self, e)