fauna 2.4.0 → 3.0.0

data/lib/fauna/version.rb

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

data/spec/client_logger_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Fauna::ClientLogger do
   before(:all) do
     create_test_db
-    @test_class = client.post('classes', name: 'logger_test')[:ref]
+    @test_class = client.query { create_class(name: 'logger_test') }[:ref]
   end
 
   after(:all) do
@@ -20,7 +20,7 @@ RSpec.describe Fauna::ClientLogger do
 
   it 'logs response' do
     reader = capture_log do |client|
-      expect(client.ping).to eq('Scope global is OK')
+      expect(client.ping).to eq('Scope write is OK')
     end
 
     expect(reader.call).to eq('Fauna GET /ping')
@@ -37,7 +37,7 @@ RSpec.describe Fauna::ClientLogger do
     end
 
     expect(reader.call).to eq('  Response JSON: {')
-    expect(reader.call).to eq('    "resource": "Scope global is OK"')
+    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
@@ -45,29 +45,29 @@ RSpec.describe Fauna::ClientLogger do
   it 'logs request content' do
     value = random_number
     reader = capture_log do |client|
-      client.post @test_class, data: { a: value }
+      client.query data: { a: value }
     end
 
-    expect(reader.call).to eq("Fauna POST /#{@test_class}")
+    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('    "data": {')
-    expect(reader.call).to eq("      \"a\": #{value}")
+    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
-    instance = client.post(@test_class)
-    ref = instance[:ref]
-    ts = instance[:ts]
-
     reader = capture_log do |client|
-      client.get ref, ts: ts
+      client.ping scope: 'global'
     end
 
-    expect(reader.call).to eq("Fauna GET /#{ref}?ts=#{ts}")
+    expect(reader.call).to eq("Fauna GET /ping?scope=global")
     # Ignore the rest
   end
 end

data/spec/client_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Fauna::Client do
   before(:all) do
     create_test_db
-    @test_class = client.post('classes', name: 'client_test')[:ref]
+    @test_class = client.query { create_class(name: 'client_test') }[:ref]
   end
 
   after(:all) do
@@ -23,32 +23,32 @@ RSpec.describe Fauna::Client do
 
     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)
+      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(:get, 'tests/decode', response, 'Content-Encoding' => 'deflate')
-      expect(test_client.get('tests/decode')).to be(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("classes/#{random_string}/#{random_number}")
-      test_client = stub_client(:get, 'tests/ref', to_json(resource: ref))
+      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.get('tests/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("indexes/#{random_string}"), terms: random_string)
-      test_client = stub_client(:get, 'tests/set', to_json(resource: set))
+      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.get('tests/set')
+      response = test_client.query('tests/set')
       expect(response).to be_a(Fauna::SetRef)
       expect(response).to eq(set)
     end
@@ -56,27 +56,27 @@ RSpec.describe Fauna::Client do
     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))
+      test_client = stub_client(:post, '/', to_json(resource: obj))
 
-      response = test_client.get('tests/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(:get, 'tests/ts', to_json(resource: ts))
+      test_client = stub_client(:post, '/', to_json(resource: ts))
 
-      response = test_client.get('tests/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(:get, 'tests/date', to_json(resource: date))
+      test_client = stub_client(:post, '/', to_json(resource: date))
 
-      response = test_client.get('tests/date')
+      response = test_client.query('tests/date')
       expect(response).to be_a(Date)
       expect(response).to eq(date)
     end
@@ -99,9 +99,9 @@ RSpec.describe Fauna::Client do
     it 'performs query from expression' do
       value = random_number
 
-      instance = client.query(Fauna::Query.create(@test_class, data: { a: value }))
+      instance = client.query { create(@test_class, data: { a: value }) }
 
-      expect(instance[:class]).to eq(@test_class)
+      expect(instance[:ref].class_).to eq(@test_class)
       expect(instance[:data][:a]).to eq(value)
     end
 
@@ -110,89 +110,14 @@ RSpec.describe Fauna::Client do
 
       instance = client.query { create @test_class, data: { a: value } }
 
-      expect(instance[:class]).to eq(@test_class)
+      expect(instance[:ref].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')
+      expect(client.ping).to eq('Scope write is OK')
     end
 
     it 'performs ping with scope' do

data/spec/context_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Fauna::Context do
   before(:all) do
     create_test_db
-    @test_class = client.post('classes', name: 'context_test')[:ref]
+    @test_class = client.query { create_class(name: 'context_test') }[:ref]
   end
 
   after(:all) do
@@ -15,51 +15,6 @@ RSpec.describe Fauna::Context do
     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

data/spec/errors_spec.rb

@@ -23,9 +23,9 @@ RSpec.describe 'Fauna Errors' do
   end
 
   # Create client with stub adapter responding to / with the given status and response
-  def stub_get(status_code, response)
+  def stub_post(status_code, response)
     stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get '/' do
+    stubs.post '/' do
       [status_code, {}, response]
     end
     Fauna::Client.new(adapter: [:test, stubs])
@@ -34,16 +34,16 @@ RSpec.describe 'Fauna Errors' do
   # Create client with stub adapter responding to / with the given exception
   def stub_error(exception)
     stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get '/' do
+    stubs.post '/' do
       fail exception
     end
     Fauna::Client.new(adapter: [:test, stubs])
   end
 
   it 'sets request result' do
-    expect { client.post '', foo: 'bar' }.to raise_error do |err|
+    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(foo: 'bar')
+      expect(err.request_result.request_content).to eq(Fauna::Query.add [1, :two])
     end
   end
 
@@ -81,7 +81,7 @@ RSpec.describe 'Fauna Errors' do
 
   describe Fauna::BadRequest do
     it 'is handled' do
-      expect { client.post '', foo: 'bar' }.to raise_error(Fauna::BadRequest)
+      expect { client.query { add 1, 'string' } }.to raise_error(Fauna::BadRequest)
     end
   end
 
@@ -103,65 +103,59 @@ RSpec.describe 'Fauna Errors' do
 
   describe Fauna::NotFound do
     it 'is handled' do
-      expect { client.get 'classes/no_class' }.to raise_fauna_error(Fauna::NotFound, 'not found')
-    end
-  end
-
-  describe Fauna::MethodNotAllowed do
-    it 'is handled' do
-      expect { client.delete 'classes' }.to raise_fauna_error(Fauna::MethodNotAllowed, 'method not allowed')
+      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_get 500,
+      stub_client = stub_post 500,
         '{"errors": [{"code": "internal server error", "description": "sample text", "stacktrace": []}]}'
 
-      expect { stub_client.get '' }.to raise_fauna_error(Fauna::InternalError, 'internal server error')
+      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_get 503, '{"errors": [{"code": "unavailable", "description": "on vacation"}]}'
-      expect { stub_client.get '' }.to raise_fauna_error(Fauna::UnavailableError, 'unavailable')
+      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_get 502, 'Bad gateway'
-      expect { stub_client.get '' }.to raise_error(Fauna::UnavailableError, 'Bad gateway')
+      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_get 503, 'Unable to reach server'
-      expect { stub_client.get '' }.to raise_error(Fauna::UnavailableError, 'Unable to reach server')
+      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_get 504, 'Server timeout'
-      expect { stub_client.get '' }.to raise_error(Fauna::UnavailableError, 'Server timeout')
+      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_get 503, '{ "error" : "service unavailable" }'
-      expect { stub_client.get '' }.to raise_error(Fauna::UnavailableError, '{ "error" : "service unavailable" }')
+      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.get '' }.to raise_error(Fauna::UnavailableError, 'Faraday::TimeoutError: 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.get '' }.to raise_error(Fauna::UnavailableError, 'Faraday::ConnectionFailed: 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_get(200, 'I like fine wine').get('') }.to raise_error(Fauna::UnexpectedError, /json/i) do |err|
+      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')
@@ -169,23 +163,23 @@ RSpec.describe 'Fauna Errors' do
     end
 
     it 'raised for missing resource' do
-      expect { stub_get(200, '{"notaresource": 1}').get('') }.to raise_error(Fauna::UnexpectedError, /expected key/)
+      expect { stub_post(200, '{"notaresource": 1}').query('') }.to raise_error(Fauna::UnexpectedError, /expected key/)
     end
 
     it 'raised for unexpected code' do
-      expect { stub_get(1337, '{"errors": []}').get('') }.to raise_error(Fauna::UnexpectedError, /status code/)
+      expect { stub_post(1337, '{"errors": []}').query('') }.to raise_error(Fauna::UnexpectedError, /status code/)
     end
 
     it 'raised for bad errors format' do
-      expect { stub_get(500, '{"errors": true}').get('') }.to raise_error(Fauna::UnexpectedError, /unexpected format/)
+      expect { stub_post(500, '{"errors": true}').query('') }.to raise_error(Fauna::UnexpectedError, /unexpected format/)
     end
 
     it 'raised for empty errors' do
-      expect { stub_get(500, '{"errors": []}').get('') }.to raise_error(Fauna::UnexpectedError, /blank/)
+      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')).get('') }.to raise_error(Fauna::UnexpectedError, /parse error/)
+      expect { stub_error(Faraday::ParsingError.new('parse error')).query('') }.to raise_error(Fauna::UnexpectedError, /parse error/)
     end
   end
 end