goncalossilva-subdomain_routes 0.3.3

data/spec/recognition_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "subdomain route recognition" do
+  before(:each) do
+    @request = ActionController::TestRequest.new
+    @request.host = "www.example.com"
+    @request.request_uri = "/items/2"
+  end
+
+  it "should add the host's subdomain to the request environment" do
+    request_environment = ActionController::Routing::Routes.extract_request_environment(@request)
+    request_environment[:subdomain].should == "www"
+  end
+  
+  it "should add an empty subdomain to the request environment if the host has no subdomain" do
+    @request.host = "example.com"
+    request_environment = ActionController::Routing::Routes.extract_request_environment(@request)
+    request_environment[:subdomain].should == ""
+  end
+  
+  context "for a single specified subdomain" do
+    it "should recognise a route if the subdomain matches" do
+      map_subdomain(:www) { |www| www.resources :items }
+      params = recognize_path(@request)
+      params[:controller].should == "www/items"
+      params[:action].should == "show"
+      params[:id].should == "2"
+    end
+  
+    it "should not recognise a route if the subdomain doesn't match" do
+      map_subdomain("admin") { |admin| admin.resources :items }
+      lambda { recognize_path(@request) }.should raise_error(ActionController::RoutingError)
+    end
+  end
+  
+  context "for a nil or blank subdomain" do
+    [ nil, "" ].each do |subdomain|
+      it "should recognise a route if there is no subdomain present" do
+        map_subdomain(subdomain) { |map| map.resources :items }
+        @request.host = "example.com"
+        lambda { recognize_path(@request) }.should_not raise_error
+      end
+    end
+  end
+  
+  context "for multiple specified subdomains" do
+    it "should recognise a route if the subdomain matches" do
+      map_subdomain(:www, :admin, :name => nil) { |map| map.resources :items }
+      lambda { recognize_path(@request) }.should_not raise_error
+    end
+  
+    it "should not recognise a route if the subdomain doesn't match" do
+      map_subdomain(:support, :admin, :name => nil) { |map| map.resources :items }
+      lambda { recognize_path(@request) }.should raise_error(ActionController::RoutingError)
+    end
+  end
+  
+  context "for a :model subdomain" do
+    before(:each) do
+      map_subdomain(:model => :user) { |user| user.resources :articles }
+    end
+    
+    context "when a nested route is requested" do
+      before(:each) do
+        @request.host = "mholling.example.com"
+        @request.request_uri = "/articles"
+      end
+      
+      it "should match the route if there is a subdomain" do
+        lambda { recognize_path(@request) }.should_not raise_error
+      end
+    
+      it "should put the subdomain into the params as :model_id" do
+        recognize_path(@request)[:user_id].should == "mholling"
+      end
+    end
+  end
+end

data/spec/resources_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "resource" do
+  describe "mappings" do
+    it "should pass the specified subdomains to any nested routes" do
+      map_subdomain(:admin) do |admin|
+        admin.resources(:users) { |user| user.options[:subdomains].should == [ "admin" ] }
+        admin.resource(:config) { |config| config.options[:subdomains].should == [ "admin" ] }
+      end
+    end
+  end
+    
+  describe "routes" do
+    before(:each) do
+      map_subdomain(:admin) do |admin|
+        admin.resources :users
+        admin.resource :config
+      end
+    end
+      
+    it "should include the subdomains in the routing conditions" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.conditions[:subdomains].should == [ "admin" ]
+      end
+    end
+    
+    it "should include the subdomains in the routing requirements" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.requirements[:subdomains].should == [ "admin" ]
+      end
+    end
+  end
+end

data/spec/routes_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "ActionController::Routing::Routes" do
+  before(:each) do
+    map_subdomain(:www, nil) { |www| www.root :controller => "homes", :action => "show" }
+  end
+  
+  it "should know a list of its reserved subdomains" do
+    ActionController::Routing::Routes.reserved_subdomains.should == [ "www", "" ]
+    ActionController::Routing::Routes.clear!
+    ActionController::Routing::Routes.reserved_subdomains.should be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'spec'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+require 'active_record' # only required for testing optional features, not required by the gem
+require 'action_mailer' # only required for testing optional features, not required by the gem
+
+require 'subdomain_routes'
+
+require 'action_controller/test_process'
+require 'action_view/test_case'
+require 'test_unit_matcher'
+
+ActiveSupport::OptionMerger.send(:define_method, :options) { @options }
+
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+  end
+  config.include(SubdomainRoutes::TestUnitMatcher)
+end
+
+def map_subdomain(*subdomains, &block)
+  ActionController::Routing::Routes.draw do |map|
+    map.subdomain(*subdomains, &block)
+  end
+end
+
+def recognize_path(request)
+  ActionController::Routing::Routes.recognize_path(request.path, ActionController::Routing::Routes.extract_request_environment(request))
+end
+
+def in_controller_with_host(host, options = {}, &block)
+  spec = self
+  Class.new(ActionView::TestCase::TestController) do
+    include Spec::Matchers
+  end.new.instance_eval do
+    request.host = host
+    request.instance_eval do
+      @env.merge! 'HTTPS' => 'on','SERVER_PORT' => 443 if options[:protocol] =~ /^https(:\/\/)?$/
+      @env.merge! 'SERVER_PORT'=> options[:port] if options[:port]
+    end
+    copy_instance_variables_from(spec)
+    instance_eval(&block)
+  end
+end
+
+def in_object_with_host(host, options = {}, &block)
+  spec = self
+  Class.new do
+    include Spec::Matchers
+    include ActionController::UrlWriter
+  end.new.instance_eval do
+    self.class.default_url_options = { :host => host }
+    self.class.default_url_options.merge! options.slice(:port, :protocol)
+    copy_instance_variables_from(spec)
+    instance_eval(&block)
+  end
+end
+
+def with_host(host, options = {}, &block)
+  in_controller_with_host(host, options.dup, &block)
+  in_object_with_host(host, options.dup, &block)
+end
+
+ActiveRecord::Base.class_eval do
+  alias_method :save, :valid?
+  def self.columns() @columns ||= []; end
+  
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type, null)
+  end
+end

data/spec/test_unit_matcher.rb

@@ -0,0 +1,46 @@
+module SubdomainRoutes
+  module TestUnitMatcher
+    class Base
+      class TestCase < ActionController::TestCase
+      end
+    
+      def initialize(count_method, messages, spec)
+        @count_method, @messages, @spec = count_method, messages, spec
+      end
+      
+      def run_test(target)
+        result = Test::Unit::TestResult.new
+        spec = @spec        
+        TestCase.send :define_method, :test do
+          copy_instance_variables_from(spec)
+          instance_eval(&target)
+        end
+        TestCase.new(:test).run(result) {}
+        result
+      end
+      
+      def matches?(target)
+        @result = run_test(target)
+        @result_count = @result.send(@count_method)
+        @result_count > 0
+      end
+      
+      def failure_message
+        "Expected #{@count_method.to_s.humanize.downcase} to be more than zero, got zero.\n"
+      end
+
+      def negative_failure_message
+        "Expected #{@count_method.to_s.humanize.downcase} to be zero, got #{@result_count}:\n" +
+        @result.instance_variable_get(@messages).map(&:inspect).join("\n")
+      end
+    end
+            
+    def have_errors
+      Base.new(:error_count, :@errors, self)
+    end
+    
+    def fail
+      Base.new(:failure_count, :@failures, self)
+    end
+  end
+end

data/spec/url_writing_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe "URL writing" do
+  { "nil" => nil, "an IP address" => "207.192.69.152" }.each do |host_type, host|
+    context "when the host is #{host_type}" do
+      it "should raise an error when a subdomain route is requested" do
+        map_subdomain(:www) { |www| www.resources :users }
+        with_host(host) do
+          lambda { www_users_path }.should raise_error(SubdomainRoutes::HostNotSupplied) 
+          lambda { url_for(:controller => "users", :action => "index", :subdomains => ["www"]) }.should raise_error(SubdomainRoutes::HostNotSupplied) 
+        end
+      end
+      
+      context "and a non-subdomain route is requested" do
+        before(:each) do
+          ActionController::Routing::Routes.draw { |map| map.resources :users }
+        end
+
+        it "should not raise an error when the route is a path" do
+          with_host(host) do
+            lambda { users_path }.should_not raise_error
+            lambda { url_for(:controller => "users", :action => "index", :only_path => true) }.should_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  [ [ "single", :admin, "admin.example.com" ],
+    [    "nil",    nil,       "example.com" ] ].each do |type, subdomain, host|
+    context "when a #{type} subdomain is specified" do
+      before(:each) do
+        map_subdomain(subdomain, :name => nil) { |map| map.resources :users }
+        @url_options = { :controller => "users", :action => "index", :subdomains => [ subdomain.to_s ] }
+        @path_options = @url_options.merge(:only_path => true)
+      end
+  
+      it "should not change the host for an URL if the host subdomain matches" do
+        with_host(host) do
+          users_url.should == "http://#{host}/users" 
+          url_for(@url_options).should == "http://#{host}/users"
+        end
+      end
+    
+      it "should change the host for an URL if the host subdomain differs" do
+        with_host "other.example.com" do
+          users_url.should == "http://#{host}/users"
+          url_for(@url_options).should == "http://#{host}/users"
+        end
+      end
+
+      it "should not force the host for a path if the host subdomain matches" do
+        with_host(host) do
+          users_path.should == "/users" 
+          url_for(@path_options).should == "/users" 
+        end
+      end
+
+      it "should force the host for a path if the host subdomain differs" do
+        with_host "other.example.com" do
+          users_path.should == "http://#{host}/users"
+          url_for(@path_options).should == "http://#{host}/users"
+        end
+      end
+      
+      [ [ "port",     { :port     => 8080    }, "http://#{host}:8080/users" ],
+        [ "protocol", { :protocol => "https" }, "https://#{host}/users"     ] ].each do |variant, options, url|
+        it "should preserve the #{variant} when forcing the host" do
+          with_host "other.example.com", options do
+            users_path.should == url
+            url_for(@path_options).should == url
+          end
+        end
+      end
+  
+      context "and a subdomain different from the host subdomain is explicitly requested" do
+        it "should change the host if the requested subdomain matches" do
+          with_host "other.example.com" do
+            users_path(:subdomain => subdomain).should == "http://#{host}/users"
+            url_for(@path_options.merge(:subdomain => subdomain)).should == "http://#{host}/users"
+          end
+        end
+    
+        it "should raise a routing error if the requested subdomain doesn't match" do
+          with_host(host) do
+            lambda { users_path(:subdomain => :other) }.should raise_error(ActionController::RoutingError)
+            lambda { url_for(@path_options.merge(:subdomain => :other)) }.should raise_error(ActionController::RoutingError)
+          end
+        end
+      end
+      
+      context "and the current host's subdomain is explicitly requested" do
+        it "should not force the host for a path if the subdomain matches" do
+          with_host(host) do
+            users_path(:subdomain => subdomain).should == "/users" 
+            url_for(@path_options.merge(:subdomain => subdomain)).should == "/users" 
+          end
+        end
+      end
+    end
+  end
+  
+  [ [               "", [ :books, :dvds ], [ "books.example.com", "dvds.example.com" ] ],
+    [ " including nil",     [ nil, :www ], [       "example.com",  "www.example.com" ] ] ].each do |qualifier, subdomains, hosts|
+    context "when multiple subdomains#{qualifier} are specified" do
+      before(:each) do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.resources :items }
+        @url_options = { :controller => "items", :action => "index", :subdomains => subdomains.map(&:to_s) }
+        @path_options = @url_options.merge(:only_path => true)
+      end
+          
+      it "should not change the host for an URL if the host subdomain matches" do
+        hosts.each do |host|
+          with_host(host) do
+           items_url.should == "http://#{host}/items" 
+           url_for(@url_options).should == "http://#{host}/items" 
+          end
+        end
+      end
+  
+      it "should not force the host for a path if the host subdomain matches" do
+        hosts.each do |host|
+          with_host(host) do
+            items_path.should == "/items" 
+            url_for(@path_options).should == "/items" 
+          end
+        end
+      end
+  
+      it "should raise a routing error if the host subdomain doesn't match" do
+        with_host "other.example.com" do
+          lambda {  item_url }.should raise_error(ActionController::RoutingError)
+          lambda { item_path }.should raise_error(ActionController::RoutingError)
+          lambda {  url_for(@url_options) }.should raise_error(ActionController::RoutingError)
+          lambda { url_for(@path_options) }.should raise_error(ActionController::RoutingError)
+        end
+      end
+    
+      context "and a subdomain different from the host subdomain is explicitly requested" do
+        it "should change the host if the requested subdomain matches" do
+          [ [ subdomains.first, hosts.first, hosts.last ],
+            [ subdomains.last, hosts.last, hosts.first ] ].each do |subdomain, new_host, old_host|
+            with_host(old_host) do
+              items_path(:subdomain => subdomain).should == "http://#{new_host}/items"
+              url_for(@path_options.merge(:subdomain => subdomain)).should == "http://#{new_host}/items"
+            end
+          end
+        end
+
+        it "should preserve the port when changing the host" do
+          [ [ subdomains.first, hosts.first, hosts.last ],
+            [ subdomains.last, hosts.last, hosts.first ] ].each do |subdomain, new_host, old_host|
+            with_host(old_host, :port => 8080) do
+              items_path(:subdomain => subdomain).should == "http://#{new_host}:8080/items"
+              url_for(@path_options.merge(:subdomain => subdomain)).should == "http://#{new_host}:8080/items"
+            end
+          end
+        end
+
+        it "should preserve the protocol when changing the host" do
+          [ [ subdomains.first, hosts.first, hosts.last ],
+            [ subdomains.last, hosts.last, hosts.first ] ].each do |subdomain, new_host, old_host|
+            with_host(old_host, :protocol => "https") do
+              items_path(:subdomain => subdomain).should == "https://#{new_host}/items"
+              url_for(@path_options.merge(:subdomain => subdomain)).should == "https://#{new_host}/items"
+            end
+          end
+        end
+          
+        it "should raise a routing error if the requested subdomain doesn't match" do
+          [ [ hosts.first, hosts.last ],
+            [ hosts.last, hosts.first ] ].each do |new_host, old_host|
+            with_host(old_host) do
+              lambda { items_path(:subdomain => :other) }.should raise_error(ActionController::RoutingError)
+              lambda { url_for(@path_options.merge(:subdomain => :other)) }.should raise_error(ActionController::RoutingError)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  it "should downcase a supplied subdomain" do
+    map_subdomain(:www1, :www2, :name => nil) { |map| map.resources :users }
+    [ [ :Www1, "www1" ], [ "Www2", "www2" ] ].each do |mixedcase, lowercase|
+      with_host "www.example.com" do
+        users_url(:subdomain => mixedcase).should == "http://#{lowercase}.example.com/users"
+        url_for(:controller => "users", :action => "index", :subdomains => [ "www1", "www2" ], :subdomain => mixedcase).should == "http://#{lowercase}.example.com/users"
+      end
+    end
+  end
+
+  context "when a :model subdomain is specified" do          
+    before(:each) do
+      map_subdomain(:model => :city) { |city| city.resources :events }
+      class City < ActiveRecord::Base; end
+      @boston = City.new
+      @boston.stub!(:new_record?).and_return(false)
+      @boston.stub!(:to_param).and_return("boston")
+      @url_options = { :controller => "city/events", :action => "index", :subdomains => :city_id, :city_id => @boston }
+      @path_options = @url_options.merge(:only_path => true)
+    end
+
+    it "should not change the host if the object has the same to_param as the current subdomain" do
+      with_host "boston.example.com" do
+         city_events_url(@boston).should == "http://boston.example.com/events"
+        city_events_path(@boston).should == "/events"
+            url_for(@url_options).should == "http://boston.example.com/events"
+           url_for(@path_options).should == "/events"
+      end
+    end
+    
+    it "should force the host if the object has a different to_param from the current subdomain" do
+      with_host "example.com" do
+         city_events_url(@boston).should == "http://boston.example.com/events"
+        city_events_path(@boston).should == "http://boston.example.com/events"
+            url_for(@url_options).should == "http://boston.example.com/events"
+           url_for(@path_options).should == "http://boston.example.com/events"
+      end
+    end
+    
+    [ [ "port",     { :port     => 8080    }, "http://boston.example.com:8080/events" ],
+      [ "protocol", { :protocol => "https" }, "https://boston.example.com/events"     ] ].each do |variant, options, url|
+      it "should preserve the #{variant} when forcing the host" do
+        with_host "example.com", options do
+           city_events_url(@boston).should == url
+          city_events_path(@boston).should == url
+              url_for(@url_options).should == url
+             url_for(@path_options).should == url
+        end
+      end
+    end
+  
+    it "should raise an error if the object to_param is an invalid subdomain" do
+      @newyork = City.new
+      @newyork.stub!(:new_record?).and_return(false)
+      @newyork.stub!(:to_param).and_return("new york")
+      with_host "www.example.com" do
+        lambda {  city_events_url(@newyork) }.should raise_error(ActionController::RoutingError)
+        lambda { city_events_path(@newyork) }.should raise_error(ActionController::RoutingError)
+        lambda {  url_for(@url_options.merge(:city_id => @newyork)) }.should raise_error(ActionController::RoutingError)
+        lambda { url_for(@path_options.merge(:city_id => @newyork)) }.should raise_error(ActionController::RoutingError)
+      end
+    end
+      
+    it "should not allow the subdomain to be manually overridden in a named route" do
+      with_host "www.example.com" do
+         city_events_url(@boston, :subdomain => :canberra).should == "http://boston.example.com/events"
+        city_events_path(@boston, :subdomain => :canberra).should == "http://boston.example.com/events"
+      end
+    end
+    
+    it "should raise a routing error if no subdomain object is supplied to the named route" do
+      with_host "www.example.com" do
+        [ lambda { city_events_url }, lambda { city_event_url("id") } ].each do |lamb|
+          lamb.should raise_error(ActionController::RoutingError) { |e| e.message.should include(":city_id") }
+        end
+      end
+    end
+  end
+end