gremlin_client 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b115f8790e0e39186f7d9d2f940e78cebe26f50
-  data.tar.gz: d3b354fb424d8d24805e7f91a97a9e1e610b9251
+  metadata.gz: 7d93c96d3bd662c361f27897fa4d1f893df713a6
+  data.tar.gz: 9401ccd8d090760cc6007f9ccf654164f21f7a95
 SHA512:
-  metadata.gz: 968658a02d4647d0d49d03530d4f0aaa7830d76807337229673f5aeaec30d9898f936d095b0ff908b087b6c1e69bc5335599a1254326ee18f687a09c2d7a4ee8
-  data.tar.gz: 74060237829bc7fef5562efa39968d6fde683ac222742cb6b3ead2228c98459adb4015fd7a65387e5ece564a72b26ac38a42b15c80f33778f3eb781515654429
+  metadata.gz: adbfeb75273dcf99e6b67e008ba1633220a1c1365b7f5300d2ca9458a211225a85b2c6de76f357990199f283ee6116d76fdd8b06f616e408e767e59f83637217
+  data.tar.gz: 313bfb016083761bec62ccdadf7452bb977523f46e19feed9e57329486a52f53c8b36b869c4198b811086c217203801ad8cf11135c492096be34901ec0e26380

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+
+notifications:
+  email:
+    on_sucess: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gremlin_client (0.0.4)
+    gremlin_client (0.1.0)
       websocket-client-simple (~> 0.3)
 
 GEM

data/README.md

@@ -1,4 +1,13 @@
 # Ruby Gremlin Client
+
+
+[![Build Status](https://travis-ci.org/marcelocf/gremlin_client.svg?branch=master)](https://travis-ci.org/marcelocf/gremlin_clien)
+[![Gem Version](https://badge.fury.io/rb/gremlin_client.svg)](https://badge.fury.io/rb/gremlin_client)
+![](http://ruby-gem-downloads-badge.herokuapp.com/gremlin_client?color=brightgreen)
+[![Coverage Status](https://coveralls.io/repos/github/marcelocf/gremlin_client/badge.svg?branch=master)](https://coveralls.io/github/marcelocf/gremlin_client?branch=master)
+
+
+
 Gremlin client in ruby for the WebSocketChannelizer.
 
 This client is not thread safe by itself! If you want to make it safer for your app, please make sure
@@ -18,7 +27,7 @@ resp = conn.send("g.V().has('myVar', myValue)", {myValue: 'this_is_processed_by_
 Alternativelly, you can use groovy files instead:
 
 ```ruby
-resp = conn.file_send("template.groovy", {var1: 12})
+resp = conn.file_send("query.groovy", {var1: 12})
 ```
 
 ```groovy
@@ -28,7 +37,7 @@ g.V().has("something", var1)
 You can even specify the folder where to load those files in the constructor:
 
 ```ruby
-conn = GremlinClient.Connection.new(groovy_script_path:  'scripts/groovy')
+conn = GremlinClient.Connection.new(gremlin_script_path:  'scripts/gremlin')
 ```
 
 

data/example/test.rb

@@ -6,14 +6,10 @@ require 'gremlin_client'
 
 conn = GremlinClient::Connection.new(groovy_script_path: 'example/scripts')
 
-
-pp conn.send_file('concierge_scores.groovy', {fincUserId: 260607, contentTypeFilter: ['Try::Beauty']})
-
 pp conn.send('1+what', {what: 10})
 
-pp conn.send('g.V().next()')
+pp conn.send('g.V().count()')
 
 pp conn.send_file('test.groovy', {what: Time.now.to_i})
 
-
 conn.close

data/lib/gremlin_client.rb

@@ -5,6 +5,7 @@ require 'pathname'
 require 'websocket-client-simple'
 
 require 'gremlin_client/server_error'
+require 'gremlin_client/connection_timeout_error'
 require 'gremlin_client/execution_timeout_error'
 require 'gremlin_client/connection'
 module GremlinClient

data/lib/gremlin_client/connection.rb

@@ -3,7 +3,7 @@ module GremlinClient
   # represents the connection to our gremlin server
   class Connection
 
-    attr_reader :timeout, :groovy_script_path
+    attr_reader :connection_timeout, :timeout, :gremlin_script_path
 
     STATUS = {
       success: 200,
@@ -13,7 +13,7 @@ module GremlinClient
       unauthorized: 401,
       authenticate: 407,
       malformed_request: 498,
-      invalid_request_arguents: 499,
+      invalid_request_arguments: 499,
       server_error: 500,
       script_evaluation_error: 597,
       server_timeout: 598,
@@ -33,8 +33,9 @@ module GremlinClient
     def initialize(
       host: 'localhost',
       port: 8182,
+      connection_timeout: 1,
       timeout: 10,
-      groovy_script_path: '.'
+      gremlin_script_path: '.'
     )
       url = "ws://#{host}:#{port}"
 
@@ -44,7 +45,6 @@ module GremlinClient
 
         @ws.on :message do |msg|
           gremlin.receive_message(msg)
-          @response=msg
         end
 
         @ws.on :error do |e|
@@ -53,22 +53,22 @@ module GremlinClient
       end
 
 
+      @connection_timeout = connection_timeout
       @timeout = timeout
-      @groovy_script_path = groovy_script_path
-      @groovy_script_path = Pathname.new(@groovy_script_path) unless @groovy_script_path.is_a?(Pathname)
+      @gremlin_script_path = gremlin_script_path
+      @gremlin_script_path = Pathname.new(@gremlin_script_path) unless @gremlin_script_path.is_a?(Pathname)
     end
 
-
-    def send(command, bindings={})
+    def send_query(command, bindings={})
       wait_connection
-      reset_timer
+      reset_request
       @ws.send(build_message(command, bindings), { type: 'text' })
       wait_response
-      return parse_response
+      return treat_response
     end
 
     def send_file(filename, bindings={})
-      send(IO.read(resolve_path(filename)), bindings)
+      send_query(IO.read(resolve_path(filename)), bindings)
     end
 
     def open?
@@ -82,7 +82,9 @@ module GremlinClient
 
     # this has to be public so the websocket client thread sees it
     def receive_message(msg)
-      @response = JSON.parse(msg.data)
+      response = JSON.parse(msg.data)
+      # this check is important in case a request timeout and we make new ones after
+      @response = response if response['requestId'] == @request_id
     end
 
     def receive_error(e)
@@ -91,14 +93,16 @@ module GremlinClient
 
     protected
 
-      def wait_connection(w_timeout = 1)
+      def wait_connection
         w_from = Time.now.to_i
-        while !open? && Time.now.to_i - w_timeout < w_from
+        while !open? && Time.now.to_i - @connection_timeout < w_from
           sleep 0.001
         end
+        fail ::GremlinClient::ConnectionTimeoutError.new(@connection_timeout) unless open?
       end
 
-      def reset_timer
+      def reset_request
+        @request_id= SecureRandom.uuid
         @started_at = Time.now.to_i
         @error = nil
         @response = nil
@@ -115,7 +119,7 @@ module GremlinClient
 
       # we validate our response here to make sure it is going to be
       # raising exceptions in the right thread
-      def parse_response
+      def treat_response
         # note that the partial_content status should be processed differently.
         # look at http://tinkerpop.apache.org/docs/3.0.1-incubating/ for more info
         ok_status = [:success, :no_content, :partial_content].map { |st| STATUS[st] }
@@ -127,7 +131,7 @@ module GremlinClient
 
       def build_message(command, bindings)
         message = {
-          requestId: SecureRandom.uuid,
+          requestId: @request_id,
           op: 'eval',
           processor: '',
           args: {
@@ -141,7 +145,7 @@ module GremlinClient
 
       def resolve_path(filename)
         return filename if filename.is_a?(String) && filename[0,1] == '/'
-        @groovy_script_path.join(filename).to_s
+        @gremlin_script_path.join(filename).to_s
       end
   end
 end

data/lib/gremlin_client/connection_timeout_error.rb

@@ -0,0 +1,13 @@
+
+module GremlinClient
+  # to track error of timeout while waiting for connection
+  class ConnectionTimeoutError < StandardError
+    attr_reader :timeout
+    def initialize(timeout)
+      @timeout = timeout
+    end
+    def to_s
+      "#{@timeout}s"
+    end
+  end
+end

data/lib/gremlin_client/version.rb

@@ -1,3 +1,3 @@
 module GremliClient
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/connection_spec.rb

@@ -0,0 +1,288 @@
+
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Tests on the freetext feature
+RSpec.describe :connection do
+  class MockedSocket
+  end
+
+  module Message
+    def self.status=(name)
+      @status_code = GremlinClient::Connection::STATUS[name]
+    end
+
+    def self.request_id=(requestId)
+      @request_id = requestId
+    end
+
+    def self.called=(c)
+      @called = c
+    end
+
+    def self.data
+      @called ||= 0
+      @called += 1
+      rid = ", \"requestId\" : \"#{@request_id}\"" unless @request_id.nil?
+      stt = ", \"status\" : { \"code\" : #{@status_code} }" unless @status_code.nil?
+      "{\"example\" : \"data #{@called}\"#{rid}#{stt}}"
+    end
+  end
+
+  before do
+    sock = MockedSocket.new
+    allow(sock).to receive(:on).and_yield(Message)
+    allow(WebSocket::Client::Simple).to receive(:connect).and_yield(sock)
+  end
+
+  describe :initialize do
+    it :websocket do
+      expect(WebSocket::Client::Simple).to receive(:connect).with('ws://localhost:8182/')
+      conn = GremlinClient::Connection.new
+    end
+
+    it :websocket do
+      expect(WebSocket::Client::Simple).to receive(:connect).with('ws://SERVER_A:123/')
+      conn = GremlinClient::Connection.new(host: :SERVER_A, port: 123)
+    end
+
+    it :gremlin_script_path do
+      conn = GremlinClient::Connection.new
+      expect(conn.gremlin_script_path).to eq(Pathname.new('.'))
+      conn = GremlinClient::Connection.new(gremlin_script_path: '/etc/groovy')
+      expect(conn.gremlin_script_path).to eq(Pathname.new('/etc/groovy'))
+    end
+
+    it :connection_timeout do
+      conn = GremlinClient::Connection.new
+      expect(conn.connection_timeout).to eq(1)
+      conn = GremlinClient::Connection.new(connection_timeout: 11)
+      expect(conn.connection_timeout).to eq(11)
+    end
+
+    it :timeout do
+      conn = GremlinClient::Connection.new
+      expect(conn.timeout).to eq(10)
+      conn = GremlinClient::Connection.new(timeout: 1)
+      expect(conn.timeout).to eq(1)
+    end
+
+
+    it :socket_listeners do
+      Message.called = 0
+      conn = GremlinClient::Connection.new
+      expect(conn.instance_variable_get('@response')).to eq({'example' => 'data 1'})
+      expect(conn.instance_variable_get('@error').data).to eq("{\"example\" : \"data 2\"}")
+    end
+  end
+
+
+  describe :send do
+    it :string do
+      conn = GremlinClient::Connection.new
+      sock = conn.instance_variable_get('@ws')
+      expect(conn).to receive(:wait_connection)
+      expect(conn).to receive(:reset_request)
+      expect(conn).to receive(:build_message).with(:query, :bindings).and_return(:my_message)
+      expect(sock).to receive(:send).with(:my_message, { type: 'text' })
+      expect(conn).to receive(:wait_response)
+      expect(conn).to receive(:treat_response)
+
+      conn.send_query(:query, :bindings)
+    end
+
+    it :file do
+      conn = GremlinClient::Connection.new
+      expect(IO).to receive(:read).with('filename').and_return(:file_contents)
+      expect(conn).to receive(:send_query).with(:file_contents, :bindings)
+      conn.send_file('filename', :bindings)
+    end
+  end
+
+
+  it :open? do
+    conn = GremlinClient::Connection.new
+    expect(conn.instance_variable_get('@ws')).to receive(:open?).and_return(:from_websocket)
+    expect(conn.open?).to eq(:from_websocket)
+  end
+
+  it :close do
+    conn = GremlinClient::Connection.new
+    expect(conn.instance_variable_get('@ws')).to receive(:close).and_return(:from_websocket)
+    expect(conn.close).to eq(:from_websocket)
+  end
+
+  describe :receive_message do
+    it :no_request_id do
+      Message.called = 0
+      Message.request_id = nil
+      conn = GremlinClient::Connection.new
+      conn.send(:reset_request)
+      conn.receive_message(Message)
+      expect(conn.instance_variable_get('@response')).to be_nil
+    end
+
+    it :different_request_id do
+      Message.called = 0
+      Message.request_id = '123'
+      conn = GremlinClient::Connection.new
+      conn.send(:reset_request)
+      conn.instance_variable_set('@request_id', '123')
+      conn.receive_message(Message)
+      expect(conn.instance_variable_get('@response')).to eq({'example' => 'data 2', 'requestId' => '123'})
+      # exit this block reseting this value
+      Message.request_id = nil
+    end
+  end
+
+  it :receive_error do
+    conn = GremlinClient::Connection.new
+    conn.receive_error(:this_is_a_bad_error)
+    expect(conn.instance_variable_get('@error')).to eq(:this_is_a_bad_error)
+  end
+
+  describe :wait_connection do
+    it :timeouts do
+      conn = GremlinClient::Connection.new
+      expect(conn).to receive(:open?).and_return(false).at_least(:once)
+      expect{conn.send(:wait_connection)}.to raise_exception(::GremlinClient::ConnectionTimeoutError)
+    end
+
+    it :success do
+      conn = GremlinClient::Connection.new
+      expect(conn).to receive(:open?).and_return(true).twice
+      conn.send(:wait_connection)
+    end
+
+    it :fails_with_longer_timeout do
+      conn = GremlinClient::Connection.new(connection_timeout: 3)
+      started_at = Time.now.to_i
+      expect(conn).to receive(:open?).and_return(false).at_least(:once)
+      expect{conn.send(:wait_connection)}.to raise_exception(::GremlinClient::ConnectionTimeoutError)
+      expect(Time.now.to_i - started_at).to be_within(1).of(3)
+    end
+  end
+
+
+  it :reset_request do
+    conn = GremlinClient::Connection.new
+    conn.instance_variable_set('@request_id', :old_id)
+    conn.instance_variable_set('@started_at', :old_started_at)
+    conn.instance_variable_set('@error', :old_error)
+    conn.instance_variable_set('@response', :old_response)
+
+    conn.send(:reset_request)
+
+    expect(conn.instance_variable_get('@request_id')).not_to eq(:old_id)
+    expect(conn.instance_variable_get('@request_id').length).to be(36) # uuid is 36 chars long
+    expect(conn.instance_variable_get('@started_at')).to be_within(1).of(Time.now.to_i)
+    expect(conn.instance_variable_get('@error')).to be_nil
+    expect(conn.instance_variable_get('@response')).to be_nil
+  end
+
+
+  describe :wait_response do
+    it :no_message do
+      conn = GremlinClient::Connection.new(timeout: 1)
+      conn.send(:reset_request)
+      expect{conn.send(:wait_response)}.to raise_exception(::GremlinClient::ExecutionTimeoutError)
+    end
+
+    it :wrong_id_message do
+      conn = GremlinClient::Connection.new(timeout: 1)
+      conn.send(:reset_request)
+      Message.request_id = :invalid_id
+      conn.receive_message(Message)
+      expect{conn.send(:wait_response)}.to raise_exception(::GremlinClient::ExecutionTimeoutError)
+    end
+
+    it :with_message do
+      conn = GremlinClient::Connection.new(timeout: 1)
+      conn.send(:reset_request)
+      Message.called = 0
+      Message.request_id = conn.instance_variable_get('@request_id')
+      conn.receive_message(Message)
+      conn.send(:wait_response)
+      expect(conn.instance_variable_get('@response')).to eq({
+          'example' =>'data 1',
+          'requestId' => conn.instance_variable_get('@request_id')
+      })
+    end
+
+    it :with_error do
+      conn = GremlinClient::Connection.new(timeout: 1)
+      conn.send(:reset_request)
+      Message.called = 0
+      Message.request_id = conn.instance_variable_get('@request_id')
+      conn.receive_error(Message)
+      expect{conn.send(:wait_response)}.to raise_exception(::GremlinClient::ServerError)
+    end
+  end
+
+  describe :treat_response do
+    it :success_statuses do
+      def test_status(name)
+        conn = GremlinClient::Connection.new
+        conn.send(:reset_request)
+        Message.request_id = conn.instance_variable_get('@request_id')
+        Message.status = name
+        conn.receive_message(Message)
+        conn.send(:treat_response)
+      end
+      test_status(:success)
+      test_status(:no_content)
+      test_status(:partial_content)
+    end
+
+    it :error_statuses do
+      def test_status(name)
+        conn = GremlinClient::Connection.new
+        conn.send(:reset_request)
+        Message.request_id = conn.instance_variable_get('@request_id')
+        Message.status = name
+        conn.receive_message(Message)
+        expect{conn.send(:treat_response)}.to raise_exception(::GremlinClient::ServerError)
+      end
+
+      [
+        :unauthorized,
+        :authenticate,
+        :malformed_request,
+        :invalid_request_arguments,
+        :server_error,
+        :script_evaluation_error,
+        :server_timeout,
+        :server_serialization_error
+      ].each { |name| test_status(name) }
+    end
+  end
+
+  it :build_message do
+    conn = GremlinClient::Connection.new
+    conn.send(:reset_request)
+    expect(JSON.parse(conn.send(:build_message, :query, :bindings))).to eq({
+      'requestId' => conn.instance_variable_get('@request_id'),
+      'op' => 'eval',
+      'processor' => '',
+      'args' => {
+        'gremlin' => 'query',
+        'bindings' => 'bindings',
+        'language' => 'gremlin-groovy'
+      }
+    })
+  end
+
+
+  it :resolve_path do
+    conn = GremlinClient::Connection.new
+    expect(conn.send(:resolve_path, 'test')).to eq('test')
+
+    conn = GremlinClient::Connection.new(gremlin_script_path: '/test/path')
+    expect(conn.send(:resolve_path, 'test')).to eq('/test/path/test')
+
+
+    conn = GremlinClient::Connection.new(gremlin_script_path: 'test/path')
+    expect(conn.send(:resolve_path, 'test')).to eq('test/path/test')
+  end
+end

data/spec/exceptions_spec.rb

@@ -0,0 +1,25 @@
+
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# test on formating messages from exceptions
+RSpec.describe :exceptions do
+  it :connection_timeout_error do
+    expect(::GremlinClient::ConnectionTimeoutError.new(10).to_s).to eq('10s')
+    expect(::GremlinClient::ConnectionTimeoutError.new(1).to_s).to eq('1s')
+    expect(::GremlinClient::ConnectionTimeoutError.new(1123).to_s).to eq('1123s')
+  end
+
+  it :execution_timeout_error do
+    expect(::GremlinClient::ExecutionTimeoutError.new(10).to_s).to eq('10s')
+    expect(::GremlinClient::ExecutionTimeoutError.new(1).to_s).to eq('1s')
+    expect(::GremlinClient::ExecutionTimeoutError.new(1123).to_s).to eq('1123s')
+  end
+
+  it :server_error do
+    expect(::GremlinClient::ServerError.new(:code, :message).to_s).to eq('message (code code)');
+    expect(::GremlinClient::ServerError.new(312, 'this exploded here').to_s).to eq('this exploded here (code 312)');
+  end
+end
+ 

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+require 'pp'
+Coveralls.wear!
+require 'gremlin_client'

data/spec/status_codes_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Tests on the freetext feature
+RSpec.describe :status_codes do
+  it :declared_every_code do
+    {
+      success: 200,
+      no_content: 204,
+      partial_content: 206,
+      unauthorized: 401,
+      authenticate: 407,
+      malformed_request: 498,
+      invalid_request_arguments: 499,
+      server_error: 500,
+      script_evaluation_error: 597,
+      server_timeout: 598,
+      server_serialization_error: 599
+    }.each_pair do |key, code|
+      expect(GremlinClient::Connection::STATUS[key]).to eq(code)
+    end
+  end
+
+  it :doesnt_have_extra_codes do
+    expect(GremlinClient::Connection::STATUS.count).to be(11)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gremlin_client
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Marcelo Coraça de Freitas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -118,6 +118,7 @@ files:
 - ".gitignore"
 - ".ruby-gemset"
 - ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -128,9 +129,14 @@ files:
 - gremlin_client.gemspec
 - lib/gremlin_client.rb
 - lib/gremlin_client/connection.rb
+- lib/gremlin_client/connection_timeout_error.rb
 - lib/gremlin_client/execution_timeout_error.rb
 - lib/gremlin_client/server_error.rb
 - lib/gremlin_client/version.rb
+- spec/connection_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb
+- spec/status_codes_spec.rb
 homepage: https://github.com/marcelocf/gremlin_client
 licenses:
 - Apache-2.0
@@ -156,4 +162,8 @@ rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple Gremlin server client for the WebSocketChannelizer
-test_files: []
+test_files:
+- spec/connection_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb
+- spec/status_codes_spec.rb