fauna 2.4.0 → 3.0.0

data/spec/fauna_helper.rb

@@ -29,7 +29,7 @@ module FaunaTestHelpers
   end
 
   def create_test_db
-    @db_ref = Fauna::Ref.new "databases/faunadb-ruby-test-#{random_string}"
+    @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 }

data/spec/json_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Fauna::FaunaJson do
     it 'deserializes ref' do
       ref = random_ref_string
 
-      data = { :@ref => ref }
+      data = { :@ref => { id: ref } }
       obj = Fauna::Ref.new(ref)
 
       expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
@@ -13,7 +13,7 @@ RSpec.describe Fauna::FaunaJson do
       ref = random_ref_string
       terms = random_string
 
-      data = { :@set => { match: { :@ref => ref }, terms: terms } }
+      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)
@@ -59,7 +59,7 @@ RSpec.describe Fauna::FaunaJson do
     it 'recursively deserializes hashes' do
       ref = random_ref_string
 
-      data = { test: { :@obj => { :@ref => ref } } }
+      data = { test: { :@obj => { :@ref => { id: ref } } } }
       obj = { test: Fauna::Ref.new(ref) }
 
       expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
@@ -69,7 +69,7 @@ RSpec.describe Fauna::FaunaJson do
       ref1 = random_ref_string
       ref2 = random_ref_string
 
-      data = [{ :@ref => ref1 }, { :@ref => ref2 }]
+      data = [{ :@ref => { id: ref1 } }, { :@ref => { id: ref2 } }]
       obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
 
       expect(Fauna::FaunaJson.deserialize(data)).to eq(obj)
@@ -80,7 +80,7 @@ RSpec.describe Fauna::FaunaJson do
     it 'serializes ref' do
       ref = random_ref_string
 
-      data = { :@ref => ref }
+      data = { :@ref => { id: ref } }
       obj = Fauna::Ref.new(ref)
 
       expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
@@ -89,7 +89,7 @@ RSpec.describe Fauna::FaunaJson do
     it 'serializes set' do
       ref = random_ref_string
 
-      data = { :@ref => ref }
+      data = { :@ref => { id: ref } }
       obj = Fauna::Ref.new(ref)
 
       expect(Fauna::FaunaJson.serialize(obj)).to eq(data)
@@ -136,7 +136,7 @@ RSpec.describe Fauna::FaunaJson do
       ref = random_ref_string
       terms = random_string
 
-      data = { a: { time: { :@ts => '1970-01-01T00:00:00.000000000Z' } }, b: { :@set => { match: { :@ref => ref }, terms: terms } } }
+      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)
@@ -146,7 +146,7 @@ RSpec.describe Fauna::FaunaJson do
       ref1 = random_ref_string
       ref2 = random_ref_string
 
-      data = [{ :@ref => ref1 }, { :@ref => ref2 }]
+      data = [{ :@ref => { id: ref1 } }, { :@ref => { id: ref2 } }]
       obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
 
       expect(Fauna::FaunaJson.serialize(obj)).to eq(data)

data/spec/page_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Fauna::Page do
     @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: [{ path: 'data.value' }] }
+    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])

data/spec/query_spec.rb

@@ -4,10 +4,10 @@ RSpec.describe Fauna::Query do
     @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' }]
+      create ref('indexes'), name: 'query_by_x', source: @test_class, terms: [{ field: %w(data x) }]
     end
     index_y = client.query do
-      create ref('indexes'), name: 'query_by_y', source: @test_class, terms: [{ path: 'data.y' }]
+      create ref('indexes'), name: 'query_by_y', source: @test_class, terms: [{ field: %w(data y) }]
     end
 
     wait_for_index(index_x[:ref], index_y[:ref])
@@ -106,13 +106,21 @@ RSpec.describe Fauna::Query do
 
   describe '#ref' do
     it 'returns a ref from a string' do
-      str = random_ref_string
-      expect(Fauna::Query.ref(str)).to eq(Fauna::Ref.new(str))
+      cls = random_string
+      id = random_number.to_s
+      str = "classes/#{cls}/#{id}"
+      expect(client.query { ref(str) }).to eq(Fauna::Ref.new(id, Fauna::Ref.new(cls, Fauna::Native.classes)))
     end
 
     it 'constructs a ref' do
-      expect(client.query { ref(@test_class, '123') }).to eq(Fauna::Ref.new('classes/query_test/123'))
-      expect(client.query { ref(@test_class, next_id) }.value).to match(%r{^classes/query_test/\d+$})
+      expect(client.query { ref(@test_class, '123') }).to eq(Fauna::Ref.new('123', @test_class))
+      expect(client.query { ref(@test_class, new_id) }.id).to match(%r{\d+$})
+    end
+  end
+
+  describe '#abort' do
+    it 'aborts the execution' do
+      expect { client.query { abort('message') }}.to raise_error(Fauna::BadRequest)
     end
   end
 
@@ -387,7 +395,7 @@ RSpec.describe Fauna::Query do
     it 'performs create' do
       instance = client.query { create(@test_class, {}) }
 
-      expect(instance[:class]).to eq(@test_class)
+      expect(instance[:ref].class_).to eq(@test_class)
       expect(client.query { exists instance[:ref] }).to be(true)
     end
   end
@@ -517,6 +525,43 @@ RSpec.describe Fauna::Query do
       @ref_xy = create_instance(x: @x_value, y: @y_value)[:ref]
     end
 
+    describe '#events' do
+      it 'performs events' do
+        client.query { update @ref_x, data: {x: random_number} }
+        client.query { delete @ref_x }
+
+        events = client.query { paginate events(@ref_x) }[:data]
+
+        expect(events.count).to be(3)
+
+        expect(events[0][:action]).to eq('create')
+        expect(events[0][:instance]).to eq(@ref_x)
+
+        expect(events[1][:action]).to eq('update')
+        expect(events[1][:instance]).to eq(@ref_x)
+
+        expect(events[2][:action]).to eq('delete')
+        expect(events[2][:instance]).to eq(@ref_x)
+      end
+    end
+
+    describe '#singleton' do
+      it 'performs singleton' do
+        client.query { update @ref_x, data: {x: random_number} }
+        client.query { delete @ref_x }
+
+        events = client.query { paginate events(singleton(@ref_x)) }[:data]
+
+        expect(events.count).to be(2)
+
+        expect(events[0][:action]).to eq('add')
+        expect(events[0][:instance]).to eq(@ref_x)
+
+        expect(events[1][:action]).to eq('remove')
+        expect(events[1][:instance]).to eq(@ref_x)
+      end
+    end
+
     describe '#match' do
       it 'performs match' do
         set = Fauna::Query.expr { match(@test_by_x, @x_value) }
@@ -549,7 +594,7 @@ RSpec.describe Fauna::Query do
   describe '#distinct' do
     before do
       over_z = client.query do
-        create ref('indexes'), name: 'query_over_z', source: @test_class, values: [{ path: 'data.z' }]
+        create ref('indexes'), name: 'query_over_z', source: @test_class, values: [{ field: %w(data z) }]
       end
       wait_for_index(over_z[:ref])
       @test_over_z = over_z[:ref]
@@ -621,7 +666,8 @@ RSpec.describe Fauna::Query 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])
+        self_ = Fauna::Ref.new('self', Fauna::Native.tokens)
+        expect(user_client.query { select(:ref, get(self_)) }).to eq(token[:ref])
       end
     end
 
@@ -639,6 +685,25 @@ RSpec.describe Fauna::Query do
         expect(client.query { identify(@user[:ref], @password) }).to be(true)
       end
     end
+
+    describe '#has_identity' do
+      it 'performs has_identity' do
+        token = client.query { login @user[:ref], password: @password }
+        user_client = get_client secret: token[:secret]
+
+        expect(client.query { has_identity }).to be(false)
+        expect(user_client.query { has_identity }).to be(true)
+      end
+    end
+
+    describe '#identity' do
+      it 'performs identity' do
+        token = client.query { login @user[:ref], password: @password }
+        user_client = get_client secret: token[:secret]
+
+        expect(user_client.query { identity }).to eq(@user[:ref])
+      end
+    end
   end
 
   describe '#concat' do
@@ -655,6 +720,14 @@ RSpec.describe Fauna::Query do
   describe '#casefold' do
     it 'performs casefold' do
       expect(client.query { casefold 'Hen Wen' }).to eq('hen wen')
+
+      # https://unicode.org/reports/tr15/
+      expect(client.query { casefold("\u212B", "NFD") } ).to eq("A\u030A")
+      expect(client.query { casefold("\u212B", "NFC") } ).to eq("\u00C5")
+      expect(client.query { casefold("\u1E9B\u0323", "NFKD") } ).to eq("\u0073\u0323\u0307")
+      expect(client.query { casefold("\u1E9B\u0323", "NFKC") } ).to eq("\u1E69")
+
+      expect(client.query { casefold("\u212B", "NFKCCaseFold") } ).to eq("\u00E5")
     end
   end
 
@@ -688,9 +761,9 @@ RSpec.describe Fauna::Query do
     end
   end
 
-  describe '#next_id' do
+  describe '#new_id' do
     it 'gets a new id' do
-      expect(client.query { next_id }).to be_a(String)
+      expect(client.query { new_id }).to be_a(String)
     end
   end
 
@@ -775,6 +848,22 @@ RSpec.describe Fauna::Query do
     end
   end
 
+  describe '#select_all' do
+    it 'performs select_all with hash' do
+      obj1 = { foo: 'bar' }
+      obj2 = { foo: 'baz' }
+
+      expect(client.query { select_all(:foo, [obj1, obj2]) }).to eq(['bar', 'baz'])
+    end
+
+    it 'performs select_all with array' do
+      obj1 = { foo: [0, 1] }
+      obj2 = { foo: [2, 3] }
+
+      expect(client.query { select_all([:foo, 0], [obj1, obj2]) }).to eq([0, 2])
+    end
+  end
+
   describe '#add' do
     it 'performs add' do
       expect(client.query { add(2, 3, 5) }).to eq(10)
@@ -861,4 +950,43 @@ RSpec.describe Fauna::Query do
       expect(client.query { not_(false) }).to be(true)
     end
   end
+
+  describe '#recursive references' do
+    it 'create nested keys' do
+      new_client = create_new_database(admin_client, 'db-for-keys')
+      new_client.query { create_database name: 'db-test' }
+
+      server_key = new_client.query { create_key database: database('db-test'), role: 'server' }
+      admin_key = new_client.query { create_key database: database('db-test'), role: 'admin' }
+
+      expect(new_client.query { paginate keys() }).to eq(data: [server_key[:ref], admin_key[:ref]])
+      expect(admin_client.query { paginate keys(database('db-for-keys')) }).to eq(data: [server_key[:ref], admin_key[:ref]])
+    end
+
+    it 'create nested class' do
+      client1 = create_new_database(admin_client, 'parent-database')
+      create_new_database(client1, 'child-database')
+
+      key = client1.query { create_key database: database('child-database'), role: 'server' }
+      client2 = get_client secret: key[:secret]
+      client2.query { create_class name: 'a_class' }
+
+      nested_database = Fauna::Query.database('child-database', Fauna::Query.database('parent-database'))
+      nested_class = Fauna::Query.class_('a_class', nested_database)
+      all_nested_classes = Fauna::Query.classes(nested_database)
+
+      parent_database_ref = Fauna::Ref.new('parent-database', Fauna::Native.databases)
+      child_database_ref = Fauna::Ref.new('child-database', Fauna::Native.databases, parent_database_ref)
+      a_class_ref = Fauna::Ref.new('a_class', Fauna::Native.classes, child_database_ref)
+
+      expect(client.query { exists nested_class }).to be(true)
+      expect(client.query { paginate all_nested_classes }).to eq(data: [a_class_ref])
+    end
+  end
+
+  def create_new_database(client, name)
+    client.query { create_database name: name }
+    key = client.query { create_key database: database(name), role: 'admin' }
+    get_client secret: key[:secret]
+  end
 end

data/spec/ref_spec.rb

@@ -1,63 +1,99 @@
 RSpec.describe Fauna::Ref do
   it 'converts to string' do
-    expect(Fauna::Ref.new('classes/test').to_s).to eq('classes/test')
+    db = Fauna::Ref.new('db', Fauna::Native.databases)
+    expect(db.to_s).to eq('Ref(id=db,class=Ref(id=databases))')
+
+    cls = Fauna::Ref.new('cls', Fauna::Native.classes, db)
+    expect(cls.to_s).to eq('Ref(id=cls,class=Ref(id=classes),database=Ref(id=db,class=Ref(id=databases)))')
+
+    expect(Fauna::Ref.new('test', cls).to_s).to eq('Ref(id=test,class=Ref(id=cls,class=Ref(id=classes),database=Ref(id=db,class=Ref(id=databases))))')
   end
 
-  describe '#initalize' do
-    it 'creates from string' do
-      name = random_string
-      expect(Fauna::Ref.new("classes/#{name}").value).to eq("classes/#{name}")
+  describe '#id' do
+    it 'returns id portion' do
+      expect(Fauna::Ref.new('test', Fauna::Native.classes).id).to eq('test')
+    end
+
+    it 'raises error' do
+      expect { Fauna::Ref.new(nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe '#id' do
-    context 'with multiple elements' do
-      it 'returns id portion' do
-        expect(Fauna::Ref.new('classes/test').id).to eq('test')
+  describe '#class_' do
+    context 'with id and user class' do
+      it 'returns class portion' do
+        expect(Fauna::Ref.new('1234', Fauna::Ref.new('test', Fauna::Native.classes)).class_).to eq(Fauna::Ref.new('test', Fauna::Native.classes))
+      end
+    end
+
+    context 'user class only' do
+      it 'returns class portion' do
+        expect(Fauna::Ref.new('test', Fauna::Native.classes).class_).to eq(Fauna::Native.classes)
       end
     end
 
-    context 'with single element' do
-      it 'raises error' do
-        expect { Fauna::Ref.new('classes').id }.to raise_error(ArgumentError)
+    context 'without id and user class' do
+      it 'does not return class portion' do
+        expect(Fauna::Ref.new('classes').class_).to be_nil
+      end
+    end
+
+    context 'with native classes' do
+      it 'does not return class portion' do
+        expect(Fauna::Native.classes.class_).to be_nil
+        expect(Fauna::Native.indexes.class_).to be_nil
+        expect(Fauna::Native.databases.class_).to be_nil
+        expect(Fauna::Native.functions.class_).to be_nil
+        expect(Fauna::Native.keys.class_).to be_nil
       end
     end
   end
 
-  describe '#to_class' do
-    context 'with three elements' do
-      it 'returns class portion' do
-        expect(Fauna::Ref.new('classes/test/1234').to_class).to eq(Fauna::Ref.new('classes/test'))
+  describe '#database' do
+    db = Fauna::Ref.new('db', Fauna::Native.databases)
+
+    context 'with simple database' do
+      it 'returns database portion' do
+        expect(Fauna::Ref.new('test', Fauna::Native.classes, db).database).to eq(Fauna::Ref.new('db', Fauna::Native.databases))
       end
     end
 
-    context 'with two elements' do
-      it 'returns class portion' do
-        expect(Fauna::Ref.new('classes/test').to_class).to eq(Fauna::Ref.new('classes'))
+    context 'with nested database' do
+      it 'returns database portion' do
+        nested_db = Fauna::Ref.new('nested-db', Fauna::Native.databases, db)
+        deep_db = Fauna::Ref.new('deep-db', Fauna::Native.databases, nested_db)
+
+        expect(nested_db.database).to eq(db)
+        expect(deep_db.database.database).to eq(db)
       end
     end
 
-    context 'with one element' do
-      it 'returns class portion' do
-        expect(Fauna::Ref.new('classes').to_class).to eq(Fauna::Ref.new('classes'))
+    context 'with native classes' do
+      it 'does not return database portion' do
+        expect(Fauna::Native.classes.database).to be_nil
+        expect(Fauna::Native.indexes.database).to be_nil
+        expect(Fauna::Native.databases.database).to be_nil
+        expect(Fauna::Native.functions.database).to be_nil
+        expect(Fauna::Native.keys.database).to be_nil
       end
     end
   end
 
   describe '#==' do
     it 'equals same ref' do
-      ref = Fauna::Ref.new('classes/test')
+      ref = Fauna::Ref.new('123', Fauna::Ref.new('test', Fauna::Native.classes))
 
-      expect(ref).to eq(Fauna::Ref.new('classes/test'))
-      expect(ref.to_class).to eq(Fauna::Ref.new('classes'))
+      expect(ref).to eq(Fauna::Ref.new('123', Fauna::Ref.new('test', Fauna::Native.classes)))
     end
 
     it 'does not equal different ref' do
-      expect(Fauna::Ref.new('classes/test')).not_to eq(Fauna::Ref.new('classes'))
+      ref = Fauna::Ref.new('123', Fauna::Ref.new('test', Fauna::Native.classes))
+
+      expect(ref).not_to eq(Fauna::Ref.new('321', Fauna::Ref.new('test', Fauna::Native.classes)))
     end
 
     it 'does not equal other type' do
-      expect(Fauna::Ref.new('classes/test')).not_to eq('classes/test')
+      expect(Fauna::Ref.new('test', Fauna::Native.classes)).not_to eq('classes/test')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fauna
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Fauna, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-12 00:00:00.000000000 Z
+date: 2018-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -81,19 +81,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.38.0
 - !ruby/object:Gem::Dependency
-  name: codecov
+  name: simplecov-json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: Ruby driver for FaunaDB.
 email: priority@fauna.com
 executables: []
@@ -113,6 +127,7 @@ files:
 - lib/fauna/client.rb
 - lib/fauna/client_logger.rb
 - lib/fauna/context.rb
+- lib/fauna/deprecate.rb
 - lib/fauna/errors.rb
 - lib/fauna/json.rb
 - lib/fauna/objects.rb