mongoid-multitenancy 0.4.4 → 1.0.0

data/lib/mongoid/multitenancy/validators/tenancy.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module Multitenancy
+    # Validates whether or not a tenant field is correct.
+    #
+    # @example Define the tenant validator
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     tenant :client
+    #
+    #     validates_tenancy_of :client
+    #   end
+    class TenancyValidator < ActiveModel::EachValidator
+      def validate_each(object, attribute, value)
+        # Immutable Check
+        if options[:immutable]
+          if object.send(:attribute_changed?, attribute) and object.send(:attribute_was, attribute)
+            object.errors.add(attribute, 'is immutable and cannot be updated')
+          end
+        end
+
+        # Ownership check
+        if value and Mongoid::Multitenancy.current_tenant and value != Mongoid::Multitenancy.current_tenant.id
+          object.errors.add(attribute, "not authorized")
+        end
+
+        # Optional Check
+        if !options[:optional] and value.nil?
+          object.errors.add(attribute, 'is mandatory')
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/validators/tenant_uniqueness.rb

@@ -0,0 +1,72 @@
+module Mongoid
+  module Multitenancy
+    # Validates whether or not a field is unique against the documents in the
+    # database.
+    #
+    # @example Define the tenant uniqueness validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     tenant :client
+    #
+    #     validates_tenant_uniqueness_of :title
+    #   end
+    #
+    # It is also possible to limit the uniqueness constraint to a set of
+    # records matching certain conditions:
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     field :active, type: Boolean
+    #     tenant :client
+    #
+    #     validates_tenant_uniqueness_of :title, conditions: -> {where(active: true)}
+    #   end
+    class TenantUniquenessValidator < Mongoid::Validatable::UniquenessValidator
+      # Validate a tenant root document.
+      def validate_root(document, attribute, value)
+        klass = document.class
+
+        while klass.superclass.respond_to?(:validators) && klass.superclass.validators.include?(self)
+          klass = klass.superclass
+        end
+        criteria = create_criteria(klass, document, attribute, value)
+
+        # <<Add the tenant Criteria>>
+        add_tenant_criterion(criteria, klass, document)
+
+        criteria = criteria.merge(options[:conditions].call) if options[:conditions]
+
+        if Mongoid::VERSION.start_with?('4')
+          if criteria.with(persistence_options(criteria)).exists?
+            add_error(document, attribute, value)
+          end
+        else
+          if criteria.with(criteria.persistence_options).read(mode: :primary).exists?
+            add_error(document, attribute, value)
+          end
+        end
+      end
+
+      # Create the validation criteria for a tenant model.
+      #
+      # @api private
+      def add_tenant_criterion(criteria, base, document)
+        tenant_value = document.send(base.tenant_field.to_sym)
+
+        if document.class.tenant_options[:optional]
+          if tenant_value
+            criteria.selector.update(criterion(document, base.tenant_field, {'$in' => [tenant_value, nil].mongoize}))
+          end
+        else
+          criteria.selector.update(criterion(document, base.tenant_field, tenant_value.mongoize))
+        end
+
+        criteria
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/version.rb

@@ -1,5 +1,6 @@
 module Mongoid
   module Multitenancy
-    VERSION = "0.4.4"
+    # Version
+    VERSION = '1.0.0'
   end
 end

data/mongoid-multitenancy.gemspec

@@ -2,18 +2,18 @@
 require File.expand_path('../lib/mongoid/multitenancy/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Aymeric Brisse"]
-  gem.email         = ["aymeric.brisse@mperfect-memory.com"]
-  gem.description   = %q{MultiTenancy with Mongoid}
-  gem.summary       = %q{Support of a multi-tenant database with Mongoid}
-  gem.homepage      = "https://github.com/PerfectMemory/mongoid-multitenancy"
+  gem.authors       = ['Aymeric Brisse']
+  gem.email         = ['aymeric.brisse@mperfect-memory.com']
+  gem.description   = 'MultiTenancy with Mongoid'
+  gem.summary       = 'Support of a multi-tenant database with Mongoid'
+  gem.homepage      = 'https://github.com/PerfectMemory/mongoid-multitenancy'
   gem.license       = 'MIT'
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "mongoid-multitenancy"
-  gem.require_paths = ["lib"]
+  gem.name          = 'mongoid-multitenancy'
+  gem.require_paths = ['lib']
   gem.version       = Mongoid::Multitenancy::VERSION
 
-  gem.add_dependency('mongoid', '>= 3.0')
+  gem.add_dependency('mongoid', '>= 4.0')
 end

data/spec/immutable_spec.rb

@@ -1,34 +1,46 @@
 require 'spec_helper'
 
 describe Immutable do
+  let(:client) do
+    Account.create!(name: 'client')
+  end
 
-  it_behaves_like "a tenantable model"
+  let(:another_client) do
+    Account.create!(name: 'another client')
+  end
 
-  let(:client) { Account.create!(:name => "client") }
-  let(:another_client) { Account.create!(:name => "another client") }
+  let(:item) do
+    Immutable.new(title: 'title X', slug: 'page-x')
+  end
 
-  describe "#valid?" do
-    before { Mongoid::Multitenancy.current_tenant = client; }
-    after { Mongoid::Multitenancy.current_tenant = nil }
+  it_behaves_like 'a tenantable model'
 
-    let(:item) { Immutable.new(:title => "title X", :slug => "page-x") }
+  describe '#valid?' do
+    before do
+      Mongoid::Multitenancy.current_tenant = client
+    end
 
-    it_behaves_like "a tenant validator"
+    context 'when the tenant has not changed' do
+      before do
+        item.save!
+      end
 
-    context "when the tenant has not changed" do
-      before { item.save! }
-      it 'should be valid' do
-        item.title = "title X (2)"
-        item.should be_valid
+      it 'is valid' do
+        item.title = 'title X (2)'
+        expect(item).to be_valid
       end
     end
 
-    context "when the tenant has changed" do
-      before { item.save!; Mongoid::Multitenancy.current_tenant = another_client }
-      it 'should not be valid' do
+    context 'when the tenant has changed' do
+      before do
+        item.save!
+        Mongoid::Multitenancy.current_tenant = another_client
+      end
+
+      it 'is not valid' do
         item.client = another_client
-        item.should_not be_valid
+        expect(item).not_to be_valid
       end
     end
   end
-end
+end

data/spec/indexable_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'tenant' do
 
   let(:client) do
-    Account.create!(:name => "client")
+    Account.create!(name: 'client')
   end
 
   before do
@@ -12,26 +12,26 @@ describe 'tenant' do
 
   context 'without index: true' do
     it 'does not create an index' do
-      Immutable.should_not have_index_for(:client_id => 1)
+      expect(Immutable).not_to have_index_for(:client_id => 1)
     end
   end
 
   context 'with index: true' do
     it 'creates an index' do
-      Indexable.should have_index_for(:client_id => 1)
+      expect(Indexable).to have_index_for(:client_id => 1)
     end
   end
 
   context 'with full_indexes: true' do
     it 'add the tenant field on each index' do
-      Immutable.should have_index_for(:client_id => 1, :title => 1)
+      expect(Immutable).to have_index_for(:client_id => 1, title: 1)
     end
   end
 
   context 'with full_indexes: false' do
     it 'does not add the tenant field on each index' do
-      Indexable.should_not have_index_for(:client_id => 1, :title => 1)
+      expect(Indexable).not_to have_index_for(:client_id => 1, title: 1)
     end
   end
 
-end
+end

data/spec/inheritance_spec.rb

@@ -1,17 +1,22 @@
 require 'spec_helper'
 
 describe 'Inheritance' do
+  let(:client) do
+    Account.create!(name: 'client')
+  end
 
-  let(:client) { Account.create!(:name => "client") }
+  before do
+    Mongoid::Multitenancy.current_tenant = client
+  end
 
-  describe "class" do
-    it 'should use inheritance pattern' do
-      MutableChild.create!(:title => "title X", :slug => "page-x")
+  describe 'class' do
+    it 'uses inheritance pattern' do
+      MutableChild.create!(title: 'title X', slug: 'page-x')
       expect(Mutable.last).to be_a MutableChild
     end
 
-    it 'should keep options' do
-      AnotherMutableChild.new(:title => "title X", :slug => "page-x").should be_valid
+    it 'keeps options' do
+      expect(AnotherMutableChild.new(title: 'title X', slug: 'page-x')).to be_valid
     end
   end
 end

data/spec/mandatory_spec.rb

@@ -2,81 +2,107 @@ require 'spec_helper'
 
 describe Mandatory do
 
-  it_behaves_like "a tenantable model"
-  it { should validate_uniqueness_of(:slug).scoped_to(:client_id) }
+  let(:client) do
+    Account.create!(name: 'client')
+  end
+
+  let(:another_client) do
+    Account.create!(name: 'another client')
+  end
 
-  let(:client) { Account.create!(:name => "client") }
-  let(:another_client) { Account.create!(:name => "another client") }
+  let(:item) do
+    Mandatory.new(title: 'title X', slug: 'page-x')
+  end
+
+  it_behaves_like 'a tenantable model'
+  it { is_expected.to validate_tenant_uniqueness_of(:slug) }
 
-  describe ".default_scope" do
-    before {
-      Mongoid::Multitenancy.with_tenant(client) { @itemX = Mandatory.create!(:title => "title X", :slug => "article-x") }
-      Mongoid::Multitenancy.with_tenant(another_client) { @itemY = Mandatory.create!(:title => "title Y", :slug => "article-y") }
-    }
+  describe '.default_scope' do
+    before do
+      Mongoid::Multitenancy.with_tenant(client) { @itemX = Mandatory.create!(title: 'title X', slug: 'article-x') }
+      Mongoid::Multitenancy.with_tenant(another_client) { @itemY = Mandatory.create!(title: 'title Y', slug: 'article-y') }
+    end
 
-    context "with a current tenant" do
-      before { Mongoid::Multitenancy.current_tenant = another_client }
-      after { Mongoid::Multitenancy.current_tenant = nil }
+    context 'with a current tenant' do
+      before do
+        Mongoid::Multitenancy.current_tenant = another_client
+      end
 
-      it "should filter on the current tenant" do
-        Mandatory.all.to_a.should =~ [@itemY]
+      it 'filters on the current tenant' do
+        expect(Mandatory.all.to_a).to match_array [@itemY]
       end
     end
 
-    context "without a current tenant" do
-      before { Mongoid::Multitenancy.current_tenant = nil }
+    context 'without a current tenant' do
+      before do
+        Mongoid::Multitenancy.current_tenant = nil
+      end
 
-      it "should not filter on any tenant" do
-        Mandatory.all.to_a.should =~ [@itemX, @itemY]
+      it 'does not filter on any tenant' do
+        expect(Mandatory.all.to_a).to match_array [@itemX, @itemY]
       end
     end
   end
 
-  describe "#delete_all" do
-    before {
-      Mongoid::Multitenancy.with_tenant(client) { @itemX = Mandatory.create!(:title => "title X", :slug => "article-x") }
-      Mongoid::Multitenancy.with_tenant(another_client) { @itemY = Mandatory.create!(:title => "title Y", :slug => "article-y") }
-    }
+  describe '#delete_all' do
+    before do
+      Mongoid::Multitenancy.with_tenant(client) { @itemX = Mandatory.create!(title: 'title X', slug: 'article-x') }
+      Mongoid::Multitenancy.with_tenant(another_client) { @itemY = Mandatory.create!(title: 'title Y', slug: 'article-y') }
+    end
 
-    context "with a current tenant" do
-      it "should only delete the current tenant" do
+    context 'with a current tenant' do
+      it 'only deletes the current tenant' do
         Mongoid::Multitenancy.with_tenant(another_client) { Mandatory.delete_all }
-        Mandatory.all.to_a.should =~ [@itemX]
+        expect(Mandatory.all.to_a).to match_array [@itemX]
       end
     end
 
-    context "without a current tenant" do
-      it "should delete all the items" do
+    context 'without a current tenant' do
+      it 'deletes all the items' do
         Mandatory.delete_all
-        Mandatory.all.to_a.should be_empty
+        expect(Mandatory.all.to_a).to be_empty
       end
     end
   end
 
-  describe "#valid?" do
-    after { Mongoid::Multitenancy.current_tenant = nil }
+  describe '#valid?' do
+    context 'with a tenant' do
+      before do
+        item.client = client
+      end
+
+      it 'is valid' do
+        expect(item).to be_valid
+      end
 
-    let(:item) { Mandatory.new(:title => "title X", :slug => "page-x") }
+      context 'with a uniqueness constraint' do
+        let(:duplicate) do
+          Mandatory.new(title: 'title Y', slug: 'page-x')
+        end
 
-    it_behaves_like "a tenant validator"
+        before do
+          item.save!
+        end
 
-    context "with a current tenant" do
-      before { Mongoid::Multitenancy.current_tenant = client }
+        it 'does not allow duplicates on the same tenant' do
+          expect(duplicate).not_to be_valid
+        end
 
-      it "should set the client field" do
-        item.valid?
-        item.client.should eq client
+        it 'allow duplicates on a different same tenant' do
+          Mongoid::Multitenancy.with_tenant(another_client) do
+            expect(duplicate).to be_valid
+          end
+        end
       end
     end
 
-    context "without a current tenant" do
-      it "should not set the client field" do
-        item.valid?
-        item.client.should be_nil
+    context 'without a tenant' do
+      before do
+        item.client = nil
       end
 
-      it "should be invalid" do
-        item.should_not be_valid
+      it 'is not valid' do
+        expect(item).not_to be_valid
       end
     end
   end

data/spec/models/immutable.rb

@@ -2,14 +2,14 @@ class Immutable
   include Mongoid::Document
   include Mongoid::Multitenancy::Document
 
-  tenant(:client, :class_name => 'Account', :immutable => true)
+  tenant(:client, class_name: 'Account', immutable: true)
 
   field :slug, :type => String
   field :title, :type => String
 
-  validates_uniqueness_of :slug
+  validates_tenant_uniqueness_of :slug
   validates_presence_of :slug
   validates_presence_of :title
 
-  index({ :title => 1 })
+  index({ title: 1 })
 end