domain and subdomain ownership wiring

app/controllers/domains_controller.rb

@@ -31,7 +31,7 @@ class DomainsController < ApplicationController
     
   def before_create_save(record)
     record.type = 'NATIVE'
-    record.user = current_user
+    record.user = record.parent_domain.present? ? record.parent_domain.user : current_user
   end
 
   def after_create_save(record)

app/models/domain.rb

@@ -56,6 +56,7 @@ class Domain < ActiveRecord::Base
   end
   
   def parent_domain
+    return nil if name.nil?
     @parent_domain ||= {}
     @parent_domain[name] ||= begin
       segments = name.split('.')

spec/controllers/domains_controller_spec.rb

@@ -1,144 +1,178 @@
 require 'spec_helper'
 
 describe DomainsController do
-  it_should_behave_like "wiring controller"
-end
   
-# TODO implement me
+  context "wiring" do
-__END__
+    include_context "data"
     
-  # This should return the minimal set of attributes required to create a valid
+    # a domain who's parent domain is not in our system
-  # Domain. As you add validations to Domain, be sure to
+    context "domain" do
-  # update the return value of this method accordingly.
+      before do
-  def valid_attributes
+        sign_in user
-    {}
+      end
-  end
 
-  describe "GET index" do
+      it "is wired with the current user by #new_model" do
-    it "assigns all domains as @domains" do
+        @controller.send(:new_model).user.should == user
-      domain = Domain.create! valid_attributes
+      end
-      get :index
+    
-      assigns(:domains).should eq([domain])
+      it "is wired with the current user by #before_create_save" do
+        domain = build(:domain)
+        @controller.send(:before_create_save, domain)
+        domain.user.should == user
+      end
     end
-  end
     
-  describe "GET show" do
+    # a domain who's parent domain is in our system
-    it "assigns the requested domain as @domain" do
+    context "subdomain" do
-      domain = Domain.create! valid_attributes
+      before do
-      get :show, :id => domain.id.to_s
+        sign_in other_user
-      assigns(:domain).should eq(domain)
+      end
+      
+      it "is wired with the user of the parent domain by #before_create_save" do
+        subdomain = build(:domain, :user => other_user, :name => "x.#{domain.name}")
+        @controller.send(:before_create_save, subdomain)
+        subdomain.user.should == user
+      end
     end
+    
   end
+end
 
-  describe "GET new" do
+# TODO implement me
-    it "assigns a new domain as @domain" do
+__END__
-      get :new
+  
-      assigns(:domain).should be_a_new(Domain)
+# This should return the minimal set of attributes required to create a valid
-    end
+# Domain. As you add validations to Domain, be sure to
+# update the return value of this method accordingly.
+def valid_attributes
+  {}
+end
+
+describe "GET index" do
+  it "assigns all domains as @domains" do
+    domain = Domain.create! valid_attributes
+    get :index
+    assigns(:domains).should eq([domain])
   end
+end
 
-  describe "GET edit" do
+describe "GET show" do
-    it "assigns the requested domain as @domain" do
+  it "assigns the requested domain as @domain" do
-      domain = Domain.create! valid_attributes
+    domain = Domain.create! valid_attributes
-      get :edit, :id => domain.id.to_s
+    get :show, :id => domain.id.to_s
-      assigns(:domain).should eq(domain)
+    assigns(:domain).should eq(domain)
-    end
   end
+end
 
-  describe "POST create" do
+describe "GET new" do
-    describe "with valid params" do
+  it "assigns a new domain as @domain" do
-      it "creates a new Domain" do
+    get :new
-        expect {
+    assigns(:domain).should be_a_new(Domain)
-          post :create, :domain => valid_attributes
+  end
-        }.to change(Domain, :count).by(1)
+end
-      end
 
-      it "assigns a newly created domain as @domain" do
+describe "GET edit" do
-        post :create, :domain => valid_attributes
+  it "assigns the requested domain as @domain" do
-        assigns(:domain).should be_a(Domain)
+    domain = Domain.create! valid_attributes
-        assigns(:domain).should be_persisted
+    get :edit, :id => domain.id.to_s
-      end
+    assigns(:domain).should eq(domain)
+  end
+end
 
-      it "redirects to the created domain" do
+describe "POST create" do
+  describe "with valid params" do
+    it "creates a new Domain" do
+      expect {
         post :create, :domain => valid_attributes
-        response.should redirect_to(Domain.last)
+      }.to change(Domain, :count).by(1)
-      end
     end
 
-    describe "with invalid params" do
+    it "assigns a newly created domain as @domain" do
-      it "assigns a newly created but unsaved domain as @domain" do
+      post :create, :domain => valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
+      assigns(:domain).should be_a(Domain)
-        Domain.any_instance.stub(:save).and_return(false)
+      assigns(:domain).should be_persisted
-        post :create, :domain => {}
+    end
-        assigns(:domain).should be_a_new(Domain)
-      end
 
-      it "re-renders the 'new' template" do
+    it "redirects to the created domain" do
-        # Trigger the behavior that occurs when invalid params are submitted
+      post :create, :domain => valid_attributes
-        Domain.any_instance.stub(:save).and_return(false)
+      response.should redirect_to(Domain.last)
-        post :create, :domain => {}
-        response.should render_template("new")
-      end
     end
   end
 
-  describe "PUT update" do
+  describe "with invalid params" do
-    describe "with valid params" do
+    it "assigns a newly created but unsaved domain as @domain" do
-      it "updates the requested domain" do
+      # Trigger the behavior that occurs when invalid params are submitted
-        domain = Domain.create! valid_attributes
+      Domain.any_instance.stub(:save).and_return(false)
-        # Assuming there are no other domains in the database, this
+      post :create, :domain => {}
-        # specifies that the Domain created on the previous line
+      assigns(:domain).should be_a_new(Domain)
-        # receives the :update_attributes message with whatever params are
+    end
-        # submitted in the request.
-        Domain.any_instance.should_receive(:update_attributes).with({'these' => 'params'})
-        put :update, :id => domain.id, :domain => {'these' => 'params'}
-      end
 
-      it "assigns the requested domain as @domain" do
+    it "re-renders the 'new' template" do
-        domain = Domain.create! valid_attributes
+      # Trigger the behavior that occurs when invalid params are submitted
-        put :update, :id => domain.id, :domain => valid_attributes
+      Domain.any_instance.stub(:save).and_return(false)
-        assigns(:domain).should eq(domain)
+      post :create, :domain => {}
-      end
+      response.should render_template("new")
+    end
+  end
+end
 
-      it "redirects to the domain" do
+describe "PUT update" do
-        domain = Domain.create! valid_attributes
+  describe "with valid params" do
-        put :update, :id => domain.id, :domain => valid_attributes
+    it "updates the requested domain" do
-        response.should redirect_to(domain)
+      domain = Domain.create! valid_attributes
-      end
+      # Assuming there are no other domains in the database, this
+      # specifies that the Domain created on the previous line
+      # receives the :update_attributes message with whatever params are
+      # submitted in the request.
+      Domain.any_instance.should_receive(:update_attributes).with({'these' => 'params'})
+      put :update, :id => domain.id, :domain => {'these' => 'params'}
     end
 
-    describe "with invalid params" do
+    it "assigns the requested domain as @domain" do
-      it "assigns the domain as @domain" do
+      domain = Domain.create! valid_attributes
-        domain = Domain.create! valid_attributes
+      put :update, :id => domain.id, :domain => valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
+      assigns(:domain).should eq(domain)
-        Domain.any_instance.stub(:save).and_return(false)
+    end
-        put :update, :id => domain.id.to_s, :domain => {}
-        assigns(:domain).should eq(domain)
-      end
 
-      it "re-renders the 'edit' template" do
+    it "redirects to the domain" do
-        domain = Domain.create! valid_attributes
+      domain = Domain.create! valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
+      put :update, :id => domain.id, :domain => valid_attributes
-        Domain.any_instance.stub(:save).and_return(false)
+      response.should redirect_to(domain)
-        put :update, :id => domain.id.to_s, :domain => {}
-        response.should render_template("edit")
-      end
     end
   end
 
-  describe "DELETE destroy" do
+  describe "with invalid params" do
-    it "destroys the requested domain" do
+    it "assigns the domain as @domain" do
       domain = Domain.create! valid_attributes
-      expect {
+      # Trigger the behavior that occurs when invalid params are submitted
-        delete :destroy, :id => domain.id.to_s
+      Domain.any_instance.stub(:save).and_return(false)
-      }.to change(Domain, :count).by(-1)
+      put :update, :id => domain.id.to_s, :domain => {}
+      assigns(:domain).should eq(domain)
     end
 
-    it "redirects to the domains list" do
+    it "re-renders the 'edit' template" do
       domain = Domain.create! valid_attributes
-      delete :destroy, :id => domain.id.to_s
+      # Trigger the behavior that occurs when invalid params are submitted
-      response.should redirect_to(domains_url)
+      Domain.any_instance.stub(:save).and_return(false)
+      put :update, :id => domain.id.to_s, :domain => {}
+      response.should render_template("edit")
     end
   end
+end
+
+describe "DELETE destroy" do
+  it "destroys the requested domain" do
+    domain = Domain.create! valid_attributes
+    expect {
+      delete :destroy, :id => domain.id.to_s
+    }.to change(Domain, :count).by(-1)
+  end
+
+  it "redirects to the domains list" do
+    domain = Domain.create! valid_attributes
+    delete :destroy, :id => domain.id.to_s
+    response.should redirect_to(domains_url)
+  end
+end
 
 end