rails_multitenant 0.11.0 → 0.15.0

data/spec/external_item_with_optional_org_spec.rb

@@ -1,25 +0,0 @@
-include RailsMultitenant
-
-describe ExternalItemWithOptionalOrg do
-
-  let!(:external_item_without_org) { as_external_org(nil) { described_class.create! } }
-
-  let!(:external_item_with_org) { as_external_org(1) { described_class.create! } }
-  let!(:external_item_with_other_org) { as_external_org(2) { described_class.create! } }
-
-  specify 'the nil org has the correct external items' do
-    as_external_org(nil) do
-      expect(described_class.all).to eq([external_item_without_org])
-    end
-  end
-
-  specify 'org1 has the correct external items' do
-    as_external_org(1) do
-      expect(described_class.all).to eq([external_item_with_org])
-    end
-  end
-
-  def as_external_org(id, &block)
-    GlobalContextRegistry.with_isolated_registry(external_organization_id: id, &block)
-  end
-end

data/spec/global_context_registry_spec.rb

@@ -1,113 +0,0 @@
-include RailsMultitenant
-
-describe GlobalContextRegistry do
-
-  before do
-    # The framework will setup the organization; clear that out
-    GlobalContextRegistry.new_registry
-    GlobalContextRegistry.set(:foo, 'bar')
-  end
-
-  describe '.get and .set' do
-    specify do
-      expect(GlobalContextRegistry.get(:foo)).to eq 'bar'
-    end
-  end
-
-  describe '.[] and .[]=' do
-    before do
-      GlobalContextRegistry[:boo] = 'baz'
-    end
-
-    specify do
-      expect(GlobalContextRegistry[:boo]).to eq 'baz'
-    end
-  end
-
-  describe '.delete' do
-    specify do
-      expect(GlobalContextRegistry.delete(:foo)).to eq 'bar'
-      expect(GlobalContextRegistry.get(:foo)).to be_nil
-    end
-  end
-
-  describe '.with_isolated_registry' do
-    specify do
-      GlobalContextRegistry.with_isolated_registry do
-        expect(GlobalContextRegistry.get(:foo)).to be_nil
-      end
-    end
-
-    specify do
-      GlobalContextRegistry.with_isolated_registry(foo: 'updated') do
-        expect(GlobalContextRegistry.get(:foo)).to eq 'updated'
-      end
-    end
-  end
-
-  describe '.replace_registry and .new_registry' do
-    let!(:old_registry) { GlobalContextRegistry.new_registry }
-
-    specify do
-      expect(old_registry).to eq({ foo: 'bar' })
-    end
-    specify do
-      expect(GlobalContextRegistry.get(:foo)).to be_nil
-    end
-    specify do
-      GlobalContextRegistry.replace_registry(old_registry)
-      expect(GlobalContextRegistry.get(:foo)).to eq 'bar'
-    end
-
-    context 'when a new registry is specified' do
-      let!(:old_registry) { GlobalContextRegistry.new_registry(bar: 'foo') }
-
-      specify do
-        expect(old_registry).to eq({ foo: 'bar' })
-      end
-      specify do
-        expect(GlobalContextRegistry.get(:foo)).to be_nil
-      end
-      specify do
-        expect(GlobalContextRegistry.get(:bar)).to eq 'foo'
-      end
-    end
-  end
-
-  describe '.duplicate_registry' do
-    def setup_registry; end
-
-    before { setup_registry }
-    let!(:dupe) { GlobalContextRegistry.duplicate_registry }
-
-    specify do
-      expect(GlobalContextRegistry.new_registry).to eq dupe
-    end
-    specify do
-      expect(GlobalContextRegistry.new_registry.object_id).not_to eq dupe.object_id
-    end
-    specify do
-      expect(GlobalContextRegistry.get(:foo).object_id).not_to eq dupe[:foo].object_id
-    end
-
-    context 'with nils' do
-      def setup_registry
-        GlobalContextRegistry.set(:bar, nil)
-      end
-
-      specify do
-        expect(dupe).to eq GlobalContextRegistry.new_registry
-      end
-    end
-
-    context 'with integers' do
-      def setup_registry
-        GlobalContextRegistry.set(:bar, 5)
-      end
-
-      specify do
-        expect(dupe).to eq GlobalContextRegistry.new_registry
-      end
-    end
-  end
-end

data/spec/item_spec.rb

@@ -1,78 +0,0 @@
-# Create multiple orgs
-# Create an item in each
-# Make sure you can only see one org's item in one org
-
-describe Item do
-
-  let!(:item1) { Item.create! }
-
-  let!(:org2) { Organization.create! }
-  let!(:item2) { org2.as_current { Item.create! } }
-  let!(:item3) { org2.as_current { Item.create! } }
-
-  specify 'default org should have one item' do
-    expect(Item.all).to eq [ item1 ]
-  end
-
-  it 'does not return item2' do
-    expect(Item.where(id: item2.id)).to eq []
-  end
-
-  specify 'org2 should have two items' do
-    org2.as_current do
-      expect(Item.all).to eq [ item2, item3]
-    end
-  end
-
-  it 'does not return item1' do
-    org2.as_current do
-      expect(Item.where(id: item1.id)).to eq []
-    end
-  end
-
-  class DependentClass
-    include RailsMultitenant::GlobalContextRegistry::Current
-    global_context_dependent_on Organization
-  end
-
-  class SubOrganization < Organization
-
-  end
-
-  describe '.as_current' do
-    it 'returns the correct items with an org supplied' do
-      Organization.as_current(org2) do
-        expect(Item.all).to eq [ item2, item3]
-      end
-    end
-
-    it 'allows a nil org to be supplied' do
-      Organization.as_current(nil) do
-        expect(Item.all).to eq []
-      end
-    end
-
-    it 'rejects models of the wrong type' do
-      model = Item.new
-      expect { Organization.as_current(model) {}}.to raise_error("#{model} is not a Organization")
-    end
-
-    it 'invalidates dependent models' do
-      DependentModel.current = DependentModel.create!
-      dependent = DependentModel.current
-
-      SubOrganization.create!.as_current do
-        expect(DependentModel.current).not_to equal(dependent)
-      end
-    end
-
-    it 'invalidates dependent objects' do
-      dependent = DependentClass.current
-
-      SubOrganization.create!.as_current do
-        expect(DependentClass.current).not_to equal(dependent)
-      end
-    end
-  end
-
-end

data/spec/item_subtype_spec.rb

@@ -1,37 +0,0 @@
-# Create multiple orgs
-# Create an item in each
-# Make sure you can only see one org's item in one org
-
-describe ItemSubtype do
-
-  let!(:item1) { ItemSubtype.create! }
-
-  let!(:org2) { Organization.create! }
-  let!(:item2) { org2.as_current { ItemSubtype.create! } }
-  let!(:item3) { org2.as_current { ItemSubtype.create! } }
-
-  it 'inherits the multitenant settings from its parent class' do
-    expect(ItemSubtype).to be_multitenant_on(:organization_id)
-  end
-
-  specify 'default org should have one item' do
-    expect(ItemSubtype.all).to eq([item1])
-  end
-
-  it 'does not return item2' do
-    expect(ItemSubtype.where(id: item2.id)).to eq([])
-  end
-
-  specify 'org2 should have two items' do
-    org2.as_current do
-      expect(ItemSubtype.all).to eq([item2, item3])
-    end
-  end
-
-  it 'does not return item1' do
-    org2.as_current do
-      expect(ItemSubtype.where(id: item1.id)).to eq([])
-    end
-  end
-
-end

data/spec/item_with_optional_org_spec.rb

@@ -1,26 +0,0 @@
-describe ItemWithOptionalOrg do
-
-  let!(:item_without_org) { without_org { described_class.create! } }
-
-  let!(:org) { Organization.create! }
-  let!(:item_with_org) { org.as_current { described_class.create! } }
-
-  let!(:other_org) { Organization.create! }
-  let!(:item_with_other_org) { other_org.as_current { described_class.create! } }
-
-  it "returns the correct items when no org is set" do
-    without_org do
-      expect(described_class.all).to eq([item_without_org])
-    end
-  end
-
-  it "returns the correct items when an org is set" do
-    org.as_current do
-      expect(described_class.all).to eq([item_with_org])
-    end
-  end
-
-  def without_org(&block)
-    GlobalContextRegistry.with_isolated_registry(&block)
-  end
-end

data/spec/middleware_isolated_context_registry_spec.rb

@@ -1,15 +0,0 @@
-describe Middleware::IsolatedContextRegistry do
-  let(:payload) { [200, {'Content-Type' => 'text/plain'}, ['OK']] }
-  let(:app) { lambda { |env| env[2] = GlobalContextRegistry.get(:foo); env } }
-  let(:middleware) { described_class.new(app) }
-
-  describe '.call' do
-    specify do
-      GlobalContextRegistry.set(:foo, 'bar')
-      # Assert that a new global registry is created and read from, where :foo is not set
-      expect(middleware.call(payload)).to eq [200, {'Content-Type' => 'text/plain'}, nil]
-      # Assert that the outer global context registry is restored
-      expect(GlobalContextRegistry.get(:foo)).to eq 'bar'
-    end
-  end
-end

data/spec/rails_multitenant_spec.rb

@@ -1,51 +0,0 @@
-describe "delegating to GlobalContextRegistry" do
-  it "RailsMultitenant.get returns values from the GlobalContextRegistry" do
-    RailsMultitenant::GlobalContextRegistry.set(:organization_id, 'Salsify Housing Authority')
-
-    expect(RailsMultitenant.get(:organization_id)).to eq('Salsify Housing Authority')
-  end
-
-  it "RailsMultitenant[] returns values from the GlobalContextRegistry" do
-    RailsMultitenant::GlobalContextRegistry.set(:organization_id, 'Salsify Farmland Inc.')
-
-    expect(RailsMultitenant[:organization_id]).to eq('Salsify Farmland Inc.')
-  end
-
-  it "RailsMultitenant.set assigns values in the GlobalContextRegistry" do
-    RailsMultitenant.set(:organization_id, 'Salsify Eminient Domain')
-
-    expect(RailsMultitenant::GlobalContextRegistry.get(:organization_id)).to eq('Salsify Eminient Domain')
-  end
-
-  it "RailsMultitenant[]= assigns values in the GlobalContextRegistry" do
-    RailsMultitenant[:organization_id] = 'Salsify Co-op'
-
-    expect(RailsMultitenant::GlobalContextRegistry[:organization_id]).to eq('Salsify Co-op')
-  end
-
-  it "RailsMultitenant.fetch checks and sets the GlobalContextRegistry" do
-    RailsMultitenant::GlobalContextRegistry[:organization_id] = nil
-
-    expect(RailsMultitenant.fetch(:organization_id) { 'Salsify Anarchists' }).to eq('Salsify Anarchists')
-
-    expect(RailsMultitenant.fetch(:organization_id) { 'Salsify Crypto Anarchists' }).to eq('Salsify Anarchists')
-  end
-
-  it "RailsMultitenant.delete removes from the GlobalContextRegistry" do
-    RailsMultitenant::GlobalContextRegistry[:organization_id] = 'Not Salsify'
-
-    RailsMultitenant.delete(:organization_id)
-
-    expect(RailsMultitenant.get(:organization_id)).to be_nil
-  end
-
-  it "RailsMultitenant.with_isolated_registry leverages the GlobalContextRegistry" do
-    RailsMultitenant::GlobalContextRegistry[:organization_id] = 'Salsify Mainland'
-
-    RailsMultitenant.with_isolated_registry({ organization_id: 'Salsify Private Island' }) do
-      expect(RailsMultitenant::GlobalContextRegistry[:organization_id]).to eq('Salsify Private Island')
-    end
-
-    expect(RailsMultitenant::GlobalContextRegistry[:organization_id]).to eq('Salsify Mainland')
-  end
-end

data/spec/spec_helper.rb

@@ -1,54 +0,0 @@
-# encoding: UTF-8
-
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-])
-SimpleCov.start do
- add_filter 'spec'
-end
-
-require 'active_record'
-if ActiveRecord::VERSION::MAJOR >= 5
-  ActiveRecord::Base.belongs_to_required_by_default = true
-end
-
-require 'logger'
-require 'database_cleaner'
-require 'rails_multitenant'
-require 'yaml'
-
-FileUtils.makedirs('log')
-
-ActiveRecord::Base.logger = Logger.new('log/test.log')
-ActiveRecord::Base.logger.level = Logger::DEBUG
-ActiveRecord::Migration.verbose = false
-
-db_adapter = ENV.fetch('ADAPTER', 'sqlite3')
-config = YAML.load(File.read('spec/db/database.yml'))
-ActiveRecord::Base.establish_connection(config[db_adapter])
-require 'db/schema'
-
-RSpec.configure do |config|
-  config.order = 'random'
-
-  config.before(:suite) do
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.before(:each) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.start
-    RailsMultitenant::GlobalContextRegistry.new_registry
-    Organization.current_id = Organization.create!.id
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
-end
-
-puts "Testing with Ruby #{RUBY_VERSION} and ActiveRecord #{ActiveRecord::VERSION::STRING}"