radiant 0.6.7 → 0.6.8

data/spec/lib/radiant/extension/script_spec.rb

@@ -0,0 +1,349 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+require 'radiant/extension/script'
+
+describe "Radiant::Extension::Script" do
+  it "should determine which subscript to run" do
+    Radiant::Extension::Script::Install.should_receive(:new)
+    Radiant::Extension::Script.execute ['install']
+
+    Radiant::Extension::Script::Uninstall.should_receive(:new)
+    Radiant::Extension::Script.execute ['uninstall']
+  end
+
+  it "should pass the command-line args to the subscript" do
+    Radiant::Extension::Script::Install.should_receive(:new).with(['page_attachments'])
+    Radiant::Extension::Script.execute ['install', 'page_attachments']
+  end
+end
+
+describe "Radiant::Extension::Script::Util" do
+  include Radiant::Extension::Script::Util
+
+  it "should determine an extension name from a camelized string" do
+    to_extension_name("PageAttachments").should == 'page_attachments'
+  end
+
+  it "should determine an extension name from a hyphened name" do
+    to_extension_name("page-attachments").should == 'page_attachments'
+  end
+
+  it "should determine an extension name from an underscored name" do
+    to_extension_name("page_attachments").should == 'page_attachments'
+  end
+
+  it "should determine extension paths" do
+    # Bad coupling, but will work by default
+    extension_paths.should be_kind_of(Array)
+    extension_paths.should include("#{RADIANT_ROOT}/vendor/extensions/archive")
+  end
+
+  it "should determine whether an extension is installed" do
+    # Bad coupling, but will work by default
+    self.extension_name = 'archive'
+    self.should be_installed
+  end
+
+  it "should load all extensions from the web service" do
+    Registry::Extension.should_receive(:find).with(:all).and_return([1,2,3])
+    load_extensions.should == [1,2,3]
+  end
+
+  it "should find an extension of the given name from the web service" do
+    @ext_mock = mock("Extension", :name => 'page_attachments')
+    should_receive(:load_extensions).and_return([@ext_mock])
+    self.extension_name = 'page_attachments'
+    find_extension.should == @ext_mock
+  end
+end
+
+describe "Radiant::Extension::Script::Install" do
+
+  before :each do
+    @extension = mock('Extension', :install => true, :name => 'page_attachments')
+    Registry::Extension.stub!(:find).and_return([@extension])
+  end
+
+  it "should read the extension name from the command line" do
+    @install = Radiant::Extension::Script::Install.new ['page_attachments']
+    @install.extension_name.should == 'page_attachments'
+  end
+
+  it "should attempt to find the extension and install it" do
+    @extension.should_receive(:install).and_return(true)
+    @install = Radiant::Extension::Script::Install.new ['page_attachments']
+  end
+
+  it "should fail if an extension name is not given" do
+    lambda { Radiant::Extension::Script::Install.new []}.should raise_error
+  end
+end
+
+describe "Radiant::Extension::Script::Uninstall" do
+
+  before :each do
+    @extension = mock('Extension', :uninstall => true, :name => 'archive')
+    Registry::Extension.stub!(:find).and_return([@extension])
+  end
+
+  it "should read the extension name from the command line" do
+    @uninstall = Radiant::Extension::Script::Uninstall.new ['archive']
+    @uninstall.extension_name.should == 'archive'
+  end
+
+  it "should attempt to find the extension and uninstall it" do
+    @extension.should_receive(:uninstall).and_return(true)
+    @uninstall = Radiant::Extension::Script::Uninstall.new ['archive']
+  end
+
+  it "should fail if an extension name is not given" do
+    lambda { Radiant::Extension::Script::Uninstall.new []}.should raise_error
+  end
+end
+
+describe "Registry::Action" do
+  before :each do
+    @action = Registry::Action.new
+  end
+
+  it "should shell out with the specified rake task" do
+    @action.should_receive(:`).with("rake sample RAILS_ENV=#{RAILS_ENV}")
+    @action.rake('sample')
+  end
+end
+
+describe "Registry::Installer" do
+  before :each do
+    @installer = Registry::Installer.new('http://localhost/', 'example')
+  end
+
+  it "should set the name and url of the extension" do
+    @installer.url.should == 'http://localhost/'
+    @installer.name.should == 'example'
+  end
+
+  it "should install by copying, migrating and updating" do
+    @installer.should_receive(:copy_to_vendor_extensions)
+    @installer.should_receive(:migrate)
+    @installer.should_receive(:update)
+    @installer.install
+  end
+
+  it "should copy the extension to vendor/extensions" do
+    @installer.path = "/tmp"
+    FileUtils.should_receive(:cp_r).with('/tmp', "#{RAILS_ROOT}/vendor/extensions/example")
+    FileUtils.should_receive(:rm_r).with('/tmp')
+    @installer.copy_to_vendor_extensions
+  end
+
+  it "should run the rake migrate task" do
+    @installer.should_receive(:rake).with('radiant:extensions:example:migrate')
+    @installer.migrate
+  end
+
+  it "should run the rake update task" do
+    @installer.should_receive(:rake).with('radiant:extensions:example:update')
+    @installer.update
+  end
+end
+
+describe "Registry::Uninstaller" do
+  before :each do
+    @extension = mock('Extension', :name => 'example')
+    @uninstaller = Registry::Uninstaller.new(@extension)
+  end
+
+  it "should migrate down" do
+    @uninstaller.should_receive(:rake).with("radiant:extensions:example:migrate VERSION=0")
+    @uninstaller.migrate_down
+  end
+
+  it "should remove the extension directory" do
+    FileUtils.should_receive(:rm_r).with("#{RAILS_ROOT}/vendor/extensions/example")
+    @uninstaller.remove_extension_directory
+  end
+
+  it "should uninstall by migrating down and removing the directory" do
+    @uninstaller.should_receive(:migrate_down)
+    @uninstaller.should_receive(:remove_extension_directory)
+    @uninstaller.uninstall
+  end
+end
+
+describe "Registry::Checkout" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :repository_url => 'http://localhost/')
+    @checkout = Registry::Checkout.new(@extension)
+    @methods = [:copy_to_vendor_extensions, :migrate, :update].each do |method|
+      @checkout.stub!(method).and_return(true)
+    end
+  end
+
+  it "should set the name and url" do
+    @checkout.name.should == 'example'
+    @checkout.url.should == 'http://localhost/'
+  end
+
+  it "should defer the checkout command to concrete subclasses" do
+    lambda { @checkout.checkout_command }.should raise_error
+  end
+
+  it "should install by checking out the source and then proceeding with the normal installation" do
+    @methods.each { |method|  @checkout.should_receive(method) }
+    @checkout.should_receive(:checkout)
+    @checkout.install
+  end
+
+  it "should checkout the source" do
+    @checkout.stub!(:checkout_command).and_return('echo')
+    @checkout.should_receive(:system).with(/^cd (.*); echo/)
+    @checkout.checkout
+    @checkout.path.should_not be_nil
+    @checkout.path.should =~ /example/
+  end
+end
+
+describe "Registry::Download" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example.pkg')
+    @download = Registry::Download.new(@extension)
+    @methods = [:copy_to_vendor_extensions, :migrate, :update].each do |method|
+      @download.stub!(method).and_return(true)
+    end
+  end
+
+  it "should set the name and url" do
+    @download.name.should == 'example'
+    @download.url.should == 'http://localhost/example.pkg'
+  end
+
+  it "should defer the unpack command to concrete subclasses" do
+    lambda { @download.unpack }.should raise_error
+  end
+
+  it "should install by downloading and unpacking and then proceeding with the normal installation" do
+    @methods.each { |method|  @download.should_receive(method) }
+    @download.should_receive(:download)
+    @download.should_receive(:unpack)
+    @download.install
+  end
+
+  it "should determine the filename" do
+    @download.filename.should == 'example.pkg'
+  end
+
+  it "should download the file" do
+    @file = mock('file')
+    File.should_receive(:open).with(/example\.pkg/, 'w').and_yield(@file)
+    @download.should_receive(:open).and_return(StringIO.new('test'))
+    @file.should_receive(:write).with('test')
+    @download.download
+  end
+end
+
+describe "Registry::Git" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :repository_url => 'http://localhost/')
+    @git = Registry::Git.new(@extension)
+  end
+
+  it "should use git to clone the repository" do
+    @git.checkout_command.should == 'git clone http://localhost/ example'
+  end
+end
+
+describe "Registry::Subversion" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :repository_url => 'http://localhost/')
+    @svn = Registry::Subversion.new(@extension)
+  end
+
+  it "should use svn to checkout the repository" do
+    @svn.checkout_command.should == 'svn checkout http://localhost/ example'
+  end
+end
+
+describe "Registry::Gem" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example-1.0.0.gem')
+    @gem = Registry::Gem.new(@extension)
+  end
+
+  it "should download the gem and install it if it is not already installed" do
+    @gem.should_receive(:gem).and_raise(::Gem::LoadError.new)
+    @file = mock('file')
+    File.should_receive(:open).with(/example-1.0.0\.gem/, 'w').and_yield(@file)
+    @gem.should_receive(:open).and_return(StringIO.new('test'))
+    @file.should_receive(:write).with('test')
+    @gem.should_receive(:`).with("gem install example-1.0.0.gem")
+    @gem.download
+  end
+
+  it "should not download the gem if it is already installed" do
+    @gem.should_receive(:gem).and_return(true)
+    File.should_not_receive(:open)
+    @gem.should_not_receive(:open)
+    @gem.should_not_receive(:`)
+    @gem.download
+  end
+
+  it "should unpack the gem and capture the path" do
+    @gem.should_receive(:`).with(/gem unpack example/).and_return("Unpacked gem: '/tmp/example-1.0.0'")
+    @gem.unpack
+    @gem.path.should == '/tmp/example-1.0.0'
+  end
+end
+
+describe "Registry::Tarball" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example-1.0.0.tar')
+    @tar = Registry::Tarball.new(@extension)
+  end
+
+  it "should unpack the tarball without compression" do
+    @tar.should_receive(:`).with(/tar xvf example.tar/).and_return('example-1.0.0/example_extension.rb\n')
+    @tar.unpack
+    @tar.path.should =~ /example-1\.0\.0$/
+  end
+end
+
+describe "Registry::Gzip" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example-1.0.0.tar.gz')
+    @gzip = Registry::Gzip.new(@extension)
+  end
+
+  it "should unpack the archive with compression" do
+    @gzip.should_receive(:system).with(/gunzip example.tar.gz/)
+    @gzip.should_receive(:`).with(/tar xvf example.tar/).and_return('example-1.0.0/example_extension.rb\n')
+    @gzip.unpack
+    @gzip.path.should =~ /example-1\.0\.0$/
+  end
+end
+
+describe "Registry::Bzip2" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example-1.0.0.tar.bz2')
+    @gzip = Registry::Bzip2.new(@extension)
+  end
+
+  it "should unpack the archive with compression" do
+    @gzip.should_receive(:system).with(/bunzip2 example.tar.bz2/)
+    @gzip.should_receive(:`).with(/tar xvf example.tar/).and_return('example-1.0.0/example_extension.rb\n')
+    @gzip.unpack
+    @gzip.path.should =~ /example-1\.0\.0$/
+  end
+end
+
+
+describe "Registry::Zip" do
+  before :each do
+    @extension = mock("Extension", :name => 'example', :download_url => 'http://localhost/example-1.0.0.zip')
+    @zip = Registry::Zip.new(@extension)
+  end
+
+  it "should unpack the zip" do
+    @zip.should_receive(:`).with(/unzip example-1.0.0.zip -d example/).and_return('')
+    @zip.unpack
+    @zip.path.should =~ /example$/
+  end
+end

data/spec/lib/radiant/extension_loader_spec.rb

@@ -6,8 +6,10 @@ describe Radiant::ExtensionLoader do
     $LOAD_PATH.stub!(:unshift)
     @observer = mock("observer")
     @configuration = mock("configuration")
+    @admin = mock("admin_ui")
     @initializer = mock("initializer")
     @initializer.stub!(:configuration).and_return(@configuration)
+    @initializer.stub!(:admin).and_return(@admin)
     @instance = Radiant::ExtensionLoader.send(:new)
     @instance.initializer = @initializer
     
@@ -143,6 +145,7 @@ describe Radiant::ExtensionLoader do
   it "should activate extensions" do
     @initializer.should_receive(:initialize_default_admin_tabs)
     @initializer.should_receive(:initialize_framework_views)
+    @admin.should_receive(:load_default_regions)
     extensions = [BasicExtension, OverridingExtension]
     @instance.extensions = extensions
     @instance.activate_extensions

data/spec/models/page_spec.rb

@@ -377,7 +377,15 @@ describe Page, "#find_by_url" do
   it 'should find the FileNotFoundPage when a page does not exist' do
     @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_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_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_url('/gallery/nothing-doing/').should == pages(:no_picture)
   end
@@ -428,7 +436,14 @@ describe Page, "class" do
   it 'should allow initialization with default page status' do
     @page = Page.new_with_defaults({ 'defaults.page.status' => 'published' })
     @page.status.should == Status[:published]
-  end  
+  end
+  
+  it 'should allow initialization with default filter' do
+    @page = Page.new_with_defaults({ 'defaults.page.filter' => 'Textile', 'defaults.page.parts' => 'a, b, c' })
+    @page.parts.each do |part|
+      part.filter_id.should == 'Textile'
+    end
+  end
   
   it 'should allow you to get the class name of a descendant class with a string' do
     ["", nil, "Page"].each do |value|
@@ -443,6 +458,51 @@ describe Page, "class" do
     end
     Page.is_descendant_class_name?("InvalidPage").should == false
   end
+  
+end
+
+describe Page, "loading subclasses before bootstrap" do
+  before :each do
+    Page.connection.should_receive(:tables).and_return([])
+  end
+  
+  it "should not attempt to search for missing subclasses" do
+    Page.connection.should_not_receive(:select_values).with("SELECT DISTINCT class_name FROM pages WHERE class_name <> '' AND class_name IS NOT NULL")
+    Page.load_subclasses
+  end
+end
+
+describe Page, 'loading subclasses after bootstrap' do
+  it "should find subclasses in extensions" do
+    defined?(ArchivePage).should_not be_nil
+  end
+  
+  it "should not adjust the display name of subclasses found in extensions" do
+    ArchivePage.display_name.should_not match(/not installed/)
+  end
+end
+
+describe Page, "class which is applied to a page but not defined" do
+  scenario :pages
+
+  before :each do
+    eval(%Q{class ClassNotDefinedPage < Page; def self.missing?; false end end}, TOPLEVEL_BINDING)    
+    create_page "Class Not Defined", :class_name => "ClassNotDefinedPage"
+    Object.send(:remove_const, :ClassNotDefinedPage)
+    Page.load_subclasses
+  end
+
+  it 'should be created dynamically as a new subclass of Page' do
+    Object.const_defined?("ClassNotDefinedPage").should == true
+  end
+
+  it 'should indicate that it wasn\'t defined' do
+    ClassNotDefinedPage.missing?.should == true
+  end
+  
+  it "should adjust the display name to indicate that the page type is not installed" do
+    ClassNotDefinedPage.display_name.should match(/not installed/)
+  end
 end
 
 describe Page, "class find_by_url" do