yax-fauna 3.0.1

data/spec/fauna_helper.rb

@@ -0,0 +1,102 @@
+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 admin_client
+    fail 'Admin client not initialized' if @admin_client.nil?
+    @admin_client
+  end
+
+  def create_test_db
+    @db_ref = Fauna::Ref.new("faunadb-ruby-test-#{random_string}", Fauna::Native.databases)
+
+    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' }
+      admin_key = root.query { create ref('keys'), database: @db_ref, role: 'admin' }
+    rescue
+      root.query { delete @db_ref }
+      @db_ref = nil
+      raise
+    end
+
+    @server_secret = server_key[:secret]
+    @server_client = get_client secret: @server_secret
+    @admin_secret = admin_key[:secret]
+    @admin_client = get_client secret: @admin_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_bytes
+    SecureRandom.random_bytes(20)
+  end
+
+  def random_ref_string
+    "classes/#{random_string}/#{random_number}"
+  end
+
+  def to_json(value)
+    Fauna::FaunaJson.to_json(value)
+  end
+
+  def from_json(value)
+    Fauna::FaunaJson.json_load(value)
+  end
+
+  def wait_for_index(*refs)
+    sleep 1 until client.query { map(refs) { |ref| select([:active], get(ref)) } }.all? { |active| active }
+  end
+end
+
+# Shared classes
+class DummyClass
+  def initialize(value)
+    @value = value
+  end
+end

data/spec/json_spec.rb

@@ -0,0 +1,161 @@
+RSpec.describe Fauna::FaunaJson do
+  describe '#deserialize' do
+    it 'deserializes ref' do
+      ref = random_ref_string
+
+      data = { :@ref => { id: ref } }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'deserializes set' do
+      ref = random_ref_string
+      terms = random_string
+
+      data = { :@set => { match: { :@ref => { id: 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 query' do
+      query = { lambda: 'a', expr: { add: [{ var: 'a' }, 1] } }
+      obj = Fauna::QueryV.new(query)
+
+      expect(Fauna::FaunaJson.deserialize(:@query => query)).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 'deserializes bytes' do
+      raw = random_bytes
+
+      data = { :@bytes => Base64.urlsafe_encode64(raw) }
+      obj = Fauna::Bytes.new(raw)
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'recursively deserializes hashes' do
+      ref = random_ref_string
+
+      data = { test: { :@obj => { :@ref => { id: ref } } } }
+      obj = { test: Fauna::Ref.new(ref) }
+
+      expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
+    end
+
+    it 'recursively deserializes arrays' do
+      ref1 = random_ref_string
+      ref2 = random_ref_string
+
+      data = [{ :@ref => { id: ref1 } }, { :@ref => { id: 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_string
+
+      data = { :@ref => { id: ref } }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes set' do
+      ref = random_ref_string
+
+      data = { :@ref => { id: ref } }
+      obj = Fauna::Ref.new(ref)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'serializes query' do
+      query = { lambda: 'a', expr: { add: [{ var: 'a' }, 1] } }
+      obj = Fauna::QueryV.new(query)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(:@query => query)
+    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 'serializes bytes' do
+      raw = random_bytes
+
+      data = { :@bytes => Base64.urlsafe_encode64(raw) }
+      obj = Fauna::Bytes.new(raw)
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'recursively serializes hashes' do
+      ref = random_ref_string
+      terms = random_string
+
+      data = { a: { time: { :@ts => '1970-01-01T00:00:00.000000000Z' } }, b: { :@set => { match: { :@ref => { id: 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_string
+      ref2 = random_ref_string
+
+      data = [{ :@ref => { id: ref1 } }, { :@ref => { id: ref2 } }]
+      obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
+
+      expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
+    end
+
+    it 'fails on unserializable objects' do
+      obj = DummyClass.new(random_string)
+
+      expect { Fauna::FaunaJson.serialize(obj) }.to raise_error(Fauna::SerializationError)
+    end
+  end
+end

data/spec/page_spec.rb

@@ -0,0 +1,357 @@
+RSpec.describe Fauna::Page do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create ref('classes'), name: 'page_test' }[:ref]
+    @foreach_class = client.query { create ref('classes'), name: 'page_foreach' }[:ref]
+
+    index_refs = client.query { create ref('indexes'), name: 'page_refs', source: @test_class }
+    index_values = client.query { create ref('indexes'), name: 'page_values', source: @test_class, values: [{ field: %w(data value) }] }
+    index_foreach = client.query { create ref('indexes'), name: 'page_apply', source: @foreach_class }
+
+    wait_for_index(index_refs[:ref], index_values[:ref], index_foreach[:ref])
+
+    @refs_index = index_refs[:ref]
+    @values_index = index_values[:ref]
+    @foreach_index = index_foreach[:ref]
+
+    @instances = client.query { (1..6).collect { |x| create(@test_class, data: { value: x }) } }.sort_by { |inst| inst[:ref].id }
+    @instance_refs = @instances.collect { |instance| instance[:ref] }
+    @instance_values = @instances.collect { |instance| instance[:data][:value] }.sort
+
+    @refs_match = Fauna::Query.match(@refs_index)
+    @values_match = Fauna::Query.match(@values_index)
+    @foreach_match = Fauna::Query.match(@foreach_index)
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  describe '#==' do
+    it 'equals identical page' do
+      page1 = Fauna::Page.new(client, @refs_match, size: 1)
+      page2 = Fauna::Page.new(client, @refs_match, size: 1)
+
+      expect(page1).to eq(page2)
+    end
+
+    it 'does not equal different page' do
+      page1 = Fauna::Page.new(client, @refs_match, size: 1234)
+      page2 = Fauna::Page.new(client, @refs_match, size: 4321)
+
+      expect(page1).not_to eq(page2)
+    end
+  end
+
+  it 'can\'t mutate params directly' do
+    page = client.paginate(@refs_match)
+
+    expect { page.params[:ts] = random_number }.to raise_error(RuntimeError, 'can\'t modify frozen Hash')
+
+    page = page.with_params(ts: random_number)
+
+    expect { page.params[:ts] = random_number }.to raise_error(RuntimeError, 'can\'t modify frozen Hash')
+  end
+
+  describe 'builders' do
+    def get_funcs(page)
+      page.instance_variable_get(:@fauna_funcs)
+    end
+
+    def get_postprocessing(page)
+      page.instance_variable_get(:@postprocessing_map)
+    end
+
+    describe '#with_params' do
+      let(:ref1) { random_ref_string }
+      let(:ref2) { random_ref_string }
+
+      it 'sets params on copy' do
+        ts1 = random_number
+        ts2 = random_number
+
+        page = client.paginate(@refs_match, ts: ts1)
+
+        expect(page.with_params(ts: ts2, sources: false).params).to eq(ts: ts2, sources: false)
+        expect(page.params).to eq(ts: ts1)
+      end
+
+      it 'reverses cursor' do
+        page = client.paginate(@refs_match, before: ref1)
+
+        expect(page.with_params(after: ref2).params).to eq(after: ref2)
+        expect(page.params).to eq(before: ref1)
+      end
+
+      it 'preserves nil' do
+        page = client.paginate(@refs_match, after: nil)
+
+        expect(page.with_params(before: nil).params).to eq(before: nil)
+        expect(page.params).to eq(after: nil)
+      end
+
+      it 'resets paging' do
+        page = client.paginate(@refs_match, size: 1)
+        page1 = page.page_after
+
+        page2 = page1.with_params(after: 0).page_after
+
+        expect(page2.data).to eq(page2.data)
+      end
+    end
+
+    describe '#map' do
+      it 'sets map on copy' do
+        page = client.paginate(@refs_match)
+
+        expect(get_funcs(page.map { |ref| get ref }).length).to be(1)
+        expect(get_funcs(page).length).to be(0)
+      end
+
+      it 'performs map when paging' do
+        page = client.paginate(@refs_match).map { |ref| get ref }
+
+        expect(page.all).to eq(@instances)
+      end
+    end
+
+    describe '#filter' do
+      it 'sets filter on copy' do
+        page = client.paginate(@values_match)
+
+        expect(get_funcs(page.filter { |value| equals(modulo(value, 2), 0) }).length).to be(1)
+        expect(get_funcs(page).length).to be(0)
+      end
+
+      it 'performs filter when paging' do
+        page = client.paginate(@values_match).filter { |value| equals(modulo(value, 2), 0) }
+
+        expect(page.all).to eq(@instance_values.find_all(&:even?))
+      end
+    end
+
+    describe '#postprocessing_map' do
+      it 'sets ruby map on copy' do
+        page = client.paginate(@refs_match)
+
+        expect(get_postprocessing(page.postprocessing_map(&:id))).to be_a(Proc)
+        expect(get_postprocessing(page)).to be_nil
+      end
+    end
+  end
+
+  describe '#load!' do
+    it 'explicitly loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@data)).to be_nil
+      page.load!
+      expect(page.instance_variable_get(:@data)).to eq(expected)
+    end
+
+    it 'returns true when page was loaded' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+
+      expect(page.instance_variable_get(:@populated)).to be(false)
+      expect(page.load!).to be(true)
+      expect(page.instance_variable_get(:@populated)).to be(true)
+    end
+
+    it 'returns false when page not loaded' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+
+      page.load!
+      expect(page.instance_variable_get(:@populated)).to be(true)
+      expect(page.load!).to be(false)
+    end
+  end
+
+  describe '#data' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@data)).to be_nil
+      expect(page.data).to eq(expected)
+      expect(page.instance_variable_get(:@data)).to eq(expected)
+    end
+  end
+
+  describe '#before' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@before)).to be_nil
+      expect(page.before).to eq(expected)
+      expect(page.instance_variable_get(:@before)).to eq(expected)
+    end
+  end
+
+  describe '#after' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[2]]
+
+      expect(page.instance_variable_get(:@after)).to be_nil
+      expect(page.after).to eq(expected)
+      expect(page.instance_variable_get(:@after)).to eq(expected)
+    end
+  end
+
+  describe '#page_after' do
+    it 'returns the page after' do
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      @instance_refs.drop(1).each do |ref|
+        page = page.page_after
+        expect(page.data.first).to eq(ref)
+      end
+    end
+
+    it 'returns nil on last page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs.last)
+
+      expect(page.data.first).to eq(@instance_refs.last)
+      expect(page.page_after).to be_nil
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      expect(page.data.first).to eq(@instance_refs[0])
+      expect(page.page_after.data.first).to eq(@instance_refs[1])
+
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      expect(page.page_after.data.first).to eq(@instance_refs[1])
+    end
+  end
+
+  describe '#page_before' do
+    it 'returns the page before' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      @instance_refs.reverse.drop(1).each do |ref|
+        page = page.page_before
+        expect(page.data.first).to eq(ref)
+      end
+    end
+
+    it 'returns nil on last page' do
+      page = client.paginate(@refs_match, size: 1, before: @instance_refs.first)
+
+      expect(page.page_before).to be_nil
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      expect(page.data.first).to eq(@instance_refs[-1])
+      expect(page.page_before.data.first).to eq(@instance_refs[-2])
+
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      expect(page.page_before.data.first).to eq(@instance_refs[-2])
+    end
+  end
+
+  it 'pages both directions' do
+    page = client.paginate(@refs_match, size: 1, after: 0)
+    expect(page.data.first).to eq(@instance_refs[0])
+
+    page = page.page_after
+    expect(page.data.first).to eq(@instance_refs[1])
+
+    page = page.page_before
+    expect(page.data.first).to eq(@instance_refs[0])
+  end
+
+  describe '#each' do
+    it 'iterates the set in the after direction' do
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.data).to eq([@instance_refs.first])
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+    end
+
+    context 'with fauna map' do
+      it 'iterates the set using the fauna map' do
+        page = client.paginate(@refs_match, size: 1) { |ref| get(ref) }
+        instances = @instances.collect { |inst| [inst] }
+
+        expect(page.each.collect { |inst| inst }).to eq(instances)
+      end
+
+      it 'chains multiple collection functions' do
+        page = client.paginate(@refs_match, size: 1)
+        # Map ref to value
+        page = page.map { |ref| select(['data', 'value'], get(ref)) }
+        # Filter out odd numbers
+        page = page.filter { |value| equals(modulo(value, 2), 0) }
+        # Map to double the value
+        page = page.map { |value| multiply(value, 2) }
+
+        # We are using the index on refs, not value, so we need to expect the values to be sorted by instance ref
+        expected = @instances.collect { |inst| inst[:data][:value] }.find_all(&:even?).collect { |v| v * 2 }
+
+        expect(page.all).to eq(expected)
+      end
+    end
+
+    context 'with ruby map' do
+      it 'iterates the set using the ruby map' do
+        page = client.paginate(@refs_match, size: 1).postprocessing_map(&:id)
+        ids = @instance_refs.collect { |ref| [ref.id] }
+
+        expect(page.each.collect { |id| id }).to eq(ids)
+      end
+    end
+  end
+
+  describe '#reverse_each' do
+    it 'iterates the set in the before direction' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+      refs = @instance_refs.reverse.collect { |ref| [ref] }
+
+      expect(page.reverse_each.collect { |ref| ref }).to eq(refs)
+    end
+  end
+
+  describe '#all' do
+    it 'returns full contents of the set' do
+      page = client.paginate(@refs_match, size: 1)
+
+      expect(page.all).to eq(@instance_refs)
+    end
+  end
+
+  describe '#foreach!' do
+    before(:each) do
+      @apply_refs = client.query { (1..3).collect { |x| select([:ref], create(@foreach_class, data: { value: x })) } }
+    end
+
+    it 'applies foreach to set' do
+      # Sanity
+      expect(client.query { map(@apply_refs) { |ref| exists ref } }).to eq(@apply_refs.collect { true })
+
+      client.paginate(@foreach_match, size: 1).foreach! { |ref| delete ref }
+
+      expect(client.query { map(@apply_refs) { |ref| exists ref } }).to eq(@apply_refs.collect { false })
+    end
+  end
+end