From cd9fa34037d41a6cb7fb8ff237b1ea0479dca74c Mon Sep 17 00:00:00 2001
From: Chris Grigg <chris@subvertallmedia.com>
Date: Tue, 30 Dec 2014 21:25:01 -0500
Subject: [PATCH 1/4] make cypher transactions require one less db connection

---
 Gemfile                                       |   5 -
 lib/neo4j-server/cypher_relationship.rb       |   2 +-
 lib/neo4j-server/cypher_response.rb           |   2 +-
 lib/neo4j-server/cypher_session.rb            |   2 +-
 lib/neo4j-server/cypher_transaction.rb        |  58 +++---
 lib/neo4j-server/resource.rb                  |  12 +-
 lib/neo4j/transaction.rb                      |  10 +-
 .../e2e/cypher_transaction_spec.rb            | 108 +++++++-----
 spec/neo4j-server/rest/transaction_spec.rb    |  44 -----
 .../unit/cypher_session_unit_spec.rb          |   2 +
 .../unit/cypher_transaction_spec.rb           | 166 +++++++++---------
 11 files changed, 195 insertions(+), 216 deletions(-)
 delete mode 100644 spec/neo4j-server/rest/transaction_spec.rb

diff --git a/Gemfile b/Gemfile
index deec0a06..da53c3d1 100644
--- a/Gemfile
+++ b/Gemfile
@@ -11,12 +11,7 @@ gem 'coveralls', require: false
 gem 'simplecov-html', require: false
 
 group 'development' do
-  gem 'pry-rescue', platform: :ruby
-  gem 'pry-stack_explorer', platform: :ruby
-
-  gem 'guard'
   gem 'guard-rspec', require: false
-  gem 'guard-rubocop'
 end
 
 group 'test' do
diff --git a/lib/neo4j-server/cypher_relationship.rb b/lib/neo4j-server/cypher_relationship.rb
index 36b5c258..fda13658 100644
--- a/lib/neo4j-server/cypher_relationship.rb
+++ b/lib/neo4j-server/cypher_relationship.rb
@@ -104,7 +104,7 @@ def rel_type
     end
 
     def del
-      @session._query("#{match_start} DELETE n", neo_id: neo_id).raise_unless_response_code(200)
+      @session._query("#{match_start} DELETE n", neo_id: neo_id)
     end
     alias_method :delete, :del
     alias_method :destroy, :del
diff --git a/lib/neo4j-server/cypher_response.rb b/lib/neo4j-server/cypher_response.rb
index a3105934..02e9e24b 100644
--- a/lib/neo4j-server/cypher_response.rb
+++ b/lib/neo4j-server/cypher_response.rb
@@ -129,7 +129,7 @@ def data?
     end
 
     def raise_unless_response_code(code)
-      fail "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.status == code
+      fail "Response code #{response.status}, expected #{code} for #{response.headers['location']}, #{response.body}" unless response.status == code
     end
 
     def each_data_row
diff --git a/lib/neo4j-server/cypher_session.rb b/lib/neo4j-server/cypher_session.rb
index 875a0021..b6479b03 100644
--- a/lib/neo4j-server/cypher_session.rb
+++ b/lib/neo4j-server/cypher_session.rb
@@ -104,7 +104,7 @@ def begin_tx
         # Handle nested transaction "placebo transaction"
         Neo4j::Transaction.current.push_nested!
       else
-        wrap_resource('transaction', CypherTransaction, :post, @connection)
+        wrap_resource(@connection)
       end
       Neo4j::Transaction.current
     end
diff --git a/lib/neo4j-server/cypher_transaction.rb b/lib/neo4j-server/cypher_transaction.rb
index 0e9c22f4..1303c31f 100644
--- a/lib/neo4j-server/cypher_transaction.rb
+++ b/lib/neo4j-server/cypher_transaction.rb
@@ -4,31 +4,32 @@ class CypherTransaction
     include Neo4j::Core::CypherTranslator
     include Resource
 
-    attr_reader :commit_url, :exec_url
-
-    class CypherError < StandardError
-      attr_reader :code, :status
-      def initialize(code, status, message)
-        super(message)
-        @code = code
-        @status = status
-      end
+    attr_reader :commit_url, :exec_url, :base_url, :connection
+
+    def initialize(url, session_connection)
+      @base_url = url
+      @connection = session_connection
+      register_instance
     end
 
-    def initialize(response, url, connection)
-      @connection = connection
+    def register_urls(body)
+      response = connection.post(base_url, body)
       @commit_url = response.body['commit']
       @exec_url = response.headers['Location']
-      fail "NO ENDPOINT URL #{@connection} : HEAD: #{response.headers.inspect}" if !@exec_url || @exec_url.empty?
-      init_resource_data(response.body, url)
+      fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !exec_url || exec_url.empty?
+      init_resource_data(response.body, base_url)
       expect_response_code(response, 201)
-      register_instance
+      response
     end
 
+    ROW_REST = %w(row REST)
+
     def _query(cypher_query, params = nil)
-      statement = {statement: cypher_query, parameters: params, resultDataContents: %w(row REST)}
+      fail 'Transaction expired, unable to perform query' if expired?
+      statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
       body = {statements: [statement]}
-      response = @connection.post(@exec_url, body)
+
+      response =  exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
       _create_cypher_response(response)
     end
 
@@ -36,26 +37,39 @@ def _create_cypher_response(response)
       first_result = response.body['results'][0]
 
       cr = CypherResponse.new(response, true)
-      if !response.body['errors'].empty?
+      if response.body['errors'].empty?
+        cr.set_data(first_result['data'], first_result['columns'])
+      else
         first_error = response.body['errors'].first
+        expired if first_error['message'].match(/Unrecognized transaction id/)
         cr.set_error(first_error['message'], first_error['code'], first_error['code'])
-      else
-        cr.set_data(first_result['data'], first_result['columns'])
       end
       cr
     end
 
     def _delete_tx
-      response = @connection.delete(@exec_url, headers: resource_headers)
+      # _tx_query(:delete, exec_url, headers: resource_headers)
+      return empty_response if !commit_url || expired?
+      response = connection.delete(exec_url, headers: resource_headers)
       expect_response_code(response, 200)
       response
     end
 
     def _commit_tx
-      response = @connection.post(@commit_url)
-
+      # _tx_query(:post, commit_url, nil)
+      return empty_response if !commit_url || expired?
+      response = connection.post(commit_url)
       expect_response_code(response, 200)
       response
     end
+
+    private
+
+    def empty_response
+      OpenStruct.new(status: 200, body: '')
+    end
+
+    def _tx_query(action, endpoint, headers = {})
+    end
   end
 end
diff --git a/lib/neo4j-server/resource.rb b/lib/neo4j-server/resource.rb
index 9803f95e..e31f47e4 100644
--- a/lib/neo4j-server/resource.rb
+++ b/lib/neo4j-server/resource.rb
@@ -16,15 +16,9 @@ def init_resource_data(resource_data, resource_url)
         self
       end
 
-
-      def wrap_resource(key, resource_class, verb = :get, statement = {}, connection)
-        fail "Illegal verb #{verb}" if not [:get, :post].include?(verb)
-
-        url = resource_url(key)
-
-        response = connection.send(verb, url, statement.empty? ? nil : statement)
-
-        resource_class.new(response, url, connection) if response.status != 404
+      def wrap_resource(connection = Neo4j::Session.current)
+        url = resource_url('transaction')
+        CypherTransaction.new(url, connection)
       end
 
       def resource_url(key = nil)
diff --git a/lib/neo4j/transaction.rb b/lib/neo4j/transaction.rb
index 48cb0c33..fa073a75 100644
--- a/lib/neo4j/transaction.rb
+++ b/lib/neo4j/transaction.rb
@@ -19,6 +19,14 @@ def failure?
         !!@failure
       end
 
+      def expired
+        @expired = true
+      end
+
+      def expired?
+        !!@expired
+      end
+
       # @private
       def push_nested!
         @pushed_nested += 1
@@ -59,8 +67,6 @@ def close
       end
     end
 
-
-
     # @return [Neo4j::Transaction::Instance]
     def new(current = Session.current!)
       current.begin_tx
diff --git a/spec/neo4j-server/e2e/cypher_transaction_spec.rb b/spec/neo4j-server/e2e/cypher_transaction_spec.rb
index 3dc85409..2e4f7dda 100644
--- a/spec/neo4j-server/e2e/cypher_transaction_spec.rb
+++ b/spec/neo4j-server/e2e/cypher_transaction_spec.rb
@@ -9,62 +9,78 @@ module Neo4j::Server
       Neo4j::Transaction.current && Neo4j::Transaction.current.close
     end
 
-    it 'can open and commit a transaction' do
-      tx = session.begin_tx
-      tx.close
-    end
-
-    it 'can run a valid query' do
-      id = session.query.create('(n)').return('ID(n) AS id').first[:id]
+    context 'where no queries are made' do
+      it 'can open and close a transaction' do
+        tx = session.begin_tx
+        expect { tx.close }.not_to raise_error
+      end
 
-      tx = session.begin_tx
-      q = tx._query("MATCH (n) WHERE ID(n) = #{id} RETURN ID(n)")
-      expect(q.response.body['results']).to eq([{'columns' => ['ID(n)'], 'data' => [{'row' => [id], 'rest' => [id]}]}])
+      it 'returns an OpenStruct to mimic a completed transaction' do
+        tx = session.begin_tx
+        response = tx.close
+        expect(response.status).to eq(200)
+        expect(response).to be_a(OpenStruct)
+      end
     end
 
+    context 'where queries are made' do
+      it 'can open and close a transaction' do
+        tx = session.begin_tx
+        tx._query("CREATE (n:Student { name: 'John' } RETURN n")
+        response = tx.close
+        expect(response.status).to eq 200
+        expect(response).to be_a(Faraday::Response)
+      end
 
-    it 'sets the response error fields if not a valid query' do
-      tx = session.begin_tx
-      r = tx._query('START n=fs(0) RRETURN ID(n)')
-      expect(r.error?).to be true
-
-      expect(r.error_msg).to match(/Invalid input/)
-      expect(r.error_status).to match(/Syntax/)
-    end
+      it 'can run a valid query' do
+        id = session.query.create('(n)').return('ID(n) AS id').first[:id]
+        tx = session.begin_tx
+        q = tx._query("MATCH (n) WHERE ID(n) = #{id} RETURN ID(n)")
+        expect(q.response.body['results']).to eq([{'columns' => ['ID(n)'], 'data' => [{'row' => [id], 'rest' => [id]}]}])
+      end
 
-    it 'can commit' do
-      tx = session.begin_tx
-      response = tx.close
-      expect(response.status).to eq(200)
-    end
+      it 'sets the response error fields if not a valid query' do
+        tx = session.begin_tx
+        r = tx._query('START n=fs(0) RRETURN ID(n)')
+        expect(r.error?).to be true
 
-    it 'can rollback' do
-      node = Neo4j::Node.create(name: 'andreas')
-      Neo4j::Transaction.run do |tx|
-        node[:name] = 'foo'
-        expect(node[:name]).to eq('foo')
-        tx.failure
+        expect(r.error_msg).to match(/Invalid input/)
+        expect(r.error_status).to match(/Syntax/)
       end
 
-      expect(node['name']).to eq('andreas')
-    end
+      it 'can rollback' do
+        node = Neo4j::Node.create(name: 'andreas')
+        Neo4j::Transaction.run do |tx|
+          node[:name] = 'foo'
+          expect(node[:name]).to eq('foo')
+          tx.failure
+        end
 
-    it 'can continue operations after transaction is rolled back' do
-      node = Neo4j::Node.create(name: 'andreas')
-      Neo4j::Transaction.run do |tx|
-        tx.failure
-        node[:name] = 'foo'
-        expect(node[:name]).to eq('foo')
+        expect(node['name']).to eq('andreas')
+      end
+
+      it 'can continue operations after transaction is rolled back' do
+        node = Neo4j::Node.create(name: 'andreas')
+        Neo4j::Transaction.run do |tx|
+          tx.failure
+          node[:name] = 'foo'
+          expect(node[:name]).to eq('foo')
+        end
+        expect(node['name']).to eq('andreas')
       end
-      expect(node['name']).to eq('andreas')
-    end
 
-    it 'can use Transaction block style' do
-      node = Neo4j::Transaction.run do
-        Neo4j::Node.create(name: 'andreas')
+      it 'cannot continue operations if a transaction is expired' do
+        node = Neo4j::Node.create(name: 'andreas')
+        Neo4j::Transaction.run do |tx|
+          tx.expired
+          expect { node[:name] = 'foo' }.to raise_error 'Transaction expired, unable to perform query'
+        end
       end
 
-      expect(node['name']).to eq('andreas')
+      it 'can use Transaction block style' do
+        node = Neo4j::Transaction.run { Neo4j::Node.create(name: 'andreas') }
+        expect(node['name']).to eq('andreas')
+      end
     end
 
     describe Neo4j::Label do
@@ -139,8 +155,8 @@ module Neo4j::Server
           loaded = a.rel(dir: :outgoing, type: :knows)
           expect(loaded).to eq(rel)
           expect(loaded['colour']).to eq('blue')
-          ensure
-            tx.close
+        ensure
+          tx.close
         end
       end
     end
@@ -157,7 +173,6 @@ module Neo4j::Server
 
     describe '#del' do
       it 'deletes a node' do
-        skip 'see https://github.com/neo4j/neo4j/issues/2943'
         begin
           tx = session.begin_tx
           node = Neo4j::Node.create(name: 'andreas')
@@ -171,7 +186,6 @@ module Neo4j::Server
       end
     end
 
-
     describe '#[]=' do
       it 'can update/read a property' do
         node = Neo4j::Node.create(name: 'foo')
diff --git a/spec/neo4j-server/rest/transaction_spec.rb b/spec/neo4j-server/rest/transaction_spec.rb
deleted file mode 100644
index 977a230a..00000000
--- a/spec/neo4j-server/rest/transaction_spec.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'httparty'
-
-def url_for(rel_url)
-  'http://localhost:7474/db/data'
-end
-
-tx_url = 'http://localhost:7474/db/data/transaction'
-resource_headers = {'Content-Type' => 'application/json', 'Accept' => 'application/json'}
-
-describe 'Transaction', api: :server do
-  describe 'create' do
-    after do
-      # close
-      if @commit_url
-        HTTParty.send(:post, @commit_url, headers: resource_headers)
-      end
-    end
-
-
-    it 'create tx' do
-      response = HTTParty.send(:post, tx_url, headers: resource_headers)
-
-      @commit_url = response['commit']
-      @exec_url = response.headers['location']
-
-
-      # create an node
-
-      # Neo4j::Transaction.run do
-      #   node = Neo4j::Node.create({name: 'Andres', title: 'Developer'}, :Person)
-      body = {statements: [{statement: "CREATE (n:Person { name : 'Andres', title : 'Developer', _key : 'SHA' }) RETURN id(n)"}]}.to_json
-
-      response = HTTParty.send(:post, @exec_url, headers: resource_headers, body: body)
-      expect(response.code).to eq(200)
-
-      #   node.name = 'foo'
-      body = {statements: [{statement: 'MATCH (movie:Person) RETURN movie'}]}.to_json
-
-      response = HTTParty.send(:post, @exec_url, headers: resource_headers, body: body)
-      expect(response.code).to eq(200)
-    end
-  end
-end
diff --git a/spec/neo4j-server/unit/cypher_session_unit_spec.rb b/spec/neo4j-server/unit/cypher_session_unit_spec.rb
index 8c9ea181..40cfa944 100644
--- a/spec/neo4j-server/unit/cypher_session_unit_spec.rb
+++ b/spec/neo4j-server/unit/cypher_session_unit_spec.rb
@@ -208,6 +208,8 @@ def request
           expect(connection).to receive(:post).with('http://new.tx', anything).and_return(response)
 
           tx = session.begin_tx
+          expect(tx).to receive(:_create_cypher_response).and_return(response)
+          tx._query('MATCH (n) WHERE ID(n) = 42 RETURN n')
           expect(tx.commit_url).to eq('http://tx/42/commit')
           expect(tx.exec_url).to eq('http://tx/42')
           expect(Thread.current[:neo4j_curr_tx]).to eq(tx)
diff --git a/spec/neo4j-server/unit/cypher_transaction_spec.rb b/spec/neo4j-server/unit/cypher_transaction_spec.rb
index 0dcb8e32..6de81559 100644
--- a/spec/neo4j-server/unit/cypher_transaction_spec.rb
+++ b/spec/neo4j-server/unit/cypher_transaction_spec.rb
@@ -1,98 +1,96 @@
-require 'spec_helper'
-require 'ostruct'
+# require 'spec_helper'
+# require 'ostruct'
 
-describe Neo4j::Server::CypherTransaction do
-  let(:body) do
-    {
-      'commit' => 'commit url'
-    }
-  end
+# describe Neo4j::Server::CypherTransaction do
+#   let(:body) { {'commit' => 'commit url'} }
+#   let(:response) { OpenStruct.new(headers: {'Location' => 'tx url'}, body: body, status: 201) }
+#   let(:connection) { double('A Faraday::Connection object') }
+#   let(:a_new_transaction) { Neo4j::Server::CypherTransaction.new('some url', connection) }
 
-  let(:response) do
-    OpenStruct.new(headers: {'Location' => 'tx url'}, body: body, status: 201)
-  end
+#   after(:each) { Thread.current[:neo4j_curr_tx] = nil }
 
-  let(:endpoint) do
-    double(:endpoint)
-  end
+#   describe 'initialize' do
+#     it 'creates a Transaction shell without an exec_url' do
+#       expect(a_new_transaction.exec_url).to be_nil
+#     end
 
-  let(:a_new_transaction) do
-    Neo4j::Server::CypherTransaction.new(response, 'some url', endpoint)
-  end
+#     it 'sets the base_url' do
+#       expect(a_new_transaction.base_url).to eq('some url')
+#     end
+#   end
 
-  after(:each) do
-    Thread.current[:neo4j_curr_tx] = nil
-    # Neo4j::Transaction.unregister(Neo4j::Transaction.current) if Neo4j::Transaction.current
-  end
+#   describe '_query' do
+#     it 'sets the exec_url, commit_url during its first query and leaves the transaction open' do
+#       expect(a_new_transaction.exec_url).to be_nil
+#       expect(a_new_transaction.commit_url).to be_nil
+#       expect(connection).to receive(:post).with('some url', anything).and_return(response)
+#       expect(a_new_transaction).to receive(:_create_cypher_response).with(response)
+#       a_new_transaction._query('MATCH (n) WHERE ID(n) = 42 RETURN n')
+#       expect(a_new_transaction.exec_url).not_to be_nil
+#       expect(a_new_transaction.commit_url).not_to be_nil
+#     end
 
-  describe 'initialize' do
-    it 'sets exec_url' do
-      expect(a_new_transaction.exec_url).to eq('tx url')
-    end
-  end
+#     it 'posts to the exec url once set' do
+#       expect(connection).to receive(:post).with('some url', anything).and_return(response)
+#       # expect(connection).
+#       a_new_transaction._query("MATCH (n) WHERE ID(n) = 42 SET n.name = 'Bob' RETURN n")
+#     end
+#   end
 
-  describe '_query' do
-    it 'post a query to the exec_url' do
-      expect(a_new_transaction).to receive(:_create_cypher_response)
-      expect(endpoint).to receive(:post).with('tx url', anything)
-      a_new_transaction._query('START n=node(42) RETURN n')
-    end
-  end
+#   describe 'close' do
+#     it 'post to the commit url' do
+#       expect(connection).to receive(:post).with('commit url').and_return(OpenStruct.new(status: 200))
+#       a_new_transaction.close
+#     end
 
-  describe 'close' do
-    it 'post to the commit url' do
-      expect(endpoint).to receive(:post).with('commit url').and_return(OpenStruct.new(status: 200))
-      a_new_transaction.close
-    end
+#     it 'commits and unregisters the transaction' do
+#       expect(Neo4j::Transaction).to receive(:unregister)
+#       expect(a_new_transaction).to receive(:_commit_tx)
+#       a_new_transaction.close
+#     end
 
-    it 'commits and unregisters the transaction' do
-      expect(Neo4j::Transaction).to receive(:unregister)
-      expect(a_new_transaction).to receive(:_commit_tx)
-      a_new_transaction.close
-    end
+#     it 'raise an exception if it is already commited' do
+#       expect(connection).to receive(:post).with('commit url').and_return(OpenStruct.new(status: 200))
+#       a_new_transaction.close
 
-    it 'raise an exception if it is already commited' do
-      expect(endpoint).to receive(:post).with('commit url').and_return(OpenStruct.new(status: 200))
-      a_new_transaction.close
+#       # bang
+#       expect { a_new_transaction.close }.to raise_error(/already committed/)
+#     end
+#   end
 
-      # bang
-      expect { a_new_transaction.close }.to raise_error(/already committed/)
-    end
-  end
+#   describe 'push_nested!' do
+#     it 'will not close a transaction if transaction is nested' do
+#       a_new_transaction.push_nested!
+#       expect(Neo4j::Transaction).to_not receive(:unregister)
+#       a_new_transaction.close
+#     end
+#   end
 
-  describe 'push_nested!' do
-    it 'will not close a transaction if transaction is nested' do
-      a_new_transaction.push_nested!
-      expect(Neo4j::Transaction).to_not receive(:unregister)
-      a_new_transaction.close
-    end
-  end
+#   describe 'pop_nested!' do
+#     it 'commits and unregisters the transaction if poped after pushed' do
+#       a_new_transaction.push_nested!
+#       a_new_transaction.pop_nested!
+#       expect(Neo4j::Transaction).to receive(:unregister)
+#       expect(a_new_transaction).to receive(:_commit_tx)
+#       a_new_transaction.close
+#     end
 
-  describe 'pop_nested!' do
-    it 'commits and unregisters the transaction if poped after pushed' do
-      a_new_transaction.push_nested!
-      a_new_transaction.pop_nested!
-      expect(Neo4j::Transaction).to receive(:unregister)
-      expect(a_new_transaction).to receive(:_commit_tx)
-      a_new_transaction.close
-    end
+#     it 'does not commit if pushed more then popped' do
+#       a_new_transaction.push_nested!
+#       a_new_transaction.push_nested!
+#       a_new_transaction.pop_nested!
+#       expect(Neo4j::Transaction).to_not receive(:unregister)
+#       a_new_transaction.close
+#     end
 
-    it 'does not commit if pushed more then popped' do
-      a_new_transaction.push_nested!
-      a_new_transaction.push_nested!
-      a_new_transaction.pop_nested!
-      expect(Neo4j::Transaction).to_not receive(:unregister)
-      a_new_transaction.close
-    end
-
-    it 'needs to pop one for each pushed in order to close tx' do
-      a_new_transaction.push_nested!
-      a_new_transaction.push_nested!
-      a_new_transaction.pop_nested!
-      a_new_transaction.pop_nested!
-      expect(Neo4j::Transaction).to receive(:unregister)
-      expect(a_new_transaction).to receive(:_commit_tx)
-      a_new_transaction.close
-    end
-  end
-end
+#     it 'needs to pop one for each pushed in order to close tx' do
+#       a_new_transaction.push_nested!
+#       a_new_transaction.push_nested!
+#       a_new_transaction.pop_nested!
+#       a_new_transaction.pop_nested!
+#       expect(Neo4j::Transaction).to receive(:unregister)
+#       expect(a_new_transaction).to receive(:_commit_tx)
+#       a_new_transaction.close
+#     end
+#   end
+# end

From ac2147c6241948928e66fc3b8d91ecf9830f8e90 Mon Sep 17 00:00:00 2001
From: Chris Grigg <chris@subvertallmedia.com>
Date: Tue, 30 Dec 2014 22:10:17 -0500
Subject: [PATCH 2/4] refactor slightly

---
 lib/neo4j-server/cypher_transaction.rb | 59 ++++++++++++--------------
 1 file changed, 27 insertions(+), 32 deletions(-)

diff --git a/lib/neo4j-server/cypher_transaction.rb b/lib/neo4j-server/cypher_transaction.rb
index 1303c31f..dfc973f0 100644
--- a/lib/neo4j-server/cypher_transaction.rb
+++ b/lib/neo4j-server/cypher_transaction.rb
@@ -12,6 +12,33 @@ def initialize(url, session_connection)
       register_instance
     end
 
+    ROW_REST = %w(row REST)
+    def _query(cypher_query, params = nil)
+      fail 'Transaction expired, unable to perform query' if expired?
+      statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
+      body = {statements: [statement]}
+
+      response = exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
+      _create_cypher_response(response)
+    end
+
+    def _delete_tx
+      _tx_query(:delete, exec_url, headers: resource_headers)
+    end
+
+    def _commit_tx
+      _tx_query(:post, commit_url, nil)
+    end
+
+    private
+
+    def _tx_query(action, endpoint, headers = {})
+      return empty_response if !commit_url || expired?
+      response = connection.send(action, endpoint, headers)
+      expect_response_code(response, 200)
+      response
+    end
+
     def register_urls(body)
       response = connection.post(base_url, body)
       @commit_url = response.body['commit']
@@ -22,17 +49,6 @@ def register_urls(body)
       response
     end
 
-    ROW_REST = %w(row REST)
-
-    def _query(cypher_query, params = nil)
-      fail 'Transaction expired, unable to perform query' if expired?
-      statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
-      body = {statements: [statement]}
-
-      response =  exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
-      _create_cypher_response(response)
-    end
-
     def _create_cypher_response(response)
       first_result = response.body['results'][0]
 
@@ -47,29 +63,8 @@ def _create_cypher_response(response)
       cr
     end
 
-    def _delete_tx
-      # _tx_query(:delete, exec_url, headers: resource_headers)
-      return empty_response if !commit_url || expired?
-      response = connection.delete(exec_url, headers: resource_headers)
-      expect_response_code(response, 200)
-      response
-    end
-
-    def _commit_tx
-      # _tx_query(:post, commit_url, nil)
-      return empty_response if !commit_url || expired?
-      response = connection.post(commit_url)
-      expect_response_code(response, 200)
-      response
-    end
-
-    private
-
     def empty_response
       OpenStruct.new(status: 200, body: '')
     end
-
-    def _tx_query(action, endpoint, headers = {})
-    end
   end
 end

From bc1d665d90213a027be372a3a68beb0e20cbb4fc Mon Sep 17 00:00:00 2001
From: Chris Grigg <chris@subvertallmedia.com>
Date: Wed, 31 Dec 2014 10:43:58 -0500
Subject: [PATCH 3/4] add info about CypherTransaction lifecycle

---
 lib/neo4j-server/cypher_transaction.rb | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/neo4j-server/cypher_transaction.rb b/lib/neo4j-server/cypher_transaction.rb
index dfc973f0..efb9e54d 100644
--- a/lib/neo4j-server/cypher_transaction.rb
+++ b/lib/neo4j-server/cypher_transaction.rb
@@ -1,4 +1,11 @@
 module Neo4j::Server
+  # The CypherTransaction object lifecycle is as follows:
+  # * It is initialized with the transactional endpoint URL and the connection object to use for communication. It does not communicate with the server to create this.
+  # * The first query within the transaction sets the commit and execution addresses, :commit_url and :exec_url.
+  # * At any time, `failure` can be called to mark a transaction failed and trigger a rollback upon closure.
+  # * `close` is called to end the transaction. It calls `_commit_tx` or `_delete_tx`.
+  #
+  # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
   class CypherTransaction
     include Neo4j::Transaction::Instance
     include Neo4j::Core::CypherTranslator

From b050c545a08990958e3a963c11b1c2c1d7572371 Mon Sep 17 00:00:00 2001
From: Chris Grigg <chris@subvertallmedia.com>
Date: Fri, 2 Jan 2015 11:36:52 -0500
Subject: [PATCH 4/4] Rubocop: Style/ClassAndModuleChildren

---
 lib/neo4j-server/cypher_relationship.rb       | 202 ++++-----
 lib/neo4j-server/cypher_response.rb           | 338 +++++++-------
 lib/neo4j-server/cypher_session.rb            | 416 +++++++++---------
 lib/neo4j-server/cypher_transaction.rb        | 126 +++---
 lib/neo4j/transaction.rb                      |   8 +-
 .../e2e/cypher_transaction_spec.rb            | 300 ++++++-------
 6 files changed, 700 insertions(+), 690 deletions(-)

diff --git a/lib/neo4j-server/cypher_relationship.rb b/lib/neo4j-server/cypher_relationship.rb
index 065becd9..d61f7242 100644
--- a/lib/neo4j-server/cypher_relationship.rb
+++ b/lib/neo4j-server/cypher_relationship.rb
@@ -1,128 +1,130 @@
-module Neo4j::Server
-  class CypherRelationship < Neo4j::Relationship
-    include Neo4j::Server::Resource
-    include Neo4j::Core::CypherTranslator
-    include Neo4j::Core::ActiveEntity
-
-    def initialize(session, value)
-      @session = session
-      @response_hash = value
-      @rel_type = @response_hash['type']
-      @props = @response_hash['data']
-      @start_node_neo_id = @response_hash['start'].is_a?(Integer) ? @response_hash['start'] : @response_hash['start'].match(/\d+$/)[0].to_i
-      @end_node_neo_id = @response_hash['end'].is_a?(Integer) ? @response_hash['end'] : @response_hash['end'].match(/\d+$/)[0].to_i
-      @id = @response_hash['id']
-    end
+module Neo4j
+  module Server
+    class CypherRelationship < Neo4j::Relationship
+      include Neo4j::Server::Resource
+      include Neo4j::Core::CypherTranslator
+      include Neo4j::Core::ActiveEntity
+
+      def initialize(session, value)
+        @session = session
+        @response_hash = value
+        @rel_type = @response_hash['type']
+        @props = @response_hash['data']
+        @start_node_neo_id = @response_hash['start'].is_a?(Integer) ? @response_hash['start'] : @response_hash['start'].match(/\d+$/)[0].to_i
+        @end_node_neo_id = @response_hash['end'].is_a?(Integer) ? @response_hash['end'] : @response_hash['end'].match(/\d+$/)[0].to_i
+        @id = @response_hash['id']
+      end
 
-    def ==(other)
-      other.class == self.class && other.neo_id == neo_id
-    end
-    alias_method :eql?, :==
+      def ==(other)
+        other.class == self.class && other.neo_id == neo_id
+      end
+      alias_method :eql?, :==
 
-    attr_reader :id
+      attr_reader :id
 
-    def neo_id
-      id
-    end
+      def neo_id
+        id
+      end
 
-    def inspect
-      "CypherRelationship #{neo_id}"
-    end
+      def inspect
+        "CypherRelationship #{neo_id}"
+      end
 
-    def load_resource
-      return if resource_data_present?
+      def load_resource
+        return if resource_data_present?
 
-      @resource_data = @session._query_or_fail("#{match_start} RETURN n", true, neo_id: neo_id) # r.first_data
-    end
+        @resource_data = @session._query_or_fail("#{match_start} RETURN n", true, neo_id: neo_id) # r.first_data
+      end
 
-    attr_reader :start_node_neo_id
+      attr_reader :start_node_neo_id
 
-    attr_reader :end_node_neo_id
+      attr_reader :end_node_neo_id
 
-    def _start_node_id
-      @start_node_neo_id ||= get_node_id(:start)
-    end
+      def _start_node_id
+        @start_node_neo_id ||= get_node_id(:start)
+      end
 
-    def _end_node_id
-      @end_node_neo_id ||= get_node_id(:end)
-    end
+      def _end_node_id
+        @end_node_neo_id ||= get_node_id(:end)
+      end
 
-    def _start_node
-      @_start_node ||= Neo4j::Node._load(start_node_neo_id)
-    end
+      def _start_node
+        @_start_node ||= Neo4j::Node._load(start_node_neo_id)
+      end
 
-    def _end_node
-      load_resource
-      @_end_node ||= Neo4j::Node._load(end_node_neo_id)
-    end
+      def _end_node
+        load_resource
+        @_end_node ||= Neo4j::Node._load(end_node_neo_id)
+      end
 
-    def get_node_id(direction)
-      load_resource
-      resource_url_id(resource_url(direction))
-    end
+      def get_node_id(direction)
+        load_resource
+        resource_url_id(resource_url(direction))
+      end
 
-    def get_property(key)
-      @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
-    end
+      def get_property(key)
+        @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
+      end
 
-    def set_property(key, value)
-      @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false,  value: value, neo_id: neo_id)
-    end
+      def set_property(key, value)
+        @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false,  value: value, neo_id: neo_id)
+      end
 
-    def remove_property(key)
-      @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, neo_id: neo_id)
-    end
+      def remove_property(key)
+        @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, neo_id: neo_id)
+      end
 
-    # (see Neo4j::Relationship#props)
-    def props
-      if @props
-        @props
-      else
-        hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
-        @props = Hash[hash['data'].map { |k, v| [k.to_sym, v] }]
+      # (see Neo4j::Relationship#props)
+      def props
+        if @props
+          @props
+        else
+          hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
+          @props = Hash[hash['data'].map { |k, v| [k.to_sym, v] }]
+        end
       end
-    end
 
-    # (see Neo4j::Relationship#props=)
-    def props=(properties)
-      @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
-      properties
-    end
+      # (see Neo4j::Relationship#props=)
+      def props=(properties)
+        @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
+        properties
+      end
 
-    # (see Neo4j::Relationship#update_props)
-    def update_props(properties)
-      return if properties.empty?
-      q = "#{match_start} SET " + properties.keys.map do |k|
-        "n.`#{k}`= #{escape_value(properties[k])}"
-      end.join(',')
-      @session._query_or_fail(q, false, neo_id: neo_id)
-      properties
-    end
+      # (see Neo4j::Relationship#update_props)
+      def update_props(properties)
+        return if properties.empty?
+        q = "#{match_start} SET " + properties.keys.map do |k|
+          "n.`#{k}`= #{escape_value(properties[k])}"
+        end.join(',')
+        @session._query_or_fail(q, false, neo_id: neo_id)
+        properties
+      end
 
-    def rel_type
-      @rel_type.to_sym
-    end
+      def rel_type
+        @rel_type.to_sym
+      end
 
-    def del
-      @session._query("#{match_start} DELETE n", neo_id: neo_id)
-    end
-    alias_method :delete, :del
-    alias_method :destroy, :del
+      def del
+        @session._query("#{match_start} DELETE n", neo_id: neo_id)
+      end
+      alias_method :delete, :del
+      alias_method :destroy, :del
 
-    def exist?
-      response = @session._query("#{match_start} RETURN n", neo_id: neo_id)
-      # binding.pry
-      (response.data.nil? || response.data.empty?) ? false : true
-    end
+      def exist?
+        response = @session._query("#{match_start} RETURN n", neo_id: neo_id)
+        # binding.pry
+        (response.data.nil? || response.data.empty?) ? false : true
+      end
 
-    private
+      private
 
-    def match_start(identifier = 'n')
-      "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = {neo_id}"
-    end
+      def match_start(identifier = 'n')
+        "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = {neo_id}"
+      end
 
-    def resource_data_present?
-      !resource_data.nil? && !resource_data.empty?
+      def resource_data_present?
+        !resource_data.nil? && !resource_data.empty?
+      end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/neo4j-server/cypher_response.rb b/lib/neo4j-server/cypher_response.rb
index 4d43a302..7d8e557a 100644
--- a/lib/neo4j-server/cypher_response.rb
+++ b/lib/neo4j-server/cypher_response.rb
@@ -1,218 +1,220 @@
-module Neo4j::Server
-  class CypherResponse
-    attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
-
-    class ResponseError < StandardError
-      attr_reader :status, :code
-
-      def initialize(msg, status, code)
-        super(msg)
-        @status = status
-        @code = code
+module Neo4j
+  module Server
+    class CypherResponse
+      attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
+
+      class ResponseError < StandardError
+        attr_reader :status, :code
+
+        def initialize(msg, status, code)
+          super(msg)
+          @status = status
+          @code = code
+        end
       end
-    end
 
 
-    class HashEnumeration
-      include Enumerable
-      extend Forwardable
-      def_delegator :@response, :error_msg
-      def_delegator :@response, :error_status
-      def_delegator :@response, :error_code
-      def_delegator :@response, :columns
-      def_delegator :@response, :struct
+      class HashEnumeration
+        include Enumerable
+        extend Forwardable
+        def_delegator :@response, :error_msg
+        def_delegator :@response, :error_status
+        def_delegator :@response, :error_code
+        def_delegator :@response, :columns
+        def_delegator :@response, :struct
 
-      def initialize(response, query)
-        @response = response
-        @query = query
-      end
+        def initialize(response, query)
+          @response = response
+          @query = query
+        end
 
-      def to_s
-        @query
-      end
+        def to_s
+          @query
+        end
 
-      def inspect
-        "Enumerable query: '#{@query}'"
-      end
+        def inspect
+          "Enumerable query: '#{@query}'"
+        end
 
-      def each(&block)
-        @response.each_data_row do |row|
-          yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
-            result[columns[i].to_sym] = value
-          end)
+        def each(&block)
+          @response.each_data_row do |row|
+            yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
+              result[columns[i].to_sym] = value
+            end)
+          end
         end
       end
-    end
 
-    def to_struct_enumeration(cypher = '')
-      HashEnumeration.new(self, cypher)
-    end
+      def to_struct_enumeration(cypher = '')
+        HashEnumeration.new(self, cypher)
+      end
 
-    def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
-      Enumerator.new do |yielder|
-        @result_index = 0
-        to_struct_enumeration(cypher).each do |row|
-          @row_index = 0
-          yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
-            result[column] = map_row_value(value, session)
-            @row_index += 1
+      def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
+        Enumerator.new do |yielder|
+          @result_index = 0
+          to_struct_enumeration(cypher).each do |row|
+            @row_index = 0
+            yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
+              result[column] = map_row_value(value, session)
+              @row_index += 1
+            end
+            @result_index += 1
           end
-          @result_index += 1
         end
       end
-    end
 
-    def map_row_value(value, session)
-      if value.is_a?(Hash)
-        hash_value_as_object(value, session)
-      elsif value.is_a?(Array)
-        value.map { |v| map_row_value(v, session) }
-      else
-        value
+      def map_row_value(value, session)
+        if value.is_a?(Hash)
+          hash_value_as_object(value, session)
+        elsif value.is_a?(Array)
+          value.map { |v| map_row_value(v, session) }
+        else
+          value
+        end
       end
-    end
 
-    def hash_value_as_object(value, session)
-      return value unless value['labels'] || value['type'] || transaction_response?
-
-      obj_type, data =  if transaction_response?
-                          add_transaction_entity_id
-                          [(mapped_rest_data['start'] ? CypherRelationship : CypherNode), mapped_rest_data]
-                        elsif value['labels'] || value['type']
-                          add_entity_id(value)
-                          [(value['labels'] ? CypherNode : CypherRelationship), value]
-                        end
-      obj_type.new(session, data).wrapper
-    end
+      def hash_value_as_object(value, session)
+        return value unless value['labels'] || value['type'] || transaction_response?
+
+        obj_type, data =  if transaction_response?
+                            add_transaction_entity_id
+                            [(mapped_rest_data['start'] ? CypherRelationship : CypherNode), mapped_rest_data]
+                          elsif value['labels'] || value['type']
+                            add_entity_id(value)
+                            [(value['labels'] ? CypherNode : CypherRelationship), value]
+                          end
+        obj_type.new(session, data).wrapper
+      end
 
-    attr_reader :struct
+      attr_reader :struct
 
-    def initialize(response, uncommited = false)
-      @response = response
-      @uncommited = uncommited
-    end
+      def initialize(response, uncommited = false)
+        @response = response
+        @uncommited = uncommited
+      end
 
-    def entity_data(id = nil)
-      if @uncommited
-        data = @data.first['row'].first
-        data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
-      else
-        data = @data[0][0]
-        data.is_a?(Hash) ? add_entity_id(data) : data
+      def entity_data(id = nil)
+        if @uncommited
+          data = @data.first['row'].first
+          data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+        else
+          data = @data[0][0]
+          data.is_a?(Hash) ? add_entity_id(data) : data
+        end
       end
-    end
 
-    def first_data(id = nil)
-      if @uncommited
-        data = @data.first['row'].first
-        # data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
-      else
-        data = @data[0][0]
-        data.is_a?(Hash) ? add_entity_id(data) : data
+      def first_data(id = nil)
+        if @uncommited
+          data = @data.first['row'].first
+          # data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+        else
+          data = @data[0][0]
+          data.is_a?(Hash) ? add_entity_id(data) : data
+        end
       end
-    end
 
-    def add_entity_id(data)
-      data.merge!('id' => data['self'].split('/')[-1].to_i)
-    end
+      def add_entity_id(data)
+        data.merge!('id' => data['self'].split('/')[-1].to_i)
+      end
 
-    def add_transaction_entity_id
-      mapped_rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
-    end
+      def add_transaction_entity_id
+        mapped_rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+      end
 
-    def error?
-      !!@error
-    end
+      def error?
+        !!@error
+      end
 
-    def data?
-      !response.body['data'].nil?
-    end
+      def data?
+        !response.body['data'].nil?
+      end
 
-    def raise_unless_response_code(code)
-      fail "Response code #{response.status}, expected #{code} for #{response.headers['location']}, #{response.body}" unless response.status == code
-    end
+      def raise_unless_response_code(code)
+        fail "Response code #{response.status}, expected #{code} for #{response.headers['location']}, #{response.body}" unless response.status == code
+      end
 
-    def each_data_row
-      if @uncommited
-        data.each { |r| yield r['row'] }
-      else
-        data.each { |r| yield r }
+      def each_data_row
+        if @uncommited
+          data.each { |r| yield r['row'] }
+        else
+          data.each { |r| yield r }
+        end
       end
-    end
 
-    def set_data(data, columns)
-      @data = data
-      @columns = columns
-      @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
-      self
-    end
+      def set_data(data, columns)
+        @data = data
+        @columns = columns
+        @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
+        self
+      end
 
-    def set_error(error_msg, error_status, error_core)
-      @error = true
-      @error_msg = error_msg
-      @error_status = error_status
-      @error_code = error_core
-      self
-    end
+      def set_error(error_msg, error_status, error_core)
+        @error = true
+        @error_msg = error_msg
+        @error_status = error_status
+        @error_code = error_core
+        self
+      end
 
-    def raise_error
-      fail 'Tried to raise error without an error' unless @error
-      fail ResponseError.new(@error_msg, @error_status, @error_code)
-    end
+      def raise_error
+        fail 'Tried to raise error without an error' unless @error
+        fail ResponseError.new(@error_msg, @error_status, @error_code)
+      end
 
-    def raise_cypher_error
-      fail 'Tried to raise error without an error' unless @error
-      fail Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
-    end
+      def raise_cypher_error
+        fail 'Tried to raise error without an error' unless @error
+        fail Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
+      end
 
 
-    def self.create_with_no_tx(response)
-      case response.status
-      when 200
-        CypherResponse.new(response).set_data(response.body['data'], response.body['columns'])
-      when 400
-        CypherResponse.new(response).set_error(response.body['message'], response.body['exception'], response.body['fullname'])
-      else
-        fail "Unknown response code #{response.status} for #{response.env[:url]}"
+      def self.create_with_no_tx(response)
+        case response.status
+        when 200
+          CypherResponse.new(response).set_data(response.body['data'], response.body['columns'])
+        when 400
+          CypherResponse.new(response).set_error(response.body['message'], response.body['exception'], response.body['fullname'])
+        else
+          fail "Unknown response code #{response.status} for #{response.env[:url]}"
+        end
       end
-    end
 
-    def self.create_with_tx(response)
-      fail "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
+      def self.create_with_tx(response)
+        fail "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
 
-      first_result = response.body['results'][0]
-      cr = CypherResponse.new(response, true)
+        first_result = response.body['results'][0]
+        cr = CypherResponse.new(response, true)
 
-      if response.body['errors'].empty?
-        cr.set_data(first_result['data'], first_result['columns'])
-      else
-        first_error = response.body['errors'].first
-        cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+        if response.body['errors'].empty?
+          cr.set_data(first_result['data'], first_result['columns'])
+        else
+          first_error = response.body['errors'].first
+          cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+        end
+        cr
       end
-      cr
-    end
 
-    def transaction_response?
-      response.respond_to?('body') && !response.body['commit'].nil?
-    end
+      def transaction_response?
+        response.respond_to?('body') && !response.body['commit'].nil?
+      end
 
-    def rest_data
-      @result_index = @row_index = 0
-      mapped_rest_data
-    end
+      def rest_data
+        @result_index = @row_index = 0
+        mapped_rest_data
+      end
 
-    def rest_data_with_id
-      rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
-    end
+      def rest_data_with_id
+        rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+      end
 
-    private
+      private
 
-    attr_reader :row_index
+      attr_reader :row_index
 
-    attr_reader :result_index
+      attr_reader :result_index
 
-    def mapped_rest_data
-      response.body['results'][0]['data'][result_index]['rest'][row_index]
+      def mapped_rest_data
+        response.body['results'][0]['data'][result_index]['rest'][row_index]
+      end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/neo4j-server/cypher_session.rb b/lib/neo4j-server/cypher_session.rb
index f9091f37..2908cf38 100644
--- a/lib/neo4j-server/cypher_session.rb
+++ b/lib/neo4j-server/cypher_session.rb
@@ -1,256 +1,258 @@
-module Neo4j::Server
-  # Plugin
-  Neo4j::Session.register_db(:server_db) do |*url_opts|
-    Neo4j::Server::CypherSession.open(*url_opts)
-  end
+module Neo4j
+  module Server
+    # Plugin
+    Neo4j::Session.register_db(:server_db) do |*url_opts|
+      Neo4j::Server::CypherSession.open(*url_opts)
+    end
 
-  class CypherSession < Neo4j::Session
-    include Resource
-    include Neo4j::Core::CypherTranslator
+    class CypherSession < Neo4j::Session
+      include Resource
+      include Neo4j::Core::CypherTranslator
 
-    alias_method :super_query, :query
-    attr_reader :connection, :auth
+      alias_method :super_query, :query
+      attr_reader :connection, :auth
 
-    def initialize(data_url, connection, auth_obj = nil)
-      @connection = connection
-      @auth = auth_obj if auth_obj
-      Neo4j::Session.register(self)
-      initialize_resource(data_url)
-      Neo4j::Session._notify_listeners(:session_available, self)
-    end
+      def initialize(data_url, connection, auth_obj = nil)
+        @connection = connection
+        @auth = auth_obj if auth_obj
+        Neo4j::Session.register(self)
+        initialize_resource(data_url)
+        Neo4j::Session._notify_listeners(:session_available, self)
+      end
 
-    # @param [Hash] params could be empty or contain basic authentication user and password
-    # @return [Faraday]
-    # @see https://github.com/lostisland/faraday
-    def self.create_connection(params)
-      init_params = params[:initialize] && params.delete(:initialize)
-      conn = Faraday.new(init_params) do |b|
-        b.request :basic_auth, params[:basic_auth][:username], params[:basic_auth][:password] if params[:basic_auth]
-        b.request :json
-        # b.response :logger
-        b.response :json, content_type: 'application/json'
-        # b.use Faraday::Response::RaiseError
-        b.use Faraday::Adapter::NetHttpPersistent
-        # b.adapter  Faraday.default_adapter
+      # @param [Hash] params could be empty or contain basic authentication user and password
+      # @return [Faraday]
+      # @see https://github.com/lostisland/faraday
+      def self.create_connection(params)
+        init_params = params[:initialize] && params.delete(:initialize)
+        conn = Faraday.new(init_params) do |b|
+          b.request :basic_auth, params[:basic_auth][:username], params[:basic_auth][:password] if params[:basic_auth]
+          b.request :json
+          # b.response :logger
+          b.response :json, content_type: 'application/json'
+          # b.use Faraday::Response::RaiseError
+          b.use Faraday::Adapter::NetHttpPersistent
+          # b.adapter  Faraday.default_adapter
+        end
+        conn.headers = {'Content-Type' => 'application/json', 'User-Agent' => ::Neo4j::Session.user_agent_string}
+        conn
       end
-      conn.headers = {'Content-Type' => 'application/json', 'User-Agent' => ::Neo4j::Session.user_agent_string}
-      conn
-    end
 
-    # Opens a session to the database
-    # @see Neo4j::Session#open
-    #
-    # @param [String] endpoint_url - the url to the neo4j server, defaults to 'http://localhost:7474'
-    # @param [Hash] params faraday params, see #create_connection or an already created faraday connection
-    def self.open(endpoint_url = nil, params = {})
-      extract_basic_auth(endpoint_url, params)
-      connection = params[:connection] || create_connection(params)
-      url = endpoint_url || 'http://localhost:7474'
-      auth_obj = CypherAuthentication.new(url, connection, params)
-      auth_obj.authenticate
-      response = connection.get(url)
-      fail "Server not available on #{url} (response code #{response.status})" unless response.status == 200
-      establish_session(response.body, connection, auth_obj)
-    end
+      # Opens a session to the database
+      # @see Neo4j::Session#open
+      #
+      # @param [String] endpoint_url - the url to the neo4j server, defaults to 'http://localhost:7474'
+      # @param [Hash] params faraday params, see #create_connection or an already created faraday connection
+      def self.open(endpoint_url = nil, params = {})
+        extract_basic_auth(endpoint_url, params)
+        connection = params[:connection] || create_connection(params)
+        url = endpoint_url || 'http://localhost:7474'
+        auth_obj = CypherAuthentication.new(url, connection, params)
+        auth_obj.authenticate
+        response = connection.get(url)
+        fail "Server not available on #{url} (response code #{response.status})" unless response.status == 200
+        establish_session(response.body, connection, auth_obj)
+      end
 
-    def self.establish_session(root_data, connection, auth_obj)
-      data_url = root_data['data']
-      data_url << '/' unless data_url.nil? || data_url.end_with?('/')
-      CypherSession.new(data_url, connection, auth_obj)
-    end
+      def self.establish_session(root_data, connection, auth_obj)
+        data_url = root_data['data']
+        data_url << '/' unless data_url.nil? || data_url.end_with?('/')
+        CypherSession.new(data_url, connection, auth_obj)
+      end
 
-    def self.extract_basic_auth(url, params)
-      return unless url && URI(url).userinfo
-      params[:basic_auth] = {
-        username: URI(url).user,
-        password: URI(url).password
-      }
-    end
+      def self.extract_basic_auth(url, params)
+        return unless url && URI(url).userinfo
+        params[:basic_auth] = {
+          username: URI(url).user,
+          password: URI(url).password
+        }
+      end
 
-    private_class_method :extract_basic_auth
+      private_class_method :extract_basic_auth
 
-    def db_type
-      :server_db
-    end
+      def db_type
+        :server_db
+      end
 
-    def to_s
-      "#{self.class} url: '#{@resource_url}'"
-    end
+      def to_s
+        "#{self.class} url: '#{@resource_url}'"
+      end
 
-    def inspect
-      "#{self} version: '#{version}'"
-    end
+      def inspect
+        "#{self} version: '#{version}'"
+      end
 
-    def version
-      resource_data ? resource_data['neo4j_version'] : ''
-    end
+      def version
+        resource_data ? resource_data['neo4j_version'] : ''
+      end
 
-    def initialize_resource(data_url)
-      response = @connection.get(data_url)
-      expect_response_code(response, 200)
-      data_resource = response.body
-      fail "No data_resource for #{response.body}" unless data_resource
-      # store the resource data
-      init_resource_data(data_resource, data_url)
-    end
+      def initialize_resource(data_url)
+        response = @connection.get(data_url)
+        expect_response_code(response, 200)
+        data_resource = response.body
+        fail "No data_resource for #{response.body}" unless data_resource
+        # store the resource data
+        init_resource_data(data_resource, data_url)
+      end
 
-    def close
-      super
-      Neo4j::Transaction.unregister_current
-    end
+      def close
+        super
+        Neo4j::Transaction.unregister_current
+      end
 
-    def begin_tx
-      if Neo4j::Transaction.current
-        # Handle nested transaction "placebo transaction"
-        Neo4j::Transaction.current.push_nested!
-      else
-        wrap_resource(@connection)
+      def begin_tx
+        if Neo4j::Transaction.current
+          # Handle nested transaction "placebo transaction"
+          Neo4j::Transaction.current.push_nested!
+        else
+          wrap_resource(@connection)
+        end
+        Neo4j::Transaction.current
       end
-      Neo4j::Transaction.current
-    end
 
-    def create_node(props = nil, labels = [])
-      id = _query_or_fail(cypher_string(labels, props), true, cypher_prop_list(props))
-      value = props.nil? ? id : {'id' => id, 'metadata' => {'labels' => labels}, 'data' => props}
-      CypherNode.new(self, value)
-    end
+      def create_node(props = nil, labels = [])
+        id = _query_or_fail(cypher_string(labels, props), true, cypher_prop_list(props))
+        value = props.nil? ? id : {'id' => id, 'metadata' => {'labels' => labels}, 'data' => props}
+        CypherNode.new(self, value)
+      end
 
-    def load_node(neo_id)
-      load_entity(CypherNode, _query("MATCH (n) WHERE ID(n) = #{neo_id} RETURN n"))
-    end
+      def load_node(neo_id)
+        load_entity(CypherNode, _query("MATCH (n) WHERE ID(n) = #{neo_id} RETURN n"))
+      end
 
-    def load_relationship(neo_id)
-      load_entity(CypherRelationship, _query("MATCH (n)-[r]-() WHERE ID(r) = #{neo_id} RETURN r"))
-    end
+      def load_relationship(neo_id)
+        load_entity(CypherRelationship, _query("MATCH (n)-[r]-() WHERE ID(r) = #{neo_id} RETURN r"))
+      end
 
-    def load_entity(clazz, cypher_response)
-      return nil if cypher_response.data.nil? || cypher_response.data[0].nil?
-      data  = if cypher_response.transaction_response?
-                cypher_response.rest_data_with_id
-              else
-                cypher_response.first_data
-              end
-
-      if cypher_response.error?
-        cypher_response.raise_error
-      elsif cypher_response.error_msg =~ /not found/  # Ugly that the Neo4j API gives us this error message
-        return nil
-      else
-        clazz.new(self, data)
+      def load_entity(clazz, cypher_response)
+        return nil if cypher_response.data.nil? || cypher_response.data[0].nil?
+        data  = if cypher_response.transaction_response?
+                  cypher_response.rest_data_with_id
+                else
+                  cypher_response.first_data
+                end
+
+        if cypher_response.error?
+          cypher_response.raise_error
+        elsif cypher_response.error_msg =~ /not found/  # Ugly that the Neo4j API gives us this error message
+          return nil
+        else
+          clazz.new(self, data)
+        end
       end
-    end
 
-    def create_label(name)
-      CypherLabel.new(self, name)
-    end
+      def create_label(name)
+        CypherLabel.new(self, name)
+      end
 
-    def uniqueness_constraints(label)
-      schema_properties("#{@resource_url}schema/constraint/#{label}/uniqueness")
-    end
+      def uniqueness_constraints(label)
+        schema_properties("#{@resource_url}schema/constraint/#{label}/uniqueness")
+      end
 
-    def indexes(label)
-      schema_properties("#{@resource_url}schema/index/#{label}")
-    end
+      def indexes(label)
+        schema_properties("#{@resource_url}schema/index/#{label}")
+      end
 
-    def schema_properties(query_string)
-      response = @connection.get(query_string)
-      expect_response_code(response, 200)
-      {property_keys: response.body.map { |row| row['property_keys'].map(&:to_sym) }}
-    end
+      def schema_properties(query_string)
+        response = @connection.get(query_string)
+        expect_response_code(response, 200)
+        {property_keys: response.body.map { |row| row['property_keys'].map(&:to_sym) }}
+      end
 
-    def find_all_nodes(label_name)
-      search_result_to_enumerable_first_column(_query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)"))
-    end
+      def find_all_nodes(label_name)
+        search_result_to_enumerable_first_column(_query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)"))
+      end
 
-    def find_nodes(label_name, key, value)
-      value = "'#{value}'" if value.is_a? String
+      def find_nodes(label_name, key, value)
+        value = "'#{value}'" if value.is_a? String
 
-      response = _query_or_fail <<-CYPHER
-        MATCH (n:`#{label_name}`)
-        WHERE n.#{key} = #{value}
-        RETURN ID(n)
-      CYPHER
-      search_result_to_enumerable_first_column(response)
-    end
+        response = _query_or_fail <<-CYPHER
+          MATCH (n:`#{label_name}`)
+          WHERE n.#{key} = #{value}
+          RETURN ID(n)
+        CYPHER
+        search_result_to_enumerable_first_column(response)
+      end
 
-    def query(*args)
-      if [[String], [String, Hash]].include?(args.map(&:class))
-        query, params = args[0, 2]
-        response = _query(query, params)
-        response.raise_error if response.error?
-        response.to_node_enumeration(query)
-      else
-        options = args[0] || {}
-        Neo4j::Core::Query.new(options.merge(session: self))
+      def query(*args)
+        if [[String], [String, Hash]].include?(args.map(&:class))
+          query, params = args[0, 2]
+          response = _query(query, params)
+          response.raise_error if response.error?
+          response.to_node_enumeration(query)
+        else
+          options = args[0] || {}
+          Neo4j::Core::Query.new(options.merge(session: self))
+        end
       end
-    end
 
-    def _query_data(q)
-      r = _query_or_fail(q, true)
-      # the response is different if we have a transaction or not
-      Neo4j::Transaction.current ? r : r['data']
-    end
+      def _query_data(q)
+        r = _query_or_fail(q, true)
+        # the response is different if we have a transaction or not
+        Neo4j::Transaction.current ? r : r['data']
+      end
 
-    def _query_or_fail(q, single_row = false, params = nil)
-      response = _query(q, params)
-      response.raise_error if response.error?
-      single_row ? response.first_data : response
-    end
+      def _query_or_fail(q, single_row = false, params = nil)
+        response = _query(q, params)
+        response.raise_error if response.error?
+        single_row ? response.first_data : response
+      end
 
-    def _query_entity_data(q, id = nil, params = nil)
-      response = _query(q, params)
-      response.raise_error if response.error?
-      response.entity_data(id)
-    end
+      def _query_entity_data(q, id = nil, params = nil)
+        response = _query(q, params)
+        response.raise_error if response.error?
+        response.entity_data(id)
+      end
 
-    def _query(q, params = nil)
-      # puts "q #{q}"
-      curr_tx = Neo4j::Transaction.current
-      if curr_tx
-        curr_tx._query(q, params)
-      else
-        url = resource_url('cypher')
-        q = params.nil? ? {'query' => q} : {'query' => q, 'params' => params}
-        response = @connection.post(url, q)
-        CypherResponse.create_with_no_tx(response)
+      def _query(q, params = nil)
+        # puts "q #{q}"
+        curr_tx = Neo4j::Transaction.current
+        if curr_tx
+          curr_tx._query(q, params)
+        else
+          url = resource_url('cypher')
+          q = params.nil? ? {'query' => q} : {'query' => q, 'params' => params}
+          response = @connection.post(url, q)
+          CypherResponse.create_with_no_tx(response)
+        end
       end
-    end
 
-    def search_result_to_enumerable_first_column(response)
-      return [] unless response.data
-      if Neo4j::Transaction.current
-        search_result_to_enumerable_first_column_with_tx(response)
-      else
-        search_result_to_enumerable_first_column_without_tx(response)
+      def search_result_to_enumerable_first_column(response)
+        return [] unless response.data
+        if Neo4j::Transaction.current
+          search_result_to_enumerable_first_column_with_tx(response)
+        else
+          search_result_to_enumerable_first_column_without_tx(response)
+        end
       end
-    end
 
-    def search_result_to_enumerable_first_column_with_tx(response)
-      Enumerator.new do |yielder|
-        response.data.each do |data|
-          data['row'].each do |id|
-            yielder << CypherNode.new(self, id).wrapper
+      def search_result_to_enumerable_first_column_with_tx(response)
+        Enumerator.new do |yielder|
+          response.data.each do |data|
+            data['row'].each do |id|
+              yielder << CypherNode.new(self, id).wrapper
+            end
           end
         end
       end
-    end
 
-    def search_result_to_enumerable_first_column_without_tx(response)
-      Enumerator.new do |yielder|
-        response.data.each do |data|
-          yielder << CypherNode.new(self, data[0]).wrapper
+      def search_result_to_enumerable_first_column_without_tx(response)
+        Enumerator.new do |yielder|
+          response.data.each do |data|
+            yielder << CypherNode.new(self, data[0]).wrapper
+          end
         end
       end
-    end
 
-    def map_column(key, map, data)
-      if map[key] == :node
-        CypherNode.new(self, data).wrapper
-      elsif map[key] == :rel || map[:key] || :relationship
-        CypherRelationship.new(self, data)
-      else
-        data
+      def map_column(key, map, data)
+        if map[key] == :node
+          CypherNode.new(self, data).wrapper
+        elsif map[key] == :rel || map[:key] || :relationship
+          CypherRelationship.new(self, data)
+        else
+          data
+        end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/neo4j-server/cypher_transaction.rb b/lib/neo4j-server/cypher_transaction.rb
index 4b40b5c9..44f58aa5 100644
--- a/lib/neo4j-server/cypher_transaction.rb
+++ b/lib/neo4j-server/cypher_transaction.rb
@@ -1,77 +1,79 @@
-module Neo4j::Server
-  # The CypherTransaction object lifecycle is as follows:
-  # * It is initialized with the transactional endpoint URL and the connection object to use for communication. It does not communicate with the server to create this.
-  # * The first query within the transaction sets the commit and execution addresses, :commit_url and :exec_url.
-  # * At any time, `failure` can be called to mark a transaction failed and trigger a rollback upon closure.
-  # * `close` is called to end the transaction. It calls `_commit_tx` or `_delete_tx`.
-  #
-  # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
-  class CypherTransaction
-    include Neo4j::Transaction::Instance
-    include Neo4j::Core::CypherTranslator
-    include Resource
+module Neo4j
+  module Server
+    # The CypherTransaction object lifecycle is as follows:
+    # * It is initialized with the transactional endpoint URL and the connection object to use for communication. It does not communicate with the server to create this.
+    # * The first query within the transaction sets the commit and execution addresses, :commit_url and :exec_url.
+    # * At any time, `failure` can be called to mark a transaction failed and trigger a rollback upon closure.
+    # * `close` is called to end the transaction. It calls `_commit_tx` or `_delete_tx`.
+    #
+    # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
+    class CypherTransaction
+      include Neo4j::Transaction::Instance
+      include Neo4j::Core::CypherTranslator
+      include Resource
 
-    attr_reader :commit_url, :exec_url, :base_url, :connection
+      attr_reader :commit_url, :exec_url, :base_url, :connection
 
-    def initialize(url, session_connection)
-      @base_url = url
-      @connection = session_connection
-      register_instance
-    end
+      def initialize(url, session_connection)
+        @base_url = url
+        @connection = session_connection
+        register_instance
+      end
 
-    ROW_REST = %w(row REST)
-    def _query(cypher_query, params = nil)
-      fail 'Transaction expired, unable to perform query' if expired?
-      statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
-      body = {statements: [statement]}
+      ROW_REST = %w(row REST)
+      def _query(cypher_query, params = nil)
+        fail 'Transaction expired, unable to perform query' if expired?
+        statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
+        body = {statements: [statement]}
 
-      response = exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
-      _create_cypher_response(response)
-    end
+        response = exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
+        _create_cypher_response(response)
+      end
 
-    def _delete_tx
-      _tx_query(:delete, exec_url, headers: resource_headers)
-    end
+      def _delete_tx
+        _tx_query(:delete, exec_url, headers: resource_headers)
+      end
 
-    def _commit_tx
-      _tx_query(:post, commit_url, nil)
-    end
+      def _commit_tx
+        _tx_query(:post, commit_url, nil)
+      end
 
-    private
+      private
 
-    def _tx_query(action, endpoint, headers = {})
-      return empty_response if !commit_url || expired?
-      response = connection.send(action, endpoint, headers)
-      expect_response_code(response, 200)
-      response
-    end
+      def _tx_query(action, endpoint, headers = {})
+        return empty_response if !commit_url || expired?
+        response = connection.send(action, endpoint, headers)
+        expect_response_code(response, 200)
+        response
+      end
 
-    def register_urls(body)
-      response = connection.post(base_url, body)
-      @commit_url = response.body['commit']
-      @exec_url = response.headers['Location']
-      fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !exec_url || exec_url.empty?
-      init_resource_data(response.body, base_url)
-      expect_response_code(response, 201)
-      response
-    end
+      def register_urls(body)
+        response = connection.post(base_url, body)
+        @commit_url = response.body['commit']
+        @exec_url = response.headers['Location']
+        fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !exec_url || exec_url.empty?
+        init_resource_data(response.body, base_url)
+        expect_response_code(response, 201)
+        response
+      end
 
-    def _create_cypher_response(response)
-      first_result = response.body['results'][0]
+      def _create_cypher_response(response)
+        first_result = response.body['results'][0]
 
-      cr = CypherResponse.new(response, true)
-      if response.body['errors'].empty?
-        cr.set_data(first_result['data'], first_result['columns'])
-      else
-        first_error = response.body['errors'].first
-        expired if first_error['message'].match(/Unrecognized transaction id/)
-        cr.set_error(first_error['message'], first_error['code'], first_error['code'])
+        cr = CypherResponse.new(response, true)
+        if response.body['errors'].empty?
+          cr.set_data(first_result['data'], first_result['columns'])
+        else
+          first_error = response.body['errors'].first
+          expired if first_error['message'].match(/Unrecognized transaction id/)
+          cr.set_error(first_error['message'], first_error['code'], first_error['code'])
+        end
+        cr
       end
-      cr
-    end
 
-    def empty_response
-      OpenStruct.new(status: 200, body: '')
+      def empty_response
+        OpenStruct.new(status: 200, body: '')
+      end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/neo4j/transaction.rb b/lib/neo4j/transaction.rb
index 6563f9d7..bc1545a9 100644
--- a/lib/neo4j/transaction.rb
+++ b/lib/neo4j/transaction.rb
@@ -9,13 +9,13 @@ def register_instance
         Neo4j::Transaction.register(self)
       end
 
-      # Marks this transaction as failed, which means that it will unconditionally be rolled back when close() is called.
+      # Marks this transaction as failed, which means that it will unconditionally be rolled back when close() is called. Aliased for legacy purposes.
       def mark_failed
         @failure = true
       end
       alias_method :failure, :mark_failed
 
-      # If it has been marked as failed
+      # If it has been marked as failed. Aliased for legacy purposes.
       def failed?
         !!@failure
       end
@@ -82,7 +82,7 @@ def run(run_in_tx = true)
       begin
         tx = Neo4j::Transaction.new
         ret = yield tx
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         if e.respond_to?(:cause) && e.cause.respond_to?(:print_stack_trace)
           puts "Java Exception in a transaction, cause: #{e.cause}"
           e.cause.print_stack_trace
@@ -117,4 +117,4 @@ def unregister_current
       Thread.current[:neo4j_curr_tx] = nil
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/neo4j-server/e2e/cypher_transaction_spec.rb b/spec/neo4j-server/e2e/cypher_transaction_spec.rb
index d7d70062..8b63af32 100644
--- a/spec/neo4j-server/e2e/cypher_transaction_spec.rb
+++ b/spec/neo4j-server/e2e/cypher_transaction_spec.rb
@@ -1,200 +1,202 @@
 require 'spec_helper'
 
-module Neo4j::Server
-  describe CypherTransaction, api: :server do
-    before { session || create_server_session }
+module Neo4j
+  module Server
+    describe CypherTransaction, api: :server do
+      before { session || create_server_session }
 
-    after do
-      session && session.close
-      Neo4j::Transaction.current && Neo4j::Transaction.current.close
-    end
-
-    context 'where no queries are made' do
-      it 'can open and close a transaction' do
-        tx = session.begin_tx
-        expect { tx.close }.not_to raise_error
+      after do
+        session && session.close
+        Neo4j::Transaction.current && Neo4j::Transaction.current.close
       end
 
-      it 'returns an OpenStruct to mimic a completed transaction' do
-        tx = session.begin_tx
-        response = tx.close
-        expect(response.status).to eq(200)
-        expect(response).to be_a(OpenStruct)
-      end
-    end
+      context 'where no queries are made' do
+        it 'can open and close a transaction' do
+          tx = session.begin_tx
+          expect { tx.close }.not_to raise_error
+        end
 
-    context 'where queries are made' do
-      it 'can open and close a transaction' do
-        tx = session.begin_tx
-        tx._query("CREATE (n:Student { name: 'John' } RETURN n")
-        response = tx.close
-        expect(response.status).to eq 200
-        expect(response).to be_a(Faraday::Response)
+        it 'returns an OpenStruct to mimic a completed transaction' do
+          tx = session.begin_tx
+          response = tx.close
+          expect(response.status).to eq(200)
+          expect(response).to be_a(OpenStruct)
+        end
       end
 
-      it 'can run a valid query' do
-        id = session.query.create('(n)').return('ID(n) AS id').first[:id]
-        tx = session.begin_tx
-        q = tx._query("MATCH (n) WHERE ID(n) = #{id} RETURN ID(n)")
-        expect(q.response.body['results']).to eq([{'columns' => ['ID(n)'], 'data' => [{'row' => [id], 'rest' => [id]}]}])
-      end
+      context 'where queries are made' do
+        it 'can open and close a transaction' do
+          tx = session.begin_tx
+          tx._query("CREATE (n:Student { name: 'John' } RETURN n")
+          response = tx.close
+          expect(response.status).to eq 200
+          expect(response).to be_a(Faraday::Response)
+        end
 
-      it 'sets the response error fields if not a valid query' do
-        tx = session.begin_tx
-        r = tx._query('START n=fs(0) RRETURN ID(n)')
-        expect(r.error?).to be true
+        it 'can run a valid query' do
+          id = session.query.create('(n)').return('ID(n) AS id').first[:id]
+          tx = session.begin_tx
+          q = tx._query("MATCH (n) WHERE ID(n) = #{id} RETURN ID(n)")
+          expect(q.response.body['results']).to eq([{'columns' => ['ID(n)'], 'data' => [{'row' => [id], 'rest' => [id]}]}])
+        end
 
-        expect(r.error_msg).to match(/Invalid input/)
-        expect(r.error_status).to match(/Syntax/)
-      end
+        it 'sets the response error fields if not a valid query' do
+          tx = session.begin_tx
+          r = tx._query('START n=fs(0) RRETURN ID(n)')
+          expect(r.error?).to be true
 
-      it 'can rollback' do
-        node = Neo4j::Node.create(name: 'andreas')
-        Neo4j::Transaction.run do |tx|
-          node[:name] = 'foo'
-          expect(node[:name]).to eq('foo')
-          tx.mark_failed
+          expect(r.error_msg).to match(/Invalid input/)
+          expect(r.error_status).to match(/Syntax/)
         end
 
-        expect(node['name']).to eq('andreas')
-      end
+        it 'can rollback' do
+          node = Neo4j::Node.create(name: 'andreas')
+          Neo4j::Transaction.run do |tx|
+            node[:name] = 'foo'
+            expect(node[:name]).to eq('foo')
+            tx.mark_failed
+          end
 
-      it 'can continue operations after transaction is rolled back' do
-        node = Neo4j::Node.create(name: 'andreas')
-        Neo4j::Transaction.run do |tx|
-          tx.mark_failed
-          node[:name] = 'foo'
-          expect(node[:name]).to eq('foo')
+          expect(node['name']).to eq('andreas')
+        end
+
+        it 'can continue operations after transaction is rolled back' do
+          node = Neo4j::Node.create(name: 'andreas')
+          Neo4j::Transaction.run do |tx|
+            tx.mark_failed
+            node[:name] = 'foo'
+            expect(node[:name]).to eq('foo')
+          end
+          expect(node['name']).to eq('andreas')
+        end
+
+        it 'cannot continue operations if a transaction is expired' do
+          node = Neo4j::Node.create(name: 'andreas')
+          Neo4j::Transaction.run do |tx|
+            tx.expired
+            expect { node[:name] = 'foo' }.to raise_error 'Transaction expired, unable to perform query'
+          end
         end
-        expect(node['name']).to eq('andreas')
-      end
 
-      it 'cannot continue operations if a transaction is expired' do
-        node = Neo4j::Node.create(name: 'andreas')
-        Neo4j::Transaction.run do |tx|
-          tx.expired
-          expect { node[:name] = 'foo' }.to raise_error 'Transaction expired, unable to perform query'
+        it 'can use Transaction block style' do
+          node = Neo4j::Transaction.run { Neo4j::Node.create(name: 'andreas') }
+          expect(node['name']).to eq('andreas')
         end
       end
 
-      it 'can use Transaction block style' do
-        node = Neo4j::Transaction.run { Neo4j::Node.create(name: 'andreas') }
-        expect(node['name']).to eq('andreas')
+      describe Neo4j::Label do
+        describe '.find_nodes' do
+          it 'find and can load them' do
+            begin
+              tx = Neo4j::Transaction.new
+              label_name = unique_random_number.to_s
+              n = Neo4j::Node.create({name: 'andreas'}, label_name)
+              found = Neo4j::Label.find_nodes(label_name, :name, 'andreas').to_a.first
+              expect(found[:name]).to eq('andreas')
+              expect(found).to eq(n)
+            ensure
+              tx.close
+            end
+          end
+        end
       end
-    end
 
-    describe Neo4j::Label do
-      describe '.find_nodes' do
-        it 'find and can load them' do
-          begin
-            tx = Neo4j::Transaction.new
-            label_name = unique_random_number.to_s
-            n = Neo4j::Node.create({name: 'andreas'}, label_name)
-            found = Neo4j::Label.find_nodes(label_name, :name, 'andreas').to_a.first
-            expect(found[:name]).to eq('andreas')
-            expect(found).to eq(n)
-          ensure
-            tx.close
+      describe Neo4j::Node do
+        describe '.load' do
+          it 'can load existing node' do
+            begin
+              node = Neo4j::Node.create(name: 'andreas')
+              id = node.neo_id
+              tx = Neo4j::Transaction.new
+              found = Neo4j::Node.load(id)
+              expect(node).to eq(found)
+            ensure
+              tx.close
+            end
+          end
+
+          it 'can load node created in tx' do
+            begin
+              tx = Neo4j::Transaction.new
+              node = Neo4j::Node.create(name: 'andreas')
+              id = node.neo_id
+              found = Neo4j::Node.load(id)
+              expect(node).to eq(found)
+            ensure
+              tx.close
+            end
           end
         end
       end
-    end
 
-    describe Neo4j::Node do
-      describe '.load' do
-        it 'can load existing node' do
+      describe '#create_rel' do
+        it 'can create and load it' do
           begin
-            node = Neo4j::Node.create(name: 'andreas')
-            id = node.neo_id
             tx = Neo4j::Transaction.new
-            found = Neo4j::Node.load(id)
-            expect(node).to eq(found)
+            a = Neo4j::Node.create(name: 'a')
+            b = Neo4j::Node.create(name: 'b')
+            rel = a.create_rel(:knows, b, colour: 'blue')
+            loaded = Neo4j::Relationship.load(rel.neo_id)
+            expect(loaded).to eq(rel)
+            expect(loaded['colour']).to eq('blue')
           ensure
             tx.close
           end
         end
+      end
+
 
-        it 'can load node created in tx' do
+      describe '#rel' do
+        it 'can load it' do
           begin
             tx = Neo4j::Transaction.new
-            node = Neo4j::Node.create(name: 'andreas')
-            id = node.neo_id
-            found = Neo4j::Node.load(id)
-            expect(node).to eq(found)
+            a = Neo4j::Node.create(name: 'a')
+            b = Neo4j::Node.create(name: 'b')
+            rel = a.create_rel(:knows, b, colour: 'blue')
+            loaded = a.rel(dir: :outgoing, type: :knows)
+            expect(loaded).to eq(rel)
+            expect(loaded['colour']).to eq('blue')
           ensure
             tx.close
           end
         end
       end
-    end
-
-    describe '#create_rel' do
-      it 'can create and load it' do
-        begin
-          tx = Neo4j::Transaction.new
-          a = Neo4j::Node.create(name: 'a')
-          b = Neo4j::Node.create(name: 'b')
-          rel = a.create_rel(:knows, b, colour: 'blue')
-          loaded = Neo4j::Relationship.load(rel.neo_id)
-          expect(loaded).to eq(rel)
-          expect(loaded['colour']).to eq('blue')
-        ensure
-          tx.close
-        end
-      end
-    end
-
 
-    describe '#rel' do
-      it 'can load it' do
-        begin
-          tx = Neo4j::Transaction.new
-          a = Neo4j::Node.create(name: 'a')
-          b = Neo4j::Node.create(name: 'b')
-          rel = a.create_rel(:knows, b, colour: 'blue')
-          loaded = a.rel(dir: :outgoing, type: :knows)
-          expect(loaded).to eq(rel)
-          expect(loaded['colour']).to eq('blue')
-        ensure
-          tx.close
+      describe '.create' do
+        it 'creates a node' do
+          tx = session.begin_tx
+          node = Neo4j::Node.create(name: 'andreas')
+          expect(tx.close.status).to eq(200)
+          expect(node['name']).to eq('andreas')
+          # tx.close
         end
       end
-    end
-
-    describe '.create' do
-      it 'creates a node' do
-        tx = session.begin_tx
-        node = Neo4j::Node.create(name: 'andreas')
-        expect(tx.close.status).to eq(200)
-        expect(node['name']).to eq('andreas')
-        # tx.close
-      end
-    end
 
-    describe '#del' do
-      it 'deletes a node' do
-        begin
-          tx = session.begin_tx
-          node = Neo4j::Node.create(name: 'andreas')
-          id = node.neo_id
-          node.del
-          loaded = Neo4j::Node.load(id)
-          expect(loaded).to be_nil
-        ensure
-          tx.close
+      describe '#del' do
+        it 'deletes a node' do
+          begin
+            tx = session.begin_tx
+            node = Neo4j::Node.create(name: 'andreas')
+            id = node.neo_id
+            node.del
+            loaded = Neo4j::Node.load(id)
+            expect(loaded).to be_nil
+          ensure
+            tx.close
+          end
         end
       end
-    end
 
-    describe '#[]=' do
-      it 'can update/read a property' do
-        node = Neo4j::Node.create(name: 'foo')
-        Neo4j::Transaction.run do
-          node[:name] = 'bar'
+      describe '#[]=' do
+        it 'can update/read a property' do
+          node = Neo4j::Node.create(name: 'foo')
+          Neo4j::Transaction.run do
+            node[:name] = 'bar'
+            expect(node[:name]).to eq('bar')
+          end
           expect(node[:name]).to eq('bar')
         end
-        expect(node[:name]).to eq('bar')
       end
     end
   end
-end
\ No newline at end of file
+end