fauna 1.3.4 → 2.0.0

data/spec/errors_spec.rb

@@ -0,0 +1,144 @@
+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_get(status_code, response)
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get '/' do
+      [status_code, {}, response]
+    end
+    Fauna::Client.new(adapter: [:test, stubs])
+  end
+
+  it 'sets request result' do
+    expect { client.post '', foo: 'bar' }.to raise_error do |err|
+      expect(err).to be_a(Fauna::BadRequest)
+      expect(err.request_result.request_content).to eq(foo: 'bar')
+    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.post '', foo: 'bar' }.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.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')
+    end
+  end
+
+  describe Fauna::InternalError do
+    it 'is handled' do
+      stub_client = stub_get 500,
+        '{"errors": [{"code": "internal server error", "description": "sample text", "stacktrace": []}]}'
+
+      expect { stub_client.get '' }.to raise_fauna_error(Fauna::InternalError, 'internal server error')
+    end
+  end
+
+  describe Fauna::UnavailableError do
+    it 'is handled' do
+      stub_client = stub_get 503, '{"errors": [{"code": "unavailable", "description": "on vacation"}]}'
+      expect { stub_client.get '' }.to raise_fauna_error(Fauna::UnavailableError, 'unavailable')
+    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|
+        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_get(200, '{"notaresource": 1}').get('') }.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/)
+    end
+
+    it 'raised for bad errors format' do
+      expect { stub_get(500, '{"errors": true}').get('') }.to raise_error(Fauna::UnexpectedError, /unexpected format/)
+    end
+  end
+end

data/spec/fauna_helper.rb

@@ -0,0 +1,87 @@
+require 'fauna'
+require 'securerandom'
+
+FAUNA_ROOT_KEY = ENV['FAUNA_ROOT_KEY']
+FAUNA_DOMAIN = ENV['FAUNA_DOMAIN']
+FAUNA_SCHEME = ENV['FAUNA_SCHEME']
+FAUNA_PORT = ENV['FAUNA_PORT']
+
+module FaunaTestHelpers
+  def get_client(params = {})
+    params = { domain: FAUNA_DOMAIN, scheme: FAUNA_SCHEME, port: FAUNA_PORT }.merge(params)
+    fail 'No secret provided' unless params.key? :secret
+    Fauna::Client.new params
+  end
+
+  def root_client
+    fail 'FAUNA_ROOT_KEY must be defined in your environment to run tests' unless FAUNA_ROOT_KEY
+    get_client secret: FAUNA_ROOT_KEY
+  end
+
+  def client
+    fail 'Server client not initialized' if @server_client.nil?
+    @server_client
+  end
+
+  def create_test_db
+    @db_ref = Fauna::Ref.new 'databases', "faunadb-ruby-test-#{random_string}"
+
+    root = root_client
+    root.query { create ref('databases'), name: @db_ref.id }
+
+    begin
+      server_key = root.query { create ref('keys'), database: @db_ref, role: 'server' }
+    rescue
+      root.query { delete @db_ref }
+      @db_ref = nil
+      raise
+    end
+
+    @server_secret = server_key[:secret]
+    @server_client = get_client secret: @server_secret
+  end
+
+  def destroy_test_db
+    root_client.query { delete @db_ref } unless @db_ref.nil?
+  end
+
+  def stub_client(method, url, response = nil, headers = {})
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.send(method, url) do |env|
+      if response.nil?
+        [200, headers, { resource: { method: env.method.to_s.upcase, body: JSON.load(env.body) } }.to_json]
+      else
+        [200, headers, response]
+      end
+    end
+    Fauna::Client.new(adapter: [:test, stubs])
+  end
+
+  def random_string
+    SecureRandom.hex(7)
+  end
+
+  def random_number
+    SecureRandom.random_number(1_000_000)
+  end
+
+  def random_ref
+    "classes/#{random_string}/#{random_number}"
+  end
+
+  def random_class_ref
+    "classes/#{random_string}"
+  end
+
+  def to_json(value)
+    Fauna::FaunaJson.to_json(value)
+  end
+
+  def from_json(value)
+    Fauna::FaunaJson.json_load(value)
+  end
+
+  def wait_for_active(ref)
+    sleep 1 until client.query { get(ref) }[:active]
+  end
+end

data/spec/json_spec.rb

@@ -0,0 +1,123 @@
+RSpec.describe Fauna::FaunaJson do
+  describe '#deserialize' do
+    it 'deserializes ref' do
+      ref = random_ref
+
+      data = { :@ref => ref }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'deserializes set' do
+      ref = random_ref
+      terms = random_string
+
+      data = { :@set => { match: { :@ref => ref }, terms: terms } }
+      obj = Fauna::SetRef.new(match: Fauna::Ref.new(ref), terms: terms)
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'deserializes obj' do
+      obj = { a: random_string, b: random_string }
+      data = { :@obj => obj }
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'deserializes ts' do
+      data = { :@ts => '1970-01-01T00:00:00.000000000Z' }
+      obj = Time.at(0).utc
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'deserializes date' do
+      data = { :@date => '1970-01-01' }
+      obj = Date.new(1970, 1, 1)
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'recursively deserializes hashes' do
+      ref = random_ref
+
+      data = { test: { :@obj => { :@ref => ref } } }
+      obj = { test: Fauna::Ref.new(ref) }
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'recursively deserializes arrays' do
+      ref1 = random_ref
+      ref2 = random_ref
+
+      data = [{ :@ref => ref1 }, { :@ref => ref2 }]
+      obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+  end
+
+  describe '#to_json' do
+    it 'serializes ref' do
+      ref = random_ref
+
+      data = { :@ref => ref }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes set' do
+      ref = random_ref
+
+      data = { :@ref => ref }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes expr' do
+      data = { a: random_string, b: random_number }
+      obj = Fauna::Query::Expr.new(data)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes time' do
+      data = { :@ts => '1970-01-01T00:00:00.000000000Z' }
+      obj = Time.at(0).utc
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes date' do
+      data = { :@date => '1970-01-01' }
+      obj = Date.new(1970, 1, 1)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'recursively serializes hashes' do
+      ref = random_ref
+      terms = random_string
+
+      data = { a: { time: { :@ts => '1970-01-01T00:00:00.000000000Z' } }, b: { :@set => { match: { :@ref => ref }, terms: terms } } }
+      obj = { a: { time: Time.at(0).utc }, b: Fauna::SetRef.new(match: Fauna::Ref.new(ref), terms: terms) }
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'recursively serializes arrays' do
+      ref1 = random_ref
+      ref2 = random_ref
+
+      data = [{ :@ref => ref1 }, { :@ref => ref2 }]
+      obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,675 @@
+RSpec.describe Fauna::Query do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create ref('classes'), name: 'query_test' }[:ref]
+
+    index_x = client.query do
+      create ref('indexes'), name: 'query_by_x', source: @test_class, terms: [{ path: 'data.x' }]
+    end
+    index_y = client.query do
+      create ref('indexes'), name: 'query_by_y', source: @test_class, terms: [{ path: 'data.y' }]
+    end
+
+    wait_for_active(index_x[:ref])
+    wait_for_active(index_y[:ref])
+
+    @test_by_x = index_x[:ref]
+    @test_by_y = index_y[:ref]
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  # Alias for creating test class instance with provided data
+  def create_instance(data = {})
+    client.query { create(@test_class, data: data) }
+  end
+
+  # Helper to collect all the contents of a set
+  def get_set_data(set, params = {})
+    data = []
+
+    page = client.query { paginate(set, params) }
+    data += page[:data]
+    while page.key? :after
+      page = client.query { paginate(set, params.merge(after: page[:after])) }
+      data += page[:data]
+    end
+
+    data
+  end
+
+  describe Fauna::Query::Expr do
+    it 'converts to string' do
+      expr = Fauna::Query::Expr.new(
+        add: Fauna::Query::Expr.new(
+          [1, Fauna::Query::Expr.new(divide: Fauna::Query::Expr.new([4, 2]))]
+        )
+      )
+      as_string = 'Expr({:add=>Expr([1, Expr({:divide=>Expr([4, 2])})])})'
+
+      expect(expr.to_s).to eq(as_string)
+    end
+  end
+
+  describe '#expr' do
+    it 'maintains lexical scope' do
+      def test_method
+        'foo'
+      end
+      test_var = 'bar'
+
+      expect(Fauna::Query.expr { test_method }).to eq('foo')
+      expect(Fauna::Query.expr { test_var }).to eq('bar')
+    end
+
+    it 'recursively wraps hashes' do
+      expr = Fauna::Query.expr { { x: 1, y: { foo: 2 }, z: add(1, 2) } }
+      query = { object: { x: 1, y: { object: { foo: 2 } }, z: { add: [1, 2] } } }
+
+      expect(to_json(expr)).to eq(to_json(query))
+    end
+
+    it 'recursively wraps special types' do
+      expr = Fauna::Query.expr { { x: { y: Time.at(0).utc } } }
+      query = { object: { x: { object: { y: { :@ts => '1970-01-01T00:00:00.000000000Z' } } } } }
+
+      expect(to_json(expr)).to eq(to_json(query))
+    end
+
+    it 'round-trips special types', skip: 'Support for auto-escaping of special types is deferred' do
+      expect(client.query { { '@ref' => 'foo' } }).to eq(:@ref => 'foo')
+    end
+  end
+
+  describe '#ref' do
+    it 'creates a ref' do
+      ref = random_ref
+      expect(Fauna::Query.ref(ref)).to eq(Fauna::Ref.new(ref))
+    end
+  end
+
+  describe '#object' do
+    it 'wraps fields in object' do
+      data = { a: random_string, b: random_number }
+      expect(Fauna::Query.object(data).raw).to eq(object: data)
+    end
+  end
+
+  describe '#let' do
+    it 'performs let with expression' do
+      x = random_number
+      expect(client.query { let({ x: x }, var(:x)) }).to eq(x)
+    end
+
+    it 'performs let with block' do
+      x = random_number
+      expect(client.query { let(x: x) { x } }).to eq(x)
+    end
+  end
+
+  describe '#var' do
+    it 'creates a var' do
+      name = random_string
+      expect(Fauna::Query.var(name).raw).to eq(var: name)
+    end
+  end
+
+  describe '#if_' do
+    it 'performs an if' do
+      expect(client.query { if_(true, 't', 'f') }).to eq('t')
+      expect(client.query { if_(false, 't', 'f') }).to eq('f')
+    end
+  end
+
+  describe '#do_' do
+    it 'performs do' do
+      instance = create_instance
+      expect(client.query { do_(delete(instance[:ref]), 1) }).to eq(1)
+      expect(client.query { exists instance[:ref] }).to be(false)
+    end
+  end
+
+  describe '#lambda' do
+    it 'raises when block takes no arguments' do
+      expect { Fauna::Query.lambda {} }.to raise_error(ArgumentError)
+    end
+
+    it 'raises when block takes splat argument' do
+      expect { Fauna::Query.lambda { |*vars| add(vars) } }.to raise_error(ArgumentError)
+    end
+
+    it 'performs lambda from single argument' do
+      expr = Fauna::Query.expr { lambda { |a| add(a, a) } }
+      query = { lambda: :a, expr: { add: [{ var: :a }, { var: :a }] } }
+
+      expect(to_json(expr)).to eq(to_json(query))
+      expect(client.query { map([1, 2, 3], expr) }).to eq([2, 4, 6])
+    end
+
+    it 'performs lambda from multiple arguments' do
+      expr = Fauna::Query.expr { lambda { |a, b| [b, a] } }
+      query = { lambda: [:a, :b], expr: [{ var: :b }, { var: :a }] }
+
+      expect(to_json(expr)).to eq(to_json(query))
+      expect(client.query { map([[1, 2], [3, 4]], expr) }).to eq([[2, 1], [4, 3]])
+    end
+  end
+
+  describe '#lambda_expr' do
+    it 'performs lambda from expression' do
+      expr = Fauna::Query.expr { lambda_expr(:a, add(var(:a), var(:a))) }
+      query = { lambda: :a, expr: { add: [{ var: :a }, { var: :a }] } }
+
+      expect(to_json(expr)).to eq(to_json(query))
+      expect(client.query { map([1, 2, 3], expr) }).to eq([2, 4, 6])
+    end
+
+    it 'destructures single element arrays' do
+      expr = Fauna::Query.expr { lambda_expr([:a], add(var(:a), var(:a))) }
+      query = { lambda: [:a], expr: { add: [{ var: :a }, { var: :a }] } }
+
+      expect(to_json(expr)).to eq(to_json(query))
+      expect(client.query { map([[1], [2], [3]], expr) }).to eq([2, 4, 6])
+    end
+  end
+
+  describe '#map' do
+    it 'performs map from expression' do
+      input = (1..3).collect { random_number }
+      output = input.collect { |x| 2 * x }
+
+      expect(client.query { map(input, lambda { |a| multiply 2, a }) }).to eq(output)
+    end
+
+    it 'performs map from block' do
+      input = (1..3).collect { random_number }
+      output = input.collect { |x| 2 * x }
+
+      expect(client.query { map(input) { |a| multiply 2, a } }).to eq(output)
+    end
+  end
+
+  describe '#foreach' do
+    before(:each) do
+      @refs = (1..3).collect { create_instance[:ref] }
+
+      # Sanity check
+      expect(client.query { @refs.collect { |ref| exists ref } }).to eq(@refs.collect { true })
+    end
+
+    it 'performs foreach from expression' do
+      client.query { foreach @refs, lambda { |a| delete a } }
+
+      expect(client.query { @refs.collect { |ref| exists ref } }).to eq(@refs.collect { false })
+    end
+
+    it 'performs foreach from block' do
+      client.query { foreach(@refs) { |a| delete a } }
+
+      expect(client.query { @refs.collect { |ref| exists ref } }).to eq(@refs.collect { false })
+    end
+  end
+
+  describe '#filter' do
+    it 'performs filter from expression' do
+      expect(client.query { filter([1, 2, 3, 4], lambda { |a| equals modulo(a, 2), 0 }) }).to eq([2, 4])
+    end
+
+    it 'performs filter from block' do
+      expect(client.query { filter([1, 2, 3, 4]) { |a| equals modulo(a, 2), 0 } }).to eq([2, 4])
+    end
+  end
+
+  describe '#take' do
+    it 'performs take' do
+      expect(client.query { take(1, [1, 2]) }).to eq([1])
+      expect(client.query { take(3, [1, 2]) }).to eq([1, 2])
+      expect(client.query { take(-1, [1, 2]) }).to eq([])
+    end
+  end
+
+  describe '#drop' do
+    it 'performs drop' do
+      expect(client.query { drop(1, [1, 2]) }).to eq([2])
+      expect(client.query { drop(3, [1, 2]) }).to eq([])
+      expect(client.query { drop(-1, [1, 2]) }).to eq([1, 2])
+    end
+  end
+
+  describe '#prepend' do
+    it 'performs prepend' do
+      expect(client.query { prepend([4, 5, 6], [1, 2, 3]) }).to eq([1, 2, 3, 4, 5, 6])
+    end
+  end
+
+  describe '#append' do
+    it 'performs append' do
+      expect(client.query { append([1, 2, 3], [4, 5, 6]) }).to eq([1, 2, 3, 4, 5, 6])
+    end
+  end
+
+  describe '#get' do
+    it 'performs get' do
+      instance = create_instance
+
+      expect(client.query { get instance[:ref] }).to eq(instance)
+    end
+  end
+
+  describe '#paginate' do
+    before do
+      @x_value = random_number
+      @x_refs = (1..3).collect { create_instance(x: @x_value)[:ref] }
+    end
+
+    it 'performs paginate' do
+      set = Fauna::Query.match(@test_by_x, @x_value)
+
+      expect(get_set_data(set, size: 1)).to eq(@x_refs)
+    end
+
+    it 'performs paginate with sources' do
+      response = {
+        data: @x_refs.collect do |ref|
+          { sources: [Fauna::SetRef.new(match: @test_by_x, terms: @x_value)], value: ref }
+        end
+      }
+
+      expect(client.query { paginate(match(@test_by_x, @x_value), sources: true) }).to eq(response)
+    end
+  end
+
+  describe '#exists' do
+    it 'performs exists' do
+      ref = create_instance[:ref]
+
+      expect(client.query { exists ref }).to be(true)
+      client.query { delete ref }
+      expect(client.query { exists ref }).to be(false)
+
+      # Sanity check
+      expect { client.query { get ref } }.to raise_error(Fauna::NotFound)
+    end
+  end
+
+  describe '#count' do
+    before do
+      @x_value = random_number
+      @x_refs = (1..3).collect { create_instance(x: @x_value)[:ref] }
+    end
+
+    it 'performs count' do
+      set = Fauna::Query.match(@test_by_x, @x_value)
+
+      # Count is only approximate; should be equal to @x_refs.length
+      expect(client.query { count set }).to be_a(Integer)
+    end
+  end
+
+  describe '#create' do
+    it 'performs create' do
+      instance = client.query { create(@test_class, {}) }
+
+      expect(instance[:class]).to eq(@test_class)
+      expect(client.query { exists instance[:ref] }).to be(true)
+    end
+  end
+
+  describe '#update' do
+    it 'performs update' do
+      x = random_number
+      y = random_number
+      ref = create_instance(x: x)[:ref]
+
+      instance = client.query { update(ref, data: { y: y }) }
+      expect(instance[:data]).to eq(x: x, y: y)
+    end
+  end
+
+  describe '#replace' do
+    it 'performs replace' do
+      x = random_number
+      y = random_number
+      ref = create_instance(x: x)[:ref]
+
+      instance = client.query { replace(ref, data: { y: y }) }
+      expect(instance[:data]).to eq(y: y)
+    end
+  end
+
+  describe '#delete' do
+    it 'performs delete' do
+      ref = create_instance[:ref]
+
+      client.query { delete ref }
+      expect(client.query { exists ref }).to be(false)
+    end
+  end
+
+  describe '#insert' do
+    it 'performs insert' do
+      instance = create_instance
+      ref = instance[:ref]
+      ts = instance[:ts]
+
+      prev_ts = ts - 1
+      value = random_number
+      client.query { insert(ref, prev_ts, :create, data: { x: value }) }
+
+      expect(client.query { get(ref, ts: prev_ts) }[:data]).to eq(x: value)
+    end
+  end
+
+  describe '#remove' do
+    it 'performs remove' do
+      # Create the instance
+      instance = create_instance
+      ref = instance[:ref]
+
+      # Change the instance
+      new_instance = client.query { replace(ref, data: { x: random_number }) }
+      expect(client.query { get(ref) }).to eq(new_instance)
+
+      # Delete the event
+      client.query { remove(ref, new_instance[:ts], :create) }
+
+      # Assert it changed
+      expect(client.query { get(ref) }).to eq(instance)
+    end
+  end
+
+  describe 'sets' do
+    before do
+      @x_value = random_number
+      @y_value = random_number
+
+      @ref_x = create_instance(x: @x_value)[:ref]
+      @ref_y = create_instance(y: @y_value)[:ref]
+      @ref_xy = create_instance(x: @x_value, y: @y_value)[:ref]
+    end
+
+    describe '#match' do
+      it 'performs match' do
+        set = Fauna::Query.expr { match(@test_by_x, @x_value) }
+        expect(get_set_data(set)).to contain_exactly(@ref_x, @ref_xy)
+      end
+    end
+
+    describe '#union' do
+      it 'performs union' do
+        set = Fauna::Query.expr { union(match(@test_by_x, @x_value), match(@test_by_y, @y_value)) }
+        expect(get_set_data(set)).to contain_exactly(@ref_x, @ref_y, @ref_xy)
+      end
+    end
+
+    describe '#intersection' do
+      it 'performs intersection' do
+        set = Fauna::Query.expr { intersection(match(@test_by_x, @x_value), match(@test_by_y, @y_value)) }
+        expect(get_set_data(set)).to contain_exactly(@ref_xy)
+      end
+    end
+
+    describe '#difference' do
+      it 'performs difference' do
+        set = Fauna::Query.expr { difference(match(@test_by_x, @x_value), match(@test_by_y, @y_value)) }
+        expect(get_set_data(set)).to contain_exactly(@ref_x)
+      end
+    end
+  end
+
+  describe '#distinct' do
+    before do
+      over_z = client.query do
+        create ref('indexes'), name: 'query_over_z', source: @test_class, values: [{ path: 'data.z' }]
+      end
+      wait_for_active(over_z[:ref])
+      @test_over_z = over_z[:ref]
+
+      @refs = []
+      @refs << client.query { create @test_class, data: { z: 0 } }[:ref]
+      @refs << client.query { create @test_class, data: { z: 1 } }[:ref]
+      @refs << client.query { create @test_class, data: { z: 1 } }[:ref]
+    end
+
+    it 'performs distinct' do
+      set = Fauna::Query.match(@test_over_z)
+      distinct = Fauna::Query.distinct(set)
+
+      expect(get_set_data(set)).to eq([0, 1, 1])
+      expect(get_set_data(distinct)).to eq([0, 1])
+    end
+  end
+
+  describe '#join' do
+    before do
+      @x_value = random_number
+      @join_refs = (1..3).collect { create_instance(x: @x_value)[:ref] }
+      @assoc_refs = @join_refs.collect { |ref| create_instance(y: ref)[:ref] }
+    end
+
+    context 'with expression' do
+      it 'performs join' do
+        source = Fauna::Query.match(@test_by_x, @x_value)
+        expect(get_set_data(source)).to eq(@join_refs)
+
+        # Get associated refs
+        set = Fauna::Query.expr { join(source, lambda { |a| match(@test_by_y, a) }) }
+        expect(get_set_data(set)).to eq(@assoc_refs)
+      end
+    end
+
+    context 'with block' do
+      it 'performs join' do
+        source = Fauna::Query.match(@test_by_x, @x_value)
+        expect(get_set_data(source)).to eq(@join_refs)
+
+        # Get associated refs
+        set = Fauna::Query.expr { join(source) { |a| match(@test_by_y, a) } }
+        expect(get_set_data(set)).to eq(@assoc_refs)
+      end
+    end
+  end
+
+  describe 'authentication' do
+    before do
+      @password = random_string
+      @user = client.query { create @test_class, credentials: { password: @password } }
+    end
+
+    describe '#login' do
+      it 'performs login' do
+        token = client.query { login @user[:ref], password: @password }
+        user_client = get_client secret: token[:secret]
+
+        expect(user_client.query { select(:ref, get(ref('tokens/self'))) }).to eq(token[:ref])
+      end
+    end
+
+    describe '#logout' do
+      it 'performs logout' do
+        token = client.query { login @user[:ref], password: @password }
+        user_client = get_client secret: token[:secret]
+
+        expect(user_client.query { logout true }).to be(true)
+      end
+    end
+
+    describe '#identify' do
+      it 'performs identify' do
+        expect(client.query { identify(@user[:ref], @password) }).to be(true)
+      end
+    end
+  end
+
+  describe '#concat' do
+    it 'performs concat' do
+      expect(client.query { concat ['a', 'b', 'c'] }).to eq('abc')
+      expect(client.query { concat [] }).to eq('')
+    end
+
+    it 'performs concat with separator' do
+      expect(client.query { concat(['a', 'b', 'c'], '.') }).to eq('a.b.c')
+    end
+  end
+
+  describe '#casefold' do
+    it 'performs casefold' do
+      expect(client.query { casefold 'Hen Wen' }).to eq('hen wen')
+    end
+  end
+
+  describe '#test' do
+    it 'performs time' do
+      # `.round 9` is necessary because MRI 1.9.3 stores with greater precision than just nanoseconds.
+      # This cuts it down to just nanoseconds so that the times compare as equal.
+      time = Time.at(0, 123_456.789).round 9
+      expect(client.query { time '1970-01-01T00:00:00.123456789Z' }).to eq(time)
+
+      # 'now' refers to the current time.
+      expect(client.query { time 'now' }).to be_a(Time)
+    end
+  end
+
+  describe '#epoch' do
+    it 'performs epoch for seconds' do
+      secs = random_number
+      expect(client.query { epoch(secs, 'second') }).to eq(Time.at(secs).utc)
+    end
+
+    it 'performs epoch for nanoseconds' do
+      nanos = random_number
+      expect(client.query { epoch(nanos, 'nanosecond') }).to eq(Time.at(Rational(nanos, 1_000_000_000)).utc)
+    end
+  end
+
+  describe '#date' do
+    it 'performs date' do
+      expect(client.query { date('1970-01-01') }).to eq(Date.new(1970, 1, 1))
+    end
+  end
+
+  describe '#equals' do
+    it 'performs equals' do
+      expect(client.query { equals(1, 1, 1) }).to be(true)
+      expect(client.query { equals(1, 1, 2) }).to be(false)
+      expect(client.query { equals 1 }).to be(true)
+    end
+  end
+
+  describe '#contains' do
+    it 'performs contains' do
+      obj = { a: { b: 1 } }
+
+      expect(client.query { contains([:a, :b], obj) }).to be(true)
+      expect(client.query { contains(:a, obj) }).to be(true)
+      expect(client.query { contains([:a, :c], obj) }).to be(false)
+    end
+  end
+
+  describe '#select' do
+    it 'performs select with hash' do
+      obj = { a: { b: 1 } }
+
+      expect(client.query { select(:a, obj) }).to eq(b: 1)
+      expect(client.query { select([:a, :b], obj) }).to eq(1)
+      expect(client.query { select(:c, obj, default: nil) }).to be_nil
+      expect { client.query { select(:c, obj) } }.to raise_error(Fauna::NotFound)
+    end
+
+    it 'performs select with array' do
+      arr = [1, 2, 3]
+
+      expect(client.query { select(2, arr) }).to eq(3)
+      expect { client.query { select(3, arr) } }.to raise_error(Fauna::NotFound)
+    end
+  end
+
+  describe '#add' do
+    it 'performs add' do
+      expect(client.query { add(2, 3, 5) }).to eq(10)
+    end
+  end
+
+  describe '#multiply' do
+    it 'performs multiply' do
+      expect(client.query { multiply(2, 3, 5) }).to eq(30)
+    end
+  end
+
+  describe '#subtract' do
+    it 'performs subtract' do
+      expect(client.query { subtract(2, 3, 5) }).to eq(-6)
+      expect(client.query { subtract(2) }).to eq(2)
+    end
+  end
+
+  describe '#divide' do
+    it 'performs divide' do
+      expect(client.query { divide(2.0, 3, 5) }).to eq(2.0 / 15)
+      expect(client.query { divide(2) }).to eq(2)
+    end
+  end
+
+  describe '#modulo' do
+    it 'performs modulo' do
+      expect(client.query { modulo(5, 2) }).to eq(1)
+      expect(client.query { modulo(15, 10, 2) }).to eq(1)
+      expect(client.query { modulo(2) }).to eq(2)
+    end
+  end
+
+  describe '#lt' do
+    it 'performs lt' do
+      expect(client.query { lt(1, 2) }).to be(true)
+      expect(client.query { lt(2, 2) }).to be(false)
+    end
+  end
+
+  describe '#lte' do
+    it 'performs lte' do
+      expect(client.query { lte(1, 1) }).to be(true)
+      expect(client.query { lte(2, 1) }).to be(false)
+    end
+  end
+
+  describe '#gt' do
+    it 'performs gt' do
+      expect(client.query { gt(2, 1) }).to be(true)
+      expect(client.query { gt(2, 2) }).to be(false)
+    end
+  end
+
+  describe '#gte' do
+    it 'performs gte' do
+      expect(client.query { gte(2, 2) }).to be(true)
+      expect(client.query { gte(2, 3) }).to be(false)
+    end
+  end
+
+  describe '#and_' do
+    it 'performs and' do
+      expect(client.query { and_(true, true, false) }).to be(false)
+      expect(client.query { and_(true, true, true) }).to be(true)
+      expect(client.query { and_(true) }).to be(true)
+      expect(client.query { and_(false) }).to be(false)
+    end
+  end
+
+  describe '#or_' do
+    it 'performs or' do
+      expect(client.query { or_(false, false, true) }).to be(true)
+      expect(client.query { or_(false, false, false) }).to be(false)
+      expect(client.query { or_(true) }).to be(true)
+      expect(client.query { or_(false) }).to be(false)
+    end
+  end
+
+  describe '#not_' do
+    it 'performs not' do
+      expect(client.query { not_(true) }).to be(false)
+      expect(client.query { not_(false) }).to be(true)
+    end
+  end
+end