radiantcms-couchrest_model 0.1.3 → 0.1.4

data/rerun.txt

@@ -0,0 +1 @@
+

data/spec/controllers/admin/export_controller_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Admin::ExportController do
+  dataset :users_and_pages
+  
+  before :each do
+    login_as :designer
+  end
+  
+  it "should export a YAML file" do
+    get :yaml
+    response.should be_success
+    response.content_type.should == "text/yaml"
+    YAML.load(response.body).should be_kind_of(Hash)
+  end
+end

data/spec/controllers/admin/pages_controller_spec.rb

@@ -134,9 +134,8 @@ describe Admin::PagesController do
 
         it "should allow access to #{user.to_s.humanize}s for the #{action} action" do
           login_as user
-          controller.should_receive(:paginated?).and_return(false)
           send method, action, :id => Page.first.id
-          response.should redirect_to('http://test.host/admin/pages')
+          response.should redirect_to('/admin/pages')
         end
       end
     end
@@ -205,41 +204,13 @@ describe Admin::PagesController do
     end
   end
 
-  describe '#new' do
-    it "should initialize meta and buttons_partials in new action" do
-      get :new, :page_id => page_id(:home)
-      response.should be_success
-      assigns(:meta).should be_kind_of(Array)
-      assigns(:buttons_partials).should be_kind_of(Array)
-    end
-  
-    it "should set the parent_id from the parameters" do
-      get :new, :page_id => page_id(:home)
-      assigns(:page).parent_id.should == page_id(:home)
-    end
-  
-    it "should set the @page variable" do
-      home = pages(:home)
-      new_page = home.class.new_with_defaults
-      new_page.parent_id = home.id
-      Page.stub!(:new_with_defaults).and_return(new_page)
-      get :new, :page_id => home.id
-      assigns(:page).should == new_page
-    end
+  it "should initialize meta and buttons_partials in new action" do
+    get :new, :page_id => page_id(:home)
+    response.should be_success
+    assigns(:meta).should be_kind_of(Array)
+    assigns(:buttons_partials).should be_kind_of(Array)
   end
 
-  describe '#update' do
-    it 'should update the page updated_at on every update' do
-      start_updated_at = pages(:home).updated_at
-      put :update, :id => page_id(:home), :page => {:breadcrumb => 'Homepage'} and sleep(1)
-      next_updated_at = pages(:home).updated_at
-      lambda{ start_updated_at <=> next_updated_at }.should be_true
-      put :update, :id => page_id(:home), :page => {:breadcrumb => 'Homepage'} and sleep(1)
-      final_updated_at = pages(:home).updated_at
-      lambda{ next_updated_at <=> final_updated_at }.should be_true
-    end
-  end
-  
   it "should initialize meta and buttons_partials in edit action" do
     get :edit, :id => page_id(:home)
     response.should be_success

data/spec/controllers/admin/preferences_controller_spec.rb

@@ -17,7 +17,7 @@ describe Admin::PreferencesController do
     login_as :non_admin
     put :update, :user => { :password => '', :password_confirmation => '', :email => 'updated@gmail.com' }
     user = users(:non_admin)
-    response.should redirect_to(admin_configuration_path)
+    response.should redirect_to(admin_preferences_path)
     user.email.should == 'updated@gmail.com'
   end
 

data/spec/datasets/config_dataset.rb

@@ -6,7 +6,6 @@ class ConfigDataset < Dataset::Base
     Radiant::Config['defaults.page.parts'] = 'body, extended'
     Radiant::Config['defaults.page.status'] = 'draft'
     Radiant::Config['defaults.page.filter'] = nil
-    Radiant::Config['defaults.page.fields'] = 'keywords, description'
     Radiant::Config['session_timeout'] = 2.weeks
   end
 end

data/spec/datasets/home_page_dataset.rb

@@ -1,7 +1,9 @@
 class HomePageDataset < Dataset::Base
   
   def load
-    create_page "Home", :slug => "/", :parent_id => nil do
+    create_page "Home", :slug => "/", :parent_id => nil, 
+                        :description => "The homepage", 
+                        :keywords => "Home, Page" do
       create_page_part "body", :content => "Hello world!"
       create_page_part "sidebar", :content => "<r:title /> sidebar."
       create_page_part "extended", :content => "Just a test."

data/spec/datasets/pages_dataset.rb

@@ -21,7 +21,7 @@ class PagesDataset < Dataset::Base
       create_page "Child 3"
     end
     create_page "Childless"
-    create_page "Assorted" do
+    create_page "Assorted", :keywords => "sweet & harmonious biscuits", :description => "sweet & harmonious biscuits" do
       breadcrumbs = %w(f e d c b a j i h g)
       %w(a b c d e f g h i j).each_with_index do |name, i|
         create_page name, :breadcrumb => breadcrumbs[i], :published_at => Time.now - (10 - i).minutes

data/spec/fixtures/radiant_config.yml

@@ -3,8 +3,8 @@
  defaults.page.parts: body, extended
  test: passes
  admin.title: RadiantCMS
- defaults.page.status: Draft
+ defaults.page.status: draft
  admin.subtitle: Publishing for Small Teams
  this: that
  defaults.page.filter: ""
- true?: true
+ true?: true

data/spec/generators/extension_generator_spec.rb

@@ -28,7 +28,7 @@ describe "ExtensionGenerator with normal options" do
   
   it "should generate extension init file" do
     'vendor/extensions/sample'.should have_generated_class('sample_extension', 'Radiant::Extension') do |body|
-      body.should match(/version RadiantSampleExtension::VERSION\n\s+description "Adds sample to Radiant."\n\s+url "http:\/\/github.com\/extauthor\/radiant-sample-extension"/)
+      body.should match(/version "1.0"\n\s+description "Describe your extension here"\n\s+url "http:\/\/github.com\/extauthor\/radiant-sample-extension"/)
       body.should match(/extension_config do \|config\|((\n|\s*.*\n)*)\s+\# end/)
       body.should have_method('activate')
     end
@@ -43,35 +43,15 @@ describe "ExtensionGenerator with normal options" do
     end
   end
 
-  it "should populate radiant-sample-extension.gemspec with gem info" do
-    'vendor/extensions/sample'.should have_generated_file('radiant-sample-extension.gemspec') do |body|
-      body.should match(%r(s.name        = "radiant-sample-extension"))
-      body.should match(%r(s.email       = \["ext@radiantcms.org"\]))
-      body.should match(%r(s.homepage    = "http://github.com/extauthor/radiant-sample-extension"))
-      body.should match(%r(s.authors     = \["Ext Author"\]))
-    end
-  end
-  
-  it "should populate radiant-sample-extension.rb with module namespace" do
-    'vendor/extensions/sample'.should have_generated_file('lib/radiant-sample-extension.rb') do |body|
-      body.should match(%r(module RadiantSampleExtension))
-    end
-  end
-  
-  it "should populate version.rb with the version" do
-    'vendor/extensions/sample'.should have_generated_file('lib/radiant-sample-extension/version.rb') do |body|
-      body.should match(%r(VERSION = '1.0.0'))
+  it "should populate Rakefile with gem info" do
+    'vendor/extensions/sample'.should have_generated_file('Rakefile') do |body|
+      body.should match(%r(gem.name = "radiant-sample-extension"))
+      body.should match(%r(gem.email = "ext@radiantcms.org"))
+      body.should match(%r(gem.homepage = "http://github.com/extauthor/radiant-sample-extension"))
+      body.should match(%r(gem.authors = \["Ext Author"\]))
     end
   end
 
-  it "should generate extension lib directory" do
-    'vendor/extensions/sample'.should have_generated_directory('lib')
-  end
-
-  it "should generate extension radiant-sample-extension directory" do
-    'vendor/extensions/sample'.should have_generated_directory('lib/radiant-sample-extension')
-  end
-
   it "should generate extension controllers directory" do
     'vendor/extensions/sample'.should have_generated_directory('app/controllers')
   end
@@ -171,7 +151,7 @@ describe "ExtensionGenerator with test-unit option" do
   
   it "should generate extension init file" do
     'vendor/extensions/sample'.should have_generated_class('sample_extension', 'Radiant::Extension') do |body|
-      body.should match(/version RadiantSampleExtension::VERSION\n\s+description "Adds sample to Radiant."\n\s+url "http:\/\/yourwebsite.com\/sample"/)
+      body.should match(/version "1.0"\n\s+description "Describe your extension here"\n\s+url "http:\/\/yourwebsite.com\/sample"/)
       body.should have_method('activate')
     end
   end

data/spec/generators/instance_generator_spec.rb

@@ -73,26 +73,19 @@ share_as :AllInstanceGenerators do
   end
   
   # Check for admin javascripts
-  %w(application.js controls.js dragdrop.js lowpro.js popup.js pagefield.js ruledtable.js sitemap.js
-    tabcontrol.js codearea.js cookie.js effects.js prototype.js shortcuts.js status.js utility.js).each do |file|
+  %w(application.js controls.js dragdrop.js lowpro.js popup.js ruledtable.js sitemap.js tabcontrol.js
+    codearea.js cookie.js effects.js prototype.js shortcuts.js status.js utility.js).each do |file|
     it "should have a #{file} admin image" do
       'public/javascripts/admin'.should have_generated_file(file)
     end
   end
 
   # Check for initializers
-  # initializers are now run from RADIANT_ROOT before the instance, 
-  # so most of those are should no longer be copied across
-  %w(radiant_config.rb).each do |file|
+  %w(haml.rb).each do |file|
     it "should have a #{file} initializer" do
       'config/initializers'.should have_generated_file(file)
     end
   end
-  %w(haml.rb compass.rb).each do |file|
-    it "should not have a #{file} initializer" do
-      'config/initializers'.should_not have_generated_file(file)
-    end
-  end 
 end
 
 describe "IntanceGenerator" do

data/spec/helpers/admin/node_helper_spec.rb

@@ -8,7 +8,6 @@ describe Admin::NodeHelper do
     helper.stub!(:cookies).and_return(@cookies)
     helper.stub!(:homepage).and_return(nil)
     @page = mock_model(Page)
-    @page.stub!(:sheet?).and_return(false) # core extension alters the behavior
   end
 
   it "should render a sitemap node" do

data/spec/helpers/admin/references_helper_spec.rb

@@ -1,10 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Admin::ReferencesHelper do
-  class CustomFilter < TextFilter
-    filter_name "Really Custom"
-  end
-
   describe "determining the page class" do
     before :each do
       helper.send(:instance_variable_set, :@page_class, nil)
@@ -39,11 +35,6 @@ describe Admin::ReferencesHelper do
       helper.filter.should == TextileFilter
     end
 
-    it "should return the filter object for a custom named filter" do
-      params[:filter_name] = "Really Custom"
-      helper.filter.should == CustomFilter
-    end
-
     it "should return nil when the set filter is blank" do
       params[:filter_name] = ' '
       helper.filter.should be_nil
@@ -121,4 +112,4 @@ describe Admin::ReferencesHelper do
       helper.tag_reference.should == "desc" * count
     end
   end
-end
+end

data/spec/helpers/application_helper_spec.rb

@@ -179,12 +179,7 @@ describe ApplicationHelper do
   it "should provide the admin object" do
     helper.admin.should == Radiant::AdminUI.instance
   end
-
-  it "should return filter options for select" do
-    helper.filter_options_for_select.should =~ %r{<option value=\"\">&lt;none&gt;</option>}
-    helper.filter_options_for_select.should =~ %r{<option value=\"Markdown\">Markdown</option>}
-  end 
-
+  
   it "should include the regions helper" do
     ApplicationHelper.included_modules.should include(Admin::RegionsHelper)
   end
@@ -260,4 +255,4 @@ describe ApplicationHelper do
   #   end
   #   
   # end
-end
+end

data/spec/lib/radiant/admin_ui_spec.rb

@@ -47,15 +47,14 @@ describe Radiant::AdminUI do
     end
     page.edit.main.should == %w{edit_header edit_form edit_popups}
     page.edit.form.should == %w{edit_title edit_extended_metadata
-                                edit_page_parts}
-    page.edit.layout.should == %w{edit_layout edit_type edit_status
-                                  edit_published_at}
+                                edit_page_parts edit_layout_and_type}
     page.edit.parts_bottom.should == %w{}
     page.edit.form_bottom.should == %w{edit_buttons edit_timestamp}
     page.index.sitemap_head.should == %w{title_column_header
                                         status_column_header
-                                        actions_column_header}
-    page.index.node.should == %w{title_column status_column actions_column}
+                                        modify_column_header}
+    page.index.node.should == %w{title_column status_column add_child_column
+                                  remove_column}
     page.remove.should === page.index
     page.children.should === page.index
     page._part.should === page.edit
@@ -70,8 +69,8 @@ describe Radiant::AdminUI do
     snippet.edit.form_bottom.should == %w{edit_buttons edit_timestamp}
     snippet.index.should_not be_nil
     snippet.index.top.should == %w{}
-    snippet.index.thead.should == %w{title_header actions_header}
-    snippet.index.tbody.should == %w{title_cell actions_cell}
+    snippet.index.thead.should == %w{title_header modify_header}
+    snippet.index.tbody.should == %w{title_cell modify_cell}
     snippet.index.bottom.should == %w{new_button}
 
     snippet.new.should == snippet.edit
@@ -86,8 +85,8 @@ describe Radiant::AdminUI do
     layout.edit.form_bottom.should == %w{reference_links edit_buttons edit_timestamp}
     layout.index.should_not be_nil
     layout.index.top.should == %w{}
-    layout.index.thead.should == %w{title_header actions_header}
-    layout.index.tbody.should == %w{title_cell actions_cell}
+    layout.index.thead.should == %w{title_header modify_header}
+    layout.index.tbody.should == %w{title_cell modify_cell}
     layout.index.bottom.should == %w{new_button}
     
     layout.new.should == layout.edit
@@ -101,8 +100,8 @@ describe Radiant::AdminUI do
                                 edit_password edit_roles edit_locale edit_notes}
     user.edit.form_bottom.should == %w{edit_buttons edit_timestamp}
     user.index.should_not be_nil
-    user.index.thead.should == %w{title_header roles_header actions_header}
-    user.index.tbody.should == %w{title_cell roles_cell actions_cell}
+    user.index.thead.should == %w{title_header roles_header modify_header}
+    user.index.tbody.should == %w{title_cell roles_cell modify_cell}
     user.index.bottom.should == %w{new_button}
     user.preferences.main.should == %w{edit_header edit_form}
     user.preferences.form.should == %w{edit_name edit_email edit_username edit_password edit_locale}

data/spec/lib/radiant/extension_spec.rb

@@ -37,7 +37,7 @@ describe Radiant::Extension do
     it { should be_routed }
   end
   context "when the routing_file does not exist" do
-    subject { UnroutedExtension }
+    subject { BasicExtension }
     it { should_not be_routed }
   end
   
@@ -61,13 +61,13 @@ describe Radiant::Extension do
   end
 
   it "should allow the manipulation of tabs" do
-    start_length = BasicExtension.admin.nav['Design'].length
+    BasicExtension.admin.nav['Design'].length.should == 2
     BasicExtension.class_eval {
       tab 'Design' do
         add_item "Pages", "/admin/pages"
       end
     }
-    BasicExtension.admin.nav['Design'].length.should == start_length + 1
+    BasicExtension.admin.nav['Design'].length.should == 3
   end
   
   it "should allow the addition of tabs" do

data/spec/lib/task_support_spec.rb

@@ -20,7 +20,6 @@ describe TaskSupport do
   describe "self.config_import" do
     before do
       @yaml_file = "#{RADIANT_ROOT}/spec/fixtures/radiant_config.yml"
-      @bad_yaml_file = "#{RADIANT_ROOT}/spec/fixtures/invalid_config.yml"
     end
     it "should delete all Radiant::Config when the clear parameter is set to true" do
       Radiant::Config['testing_clear'] = 'true'
@@ -39,11 +38,6 @@ describe TaskSupport do
       TaskSupport.config_import(@yaml_file)
       Radiant::Config.to_hash.should == YAML.load(YAML.load_file(@yaml_file))
     end
-    it "should roll back if an invalid config setting is imported" do
-      Radiant::Config['defaults.page.status'] = "Draft"
-      lambda{TaskSupport.config_import(@bad_yaml_file)}.should_not raise_error
-      Radiant::Config['defaults.page.status'].should == "Draft"
-    end
   end
 
   describe "self.cache_files" do

data/spec/models/env_dump_page_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe EnvDumpPage do
+  before :each do
+    @request = ActionController::TestRequest.new :url => '/env_dump/'
+    @page = EnvDumpPage.new
+    @page.request = @request
+  end
+
+  it "should render the request environment" do
+    @page.render.should =~ %r{=>}
+    @page.render.should =~ %r{^<html><body><pre>}
+  end
+
+  it "should not be cached" do
+    @page.cache?.should be_false
+  end
+end

data/spec/models/file_not_found_page_spec.rb

@@ -4,32 +4,28 @@ describe FileNotFoundPage do
   dataset :file_not_found
   test_helper :render
   
-  let(:file_not_found){ pages(:file_not_found) }
-  
-  its(:allowed_children){ should == [] }
+  before(:each) do
+    @page = pages(:file_not_found)
+  end
   
-  describe '<r:attempted_url>' do
-    it 'should have a working url tag' do
-      @page = file_not_found
-      assert_renders '/gallery/asdf?param=4', '<r:attempted_url />', '/gallery/asdf?param=4'
-    end
+  it 'should have a working url tag' do
+    assert_renders '/gallery/asdf?param=4', '<r:attempted_url />', '/gallery/asdf?param=4'
+  end
 
-    it 'should correctly quote the url' do
-      @page = file_not_found
-      assert_renders '/gallery/&lt;script&gt;alert(&quot;evil&quot;)&lt;/script&gt;', '<r:attempted_url />', '/gallery/<script>alert("evil")</script>'
-    end
+  it 'should correctly quote the url' do
+    assert_renders '/gallery/&lt;script&gt;alert(&quot;evil&quot;)&lt;/script&gt;', '<r:attempted_url />', '/gallery/<script>alert("evil")</script>'
   end
   
   it 'should be a virtual page' do
-    file_not_found.should be_virtual
+    @page.should be_virtual
   end
   
   it 'should not be cached' do
-    file_not_found.should_not be_cache
+    @page.should_not be_cache
   end
   
   it 'should return a 404 status code' do
-    file_not_found.response_code.should == 404
+    @page.response_code.should == 404
   end
   
 end

data/spec/models/page_spec.rb

@@ -23,30 +23,10 @@ end
 describe Page, 'validations' do
   dataset :pages
   test_helper :validations
-  
-  let(:page){ Page.new(page_params)}
 
   before :each do
     @page = @model = Page.new(page_params)
   end
-  
-  it 'should not be valid with a slug length greater than 100 characters' do
-    page.valid?.should be_true
-    page.slug = 'x'*101
-    page.valid?.should be_false
-  end
-  
-  it 'should not be valid with a title length greater than 255 characters' do
-    page.valid?.should be_true
-    page.title = 'x'*256
-    page.valid?.should be_false
-  end
-  
-  it 'should not be valid with a breadcrumb length greater than 160 characters' do
-    page.valid?.should be_true
-    page.breadcrumb = 'x'*161
-    page.valid?.should be_false
-  end
 
   it 'should validate length of' do
     {
@@ -140,195 +120,184 @@ end
 
 describe Page do
   dataset :pages
-  
-  let(:page){ pages(:first ) }
-  let(:home){ pages(:home) }
-  let(:parent){ pages(:parent) }
-  let(:child){ pages(:child) }
-  let(:part){ page.parts(:body) }
-
-  describe '#parts' do
-    it 'should return PageParts with a page_id of the page id' do
-      home.parts.sort_by{|p| p.name }.should == PagePart.find_all_by_page_id(home.id).sort_by{|p| p.name }
-    end
-  end
 
-  it 'should destroy dependant parts' do
-    page.parts.create(page_part_params(:name => 'test'))
-    page.parts.find_by_name('test').should_not be_nil
-    id = page.id
-    page.destroy
-    PagePart.find_by_page_id(id).should be_nil
+  before :each do
+    @page = pages(:first)
   end
-  
-  describe '#part' do
-    it 'should find the part with a name of the given string' do
-      page.part('body').should == page.parts.find_by_name('body')
-    end
-    it 'should find the part with a name of the given symbol' do
-      page.part(:body).should == page.parts.find_by_name('body')
-    end
-    it 'should access unsaved parts by name' do
-      part = PagePart.new(:name => "test")
-      page.parts << part
-      page.part('test').should == part
-      page.part(:test).should == part
-    end
-    it 'should return nil for an invalid part name' do
-      page.part('not-real').should be_nil
-    end
+
+  it 'should have parts' do
+    @page.parts.count.should == 1
+    pages(:home).parts.count.should == 4
   end
 
-  describe '#field' do
-    it "should find a field" do
-      page.fields.create(:name => 'keywords', :content => 'radiant')
-      page.field(:keywords).should == page.fields.find_by_name('keywords')
-    end
+  it 'should destroy dependant parts' do
+    @page.parts.create(page_part_params(:name => 'test', :page_id => nil))
+    @page.parts.find_by_name('test').should be_kind_of(PagePart)
 
-    it "should find an unsaved field" do
-      field = PageField.new(:name => 'description', :content => 'radiant')
-      page.fields << field
-      page.field(:description).should == field
-    end
+    id = @page.id
+    @page.destroy
+    PagePart.find_by_page_id_and_name(id, 'test').should be_nil
   end
-  
-  describe '#has_part?' do
-    it 'should return true for a valid part' do
-      page.has_part?('body').should == true
-      page.has_part?(:body).should == true
-    end
-    it 'should return false for a non-existant part' do
-      page.has_part?('obviously_false_part_name').should == false
-      page.has_part?(:obviously_false_part_name).should == false
-    end
+
+  it 'should allow access to parts by name with a string' do
+    part = @page.part('body')
+    part.name.should == 'body'
   end
-  
-  describe '#inherits_part?' do
-    it 'should return true if any ancestor page has a part of the given name' do
-      child.has_part?(:sidebar).should be_false
-      child.inherits_part?(:sidebar).should be_true
-    end
-    it 'should return false if any ancestor page does not have a part of the given name' do
-      home.has_part?(:sidebar).should be_true
-      home.inherits_part?(:sidebar).should be_false
-    end
+
+  it 'should allow access to parts by name with a symbol' do
+    part = @page.part(:body)
+    part.name.should == 'body'
   end
-  
-  describe '#has_or_inherits_part?' do
-    it 'should return true if the current page or any ancestor has a part of the given name' do
-      child.has_or_inherits_part?(:sidebar).should be_true
-    end
-    it 'should return false if the current part or any ancestor does not have a part of the given name' do
-      child.has_or_inherits_part?(:obviously_false_part_name).should be_false
-    end
+
+  it 'should allow access to parts by name when page is unsaved' do
+    part = PagePart.new(:content => "test", :name => "test")
+    @page.parts << part
+    @page.part('test').should == part
+    @page.part(:test).should == part
+  end
+
+  it 'should allow access to parts by name created with the build method when page is unsaved' do
+    @page.parts.build(:content => "test", :name => "test")
+    @page.part('test').content.should == "test"
+    @page.part(:test).content.should == "test"
   end
 
   it "should accept new page parts as an array of PageParts" do
-    page.parts = [PagePart.new(:name => 'body', :content => 'Hello, world!')]
-    page.parts.size.should == 1
-    page.parts.first.should be_kind_of(PagePart)
-    page.parts.first.name.should == 'body'
-    page.parts.first.content.should == 'Hello, world!'
+    @page.parts = [PagePart.new(:name => 'body', :content => 'Hello, world!')]
+    @page.parts.size.should == 1
+    @page.parts.first.should be_kind_of(PagePart)
+    @page.parts.first.name.should == 'body'
+    @page.parts.first.content.should == 'Hello, world!'
   end
 
   it "should dirty the page object when only changing parts" do
     lambda do
-      page.dirty?.should be_false
-      page.parts = [PagePart.new(:name => 'body', :content => 'Hello, world!')]
-      page.dirty?.should be_true
+      @page.parts = [PagePart.new(:name => 'body', :content => 'Hello, world!')]
+      @page.changed.should_not be_empty
     end
   end
-  
-  describe '#published?' do
-    it "should be true when the status is Status[:published]" do
-      page.status = Status[:published]
-      page.published?.should be_true
-    end
-    it "should be false when the status is not Status[:published]" do
-      page.status = Status[:draft]
-      page.published?.should be_false
-    end
+
+  # invalid, as published_at is set when form is submitted
+
+  it 'should set published_at when published' do
+    @page = Page.new(page_params(:status_id => '1', :published_at => nil))
+    @page.published_at.should be_nil
+
+    @page.status_id = Status[:published].id
+    @page.save
+    @page.published_at.should_not be_nil
+    @page.published_at.utc.day.should == Time.now.utc.day
   end
-  
-  describe '#scheduled?' do
-    it "should be true when the status is Status[:scheduled]" do
-      page.status = Status[:scheduled]
-      page.scheduled?.should be_true
-    end
-    it "should be false when the status is not Status[:scheduled]" do
-      page.status = Status[:published]
-      page.scheduled?.should be_false
-    end
+
+  it 'should not update published_at when already published' do
+    @page = Page.new(page_params(:status_id => Status[:published].id))
+    @page.published_at.should be_kind_of(Time)
+
+    expected = @page.published_at
+    @page.save
+    @page.published_at.should == expected
   end
 
-  context 'when setting the published_at date' do
-    it 'should change its status to scheduled with a date in the future' do
-      new_page = Page.new(page_params(:status_id => '100', :published_at => '2020-1-1'))
-      new_page.save
-      new_page.status_id.should == 90 
-    end
-    it 'should set the status to published when the date is in the past' do
-      scheduled_time = Time.zone.now - 1.year
-      p = Page.new(page_params(:status_id => '90', :published_at => scheduled_time))
-      p.save
-      p.status_id.should == 100
-    end
+  it 'should answer true when published' do
+    @page.status = Status[:published]
+    @page.published?.should == true
+  end
+
+  it 'should answer false when not published' do
+    @page.status = Status[:draft]
+    @page.published?.should be_false
   end
   
-  context 'when setting the status' do  
-    it 'should set published_at when given the published status id' do
-      page = Page.new(page_params(:status_id => '100', :published_at => nil))
-      page.status_id = Status[:published].id
-      page.save
-      page.published_at.utc.day.should == Time.now.utc.day
-    end
-    it 'should change its status to draft when set to draft' do
-      scheduled = pages(:scheduled)
-      scheduled.status_id = '1'
-      scheduled.save
-      scheduled.status_id.should == 1
-    end
-    it 'should not update published_at when already published' do
-      new_page = Page.new(page_params(:status_id => Status[:published].id))
-      expected = new_page.published_at
-      new_page.save
-      new_page.published_at.should == expected
-    end
+  it 'should answer false when not published but scheduled' do
+    @page.status = Status[:scheduled]
+    @page.published?.should be_false
   end
-    
-  describe '#path' do
-    it "should start with a slash" do
-      page.path.should match(/^\//)
-    end
-    it "should return a string with the current page's slug catenated with it's ancestor's slugs and delimited by slashes" do
-      pages(:grandchild).path.should == '/parent/child/grandchild/'
-    end
-    it 'should end with a slash' do
-      page.path.should match(/\/$/)
-    end
+
+  it 'should change its status to scheduled when publishing in the future' do
+    @page = Page.new(page_params(:status_id => '100', :published_at => '2020-1-1'))
+    @page.save
+    @page.status_id.should == 90    
+  end
+
+  it 'should change its status to draft when set to draft' do
+    @page = pages(:scheduled)
+    @page.status_id = Status[:draft].id
+    @page.save
+    @page.status_id.should == 1    
   end
   
-  describe '#child_path' do
-    it 'should return the #path for the given child' do
-      parent.child_path(child).should == '/parent/child/'
-    end
+  it 'should be published status when published_at is in the past' do
+    #current time 01-29-2010
+    scheduled_time = '2010-1-1'
+    @page = Page.new(page_params(:status_id => Status[:scheduled].id, :published_at => scheduled_time))
+    @page.save
+    @page.status_id.should == Status[:published].id
   end
   
-  describe '#status' do
-    it 'should return the Status with the id of the page status_id' do
-      home.status.should == Status.find(home.status_id)
-    end
+  it "should answer the page's url" do
+    @page = pages(:parent)
+    @page.url.should == '/parent/'
+    @page.children.first.url.should == '/parent/child/'
+
+    grandchild = pages(:grandchild)
+    grandchild.url.should == '/parent/child/grandchild/'
   end
 
-  describe '#status=' do
-    it 'should set the status_id to the id of the given Status' do
-      home.status = Status[:draft]
-      home.status_id.should == Status[:draft].id
-    end
+  it 'should allow you to calculate a child url from the parent' do
+    @page = pages(:parent)
+    child = pages(:child)
+    @page.child_url(child).should == '/parent/child/'
+  end
+
+  it 'should have status' do
+    @page = pages(:home)
+    @page.status.should == Status[:published]
+  end
+
+  it 'should allow you to set the status' do
+    @page = pages(:home)
+    draft = Status[:draft]
+    @page.status = draft
+    @page.status.should == draft
+    @page.status_id.should == draft.id
+  end
+
+  it 'should respond to cache? with true (by default)' do
+    @page.cache?.should == true
+  end
+
+  it 'should respond to virtual? with false (by default)' do
+    @page.virtual?.should == false
+  end
+
+  it 'should allow you to tell if a part exists based on a string or symbol' do
+    @page = pages(:home)
+    @page.has_part?(:body).should == true
+    @page.has_part?('sidebar').should == true
+    @page.has_part?(:obviously_false_part_name).should == false
   end
 
-  its(:cache?){ should be_true }
-  its(:virtual?){ should be_false }
+  it 'should allow you to tell if a part is inherited' do
+    @page = pages(:child)
+    @page.has_part?(:sidebar).should == false
+    @page.inherits_part?(:sidebar).should == true
+
+    @page = pages(:home)
+    @page.has_part?(:sidebar).should == true
+    @page.inherits_part?(:sidebar).should == false
+  end
+
+  it 'should allow you to tell if a part exists or is inherited' do
+    @page = pages(:child)
+    @page.has_part?(:sidebar).should == false
+    @page.has_or_inherits_part?(:sidebar).should == true
+    @page.has_or_inherits_part?(:obviously_false_part_name).should == false
+
+    @page = pages(:home)
+    @page.has_part?(:sidebar).should == true
+    @page.has_or_inherits_part?(:sidebar).should == true
+    @page.has_or_inherits_part?(:obviously_false_part_name).should == false
+  end
 
   it 'should support optimistic locking' do
     p1, p2 = Page.find(page_id(:first)), Page.find(page_id(:first))
@@ -362,7 +331,7 @@ describe Page, "before save filter" do
     @page.send(:read_attribute, :virtual).should == true
 
    # turn a virtual page into a non-virtual one
-   ["", nil, "Page", "PageSpecTestPage"].each do |value|
+   ["", nil, "Page", "EnvDumpPage"].each do |value|
       @page = ArchiveYearIndexPage.create(page_params)
       @page.class_name = value
       @page.save.should == true
@@ -425,7 +394,7 @@ describe Page, "rendering" do
   end
 end
 
-describe Page, "#find_by_path" do
+describe Page, "#find_by_url" do
   dataset :pages, :file_not_found
 
   before :each do
@@ -433,44 +402,44 @@ describe Page, "#find_by_path" do
   end
 
   it 'should allow you to find the home page' do
-    @page.find_by_path('/').should == @page
+    @page.find_by_url('/').should == @page
   end
 
   it 'should allow you to find deeply nested pages' do
-    @page.find_by_path('/parent/child/grandchild/great-grandchild/').should == pages(:great_grandchild)
+    @page.find_by_url('/parent/child/grandchild/great-grandchild/').should == pages(:great_grandchild)
   end
 
   it 'should not allow you to find virtual pages' do
-    @page.find_by_path('/virtual/').should == pages(:file_not_found)
+    @page.find_by_url('/virtual/').should == pages(:file_not_found)
   end
 
   it 'should find the FileNotFoundPage when a page does not exist' do
-    @page.find_by_path('/nothing-doing/').should == pages(:file_not_found)
+    @page.find_by_url('/nothing-doing/').should == pages(:file_not_found)
   end
 
   it 'should find a draft FileNotFoundPage in dev mode' do
-    @page.find_by_path('/drafts/no-page-here', false).should == pages(:lonely_draft_file_not_found)
+    @page.find_by_url('/drafts/no-page-here', false).should == pages(:lonely_draft_file_not_found)
   end
 
   it 'should not find a draft FileNotFoundPage in live mode' do
-    @page.find_by_path('/drafts/no-page-here').should_not == pages(:lonely_draft_file_not_found)
+    @page.find_by_url('/drafts/no-page-here').should_not == pages(:lonely_draft_file_not_found)
   end
 
   it 'should find a custom file not found page' do
-    @page.find_by_path('/gallery/nothing-doing').should == pages(:no_picture)
+    @page.find_by_url('/gallery/nothing-doing').should == pages(:no_picture)
   end
 
   it 'should not find draft pages in live mode' do
-    @page.find_by_path('/draft/').should == pages(:file_not_found)
+    @page.find_by_url('/draft/').should == pages(:file_not_found)
   end
 
   it 'should find draft pages in dev mode' do
-    @page.find_by_path('/draft/', false).should == pages(:draft)
+    @page.find_by_url('/draft/', false).should == pages(:draft)
   end
 
   it "should use the top-most published 404 page by default" do
-    @page.find_by_path('/foo').should == pages(:file_not_found)
-    @page.find_by_path('/foo/bar').should == pages(:file_not_found)
+    @page.find_by_url('/foo').should == pages(:file_not_found)
+    @page.find_by_url('/foo/bar').should == pages(:file_not_found)
   end
 end
 
@@ -520,13 +489,6 @@ describe Page, "class" do
     end
   end
 
-  it "should allow initialization with default fields" do
-    @page = Page.new_with_defaults({ 'defaults.page.fields' => 'x, y, z' })
-    @page.fields.size.should == 3
-    @page.fields.first.name.should == 'x'
-    @page.fields.last.name.should == 'z'
-  end
-
   it "should expose default page parts" do
     override = PagePart.new(:name => 'override')
     Page.stub!(:default_page_parts).and_return([override])
@@ -548,11 +510,6 @@ describe Page, "class" do
     Page.is_descendant_class_name?("InvalidPage").should == false
   end
 
-  describe ".date_column_names" do
-    it "should return an array of column names whose sql_type is a date or datetime" do
-      Page.date_column_names.should == Page.columns.collect{|c| c.name if c.sql_type =~ /date/ }.compact
-    end
-  end
 end
 
 describe Page, "loading subclasses before bootstrap" do
@@ -615,26 +572,26 @@ describe Page, "class which is applied to a page but not defined" do
   end
 end
 
-describe Page, "class find_by_path" do
+describe Page, "class find_by_url" do
   dataset :pages, :file_not_found
 
   it 'should find the home page' do
-    Page.find_by_path('/').should == pages(:home)
+    Page.find_by_url('/').should == pages(:home)
   end
 
   it 'should find children' do
-    Page.find_by_path('/parent/child/').should == pages(:child)
+    Page.find_by_url('/parent/child/').should == pages(:child)
   end
 
   it 'should not find draft pages in live mode' do
-    Page.find_by_path('/draft/').should == pages(:file_not_found)
-    Page.find_by_path('/draft/', false).should == pages(:draft)
+    Page.find_by_url('/draft/').should == pages(:file_not_found)
+    Page.find_by_url('/draft/', false).should == pages(:draft)
   end
 
   it 'should raise an exception when root page is missing' do
     pages(:home).destroy
     Page.find_by_parent_id().should be_nil
-    lambda { Page.find_by_path "/" }.should raise_error(Page::MissingRootPageError, 'Database missing root page')
+    lambda { Page.find_by_url "/" }.should raise_error(Page::MissingRootPageError, 'Database missing root page')
   end
 end