motel-activerecord 1.0.0

data/spec/lib/motel/manager_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe Motel::Manager do
+
+  before(:all) do
+    ActiveRecord::Base.connection_handler = begin
+      Motel::ConnectionAdapters::ConnectionHandler.new
+    end
+    @manager = Motel::Manager
+  end
+
+  before(:each) do
+    ActiveRecord::Base.connection_handler.tenants_source = begin
+      Motel::Sources::Default.new
+    end
+    @tenants_source = ActiveRecord::Base.connection_handler.tenants_source
+    @tenants_source.add_tenant('foo', FOO_SPEC)
+    @tenants_source.add_tenant('bar', BAR_SPEC)
+  end
+
+  after(:each) do
+    ENV['TENANT'] = nil
+    @manager.current_tenant = nil
+    @manager.default_tenant = nil
+
+    # Remove all connections tenant
+    ActiveRecord::Base.connection_handler.active_tenants do |tenant|
+      ActiveRecord::Base.connection_handler.remove_connection(tenant)
+    end
+  end
+
+  describe '#tenants_source_configurations' do
+
+    context 'redis source' do
+
+      before(:each) do
+        @manager.tenants_source_configurations({
+          source:              :redis,
+          host:                'localhost',
+          port:                6380,
+          password:            'none',
+          path:                '/tmp/redis.sock',
+          prefix_tenant_alias: 'test-tenant'
+        })
+      end
+
+      it 'places a redis instance on the source' do
+        expect(@manager.tenants_source).to be_an_instance_of Motel::Sources::Redis
+      end
+
+      it 'source attributes has a correct values' do
+        expect(@manager.tenants_source.host).to                eq 'localhost'
+        expect(@manager.tenants_source.port).to                eq 6380
+        expect(@manager.tenants_source.password).to            eq 'none'
+        expect(@manager.tenants_source.path).to                eq '/tmp/redis.sock'
+        expect(@manager.tenants_source.prefix_tenant_alias).to eq 'test-tenant'
+      end
+
+    end
+
+    context 'database source' do
+
+      before(:each) do
+        @manager.tenants_source_configurations({
+          source:      :database,
+          source_spec: TENANTS_SPEC,
+          table_name:  'tenant'
+        })
+      end
+
+      it 'places a database instance on the source' do
+        expect(@manager.tenants_source).to be_an_instance_of Motel::Sources::Database
+      end
+
+      it 'source attributes has a correct values' do
+        expect(@manager.tenants_source.source_spec).to eq TENANTS_SPEC
+        expect(@manager.tenants_source.table_name).to  eq 'tenant'
+      end
+
+    end
+
+    context 'default source' do
+
+      before(:each) do
+        @manager.tenants_source_configurations({source: :default})
+      end
+
+      it 'places a default instance on the source' do
+        expect(@manager.tenants_source).to be_an_instance_of Motel::Sources::Default
+      end
+
+    end
+
+  end
+
+  describe '#tenants' do
+
+    it 'returns tenant foo' do
+      expect(@manager.tenants.key?('foo')).to be_true
+    end
+
+    it 'returns tenant bar' do
+      expect(@manager.tenants.key?('bar')).to be_true
+    end
+
+  end
+
+  describe '#tenant' do
+
+    it 'returns tenant foo spec' do
+      expect(@manager.tenant('foo')['adapter']).to eq FOO_SPEC['adapter']
+      expect(@manager.tenant('foo')['database']).to eq FOO_SPEC['database']
+    end
+
+  end
+
+  describe '#tenant?' do
+
+    it 'returns true if tenant foo does exist' do
+      expect(@manager.tenant?('foo')).to be_true
+    end
+
+    it 'returns true if tenant baz does exist' do
+      resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+        BAZ_SPEC, nil
+      )
+      handler = ActiveRecord::Base.connection_handler
+      handler.establish_connection('baz', resolver.spec)
+      expect(@manager.tenant?('baz')).to be_true
+    end
+
+    it 'returns false if tenant does not exist' do
+      expect(@manager.tenant?('foobar')).to be_false
+    end
+
+  end
+
+  describe '#add_tenant' do
+
+    it 'adds new tenant' do
+      @manager.add_tenant('baz', BAZ_SPEC)
+
+      expect(@tenants_source.tenant?('baz')).to be_true
+    end
+
+  end
+
+  describe '#update_tenant' do
+
+    it 'updates tenant' do
+      @manager.update_tenant('foo', {adapter: 'mysql2', database: 'foo'})
+
+      expect(@tenants_source.tenant('foo')['adapter']).to  eq 'mysql2'
+      expect(@tenants_source.tenant('foo')['database']).to eq 'foo'
+    end
+
+    it 'returns the spec unpdated' do
+      spec_updated = @manager.update_tenant('foo', {adapter: 'mysql2', database: 'foo'})
+
+
+      expect(spec_updated['adapter']).to  eq 'mysql2'
+      expect(spec_updated['database']).to eq 'foo'
+    end
+
+  end
+
+  describe '#delete_tenant' do
+
+    it 'returns true' do
+      expect(@manager.delete_tenant('foo')).to be_true
+    end
+
+    it 'deletes tenant' do
+      @manager.delete_tenant('foo')
+      expect(@tenants_source.tenant?('foo')).to be_false
+    end
+
+    it 'removes connection of tenant' do
+
+      ActiveRecord::Base.connection_handler.establish_connection('foo')
+      @manager.delete_tenant('foo')
+
+      expect(ActiveRecord::Base.connection_handler.active_tenants).not_to include('foo')
+    end
+
+  end
+
+  describe '#active_tenants' do
+
+    it 'returns active tenans' do
+      ActiveRecord::Base.connection_handler.establish_connection('foo')
+      expect(@manager.active_tenants).to include('foo')
+    end
+
+  end
+
+  describe '#determines_tenant' do
+
+    context 'tenant environment variable, current tenant and default tenant are set' do
+
+      it 'returns tenant enviroment variable' do
+        ENV['TENANT'] = 'foo'
+        @manager.current_tenant = 'bar'
+        @manager.default_tenant = 'baz'
+
+        expect(@manager.determines_tenant).to eq ENV['TENANT']
+      end
+
+    end
+
+    context 'only current tenant and default tenant are set' do
+
+      it 'returns tenant enviroment variable' do
+        ENV['TENANT'] = nil
+        @manager.current_tenant = 'bar'
+        @manager.default_tenant = 'baz'
+
+        expect(@manager.determines_tenant).to eq @manager.current_tenant
+      end
+
+    end
+
+    context 'only default tenant is set' do
+
+      it 'returns tenant enviroment variable' do
+        ENV['TENANT'] = nil
+        @manager.current_tenant = nil
+        @manager.default_tenant = 'baz'
+
+        expect(@manager.determines_tenant).to eq @manager.default_tenant
+      end
+
+    end
+
+  end
+
+end
+

data/spec/lib/motel/multi_tenant_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe ActiveRecord::Base do
+
+  before(:all) do
+    ActiveRecord::Base.motel.tenants_source_configurations({source: :default})
+    ActiveRecord::Base.motel.add_tenant('foo', FOO_SPEC)
+    ActiveRecord::Base.motel.add_tenant('bar', BAR_SPEC)
+  end
+
+  after(:all) do
+    ActiveRecord::Base.motel.delete_tenant('foo')
+    ActiveRecord::Base.motel.delete_tenant('bar')
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection_handler.active_tenants do |tenant|
+      ActiveRecord::Base.connection_handler.remove_connection(tenant)
+    end
+    ActiveRecord::Base.motel.current_tenant = nil
+  end
+
+  describe '.establish_connection' do
+
+    it 'establishes a connection keyed  by the class name' do
+      ActiveRecord::Base.establish_connection(BAZ_SPEC)
+
+      expect(ActiveRecord::Base.connection_handler.active_tenants).to include('ActiveRecord::Base')
+    end
+
+  end
+
+  describe '.connection_pool' do
+
+    context 'current tenant established' do
+
+      it 'returns a connection pool of current tenant' do
+        ActiveRecord::Base.motel.current_tenant = 'foo'
+        pool = ActiveRecord::Base.connection_handler.establish_connection('foo')
+
+        expect(ActiveRecord::Base.connection_pool).to eq pool
+      end
+
+    end
+
+    context 'current tenant not established' do
+
+      it 'rises an error' do
+        ActiveRecord::Base.motel.current_tenant = nil
+        expect{ActiveRecord::Base.connection_pool}.to raise_error Motel::NoCurrentTenantError
+      end
+
+    end
+
+  end
+
+  describe '.retrieve_connection' do
+
+    context 'current tenant established' do
+
+      it 'returns a connection of current tenant' do
+        ActiveRecord::Base.motel.current_tenant = 'foo'
+        pool = ActiveRecord::Base.connection_handler.establish_connection('foo')
+
+        expect(ActiveRecord::Base.retrieve_connection).to eq pool.connection
+      end
+
+    end
+
+    context 'current tenant not established' do
+
+      it 'rises an error' do
+        ActiveRecord::Base.motel.current_tenant = nil
+        expect{ActiveRecord::Base.retrieve_connection}.to raise_error Motel::NoCurrentTenantError
+      end
+
+    end
+
+  end
+
+  describe '.connected?' do
+
+    before(:each) do
+      ActiveRecord::Base.connection_handler.retrieve_connection('foo')
+    end
+
+    context 'current tenant established' do
+
+      it 'returns true' do
+        ActiveRecord::Base.motel.current_tenant = 'foo'
+        expect(ActiveRecord::Base.connected?).to be_true
+      end
+
+      it 'returns false' do
+        ActiveRecord::Base.motel.current_tenant = 'bar'
+        expect(ActiveRecord::Base.connected?).to be_false
+      end
+
+    end
+
+    context 'current tenant not established' do
+
+      it 'rises an error' do
+        ActiveRecord::Base.motel.current_tenant = nil
+        expect{ActiveRecord::Base.connected?}.to raise_error Motel::NoCurrentTenantError
+      end
+
+    end
+
+  end
+
+  describe '.remove_connection' do
+
+    context 'current tenant established' do
+
+      it 'removes connection' do
+        ActiveRecord::Base.connection_handler.establish_connection('foo')
+        ActiveRecord::Base.motel.current_tenant = 'foo'
+        ActiveRecord::Base.remove_connection
+        expect(ActiveRecord::Base.connection_handler.active_tenants).not_to include('foo')
+      end
+
+    end
+
+    context 'current tenant not established' do
+
+      it 'rises an error' do
+        ActiveRecord::Base.motel.current_tenant = nil
+        expect{ActiveRecord::Base.remove_connection}.to raise_error Motel::NoCurrentTenantError
+      end
+
+    end
+
+  end
+
+  describe '.arel_engine' do
+
+    it 'returns a ActiveRecord::Base class' do
+      expect(ActiveRecord::Base.arel_engine).to eq ActiveRecord::Base
+    end
+
+  end
+
+  describe '.current_tenant' do
+
+    context 'tenant enviroment variable or current tenant or default tenant are set' do
+
+      it 'returns the current tenant' do
+        ActiveRecord::Base.motel.current_tenant = 'foo'
+
+        expect(ActiveRecord::Base.current_tenant).to eq 'foo'
+      end
+
+    end
+
+    context 'no tenant has been established' do
+
+      it 'rises an error' do
+        ActiveRecord::Base.motel.current_tenant = nil
+
+        expect{ActiveRecord::Base.current_tenant}.to raise_error Motel::NoCurrentTenantError
+      end
+
+    end
+
+  end
+
+end
+

data/spec/lib/motel/sources/database_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Motel::Sources::Database do
+
+  before(:all) do
+    @klass = Class.new(ActiveRecord::Base) { def self.name; 'klass'; end }
+
+    resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(TENANTS_SPEC, nil)
+    @handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    @handler.establish_connection(@klass, resolver.spec)
+
+    @table_name = 'tenant'
+    @tenants_source = Motel::Sources::Database.new(
+      source_spec: TENANTS_SPEC, table_name: @table_name
+    )
+
+    @tenant_table_sql = <<-SQL
+      CREATE TABLE #{@table_name}(
+        `name`     VARCHAR PRIMARY KEY,
+        `adapter`  VARCHAR,
+        `socket`   VARCHAR,
+        `port`     INTEGER,
+        `pool`     INTEGER,
+        `host`     VARCHAR,
+        `username` VARCHAR,
+        `password` VARCHAR,
+        `database` VARCHAR,
+        `url`      VARCHAR
+      )
+    SQL
+  end
+
+  before(:all) do
+    @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+      conn.execute(@tenant_table_sql)
+    end
+  end
+
+  before (:each) do
+    @foo_tenant_sql = <<-SQL
+      INSERT INTO #{@table_name}(`name`, `adapter`, `database`)
+      VALUES ("foo", "#{FOO_SPEC['adapter']}", "#{FOO_SPEC['database']}")
+    SQL
+
+    @bar_tenant_sql = <<-SQL
+      INSERT INTO #{@table_name}(`name`, `adapter`, `database`)
+      VALUES ("bar", "#{BAR_SPEC['adapter']}", "#{BAR_SPEC['database']}")
+    SQL
+
+    @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+      conn.execute(@foo_tenant_sql)
+      conn.execute(@bar_tenant_sql)
+    end
+  end
+
+  after(:each) do
+    @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+      conn.execute("DELETE FROM #{@table_name}")
+    end
+  end
+
+  after(:all) do
+    @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+      conn.execute("DROP TABLE #{@table_name}")
+    end
+  end
+
+  describe '#tenants' do
+
+    it 'there are only two tenants' do
+      expect(@tenants_source.tenants.count).to eq 2
+    end
+
+    it 'exist foo key' do
+      expect(@tenants_source.tenants.key?('foo')).to be_true
+    end
+
+    it 'tenant foo has a correct spec' do
+      expect(@tenants_source.tenants['foo']['adapter']).to eq FOO_SPEC['adapter']
+      expect(@tenants_source.tenants['foo']['database']).to eq FOO_SPEC['database']
+    end
+
+    it 'exist bar key' do
+      expect(@tenants_source.tenants.key?('bar')).to be_true
+    end
+
+    it 'tenant bar has a correct spec' do
+      expect(@tenants_source.tenants['bar']['adapter']).to eq BAR_SPEC['adapter']
+      expect(@tenants_source.tenants['bar']['database']).to eq BAR_SPEC['database']
+    end
+
+  end
+
+  describe '#tenant' do
+
+    context 'existing tenant' do
+
+      it 'tenant foo has a correct spec' do
+        expect(@tenants_source.tenant('foo')['adapter']).to eq FOO_SPEC['adapter']
+        expect(@tenants_source.tenant('foo')['database']).to eq FOO_SPEC['database']
+      end
+
+    end
+
+    context 'nonexistent tenant' do
+
+      it 'returns null' do
+        expect(@tenants_source.tenant('baz')).to be_nil
+      end
+
+    end
+
+  end
+
+  describe '#tenant?' do
+
+    it 'returns true if tenant does exist' do
+      expect(@tenants_source.tenant?('foo')).to be_true
+    end
+
+    it 'returns false if tenant does not exist' do
+      expect(@tenants_source.tenant?('baz')).to be_false
+    end
+
+  end
+
+  describe '#add_tenant' do
+
+    context 'existing tenant' do
+
+      it 'raise an error' do
+        expect{
+          @tenants_source.add_tenant('foo', FOO_SPEC)
+        }.to raise_error Motel::ExistingTenantError
+      end
+
+    end
+
+    context 'nonexistent tenant' do
+
+      context 'spec has keys as strings' do
+
+        it 'add new tenant to database' do
+          @tenants_source.add_tenant(
+            'baz', {'adapter'  => BAZ_SPEC['adapter'], 'database' => BAZ_SPEC['database']}
+          )
+
+          result = @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+            conn.select_all("SELECT * FROM #{@table_name} WHERE `name` = 'baz'")
+          end
+
+          expect(result.first['adapter']).to eq BAZ_SPEC['adapter']
+          expect(result.first['database']).to eq BAZ_SPEC['database']
+        end
+
+      end
+
+      context 'spec has keys as symbols' do
+
+        it 'add new tenant to database' do
+          @tenants_source.add_tenant(
+            'baz', {adapter:  BAZ_SPEC['adapter'] , database: BAZ_SPEC['database']}
+          )
+
+          result = @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+            conn.select_all("SELECT * FROM #{@table_name} WHERE `name` = 'baz'")
+          end
+
+          expect(result.first['adapter']).to eq BAZ_SPEC['adapter']
+          expect(result.first['database']).to eq BAZ_SPEC['database']
+        end
+
+      end
+
+    end
+
+  end
+
+  describe '#update_tenant' do
+
+    context 'existing tenant' do
+
+      context 'full update' do
+
+        it 'update tenant in the database' do
+          @tenants_source.update_tenant(
+            'foo', {adapter: 'mysql2', database: 'foo'}
+          )
+
+          result = @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+            conn.select_all("SELECT * FROM #{@table_name} WHERE `name` = 'foo'")
+          end
+
+          expect(result.first['adapter']).to eq 'mysql2'
+          expect(result.first['database']).to eq 'foo'
+        end
+
+      end
+
+      context 'partial update' do
+
+        it 'update tenant in the database' do
+          @tenants_source.update_tenant(
+            'foo', {adapter: 'mysql2'}
+          )
+
+          result = @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+            conn.select_all("SELECT * FROM #{@table_name} WHERE `name` = 'foo'")
+          end
+
+          expect(result.first['adapter']).to eq 'mysql2'
+          expect(result.first['database']).to eq FOO_SPEC['database']
+        end
+
+      end
+
+    end
+
+    context 'nonexistent tenant' do
+
+      it 'raise an error' do
+        expect{
+          @tenants_source.update_tenant('baz', {})
+        }.to raise_error Motel::NonexistentTenantError
+      end
+
+    end
+
+  end
+
+  describe '#delete_tenant' do
+
+    it 'remove tenant from redis server' do
+      @tenants_source.delete_tenant('foo')
+
+      result = @handler.retrieve_connection_pool(@klass).with_connection do |conn|
+        conn.select_all("SELECT * FROM #{@table_name} WHERE `name` = 'foo'")
+      end
+
+      expect(result.count).to eq 0
+    end
+
+  end
+
+end
+