fauna 1.3.4 → 2.0.0

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

@@ -1,9 +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, &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(&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 = '2.0.0'
+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.post('classes', 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 global 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 global 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.post @test_class, data: { a: value }
+    end
+
+    expect(reader.call).to eq("Fauna POST /#{@test_class}")
+    expect(reader.call).to match(/^  Credentials:/)
+    expect(reader.call).to eq('  Request JSON: {')
+    expect(reader.call).to eq('    "data": {')
+    expect(reader.call).to eq("      \"a\": #{value}")
+    expect(reader.call).to eq('    }')
+    expect(reader.call).to eq('  }')
+    # Ignore the rest
+  end
+
+  it 'logs request query' do
+    instance = client.post(@test_class)
+    ref = instance[:ref]
+    ts = instance[:ts]
+
+    reader = capture_log do |client|
+      client.get ref, ts: ts
+    end
+
+    expect(reader.call).to eq("Fauna GET /#{ref}?ts=#{ts}")
+    # Ignore the rest
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,202 @@
+RSpec.describe Fauna::Client do
+  before(:all) do
+    create_test_db
+    @test_class = client.post('classes', 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(:get, 'tests/decode', response, 'Content-Encoding' => 'gzip')
+      expect(test_client.get('tests/decode')).to be(1)
+    end
+
+    it 'decodes deflate response' do
+      response = Zlib::Deflate.deflate '{"resource": 1}'
+      test_client = stub_client(:get, 'tests/decode', response, 'Content-Encoding' => 'deflate')
+      expect(test_client.get('tests/decode')).to be(1)
+    end
+  end
+
+  describe 'serialization' do
+    it 'decodes ref' do
+      ref = Fauna::Ref.new('classes', random_string, random_number)
+      test_client = stub_client(:get, 'tests/ref', to_json(resource: ref))
+
+      response = test_client.get('tests/ref')
+      expect(response).to be_a(Fauna::Ref)
+      expect(response).to eq(ref)
+    end
+
+    it 'decodes set' do
+      set = Fauna::SetRef.new(match: random_string, index: Fauna::Ref.new('indexes', random_string))
+      test_client = stub_client(:get, 'tests/set', to_json(resource: set))
+
+      response = test_client.get('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(:get, 'tests/obj', to_json(resource: obj))
+
+      response = test_client.get('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(:get, 'tests/ts', to_json(resource: ts))
+
+      response = test_client.get('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(:get, 'tests/date', to_json(resource: date))
+
+      response = test_client.get('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(Fauna::Query.create(@test_class, data: { a: value }))
+
+      expect(instance[: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[:class]).to eq(@test_class)
+      expect(instance[:data][:a]).to eq(value)
+    end
+  end
+
+  describe '#get' do
+    it 'performs GET' do
+      value = random_number
+      ref = client.post(@test_class, data: { a: value })[:ref]
+
+      instance = client.get(ref)
+
+      expect(instance[:ref]).to eq(ref)
+      expect(instance[:data][:a]).to eq(value)
+    end
+
+    it 'performs GET with query' do
+      value = random_number
+      created = client.post(@test_class, data: { a: value })
+      ref = created[:ref]
+      ts = created[:ts]
+
+      instance = client.get(ref, ts: ts)
+
+      expect(instance[:ref]).to eq(ref)
+      expect(instance[:data][:a]).to eq(value)
+
+      expect { client.get(ref, ts: ts - 1) }.to raise_error(Fauna::NotFound)
+    end
+  end
+
+  describe '#post' do
+    it 'performs POST' do
+      value = random_number
+
+      instance = client.post(@test_class, data: { a: value })
+
+      expect(instance[:class]).to eq(@test_class)
+      expect(instance[:data][:a]).to eq(value)
+    end
+  end
+
+  describe '#put' do
+    it 'performs PUT' do
+      value = random_number
+      ref = client.post(@test_class, data: { a: random_number })[:ref]
+
+      instance = client.put(ref, data: { b: value })
+
+      expect(instance[:ref]).to eq(ref)
+      expect(instance[:data][:a]).to be_nil
+      expect(instance[:data][:b]).to eq(value)
+    end
+  end
+
+  describe '#patch' do
+    it 'performs PATCH' do
+      value1 = random_number
+      value2 = random_number
+      ref = client.post(@test_class, data: { a: value1 })[:ref]
+
+      instance = client.patch(ref, data: { b: value2 })
+
+      expect(instance[:ref]).to eq(ref)
+      expect(instance[:data][:a]).to eq(value1)
+      expect(instance[:data][:b]).to eq(value2)
+    end
+  end
+
+  describe '#delete' do
+    it 'performs DELETE' do
+      ref = client.post(@test_class, data: { a: random_number })[:ref]
+
+      instance = client.delete(ref)
+
+      expect(instance[:ref]).to eq(ref)
+      expect { client.get(ref) }.to raise_error(Fauna::NotFound)
+    end
+  end
+
+  describe '#ping' do
+    it 'performs ping' do
+      expect(client.ping).to eq('Scope global 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,121 @@
+RSpec.describe Fauna::Context do
+  before(:all) do
+    create_test_db
+    @test_class = client.post('classes', 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 'REST methods' do
+    around do |ex|
+      stubs = Faraday::Adapter::Test::Stubs.new
+      [:get, :post, :put, :patch, :delete].each do |method|
+        stubs.send(method, '/tests/context') do |env|
+          [200, {}, { resource: env.method.to_s.upcase }.to_json]
+        end
+      end
+
+      Fauna::Context.block(Fauna::Client.new(adapter: [:test, stubs])) do
+        ex.run
+      end
+    end
+
+    describe '#get' do
+      it 'performs GET request' do
+        expect(Fauna::Context.get('tests/context')).to eq('GET')
+      end
+    end
+
+    describe '#post' do
+      it 'performs POST request' do
+        expect(Fauna::Context.post('tests/context')).to eq('POST')
+      end
+    end
+
+    describe '#put' do
+      it 'performs PUT request' do
+        expect(Fauna::Context.put('tests/context')).to eq('PUT')
+      end
+    end
+
+    describe '#patch' do
+      it 'performs PATCH request' do
+        expect(Fauna::Context.patch('tests/context')).to eq('PATCH')
+      end
+    end
+
+    describe '#delete' do
+      it 'performs DELETE request' do
+        expect(Fauna::Context.delete('tests/context')).to eq('DELETE')
+      end
+    end
+  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 '#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