nate-browsercms 3.0.210

data/test/unit/behaviors/attaching_test.rb

@@ -0,0 +1,355 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:default_attachables) if table_exists?(:default_attachables)
+  drop_table(:default_attachable_versions) if table_exists?(:default_attachable_versions)
+  create_versioned_table(:default_attachables) do |t| 
+    t.string :name
+    t.integer :attachment_id
+    t.integer :attachment_version
+    t.timestamps
+  end
+  
+  drop_table(:attachables) if table_exists?(:attachables)
+  create_table(:attachables) do |t| 
+    t.string :name
+    t.integer :attachment_id
+    t.integer :attachment_version
+    t.timestamps
+  end
+
+  drop_table(:versioned_attachables) if table_exists?(:versioned_attachables)
+  drop_table(:versioned_attachable_versions) if table_exists?(:versioned_attachable_versions)
+  create_versioned_table(:versioned_attachables) do |t| 
+    t.string :name
+    t.integer :attachment_id
+    t.integer :attachment_version
+    t.timestamps
+  end
+  
+  drop_table(:versioned_attachables) if table_exists?(:versioned_attachables)
+  drop_table(:versioned_attachable_versions) if table_exists?(:versioned_attachable_versions)
+  create_versioned_table(:versioned_attachables) do |t| 
+    t.string :name
+    t.integer :attachment_id
+    t.integer :attachment_version
+    t.timestamps
+  end
+  
+end
+
+class DefaultAttachable < ActiveRecord::Base
+  acts_as_content_block :belongs_to_attachment => true
+end
+
+class Attachable < ActiveRecord::Base
+  belongs_to_attachment
+  
+  def set_attachment_file_path
+    if @attachment_file_path && @attachment_file_path != attachment.file_path
+      attachment.file_path = @attachment_file_path
+    end
+  end
+
+  def set_attachment_section
+    if @attachment_section_id && @attachment_section_id != attachment.section_id
+      attachment.section_id = @attachment_section_id 
+    end
+  end  
+end
+
+class VersionedAttachable < ActiveRecord::Base
+  acts_as_content_block :belongs_to_attachment => true
+  
+  def set_attachment_file_path
+    if @attachment_file_path && @attachment_file_path != attachment.file_path
+      attachment.file_path = @attachment_file_path
+    end
+  end
+
+  def set_attachment_section
+    if @attachment_section_id && @attachment_section_id != attachment.section_id
+      attachment.section_id = @attachment_section_id 
+    end
+  end
+end
+
+class DefaultAttachableTest < ActiveSupport::TestCase
+  def setup
+    #file is a mock of the object that Rails wraps file uploads in
+    @file = file_upload_object(:original_filename => "foo.jpg",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "01010010101010101")
+
+    @section = root_section
+  end
+  
+  def test_create_with_attachment_file
+    @attachable = DefaultAttachable.new(:name => "File Name", 
+      :attachment_file => @file, :publish_on_save => true)
+
+    attachable_count = DefaultAttachable.count
+
+    assert_valid @attachable
+    @attachable.save!
+
+    assert_incremented attachable_count, DefaultAttachable.count
+    assert_equal @section, @attachable.attachment_section
+    assert_equal @section.id, @attachable.attachment_section_id
+    assert_equal "/attachments/foo.jpg", @attachable.attachment_file_path
+
+    reset(:attachable)
+
+    assert_equal @section, @attachable.attachment_section
+    assert_equal @section.id, @attachable.attachment_section_id
+    assert_equal "/attachments/foo.jpg", @attachable.attachment_file_path
+    assert @attachable.attachment.published?
+  end  
+  
+  
+end
+
+class AttachingTest < ActiveSupport::TestCase
+  
+  def test_block_without_attaching_behavior
+    assert !HtmlBlock.belongs_to_attachment?
+  end
+  
+  def test_file_path_sanitization
+    {
+      "Draft #1.txt" => "Draft_1.txt",
+      "Copy of 100% of Paul's Time(1).txt" => "Copy_of_100_of_Pauls_Time-1-.txt"
+    }.each do |example, expected|
+      assert_equal expected, 
+        Attachable.new.sanitize_file_path(example)
+    end
+  end
+  
+end
+
+class AttachableTest < ActiveSupport::TestCase
+  def setup
+    #file is a mock of the object that Rails wraps file uploads in
+    @file = file_upload_object(:original_filename => "foo.jpg",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "01010010101010101")
+
+    @section = Factory(:section, :name => "attachables", :parent => root_section)    
+  end
+  
+  def test_create_with_attachment_section_id_attachment_file_and_attachment_file_path
+    @attachable = Attachable.new(:name => "Section ID, File and File Name", 
+      :attachment_section_id => @section.id, 
+      :attachment_file => @file, 
+      :attachment_file_path => "test.jpg")
+
+    assert_was_saved_properly
+  end  
+  
+  def test_create_with_attachment_section_attachment_file_and_attachment_file_path
+    @attachable = Attachable.new(:name => "Section, File and File Name", 
+     :attachment_section => @section, 
+     :attachment_file => @file, 
+     :attachment_file_path => "test.jpg")
+    
+    assert_was_saved_properly
+  end
+  
+  def test_create_with_an_attachment_section_but_no_attachment_file
+    @attachable = Attachable.new(:name => "Section, No File", 
+      :attachment_section => @section)
+    
+    attachable_count = Attachable.count
+    
+    assert !@attachable.save
+    
+    assert_equal attachable_count, Attachable.count
+    assert_equal @section, @attachable.attachment_section
+    assert_equal @section.id, @attachable.attachment_section_id
+    assert_nil @attachable.attachment_file_path
+  end  
+  
+  def test_create_with_an_attachment_file_but_no_attachment_section
+    @attachable = Attachable.new(:name => "File Name, No File", 
+      :attachment_file_path => "whatever.jpg")
+    
+    attachable_count = Attachable.count
+    
+    assert !@attachable.save
+
+    assert_equal attachable_count, Attachable.count
+    assert_nil @attachable.attachment_section
+    assert_nil @attachable.attachment_section_id
+    assert_equal "whatever.jpg", @attachable.attachment_file_path
+  end  
+  
+  def test_create_screwy_attachment_file_name
+    @attachable = Attachable.new(:name => "Section ID, File and File Name", 
+      :attachment_section_id => @section.id, 
+      :attachment_file => @file, 
+      :attachment_file_path => "Broken? Yes & No!.txt")
+    
+    attachable_count = Attachable.count
+    
+    assert @attachable.save
+
+    assert_incremented attachable_count, Attachable.count
+    assert_equal "/Broken_Yes_-_No.txt", @attachable.attachment_file_path
+  end  
+  
+  def test_updating_the_attachment_file_name
+    @attachable = Attachable.create!(:name => "Foo", 
+      :attachment_section_id => @section.id, 
+      :attachment_file => @file, 
+      :attachment_file_path => "test.jpg")
+    reset(:attachable)
+
+    attachment_count = Attachment.count
+    attachment_version = @attachable.attachment_version
+    attachment_version_count = Attachment::Version.count
+    
+    assert @attachable.update_attributes(:attachment_file_path => "test2.jpg")
+    
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version, @attachable.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_equal "/test2.jpg", @attachable.attachment_file_path
+    
+    reset(:attachable)
+
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version, @attachable.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_equal "/test2.jpg", @attachable.attachment_file_path
+  end  
+  
+  def test_updating_the_attachment_file
+    @attachable = Attachable.create!(:name => "Foo", 
+      :attachment_section_id => @section.id, 
+      :attachment_file => @file, 
+      :attachment_file_path => "test.jpg")
+
+    reset(:attachable)
+
+    @file2 = file_upload_object(:original_filename => "foo.txt",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "Foo v2")        
+
+    attachment_count = Attachment.count
+    attachment_version = @attachable.attachment_version
+    attachment_version_count = Attachment::Version.count
+
+    assert @attachable.update_attributes(:attachment_file => @file2)
+
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version, @attachable.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count    
+    assert_equal @file2.read, open(@attachable.attachment.full_file_location){|f| f.read}
+    
+    reset(:attachable)
+    @file2.rewind
+
+    assert_equal @file.read, open(@attachable.attachment.as_of_version(1).full_file_location){|f| f.read}
+    assert_equal @file2.read, open(@attachable.attachment.as_of_version(2).full_file_location){|f| f.read}
+    
+  end
+  
+  protected
+    def assert_was_saved_properly
+      attachable_count = Attachable.count
+
+      assert @attachable.save
+
+      assert_incremented attachable_count, Attachable.count
+      assert_equal @section, @attachable.attachment_section
+      assert_equal @section.id, @attachable.attachment_section_id
+      assert_equal "/test.jpg", @attachable.attachment_file_path
+
+      reset(:attachable)
+
+      assert_equal @section, @attachable.attachment_section
+      assert_equal @section.id, @attachable.attachment_section_id
+      assert_equal "/test.jpg", @attachable.attachment_file_path      
+    end
+  
+end
+
+class VersionedAttachableTest < ActiveSupport::TestCase
+  def setup
+    #file is a mock of the object that Rails wraps file uploads in
+    @file = file_upload_object(:original_filename => "foo.jpg",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "01010010101010101")
+
+    @section = Factory(:section, :name => "attachables", :parent => root_section)    
+    
+    @attachable = VersionedAttachable.create!(:name => "Foo v1", 
+      :attachment_section_id => @section.id, 
+      :attachment_file => @file, 
+      :attachment_file_path => "test.jpg")
+    reset(:attachable)
+  end
+
+  def test_updating_the_versioned_attachable
+    attachment_count = Attachment.count
+    attachment_version = @attachable.attachment_version
+    attachment_version_count = Attachment::Version.count
+    
+    assert @attachable.update_attributes(:name => "Foo v2")
+    
+    assert_equal attachment_count, Attachment.count
+    assert_equal attachment_version, @attachable.attachment_version
+    assert_equal attachment_version_count, Attachment::Version.count
+    assert_equal "Foo v2", @attachable.name
+    assert_equal @attachable.as_of_version(1).attachment, @attachable.as_of_version(2).attachment
+  end
+  
+  def test_updating_the_versioned_attachable_attachment_file_path
+    attachable_count = VersionedAttachable.count
+    attachment_count = Attachment.count
+    attachment_version = @attachable.attachment_version
+    attachment_version_count = Attachment::Version.count
+
+    assert @attachable.update_attributes(:attachment_file_path => "test2.jpg")
+
+    assert_equal attachable_count, VersionedAttachable.count
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version, @attachable.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_equal "/test2.jpg", @attachable.attachment_file_path
+
+    assert_equal @attachable.as_of_version(1).attachment, @attachable.as_of_version(2).attachment
+    assert_not_equal @attachable.as_of_version(1).attachment_version, @attachable.as_of_version(2).attachment_version
+    assert_equal "/test.jpg", @attachable.as_of_version(1).attachment_file_path
+    assert_equal "/test2.jpg", @attachable.as_of_version(2).attachment_file_path
+  end  
+  
+  def test_updating_the_versioned_attachable_attachment_file
+    @file2 = file_upload_object(:original_filename => "foo.txt",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "Foo v2")
+
+    attachable_count = VersionedAttachable.count
+    attachment_count = Attachment.count
+    attachment_version = @attachable.attachment_version
+    attachment_version_count = Attachment::Version.count
+
+    assert @attachable.update_attributes(:attachment_file => @file2)
+
+    assert_equal attachable_count, VersionedAttachable.count
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version, @attachable.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count
+
+    @file2.rewind
+    assert_equal @file2.read, open(@attachable.attachment.full_file_location){|f| f.read}
+    
+    @file.rewind
+    assert_equal @file.read, open(@attachable.attachment.as_of_version(1).full_file_location){|f| f.read}
+    
+    @file2.rewind
+    assert_equal @file2.read, open(@attachable.attachment.as_of_version(2).full_file_location){|f| f.read}
+  end
+  
+end
+

data/test/unit/behaviors/dynamic_attributes_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:things) if table_exists?(:things)
+  drop_table(:thing_attributes) if table_exists?(:thing_attributes)
+  create_table(:things) do |t| 
+    t.string :name
+    t.timestamps
+  end
+  create_table(:thing_attributes) do |t| 
+    t.integer :thing_id
+    t.string :name
+    t.text :value
+  end
+end
+
+class Thing < ActiveRecord::Base
+  has_dynamic_attributes
+end
+
+class ThingTest < ActiveSupport::TestCase
+  def test_dynamic_attributes
+    assert !User.has_dynamic_attributes?
+    assert Thing.has_dynamic_attributes?
+
+    thing = Thing.new(:foo => "bar")
+    assert_equal "bar", thing.foo
+
+    thing.foo = "Bang"
+    assert_equal "Bang", thing.foo
+
+    assert thing.save
+
+    thing = Thing.find(thing.id)
+    assert_equal "Bang", thing.foo
+    assert_nil thing.bar
+  end
+end

data/test/unit/behaviors/publishable_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:publishables) if table_exists?(:publishables)
+  create_table(:publishables) do |t| 
+    t.string :name
+    t.datetime :published_at
+    t.boolean :published, :default => false
+  end
+  drop_table(:unpublishables) if table_exists?(:unpublishables)
+  create_table(:unpublishables) do |t| 
+    t.string :name
+  end
+end
+
+class Publishable < ActiveRecord::Base
+  is_publishable
+end
+
+class Unpublishable < ActiveRecord::Base
+end
+
+class PublishableTestCase < ActiveSupport::TestCase
+  def test_publishable
+    @object = Publishable.new(:name => "New Record")
+    assert @object.publishable?
+  end
+  
+  def test_save
+    @object = Publishable.new(:name => "New Record")
+    assert @object.save
+    assert !@object.published?
+    assert_nil @object.published_at
+  end
+
+  def test_publish_on_save
+    @object = Publishable.new(:name => "New Record")
+    @object.publish_on_save = true
+    assert @object.save
+    assert @object.published?
+    assert @object.published_at <= Time.now
+  end
+
+  def test_published_at_does_not_change
+    @object = Publishable.create(:name => "New Record")
+    @published_at = 5.minutes.ago
+    assert @object.update_attributes(:published_at => @published_at, :publish_on_save => true)
+    assert_equal @published_at, @object.published_at
+    assert @object.update_attributes(:name => "Changed", :publish_on_save => true)
+    assert_equal @published_at, @object.published_at
+  end
+  
+  def test_unpublishable
+    @object = Unpublishable.new(:name => "New Record")
+    assert !@object.publishable?
+    assert @object.save
+    assert !@object.publishable?
+  end
+  
+  def test_not_publishable_if_connect_to_page_id_is_blank
+    assert HtmlBlock.new(:connect_to_page_id => "").publishable?
+  end
+  
+end

data/test/unit/behaviors/searching_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:searchable_content_block_parents) if table_exists?(:searchable_content_block_parents)  
+  create_table(:searchable_content_block_parents) {|t| t.string :name }
+  drop_table(:searchable_content_blocks) if table_exists?(:searchable_content_blocks)
+  drop_table(:searchable_content_block_versions) if table_exists?(:searchable_content_block_versions)
+  create_versioned_table(:searchable_content_blocks) do |t| 
+    t.integer :parent_id
+    t.string :name 
+    t.boolean :deleted, :default => 0
+    t.integer :created_by
+    t.integer :updated_by
+    t.timestamps
+  end
+end
+
+class SearchableContentBlockParent < ActiveRecord::Base
+  has_many :children, :class_name => "SearchableContentBlock", :foreign_key => "parent_id" 
+end
+
+class SearchableContentBlock < ActiveRecord::Base
+  acts_as_content_block
+  belongs_to :parent, :class_name => "SearchableContentBlockParent"
+  named_scope :created_after, lambda{|time| {:conditions => ["created_at > ?", time]}}
+end
+
+class SearchableContentBlockTest < ActiveSupport::TestCase
+  def test_searchable
+    @parent = SearchableContentBlockParent.create!(:name => "Papa")
+    @a1 = @parent.children.create!(:name => "a1")
+    @a2 = @parent.children.create!(:name => "a2")
+    @b1 = @parent.children.create!(:name => "b1")
+    @b2 = @parent.children.create!(:name => "b2")
+
+    assert SearchableContentBlock.searchable?
+    assert_equal [@a1, @a2], SearchableContentBlock.search("a").all
+    assert_equal [@a2, @a1], SearchableContentBlock.search(:term => "a", :order => "id desc").all
+    assert_equal [@a2, @a1], SearchableContentBlock.created_after(1.hour.ago).search(:term => "a", :order => "id desc").all
+    assert_equal [@a2, @a1], @parent.children.created_after(1.hour.ago).search(:term => "a", :order => "id desc").all
+  end
+end
+
+class SearchableHtmlBlockTest < ActiveSupport::TestCase
+  def test_searchable
+    @a1 = Factory(:html_block, :name => "a1", :content => "a one")
+    @a2 = Factory(:html_block, :name => "a2", :content => "a two")
+    @b1 = Factory(:html_block, :name => "b1", :content => "b one")
+    @b2 = Factory(:html_block, :name => "b2", :content => "b two")
+
+    assert HtmlBlock.searchable?
+    assert_equal [@a2, @b2], HtmlBlock.search("2").all
+    assert HtmlBlock.search(:term => "one").all.empty?
+    assert_equal [@a1, @b1], HtmlBlock.search(:term => "one", :include_body => true).all
+    assert HtmlBlock.search(nil).include?(@b2)
+  end
+end

data/test/unit/behaviors/taggable_test.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:taggable_articles) if table_exists?(:taggable_articles)
+  create_table(:taggable_articles) {|t| t.string :name }
+
+  drop_table(:versioned_taggable_articles) if table_exists?(:versioned_taggable_articles)
+  drop_table(:versioned_taggable_article_versions) if table_exists?(:versioned_taggable_article_versions)
+  create_versioned_table(:versioned_taggable_articles) do |t| 
+    t.string :name
+  end
+end
+
+class TaggableArticle < ActiveRecord::Base
+  is_taggable
+end
+
+class VersionedTaggableArticle < ActiveRecord::Base
+  acts_as_content_block :taggable => true
+end
+
+class TaggableBlockTest < ActiveSupport::TestCase
+  def test_tagging
+    article = TaggableArticle.create!(:name => "foo")
+    assert_equal 0, article.taggings.count
+    assert_equal 0, article.tags.count
+    assert_equal 0, Tag.count
+    assert_equal 0, Tagging.count
+
+    article.tag_list = "foo bar"
+    assert article.save
+    assert_equal 2, article.taggings.count
+    assert_equal 2, article.tags.count
+    assert_equal 2, Tag.count
+    assert_equal 2, Tagging.count
+    
+    assert_equal [article], TaggableArticle.tagged_with("foo").all
+    assert_equal [article], TaggableArticle.tagged_with("bar").all
+    assert TaggableArticle.tagged_with("bang").all.empty?
+        
+    article.tag_list = "foo bang"
+    assert article.save
+    assert_equal 2, article.taggings.count
+    assert_equal 2, article.tags.count
+    assert_equal 3, Tag.count
+    assert_equal 2, Tagging.count
+
+    assert_equal [article], TaggableArticle.tagged_with("foo").all
+    assert_equal [article], TaggableArticle.tagged_with("bang").all
+    assert TaggableArticle.tagged_with("bar").all.empty?
+    
+    assert_equal "bang foo", article.tag_list
+  end
+  
+  def test_tag_cloud
+    25.times do |n|
+      tag_list = ["article"]
+      tag_list << "first" if n == 0
+      tag_list << "even" if n.even?
+      tag_list << "five" if n % 5 == 0
+      tag_list << "last" if n == 24
+      TaggableArticle.create!(:name => "Article ##{n}", :tag_list => tag_list.join(" ") )
+    end
+    
+    tag_counts = Tag.counts(:limit => 4)
+    assert_equal 4, tag_counts.size
+    assert_equal Tag.find_by_name("article"), tag_counts[0]
+    assert_equal "25", tag_counts[0].count
+    assert_equal Tag.find_by_name("even"), tag_counts[1]
+    assert_equal "13", tag_counts[1].count
+    assert_equal Tag.find_by_name("five"), tag_counts[2]
+    assert_equal "5", tag_counts[2].count
+    assert_equal Tag.find_by_name("first"), tag_counts[3]
+    assert_equal "1", tag_counts[3].count
+    
+    tag_cloud = Tag.cloud(:sizes => 9)
+    assert_equal 5, tag_cloud.size
+    assert_equal Tag.find_by_name("article"), tag_cloud[0]
+    assert_equal 6, tag_cloud[0].size
+    assert_equal Tag.find_by_name("even"), tag_cloud[1]
+    assert_equal 3, tag_cloud[1].size
+    assert_equal Tag.find_by_name("five"), tag_cloud[2]
+    assert_equal 1, tag_cloud[2].size
+    assert_equal Tag.find_by_name("first"), tag_cloud[3]
+    assert_equal 0, tag_cloud[3].size
+    assert_equal Tag.find_by_name("last"), tag_cloud[4]
+    assert_equal 0, tag_cloud[4].size
+  end
+  
+end

data/test/unit/extensions/active_record/base_test.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '/../../../test_helper')
+
+class ActiveRecord::BaseTest < ActiveSupport::TestCase
+  def test_updated_on_string
+    base = HtmlBlock.new
+    assert_nil base.updated_on_string
+    base.updated_at = Time.zone.parse("1978-07-06")
+    assert_equal "Jul 6, 1978", base.updated_on_string
+  end
+end

data/test/unit/extensions/hash_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class HashTest < ActiveSupport::TestCase
+  def test_except
+    x = {:a => 1, :b => 2}
+    assert_equal({:b => 2}, x.except(:a))
+    assert_equal({:a => 1, :b => 2}, x)
+  end
+  
+  def test_extract!
+    x = {:a => 1, :b => 2}
+    y = x.extract!(:b, :c)
+    assert_equal({:a => 1}, x)
+    assert_equal({:b => 2}, y)
+  end
+  
+end

data/test/unit/extensions/integer_test.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class IntegerTest < ActiveSupport::TestCase
+  def test_round_bytes
+    assert_equal "99.44 MB", (99.megabytes + 450.kilobytes).round_bytes
+    assert_equal "12.04 KB", (12.kilobytes + 45).round_bytes
+    assert_equal "999 bytes", 999.round_bytes
+    assert_equal "0 bytes", nil.round_bytes
+  end
+end

data/test/unit/helpers/application_helper_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class Cms::ApplicationHelperTest < ActionView::TestCase
+  
+  def test_url_with_mode
+    [
+      [["http://localhost:3000", "edit"], "?mode=edit"],
+      [["http://localhost:3000/", "edit"], "/?mode=edit"],
+      [["http://localhost:3000/foo", "edit"], "/foo?mode=edit"],
+      [["http://localhost:3000/foo?bar=1", "edit"], "/foo?bar=1&mode=edit"],
+      [["http://localhost:3000/foo?mode=view", "edit"], "/foo?mode=edit"],
+      [["http://localhost:3000/foo?bar=1&mode=view", "edit"], "/foo?bar=1&mode=edit"],
+      [["http://localhost:3000/foo?other_mode=1&mode=view", "edit"], "/foo?other_mode=1&mode=edit"],
+      [["/foo?other_mode=1&mode=view", "edit"], "/foo?other_mode=1&mode=edit"]
+    ].each do |args, expected|
+      assert_equal expected, url_with_mode(*args)
+    end
+  end
+  
+  def test_determine_order
+    assert_equal "foo", determine_order("foo desc", "foo desc")
+    assert_equal "foo", determine_order("foo desc", "foo")
+    assert_equal "foo desc", determine_order("foo", "foo desc")
+    assert_equal "foo desc", determine_order("foo", "foo")
+    assert_equal "bar desc", determine_order("foo", "bar desc")
+    assert_equal "bar", determine_order("foo", "bar")
+  end
+  
+end