couchbase-orm 1.1.1 → 2.0.0

data/spec/has_many_spec.rb

@@ -2,81 +2,128 @@
 
 require File.expand_path("../support", __FILE__)
 
+shared_examples "has_many example" do |parameter|
+    before :all do
+        @context = parameter[:context].to_s
+        @rating_test_class = Kernel.const_get("Rating#{@context.camelize}Test".classify)
+        @object_test_class = Kernel.const_get("Object#{@context.camelize}Test".classify)
+        @object_rating_test_class = Kernel.const_get("ObjectRating#{@context.camelize}Test".classify)
+
+        @rating_test_class.ensure_design_document!
+        @object_test_class.ensure_design_document!
+        @object_rating_test_class.ensure_design_document!
+
+        @rating_test_class.delete_all
+        @object_test_class.delete_all
+        @object_rating_test_class.delete_all
+    end
 
-class ObjectRatingTest < CouchbaseOrm::Base
-    join :object_test, :rating_test
-    view :all
-end
+    after :each do
+        @rating_test_class.delete_all
+        @object_test_class.delete_all
+        @object_rating_test_class.delete_all
+    end
 
-class RatingTest < CouchbaseOrm::Base
-    enum rating: [:awesome, :good, :okay, :bad], default: :okay
-    belongs_to :object_test
+    it "should return matching results" do
+        first = @object_test_class.create! name: :bob
+        second = @object_test_class.create! name: :jane
 
-    has_many :object_tests, through: :object_rating_test
-    view :all
-end
+        rate = @rating_test_class.create! rating: :awesome, "object_#{@context}_test": first
+        @rating_test_class.create! rating: :bad, "object_#{@context}_test": second
+        @rating_test_class.create! rating: :good, "object_#{@context}_test": first
 
-class ObjectTest < CouchbaseOrm::Base
-    attribute :name, type: String
-    has_many :rating_tests, dependent: :destroy
+        expect(rate.try("object_#{@context}_test_id")).to eq(first.id)
+        expect(@rating_test_class.respond_to?(:"find_by_object_#{@context}_test_id")).to be(true)
+        expect(first.respond_to?(:"rating_#{@context}_tests")).to be(true)
 
-    view :all
-end
+        docs = first.try(:"rating_#{@context}_tests").collect(&:rating)
 
+        expect(docs).to match_array([1, 2])
 
-describe CouchbaseOrm::HasMany do
-    before :all do
-        RatingTest.ensure_design_document!
-        ObjectTest.ensure_design_document!
-        ObjectRatingTest.ensure_design_document!
+        first.destroy
+        expect { @rating_test_class.find rate.id }.to raise_error(Couchbase::Error::DocumentNotFound)
+        expect(@rating_test_class.send(:"#{@context}_all").count).to be(1)
     end
 
-    after :each do
-        ObjectTest.all.stream { |ob| ob.delete }
-        RatingTest.all.stream { |ob| ob.delete }
-        ObjectRatingTest.all.stream { |ob| ob.delete }
+    it "should work through a join model" do
+        first = @object_test_class.create! name: :bob
+        second = @object_test_class.create! name: :jane
+
+        rate1 = @rating_test_class.create! rating: :awesome, "object_#{@context}_test": first
+        _rate2 = @rating_test_class.create! rating: :bad, "object_#{@context}_test": second
+        _rate3 = @rating_test_class.create! rating: :good, "object_#{@context}_test": first
+
+        ort = @object_rating_test_class.create! "object_#{@context}_test": first, "rating_#{@context}_test": rate1
+        @object_rating_test_class.create! "object_#{@context}_test": second, "rating_#{@context}_test": rate1
+
+        expect(ort.try(:"rating_#{@context}_test_id".to_sym)).to eq(rate1.id)
+        expect(rate1.respond_to?(:"object_#{@context}_tests")).to be(true)
+        docs = rate1.try(:"object_#{@context}_tests").collect(&:name)
+
+        expect(docs).to match_array(['bob', 'jane'])
     end
 
-    it "should return matching results" do
-        first = ObjectTest.create! name: :bob
-        second = ObjectTest.create! name: :jane
+    it "should work with new objects not yet saved" do
+        existing_object = @object_test_class.create! name: :bob
+        expect(existing_object.send(:"rating_#{@context}_tests")).to be_empty
 
-        rate = RatingTest.create! rating: :awesome, object_test: first
-        RatingTest.create! rating: :bad, object_test: second
-        RatingTest.create! rating: :good, object_test: first
+        @rating_test_class.create! rating: :good, "object_#{@context}_test": existing_object
+    
+        new_object = @object_test_class.new name: :jane
+        expect(new_object.send(:"rating_#{@context}_tests")).to be_empty
+    end
 
-        expect(rate.object_test_id).to eq(first.id)
-        expect(RatingTest.respond_to?(:find_by_object_test_id)).to be(true)
-        expect(first.respond_to?(:rating_tests)).to be(true)
+end
 
-        docs = first.rating_tests.collect { |ob|
-            ob.rating
-        }
+describe CouchbaseOrm::HasMany do
+    context 'with view' do
+        class ObjectRatingViewTest < CouchbaseOrm::Base
+            join :object_view_test, :rating_view_test
+            view :view_all
+        end
 
-        expect(docs).to eq([1, 2])
+        class RatingViewTest < CouchbaseOrm::Base
+            enum rating: [:awesome, :good, :okay, :bad], default: :okay
+            belongs_to :object_view_test
 
-        first.destroy
-        expect { RatingTest.find rate.id }.to raise_error(::Libcouchbase::Error::KeyNotFound)
-        expect(RatingTest.all.count).to be(1)
+            has_many :object_view_tests, through: :object_rating_view_test
+            view :view_all
+        end
+
+        class ObjectViewTest < CouchbaseOrm::Base
+            attribute :name, type: String
+            has_many :rating_view_tests, dependent: :destroy
+
+            view :view_all
+        end
+
+        include_examples("has_many example", context: :view)
     end
 
-    it "should work through a join model" do
-        first = ObjectTest.create! name: :bob
-        second = ObjectTest.create! name: :jane
+    context 'with n1ql' do
+        class ObjectRatingN1qlTest < CouchbaseOrm::Base
+            join :object_n1ql_test, :rating_n1ql_test
+
+            n1ql :n1ql_all
+        end
+
+        class RatingN1qlTest < CouchbaseOrm::Base
+            enum rating: [:awesome, :good, :okay, :bad], default: :okay
+            belongs_to :object_n1ql_test
+
+            has_many :object_n1ql_tests, through: :object_rating_n1ql_test, type: :n1ql
+        
+            n1ql :n1ql_all
+        end
 
-        rate1 = RatingTest.create! rating: :awesome, object_test: first
-        rate2 = RatingTest.create! rating: :bad, object_test: second
-        rate3 = RatingTest.create! rating: :good, object_test: first
+        class ObjectN1qlTest < CouchbaseOrm::Base
+            attribute :name, type: String
 
-        ort = ObjectRatingTest.create! object_test: first, rating_test: rate1
-        ObjectRatingTest.create! object_test: second, rating_test: rate1
+            has_many :rating_n1ql_tests, dependent: :destroy, type: :n1ql
 
-        expect(ort.rating_test_id).to eq(rate1.id)
-        expect(rate1.respond_to?(:object_tests)).to be(true)
-        docs = rate1.object_tests.collect { |ob|
-            ob.name
-        }
+            n1ql :n1ql_all
+        end
 
-        expect(docs).to eq(['bob', 'jane'])
+        include_examples("has_many example", context: :n1ql)
     end
 end

data/spec/index_spec.rb

@@ -16,15 +16,15 @@ class NoUniqueIndexTest < CouchbaseOrm::Base
     index :email, presence: false
 end
 
-class EnumTest < CouchbaseOrm::Base
+class IndexEnumTest < CouchbaseOrm::Base
     enum visibility: [:group, :authority, :public], default: :authority
+    enum color: [:red, :green, :blue]
 end
 
 
 describe CouchbaseOrm::Index do
     after :each do
-        IndexTest.bucket.delete('index_testemail-joe@aca.com')
-        IndexTest.bucket.delete('index_testemail-')
+        IndexTest.all.map(&:destroy)
     end
 
     it "should prevent models being created if they should have unique keys" do
@@ -69,7 +69,7 @@ describe CouchbaseOrm::Index do
 
     it "should work with nil values" do
         joe = IndexTest.create!
-        expect(IndexTest.find_by_email(nil)).to eq(nil)
+        expect(IndexTest.find_by_email(nil)).to eq(joe)
 
         joe.email = 'joe@aca.com'
         joe.save!
@@ -78,31 +78,35 @@ describe CouchbaseOrm::Index do
         joe.email = nil
         joe.save!
         expect(IndexTest.find_by_email('joe@aca.com')).to eq(nil)
-        expect(IndexTest.find_by_email(nil)).to eq(nil)
+        expect(IndexTest.find_by_email(nil)).to eq(joe)
 
         joe.destroy
     end
 
     it "should work with enumerators" do
         # Test symbol
-        enum = EnumTest.create!(visibility: :public)
+        enum = IndexEnumTest.create!(visibility: :public)
         expect(enum.visibility).to eq(3)
         enum.destroy
 
         # Test number
-        enum = EnumTest.create!(visibility: 2)
+        enum = IndexEnumTest.create!(visibility: 2)
         expect(enum.visibility).to eq(2)
         enum.destroy
 
         # Test default
-        enum = EnumTest.create!
+        enum = IndexEnumTest.create!
         expect(enum.visibility).to eq(2)
         enum.destroy
+
+        # Test default default
+        enum = IndexEnumTest.create!
+        expect(enum.color).to eq(1)
     end
 
     it "should not overwrite index's that do not belong to the current model" do
         joe = NoUniqueIndexTest.create!
-        expect(NoUniqueIndexTest.find_by_email(nil)).to eq(nil)
+        expect(NoUniqueIndexTest.find_by_email(nil)).to eq(joe)
 
         joe.email = 'joe@aca.com'
         joe.save!

data/spec/json-schema/JsonSchemaBaseTest.json

@@ -0,0 +1,19 @@
+{
+  "type": "object",
+  "required": [
+    "name"
+  ],
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "numb": {
+      "type": "integer",
+      "format": "uint32",
+      "minimum": 3.0
+    },
+    "name": {
+      "type": "string"
+    }
+  }
+}

data/spec/json-schema/entity_snakecase.json

@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "required": [
+    "value"
+  ],
+  "properties": {
+    "value": {
+      "$ref": "#/definitions/ValueType"
+    }
+  },
+  "definitions": {
+    "ValueType": {
+      "type": "string",
+      "enum": [
+        "value_one",
+        "value_two"
+      ]
+    }
+  }
+}

data/spec/json-schema/loader_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../support', __FILE__)
+require 'couchbase-orm/json_schema/loader'
+
+RSpec.describe CouchbaseOrm::JsonSchema::Loader do
+  let(:loader) { described_class.send(:new, "#{Dir.pwd}/spec/json-schema") }
+
+  describe '#extract_type' do
+    it 'returns the type from the entity' do
+      entity = { type: 'entity_snakecase' }
+      expect(loader.extract_type(entity)).to eq('entity_snakecase')
+
+      expect(loader.get_json_schema!(entity)).not_to be_nil
+    end
+  end
+
+  describe '#get_json_schema' do
+    context 'when schemas are present and document type exists' do
+      let(:schemas) { { 'user' => { 'properties' => { 'name' => { 'type' => 'string' } } } } }
+
+      before do
+        allow(loader).to receive(:schemas).and_return(schemas)
+      end
+
+      it 'returns the schema for the given document type' do
+        entity = { type: 'user' }
+        expect(loader.get_json_schema!(entity)).to eq(schemas['user'])
+      end
+
+      it 'raise error if no schema found for the document type' do
+        entity = { type: 'post' }
+        expect { loader.get_json_schema!(entity) }.to raise_error(CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for post in .*\/json-schema/)
+      end
+    end
+
+    context 'when schemas are not present or document type is missing' do
+      it 'returns nil' do
+        entity = { type: 'user' }
+        expect { loader.get_json_schema!(entity) }.to raise_error(CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for user in .*\/json-schema/)
+      end
+    end
+  end
+end

data/spec/json-schema/specific_path.json

@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "required": [
+    "foo"
+  ],
+  "properties": {
+    "foo": {
+      "$ref": "#/definitions/ValueType"
+    }
+  },
+  "definitions": {
+    "ValueType": {
+      "type": "string",
+      "enum": [
+        "foo_one",
+        "foo_two"
+      ]
+    }
+  }
+}

data/spec/json_schema_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+class JsonSchemaBaseTest < CouchbaseOrm::Base
+  attribute :name, :string
+  attribute :numb, :integer
+
+  design_document('JsonSchemaBaseTest')
+  validate_json_schema
+end
+
+class UnknownTest < CouchbaseOrm::Base
+  attribute :test, :boolean
+  validate_json_schema
+end
+
+class EntitySnakecase < CouchbaseOrm::Base
+  attribute :value, :string
+  validate_json_schema
+end
+
+describe CouchbaseOrm::JsonSchema::Loader do
+
+  after(:each) do
+    reset_schemas
+  end
+
+  context "with validation enabled on model" do
+
+    it "With no existing dir " do
+      load_schemas("../dontexist")
+      expect { CouchbaseOrm::JsonSchema::Loader.instance.get_json_schema!({ :type => "Unknown" }) }.to raise_error CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for Unknown in .*\/dontexist/
+    end
+
+    it "Without existing json " do
+      load_schemas("../empty-json-schema")
+      expect { CouchbaseOrm::JsonSchema::Loader.instance.get_json_schema!({ :type => "Unknown" }) }.to raise_error CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for Unknown in .*\/empty-json-schema/
+    end
+
+    it "with schema " do
+      load_schemas("../json-schema")
+      expect(CouchbaseOrm::JsonSchema::Loader.instance.get_json_schema!({ :type => "JsonSchemaBaseTest" })).to include('"name"')
+      expect { CouchbaseOrm::JsonSchema::Loader.instance.get_json_schema!({ :type => "Unknown" }) }.to raise_error CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for Unknown in .*\/json-schema/
+    end
+  end
+
+  describe CouchbaseOrm::JsonSchema::Validator do
+    after(:each) do
+      reset_schemas
+    end
+
+    it "creation ok" do
+          load_schemas("../json-schema")
+      base = EntitySnakecase.create!(value: "value_one")
+      base.delete
+    end
+
+    it "creation ko" do
+      load_schemas("../json-schema")
+      expect { EntitySnakecase.create!(value: "value_1") }.to raise_error CouchbaseOrm::JsonSchema::JsonValidationError
+    end
+
+    it "update ok" do
+      load_schemas("../json-schema")
+      base = EntitySnakecase.create!(value: "value_one")
+      base.value = "value_two"
+      base.save
+      base.delete
+    end
+
+    it "update ko" do
+      load_schemas("../json-schema")
+      base = EntitySnakecase.create!(value: "value_one")
+      base.value = "value_2"
+      expect { base.save }.to raise_error CouchbaseOrm::JsonSchema::JsonValidationError
+      base.delete
+    end
+
+    it "creation ok with design_document" do
+      load_schemas("../json-schema")
+      base = JsonSchemaBaseTest.create!(name: "dsdsd", numb: 3)
+      base.delete
+    end
+
+    it "creation ko with design_document" do
+      load_schemas("../json-schema")
+      expect { JsonSchemaBaseTest.create!(name: "dsdsd", numb: 2) }.to raise_error CouchbaseOrm::JsonSchema::JsonValidationError
+    end
+
+    it "update ok with design_document" do
+      load_schemas("../json-schema")
+      base = JsonSchemaBaseTest.create!(name: "dsdsd", numb: 3)
+      base.numb = 4
+      base.save
+      base.delete
+    end
+
+    it "update ok with design_document" do
+      load_schemas("../json-schema")
+      base = JsonSchemaBaseTest.create!(name: "dsdsd", numb: 3)
+      base.numb = 2
+      expect { base.save }.to raise_error CouchbaseOrm::JsonSchema::JsonValidationError
+      base.delete
+    end
+
+    it 'prevent saving with entity not define in schema files and raise' do
+      load_schemas("../json-schema")
+      expect { UnknownTest.create!(test: true) }.to raise_error CouchbaseOrm::JsonSchema::Loader::Error, /Schema not found for unknown_test in .*\/json-schema/
+    end
+
+    it 'prevent updating with entity not define in schema files and raise' do
+      load_schemas("../json-schema")
+      base = JsonSchemaBaseTest.create!(name: 'Juju', numb: 3)
+      reset_schemas
+      base.name = 'Pierre'
+      expect { base.save }.to raise_error CouchbaseOrm::JsonSchema::Loader::Error, "Schema not found for JsonSchemaBaseTest in db/cborm_schemas/JsonSchemaBaseTest.json"
+      base.delete
+    end
+  end
+
+  context "with validation disabled on model" do
+    let!(:original_config) { EntitySnakecase.instance_variable_get(:@json_validation_config) }
+    before do
+      EntitySnakecase.instance_variable_set(:@json_validation_config, {enabled: false})
+    end
+    after do
+      EntitySnakecase.instance_variable_set(:@json_validation_config, original_config)
+    end
+    it "does not validate schema (even if scehma exists and is not valid)" do
+      load_schemas("../json-schema")
+      base = EntitySnakecase.create!(value: "value_one")
+      base.value = "value_2"
+      expect { base.save }.not_to raise_error CouchbaseOrm::JsonSchema::JsonValidationError
+      base.delete
+    end
+
+  end
+
+  context "with logger mode on model" do
+    before do
+      EntitySnakecase.instance_variable_set(:@json_validation_config, {enabled: true, mode: :logger})
+    end
+    it "does not raise error but log it" do
+      load_schemas("../json-schema")
+      base = EntitySnakecase.create!(value: "value_one")
+      base.value = "value_2"
+      expect(CouchbaseOrm.logger).to receive(:error)
+      base.save
+      base.delete
+    end
+  end
+
+  context "when schema_path is set on model" do
+    let!(:original_config) { EntitySnakecase.instance_variable_get(:@json_validation_config) }
+    before do
+      EntitySnakecase.instance_variable_set(:@json_validation_config, {enabled: true, mode: :strict, schema_path: 'spec/json-schema/specific_path.json'})
+    end
+    after do
+      EntitySnakecase.instance_variable_set(:@json_validation_config, original_config)
+    end
+    it "loads schema from the specified path" do
+      expect { EntitySnakecase.create!(value: "value_one") }.to raise_error CouchbaseOrm::JsonSchema::JsonValidationError, /did not contain a required property of 'foo' in schema/
+    end
+  end
+end
+
+
+# TODO : extract following helpers methods elsewhere
+
+def load_schemas(file_relative_path)
+  CouchbaseOrm::JsonSchema::Loader.instance.send(:instance_variable_set, :@schemas_directory, File.expand_path(file_relative_path, __FILE__))
+end
+
+def reset_schemas
+  CouchbaseOrm::JsonSchema::Loader.instance.send(:instance_variable_set, :@schemas_directory, CouchbaseOrm::JsonSchema::Loader::JSON_SCHEMAS_PATH)
+  CouchbaseOrm::JsonSchema::Loader.instance.instance_variable_get(:@schemas).clear
+end