tenantify 0.0.1

data/lib/tenantify/middleware/strategies/default.rb

@@ -0,0 +1,46 @@
+module Tenantify
+  class Middleware
+    class Strategies
+      # Strategy to return always the same tenant.
+      #
+      # @example Using Default strategy:
+      #   config   = {:tenant => :a_tenant}
+      #   strategy = Tenantify::Middleware::Strategies::Default.new(config)
+      #
+      #   env = {} # any environment
+      #   strategy.tenant_for(env) # => :a_tenant
+      class Default
+        # No tenant given.
+        NoTenantGivenError = Class.new(StandardError)
+
+        # Constructor.
+        #
+        # @param [Hash] the strategy configuration.
+        # @option :tenant the tenant to return
+        def initialize config
+          @config = config
+        end
+
+        # Finds a tenant for the given env.
+        #
+        # @param [rack_environment] the rack environment.
+        # @return [Symbol, nil] the found tenant of nil.
+        def tenant_for _env
+          tenant
+        end
+
+      private
+
+        attr_reader :config
+
+        def tenant
+          @tenant ||= config.fetch(:tenant) { raise_error }.to_sym
+        end
+
+        def raise_error
+          raise NoTenantGivenError
+        end
+      end
+    end
+  end
+end

data/lib/tenantify/middleware/strategies/header.rb

@@ -0,0 +1,52 @@
+module Tenantify
+  class Middleware
+    class Strategies
+      # Strategy to get the tenant from a request header.
+      # It expect the tenant name from configuration.
+      #
+      # @example Using Header strategy:
+      #   config   = {:name => "X-Tenant"}
+      #   strategy = Tenantify::Middleware::Strategies::Header.new(config)
+      #
+      #   matching_env = {"X-Tenant" => "a_tenant"}
+      #   strategy.tenant_for(matching_env) # => :a_tenant
+      #
+      #   not_matching_env = {"X-Another-Header" => "something"}
+      #   strategy.tenant_for(not_matching_env) # => nil
+      class Header
+        # No header name provided.
+        NoHeaderNameError = Class.new(StandardError)
+
+        # Constructor.
+        #
+        # @param [Hash] the strategy configuration.
+        # @option :name the name of the header.
+        def initialize config
+          @config = config
+        end
+
+        # Finds a tenant for the given env.
+        #
+        # @param [rack_environment] the rack environment.
+        # @return [Symbol, nil] the found tenant of nil.
+        def tenant_for env
+          tenant = env[header_name]
+
+          tenant.to_sym if tenant
+        end
+
+      private
+
+        attr_reader :config
+
+        def header_name
+          @header_name ||= config.fetch(:name) { raise_error }
+        end
+
+        def raise_error
+          raise NoHeaderNameError
+        end
+      end
+    end
+  end
+end

data/lib/tenantify/middleware/strategies/host.rb

@@ -0,0 +1,57 @@
+module Tenantify
+  class Middleware
+    class Strategies
+      # Strategy to get the tenant from the request host.
+      # It expect the tenant name from configuration.
+      #
+      # @example Using Host strategy:
+      #   config = {
+      #     :tenant_1 => ["www.domain_a.com", "www.domain_b.com"],
+      #     :tenant_2 => ["www.domain_c.com"]
+      #   }
+      #   strategy = Tenantify::Middleware::Strategies::Host.new(config)
+      #
+      #   matching_env = {"SERVER_NAME" => "www.domain_b.com"}
+      #   strategy.tenant_for(matching_env) # => :tenant_1
+      #
+      #   not_matching_env = {"SERVER_NAME" => "www.another_domain.com"}
+      #   strategy.tenant_for(not_matching_env) # => nil
+      class Host
+        # Constructor. It receives a hash with tenants as keys and arrays of
+        # hosts as values.
+        #
+        # @param [{Symbol => <String>}] the strategy configuration.
+        def initialize config
+          @config = config
+        end
+
+        # Finds a tenant for the given env.
+        #
+        # @param [rack_environment] the rack environment.
+        # @return [Symbol, nil] the found tenant of nil.
+        def tenant_for env
+          host   = env["SERVER_NAME"]
+          tenant = correspondence[host]
+
+          tenant.to_sym if tenant
+        end
+
+      private
+
+        attr_reader :config
+
+        def correspondence
+          @correspondence ||= config.reduce Hash.new do |result, (tenant, domains)|
+            result.merge! correspondence_for(tenant, domains)
+          end
+        end
+
+        def correspondence_for tenant, domains
+          domains.reduce Hash.new do |result, domain|
+            result.merge! domain => tenant
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tenantify/resource.rb

@@ -0,0 +1,28 @@
+require 'tenantify/tenant'
+
+module Tenantify
+  class Resource
+    include Enumerable
+
+    def initialize correspondence
+      @correspondence = correspondence
+    end
+
+    def current
+      correspondence.fetch(Tenant.current)
+    end
+
+    def all
+      correspondence
+    end
+
+    def each &block
+      correspondence.each &block
+    end
+
+  private
+
+    attr_reader :correspondence
+
+  end
+end

data/lib/tenantify/tenant.rb

@@ -0,0 +1,44 @@
+module Tenantify
+  # Responsible for managing the current tenant. All useful methods {#using},
+  # {#use!}, and {#current} have aliases at {Tenantify} module.
+  #
+  # == Threading Notes
+  # The {Tenantify::Tenant} module uses thread variables to store the current
+  # tenant. This means that when a new thread is spawned, the tenant has to
+  # be set manually.
+  module Tenant
+    # Runs the given block for a tenant.
+    #
+    # @param [Symbol] the tenant to run the code for.
+    # @yield the code to run.
+    # @return the returning value of the block.
+    #
+    # @example Getting data from a storage of a particular tenant:
+    #   data = Tenant.using :the_tenant do
+    #     Storage.current.get_data
+    #   end
+    def self.using tenant
+      original_tenant = Thread.current.thread_variable_get(:tenant)
+
+      Thread.current.thread_variable_set(:tenant, tenant)
+      yield
+    ensure
+      Thread.current.thread_variable_set(:tenant, original_tenant)
+    end
+
+    # Sets the given tenant from now on.
+    #
+    # @param [Symbol] the tenant to set.
+    # @return [Symbol] the set tenant.
+    def self.use! tenant
+      Thread.current.thread_variable_set(:tenant, tenant)
+    end
+
+    # Returns the current tenant.
+    #
+    # @return [Symbol] the current tenant.
+    def self.current
+      Thread.current.thread_variable_get(:tenant)
+    end
+  end
+end

data/lib/tenantify/version.rb

@@ -0,0 +1,5 @@
+module Tenantify
+
+  VERSION = "0.0.1"
+
+end

data/spec/integration/manual_tenant_selection_spec.rb

@@ -0,0 +1,16 @@
+require 'tenantify'
+
+RSpec.describe "Manual tenant selection" do
+
+  it 'changes the current tenant properly' do
+    Tenantify.use! :tenant_1
+    expect(Tenantify.current).to eq :tenant_1
+
+    Tenantify.using :tenant_2 do
+      expect(Tenantify.current).to eq :tenant_2
+    end
+
+    expect(Tenantify.current).to eq :tenant_1
+  end
+
+end

data/spec/integration/middleware/custom_strategy.rb

@@ -0,0 +1,40 @@
+require 'tenantify'
+
+RSpec.describe "Many middleware strategies" do
+
+  let(:app) { double 'app' }
+
+  let :test_strategy do
+    Class.new do
+      def initialize config
+      end
+
+      def tenant_for env
+        :the_tenant
+      end
+    end
+  end
+
+  let :config do
+    Tenantify::Configuration.new.tap do |config|
+      config.strategy test_strategy
+    end
+  end
+
+  let(:env)      { double 'env' }
+  let(:response) { double 'response' }
+
+  it 'returns a matching tenant or raises_error' do
+    middleware = Tenantify::Middleware.new(app, config)
+
+    expect(app).to receive :call do |env|
+      expect(env).to eq env
+      expect(Tenantify.current).to eq :the_tenant
+
+      response
+    end
+
+    expect(middleware.call(env)).to eq response
+  end
+
+end

data/spec/integration/middleware/many_strategies.rb

@@ -0,0 +1,35 @@
+require 'tenantify'
+
+RSpec.describe "Many middleware strategies" do
+
+  let(:app) { double 'app' }
+
+  let :hosts_config do
+    {:first_tenant  => ["www.host_a.com", "www.host_b.com"],
+     :second_tenant => ["www.host_c.com", "www.host_d.com"]}
+  end
+
+  let :config do
+    Tenantify::Configuration.new.tap do |config|
+      config.strategy :header, :name => "X-Tenant"
+      config.strategy :host, hosts_config
+    end
+  end
+
+  let(:env)      { {"SERVER_NAME" => "www.host_c.com"} }
+  let(:response) { double 'response' }
+
+  it 'returns a matching tenant' do
+    middleware = Tenantify::Middleware.new(app, config)
+
+    expect(app).to receive :call do |env|
+      expect(env).to eq env
+      expect(Tenantify.current).to eq :second_tenant
+
+      response
+    end
+
+    expect(middleware.call(env)).to eq response
+  end
+
+end

data/spec/integration/middleware/one_strategy_spec.rb

@@ -0,0 +1,36 @@
+require 'tenantify'
+
+RSpec.describe "One middleware strategy" do
+
+  let(:app) { double 'app' }
+
+  let :config do
+    Tenantify::Configuration.new.tap do |config|
+      config.strategy :header, :name => "X-Tenant"
+    end
+  end
+
+  let(:valid_env)   { {"X-Tenant" => "a_tenant"} }
+  let(:invalid_env) { {} }
+
+  let(:response) { double 'response' }
+
+  it 'returns a matching tenant or raises_error' do
+    middleware = Tenantify::Middleware.new(app, config)
+
+    # Valid env
+    expect(app).to receive :call do |env|
+      expect(env).to eq env
+      expect(Tenantify.current).to eq :a_tenant
+
+      response
+    end
+
+    expect(middleware.call(valid_env)).to eq response
+
+    # Invalid env
+    no_match_error = Tenantify::Middleware::Strategies::NotMatchingStrategyError
+    expect {middleware.call(invalid_env)}.to raise_error no_match_error
+  end
+
+end

data/spec/integration/middleware/using_resources_spec.rb

@@ -0,0 +1,48 @@
+require 'tenantify'
+
+RSpec.describe "Using a resource with the middleware" do
+
+  let(:app) { double 'app' }
+
+  let :test_strategy do
+    Class.new do
+      def initialize config
+      end
+
+      def tenant_for env
+        :a_tenant
+      end
+    end
+  end
+
+  let :config do
+    Tenantify::Configuration.new.tap do |config|
+      config.strategy test_strategy
+    end
+  end
+
+  let(:resource_1) { double 'resource_1' }
+  let(:resource_2) { double 'resource_2' }
+
+  let :resource do
+    Tenantify.resource :a_tenant       => resource_1,
+                       :another_tenant => resource_2
+  end
+
+  let(:env)      { double 'env' }
+  let(:response) { double 'response' }
+
+  it 'returns a matching tenant or raises_error' do
+    middleware = Tenantify::Middleware.new(app, config)
+
+    expect(app).to receive :call do |env|
+      expect(env).to eq env
+      expect(resource.current).to eq resource_1
+
+      response
+    end
+
+    expect(middleware.call(env)).to eq response
+  end
+
+end

data/spec/integration/resources_spec.rb

@@ -0,0 +1,16 @@
+require 'tenantify'
+
+RSpec.describe "Resource creation" do
+
+  it 'changes the current tenant properly' do
+    Tenantify.use! :tenant_1
+    expect(Tenantify.current).to eq :tenant_1
+
+    Tenantify.using :tenant_2 do
+      expect(Tenantify.current).to eq :tenant_2
+    end
+
+    expect(Tenantify.current).to eq :tenant_1
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'pry'
+require 'tenantify/tenant'
+
+RSpec.configure do |config|
+
+  # Restore the original tenant after each test
+  config.around :each do |example|
+    begin
+      original_value = Tenantify::Tenant.current
+      example.run
+    ensure
+      Tenantify::Tenant.use! original_value
+    end
+  end
+
+  config.expect_with :rspec do |expectations|
+    # Best error messages on chained expectations
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from stubbing a method that does not exist on a real object
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+  config.order = :random
+
+end