zena 0.15.0

data/test/unit/discussion_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class DiscussionTest < Zena::Unit::TestCase
+
+  def test_comments
+    discussion = Discussion.find(discussions_id(:inside_discussion_on_status))
+    assert_kind_of Discussion, discussion
+    comments = discussion.comments
+    assert_equal 3, comments.size   # only find 'root' comments
+    assert_equal comments_id(:tiger_says_inside), comments[0][:id]
+    assert_equal comments_id(:ant_says_inside),   comments[1][:id]
+    assert_equal comments_id(:lion_says_inside),  comments[2][:id]
+    allcomm = discussion.all_comments
+    assert_equal 4, allcomm.size
+    assert_equal comments_id(:tiger_says_inside),  allcomm[0][:id]
+    assert_equal comments_id(:ant_says_inside),    allcomm[1][:id]
+    assert_equal comments_id(:tiger_reply_inside), allcomm[3][:id]
+  end
+
+  def test_cannot_set_site_id_for_new_record
+    disc = Discussion.new(:site_id=>1234)
+    assert_nil disc.site_id
+  end
+
+  def test_cannot_set_site_id
+    disc = discussions(:inside_discussion_on_status)
+    original_site_id = disc.site_id
+    disc.update_attributes(:site_id =>1234)
+    assert_equal original_site_id, disc.site_id
+  end
+
+  def test_site_id
+    login(:tiger)
+    disc = Discussion.create(:node_id=>nodes_id(:projects))
+    assert !disc.new_record?, "Not a new record"
+    assert_equal sites_id(:zena), disc.site_id
+  end
+
+  context 'A visitor without write access' do
+    setup do
+      login(:anon)
+    end
+
+    context 'on a node without a publication in the current lang' do
+      setup do
+        login(:lion)
+        visitor.lang = 'fr'
+        node = secure!(Node) { nodes(:status) }
+        node.unpublish
+        login(:anon)
+        @node = secure!(Node) { nodes(:status) }
+      end
+
+      should 'see the discussion related to the seen version' do
+        assert_equal discussions_id(:outside_discussion_on_status_en), @node.discussion.id
+      end
+    end
+  end
+end

data/test/unit/document_content_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+class DocumentContentTest < Zena::Unit::TestCase
+
+  def test_site_id
+    without_files('/test.host/data/full') do
+      doc = DocumentContent.create( :version_id=>versions_id(:water_pdf_en), :ext=>'tic', :name=>'abc', :file => uploaded_pdf('forest.pdf') )
+      assert_equal sites_id(:zena), doc.site_id
+    end
+  end
+
+  def test_site_id
+    without_files('/test.host/data/full') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :name=>'report',
+                                                :c_file => uploaded_pdf('water.pdf') ) }
+      assert_kind_of Document , doc
+      content = doc.v_content
+      assert_kind_of DocumentContent, content
+      assert_equal sites_id(:zena), content.site_id
+      assert File.exist?(content.filepath)
+      assert_equal File.stat(content.filepath).size, content.size
+    end
+  end
+
+  def test_cannot_set_site_id
+    without_files('/test.host/data/full') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :name=>'report',
+                                                :c_file => uploaded_pdf('water.pdf') ) }
+
+
+      assert !doc.new_record?, "Not a new record"
+      assert_kind_of Document , doc
+      content = doc.v_content
+      assert_kind_of DocumentContent, content
+      assert_equal sites_id(:zena), content.site_id
+      doc.update_attributes(:site_id   => sites_id(:ocean) )
+      content.update_attributes(:site_id => sites_id(:ocean))
+      assert_equal sites_id(:zena), doc.site_id
+      assert_equal sites_id(:zena), content.site_id
+    end
+  end
+
+  def test_file
+    doc = DocumentContent.new( :file=>uploaded_pdf('water.pdf') )
+    data = nil
+    assert_nothing_raised { data = doc.file }
+    assert_equal data.read, uploaded_pdf('water.pdf').read
+    doc = DocumentContent.new( :version_id=>7, :name => 'hoho', :ext => 'txt' )
+    assert_raise(StandardError) { doc.file } # filepath not set
+  end
+
+  def test_set_size
+    imf = DocumentContent.new
+    assert_raise(StandardError) { imf.size = 34 }
+  end
+
+  def test_filepath_without_version
+    doc = DocumentContent.new( :file=>uploaded_pdf('water.pdf') )
+    assert_raise(StandardError) { doc.filepath }
+  end
+
+  def test_save_file
+    without_files("/test.host/data/full") do
+      doc = document_contents(:water_pdf)
+      doc.file = uploaded_pdf('water.pdf')
+      assert doc.save, "Can save"
+      assert File.exist?(file_path('water.pdf','full',doc[:id]))
+      assert_equal 29279, doc.size
+      doc = DocumentContent.find(doc.id)
+      assert doc.save, "Can save again"
+      doc.file = uploaded_pdf('forest.pdf')
+      assert doc.save, "Can save"
+      assert_equal 63569, doc.size
+    end
+  end
+
+  def test_destroy
+    preserving_files('/test.host/data/full') do
+      doc = DocumentContent.find(document_contents_id(:water_pdf))
+      assert_equal DocumentContent, doc.class
+      assert File.exist?(doc.filepath), "File exist"
+      assert doc.destroy, "Can destroy"
+      assert !File.exist?(doc.filepath), "File does not exist"
+      directory = File.dirname(file_path(:water_pdf))
+      parent_di = File.dirname(directory)
+      assert !File.exist?(directory), "Directory does not exist"
+      assert !File.exist?(parent_di), "Parent directory does not exist"
+    end
+  end
+
+  def test_wrong_file_type
+    preserving_files("/test.host/data/jpg/20") do
+      login(:tiger)
+      node = secure!(Node) { nodes(:bird_jpg) }
+      assert !node.update_attributes(:c_file=>uploaded_pdf('water.pdf'))
+      assert node.errors[:version_content_file]
+    end
+  end
+
+  def test_would_edit
+    doc = document_contents(:bird_jpg)
+    assert doc.would_edit?('file' => uploaded_pdf('water.pdf'))
+    assert !doc.would_edit?('file' => uploaded_pdf('bird.jpg'))
+  end
+
+end

data/test/unit/document_test.rb

@@ -0,0 +1,234 @@
+require 'test_helper'
+require 'fileutils'
+
+class DocumentTest < Zena::Unit::TestCase
+
+  def test_create_with_file
+    without_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :name=>'report',
+                                                :c_file => uploaded_pdf('water.pdf') ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "report", doc.name
+      assert_equal "report", doc.version.title
+      assert_equal "report.pdf", doc.filename
+      assert_equal 'pdf', doc.version.content.ext
+      assert ! doc.version.new_record? , "Version is not a new record"
+      assert_not_nil doc.version.content.id , "Content id is set"
+      assert_kind_of DocumentContent , doc.version.content
+      assert File.exist?(doc.version.content.filepath)
+      assert_equal File.stat(doc.version.content.filepath).size, doc.version.content.size
+    end
+  end
+
+  def test_create_with_bad_filename
+    preserving_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :v_title => 'My new project',
+                                                :c_file => uploaded_pdf('water.pdf', 'stupid.jpg') ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "stupid.pdf", doc.name
+      assert_equal "My new project", doc.version.title
+      v = doc.send :version
+    end
+  end
+
+  def test_create_without_file
+    login(:ant)
+    doc = secure!(Document) { Document.new(:parent_id=>nodes_id(:cleanWater), :name=>'lalala') }
+    assert_kind_of TextDocument, doc
+    assert_equal 'text/plain', doc.version.content.content_type
+    assert doc.save, "Can save"
+  end
+
+  def test_create_with_content_type
+    login(:tiger)
+    doc = secure!(Template) { Template.create("name"=>"Node_tree", "c_content_type"=>"text/css", "c_mode"=>"tree", "c_klass"=>"Node", "v_summary"=>"", "parent_id"=>nodes_id(:default))}
+    assert !doc.kind_of?(Template)
+    assert_kind_of TextDocument, doc
+    assert !doc.new_record?, "Not a new record"
+    assert_equal 'text/css', doc.version.content.content_type
+    assert_equal 'css', doc.version.content.ext
+  end
+
+  def test_create_with_duplicate_name
+    preserving_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:wiki),
+        :v_title => 'bird.jpg',
+        :c_file => uploaded_pdf('bird.jpg') ) }
+        assert_kind_of Document , doc
+        assert_equal 'bird-1', doc.name
+        assert !doc.new_record? , "Saved"
+        assert_equal "bird-1", doc.name
+      end
+  end
+
+  def test_create_with_bad_filename
+    preserving_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+        :name => 'stupid.jpg',
+        :c_file => uploaded_pdf('water.pdf') ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "stupid", doc.name
+      assert_equal "stupid", doc.version.title
+      assert_equal "stupid.pdf", doc.filename
+    end
+  end
+
+  def get_with_full_path
+    login(:tiger)
+    doc = secure!(Document) { Document.find_by_path("/projects/cleanWater/water.pdf") }
+    assert_kind_of Document, doc
+    assert_equal "/projects/cleanWater/water.pdf", doc.fullpath
+  end
+
+  def test_image
+    login(:tiger)
+    doc = secure!(Document) { Document.find( nodes_id(:water_pdf) ) }
+    assert ! doc.image?, 'Not an image'
+    doc = secure!(Document) { Document.find( nodes_id(:bird_jpg) )  }
+    assert doc.image?, 'Is an image'
+  end
+
+  def test_filename
+    login(:tiger)
+    doc = secure!(Node) { nodes(:lake_jpg) }
+    assert_equal 'lake.jpg', doc.filename
+    doc.name = 'test'
+    assert_equal 'test.jpg', doc.filename
+    doc.update_attributes('c_ext' => 'pdf')
+    assert_equal 'test.jpg', doc.filename
+  end
+
+  def test_filesize
+    login(:tiger)
+    doc = secure!(Document) { Document.find( nodes_id(:water_pdf) ) }
+    assert_nothing_raised { doc.version.content.size }
+  end
+
+  def test_create_with_text_file
+    preserving_files('/test.host/data/txt') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+        :name => 'stupid.jpg',
+        :c_file => uploaded_text('some.txt') ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "stupid", doc.name
+      assert_equal "stupid", doc.version.title
+      assert_equal 'txt', doc.version.content.ext
+    end
+  end
+
+  def test_change_file
+    preserving_files('/test.host/data') do
+      login(:tiger)
+      doc = secure!(Document) { Document.find(nodes_id(:water_pdf)) }
+      assert_equal 29279, doc.version.content.size
+      assert_equal file_path(:water_pdf), doc.version.content.filepath
+      content_id = doc.version.content.id
+      # new redaction in 'en'
+      assert doc.update_attributes(:c_file=>uploaded_pdf('forest.pdf'), :v_title=>'forest gump'), "Can change file"
+      assert_not_equal content_id, doc.version.content.id
+      assert !doc.version.content.new_record?
+      doc = secure!(Node) { nodes(:water_pdf) }
+      assert_equal 'forest gump', doc.version.title
+      assert_equal 'pdf', doc.version.content.ext
+      assert_equal 63569, doc.version.content.size
+      last_id = Version.find(:first, :order=>"id DESC").id
+      assert_not_equal versions_id(:water_pdf_en), last_id
+      # filepath is set from initial node name
+      assert_equal file_path('water.pdf', 'full', doc.version.content.id), doc.version.content.filepath
+      assert doc.update_attributes(:c_file=>uploaded_pdf('water.pdf')), "Can change file"
+      doc = secure!(Node) { nodes(:water_pdf) }
+      assert_equal 'forest gump', doc.version.title
+      assert_equal 'pdf', doc.version.content.ext
+      assert_equal 29279, doc.version.content.size
+      assert_equal file_path('water.pdf', 'full', doc.version.content.id), doc.version.content.filepath
+    end
+  end
+
+
+  def test_create_with_file_name_has_dots
+    without_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :name=>'report...',
+                                                :c_file => uploaded_pdf('water.pdf') ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "report...", doc.name
+      assert_equal "report...", doc.version.title
+      assert_equal 'report', doc.version.content.name
+      assert_equal "report....pdf", doc.filename
+      assert_equal 'pdf', doc.version.content.ext
+    end
+  end
+
+  def test_create_with_file_name_unknown_ext
+    without_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :c_file  => uploaded_file("some.txt", 'application/octet-stream', "super.zz") ) }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "super", doc.name
+      assert_equal "super", doc.version.title
+      assert_equal 'super', doc.version.content.name
+      assert_equal "super.zz", doc.filename
+      assert_equal 'zz', doc.version.content.ext
+      assert_equal 'application/octet-stream', doc.version.content.content_type
+    end
+  end
+
+  def test_destroy_many_versions
+    preserving_files('/test.host/data') do
+      login(:tiger)
+      doc = secure!(Node) { nodes(:water_pdf) }
+      filepath = doc.version.content.filepath
+      assert File.exist?(filepath), "File path #{filepath.inspect} exists"
+      first = doc.version.number
+      content_id = doc.version.content.id
+      assert doc.update_attributes(:v_title => 'WahWah')
+      second = doc.version.number
+      assert first != second
+      assert_equal content_id, doc.version.content.id # shared content
+      doc = secure!(Node) { nodes(:water_pdf) }
+      doc.version(first)
+      assert doc.unpublish
+      assert doc.can_destroy_version?
+      assert doc.destroy_version
+      doc = secure!(Node) { nodes(:water_pdf) }
+      assert File.exist?(filepath)
+      assert_equal content_id, doc.version.content.id # shared content note destroyed
+      assert doc.remove
+      assert doc.destroy_version
+      assert_nil DocumentContent.find_by_id(content_id)
+      assert ! File.exist?(filepath)
+    end
+  end
+
+  def test_set_v_title
+    without_files('/test.host/data') do
+      login(:ant)
+      doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
+                                                :c_file  => uploaded_file('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
+      assert_kind_of Document , doc
+      assert ! doc.new_record? , "Not a new record"
+      assert_equal "lazyWaters", doc.name
+      assert_equal "lazy waters", doc.version.title
+      assert_equal 'lazyWaters', doc.version.content.name
+      assert_equal "lazyWaters.pdf", doc.filename
+      assert_equal 'pdf', doc.version.content.ext
+      assert_equal 'application/pdf', doc.version.content.content_type
+    end
+  end
+
+end

data/test/unit/document_version_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class DocumentVersionTest < Zena::Unit::TestCase
+
+  def test_content
+    v = versions(:water_pdf_en)
+    assert_equal DocumentContent, v.content_class
+    assert_kind_of DocumentContent, v.content
+    assert_equal 'water', v.content.name
+  end
+end

data/test/unit/dyn_attributes_test.rb

@@ -0,0 +1,229 @@
+require 'test_helper'
+
+class DynDummy < ActiveRecord::Base
+  before_save :set_dummy_node_id
+  set_table_name 'versions'
+  include Zena::Use::DynAttributes::ModelMethods
+  dynamic_attributes_setup :nested_alias => {%r{^d_(\w+)} => ['dyn']}
+
+  def set_dummy_node_id
+    self[:node_id] = 0
+    self[:user_id] = 0
+  end
+end
+
+class DynStrictDummy < ActiveRecord::Base
+  set_table_name 'versions'
+  include Zena::Use::DynAttributes::ModelMethods
+  dynamic_attributes_setup :only => [:bio, :phone], :nested_alias => {%r{^d_(\w+)} => ['dyn']}
+
+  def before_save
+    self[:node_id] = 123
+    self[:user_id] = 123
+  end
+end
+
+class DynSubStrictDummy < DynStrictDummy
+end
+
+class DynSub2StrictDummy < DynStrictDummy
+  include Zena::Use::DynAttributes::ModelMethods
+  dynamic_attributes_setup :only => [:hell]
+end
+
+class AttrDummy < ActiveRecord::Base
+  set_table_name 'dyn_attributes'
+end
+
+class DynAttributesTest < Test::Unit::TestCase
+
+  def test_simple
+    assert record = DynDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'')
+    assert_nil record.dyn['color']
+    record.dyn['color'] = 'blue'
+    assert_equal 'blue', record.dyn['color']
+    assert_equal 'blue', record.dyn[:color]
+    assert record.save
+
+    record = DynDummy.find(record[:id]) # reload
+    assert_equal 'blue', record.dyn['color']
+  end
+
+  def test_many_alias_methods
+    assert DynDummy.create(:title => 'worn shoes', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    record = DynDummy.find_by_title('worn shoes')
+    assert_equal 'worn', record.dyn.send('shoes')
+    assert_equal 'worn', record.dyn['shoes']
+    assert_equal 'blue', record.dyn.send('color')
+  end
+
+  def test_update
+    assert record = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+
+    assert_equal 'blue', record.dyn['color'] # reload hash
+    proxy = record.dyn
+    keys = proxy.instance_variable_get(:@keys)
+    assert keys['color']
+    assert keys['shoes']
+    assert keys['life']
+
+    assert record.update_attributes(:d_life => 'hell', :d_heidegger => 'Martin')
+    proxy = record.dyn
+    new_keys = proxy.instance_variable_get(:@keys)
+    ['color', 'life', 'shoes'].each do |k|
+      assert_equal keys[k], new_keys[k]
+    end
+    assert_equal 'Martin', record.dyn['heidegger']
+  end
+
+  def test_delete
+    assert record = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    proxy = record.dyn
+    keys = proxy.instance_variable_get(:@keys)
+    assert record.update_attributes(:d_life => nil)
+    assert_nil record.dyn['life']
+    assert_nil AttrDummy.find_by_id(keys['life'])
+  end
+
+  def test_delete_many
+    assert record = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    proxy = record.dyn
+    keys = proxy.instance_variable_get(:@keys)
+    assert record.update_attributes(:d_life => nil, :d_shoes => nil)
+    assert_nil record.dyn['life']
+    assert_nil AttrDummy.find_by_id(keys['life'])
+    assert_nil record.dyn['shoes']
+    assert_nil AttrDummy.find_by_id(keys['shoes'])
+  end
+
+  # DynStrictDummy
+
+  def test_only
+    assert record = DynStrictDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'', :d_bio=>'biography', :d_hell => 'not allowed')
+    assert_equal 'biography', record.dyn['bio']
+    assert_nil record.dyn['hell']
+    record.dyn['hell'] = 'lucifer'
+    record.dyn['hell'] = 'master of darkness'
+    assert record.save
+    assert_nil record.dyn['hell']
+  end
+
+  def test_only_subclass
+    assert record = DynSubStrictDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'', :d_bio=>'biography', :d_hell => 'not allowed')
+    assert_equal 'biography', record.dyn['bio']
+    assert_nil record.dyn['hell']
+  end
+
+  def test_only_subclass_overwrite
+    assert record = DynSub2StrictDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'', :d_bio=>'biography', :d_hell => 'not allowed')
+    assert_nil record.dyn['bio']
+    assert_equal 'not allowed', record.dyn['hell']
+  end
+
+  def test_each
+    assert record = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    record.dyn.each do |k,v|
+      case k
+      when 'color'
+        assert_equal 'blue', v
+      when 'life'
+        assert_equal 'fun', v
+      when 'shoes'
+        assert_equal 'worn', v
+      end
+    end
+  end
+
+  def test_dyn_equal
+    assert record  = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    proxy = record.dyn
+    keys = proxy.instance_variable_get(:@keys)
+    assert record2 = DynDummy.create(:title => 'hulk', :text=>'', :comment=>'', :summary=>'', :d_lobotomize=>'me')
+    assert_equal 'me', record2.dyn['lobotomize']
+
+    record2.dyn = record.dyn
+    assert record2.save, "Can save modified record"
+
+    record2 = DynDummy.find(record2[:id]) # reload
+    proxy = record2.dyn
+    new_keys = proxy.instance_variable_get(:@keys)
+    assert_equal 'blue', record2.dyn['color']
+    keys.each do |k,id|
+      assert new_keys[k]
+      assert_not_equal id, new_keys[k]
+    end
+    assert_nil record2.dyn['lobotomize']
+  end
+
+  def test_dyn_update_with
+    assert record  = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_color=>'blue', :d_life=>'fun', :d_shoes=>'worn')
+    proxy = record.dyn
+    keys = proxy.instance_variable_get(:@keys)
+
+    record.dyn = {:color => 'yellow', :lobotomize=>'me'}
+    assert record.save, "Can save modified record"
+
+    record = DynDummy.find(record[:id]) # reload
+    proxy = record.dyn
+    new_keys = proxy.instance_variable_get(:@keys)
+    assert_equal 'yellow', record.dyn['color']
+    assert_equal 'me', record.dyn['lobotomize']
+    assert_nil record.dyn['life']
+    assert_nil record.dyn['shoes']
+  end
+
+  def test_set_with_hash
+    assert record  = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'')
+    record.dyn = {:fingers => 'hurt'}
+    assert record.save, "Can save"
+
+    record = DynDummy.find(record[:id]) # reload
+    assert_equal 'hurt', record.dyn['fingers']
+  end
+
+  def test_delete
+    assert record  = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_life=>'fun', :d_joy=>'weird')
+    assert_equal 'weird', record.dyn.delete(:joy)
+    assert_nil record.dyn['joy']
+    assert record.save
+    record = DynDummy.find(record[:id]) # reload
+    assert_nil record.dyn['joy']
+    assert_equal 'fun', record.dyn['life']
+  end
+
+  def test_destroy
+    assert record  = DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_life=>'fun', :d_joy=>'weird')
+    assert_equal 2, DynDummy.count_by_sql("SELECT COUNT(*) FROM dyn_attributes WHERE owner_id = #{record[:id]}")
+    assert record.destroy
+    assert_equal 0, DynDummy.count_by_sql("SELECT COUNT(*) FROM dyn_attributes WHERE owner_id = #{record[:id]}")
+  end
+
+  def test_empty_key_empty_value
+    assert_raise(ActiveRecord::UnknownAttributeError)  { DynDummy.create(:title => 'lolipop', :text=>'', :comment=>'', :summary=>'', :d_=>'bad', :d_og=>'') }
+  end
+
+  def test_would_edit
+   record = DynDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'', :d_bio=>'biography', :d_hell => 'blind love')
+   assert !record.dyn.would_edit?('hell' => 'blind love', 'bio' => 'biography')
+   assert  record.dyn.would_edit?('hell' => 'blind love', 'bio' => '')
+   assert  record.dyn.would_edit?('hell' => 'blind love', 'fox' => 'hop')
+   assert !record.dyn.would_edit?('hell' => 'blind love', 'fox' => '', 'fly' => nil)
+  end
+
+  def test_changed
+    record = DynDummy.create(:title => 'this is my title', :text=>'', :comment=>'', :summary=>'', :d_bio=>'biography', :d_hell => 'blind love')
+    record = DynDummy.find(record.id) # reload
+    dyn = record.dyn
+    assert !dyn.changed?
+    dyn['bio'] = 'biography'
+    assert !dyn.changed?
+    dyn['bio'] = 'Gemüse'
+    assert dyn.changed?
+
+    record = DynDummy.find(record.id) # reload
+    dyn = record.dyn
+
+    dyn['title'] = nil
+    assert dyn.changed?
+  end
+end