skylinecms 3.0.8 → 3.1.0

data/test/integration/user_preferences_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+require 'user_access_helper'
+
+class UserPreferencesTest < ActionController::IntegrationTest
+  include UserAccessHelper
+  context "User preferences" do
+    setup do
+       @user = Factory(:user)
+       @user.force_password!("qwedsa")
+       
+       @user.user_preferences << Factory(:user_preference, :key => "a.", :encoded_value => 1.to_yaml)
+       
+       @u = login(@user,"qwedsa")
+    end
+    
+    should "be stored in a cookie with value and sent on request" do
+      @u.cookies["skyline_up"] = CGI::escape(ActiveSupport::JSON.encode({"my_field" => "a.email@address.com"}))
+      @u.get "/skyline"
+      @u.assert_equal('a.email@address.com', @user.user_preferences.get('my_field'))
+    end
+    
+    should "be stored in a cookie with serialized hash and sent on request" do
+      up_my_hash = {'a' => 1, 'b' => 2}
+      @u.cookies["skyline_up"] = CGI::escape(ActiveSupport::JSON.encode({"my_hash" => up_my_hash}))
+      @u.get "/skyline"
+      @u.assert_equal(up_my_hash, @user.user_preferences.get('my_hash'))
+    end
+
+    should "be able to collect multiple values and send after request" do
+      @u.cookies["skyline_up"] = CGI::escape(ActiveSupport::JSON.encode({"my_field" => "a.email@address.com", "my_hash" => {'a' => 1, 'b' => 2}}))
+      @u.get "/skyline"  
+      @u.assert_equal({'a' => 1, 'b' => 2}, @user.user_preferences.get('my_hash'))
+      @u.assert_equal('a.email@address.com', @user.user_preferences.get('my_field'))
+    end
+    
+    should "have empty value in cookie after request" do
+      @u.cookies["skyline_up"] = CGI::escape(ActiveSupport::JSON.encode({"my_field" => "a.email@address.com"}))
+      @u.cookies["my_own_field"] = "Do not delete me"
+      
+      @u.get "/skyline"
+          
+      @u.assert("", cookies["skyline_up"])
+      @u.assert("Do not delete me", cookies["my_own_field"])
+    end
+    
+    should "be able to be set through controller" do
+      @u.post "skyline/user_preferences",
+            'skyline_up' => ActiveSupport::JSON.encode({"my_hash" => {"a" => 1, "b" => 2}})
+                    
+      @u.assert_equal({'a' => 1, 'b' => 2}, @user.user_preferences.get('my_hash'))     
+    end
+    
+    should "be able to delete through controller" do
+      @u.assert @user.user_preferences.has_key?("a")
+      @u.post "skyline/user_preferences", 
+            'skyline_up' => ActiveSupport::JSON.encode({"a" => "_delete"})
+                    
+      @u.assert !@user.user_preferences.has_key?("a")
+    end
+    
+    should "store delete value in cookie and handle correctly" do
+      @u.assert @user.user_preferences.has_key?("a")
+      @u.cookies["skyline_up"] = CGI::escape(ActiveSupport::JSON.encode({"_delete" => ["a","b"]}))
+      
+      @u.get "/skyline"
+      
+      @u.assert !@user.user_preferences.has_key?("a")
+      @u.assert !@user.user_preferences.has_key?("b")
+    end
+    
+    
+  end
+end

data/test/mocks/test_content_object.rb

@@ -0,0 +1,32 @@
+class Skyline::TestContentObject < ActiveRecord::Base
+  include Skyline::BelongsToReferable
+   
+  belongs_to_referable :image
+    
+  # before_save :create_object_ref
+  # after_save :update_object_ref
+  # 
+  # belongs_to :image, :class_name => "Skyline::ObjectRef", :foreign_key => :image_id, :dependent => :destroy
+  # 
+  # def image=(image)
+  #   @image = image
+  # end
+  # 
+  # private
+  # def create_object_ref
+  #   unless @image.nil?
+  #     @object_ref = Skyline::ObjectRef.find_or_create_by_id(self.image_id)
+  #     @object_ref.update_attributes(
+  #                         :referable_id =>@image.id,
+  #                         :referable_type =>@image.class.name,
+  #                         :refering_type =>self.class.name,
+  #                         :refering_column_name =>"image_id")
+  #     self.image_id = @object_ref.id if self.image_id.nil?
+  #     self.image = @object_ref
+  #   end    
+  # end
+  # 
+  # def update_object_ref
+  #   Skyline::ObjectRef.update_all({:refering_id => self.id}, "id = #{@object_ref.id}") unless @object_ref.blank?
+  # end
+end

data/test/mocks/test_section.rb

@@ -0,0 +1,22 @@
+class Skyline::TestSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include Skyline::HasManyReferablesIn
+  
+  has_many_referables_in :body_a
+  has_many_referables_in :body_b
+  
+  attr_accessor :fail_validation
+  
+  validate :validate_fail_validation
+  
+  self.table_name = "skyline_test_sections"
+  
+  protected
+  
+  def validate_fail_validation
+    self.errors.add_to_base("FAILED!!") if self.fail_validation == true
+  end
+  
+    
+end
+

data/test/test_helper.rb

@@ -0,0 +1,60 @@
+ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..' 
+require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+require 'test_help'
+# include ActionController::TestProcess
+require 'factories'
+
+SILENT_SEED = true
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  # fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+  
+  #convert [REF:id] tags back to html without specific object
+  def ref_id_convert(value,with_refs=false)
+    refs = Hash[*Skyline::InlineRef.all.map{ |m| [m.id, m]}.flatten]
+        
+    return value unless value.kind_of?(String)
+    v = value.gsub(/\[REF:(\d+)\]/) do |match|
+      i = match[5..-2]
+      refs[i.to_i].to_start_html(with_refs)
+    end
+    
+    outp = v.gsub(/\[\/REF:(\d+)\]/) do |match|
+      i = match[6..-2]
+      refs[i.to_i].to_end_html
+    end
+                  
+  end 
+end

data/test/unit/inline_ref_test.rb

@@ -0,0 +1,195 @@
+require 'test_helper'
+require 'mocks/test_section.rb'
+
+class BogusSection
+  def id; @id ||= 10000; end
+  
+  attr_accessor :body
+end
+
+class TestSectionTest < ActiveSupport::TestCase
+  
+  context "InlineRef class" do
+    setup do
+      @section = BogusSection.new
+    end
+    
+    context "parsing html" do
+            
+      should "create new refs" do
+        html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' />"
+        parsed_html, ids = Skyline::InlineRef.parse_html(html,@section,:body)
+        assert_equal 2, ids.size
+        assert_equal 2,Skyline::InlineRef.count(:conditions => {:refering_id => @section.id, :refering_type => @section.class.name})
+        
+        assert_equal ids,Skyline::InlineRef.all(ids).map(&:id)
+        ids.each do |id|
+          assert parsed_html =~ /\[REF:#{id}\]/
+        end
+      end
+      
+      should "delete unused refs" do
+        html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' />"
+        parsed_html, ids = Skyline::InlineRef.parse_html(html,@section,:body)
+        assert_equal 2, ids.size
+        assert_equal 2,Skyline::InlineRef.count(:conditions => {:refering_id => @section.id, :refering_type => @section.class.name})        
+        assert_equal ids,Skyline::InlineRef.all(ids).map(&:id)        
+
+        new_html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' />"
+        new_parsed_html, new_ids = Skyline::InlineRef.parse_html(new_html,@section,:body)        
+        assert_equal 1, new_ids.size
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => @section.id, :refering_type => @section.class.name})        
+        assert_equal new_ids,Skyline::InlineRef.all(new_ids).map(&:id)
+        assert_equal new_ids,Skyline::InlineRef.all(ids).map(&:id)
+      end
+      
+      should "update existing refs" do
+        html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> bla bla"
+        section = Skyline::TestSection.new(:body_a => html)
+        assert section.save
+        refs_1 = Skyline::InlineRef.all(:conditions => {:refering_id => section.id, :refering_type => section.class.name}).map(&:id)
+        section.body_a = section.body_a(true).gsub("skyline-referable-id='1'","skyline-referable-id='2'")
+        assert section.save
+        refs_2 = Skyline::InlineRef.all(:conditions => {:refering_id => section.id, :refering_type => section.class.name}).map(&:id)
+
+        assert_equal refs_1,refs_2
+      end
+      
+      should "only update it's own refs and replace 'foreign' refs" do
+        html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> bla bla"
+        section_1 = Skyline::TestSection.new(:body_a => html)
+        assert section_1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => section_1.id, :refering_type => section_1.class.name})
+        
+        section_2 = Skyline::TestSection.new(:body_a => section_1.body_a(true))
+        assert section_2.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => section_2.id, :refering_type => section_2.class.name})
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => section_1.id, :refering_type => section_1.class.name})
+        
+        assert_not_equal section_1.body_a(true), section_2.body_a(true)
+      end
+      
+      should "make sure that copying a ref from one field to another doesn't break" do
+        html = "abcdefghi <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> bla bla"
+        s1 = Skyline::TestSection.new(:body_a => html)
+        assert s1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+
+        s1.body_b = s1.body_a(true)
+        assert s1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_b"})        
+      end
+      
+    end
+    
+    context "converting REFS to html" do
+      
+      setup do
+        @html = "a <img src='' skyline-referable-id='1' skyline-referable-type='Skyline::Page' /> <a href='' skyline-referable-id='2' skyline-referable-type='Skyline::Page'>test</a>"
+        @parsed_html, @ref_ids = Skyline::InlineRef.parse_html(@html,@section,:body)
+        assert_equal 2,Skyline::InlineRef.count(:conditions => {:refering_id => @section.id, :refering_type => @section.class.name})                
+      end
+      
+      should "return all refs on #hash_refs_for_object" do
+        refs = Skyline::InlineRef.hash_refs_for_object(@section,:body)
+        assert_equal 2,refs.keys.size
+      end
+      
+    end
+    
+    context "with external links" do 
+      
+      setup do
+        @html = "<a href=\"http://www.google.com\" skyline-referable-type=\"Skyline::ReferableUri\">Link1</a>link1</a> <a href=\"http://www.digitpaint.nl\" skyline-referable-type=\"Skyline::ReferableUri\">link2</a>"
+        
+      end
+      
+      should "create a ReferableUri object for each external link" do 
+        s1 = Skyline::TestSection.new(:body_a => @html)
+        assert s1.save
+        
+        refs = Skyline::InlineRef.all(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        assert_equal 2, refs.size
+        referable_uris = refs.map(&:referable)
+        uris = referable_uris.map(&:uri)
+        
+        assert_equal 2,referable_uris.select{|r| r.kind_of?(Skyline::ReferableUri) }.size
+        assert_equal ["http://www.google.com", "http://www.digitpaint.nl"], uris
+      end
+      
+      should "not break when recovering from a validation" do
+        s1 = Skyline::TestSection.new(:body_a => @html)
+        s1.fail_validation = true
+        
+        assert !s1.save
+        assert_equal 0,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        
+        s2 = Skyline::TestSection.new(:body_a => s1.body_a(true), :id => '')
+        s2.fail_validation = false
+        
+        assert s2.save
+        refs = Skyline::InlineRef.all(:conditions => {:refering_id => s2.id, :refering_type => s2.class.name, :refering_column_name => "body_a"})        
+        assert_equal 2,refs.size
+        
+        referable_uris = refs.map(&:referable)
+        uris = referable_uris.map(&:uri)
+        
+        assert_equal 2,referable_uris.select{|r| r.kind_of?(Skyline::ReferableUri) }.size
+        assert_equal ["http://www.google.com", "http://www.digitpaint.nl"], uris
+        
+      end
+      
+    end
+    
+    
+    context "on an object with callbacks" do
+      
+      should "not fail when after_create does another save" do
+        class TS1 < Skyline::TestSection
+          attr_accessor :skip_extra_save
+          after_create :after_creating
+          def after_creating
+            return if self.skip_extra_save
+            self.skip_extra_save = true            
+            self.save
+          end          
+        end
+        s1 = TS1.new(:body_a => "<a href=\"http://www.google.com\" skyline-referable-type=\"Skyline::ReferableUri\">Link1</a>link1</a>")
+        
+        assert s1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        assert_nothing_raised{ s1.body_a(true) }
+        
+        s1.reload
+        assert s1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        assert_nothing_raised{ s1.body_a(true) }                
+      end
+
+      should "not fail when after_save does another save" do
+        class TS2 < Skyline::TestSection
+          attr_accessor :skip_extra_save
+          after_save :after_saving
+          def after_saving
+            return if self.skip_extra_save
+            self.skip_extra_save = true            
+            self.save
+          end          
+        end
+        s1 = TS2.new(:body_a => "<a href=\"http://www.google.com\" skyline-referable-type=\"Skyline::ReferableUri\">Link1</a>link1</a>")
+        
+        assert s1.save
+        
+        s1.reload
+        assert s1.save
+        assert_equal 1,Skyline::InlineRef.count(:conditions => {:refering_id => s1.id, :refering_type => s1.class.name, :refering_column_name => "body_a"})
+        assert_nothing_raised{ s1.body_a(true) }                      
+      end
+
+      
+    end
+    
+  end
+  
+end

data/test/unit/locales_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class Skyline::LocalesTest < ActiveSupport::TestCase
+  context "The locale files" do
+    setup do
+      @original_load_path = I18n.load_path.dup
+      @origignal_locale = I18n.locale
+      I18n.load_path = I18n.load_path.select{|p| (p =~ /vendor\/plugins\/skyline/)}
+      I18n.backend = I18n::Backend::Simple.new
+      
+      @standard_locale = :"nl-NL"
+      @other_locales = I18n.available_locales.select{|l| l.to_s =~ /^[a-z]{2}-[A-Z]{2}$/}
+      @other_locales -= [@standard_locale]
+    end
+
+    should "should all have all entries" do
+      I18n.locale = @standard_locale
+      standard = I18n.translate("")
+      
+      @other_locales.each do |l|
+        I18n.locale = l
+        other = I18n.translate("")
+        
+        missing_keys = differences(standard, other)
+        if missing_keys.any?
+          puts "\n" + "-" * 80
+          puts "\nMissing translations in language file: #{l.to_s}"
+          print_differences(missing_keys)
+          puts "\n\n1: one entry is missing"
+          puts "*: complete subtree is missing"
+          puts "\n" + "-" * 80
+        end
+        assert_equal missing_keys.size, 0
+
+        missing_keys = differences(other, standard)
+        if missing_keys.any?
+          puts "\n" + "-" * 80
+          puts "\nObsolete translations in language file: #{l.to_s}"
+          print_differences(missing_keys)
+          puts "\n\n1: one entry is obsolete"
+          puts "*: complete subtree is obsolete"
+          puts "\n" + "-" * 80
+        end
+        assert_equal missing_keys.size, 0
+      end
+    end            
+    
+    teardown do
+      I18n.load_path = @original_load_path
+      I18n.backend = I18n::Backend::Simple.new
+      I18n.locale = @origignal_locale
+    end
+  end
+
+  def differences(standard, other)
+    missing = {}
+    standard.keys.each do |k|
+      if standard[k].kind_of?(Hash)
+        if other[k]
+          d = differences(standard[k], other[k])
+          missing[k] = d if d.any?
+        else
+          missing[k] = "*"
+        end
+      else
+        missing[k] = "1" unless other.keys.include?(k)
+      end
+    end        
+    missing
+  end
+  
+  def print_differences(missing_keys, indent = 2)
+    missing_keys.each do |k, v|
+      if v.kind_of?(String)
+        puts v + " " * indent + k.inspect
+      else
+        puts " " + " " * indent + k.inspect
+        print_differences(v, indent + 2)
+      end
+    end
+  end
+end

data/test/unit/page_test.rb

@@ -0,0 +1,204 @@
+require 'test_helper'
+
+class Skyline::PageTest < ActiveSupport::TestCase
+  context "A new page" do
+    setup do
+      @page = Factory(:page)
+      assert !@page.new_record?      
+    end
+
+    should "have one variant" do
+      assert_equal 1, @page.variants.size
+    end            
+  end
+      
+  context "A page" do
+    setup do
+      @page = Factory(:page)
+      assert !@page.new_record?      
+      
+      @variant = @page.variants.first
+      @section_a = @variant.sections.create
+      @section_b = @variant.sections.create
+      @section_c = @variant.sections.create
+      
+      @section_a.sectionable = Factory(:wysiwyg_section, :body => "Hallo, dit is de body")
+      @section_b.sectionable = Factory(:wysiwyg_section, :body => "Tweede sectie!")
+      @section_c.sectionable = Factory(:rss_section, :url => "http://www.google.nl/x.rss", :show_count => 1)
+      
+      @section_a.save
+      @section_b.save
+      @section_c.save
+      
+      @variant.reload
+    end
+
+    should "have 3 sections when 3 sections are created" do
+      assert_equal 3, @page.variants.first.sections.size
+    end
+    
+    should "not be publishable when its not saved" do 
+      @variant.data.url_part = "test"
+      assert_raise(StandardError) {@variant.publish}
+    end
+    
+    should "be publishable" do
+      @variant.data.url_part = "test"
+      @variant.save
+      assert published_publication = @variant.publish
+      
+      assert_not_equal published_publication, @variant
+      
+      # published publication should have its own sections
+      assert_equal [], published_publication.sections.collect{|s| s.id} & @variant.sections.collect{|s| s.id}   
+      
+      # published publication should have its own sectionables
+      assert_equal [], published_publication.sections.collect{|s| s.sectionable.id} & @variant.sections.collect{|s| s.sectionable.id} 
+    end
+    
+    should "should reference the published publication via .published_publication" do
+      @variant.data.url_part = "test"
+      @variant.save
+      publised_publication = @variant.publish
+      
+      assert_equal publised_publication, @variant.page.published_publication
+      assert_equal publised_publication.variant, @variant
+    end
+    
+    should "should always keep the variant of a published publication" do
+      @variant.data.url_part = "test"
+      @variant.save
+      publised_publication = @variant.publish
+      
+      assert_raise(StandardError) {@variant.destroy}
+    end
+    
+    should "be destroyed when the last variant is destroyed" do
+      assert !@variant.page.frozen?
+      @variant.destroy
+      assert @variant.page.frozen?
+    end
+    
+    should "have the published variant know its the published variant" do
+      @variant.data.url_part = "test"
+      @variant.save      
+      @variant.publish
+      assert @variant.published_variant?
+    end
+    
+    should "have the published variant know whether is has been modified" do
+      @variant.attributes = {:data_attributes => {:class => @variant.article.data_class.name, :url_part => "test"}}
+      @variant.save      
+      @variant.reload
+       
+      @variant.publish
+      assert_equal true, @variant.identical_published_variant?
+      @variant.data.custom_title_tag = "testing 123"
+      @variant.save
+      assert_equal false, @variant.identical_published_variant?
+    end
+
+    should "have the published variant know it has been modified when a section is modified via accepts_nested_attributes_for" do
+      @variant.attributes = {:data_attributes => {:class => @variant.article.data_class.name, :url_part => "test"}}
+      @variant.save      
+      @variant.reload
+      
+      @variant.publish
+
+      assert_equal true, @variant.identical_published_variant?
+      @variant.attributes = {"sections_attributes" => {1 => {'id' => @section_a.id, 'sectionable_attributes' => {'id' => @section_a.sectionable_id, 'body' => 'pino'}}}}
+      @variant.save
+      assert_equal false, @variant.identical_published_variant?
+    end
+    
+    should "be able to rollback a publication" do
+      assert_equal [@variant], @variant.page.variants(true)
+      
+      @variant.data.url_part = "test"
+      @variant.save      
+      @variant.publish
+
+      assert_equal [@variant], @variant.page.variants(true)
+
+      publication = @variant.page.publications(true).first
+      variant = publication.rollback({'name' => "nieuwe variant"})
+      assert_not_equal publication, variant
+      assert_equal "nieuwe variant", variant.name
+      assert_equal publication.data.title, variant.data.title
+      assert_equal publication.version, variant.version
+
+      # @variant.page.variants contains exactly @variant and variant (no matter which order)
+      assert_equal 2, ([@variant, variant] & @variant.page.variants(true)).size
+    end
+    
+    should "let a variant to be saved when a version attribute is set and it matches the current version" do
+      @variant.data.url_part = "test"
+      @variant.version = @variant.version
+      assert @variant.save
+    end
+
+    should "not let a variant to be saved when the actual version is higher than the version of the variant when it was retrieved" do
+      variant_id = @variant.id
+      current_version = @variant.version
+      
+      # bob sends a POST request to save the Variant
+      bobs_variant = Skyline::Variant.find_by_id(variant_id)
+      bobs_variant.attributes = {:version => current_version, :data_attributes => {:class => bobs_variant.article.data_class.name, :url_part => "bob's url_part"}}
+      assert bobs_variant.save
+      
+      # alice's save will fail
+      alices_variant = Skyline::Variant.find_by_id(variant_id)
+      bobs_variant_version = alices_variant.version
+      alices_variant.attributes = {:version => current_version, :data_attributes => {:class => alices_variant.article.data_class.name, :url_part => "alice's url_part"}}
+      assert !alices_variant.save      
+      
+      # after confirming she really wants to overwrite Bob's changes she can save the Variant by specifying Bob's version number
+      # if someone again edits the Variant between the save and confirmation the same problem and question arrises
+      alices_variant = Skyline::Variant.find(variant_id)
+      alices_variant.attributes = {:version => bobs_variant_version, :data_attributes => {:class => alices_variant.article.data_class.name, :url_part => "alice's url_part"}}
+      assert alices_variant.save
+    end
+    
+    should "return the published variant as default_variant if the page is published" do
+      @variant.data.url_part = "test"
+      @variant.save
+      @variant.publish
+      assert_equal @variant, @variant.page.default_variant
+    end
+
+    should "return the last published variant as default_variant if the page is not published *anymore*" do
+      @variant.attributes = {:data_attributes => {:class => @variant.article.data_class.name, :url_part => "test"}}
+      @variant.save      
+      @variant.reload
+        
+      @variant.publish
+      @variant.page.depublish
+      assert_equal @variant, @variant.page.default_variant(true)
+      
+      new_variant = @variant.clone
+      new_variant.save
+      new_variant.publish
+      
+      new_variant.page.depublish
+
+      @variant.reload
+      assert_equal new_variant, @variant.page.default_variant(true)
+    end
+
+    should "return the last edited variant as default_variant if the page is *never* published" do
+      @variant.attributes = {:data_attributes => {:class => @variant.article.data_class.name, :url_part => "test"}}
+      @variant.save      
+      @variant.reload
+      
+      Skyline::Page.connection.execute("UPDATE skyline_article_versions SET updated_at='2009-01-01' WHERE id=#{@variant.id}")
+      assert_equal @variant, @variant.page.default_variant(true)
+
+      new_variant = @variant.clone
+      new_variant.save
+      
+      @variant.article.set_default_variant!(new_variant)
+      
+      assert_equal new_variant, @variant.page.default_variant(true)
+    end
+  end  
+end