mholling-subdomain_routes 0.2.3 → 0.3.0

data/README.textile

@@ -21,6 +21,8 @@ In your Rails app, make sure to specify the gem dependency in environment.rb:
 config.gem "mholling-subdomain_routes", :lib => "subdomain_routes", :source => "http://gems.github.com"
 </pre>
 
+[ *UPDATE:* You can also install the gem as a plugin: <code>script/plugin install git://github.com/mholling/subdomain_routes.git</code> ]
+
 (Note that the SubdomainRoutes gem requires Rails 2.2 or later to run since it changes <code>ActionController::Resources::INHERITABLE_OPTIONS</code>. If you're on an older version of Rails, you need to get with the program. ;)
 
 Finally, you'll probably want to configure your session to work across all your subdomains. You can do this in your environment files:
@@ -33,6 +35,8 @@ config.action_controller.session[:session_domain] = "yourdomain.local" # or what
 config.action_controller.session[:session_domain] = "yourdomain.com" # or whatever
 </pre>
 
+[ *UPDATE*: If you're using your domain without any subdomain, you may need to set the domain to ".yourdomain.com" (with leading period). Also, you may first need to set <code>config.action_controller.session ||= {}</code> in your environment file, in case the session configuration variable has not already been set. ]
+
 h2. Mapping a Single Subdomain
 
 Let's start with a simple example. Say we have a site which offers a support section, where users submit and view support tickets for problems they're having. It'd be nice to have that under a separate subdomain, say _support.mysite.com_. With subdomain routes we'd map that as follows:
@@ -284,5 +288,134 @@ If you're using model-based subdomain routes (covered next), you may want to use
 # Use a "proxy.pac":http://en.wikipedia.org/wiki/Proxy.pac file in your browser so that it proxies _*.reviews.local_ to localhost. How to do this will depend on the browser you're using.
 # Set up a local DNS server with an A record for the domain. This may be a bit involved.
 
+h2. Testing with Subdomain Routes
+
+Testing routes and controllers with the SubdomainRoutes gem may require a little extra work. Here's a simple <code>routes.rb</code> as an example:
+
+<pre>
+map.subdomain :admin do |admin|
+  admin.resources :users
+end
+
+map.subdomain :model => :city do |city|
+  city.resources :reviews, :only => [ :index, :show ]
+end
+</pre>
+
+(This connects a fixed _admin_ subdomain to a <code>Admin::UsersController</code>, and a model-based _city_ subdomain to a <code>City::ReviewsController</code>.)
+
+h2. Testing Controllers
+
+A simple test for the <code>Admin::UsersController#show</code> action would go along these lines:
+
+<pre>
+class Admin::UsersControllerTest < ActionController::TestCase
+  test "show action" do
+    get :show, :id => "1", :subdomains => [ "admin" ]
+    assert_response :success # or whatever
+  end
+end
+</pre>
+
+Notice the <code>:subdomains => [ "admin" ]</code> in the hash passed to the <code>get</code> method. This is the additional requirement for testing controller actions which lie under a subdomain route. Your tests won't work without it. The same applies for <code>post</code>, <code>put</code> and <code>delete</code>.
+
+(For testing the model-based subdomain routes, <code>:subdomains => :city_id</code> and <code>:city_id => "..."</code> would be added to the route's options hash. Check the specs for more examples, if you need them.)
+
+It's a little bit ugly (and not too DRY) to have to list the subdomains for the route in the test. Want to change the actual subdomains you are using? You'll have to change your tests as well. But that's the way it goes. (One way to avoid this brittleness, at least, would be to assign the subdomains to a constant and use the constant in your routes and tests.)
+
+It's easy to figure out what <code>:subdomain</code> option you should pass. Just look it up in your routes by typing <code>rake routes</code> at the console:
+
+<pre>
+    admin_users GET    /users(.:format)          {:action=>"index", :subdomains=>["admin"], :controller=>"admin/users"}
+                POST   /users(.:format)          {:action=>"create", :subdomains=>["admin"], :controller=>"admin/users"}
+ new_admin_user GET    /users/new(.:format)      {:action=>"new", :subdomains=>["admin"], :controller=>"admin/users"}
+edit_admin_user GET    /users/:id/edit(.:format) {:action=>"edit", :subdomains=>["admin"], :controller=>"admin/users"}
+     admin_user GET    /users/:id(.:format)      {:action=>"show", :subdomains=>["admin"], :controller=>"admin/users"}
+                PUT    /users/:id(.:format)      {:action=>"update", :subdomains=>["admin"], :controller=>"admin/users"}
+                DELETE /users/:id(.:format)      {:action=>"destroy", :subdomains=>["admin"], :controller=>"admin/users"}
+   city_reviews GET    /reviews(.:format)        {:action=>"index", :subdomains=>:city_id, :controller=>"city/reviews"}
+    city_review GET    /reviews/:id(.:format)    {:action=>"show", :subdomains=>:city_id, :controller=>"city/reviews"}
+</pre>
+
+The <code>:subdomain</code> option you need to use is listed right there in the right-most column of each route.
+
+h2. Testing Subdomain Routes
+
+An underlying assumption in the Rails routing code is that the _path_ is all that's needed to specify an URL, since the host is assumed to be fixed and irrelevant. In some parts of the routing assertions code, this assumption is fairly tightly entangled in the code. Obviously, for subdomain routes, it's an invalid assumption.
+
+Augmenting Rails' <code>assert_generates</code> and <code>assert_recognizes</code> methods to allow for a changeable host is not really a practical or sensible option. Instead, SubdomainRoutes adds some new assertions specifically for testing subdomain routes.
+
+h3. Testing Recognition
+
+The signature for Rails' traditional <code>assert_recognizes</code> method looks like this:
+
+<pre>
+def assert_recognizes(expected_options, path, extras={}, message=nil)
+</pre>
+
+The <code>expected_options</code> path is options hash describing the route that should be recognised (always including <code>:controller</code> and <code>:action</code>, as well as any other parameters that the route might produce). The <code>path</code> can either be a string representing the path, or a hash with <code>:path</code> and <code>:method</code> values (if you need to specify an HTTP method other than GET).
+
+For <code>assert_recognizes_with_host</code> the same arguments are kept, since the <code>:host</code> can be passed as another option in the <code>path</code> hash. The <code>:host</code> option represents what host should be set in the <code>TestRequest</code> that's used to recognise the path. (Unlike traditional routes, the subdomain, and hence the host, is required for recognition of the route.)
+
+So a typical passing recognition test for the user index route would be:
+
+<pre>
+test "admin_users route recognition" do
+  assert_recognizes_with_host(
+    { :controller => "admin/users", :action => "index", :subdomains => [ "admin" ] },
+    { :path => "/users", :host => "admin.example.com" })
+end
+</pre>
+
+Notice the correct subdomain for this route is specified in the host. Note also the annoying <code>:subdomains</code> value in the first options hash. It needs to be there as well, to specify the route.
+
+h3. Testing Generation
+
+Testing route generation is a little more involved. The Rails assertion is as follows:
+
+<pre>
+def assert_generates(expected_path, options, defaults={}, extras={}, message=nil)
+</pre>
+
+This method asserts that <code>expected_path</code> (a string) is the path generated by the route <code>options</code>. But with subdomain routes, the generated route may also depend on the current host - if the subdomain for the route is different than the current host, the host will be forced to the new subdomain.
+
+To allow testing of this behaviour, the <code>assert_generates_with_host</code> method is introduced. This assertion allows you to specify the current host, as well as the host that the new route should have (if different):
+
+<pre>
+def assert_generates_with_host(expected_path, options, host, defaults={}, extras={}, message=nil)
+</pre>
+
+Notice the additional third argument, <code>host</code>, which you should set to the current host (i.e. the host under which the route is being generated).
+
+Now to test an example route. First, test the case where the host doesn't change:
+
+<pre>
+test "admin_users route generation for the same subdomain" do
+  assert_generates_with_host(
+    "/users",
+    { :controller => "admin/users", :action => "index", :subdomains => [ "admin" ] },
+    "admin.example.com")
+end
+</pre>
+
+The assertion in this test is saying that, for _admin.example.com_, the index route should generate <code>"/users"</code> as the path, and not change the host. The test passes as this is expected behaviour.
+
+The second test case covers the case of generating the route from a host with a different subdomain:
+
+<pre>
+test "admin_users route generation for a different subdomain" do
+  assert_generates_with_host(
+    { :path => "/users", :host => "admin.example.com" },
+    { :controller => "admin/users", :action => "index", :subdomains => [ "admin" ] },
+    "www.example.com")
+end
+</pre>
+
+Here the usage diverges from <code>assert_generates</code>: instead of passing a string as the expected path, a hash is passed. As with <code>assert_recognizes</code>, the hash is used to specify both the <code>:path</code> and the <code>:host</code> that the route should generate. The above test passes because the route changes the subdomain from _www_ to _admin_. (This only occurs in a single-subdomain route, of course.)
+
+h3. Use with RSpec
+
+The subdomain routing assertions won't help you much if you're using RSpec or some other testing framework. Your best bet is to wrap each assertion up in its own class, just as RSpec does with <code>assert_recognizes</code>  in its <code>route_for</code> method (check the rspec-rails source code). This shouldn't be too hard to do.
+
 
 Copyright (c) 2009 Matthew Hollingworth. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 3
+:patch: 0
 :major: 0
-:minor: 2
+:minor: 3

data/lib/subdomain_routes.rb

@@ -10,3 +10,4 @@ require 'subdomain_routes/resources'
 require 'subdomain_routes/url_writer'
 require 'subdomain_routes/request'
 require 'subdomain_routes/validations'
+require 'subdomain_routes/assertions'

data/lib/subdomain_routes/assertions.rb

@@ -0,0 +1,68 @@
+module SubdomainRoutes
+  module RoutingAssertions        
+    include SubdomainRoutes::RewriteSubdomainOptions
+
+    def assert_recognizes_with_host(expected_options, path, extras={}, message=nil)
+      # copied from Rails source, with modification to set the the supplied host on the request
+      if path.is_a? Hash
+        request_method = path[:method]
+        host           = path[:host]
+        path           = path[:path]
+      else
+        request_method = nil
+        host = nil
+      end
+      clean_backtrace do
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        request = recognized_request_for_with_host(path, host, request_method)
+        
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
+
+        expected_options.stringify_keys!
+        routing_diff = expected_options.diff(request.path_parameters)
+        
+        msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
+            request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
+        assert_block(msg) { request.path_parameters == expected_options }
+      end
+    end
+
+    def assert_generates_with_host(expected_path, options, host, defaults={}, extras = {}, message=nil)
+      if expected_path.is_a? Hash
+        expected_host = expected_path[:host]
+        expected_path = expected_path[:path]
+      else
+        expected_host = nil
+      end
+      rewrite_subdomain_options(options, host)
+      if options.delete(:only_path) == false
+        generated_host = options.delete(:host)
+        msg = expected_host ? 
+          build_message(message, "The route for <?> changed the host to <?> but this did not match expected host <?>", options, generated_host, expected_host) :
+          build_message(message, "The route for <?> changed the host to <?> but the host was not expected to change", options, generated_host)
+        assert_block(msg) { expected_host == generated_host }
+      else
+        msg = build_message(message, "The route for <?> was expected to change the host to <?> but did not change the host", options, expected_host)
+        assert_block(msg) { expected_host == nil }
+      end
+      assert_generates(expected_path, options, defaults, extras, message)
+    end
+
+    private
+
+    def recognized_request_for_with_host(path, host, request_method = nil)
+      path = "/#{path}" unless path.first == '/'
+
+      # Assume given controller
+      request = ActionController::TestRequest.new
+      request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
+      request.path = path
+      request.host = host if host
+      ActionController::Routing::Routes.recognize(request)
+      request
+    end
+  end
+end
+
+ActionController::Assertions::RoutingAssertions.send :include, SubdomainRoutes::RoutingAssertions

data/lib/subdomain_routes/mapper.rb

@@ -3,14 +3,15 @@ module SubdomainRoutes
     module RouteSet
       module Mapper
         def subdomain(*subdomains, &block)
-          options = subdomains.extract_options!
+          options = subdomains.extract_options!.dup
           if subdomains.empty?
             if model = options.delete(:model)
               raise ArgumentError, "Invalid model name" if model.blank?
               models = model.to_s.downcase.pluralize
               model = models.singularize
               model_id = model.foreign_key.to_sym
-              subdomain_options = { :subdomains => model_id, :name_prefix => "#{model}_", :namespace => "#{model}/" }
+              subdomain_options = { :subdomains => model_id }
+              name = options.has_key?(:name) ? options.delete(:name) : model
             else
               raise ArgumentError, "Please specify at least one subdomain!"
             end
@@ -27,9 +28,9 @@ module SubdomainRoutes
             subdomain_options = { :subdomains => subdomains }
             name = subdomains.reject(&:blank?).first
             name = options.delete(:name) if options.has_key?(:name)
-            name = name.to_s.downcase.gsub(/[^(a-z0-9)]/, ' ').squeeze(' ').strip.gsub(' ', '_') unless name.blank?
-            subdomain_options.merge! :name_prefix => "#{name}_", :namespace => "#{name}/" unless name.blank?
           end
+          name = name.to_s.downcase.gsub(/[^(a-z0-9)]/, ' ').squeeze(' ').strip.gsub(' ', '_') unless name.blank?
+          subdomain_options.merge! :name_prefix => "#{name}_", :namespace => "#{name}/" unless name.blank?
           with_options(subdomain_options.merge(options), &block)
         end
         alias_method :subdomains, :subdomain

data/lib/subdomain_routes/routes.rb

@@ -43,18 +43,18 @@ module SubdomainRoutes
   
     module Route
       def self.included(base)
-        [ :recognition_conditions, :generation_extraction, :segment_keys, :recognition_extraction ].each { |method| base.alias_method_chain method, :subdomains }
+        [ :recognition_conditions, :generation_extraction, :segment_keys, :significant_keys, :recognition_extraction ].each { |method| base.alias_method_chain method, :subdomains }
       end
       
       def recognition_conditions_with_subdomains
-        result = recognition_conditions_without_subdomains
-        case conditions[:subdomains]
-        when Array
-          result << "conditions[:subdomains].include?(env[:subdomain])"
-        when Symbol
-          result << "(subdomain = env[:subdomain] unless env[:subdomain].blank?)"
+        returning recognition_conditions_without_subdomains do |result|
+          case conditions[:subdomains]
+          when Array
+            result << "conditions[:subdomains].include?(env[:subdomain])"
+          when Symbol
+            result << "(subdomain = env[:subdomain] unless env[:subdomain].blank?)"
+          end
         end
-        result
       end
       
       def generation_extraction_with_subdomains
@@ -66,15 +66,24 @@ module SubdomainRoutes
       end
                   
       def segment_keys_with_subdomains
-        result = segment_keys_without_subdomains
-        result.unshift(conditions[:subdomains]) if conditions[:subdomains].is_a? Symbol
-        result
+        returning segment_keys_without_subdomains do |result|
+          result.unshift(conditions[:subdomains]) if conditions[:subdomains].is_a? Symbol
+        end
+      end
+      
+      def significant_keys_with_subdomains
+        returning significant_keys_without_subdomains do |result|
+          if conditions[:subdomains].is_a? Symbol
+            result << conditions[:subdomains]
+            result.uniq!
+          end
+        end
       end
       
       def recognition_extraction_with_subdomains
-        result = recognition_extraction_without_subdomains
-        result.unshift "\nparams[#{conditions[:subdomains].inspect}] = subdomain\n" if conditions[:subdomains].is_a? Symbol
-        result
+        returning recognition_extraction_without_subdomains do |result|
+          result.unshift "\nparams[#{conditions[:subdomains].inspect}] = subdomain\n" if conditions[:subdomains].is_a? Symbol
+        end
       end
       
       def reserved_subdomains

data/spec/assertions_spec.rb

@@ -0,0 +1,193 @@
+require 'test/unit/testresult'
+require 'spec_helper'
+
+class HomesController < ActionController::Base
+end
+
+describe "routing assertions" do
+  context "for single-subdomain route" do
+    before(:each) do
+      map_subdomain :admin, :name => nil do |admin|
+        admin.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => [ "admin" ] }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "admin.example.com" }) }
+        test.should_not have_errors
+        test.should_not fail
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "www.example.com" } ) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain and no subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options, "www.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the wrong subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options.merge(:subdomain => "other"), "www.example.com") }
+        test.should have_errors
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the correct subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options.merge(:subdomain => "admin"), "www.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options, "admin.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+      
+      it "should correctly succeed with a path and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "admin.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+    
+      it "should correctly fail with a path and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "www.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+    end
+  end
+
+  context "for multiple-subdomain route" do
+    before(:each) do
+      @subdomains = [ "admin", "support" ]
+      map_subdomain *(@subdomains + [ { :name => nil } ]) do |media|
+        media.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => @subdomains }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "#{subdomain}.example.com" }) }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "www.example.com" } ) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and no subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options, "www.example.com") }
+          test.should have_errors
+        end
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the wrong subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options.merge(:subdomain => "other"), "www.example.com") }
+          test.should have_errors
+        end
+      end
+      
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain and a correct subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options.merge(:subdomain => subdomain), "www.example.com") }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options, "#{subdomain}.example.com") }
+          test.should_not have_errors
+          test.should fail
+        end
+      end
+      
+      it "should correctly succeed with a path and a subdomain route which doesn't change the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host("/home", @options, "#{subdomain}.example.com") }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+    
+      it "should correctly fail with a path and a subdomain route which changes the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host("/home", @options.merge(:subdomain => subdomain), "www.example.com") }
+          test.should_not have_errors
+          test.should fail
+        end
+      end
+    end
+  end
+
+  context "for model-based subdomain route" do
+    before(:each) do
+      map_subdomain :model => :city, :namespace => nil do |city|
+        city.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => :city_id, :city_id => "canberra" }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "canberra.example.com" }) }
+        test.should_not have_errors
+        test.should_not fail
+      end
+
+      it "should correctly fail with a :host option and a subdomain route for the wrong subdomain" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "boston.example.com" }) }
+        test.should_not have_errors
+        test.should fail
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route for no subdomain" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "example.com" }) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "canberra.example.com" }, @options, "boston.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "canberra.example.com" }, @options, "canberra.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+      
+      it "should correctly succeed with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "canberra.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+          
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "www.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+    end
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe "subdomain route mapping" do
+  it "should check the validity of each subdomain" do
+    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, true)
+    lambda { map_subdomain(:www, :www1) { } }.should_not raise_error
+  end
+  
+  it "should check the validity of each subdomain and raise an error if any are invalid" do
+    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, false)
+    lambda { map_subdomain(:www, :www!) { } }.should raise_error(ArgumentError)
+  end
+  
+  it "should check not the validity of a nil subdomain" do
+    SubdomainRoutes.should_not_receive(:valid_subdomain?)
+    map_subdomain(nil) { }
+  end
+  
+  it "should accept a nil subdomain" do
+    map_subdomain(nil) { |map| map.options[:subdomains].should == [ "" ] }
+  end
+
+  it "should accept a blank subdomain" do
+    map_subdomain("") { |map| map.options[:subdomains].should == [ "" ] }
+  end
+
+  it "should accept a single specified subdomain" do
+    map_subdomain(:admin) { |admin| admin.options[:subdomains].should == [ "admin" ] }
+  end
+  
+  it "should accept strings or symbols as subdomains" do
+    map_subdomain(:admin)  { |admin| admin.options[:subdomains].should == [ "admin" ] }
+    map_subdomain("admin") { |admin| admin.options[:subdomains].should == [ "admin" ] }
+  end
+
+  it "should accept multiple subdomains" do
+    map_subdomain(:admin, :support) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+
+  it "should downcase the subdomains" do
+    map_subdomain(:Admin, "SUPPORT") { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+
+  it "should raise ArgumentError if a nil :model option is specified as the subdomain" do
+    lambda { map_subdomain(:model => "") { } }.should raise_error(ArgumentError)
+  end
+
+  it "should raise ArgumentError if no subdomain is specified" do
+    lambda { map_subdomain }.should raise_error(ArgumentError)
+  end
+  
+  it "should not include repeated subdomains in the options" do
+    map_subdomain(:admin, :support, :admin) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+  
+  it "should be invoked by map.subdomains as well as map.subdomain" do
+    ActionController::Routing::Routes.draw do |map|
+      map.subdomains(:admin, :support) { |sub| sub.options[:subdomains].should == [ "admin", "support" ] }
+    end
+  end
+  
+  [ [ :admin ], [ :support, :admin ] ].each do |subdomains|
+    context "mapping #{subdomains.size} subdomains" do
+      it "should set the first subdomain as a namespace" do
+        map_subdomain(*subdomains) { |map| map.options[:namespace].should == "#{subdomains.first}/" }
+      end
+
+      it "should prefix the first subdomain to named routes" do
+        map_subdomain(*subdomains) { |map| map.options[:name_prefix].should == "#{subdomains.first}_" }
+      end
+      
+      it "should instead set a namespace to the name if specified" do
+        args = subdomains + [ :name => :something ]
+        map_subdomain(*args) { |map| map.options[:namespace].should == "something/" }
+      end
+
+      it "should instead prefix the name to named routes if specified" do
+        args = subdomains + [ :name => :something ]
+        map_subdomain(*args) { |map| map.options[:name_prefix].should == "something_" }
+      end
+
+      it "should not set a namespace if name is specified as nil" do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.options[:namespace].should be_nil }
+      end
+
+      it "should not set a named route prefix if name is specified as nil" do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.options[:name_prefix].should be_nil }
+      end
+    end
+  end
+  
+  it "should strip bad characters from the namespace and name prefix" do
+    map_subdomain("just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain("just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
+    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
+    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:name_prefix].should == "just_do_it_" }
+  end
+  
+  context "mapping the nil subdomain" do
+    it "should not set a namespace" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none) { |map| map.options[:namespace].should be_nil }
+      end
+    end
+
+    it "should not set a named route prefix" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none) { |map| map.options[:name_prefix].should be_nil }
+      end
+    end
+  end
+  
+  context "mapping nil and other subdomains" do
+    it "should set the first non-nil subdomain as a namespace" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none, :www) { |map| map.options[:namespace].should == "www/" }
+      end
+    end
+
+    it "should prefix the first non-nil subdomain to named routes" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none, :www) { |map| map.options[:name_prefix].should == "www_" }
+      end
+    end
+  end
+        
+  context "for a :model subdomain" do
+    it "should accept a :model option as the subdomain and turn it into a foreign key symbol" do
+      map_subdomain(:model => :city) { |city| city.options[:subdomains].should == :city_id }
+    end
+
+    it "should singularize a plural model name" do
+      map_subdomain(:model => :cities) { |city| city.options[:subdomains].should == :city_id }
+    end
+    
+    it "should accept a string model name" do
+      map_subdomain(:model => "city") { |city| city.options[:subdomains].should == :city_id }
+    end
+    
+    it "should set the model name as a namespace" do
+      map_subdomain(:model => :city) { |city| city.options[:namespace].should == "city/" }
+    end
+  
+    it "should prefix the model name to named routes" do
+      map_subdomain(:model => :city) { |city| city.options[:name_prefix].should == "city_" }
+    end
+    
+    it "should instead set a namespace to the name if specified" do
+      map_subdomain(:model => :city, :name => :something) { |map| map.options[:namespace].should == "something/" }
+    end
+
+    it "should instead prefix the name to named routes if specified" do
+      map_subdomain(:model => :city, :name => :something) { |map| map.options[:name_prefix].should == "something_" }
+    end
+
+    it "should not set a namespace if name is specified as nil" do
+      map_subdomain(:model => :city, :name => nil) { |map| map.options[:namespace].should be_nil }
+    end
+
+    it "should not set a named route prefix if name is specified as nil" do
+      map_subdomain(:model => :city, :name => nil) { |map| map.options[:name_prefix].should be_nil }
+    end
+  end
+end

data/spec/routes_spec.rb

@@ -1,156 +1,5 @@
 require 'spec_helper'
 
-describe "subdomain routes" do
-  it "should check the validity of each subdomain" do
-    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, true)
-    lambda { map_subdomain(:www, :www1) { } }.should_not raise_error
-  end
-  
-  it "should check the validity of each subdomain and raise an error if any are invalid" do
-    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, false)
-    lambda { map_subdomain(:www, :www!) { } }.should raise_error(ArgumentError)
-  end
-  
-  it "should check not the validity of a nil subdomain" do
-    SubdomainRoutes.should_not_receive(:valid_subdomain?)
-    map_subdomain(nil) { }
-  end
-  
-  it "should accept a nil subdomain" do
-    map_subdomain(nil) { |map| map.options[:subdomains].should == [ "" ] }
-  end
-
-  it "should accept a blank subdomain" do
-    map_subdomain("") { |map| map.options[:subdomains].should == [ "" ] }
-  end
-
-  it "should accept a single specified subdomain" do
-    map_subdomain(:admin) { |admin| admin.options[:subdomains].should == [ "admin" ] }
-  end
-  
-  it "should accept strings or symbols as subdomains" do
-    map_subdomain(:admin)  { |admin| admin.options[:subdomains].should == [ "admin" ] }
-    map_subdomain("admin") { |admin| admin.options[:subdomains].should == [ "admin" ] }
-  end
-
-  it "should accept multiple subdomains" do
-    map_subdomain(:admin, :support) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
-  end
-
-  it "should downcase the subdomains" do
-    map_subdomain(:Admin, "SUPPORT") { |map| map.options[:subdomains].should == [ "admin", "support" ] }
-  end
-
-  it "should raise ArgumentError if a nil :model option is specified as the subdomain" do
-    lambda { map_subdomain(:model => "") { } }.should raise_error(ArgumentError)
-  end
-
-  it "should raise ArgumentError if no subdomain is specified" do
-    lambda { map_subdomain }.should raise_error(ArgumentError)
-  end
-  
-  it "should not include repeated subdomains in the options" do
-    map_subdomain(:admin, :support, :admin) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
-  end
-  
-  it "should be invoked by map.subdomains as well as map.subdomain" do
-    ActionController::Routing::Routes.draw do |map|
-      map.subdomains(:admin, :support) { |sub| sub.options[:subdomains].should == [ "admin", "support" ] }
-    end
-  end
-  
-  [ [ :admin ], [ :support, :admin ] ].each do |subdomains|
-    context "mapping #{subdomains.size} subdomains" do
-      it "should set the first subdomain as a namespace" do
-        map_subdomain(*subdomains) { |map| map.options[:namespace].should == "#{subdomains.first}/" }
-      end
-
-      it "should prefix the first subdomain to named routes" do
-        map_subdomain(*subdomains) { |map| map.options[:name_prefix].should == "#{subdomains.first}_" }
-      end
-      
-      it "should instead set a namespace to the name if specified" do
-        args = subdomains + [ :name => :something ]
-        map_subdomain(*args) { |map| map.options[:namespace].should == "something/" }
-      end
-
-      it "should instead prefix the name to named routes if specified" do
-        args = subdomains + [ :name => :something ]
-        map_subdomain(*args) { |map| map.options[:name_prefix].should == "something_" }
-      end
-
-      it "should not set a namespace if name is specified as nil" do
-        args = subdomains + [ :name => nil ]
-        map_subdomain(*args) { |map| map.options[:namespace].should be_nil }
-      end
-
-      it "should not set a named route prefix if name is specified as nil" do
-        args = subdomains + [ :name => nil ]
-        map_subdomain(*args) { |map| map.options[:name_prefix].should be_nil }
-      end
-    end
-  end
-  
-  it "should strip bad characters from the namespace and name prefix" do
-    map_subdomain("just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
-    map_subdomain("just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
-    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
-    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
-    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:namespace].should == "just_do_it/" }
-    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:name_prefix].should == "just_do_it_" }
-  end
-  
-  context "mapping the nil subdomain" do
-    it "should not set a namespace" do
-      [ nil, "" ].each do |none|
-        map_subdomain(none) { |map| map.options[:namespace].should be_nil }
-      end
-    end
-
-    it "should not set a named route prefix" do
-      [ nil, "" ].each do |none|
-        map_subdomain(none) { |map| map.options[:name_prefix].should be_nil }
-      end
-    end
-  end
-  
-  context "mapping nil and other subdomains" do
-    it "should set the first non-nil subdomain as a namespace" do
-      [ nil, "" ].each do |none|
-        map_subdomain(none, :www) { |map| map.options[:namespace].should == "www/" }
-      end
-    end
-
-    it "should prefix the first non-nil subdomain to named routes" do
-      [ nil, "" ].each do |none|
-        map_subdomain(none, :www) { |map| map.options[:name_prefix].should == "www_" }
-      end
-    end
-  end
-        
-  context "for a :model subdomain" do
-    it "should accept a :model option as the subdomain and turn it into a foreign key symbol" do
-      map_subdomain(:model => :city) { |city| city.options[:subdomains].should == :city_id }
-    end
-
-    it "should singularize a plural model name" do
-      map_subdomain(:model => :cities) { |city| city.options[:subdomains].should == :city_id }
-    end
-    
-    it "should accept a string model name" do
-      map_subdomain(:model => "city") { |city| city.options[:subdomains].should == :city_id }
-    end
-    
-    it "should set the model name as a namespace" do
-      map_subdomain(:model => :city) { |city| city.options[:namespace].should == "city/" }
-    end
-  
-    it "should prefix the model name to named routes" do
-      map_subdomain(:model => :city) { |city| city.options[:name_prefix].should == "city_" }
-    end
-  end
-end
-
 describe "ActionController::Routing::Routes" do
   before(:each) do
     map_subdomain(:www, nil) { |www| www.root :controller => "homes", :action => "show" }

data/spec/spec_helper.rb

@@ -9,18 +9,21 @@ require 'action_mailer' # only required for testing optional features, not requi
 
 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
 
-require 'action_controller/test_process'
-require 'action_view/test_case'
-
-ActiveSupport::OptionMerger.send(:define_method, :options) { @options }
-
 def map_subdomain(*subdomains, &block)
   ActionController::Routing::Routes.draw do |map|
     map.subdomain(*subdomains, &block)
@@ -32,28 +35,24 @@ def recognize_path(request)
 end
 
 def in_controller_with_host(host, &block)
-  variables = instance_variables.inject([]) do |array, name|
-    array << [ name, instance_variable_get(name) ]
-  end
+  spec = self
   Class.new(ActionView::TestCase::TestController) do
     include Spec::Matchers
   end.new.instance_eval do
     request.host = host
-    variables.each { |name, value| instance_variable_set(name, value) }
+    copy_instance_variables_from(spec)
     instance_eval(&block)
   end
 end
 
 def in_object_with_host(host, &block)
-  variables = instance_variables.inject([]) do |array, name|
-    array << [ name, instance_variable_get(name) ]
-  end
+  spec = self
   Class.new do
     include Spec::Matchers
     include ActionController::UrlWriter
   end.new.instance_eval do
     self.class.default_url_options = { :host => host }
-    variables.each { |name, value| instance_variable_set(name, value) }
+    copy_instance_variables_from(spec)
     instance_eval(&block)
   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

@@ -212,7 +212,7 @@ describe "URL writing" do
     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" }
+          lamb.should raise_error(ActionController::RoutingError) { |e| e.message.should include(":city_id") }
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mholling-subdomain_routes
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - Matthew Hollingworth
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-28 00:00:00 -07:00
+date: 2009-08-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,7 @@ files:
 - Rakefile
 - VERSION.yml
 - lib/subdomain_routes.rb
+- lib/subdomain_routes/assertions.rb
 - lib/subdomain_routes/config.rb
 - lib/subdomain_routes/mapper.rb
 - lib/subdomain_routes/request.rb
@@ -46,11 +47,14 @@ files:
 - lib/subdomain_routes/url_writer.rb
 - lib/subdomain_routes/validations.rb
 - rails/init.rb
+- spec/assertions_spec.rb
 - spec/extraction_spec.rb
+- spec/mapping_spec.rb
 - spec/recognition_spec.rb
 - spec/resources_spec.rb
 - spec/routes_spec.rb
 - spec/spec_helper.rb
+- spec/test_unit_matcher.rb
 - spec/url_writing_spec.rb
 - spec/validations_spec.rb
 has_rdoc: false
@@ -81,10 +85,13 @@ signing_key:
 specification_version: 2
 summary: A Rails library for incorporating subdomains into route generation and recognition.
 test_files: 
+- spec/assertions_spec.rb
 - spec/extraction_spec.rb
+- spec/mapping_spec.rb
 - spec/recognition_spec.rb
 - spec/resources_spec.rb
 - spec/routes_spec.rb
 - spec/spec_helper.rb
+- spec/test_unit_matcher.rb
 - spec/url_writing_spec.rb
 - spec/validations_spec.rb