typo 5.4.4 → 5.5

data/spec/models/redirect_spec.rb

@@ -1,17 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'Given an empty redirects table' do
-  before(:each) do
-    Redirect.delete_all
-  end
-
-  it 'redirects are unique' do
-    lambda { Redirect.create!(:from_path => 'foo/bar', :to_path => '/') }.should_not raise_error
-
-    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

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Resource, ' with its fixtures loaded' do
-  before(:each) do
-    File.stub!(:exist?).and_return(true)
-  end
-
-  it 'there are three resources in the database' do
-    Resource.count.should == 3
-  end
-
-  it '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
-
-  it 'resources created with the same name as an existing resource don\'t overwrite the old resource' do
-    File.should_receive(:exist?).with(%r{public/files/me\.jpg$}).and_return(true)
-    File.should_receive(:exist?).with(%r{public/files/me1\.jpg$}).at_least(:once).and_return(false)
-    File.should_receive(:unlink).with(%r{public/files/me1\.jpg$}).and_return(true)
-
-    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.filename.should == 'me1.jpg'
-    f1.destroy
-  end
-
-  it 'a resource deletes its associated file on destruction' do
-    res = resources(:resource1)
-    File.should_receive(:exist?).with(res.fullpath).and_return(true)
-    File.should_receive(:unlink).with(res.fullpath).and_return(true)
-
-    res.destroy
-  end
-end

data/spec/models/route_cache_spec.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe RouteCache do
-
-  it "test_cache_clear" do
-    RouteCache[:foo] = :bar
-    RouteCache.clear
-    assert_equal({}, RouteCache.instance_variable_get(:@cache))
-  end
-
-end

data/spec/models/sidebar_spec.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe Sidebar do
-  it "test_available_sidebars" do
-    assert Sidebar.available_sidebars.size >= 6
-  end
-end

data/spec/models/static_sidebar_spec.rb

@@ -1,17 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'Given a new StaticSidebar' do
-  before(:each) { @sb = StaticSidebar.new }
-
-  it 'title should be Links' do
-    @sb.title.should == 'Links'
-  end
-
-  it 'body should be our default' do
-    @sb.body.should == StaticSidebar::DEFAULT_TEXT
-  end
-
-  it '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

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'Given loaded fixtures' do
-  it 'we can Tag.get by name' do
-    Tag.get('foo').should == tags(:foo)
-  end
-
-  it 'tags are unique' do
-    lambda {Tag.create!(:name => 'test')}.should_not raise_error
-
-    test_tag = Tag.new(:name => 'test')
-    test_tag.should_not be_valid
-    test_tag.errors.on(:name).should == 'has already been taken'
-  end
-
-  it '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
-
-  it 'articles can be tagged' do
-    a = Article.create(:title => 'an article')
-    a.tags << tags(:foo)
-    a.tags << tags(:bar)
-
-    a.reload
-    a.tags.size.should == 2
-    a.tags.sort_by(&:id).should == [tags(:foo), tags(:bar)].sort_by(&:id)
-  end
-
-  it '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 == 3
-
-    tags.last.name.should == 'bar'
-    tags.last.article_counter.should == 2
-  end
-
-  it 'permalink_url should be of form /tag/<name>' do
-    Tag.get('foo').permalink_url.should == 'http://myblog.net/tag/foo'
-  end
-  
-  it "find_with_char('f') should be return foo" do
-    Tag.find_with_char('f').should == [tags(:foo)]
-  end
-  
-  it "find_with_char('v') should return empty data" do
-    Tag.find_with_char('v').should == []
-  end
-  
-  it "find_with_char('ba') should return tag bar and bazz" do
-    Tag.find_with_char('ba').sort_by(&:id).should == [tags(:bar), tags(:bazz)].sort_by(&:id)
-  end
-  
-end

data/spec/models/text_filter_spec.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "With the list of available filters" do
-  before(:each) { @filters = TextFilter.available_filters }
-
-  it 'Markdown is an available filter' do
-    @filters.should include(Typo::Textfilter::Markdown)
-  end
-
-  it 'Smartypants is available' do
-    @filters.should include(Typo::Textfilter::Smartypants)
-  end
-
-  it 'Htmlfilter is available' do
-    @filters.should include(Typo::Textfilter::Htmlfilter)
-  end
-
-  it 'Textile is available' do
-    @filters.should include(Typo::Textfilter::Textile)
-  end
-
-  it 'Flickr is available' do
-    @filters.should include(Typo::Textfilter::Flickr)
-  end
-
-  it 'TextFilterPlugin::Markup should be unavailable' do
-    @filters.should_not include(TextFilterPlugin::Markup)
-  end
-
-  it 'TextFilterPlugin::Macro should be unavailable' do
-    @filters.should_not include(TextFilterPlugin::Macro)
-  end
-
-end

data/spec/models/theme_spec.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'Given a new test theme' do
-  before(:each) do
-    @theme = Theme.new("test", "test")
-  end
-
-  it 'layout path should be "#{RAILS_ROOT}/themes/test/layouts/default.html.erb"'  do
-    @theme.layout('index').should == "#{RAILS_ROOT}/themes/test/layouts/default.html.erb"
-  end  
-end
-
-describe 'Given the default theme' do
-  before(:each) do
-    @theme = Blog.default.current_theme
-  end
-
-  it 'theme should be typographic' do
-    @theme.name.should == 'typographic'
-  end
-
-  it 'theme description should be correct' do
-    @theme.description.should ==
-      File.open(RAILS_ROOT + '/themes/typographic/about.markdown') {|f| f.read}
-  end
-
-  it 'theme_from_path should find the correct theme' do
-    Theme.theme_from_path(RAILS_ROOT + 'themes/typographic').name.should == 'typographic'
-    Theme.theme_from_path(RAILS_ROOT + 'themes/scribbish').name.should == 'scribbish'
-  end
-
-  it '#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 i-have-special-chars typographic }
-  end
-
-  it '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

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Trackback, 'With the various trackback filters loaded and DNS mocked out appropriately' do
-  before(:each) do
-    IPSocket.stub!(:getaddress).and_return { raise SocketError.new("getaddrinfo: Name or service not known") }
-    @blog = Blog.default
-    @blog.sp_global = true
-    @blog.default_moderate_comments = false
-    @blog.save!
-  end
-
-  it 'Incomplete trackbacks should not be accepted' do
-    tb = Trackback.new(:blog_name => 'Blog name', 
-                       :title => 'Title', 
-                       :excerpt => 'Excerpt',
-                       :article_id => contents(:article1).id)
-    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
-
-  it '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
-
-  it '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
-
-  it '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
-
-  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',
-      :blog => @blog }
-  end
-end

data/spec/models/trigger_spec.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'With the contents fixture' do
-  before(:each) do
-    @page = mock('fake_page')
-    @page.stub!(:id).and_return(1)
-    @page.stub!(:type).and_return('Page')
-    @page.stub!(:new_record?).and_return(false)
-    @page.stub!(:class).and_return(Page)
-    @page.stub!(:destroyed?).and_return(false)
-    Content.stub!(:find).and_return(@page)
-    @current_utime = 1
-    Time.stub!(:now).and_return { Time.at(@current_utime) }
-  end
-
-  def sleep(time_delta)
-    @current_utime += time_delta
-  end
-
-  it '.post_action should not fire immediately for future triggers' do
-    lambda do
-      Trigger.post_action(Time.now + 2, @page, 'tickle')
-      Trigger.count.should == 1
-      Trigger.fire
-      Trigger.count.should == 1
-    end.should_not raise_error
-
-    @page.should_receive(:tickle)
-    sleep 2
-    Trigger.fire
-    Trigger.count.should == 0
-  end
-
-  it '.post_action should fire immediately if the target time is <= now' do
-    @page.should_receive(:tickle)
-    Trigger.post_action(Time.now, @page, 'tickle')
-    Trigger.count.should == 0
-  end
-
-end

data/spec/models/user_spec.rb

@@ -1,198 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe User do
-  describe 'Factory Girl' do
-    it 'should user factory valid' do
-      Factory.create(:user).should be_valid
-      Factory.build(:user).should be_valid
-    end
-    it 'should multiple user factory valid' do
-      Factory.create(:user).should be_valid
-      Factory.create(:user).should be_valid
-    end
-  end
-end
-
-describe 'With the contents and users fixtures loaded' do
-  before(:each) do
-    User.stub!(:salt).and_return('change-me')
-  end
-
-  it 'Calling User.authenticate with a valid user/password combo returns a user' do
-    User.authenticate('bob', 'test').should == users(:bob)
-  end
-
-  it 'User.authenticate(user,invalid) returns nil' do
-    User.authenticate('bob', 'wrong password').should be_nil
-  end
-
-  it 'User.authenticate(inactive,valid) returns nil' do
-    User.authenticate('inactive', 'longtest').should be_nil
-  end
-
-  it 'User.authenticate(invalid,whatever) returns nil' do
-    User.authenticate('userwhodoesnotexist', 'what ever').should be_nil
-  end
-
-  it 'The various article finders work appropriately' do
-    users(:tobi).articles.size.should == 8
-#    User.find(1).articles.find_published.size.should == Article.find(:all, :conditions => {:published => true}).size
-    users(:tobi).articles.published.size.should == 7
-  end
-
-  it 'authenticate? works as expected' do
-    User.should be_authenticate('bob', 'test')
-    User.should_not be_authenticate('bob', 'duff password')
-  end
-end
-
-describe 'With a new user' do
-  before(:each) do
-    @user = User.new :login => 'not_bob'
-    @user.email = 'typo@typo.com'
-    set_password 'a secure password'
-  end
-
-  describe "the password" do
-    it 'can be just right' do
-      set_password 'Just right'
-      @user.should be_valid
-    end
-
-    { 'too short' => 'x',
-      'too long' => 'repetitivepass' * 10,
-      'empty' => ''
-    }.each do |problematic, password|
-      it "cannot be #{problematic}" do
-        set_password password
-        @user.should_not be_valid
-        @user.errors.should be_invalid('password')
-      end
-    end
-
-    it "has to match confirmation" do
-      @user.password = "foo"
-      @user.password_confirmation = "bar"
-      @user.should_not be_valid
-      @user.errors.should be_invalid('password')
-    end
-  end
-
-  describe 'the login' do
-    it 'can be just right' do
-      @user.login = 'okbob'
-      @user.should be_valid
-    end
-
-    { 'too short' => 'x',
-      'too long' => 'repetitivepass' * 10,
-      'empty' => ''
-    }.each do |problematic, login|
-      it "cannot be #{problematic}" do
-        @user.login = login
-        @user.should_not be_valid
-        @user.errors.should be_invalid('login')
-      end
-    end
-  end
-
-  it 'email cannot be blank' do
-    @user.email = ''
-    @user.should_not be_valid
-  end
-
-  def set_password(newpass)
-    @user.password = @user.password_confirmation = newpass
-  end
-end
-
-describe 'With a user in the database' do
-  before(:each) do
-    @olduser = Factory.create(:user)
-  end
-
-  it 'should not be able to create another user with the same login' do
-    login = @olduser.login
-    u = User.new(:login => login) {|u| u.password = u.password_confirmation = 'secure password'}
-
-    u.should_not be_valid
-    u.errors.should be_invalid('login')
-  end
-end
-
-describe 'Updating an existing user' do
-  before(:each) do
-    @user = Factory.create(:user)
-    set_password 'a secure password'
-    @user.save!
-  end
-
-  describe "the password" do
-    { 'just right' => 'Just right',
-      'empty' => ''
-    }.each do |ok, password|
-      it "can be #{ok}" do
-        set_password password
-        @user.should be_valid
-      end
-    end
-
-    { 'too short' => 'x',
-      'too long' => 'repetitivepass' * 10,
-    }.each do |problematic, password|
-      it "cannot be #{problematic}" do
-        set_password password
-        @user.should_not be_valid
-        @user.errors.should be_invalid('password')
-      end
-    end
-
-    it "has to match confirmation" do
-      @user.password = "foo"
-      @user.password_confirmation = "bar"
-      @user.should_not be_valid
-      @user.errors.should be_invalid('password')
-    end
-
-    it "is not actually changed when set to empty" do
-      set_password ''
-      @user.save!
-      User.authenticate(@user.login, '').should be_nil
-      User.authenticate(@user.login, 'a secure password').should == @user
-    end
-  end
-
-  describe "saving twice" do
-    it "should not change the password" do
-      (found = User.authenticate(@user.login, 'a secure password')).should == @user
-      found.save
-      found.save
-      User.authenticate(@user.login, 'a secure password').should == found
-    end
-  end
-
-  describe 'the login' do
-    it 'must not change' do
-      @user.login = 'not_bob'
-      @user.should_not be_valid
-    end
-  end
-
-  def set_password(newpass)
-    @user.password = @user.password_confirmation = newpass
-  end
-end
-
-describe User do
-  describe '#admin?' do
-
-    it 'should return true if user is admin' do
-      users(:tobi).should be_admin
-    end
-
-    it 'should return false if user is not admin' do
-      users(:user_publisher).should_not be_admin
-    end
-
-  end
-end