motel-activerecord 1.0.0

data/lib/motel/sources/redis.rb

@@ -0,0 +1,80 @@
+require 'redis'
+
+module Motel
+  module Sources
+
+    class Redis
+
+      attr_accessor :host, :port, :password, :path, :prefix_tenant_alias
+
+      def initialize(config = {})
+        @host                = config[:host]
+        @port                = config[:port]
+        @password            = config[:password]
+        @path                = config[:path]
+        @prefix_tenant_alias = (config[:prefix_tenant_alias] || 'tenant:')
+      end
+
+      def tenants
+        redis.keys.inject({}) do |hash, tenant_als|
+          if tenant_als.match("^#{prefix_tenant_alias}")
+            hash[tenant_name(tenant_als)] = tenant(tenant_name(tenant_als))
+          end
+          hash
+        end
+      end
+
+      def tenant(name)
+        spec = redis.hgetall(tenant_alias(name))
+        spec if spec.any?
+      end
+
+      def tenant?(name)
+        !tenant(name).nil?
+      end
+
+      def add_tenant(name, spec)
+        raise ExistingTenantError if tenant?(name)
+
+        spec.each do |field, value|
+          redis.hset(tenant_alias(name), field, value)
+        end
+      end
+
+      def update_tenant(name, spec)
+        raise NonexistentTenantError unless tenant?(name)
+
+        spec.each do |field, value|
+          redis.hset(tenant_alias(name), field, value)
+        end
+      end
+
+      def delete_tenant(name)
+        if tenant?(name)
+          fields = redis.hkeys tenant_alias(name)
+          redis.hdel(tenant_alias(name), [*fields])
+        end
+      end
+
+      private
+
+        def redis
+          @redis ||= begin
+            ::Redis.new(host: host, port: port, password: password, path: path)
+          end
+        end
+
+        def tenant_alias(name)
+          "#{prefix_tenant_alias}#{name}"
+        end
+
+        def tenant_name(tenant_alias)
+          name = tenant_alias.match("#{prefix_tenant_alias}(.*)")
+          name[1] if name
+        end
+
+    end
+
+  end
+end
+

data/lib/motel/version.rb

@@ -0,0 +1,6 @@
+module Motel
+
+  VERSION = File.read(File.expand_path('../../../VERSION', __FILE__)).strip
+
+end
+

data/spec/lib/motel/connection_adapters/connection_handler_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Motel::ConnectionAdapters::ConnectionHandler do
+
+  before(:each) do
+    @handler = Motel::ConnectionAdapters::ConnectionHandler.new
+    @handler.tenants_source.add_tenant('foo', FOO_SPEC)
+    @handler.tenants_source.add_tenant('bar', BAR_SPEC)
+  end
+
+  describe '#establish_connection' do
+
+    context 'specifying only the tenant name' do
+
+      context 'existing tenant' do
+
+        it 'returns an instance of ConnectionPool' do
+          expect(
+            @handler.establish_connection('foo')
+          ).to be_an_instance_of ActiveRecord::ConnectionAdapters::ConnectionPool
+        end
+
+      end
+
+      context 'nonexistent tenant' do
+
+        it 'raise an error' do
+          expect{
+            @handler.establish_connection('baz')
+          }.to raise_error Motel::NonexistentTenantError
+        end
+
+      end
+
+    end
+
+    context 'specifying tenant name and the spec' do
+
+      it 'returns an instance if ConnectionPool' do
+        resolver = Motel::ConnectionAdapters::ConnectionSpecification::Resolver.new
+        spec = resolver.spec(BAZ_SPEC)
+        expect(
+          @handler.establish_connection('baz', spec)
+        ).to be_an_instance_of ActiveRecord::ConnectionAdapters::ConnectionPool
+      end
+
+    end
+
+  end
+
+  describe '#retrieve_connection' do
+
+    context 'existing tenant' do
+
+      it 'initializes and returns a connection' do
+        expect(@handler.retrieve_connection('foo')).to be_true
+      end
+
+      it 'returns a connection' do
+        @pool = @handler.establish_connection('foo')
+        expect(@handler.retrieve_connection('foo')).to eq @pool.connection
+      end
+
+    end
+
+    context 'nonexistent tenant' do
+
+      it 'raise an error' do
+        expect{
+          @handler.retrieve_connection('baz')
+        }.to raise_error Motel::NonexistentTenantError
+      end
+
+    end
+
+  end
+
+  describe '#retrieve_connection_pool' do
+
+    context 'existing tenant' do
+
+      it 'initializes and returns a connection pool' do
+        expect(@handler.retrieve_connection_pool('foo')).to be_true
+      end
+
+      it 'returns a connection pool' do
+        @pool = @handler.establish_connection('foo')
+        expect(@handler.retrieve_connection_pool('foo')).to eq @pool
+      end
+
+    end
+
+    context 'nonexistent tenant' do
+
+      it 'raise an error' do
+        expect{
+          @handler.retrieve_connection('baz')
+        }.to raise_error Motel::NonexistentTenantError
+      end
+
+    end
+
+  end
+
+  describe '#connected?' do
+
+    it 'returns true' do
+      @handler.retrieve_connection('foo')
+      expect(@handler.connected?('foo')).to be_true
+    end
+
+    it 'returns false' do
+      expect(@handler.connected?('foo')).to be_false
+    end
+
+  end
+
+  describe '#active_connections?' do
+
+    it 'has not active connections' do
+      expect(@handler.active_connections?).to be_false
+    end
+
+    it 'has active connections' do
+      @handler.retrieve_connection('foo')
+      expect(@handler.active_connections?).to be_true
+    end
+
+  end
+
+  describe '#remove_connection' do
+
+    it 'removes the connection' do
+      @handler.retrieve_connection('foo')
+      expect(@handler.active_connections?).to be_true
+
+      @handler.remove_connection('foo')
+      expect(@handler.active_connections?).to be_false
+    end
+
+  end
+
+  describe '#active_tenants' do
+
+    context 'no active tenants' do
+
+      it 'returns empty array' do
+        expect(@handler.active_tenants).to be_empty
+      end
+
+    end
+
+    context 'are active tenants' do
+
+      before(:each) do
+        @handler.establish_connection('foo')
+        @handler.establish_connection('bar')
+      end
+
+
+      it 'returns exactly two names' do
+        expect(@handler.active_tenants.count).to eq 2
+      end
+
+      it 'returns the names' do
+        expect(@handler.active_tenants).to include('foo', 'bar')
+      end
+
+    end
+
+  end
+
+  describe '#tenants_sources=' do
+
+    it 'sets a tenats source for teh resolver' do
+      @handler.tenants_source = Motel::Sources::Redis.new
+
+      expect(@handler.tenants_source).to be_an_instance_of Motel::Sources::Redis
+    end
+
+  end
+
+end
+

data/spec/lib/motel/connection_adapters/connection_specification/resolver_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Motel::ConnectionAdapters::ConnectionSpecification::Resolver do
+
+  describe '#spec' do
+
+    context 'from a hash' do
+
+      before(:each) do
+        @resolver = Motel::ConnectionAdapters::ConnectionSpecification::Resolver.new
+      end
+
+      context 'specifying adapter' do
+
+        context 'existing adapter' do
+
+          it 'returns an instance of ConnectionSpecification' do
+            expect(
+              @resolver.spec(BAZ_SPEC)
+            ).to be_an_instance_of ActiveRecord::ConnectionAdapters::ConnectionSpecification
+          end
+
+        end
+
+        context 'nonexistent adapter' do
+
+          it 'rises an error' do
+            expect{@resolver.spec({adapter: 'nonexistent_adapter'})}.to raise_error LoadError
+          end
+
+        end
+
+      end
+
+      context 'adapter unspecified' do
+
+        it 'rises an error' do
+          expect{
+            @resolver.spec({database: BAZ_SPEC['database']})
+          }.to raise_error ActiveRecord::AdapterNotSpecified
+        end
+
+      end
+
+    end
+
+    context 'from a string' do
+
+      before(:each) do
+        @resolver = Motel::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+          {'foo' => FOO_SPEC}
+        )
+      end
+
+      context 'string as a key' do
+
+        context 'existing configuration' do
+
+          it 'returns an instance of ConnectionSpecification' do
+            expect(
+              @resolver.spec('foo')
+            ).to be_an_instance_of ActiveRecord::ConnectionAdapters::ConnectionSpecification
+          end
+
+        end
+
+        context 'nonexistent configuration' do
+
+          it 'rises an error' do
+            expect{@resolver.spec('baz')}.to raise_error ActiveRecord::AdapterNotSpecified
+          end
+
+        end
+
+      end
+
+      context 'string as a url' do
+
+        before(:all) do
+          @url = 'mysql2://foo:foobar_password@localhost:3306/foobar'
+        end
+
+        it 'returns an instance of ConnectionSpecification' do
+          expect(
+            @resolver.spec(@url)
+          ).to be_an_instance_of ActiveRecord::ConnectionAdapters::ConnectionSpecification
+        end
+
+        it 'spec of connection specifications contains a correct adapter' do
+          expect(@resolver.spec(@url).config[:adapter]).to eq 'mysql2'
+        end
+
+        it 'spec of connection specifications contains a correct username' do
+          expect(@resolver.spec(@url).config[:username]).to eq 'foo'
+        end
+
+        it 'spec of connection specifications contains a correct password' do
+          expect(@resolver.spec(@url).config[:password]).to eq 'foobar_password'
+        end
+
+        it 'spec of connection specifications contains a correct host' do
+          expect(@resolver.spec(@url).config[:host]).to eq 'localhost'
+        end
+
+        it 'spec of connection specifications contains a correct port' do
+          expect(@resolver.spec(@url).config[:port]).to eq 3306
+        end
+
+        it 'spec of connection specifications contains a correct database' do
+          expect(@resolver.spec(@url).config[:database]).to eq 'foobar'
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/spec/lib/motel/lobby_spec.rb

@@ -0,0 +1,155 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'spec_helper'
+require 'rack/test'
+require 'tempfile'
+
+describe Motel::Lobby do
+  include Rack::Test::Methods
+
+  def app
+    app = lambda{ |env| [200, {"Content-Type" => "text/html"}, "Test"] }
+    Motel::Lobby.new(app)
+  end
+
+  before(:all) do
+    ActiveRecord::Base.motel.add_tenant('foo', FOO_SPEC)
+  end
+
+  after(:all) do
+    ActiveRecord::Base.motel.delete_tenant('foo')
+    ActiveRecord::Base.motel.admission_criteria = nil #sets default
+    ActiveRecord::Base.motel.nonexistent_tenant_page = nil #sets default
+  end
+
+  describe '#call' do
+
+    context 'default admission criteria' do
+
+      before(:all) do
+        ActiveRecord::Base.motel.admission_criteria = nil
+      end
+
+      context 'url match' do
+
+        context 'existing tenant' do
+
+          before(:each) do
+            @url = 'http://foo.test.com'
+          end
+
+          it 'sets the current tenant' do
+            request @url
+
+            expect(ActiveRecord::Base.motel.current_tenant).to eq 'foo'
+          end
+
+          it 'response is ok' do
+            request  @url
+
+            expect(last_response).to be_ok
+          end
+
+        end
+
+        context 'nonexistent tenant' do
+
+          before(:each) do
+            @url = 'http://bar.test.com'
+          end
+
+          it 'returns 404 code' do
+            request @url
+
+            expect(last_response.status).to eq 404
+          end
+
+          context 'with default nonexistent tenant message' do
+
+            it 'returns default message on body' do
+              ActiveRecord::Base.motel.nonexistent_tenant_page = nil
+              request @url
+
+              expect(last_response.body).to eq "Nonexistent bar tenant"
+            end
+
+          end
+
+          context 'specifying the path of the page with the nonexistent tenant message' do
+
+            it 'returns default message on body' do
+              message = '<h1>Noexistent tenant<h1>'
+              file = Tempfile.new(['status_404', '.html'], TEMP_DIR)
+              file.write(message)
+              file.close
+
+              ActiveRecord::Base.motel.nonexistent_tenant_page = file.path
+              request @url
+
+              expect(last_response.body).to eq message
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  context 'specifying admission criteria' do
+
+    before(:all) do
+      ActiveRecord::Base.motel.admission_criteria = 'tenants\/(\w*)'
+    end
+
+    context 'url match' do
+
+      context 'existing tenant' do
+
+        before(:each) do
+          @url = 'http://www.example.com/tenants/foo'
+        end
+
+        it 'sets the current tenant' do
+          request @url
+
+          expect(ActiveRecord::Base.motel.current_tenant).to eq 'foo'
+        end
+
+        it 'response is ok' do
+          request  @url
+
+          expect(last_response).to be_ok
+        end
+
+      end
+
+    end
+
+    context 'url does not match' do
+
+      before(:each) do
+        @url = 'http://example.com'
+      end
+
+      it 'sets null the current tenant' do
+        request @url
+
+        expect(ActiveRecord::Base.motel.current_tenant).to be_nil
+     end
+
+      it 'response is ok' do
+        request  @url
+
+        expect(last_response).to be_ok
+      end
+
+    end
+
+  end
+
+end
+