alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/spec/helpers/admin/tags_helper_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Admin::TagsHelper do
+
+    let(:tag) do
+      mock_model(ActsAsTaggableOn::Tag, :name => "foo")
+    end
+
+    describe "#filtered_by_tag?" do
+      it "should return true if the filterlist contains the given tag" do
+        controller.params[:tagged_with] = "foo,bar,baz"
+        helper.filtered_by_tag?(tag).should == true
+      end
+
+      it "should return false if the filterlist does not contain the given tag" do
+        controller.params[:tagged_with] = "bar,baz"
+        helper.filtered_by_tag?(tag).should == false
+      end
+    end
+
+    describe "#add_to_tag_filter" do
+      context "if params[:tagged_with] is not present" do
+        it "should return an Array with the given tag name" do
+          helper.add_to_tag_filter(tag).should == ["foo"]
+        end
+      end
+
+      context "if params[:tagged_with] contains some tag names" do
+        it "should return an Array of tag names including the given one" do
+          controller.params[:tagged_with] = "bar,baz"
+          helper.add_to_tag_filter(tag).should == ["bar", "baz", "foo"]
+        end
+      end
+    end
+
+    describe "#remove_from_tag_filter" do
+      context "if params[:tagged_with] is not present" do
+        it "should return an empty Array" do
+          helper.remove_from_tag_filter(tag).should be_empty
+        end
+      end
+
+      context "if params[:tagged_with] contains some tag names" do
+        it "should return an Array of tag names without the given one" do
+          controller.params[:tagged_with] = "bar,baz,foo"
+          helper.remove_from_tag_filter(tag).should == ["bar", "baz"]
+        end
+      end
+    end
+
+  end
+end

data/spec/helpers/base_helper_spec.rb

@@ -4,7 +4,6 @@ module Alchemy
   describe BaseHelper do
 
     describe "#render_message" do
-
       context "if no argument is passed" do
         it "should render a div with an info icon and the given content" do
           helper.render_message{ content_tag(:p, "my notice") }.should match(/<div class="info message"><span class="icon info"><\/span><p>my notice/)
@@ -16,7 +15,6 @@ module Alchemy
           helper.render_message(:error){ content_tag(:p, "my notice") }.should match(/<div class="error message"><span class="icon error">/)
         end
       end
-
     end
 
     describe "#configuration" do
@@ -27,7 +25,6 @@ module Alchemy
     end
 
     describe "#multi_language?" do
-
       context "if more than one published language exists" do
         it "should return true" do
           Alchemy::Language.stub_chain(:published, :count).and_return(2)
@@ -41,7 +38,26 @@ module Alchemy
           helper.multi_language?.should == false
         end
       end
+    end
+
+    describe '#breadcrumb' do
+      let(:lang_root) { Page.language_root_for(Language.get_default.id) }
+      let(:parent)    { FactoryGirl.create(:public_page) }
+      let(:page)      { FactoryGirl.create(:public_page, parent_id: parent.id) }
 
+      it "returns an array of all parents including self" do
+        helper.breadcrumb(page).should == [lang_root, parent, page]
+      end
+
+      it "does not include the root page" do
+        helper.breadcrumb(page).should_not include(Page.root)
+      end
+
+      context "with current page nil" do
+        it "should return an empty array" do
+          helper.breadcrumb(nil).should == []
+        end
+      end
     end
 
   end

data/spec/helpers/pages_helper_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 include Alchemy::BaseHelper
@@ -11,6 +12,7 @@ module Alchemy
     let(:language_root)             { FactoryGirl.create(:language_root_page) }
     let(:public_page)               { FactoryGirl.create(:public_page) }
     let(:visible_page)              { FactoryGirl.create(:public_page, :visible => true) }
+    let(:restricted_page)           { FactoryGirl.create(:public_page, :visible => true, :restricted => true) }
     let(:level_2_page)              { FactoryGirl.create(:public_page, :parent_id => visible_page.id, :visible => true, :name => 'Level 2') }
     let(:level_3_page)              { FactoryGirl.create(:public_page, :parent_id => level_2_page.id, :visible => true, :name => 'Level 3') }
     let(:level_4_page)              { FactoryGirl.create(:public_page, :parent_id => level_3_page.id, :visible => true, :name => 'Level 4') }
@@ -19,8 +21,8 @@ module Alchemy
     let(:klingonian_public_page)    { FactoryGirl.create(:public_page, :language => klingonian, :parent_id => klingonian_language_root.id) }
 
     before do
+      Config.stub!(:get) { |arg| arg == :url_nesting ? true : Config.parameter(arg) }
       @root_page = language_root # We need this instance variable in the helpers
-      helper.stub(:configuration).and_return(false)
     end
 
     it "should render the current page layout" do
@@ -29,19 +31,32 @@ module Alchemy
     end
 
     describe "#render_navigation" do
-
-      before do
-        visible_page
-      end
+      before { visible_page }
 
       context "not in multi_language mode" do
+        before { helper.stub(:multi_language?).and_return(false) }
 
-        before do
-          helper.stub(:multi_language?).and_return(false)
+        it "should render the page navigation" do
+          helper.render_navigation.should have_selector("ul.navigation.level_1 li.#{visible_page.urlname} a[href=\"/#{visible_page.urlname}\"]")
         end
 
-        it "should render the page navigation" do
-          helper.render_navigation.should have_selector("ul.navigation.level_1 li.#{visible_page.urlname} a[href=\"/alchemy/#{visible_page.urlname}\"]")
+        context "as guest user" do
+          before { restricted_page }
+
+          it "should not render restricted pages" do
+            helper.render_navigation.should_not have_selector("ul.navigation.level_1 li a[href=\"/#{restricted_page.urlname}\"]")
+          end
+        end
+
+        context "as registered user" do
+          before do
+            restricted_page
+            Authorization.stub!(:current_user).and_return(FactoryGirl.build(:registered_user))
+          end
+
+          it "should render restricted pages" do
+            helper.render_navigation.should have_selector("ul.navigation.level_1 li a[href=\"/#{restricted_page.urlname}\"]")
+          end
         end
 
         context "with enabled url nesting" do
@@ -52,7 +67,7 @@ module Alchemy
           end
 
           it "should render nested page links" do
-            helper.render_navigation(:all_sub_menues => true).should have_selector("ul li a[href=\"/alchemy/#{visible_page.urlname}/#{level_2_page.urlname}/#{level_3_page.urlname}\"]")
+            helper.render_navigation(:all_sub_menues => true).should have_selector("ul li a[href=\"/#{level_3_page.urlname}\"]")
           end
 
         end
@@ -71,6 +86,34 @@ module Alchemy
 
       end
 
+      context "with options[:deepness] set" do
+        before { level_3_page }
+
+        it "shows only pages up to this depth" do
+          output = helper.render_navigation(deepness: 3, all_sub_menues: true)
+          output.should have_selector("ul li a[href=\"/#{level_2_page.urlname}\"]")
+          output.should_not have_selector("ul li a[href=\"/#{level_3_page.urlname}\"]")
+        end
+      end
+
+      context "with options[:spacer] set" do
+        before { visible_page }
+
+        context "with two pages on same level" do
+          before { FactoryGirl.create(:public_page, visible: true) }
+
+          it "should render the given spacer" do
+            helper.render_navigation(spacer: '•').should match(/•/)
+          end
+        end
+
+        context "only one page in current level" do
+          it "should not render the spacer" do
+            helper.render_navigation(spacer: '•').should_not match(/•/)
+          end
+        end
+      end
+
     end
 
     describe '#render_subnavigation' do
@@ -88,11 +131,11 @@ module Alchemy
         before { @page = level_2_page }
 
         it "should render the navigation from current page" do
-          helper.render_subnavigation.should have_selector("ul > li > a[href='/alchemy/#{level_2_page.urlname}']")
+          helper.render_subnavigation.should have_selector("ul > li > a[href='/#{level_2_page.urlname}']")
         end
 
         it "should set current page active" do
-          helper.render_subnavigation.should have_selector("a[href='/alchemy/#{level_2_page.urlname}'].active")
+          helper.render_subnavigation.should have_selector("a[href='/#{level_2_page.urlname}'].active")
         end
 
       end
@@ -102,11 +145,11 @@ module Alchemy
         before { @page = level_3_page }
 
         it "should render the navigation from current pages parent" do
-          helper.render_subnavigation.should have_selector("ul > li > ul > li > a[href='/alchemy/#{level_3_page.urlname}']")
+          helper.render_subnavigation.should have_selector("ul > li > ul > li > a[href='/#{level_3_page.urlname}']")
         end
 
         it "should set current page active" do
-          helper.render_subnavigation.should have_selector("a[href='/alchemy/#{level_3_page.urlname}'].active")
+          helper.render_subnavigation.should have_selector("a[href='/#{level_3_page.urlname}'].active")
         end
 
       end
@@ -116,17 +159,17 @@ module Alchemy
         before { @page = level_4_page }
 
         it "should render the navigation from current pages parents parent" do
-          helper.render_subnavigation.should have_selector("ul > li > ul > li > ul > li > a[href='/alchemy/#{level_4_page.urlname}']")
+          helper.render_subnavigation.should have_selector("ul > li > ul > li > ul > li > a[href='/#{level_4_page.urlname}']")
         end
 
         it "should set current page active" do
-          helper.render_subnavigation.should have_selector("a[href='/alchemy/#{level_4_page.urlname}'].active")
+          helper.render_subnavigation.should have_selector("a[href='/#{level_4_page.urlname}'].active")
         end
 
         context "beginning with level 3" do
 
           it "should render the navigation beginning from its parent" do
-            helper.render_subnavigation(:level => 3).should have_selector("ul > li > ul > li > a[href='/alchemy/#{level_4_page.urlname}']")
+            helper.render_subnavigation(:level => 3).should have_selector("ul > li > ul > li > a[href='/#{level_4_page.urlname}']")
           end
 
         end
@@ -136,56 +179,61 @@ module Alchemy
     end
 
     describe "#render_breadcrumb" do
+      let(:parent)    { FactoryGirl.create(:public_page, visible: true) }
+      let(:page)      { FactoryGirl.create(:public_page, parent_id: parent.id, visible: true) }
 
       before do
         helper.stub(:multi_language?).and_return(false)
-        @root = mock_model('Page', :urlname => 'root', :name => 'Root', :title => 'Root', :visible? => false, :public? => false, :restricted? => false, :parent => nil)
-        @language_root = mock_model('Page', :urlname => 'language_root', :name => 'Language Root', :title => 'Language Root', :visible? => true, :public? => true, :restricted? => false, :parent => @root)
-        @page = mock_model('Page', :urlname => 'a-public-page', :name => 'A Public Page', :title => 'A Public Page', :visible? => true, :public? => true, :restricted? => false, :parent => @language_root)
       end
 
       it "should render a breadcrumb to current page" do
-        helper.render_breadcrumb.should have_selector('.active.last[contains("A Public Page")]')
+        helper.render_breadcrumb(page: page).should have_selector(".active.last[contains('#{page.name}')]")
       end
 
-      it "should render a breadcrumb with a alternative seperator" do
-        helper.render_breadcrumb(:seperator => '<span>###</span>').should have_selector('span[contains("###")]')
+      context "with options[:seperator] given" do
+        it "should render a breadcrumb with an alternative seperator" do
+          helper.render_breadcrumb(page: page, seperator: '<span>###</span>').should have_selector('span[contains("###")]')
+        end
       end
 
-      it "should render a breadcrumb in reversed order" do
-        helper.render_breadcrumb(:reverse => true).should have_selector('.active.first[contains("A Public Page")]')
+      context "with options[:reverse] set to true" do
+        it "should render a breadcrumb in reversed order" do
+          helper.render_breadcrumb(page: page, reverse: true).should have_selector('.active.first[contains("A Public Page")]')
+        end
       end
 
-      it "should render a breadcrumb of restricted pages only" do
-        @page.stub!(:restricted? => true, :urlname => 'a-restricted-public-page', :name => 'A restricted Public Page', :title => 'A restricted Public Page')
-        helper.render_breadcrumb(:restricted_only => true).should match(/^(<span(.[^>]+)>)A restricted Public Page/)
-      end
+      context "with options[:restricted_only] set to true" do
+        before { Authorization.current_user = FactoryGirl.build(:registered_user) }
 
-      it "should render a breadcrumb of visible pages only" do
-        @page.stub!(:visible? => false, :urlname => 'a-invisible-public-page', :name => 'A invisible Public Page', :title => 'A invisible Public Page')
-        helper.render_breadcrumb(:visible_only => true).should_not match(/A invisible Public Page/)
+        it "should render a breadcrumb of restricted pages only" do
+          page.update_attributes!(restricted: true, urlname: 'a-restricted-public-page', name: 'A restricted Public Page', title: 'A restricted Public Page')
+          helper.render_breadcrumb(page: page, restricted_only: true).strip.should match(/^(<span(.[^>]+)>)A restricted Public Page/)
+        end
       end
 
-      it "should render a breadcrumb of visible and invisible pages" do
-        @page.stub!(:visible? => false, :urlname => 'a-invisible-public-page', :name => 'A invisible Public Page', :title => 'A invisible Public Page')
-        helper.render_breadcrumb(:visible_only => false).should match(/A invisible Public Page/)
+      it "should render a breadcrumb of visible pages only." do
+        page.update_attributes!(visible: false, urlname: 'a-invisible-public-page', name: 'A invisible Public Page', title: 'A invisible Public Page')
+        helper.render_breadcrumb(page: page, visible_only: true).should_not match(/A invisible Public Page/)
       end
 
       it "should render a breadcrumb of published pages only" do
-        @page.stub!(:public => false, :public? => false, :urlname => 'a-unpublic-page', :name => 'A Unpublic Page', :title => 'A Unpublic Page')
-        helper.render_breadcrumb(:public_only => true).should_not match(/A Unpublic Page/)
+        page.update_attributes!(public: false, urlname: 'a-unpublic-page', name: 'A Unpublic Page', title: 'A Unpublic Page')
+        helper.render_breadcrumb(page: page, public_only: true).should_not match(/A Unpublic Page/)
       end
 
-      it "should render a breadcrumb of published and unpublished pages" do
-        @page.stub!(:public => false, :public? => false, :urlname => 'a-unpublic-page', :name => 'A Unpublic Page', :title => 'A Unpublic Page')
-        helper.render_breadcrumb(:public_only => false).should match(/A Unpublic Page/)
+      context "with options[:without]" do
+        it "should render a breadcrumb without this page" do
+          page.update_attributes!(urlname: 'not-me', name: 'Not Me', title: 'Not Me')
+          helper.render_breadcrumb(page: page, without: page).should_not match(/Not Me/)
+        end
       end
 
-      it "should render a breadcrumb without the page named 'Not Me'" do
-        @page.stub!(:urlname => 'not-me', :name => 'Not Me', :title => 'Not Me')
-        helper.render_breadcrumb(:without => @page).should_not match(/Not Me/)
+      context "with options[:without] as array" do
+        it "should render a breadcrumb without these pages." do
+          page.update_attributes!(urlname: 'not-me', name: 'Not Me', title: 'Not Me')
+          helper.render_breadcrumb(page: page, without: [page]).should_not match(/Not Me/)
+        end
       end
-
     end
 
     describe "#render_meta_data" do

data/spec/{url_helpers_spec.rb → helpers/picture_url_helpers_spec.rb}

@@ -1,35 +1,35 @@
 require 'spec_helper'
 
-describe "URL generating" do
+describe "Picture url helpers" do
 
   it "should generate a url string for cropped picture" do
     p = show_picture_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => "jpg")
-    p.should == "/alchemy/pictures/3/show/100x33/crop/kitten.jpg"
+    p.should == "/pictures/3/show/100x33/crop/kitten.jpg"
   end
 
   it "should generate a url string for cropped and masked picture" do
     p = show_picture_path(:id => 3, :crop => "crop", :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/alchemy/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg"
+    p.should == "/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg"
   end
 
   it "should generate a url string for cropped thumbnail" do
     p = thumbnail_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/alchemy/pictures/3/thumbnails/100x33/crop/kitten.jpg"
+    p.should == "/pictures/3/thumbnails/100x33/crop/kitten.jpg"
   end
 
   it "should generate a url string for thumbnail with default name and format" do
     p = thumbnail_path(:id => 3, :size => "100x33")
-    p.should == "/alchemy/pictures/3/thumbnails/100x33/thumbnail.png"
+    p.should == "/pictures/3/thumbnails/100x33/thumbnail.png"
   end
 
   it "should generate a url string for cropped and masked thumbnail" do
     p = thumbnail_path(:id => 3, :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
-    p.should == "/alchemy/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg"
+    p.should == "/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg"
   end
 
   it "should generate a url string for zoomed image" do
     p = zoom_picture_path(:id => 3, :name => "kitten", :format => :jpg)
-    p.should == "/alchemy/pictures/3/zoom/kitten.jpg"
+    p.should == "/pictures/3/zoom/kitten.jpg"
   end
 
 end

data/spec/helpers/url_helper_spec.rb

@@ -5,130 +5,134 @@ include Alchemy::BaseHelper
 module Alchemy
   describe UrlHelper do
 
-    before do
-      @page = mock_model(Page, :urlname => 'testpage', :language_code => 'en')
-    end
+    context 'page path helpers' do
 
-    describe "#show_page_path_params" do
+      before do
+        @page = mock_model(Page, :urlname => 'testpage', :language_code => 'en')
+      end
 
-      context "when multi_language" do
+      describe "#show_page_path_params" do
 
-        before do
-          helper.stub!(:multi_language?).and_return(true)
-        end
+        context "when multi_language" do
 
-        it "should return a Hash with urlname and language_id parameter" do
-          helper.stub!(:multi_language?).and_return(true)
-          helper.show_page_path_params(@page).should include(:urlname => 'testpage', :lang => 'en')
-        end
+          before do
+            helper.stub!(:multi_language?).and_return(true)
+          end
+
+          it "should return a Hash with urlname and language_id parameter" do
+            helper.stub!(:multi_language?).and_return(true)
+            helper.show_page_path_params(@page).should include(:urlname => 'testpage', :lang => 'en')
+          end
+
+          it "should return a Hash with urlname, language_id and query parameter" do
+            helper.stub!(:multi_language?).and_return(true)
+            helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :lang => 'en', :query => 'test')
+          end
 
-        it "should return a Hash with urlname, language_id and query parameter" do
-          helper.stub!(:multi_language?).and_return(true)
-          helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :lang => 'en', :query => 'test')
         end
 
-      end
+        context "not multi_language" do
 
-      context "not multi_language" do
+          before do
+            helper.stub!(:multi_language?).and_return(false)
+          end
 
-        before do
-          helper.stub!(:multi_language?).and_return(false)
-        end
+          it "should return a Hash with the urlname but without language_id parameter" do
+            helper.show_page_path_params(@page).should include(:urlname => 'testpage')
+            helper.show_page_path_params(@page).should_not include(:lang => 'en')
+          end
 
-        it "should return a Hash with the urlname but without language_id parameter" do
-          helper.show_page_path_params(@page).should include(:urlname => 'testpage')
-          helper.show_page_path_params(@page).should_not include(:lang => 'en')
-        end
+          it "should return a Hash with urlname and query parameter" do
+            helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :query => 'test')
+            helper.show_page_path_params(@page).should_not include(:lang => 'en')
+          end
 
-        it "should return a Hash with urlname and query parameter" do
-          helper.show_page_path_params(@page, {:query => 'test'}).should include(:urlname => 'testpage', :query => 'test')
-          helper.show_page_path_params(@page).should_not include(:lang => 'en')
         end
 
       end
 
-    end
+      describe "#show_alchemy_page_path" do
 
-    describe "#show_alchemy_page_path" do
+        context "when multi_language" do
 
-      context "when multi_language" do
+          before do
+            helper.stub!(:multi_language?).and_return(true)
+          end
 
-        before do
-          helper.stub!(:multi_language?).and_return(true)
-        end
+          it "should return the correct relative path string" do
+            helper.show_alchemy_page_path(@page).should == "/#{@page.language_code}/testpage"
+          end
 
-        it "should return the correct relative path string" do
-          helper.show_alchemy_page_path(@page).should == "/alchemy/#{@page.language_code}/testpage"
-        end
+          it "should return the correct relative path string with additional parameters" do
+            helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/#{@page.language_code}/testpage?query=test"
+          end
 
-        it "should return the correct relative path string with additional parameters" do
-          helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/alchemy/#{@page.language_code}/testpage?query=test"
         end
 
-      end
+        context "not multi_language" do
 
-      context "not multi_language" do
+          before do
+            helper.stub!(:multi_language?).and_return(false)
+          end
 
-        before do
-          helper.stub!(:multi_language?).and_return(false)
-        end
+          it "should return the correct relative path string" do
+            helper.show_alchemy_page_path(@page).should == "/testpage"
+          end
 
-        it "should return the correct relative path string" do
-          helper.show_alchemy_page_path(@page).should == "/alchemy/testpage"
-        end
+          it "should return the correct relative path string with additional parameter" do
+            helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/testpage?query=test"
+          end
 
-        it "should return the correct relative path string with additional parameter" do
-          helper.show_alchemy_page_path(@page, {:query => 'test'}).should == "/alchemy/testpage?query=test"
         end
 
       end
 
-    end
+      describe "#show_alchemy_page_url" do
 
-    describe "#show_alchemy_page_url" do
+        context "when multi_language" do
 
-      context "when multi_language" do
+          before do
+            helper.stub!(:multi_language?).and_return(true)
+          end
 
-        before do
-          helper.stub!(:multi_language?).and_return(true)
-        end
+          it "should return the correct url string" do
+            helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/#{@page.language_code}/testpage"
+          end
 
-        it "should return the correct url string" do
-          helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/alchemy/#{@page.language_code}/testpage"
-        end
+          it "should return the correct url string with additional parameters" do
+            helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/#{@page.language_code}/testpage?query=test"
+          end
 
-        it "should return the correct url string with additional parameters" do
-          helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/alchemy/#{@page.language_code}/testpage?query=test"
         end
 
-      end
+        context "not multi_language" do
 
-      context "not multi_language" do
+          before do
+            helper.stub!(:multi_language?).and_return(false)
+          end
 
-        before do
-          helper.stub!(:multi_language?).and_return(false)
-        end
+          it "should return the correct url string" do
+            helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/testpage"
+          end
 
-        it "should return the correct url string" do
-          helper.show_alchemy_page_url(@page).should == "http://#{helper.request.host}/alchemy/testpage"
-        end
+          it "should return the correct url string with additional parameter" do
+            helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/testpage?query=test"
+          end
 
-        it "should return the correct url string with additional parameter" do
-          helper.show_alchemy_page_url(@page, {:query => 'test'}).should == "http://#{helper.request.host}/alchemy/testpage?query=test"
         end
 
       end
 
     end
 
-    describe 'picture path helpers' do
+    context 'picture path helpers' do
 
       let(:picture) { stub_model(Picture, :urlname => 'cute_kitten', :id => 42) }
 
       describe '#show_alchemy_picture_path' do
 
         it "should return the correct relative path string" do
-          helper.show_alchemy_picture_path(picture).should =~ Regexp.new("/alchemy/pictures/42/show/cute_kitten.jpg")
+          helper.show_alchemy_picture_path(picture).should =~ Regexp.new("/pictures/42/show/cute_kitten.jpg")
         end
 
       end
@@ -136,7 +140,7 @@ module Alchemy
       describe '#show_alchemy_picture_url' do
 
         it "should return the correct url string" do
-          helper.show_alchemy_picture_url(picture).should =~ Regexp.new("http://#{helper.request.host}/alchemy/pictures/42/show/cute_kitten.jpg")
+          helper.show_alchemy_picture_url(picture).should =~ Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg")
         end
 
       end
@@ -172,5 +176,21 @@ module Alchemy
 
     end
 
+    context 'attachment path helpers' do
+
+      before do
+        @attachment = mock_model(Attachment, :urlname => 'test-attachment.pdf')
+      end
+
+      it 'should return the correct relative path to download an attachment' do
+        helper.download_alchemy_attachment_path(@attachment).should == "/attachment/#{@attachment.id}/download/#{@attachment.urlname}"
+      end
+
+      it 'should return the correct url to download an attachment' do
+        helper.download_alchemy_attachment_url(@attachment).should == "http://#{helper.request.host}/attachment/#{@attachment.id}/download/#{@attachment.urlname}"
+      end
+
+    end
+
   end
 end