typo 4.0.3 → 4.1

data/spec/models/page_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given the fixture :first_page' do
+  fixtures :contents, :blogs
+
+  setup { @page = contents(:first_page) }
+
+  specify '#permalink_url should be: http://myblog.net/pages/page_one' do
+    @page.permalink_url.should == 'http://myblog.net/pages/page_one'
+  end
+
+  specify '#edit_url should be: http://myblog.net/admin/pages/edit/9' do
+    @page.edit_url.should == 'http://myblog.net/admin/pages/edit/9'
+  end
+
+  specify '#delete_url should work too' do
+    @page.delete_url.should == 'http://myblog.net/admin/pages/destroy/9'
+  end
+
+  specify 'Pages cannot have the same name' do
+    Page.new(:name => @page.name, :body => @page.body, :title => @page.title).should_not_be_valid
+    Page.new(:name => @page.name, :body => 'body', :title => 'title').should_not_be_valid
+  end
+end
+
+class Hash
+  def except(*keys)
+    self.reject { |k,v| keys.include? k.to_sym }
+  end
+
+  def only(*keys)
+    self.dup.reject { |k, v| !keys.include? k.to_sym }
+  end
+end
+
+module ValidPageHelper
+  def valid_attributes
+    { :name => 'name', :title => 'title', :body => 'body'}
+  end
+end
+
+context 'Given no pages' do
+  include ValidPageHelper
+
+  setup { @page = Page.new }
+
+  specify 'An empty page is invalid' do
+    @page.should_not_be_valid
+  end
+
+  specify 'A page is valid with name, title and body' do
+    @page.attributes = valid_attributes
+    @page.should_be_valid
+  end
+
+  specify 'A page is invalid without a name' do
+    @page.attributes = valid_attributes.except(:name)
+    @page.should_not_be_valid
+    @page.errors.on(:name).should == "can't be blank"
+    @page.name = 'somename'
+    @page.should_be_valid
+  end
+
+  specify 'A page is invalid without a title' do
+    @page.attributes = valid_attributes.except(:title)
+    @page.should_not_be_valid
+    @page.errors.on(:title).should == "can't be blank"
+    @page.title = 'sometitle'
+    @page.should_be_valid
+  end
+
+  specify 'A page is invalid without a body' do
+    @page.attributes = valid_attributes.except(:body)
+    @page.should_not_be_valid
+    @page.errors.on(:body).should == "can't be blank"
+    @page.body = 'somebody'
+    @page.should_be_valid
+  end
+end
+
+context 'Given a valid page' do
+  include ValidPageHelper
+  setup { @page = Page.new(valid_attributes) }
+
+  specify 'default filter should be textile' do
+    @page.default_text_filter.name.should == 'textile'
+  end
+end

data/spec/models/ping_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given a post which references a pingback enabled article' do
+  fixtures :contents, :blogs
+
+  PINGBACK_TARGET='http://anotherblog.org/xml-rpc'
+  REFERENCED_URL='http://anotherblog.org/a-post'
+  REFERRER_URL='http://myblog.net/referring-post'
+
+
+  setup do
+    @mock_response = mock('response')
+    @mock_xmlrpc_response = mock('xmlrpc_response')
+  end
+
+  specify 'Pingback sent to url found in referenced header' do
+    @mock_response.should_receive(:[]).with('X-Pingback').at_least(:once).and_return(PINGBACK_TARGET)
+    @mock_xmlrpc_response.should_receive(:call).with('pingback.ping', REFERRER_URL, REFERENCED_URL)
+    make_and_send_ping
+  end
+
+  specify 'Pingback sent to url found in referenced body' do
+    @mock_response.should_receive(:[]).with('X-Pingback').at_least(:once).and_return(nil)
+    @mock_response.should_receive(:body).at_least(:once)\
+      .and_return(%{<link rel="pingback" href="http://anotherblog.org/xml-rpc" />})
+    @mock_xmlrpc_response.should_receive(:call).with('pingback.ping', REFERRER_URL, REFERENCED_URL)
+    make_and_send_ping
+  end
+
+  specify 'Pingback sent when new article is saved' do
+    ActiveRecord::Base.observers.should == [:email_notifier, :web_notifier]
+
+    blog = Blog.default
+
+    blog.should_not_send_outbound_pings
+    blog.send_outbound_pings = 1
+    blog.save!
+    blog.should_send_outbound_pings
+
+
+    a = blog.articles.build \
+      :body => '<a href="http://anotherblog.org/a-post">',
+      :title => 'Test the pinging',
+      :published => true
+
+    Net::HTTP.should_receive(:get_response).and_return(@mock_response)
+    XMLRPC::Client.should_receive(:new2).with(PINGBACK_TARGET).and_return(@mock_xmlrpc_response)
+
+    @mock_response.should_receive(:[]).with('X-Pingback').at_least(:once).and_return(PINGBACK_TARGET)
+    @mock_xmlrpc_response.should_receive(:call)\
+      .with('pingback.ping',
+            %r{http://myblog.net/articles/\d{4}/\d{2}/\d{2}/test-the-pinging},
+            REFERENCED_URL)
+
+
+    a.should_have(1).html_urls
+    a.save!
+    a.should_be_just_published
+    a.reload
+    a.should_not_be_just_published
+    # Saving again will not resend the pings
+    a.save
+  end
+
+  def make_and_send_ping
+    Net::HTTP.should_receive(:get_response).and_return(@mock_response)
+    XMLRPC::Client.should_receive(:new2).with(PINGBACK_TARGET).and_return(@mock_xmlrpc_response)
+
+    ping = contents(:article1).pings.build("url" => REFERENCED_URL)
+    ping.should_be_instance_of(Ping)
+    ping.url.should == REFERENCED_URL
+    ping.send_pingback_or_trackback(REFERRER_URL)
+  end
+end
+
+context "An article links to another article, which contains a trackback URL" do
+  fixtures :contents, :blogs
+
+  REFERENCED_URL='http://anotherblog.org/a-post'
+  TRACKBACK_URL="http://anotherblog.org/a-post/trackback"
+  REFERRER_URL='http://myblog.net/referring-post'
+
+  def expected_trackback_post_data
+    "title=Article+1%21&excerpt=body&url=http://myblog.net/referring-post&blog_name=test+blog"
+  end
+
+  specify 'Trackback URL is detected and pinged' do
+    @mock = mock('html_response')
+    Net::HTTP.should_receive(:get_response).with(URI.parse(REFERENCED_URL)).and_return(@mock)
+    @mock.should_receive(:[]).with('X-Pingback').at_least(:once)
+    @mock.should_receive(:body).twice.and_return(referenced_body)
+    Net::HTTP.should_receive(:start).with(URI.parse(TRACKBACK_URL).host, 80).and_yield(@mock)
+    @mock.should_receive(:post) \
+      .with('/a-post/trackback', expected_trackback_post_data,
+            'Content-type' => 'application/x-www-form-urlencoded; charset=utf-8') \
+      .and_return(@mock)
+
+    ping = contents(:article1).pings.build(:url => REFERENCED_URL)
+    ping.send_pingback_or_trackback(REFERRER_URL)
+  end
+
+
+  def referenced_body
+    <<-eobody
+    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/"
+           xmlns:dc="http://purl.org/dc/elements/1.1/">
+    <rdf:Description
+        rdf:about=""
+        trackback:ping="http://anotherblog.org/a-post/trackback"
+        dc:title="Track me, track me!"
+        dc:identifier="http://anotherblog.org/a-post"
+        dc:description="Track me 'til I fart!'"
+        dc:creator="pdcawley"
+        dc:date="2006-03-01T04:31:00-05:00" />
+    </rdf:RDF>
+    eobody
+  end
+end
+
+context 'Given a remote site to notify, eg technorati' do
+  fixtures :contents, :blogs
+
+  specify 'we can ping them correctly' do
+    mock = mock('response')
+    XMLRPC::Client.should_receive(:new2).with('http://rpc.technorati.com/rpc/ping').and_return(mock)
+    mock.should_receive(:call).with('weblogUpdates.ping', 'test blog',
+                                    'http://myblog.net', 'http://myblog.net/new-post')
+
+    ping = contents(:article1).pings.build("url" => "http://rpc.technorati.com/rpc/ping")
+    ping.send_weblogupdatesping('http://myblog.net', 'http://myblog.net/new-post')
+  end
+end

data/spec/models/redirect_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given an empty redirects table' do
+  setup do
+    Redirect.delete_all
+  end
+
+  specify 'redirects are unique' do
+    lambda { Redirect.create!(:from_path => 'foo/bar', :to_path => '/') }.should_not_raise
+
+    redirect = Redirect.new(:from_path => 'foo/bar', :to_path => '/')
+
+    redirect.should_not_be_valid
+    redirect.errors.on(:from_path).should == 'has already been taken'
+  end
+end
+

data/spec/models/resource_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'With the resource fixtures loaded and their equivalent files in place on the disk' do
+  fixtures(:resources)
+
+  setup do
+     FileUtils.mkpath(RAILS_ROOT + '/public/files')
+    Resource.find(:all).each {|f| FileUtils.touch(f.fullpath)}
+  end
+
+  teardown do
+    [:resource1, :resource2, :resource3].each do |sym|
+      res = resources(sym)
+      File.unlink(res.fullpath) if File.exist?(res.fullpath)
+    end
+  end
+
+  specify 'there are three resources in the database' do
+    Resource.count.should == 3
+  end
+
+  specify 'fullpath should be RAILS_ROOT + "/public/files/" + resource.filename' do
+    res = Resource.new(:article_id => 1, :filename => 'a_new_file', :mime => 'image/jpeg', :size => 110)
+    res.fullpath.should == RAILS_ROOT + "/public/files/a_new_file"
+  end
+
+  specify 'resources created with the same name as an existing resource don\'t overwrite the old resource' do
+    resources(:resource1).should_not_be_nil
+    f1 = Resource.create(:filename => resources(:resource1).filename,
+                         :mime => resources(:resource1).mime)
+    f1.should_not_be_nil
+    f1.should_be_valid
+
+    f1.filename.should_not == resources(:resource1).filename
+    f1.destroy
+  end
+
+  specify 'a resource deletes its associated file on destruction' do
+    File.exist?(RAILS_ROOT + '/public/files/me.jpg').should_be true
+    Resource.destroy(1)
+    File.exist?(RAILS_ROOT + '/public/files/me.jpg').should_be false
+  end
+end

data/spec/models/static_sidebar_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given a new StaticSidebar' do
+  setup { @sb = StaticSidebar.new }
+
+  specify 'title should be Links' do
+    @sb.title.should == 'Links'
+  end
+
+  specify 'body should be our default' do
+    @sb.body.should == StaticSidebar::DEFAULT_TEXT
+  end
+
+  specify 'description should be set correctly' do
+    @sb.description.should == 'Static content, like links to other sites, advertisements, or blog meta-information'
+  end
+end

data/spec/models/tag_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given loaded fixtures' do
+  fixtures :tags, :contents, :articles_tags, :blogs
+
+  specify 'we can Tag.get by name' do
+    Tag.get('foo').should == tags(:foo_tag)
+  end
+
+  specify 'tags are unique' do
+    lambda {Tag.create!(:name => 'test')}.should_not_raise
+
+    test_tag = Tag.new(:name => 'test')
+    test_tag.should_not_be_valid
+    test_tag.errors.on(:name).should == 'has already been taken'
+  end
+
+  specify 'display names with spaces can be found by joinedupname' do
+    Tag.find(:first, :conditions => {:name => 'Monty Python'}).should_be nil
+    tag = Tag.create(:name => 'Monty Python')
+
+    tag.should_be_valid
+    tag.name.should == 'montypython'
+    tag.display_name.should == 'Monty Python'
+
+    tag.should == Tag.get('montypython')
+    tag.should == Tag.get('Monty Python')
+  end
+
+  specify 'articles can be tagged' do
+    a = Article.create(:title => 'an article')
+    a.tags << tags(:foo_tag)
+    a.tags << tags(:bar_tag)
+
+    a.reload
+    a.tags.size.should == 2
+    a.tags.sort_by(&:id).should == [tags(:foo_tag), tags(:bar_tag)].sort_by(&:id)
+  end
+
+  specify 'find_all_with_article_counters finds 2 tags' do
+    tags = Tag.find_all_with_article_counters
+    tags.should_have(2).entries
+
+    tags.first.name.should == "foo"
+    tags.first.article_counter.should == 2
+
+    tags.last.name.should == 'bar'
+    tags.last.article_counter.should == 1
+  end
+
+  specify 'permalink_url should be of form /articles/tag/<name>' do
+    Tag.get('foo').permalink_url.should == 'http://myblog.net/articles/tag/foo'
+  end
+end

data/spec/models/text_filter_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context "With the list of available filters" do
+  setup { @filters = TextFilter.available_filters }
+
+  specify 'Markdown is an available filter' do
+    @filters.should_include Typo::Textfilter::Markdown
+  end
+
+  specify 'Smartypants is available' do
+    @filters.should_include Typo::Textfilter::Smartypants
+  end
+
+  specify 'Htmlfilter is available' do
+    @filters.should_include Typo::Textfilter::Htmlfilter
+  end
+
+  specify 'Textile is available' do
+    @filters.should_include Typo::Textfilter::Textile
+  end
+
+  specify 'Amazon is available' do
+    @filters.should_include Typo::Textfilter::Amazon
+  end
+
+  specify 'Flickr is available' do
+    @filters.should_include Typo::Textfilter::Flickr
+  end
+
+  specify 'TextFilterPlugin::Markup should be unavailable' do
+    @filters.should_not_include TextFilterPlugin::Markup
+  end
+
+  specify 'TextFilterPlugin::Macro should be unavailable' do
+    @filters.should_not_include TextFilterPlugin::Macro
+  end
+
+end

data/spec/models/theme_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'Given a new test theme' do
+  setup do
+    @theme = Theme.new("test", "test")
+  end
+
+  specify 'layout path should be "../../themes/test/layouts/default"'  do
+    @theme.layout.should == "../../themes/test/layouts/default"
+  end
+end
+
+context 'Given a the default theme' do
+  setup do
+    @theme = Blog.new.current_theme
+  end
+
+  specify 'theme should be azure' do
+    @theme.name.should == 'azure'
+  end
+
+  specify 'theme description should be correct' do
+    @theme.description.should ==
+      File.open(RAILS_ROOT + '/themes/azure/about.markdown') {|f| f.read}
+  end
+
+  specify 'theme_from_path should find the correct theme' do
+    Theme.theme_from_path(RAILS_ROOT + 'themes/azure').name.should == 'azure'
+    Theme.theme_from_path(RAILS_ROOT + 'themes/scribbish').name.should == 'scribbish'
+  end
+
+  specify '#search_theme_path finds the right things' do
+    Theme.should_receive(:themes_root).and_return(RAILS_ROOT + '/test/mocks/themes')
+    Theme.search_theme_directory.collect{|t| File.basename(t)}.sort.should ==
+      %w{ 123-numbers-in-path CamelCaseDirectory azure i-have-special-chars }
+  end
+
+  specify 'find_all finds all the installed themes' do
+    Theme.find_all.collect{|t| t.name}.should_include(@theme.name)
+    Theme.find_all.size.should ==
+      Dir.glob(RAILS_ROOT + '/themes/[a-zA-Z0-9]*').select do |file|
+        File.readable? "#{file}/about.markdown"
+      end.size
+  end
+end

data/spec/models/trackback_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+context 'With the various trackback filters loaded and DNS mocked out appropriately' do
+  setup do
+    IPSocket.stub!(:getaddress).and_return { raise SocketError.new("getaddrinfo: Name or service not known") }
+  end
+
+  specify 'Incomplete trackbacks should not be accepted' do
+    tb = Trackback.new(:blog_name => 'Blog name', :title => 'Title', :excerpt => 'Excerpt')
+    tb.should_not_be_valid
+    tb.errors.should_be_invalid('url')
+
+    tb.url = 'http://foo.com'
+    tb.should_be_valid
+    tb.save
+    tb.guid.size.should_be > 15
+    tb.should_not_be_spam
+  end
+
+  specify 'Trackbacks with a spammy link in the excerpt should be rejected' do
+    IPSocket.should_receive(:getaddress).with('chinaaircatering.com.bsb.empty.us').at_least(:once).and_return('127.0.0.2')
+
+    tb = Trackback.new(ham_params.merge(:excerpt => '<a href="http://chinaaircatering.com">spam</a>'))
+    tb.should_be_spam
+  end
+
+  specify 'Trackbacks with a spammy source url should be rejected' do
+    add_spam_domain
+    tb = Trackback.new(ham_params.merge(:url => 'http://www.chinaircatering.com'))
+    tb.should_be_spam
+  end
+
+  specify 'Trackbacks from a spammy ip address should be rejected' do
+    add_spam_ip('212.42.230.207')
+    tb = Trackback.new(ham_params.merge(:ip => '212.42.230.207'))
+    tb.should_be_spam
+  end
+
+  specify 'Trackbacks with a blacklisted pattern in the excerpt should be rejected' do
+    BlacklistPattern.should_receive(:find).with(:all).at_least(:once)\
+      .and_return([StringPattern.new(:pattern => 'poker'),
+                   RegexPattern.new(:pattern => '^Texas')])
+    Trackback.new(ham_params.merge(:excerpt => 'Mmm... come to my shiny poker site')).should_be_spam
+    Trackback.new(ham_params.merge(:excerpt => 'Texas hold-em rules!')).should_be_spam
+  end
+
+  def add_spam_domain(domain = 'chinaircatering.com')
+    IPSocket.should_receive(:getaddress).with("#{domain}.bsb.empty.us").at_least(:once).and_return('127.0.0.2')
+  end
+
+  def add_spam_ip(addr = '212.42.230.206')
+    rbl_domain = addr.split(/\./).reverse.join('.') + '.opm.blitzed.us'
+    IPSocket.should_receive(:getaddress).with(rbl_domain).at_least(:once).and_return('127.0.0.2')
+  end
+
+  def ham_params
+    { :blog_name => 'Blog', :title => 'trackback', :excerpt => 'bland',
+      :url => 'http://notaspammer.com', :ip => '212.42.230.206' }
+  end
+end