yax-fauna 3.0.1

data/lib/fauna/request_result.rb

@@ -0,0 +1,58 @@
+module Fauna
+  # The result of a request. Provided to observers and included within errors.
+  class RequestResult
+    # The Client.
+    attr_reader :client
+    # HTTP method. Either +:get+, +:post+, +:put+, +:patch+, or +:delete+
+    attr_reader :method
+    # Path that was queried. Relative to client's domain.
+    attr_reader :path
+    # URL query. +nil+ except for +GET+ requests.
+    attr_reader :query
+    # Request data.
+    attr_reader :request_content
+    # String value returned by the server.
+    attr_reader :response_raw
+    ##
+    # Parsed value returned by the server.
+    # Includes "resource" wrapper hash, or may be an "errors" hash instead.
+    # In the case of a JSON parse error, this will be nil.
+    attr_reader :response_content
+    # HTTP status code.
+    attr_reader :status_code
+    # A hash of headers.
+    attr_reader :response_headers
+    # Time the request started.
+    attr_reader :start_time
+    # Time the response was received.
+    attr_reader :end_time
+
+    def initialize(
+        client,
+        method, path, query, request_content,
+        response_raw, response_content, status_code, response_headers,
+        start_time, end_time) # :nodoc:
+      @client = client
+      @method = method
+      @path = path
+      @query = query
+      @request_content = request_content
+      @response_raw = response_raw
+      @response_content = response_content
+      @status_code = status_code
+      @response_headers = response_headers
+      @start_time = start_time
+      @end_time = end_time
+    end
+
+    # Real time spent performing the request.
+    def time_taken
+      end_time - start_time
+    end
+
+    # Credentials used by the client.
+    def auth
+      client.credentials
+    end
+  end
+end

data/lib/fauna/util.rb

@@ -0,0 +1,50 @@
+module Fauna
+  ##
+  # Converts microseconds to a Time object.
+  #
+  # +microseconds+:: Time in microseconds.
+  def self.time_from_usecs(microseconds)
+    Time.at(microseconds / 1_000_000, microseconds % 1_000_000)
+  end
+
+  ##
+  # Converts a Time object to microseconds.
+  #
+  # +time+:: A Time object.
+  def self.usecs_from_time(time)
+    time.to_i * 1_000_000 + time.usec
+  end
+
+  class DSLContext # :nodoc:
+    def self.eval_dsl(dsl, *args, &blk)
+      ctx = eval('self', blk.binding)
+      dsl.instance_variable_set(:@__ctx__, ctx)
+
+      ctx.instance_variables.each do |iv|
+        dsl.instance_variable_set(iv, ctx.instance_variable_get(iv))
+      end
+
+      dsl.instance_exec(*args, &blk)
+
+    ensure
+      dsl.instance_variables.each do |iv|
+        if iv.to_sym != :@__ctx__
+          ctx.instance_variable_set(iv, dsl.instance_variable_get(iv))
+        end
+      end
+    end
+
+    NON_PROXIED_METHODS = Set.new %w(__send__ object_id __id__ == equal?
+                                     ! != instance_exec instance_variables
+                                     instance_variable_get instance_variable_set
+                                  ).map(&:to_sym)
+
+    instance_methods.each do |method|
+      undef_method(method) unless NON_PROXIED_METHODS.include?(method.to_sym)
+    end
+
+    def method_missing(method, *args, &block)
+      @__ctx__.send(method, *args, &block)
+    end
+  end
+end

data/lib/fauna/version.rb

@@ -0,0 +1,4 @@
+module Fauna
+  # The version of the Fauna gem
+  VERSION = '3.0.1'.freeze
+end

data/spec/bytes_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Fauna::Bytes do
+  describe '#initalize' do
+    it 'creates from bytes' do
+      raw = random_bytes
+      expect(Fauna::Bytes.new(raw).bytes).to eq(raw)
+    end
+  end
+
+  describe '#from_base64' do
+    it 'creates from base64' do
+      raw = random_bytes
+      encoded = Base64.urlsafe_encode64(raw)
+
+      expect(Fauna::Bytes.from_base64(encoded).bytes).to eq(raw)
+    end
+  end
+
+  describe '#==' do
+    it 'equals same bytes' do
+      raw = random_bytes
+      bytes = Fauna::Bytes.new(raw)
+
+      expect(bytes).to eq(Fauna::Bytes.new(raw))
+    end
+
+    it 'does not equal different bytes' do
+      expect(Fauna::Bytes.new(random_bytes)).not_to eq(Fauna::Bytes.new(random_bytes))
+    end
+
+    it 'does not equal other type' do
+      raw = random_bytes
+
+      expect(Fauna::Bytes.new(raw)).not_to eq(raw)
+    end
+  end
+end

data/spec/client_logger_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Fauna::ClientLogger do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create_class(name: 'logger_test') }[:ref]
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  # Captures logger output from wrapped client and splits it into lines
+  def capture_log
+    lines = nil
+    observer = Fauna::ClientLogger.logger { |log| lines = log.split("\n") }
+
+    yield get_client(secret: @server_secret, observer: observer)
+
+    lambda { lines.shift }
+  end
+
+  it 'logs response' do
+    reader = capture_log do |client|
+      expect(client.ping).to eq('Scope write is OK')
+    end
+
+    expect(reader.call).to eq('Fauna GET /ping')
+    expect(reader.call).to match(/^  Credentials:/)
+    expect(reader.call).to eq('  Response headers: {')
+
+    # Skip through headers
+    loop do
+      line = reader.call
+      unless line.start_with? '    '
+        expect(line).to eq('  }')
+        break
+      end
+    end
+
+    expect(reader.call).to eq('  Response JSON: {')
+    expect(reader.call).to eq('    "resource": "Scope write is OK"')
+    expect(reader.call).to eq('  }')
+    expect(reader.call).to match(/^  Response \(200\): Network latency \d+ms$/)
+  end
+
+  it 'logs request content' do
+    value = random_number
+    reader = capture_log do |client|
+      client.query data: { a: value }
+    end
+
+    expect(reader.call).to eq("Fauna POST /")
+    expect(reader.call).to match(/^  Credentials:/)
+    expect(reader.call).to eq('  Request JSON: {')
+    expect(reader.call).to eq('    "object": {')
+    expect(reader.call).to eq('      "data": {')
+    expect(reader.call).to eq('        "object": {')
+    expect(reader.call).to eq("          \"a\": #{value}")
+    expect(reader.call).to eq('        }')
+    expect(reader.call).to eq('      }')
+    expect(reader.call).to eq('    }')
+    expect(reader.call).to eq('  }')
+    # Ignore the rest
+  end
+
+  it 'logs request query' do
+    reader = capture_log do |client|
+      client.ping scope: 'global'
+    end
+
+    expect(reader.call).to eq("Fauna GET /ping?scope=global")
+    # Ignore the rest
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,127 @@
+RSpec.describe Fauna::Client do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create_class(name: 'client_test') }[:ref]
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  describe 'connection' do
+    # Compress string with gzip
+    def gzipped(str)
+      out = ''
+      StringIO.open out do |io|
+        writer = Zlib::GzipWriter.new io
+        writer.write str
+        writer.flush
+        writer.close
+      end
+      out
+    end
+
+    it 'decodes gzip response' do
+      response = gzipped '{"resource": 1}'
+      test_client = stub_client(:post, '/', response, 'Content-Encoding' => 'gzip')
+      expect(test_client.query('tests/decode')).to be(1)
+    end
+
+    it 'decodes deflate response' do
+      response = Zlib::Deflate.deflate '{"resource": 1}'
+      test_client = stub_client(:post, '/', response, 'Content-Encoding' => 'deflate')
+      expect(test_client.query('tests/decode')).to be(1)
+    end
+  end
+
+  describe 'serialization' do
+    it 'decodes ref' do
+      ref = Fauna::Ref.new(random_number, Fauna::Ref.new(random_string, Fauna::Native.classes))
+      test_client = stub_client(:post, '/', to_json(resource: ref))
+
+      response = test_client.query('tests/ref')
+      expect(response).to be_a(Fauna::Ref)
+      expect(response).to eq(ref)
+    end
+
+    it 'decodes set' do
+      set = Fauna::SetRef.new(match: Fauna::Ref.new(random_string, Fauna::Native.indexes), terms: random_string)
+      test_client = stub_client(:post, '/', to_json(resource: set))
+
+      response = test_client.query('tests/set')
+      expect(response).to be_a(Fauna::SetRef)
+      expect(response).to eq(set)
+    end
+
+    it 'decodes obj' do
+      data = { random_string.to_sym => random_string }
+      obj = { :@obj => data }
+      test_client = stub_client(:post, '/', to_json(resource: obj))
+
+      response = test_client.query('tests/obj')
+      expect(response).to be_a(Hash)
+      expect(response).to eq(data)
+    end
+
+    it 'decodes ts' do
+      ts = Time.at(0).utc
+      test_client = stub_client(:post, '/', to_json(resource: ts))
+
+      response = test_client.query('tests/ts')
+      expect(response).to be_a(Time)
+      expect(response).to eq(ts)
+    end
+
+    it 'decodes date' do
+      date = Date.new(1970, 1, 1)
+      test_client = stub_client(:post, '/', to_json(resource: date))
+
+      response = test_client.query('tests/date')
+      expect(response).to be_a(Date)
+      expect(response).to eq(date)
+    end
+  end
+
+  describe '#with_secret' do
+    it 'creates client with secret' do
+      old_secret = random_string
+      new_secret = random_string
+
+      old_client = get_client(secret: old_secret)
+      new_client = old_client.with_secret(new_secret)
+
+      expect(old_client.credentials).to eq([old_secret])
+      expect(new_client.credentials).to eq([new_secret])
+    end
+  end
+
+  describe '#query' do
+    it 'performs query from expression' do
+      value = random_number
+
+      instance = client.query { create(@test_class, data: { a: value }) }
+
+      expect(instance[:ref].class_).to eq(@test_class)
+      expect(instance[:data][:a]).to eq(value)
+    end
+
+    it 'performs query from block' do
+      value = random_number
+
+      instance = client.query { create @test_class, data: { a: value } }
+
+      expect(instance[:ref].class_).to eq(@test_class)
+      expect(instance[:data][:a]).to eq(value)
+    end
+  end
+
+  describe '#ping' do
+    it 'performs ping' do
+      expect(client.ping).to eq('Scope write is OK')
+    end
+
+    it 'performs ping with scope' do
+      expect(client.ping(scope: 'node')).to eq('Scope node is OK')
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,84 @@
+RSpec.describe Fauna::Context do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create_class(name: 'context_test') }[:ref]
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  around do |ex|
+    # Ensure context is not shared between tests
+    Fauna::Context.reset
+    ex.run
+    Fauna::Context.reset
+  end
+
+  describe '#query' do
+    it 'performs query' do
+      Fauna::Context.block(client) do
+        expect(Fauna::Context.query { add 1, 1 }).to eq(2)
+      end
+    end
+  end
+
+  describe '#paginate' do
+    it 'performs paginate' do
+      Fauna::Context.block(client) do
+        expect(Fauna::Context.paginate(Fauna::Query.expr { ref('classes') }).data).to eq([@test_class])
+      end
+    end
+  end
+
+  describe '#push' do
+    it 'pushes new client' do
+      new = Fauna::Client.new
+
+      Fauna::Context.push(new)
+      expect(Fauna::Context.client).to be(new)
+    end
+  end
+
+  describe '#pop' do
+    it 'pops active client' do
+      outer = Fauna::Client.new
+      inner = Fauna::Client.new
+
+      Fauna::Context.push(outer)
+      Fauna::Context.push(inner)
+
+      expect(Fauna::Context.pop).to be(inner)
+      expect(Fauna::Context.client).to be(outer)
+    end
+  end
+
+  describe '#reset' do
+    it 'resets stack' do
+      initial = Fauna::Client.new
+      outer = Fauna::Client.new
+      inner = Fauna::Client.new
+
+      Fauna::Context.push(initial)
+      Fauna::Context.push(outer)
+      Fauna::Context.push(inner)
+
+      Fauna::Context.reset
+      expect { Fauna::Context.client }.to raise_error(Fauna::NoContextError)
+    end
+  end
+
+  describe '#block' do
+    it 'changes client within block' do
+      outer = Fauna::Client.new
+      inner = Fauna::Client.new
+      Fauna::Context.push(outer)
+
+      expect(Fauna::Context.client).to be(outer)
+      Fauna::Context.block(inner) do
+        expect(Fauna::Context.client).to be(inner)
+      end
+      expect(Fauna::Context.client).to be(outer)
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,185 @@
+RSpec.describe 'Fauna Errors' do
+  RSpec::Matchers.define :raise_fauna_error do |exception, code, position = nil|
+    match do |block|
+      expect(&block).to raise_error(exception) do |ex|
+        expect(ex.errors.length).to be(1)
+        error = ex.errors.first
+        expect(error.code).to eq(code)
+        expect(error.position).to eq(position)
+      end
+    end
+
+    def supports_block_expectations?
+      true
+    end
+  end
+
+  before(:all) do
+    create_test_db
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  # Create client with stub adapter responding to / with the given status and response
+  def stub_post(status_code, response)
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.post '/' do
+      [status_code, {}, response]
+    end
+    Fauna::Client.new(adapter: [:test, stubs])
+  end
+
+  # Create client with stub adapter responding to / with the given exception
+  def stub_error(exception)
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.post '/' do
+      fail exception
+    end
+    Fauna::Client.new(adapter: [:test, stubs])
+  end
+
+  it 'sets request result' do
+    expect { client.query { add 1, :two } }.to raise_error do |err|
+      expect(err).to be_a(Fauna::BadRequest)
+      expect(err.request_result.request_content).to eq(Fauna::Query.add [1, :two])
+    end
+  end
+
+  it 'parses query errors' do
+    expect { client.query { add 1, :two } }.to raise_fauna_error(Fauna::BadRequest, 'invalid argument', [:add, 1])
+  end
+
+  it 'parses invalid data' do
+    expect { client.query { create ref('classes'), name: 123 } }.to raise_error(Fauna::BadRequest) do |err|
+      expect(err.errors.length).to eq(1)
+      error = err.errors.first
+
+      expect(error.code).to eq('validation failed')
+      expect(error.position).to eq([])
+      expect(error.failures.length).to eq(1)
+      failure = error.failures.first
+
+      expect(failure.code).to eq('invalid type')
+      expect(failure.field).to eq([:name])
+    end
+  end
+
+  describe Fauna::ErrorData do
+    it 'handles inspect' do
+      err = Fauna::ErrorData.new 'code', 'desc', nil, nil
+      expect(err.inspect).to eq('ErrorData("code", "desc", nil, nil)')
+    end
+
+    it 'handles inspect with failures' do
+      failure = Fauna::Failure.new 'code', 'desc', [:a, :b]
+      err = Fauna::ErrorData.new 'code', 'desc', [:pos], [failure]
+      expect(err.inspect).to eq('ErrorData("code", "desc", [:pos], [Failure("code", "desc", [:a, :b])])')
+    end
+  end
+
+  describe Fauna::BadRequest do
+    it 'is handled' do
+      expect { client.query { add 1, 'string' } }.to raise_error(Fauna::BadRequest)
+    end
+  end
+
+  describe Fauna::Unauthorized do
+    it 'is handled' do
+      bad_client = get_client secret: 'bad_key'
+      expect { bad_client.query { get @db_ref } }.to raise_error(Fauna::Unauthorized)
+    end
+  end
+
+  describe Fauna::PermissionDenied do
+    it 'is handled' do
+      key = root_client.query { create ref('keys'), database: @db_ref, role: :client }
+
+      expect { get_client(secret: key[:secret]).query { paginate ref('databases') } }.to raise_fauna_error(
+        Fauna::PermissionDenied, 'permission denied', [:paginate])
+    end
+  end
+
+  describe Fauna::NotFound do
+    it 'is handled' do
+      expect { client.query { delete Fauna::Ref.new('classes') } }.to raise_fauna_error(Fauna::NotFound, 'instance not found', [])
+    end
+  end
+
+  describe Fauna::InternalError do
+    it 'is handled' do
+      stub_client = stub_post 500,
+        '{"errors": [{"code": "internal server error", "description": "sample text", "stacktrace": []}]}'
+
+      expect { stub_client.query '' }.to raise_fauna_error(Fauna::InternalError, 'internal server error')
+    end
+  end
+
+  describe Fauna::UnavailableError do
+    it 'handles fauna 503' do
+      stub_client = stub_post 503, '{"errors": [{"code": "unavailable", "description": "on vacation"}]}'
+      expect { stub_client.query '' }.to raise_fauna_error(Fauna::UnavailableError, 'unavailable')
+    end
+
+    it 'handles upstream 502' do
+      stub_client = stub_post 502, 'Bad gateway'
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, 'Bad gateway')
+    end
+
+    it 'handles upstream 503' do
+      stub_client = stub_post 503, 'Unable to reach server'
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, 'Unable to reach server')
+    end
+
+    it 'handles upstream 504' do
+      stub_client = stub_post 504, 'Server timeout'
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, 'Server timeout')
+    end
+
+    it 'handles upstream json 503' do
+      stub_client = stub_post 503, '{ "error" : "service unavailable" }'
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, '{ "error" : "service unavailable" }')
+    end
+
+    it 'handles timeout error' do
+      stub_client = stub_error Faraday::TimeoutError.new('timeout')
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, 'Faraday::TimeoutError: timeout')
+    end
+
+    it 'handles connection error' do
+      stub_client = stub_error Faraday::ConnectionFailed.new('connection refused')
+      expect { stub_client.query '' }.to raise_error(Fauna::UnavailableError, 'Faraday::ConnectionFailed: connection refused')
+    end
+  end
+
+  describe Fauna::UnexpectedError do
+    it 'raised for json error' do
+      expect { stub_post(200, 'I like fine wine').query('') }.to raise_error(Fauna::UnexpectedError, /json/i) do |err|
+        rr = err.request_result
+        expect(rr.response_content).to be_nil
+        expect(rr.response_raw).to eq('I like fine wine')
+      end
+    end
+
+    it 'raised for missing resource' do
+      expect { stub_post(200, '{"notaresource": 1}').query('') }.to raise_error(Fauna::UnexpectedError, /expected key/)
+    end
+
+    it 'raised for unexpected code' do
+      expect { stub_post(1337, '{"errors": []}').query('') }.to raise_error(Fauna::UnexpectedError, /status code/)
+    end
+
+    it 'raised for bad errors format' do
+      expect { stub_post(500, '{"errors": true}').query('') }.to raise_error(Fauna::UnexpectedError, /unexpected format/)
+    end
+
+    it 'raised for empty errors' do
+      expect { stub_post(500, '{"errors": []}').query('') }.to raise_error(Fauna::UnexpectedError, /blank/)
+    end
+
+    it 'raised for parsing error' do
+      expect { stub_error(Faraday::ParsingError.new('parse error')).query('') }.to raise_error(Fauna::UnexpectedError, /parse error/)
+    end
+  end
+end