talia_core 0.4.0

data/test/talia_core/active_source_test.rb

@@ -0,0 +1,631 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+module TaliaCore
+  
+  class SingularAccessorTest < ActiveSource
+    singular_property :siglum, N::RDFS.siglum
+    has_rdf_type N::TALIA.foo
+  end
+  
+  # Test the ActiveSource
+  class ActiveSourceTest < Test::Unit::TestCase
+    fixtures :active_sources, :semantic_properties, :semantic_relations
+    
+    N::Namespace.shortcut(:as_test_preds, 'http://testvalue.org/')
+    
+    def setup
+      setup_once(:flush) do
+        TaliaUtil::Util.flush_rdf
+        true
+      end
+      
+      setup_once(:data_source) do
+        data_source = ActiveSource.new("http://www.test.org/source_with_data")
+        text = DataTypes::SimpleText.new
+        text.location = "text.txt"
+        image = DataTypes::ImageData.new
+        image.location = "image.jpg"
+        data_source.data_records << text
+        data_source.data_records << image
+        data_source.save!
+        data_source
+      end
+      
+    end
+
+    def test_has_type
+      facs = ActiveSource.new('http://facsimile/has_type_test')
+      facs.types << N::HYPER.testtype
+      assert(facs.has_type?(N::HYPER.testtype))
+    end
+
+
+    def test_exists
+      assert_not_nil(ActiveSource.find(:first))
+    end
+    
+    def test_create_existing
+      src = ActiveSource.new(active_sources(:testy).uri)
+      assert_equal(src, active_sources(:testy))
+      assert(!src.new_record?)
+    end
+    
+    def test_create_new
+      src_uri = 'http://foobarxxx.com/imallnew'
+      src = ActiveSource.new(src_uri)
+      assert_equal(src_uri, src.uri)
+      assert(src.new_record?)
+    end
+    
+    def test_create_vanilla
+      src = ActiveSource.new
+      # Somehow this gives different results for JRuby/Ruby
+      assert(src.uri == nil || src.uri == '')
+      assert(src.new_record?)
+    end
+    
+    def test_accessor
+      assert_equal(3, active_sources(:multirel)['http://testvalue.org/multirel'].size)
+      assert_equal(1, active_sources(:multirel)['http://testvalue.org/multi_b'].size)
+    end
+    
+    def test_delete
+      del = active_sources(:deltest)
+      assert_equal(2, del['http://testvalue.org/delete_test'].size)
+      del["http://testvalue.org/delete_test"].remove("Delete Me!")
+      del.save!
+      assert_equal(1, active_sources(:deltest)["http://testvalue.org/delete_test"].size)
+    end
+    
+    def test_delete_relation
+      del = active_sources(:deltest_rel)
+      assert_equal(2, del['http://testvalue.org/delete_test'].size)
+      del['http://testvalue.org/delete_test'].remove(active_sources(:deltest_rel_target1))
+      del.save
+      assert_equal(1, active_sources(:deltest_rel)["http://testvalue.org/delete_test"].size)
+    end
+    
+    def test_accessor_tripledup
+      assert_equal(2, active_sources(:duplicator)['http://testvalue.org/dup_rel'].size)
+    end
+    
+    def test_accessor_tripledup_delete
+      dupey = active_sources(:dup_for_delete)
+      dupdouble = TaliaCore::ActiveSource.find(dupey.uri)
+      assert_equal(2, dupey['http://testvalue.org/dup_rel'].size)
+      dupey['http://testvalue.org/dup_rel'].remove(active_sources(:testy))
+      assert_equal(1, dupey['http://testvalue.org/dup_rel'].size)
+      dupey.save!
+      assert_equal(1, dupdouble['http://testvalue.org/dup_rel'].size)
+      assert_equal(1, dupey['http://testvalue.org/dup_rel'].size)
+      dupey['http://testvalue.org/dup_rel'].remove(active_sources(:testy))
+      assert_equal(0, active_sources(:dup_for_delete)['http://testvalue.org/dup_rel'].size)
+      dupey.save!
+      assert_equal(0, active_sources(:dup_for_delete)['http://testvalue.org/dup_rel'].size)
+    end
+    
+    def test_uri
+      assert_equal("http://testy.com/testme/hard", active_sources(:testy).uri)
+    end
+    
+    def test_to_s
+      assert_equal active_sources(:testy).uri, active_sources(:testy).to_s
+    end
+    
+    def test_create
+      src = ActiveSource.new
+      src.uri = "http://www.testy.org/create_test"
+      src.save!
+      assert_equal(1, ActiveSource.find(:all, :conditions => { :uri =>  "http://www.testy.org/create_test" } ).size)
+    end
+    
+    def test_associate
+      test_src = active_sources(:assoc_test)
+      test_src["http://foo/assoc_test"] << active_sources(:assoc_test_target)
+      test_src["http://bar/assoc_test_prop"] << 'Test Value'
+      test_src.save!
+      assert_equal(1, test_src["http://foo/assoc_test"].size)
+      assert_equal(1, active_sources(:assoc_test)["http://foo/assoc_test"].size)
+      assert_equal(1, active_sources(:assoc_test)["http://bar/assoc_test_prop"].size)
+      active_sources(:assoc_test).save!
+      assert_equal(1, active_sources(:assoc_test)["http://foo/assoc_test"].size)
+      assert_equal(1, active_sources(:assoc_test)["http://bar/assoc_test_prop"].size)
+      assert_equal('TaliaCore::ActiveSource', SemanticRelation.find(:first, 
+          :conditions => { 
+            :subject_id => test_src.id, 
+            :predicate_uri => 'http://foo/assoc_test',
+            :object_id => active_sources(:assoc_test_target)
+          }).object_type)
+    end
+    
+    def test_create_validate
+      src = ActiveSource.new
+      assert_raise(ActiveRecord::RecordInvalid) { src.save! }
+    end
+    
+    def test_create_validate_format
+      src = ActiveSource.new
+      src.uri = "invalid"
+      assert_raise(ActiveRecord::RecordInvalid) { src.save! }
+    end
+    
+    def test_create_validate_unique
+      src = ActiveSource.new
+      src.uri = active_sources(:testy).uri
+      assert_raise(ActiveRecord::RecordInvalid) { src.save! }
+    end
+
+    def test_validate_uri
+      source = ActiveSource.new(:uri => N::LOCAL.to_s)
+      assert !source.valid?
+      
+      source = ActiveSource.new(:uri => "#{N::LOCAL}#{source}")
+      assert source.valid?
+    end
+
+    def test_inverse
+      assert_equal(2, active_sources(:assoc_inverse_start).inverse['http://testvalue.org/inverse_test'].size)
+      second_rel = active_sources(:assoc_inverse_start).inverse['http://testvalue.org/inverse_test_rel2']
+      assert_equal(1, second_rel.size)
+      assert_kind_of(TaliaCore::ActiveSource, second_rel[0])
+      assert_equal('http://testy.com/testme/inverse_end_c', second_rel[0].uri)
+    end
+    
+    def test_predicate_access
+      assert_equal('The test value', active_sources(:testy).predicate(:as_test_preds, :the_rel1)[0])
+    end
+    
+    def test_predicate_assign_string
+      src = active_sources(:assoc_predicate_test)
+      src.predicate_set(:as_test_preds, :test, "Foo")
+      src.save!
+      src_chng = TaliaCore::ActiveSource.find(src.id)
+      assert_equal('Foo', src_chng[N::AS_TEST_PREDS.test][0])
+    end
+    
+    def test_predicate_assign_rel
+      src = active_sources(:assoc_predicate_test)
+      src.predicate_set(:as_test_preds, :test_rel, src)
+      src.save!
+      assert_equal(src.uri, active_sources(:assoc_predicate_test)[N::AS_TEST_PREDS.test_rel][0].uri)
+    end
+
+    def test_semantic_build_success
+      src = TaliaCore::ActiveSource.new('http://buildsuccesstest/source')
+      src.predicate_set(:hyper, 'buildsucc', 'test')
+      src['http://buildsucc'] << 'test'
+      assert_equal(1, src['http://buildsucc'].size)
+      assert_equal(1,  src[N::HYPER.buildsucc].size)
+      src.save!
+      assert_equal(1, ActiveSource.find(src.uri)['http://buildsucc'].size)
+    end
+    
+    def test_predicate_set_uniq
+      src = active_sources(:assoc_predicate_test)
+      src.predicate_set_uniq(:as_test_preds, :test_uniq, "foo")
+      assert_property(src.predicate(:as_test_preds, :test_uniq), "foo")
+      src.predicate_set_uniq(:as_test_preds, :test_uniq, "bar")
+      src.predicate_set_uniq(:as_test_preds, :test_uniq, "foo")
+      src.save!
+      assert_property(src.predicate(:as_test_preds, :test_uniq), "foo", "bar")
+    end
+
+    def test_predicate_replace
+      src = active_sources(:assoc_predicate_test)
+      src.predicate_set(:as_test_preds, :test_replace, "foo")
+      src.predicate_replace(:as_test_preds, :test_replace, "bar")
+      src.save!
+      assert_property(src.predicate(:as_test_preds, :test_replace), "bar")
+    end
+    
+    def test_direct_predicates
+      preds = active_sources(:predicate_search_a).direct_predicates
+      assert_equal(4, preds.size)
+      assert(preds.include?('http://testvalue.org/pred_b'), "#{preds} does not include the expected value")
+    end
+
+    def tes_predicates_prefetch
+      uri = active_sources(:testy)
+      src = TaliaCore::ActiveSource.find(uri, :prefetch_relations => true)
+      assert_equal('The test value', src.predicate(:as_test_preds, :the_rel1)[0])
+    end
+    
+    def test_inverse_predicates
+      preds = active_sources(:predicate_search_b).inverse_predicates
+      assert_equal(4, preds.size)
+      assert(preds.include?('http://testvalue.org/pred_b'), "#{preds} does not include the expected value")
+      assert_equal(0, active_sources(:predicate_search_b).direct_predicates.size)
+    end
+    
+    def test_types
+      src = ActiveSource.new
+      src.uri = 'http://testy.com/testme/type_test'
+      src.save!
+      src.types << N::SourceClass.new(active_sources(:type_a).uri)
+      src.types << N::SourceClass.new(active_sources(:type_b).uri)
+      src.save!
+      assert_equal(2, src.types.size)
+      assert_kind_of(N::SourceClass, src.types[0])
+      assert(src.types.include?(active_sources(:type_b).uri))
+    end
+    
+    def test_sti_simple # Single table inheritance
+      assert_kind_of(TaliaCore::OrderedSource, ActiveSource.find(:first, :conditions => { :uri => active_sources(:sti_source).uri }  ))
+      assert_kind_of(TaliaCore::OrderedSource, active_sources(:sti_source))
+    end
+    
+    def test_sti_relation_create
+      src = active_sources(:sti_source_reltest)
+      src['http://reltest_test'] << active_sources(:sti_source_reltest_b)
+      src['http://reltest_test_b'] << active_sources(:sti_source_reltest_c)
+      src.save!
+      assert_equal(1, src['http://reltest_test'].size)
+      assert_equal(1, src['http://reltest_test_b'].size)
+      assert_equal(TaliaCore::OrderedSource, src['http://reltest_test'][0].class)
+      assert_equal(TaliaCore::ActiveSource, src['http://reltest_test_b'][0].class)
+    end
+    
+    def test_sti_relation_inverse
+      assert_equal(1, active_sources(:sti_source_b).subjects.size)
+      assert_equal(TaliaCore::OrderedSource, active_sources(:sti_source_b).subjects[0].class)
+      assert_equal(TaliaCore::OrderedSource, active_sources(:sti_source_b).inverse['http://testvalue.org/sti_test'][0].class)
+      assert_equal(active_sources(:sti_source).uri, active_sources(:sti_source_b).inverse['http://testvalue.org/sti_test'][0].uri)
+    end
+    
+    def test_attach_large_and_strange_text
+      src = active_sources(:strange_attach)
+      src['http://strangeattach_prop'] << "Nous présentons un commentaire de l'aphorisme 103 du Voyageur et son ombre, que Nietzsche a intitulé \" Lessing \" et où l'oeuvre de cet écrivain est jugée du du point de vue du style. On ne comprend vraiment le problème que si on inscrit l'aphorisme dans le cadre de la réception par Nietzsche, dès ses années d'études, des oeuvres de Lessing. Il résulte de notre analyse que Nietzsche définit le style de Lessing en le comparant à ce que Nietzsche lui-même appelle l'école française. À l'époque du Voyageur, le concept de sérénité (Heiterkeit) dont Montaigne est le modèle, est central pour juger un style. La question est de savoir à quelle école française Lessing a appartenu. La réponse de Nietzsche est apparemment assez ambiguë : Lessing est rapproché non seulement de Bayle, de Voltaire, de Diderot et de Montaigne, mais aussi de Marivaux, de Corneille et de Racine."
+      src.save!
+      assert_equal(src['http://strangeattach_prop'][0],"Nous présentons un commentaire de l'aphorisme 103 du Voyageur et son ombre, que Nietzsche a intitulé \" Lessing \" et où l'oeuvre de cet écrivain est jugée du du point de vue du style. On ne comprend vraiment le problème que si on inscrit l'aphorisme dans le cadre de la réception par Nietzsche, dès ses années d'études, des oeuvres de Lessing. Il résulte de notre analyse que Nietzsche définit le style de Lessing en le comparant à ce que Nietzsche lui-même appelle l'école française. À l'époque du Voyageur, le concept de sérénité (Heiterkeit) dont Montaigne est le modèle, est central pour juger un style. La question est de savoir à quelle école française Lessing a appartenu. La réponse de Nietzsche est apparemment assez ambiguë : Lessing est rapproché non seulement de Bayle, de Voltaire, de Diderot et de Montaigne, mais aussi de Marivaux, de Corneille et de Racine.")
+    end
+    
+    def test_attach_large_and_strange_text_fresh
+      src = ActiveSource.new('http://freshstrangeattach.xml')
+      src['http://strangeattach_prop'] << "Nous présentons un commentaire de l'aphorisme 103 du Voyageur et son ombre, que Nietzsche a intitulé \" Lessing \" et où l'oeuvre de cet écrivain est jugée du du point de vue du style.\nOn ne comprend vraiment le problème que si on inscrit l'aphorisme dans le cadre de la réception par Nietzsche, dès ses années d'études, des oeuvres de Lessing. Il résulte de notre analyse que Nietzsche définit le style de Lessing en le comparant à ce que Nietzsche lui-même appelle l'école française. À l'époque du Voyageur, le concept de sérénité (Heiterkeit) dont Montaigne est le modèle, est central pour juger un style. La question est de savoir à quelle école française Lessing a appartenu. La réponse de Nietzsche est apparemment assez ambiguë : Lessing est rapproché non seulement de Bayle, de Voltaire, de Diderot et de Montaigne, mais aussi de Marivaux, de Corneille et de Racine."
+      src.save!
+      assert_equal(src['http://strangeattach_prop'][0],"Nous présentons un commentaire de l'aphorisme 103 du Voyageur et son ombre, que Nietzsche a intitulé \" Lessing \" et où l'oeuvre de cet écrivain est jugée du du point de vue du style.\nOn ne comprend vraiment le problème que si on inscrit l'aphorisme dans le cadre de la réception par Nietzsche, dès ses années d'études, des oeuvres de Lessing. Il résulte de notre analyse que Nietzsche définit le style de Lessing en le comparant à ce que Nietzsche lui-même appelle l'école française. À l'époque du Voyageur, le concept de sérénité (Heiterkeit) dont Montaigne est le modèle, est central pour juger un style. La question est de savoir à quelle école française Lessing a appartenu. La réponse de Nietzsche est apparemment assez ambiguë : Lessing est rapproché non seulement de Bayle, de Voltaire, de Diderot et de Montaigne, mais aussi de Marivaux, de Corneille et de Racine.")
+    end
+    
+    def test_destroy_from_predicate
+      src = active_sources(:pred_destroy_test)
+      assert_equal(2, src.direct_predicates.size)
+      src['http://testvalue.org/pred_destroy_a'].remove
+      src.save!
+      assert_equal(1, active_sources(:pred_destroy_test).direct_predicates.size)
+    end
+    
+    def test_create_local
+      src = ActiveSource.new('testlocalthing')
+      assert_equal(N::LOCAL.testlocalthing, src.uri)
+    end
+    
+    def test_assign_and_save
+      src = ActiveSource.new('http://testassignandsave/')
+      src[N::LOCAL.something] << ActiveSource.new('http://types_test/assign_and_save_a')
+      src.save!
+      assert(ActiveSource.exists?(src.uri))
+    end
+    
+    def test_assign_nil_fail
+      src = ActiveSource.new('http://testassignandsave_nil/')
+      assert_raise(ArgumentError) { src['rdfs:something'] << nil }
+    end
+    
+    def test_find_through
+      result = ActiveSource.find(:all, :find_through => ['http://testvalue.org/pred_find_through', active_sources(:find_through_target).uri])
+      assert_equal(1, result.size)
+      assert_equal(active_sources(:find_through_test), result[0])
+    end
+    
+    def test_find_through_props
+      result = ActiveSource.find(:all, :find_through => ['http://testvalue.org/pred_find_through', 'the_value'])
+      assert_equal(1, result.size)
+      assert_equal(active_sources(:find_through_test), result[0])
+    end
+    
+    def test_find_through_fail
+      assert_raise(ArgumentError) { ActiveSource.find(:all, :find_through => ['foo:bar', 'bar'], :joins => "LEFT JOIN something") }
+      assert_raise(ArgumentError) { ActiveSource.find(:all, :find_through => ['foo:bar', 'bar'], :conditions => ["x = ?", 'bar']) }
+    end
+    
+    def test_find_through_inv
+      result = ActiveSource.find(:all, :find_through_inv => ['http://testvalue.org/pred_find_through', active_sources(:find_through_test).uri])
+      assert_equal(1, result.size)
+      assert_equal(active_sources(:find_through_target), result[0])
+    end
+    
+    def test_find_through_type
+      result = ActiveSource.find(:all, :type => active_sources(:find_through_type).uri)
+      assert_equal(1, result.size)
+      assert_equal(active_sources(:find_through_test), result[0])
+    end
+    
+    def test_singular_accessor
+      src = SingularAccessorTest.new('http://testvalue.org/singular_acc_test')
+      assert_equal(nil, src.siglum)
+      src.siglum = 'foo'
+      src.save!
+      assert_equal('foo', src.siglum)
+      src.siglum = 'bar'
+      assert_equal('bar', src.siglum)
+    end
+    
+    def test_singular_accessor_finder
+      src = SingularAccessorTest.new('http://testvalue.org/singular_find_test')
+      src.siglum = 'foo'
+      src.save!
+      src2 = SingularAccessorTest.new('http://testvalue.org/singular_find_test2')
+      src2.siglum = 'bar'
+      src2.save!
+      assert_equal(SingularAccessorTest.find_by_siglum('foo'), [ src ])
+    end
+    
+    def test_autosave_rdf
+      src = ActiveSource.new('http://testautosaverdf/')
+      assert(src.autosave_rdf?)
+      src.autosave_rdf = false
+      assert(src.autosave_rdf? == false)
+    end
+
+    def test_write_predicate
+      src = ActiveSource.new('http://activesourcetest/testwritepredicate')
+      src['http://activesourcetest/write_predicate'] << 'foo'
+      src.save!
+      assert_equal(['foo'], src['http://activesourcetest/write_predicate'].values)
+    end
+
+    def test_write_predicate_direct
+      src = ActiveSource.new('http://activesourcetest/testwritepredicate')
+      src.write_predicate_direct('http://activesourcetest/write_predicate', 'foo')
+      assert_equal(['foo'], src['http://activesourcetest/write_predicate'].values)
+      assert_equal(['foo'], src.my_rdf['http://activesourcetest/write_predicate'])
+    end
+
+    def test_write_direct_new_source
+      src = ActiveSource.new('http://activesourcetest/testwritepredicatenewsrc')
+      src2 = ActiveSource.new('http://activesourcetest/testwritepredicatenewsrctarg')
+      src.write_predicate_direct('http://activesourcetest/write_predicate', src2)
+      assert_equal([src2], src['http://activesourcetest/write_predicate'].values)
+      assert_equal([src2], src.my_rdf['http://activesourcetest/write_predicate'])
+    end
+
+
+    def test_write_predicate_multi
+      src = ActiveSource.new('http://activesourcetest/testwritepredicatemulti')
+      src[N::HYPER.multipred] << ['target1', 'target2']
+      assert_equal(['target1', 'target2'], src[N::HYPER.multipred].values)
+      src.save!
+      assert_equal(['target1', 'target2'], src[N::HYPER.multipred].values)
+    end
+
+    def test_write_predicate_advanced
+      src = ActiveSource.new('http://activesourcetest/testwritepredicateadv')
+      target1 = ActiveSource.new('http://activesourcetest/testwritepredtarget1')
+      target2 = ActiveSource.new('http://activesourcetest/testwritepredtarget2')
+      src[N::HYPER.write_pred] << [target1, target2]
+      assert_equal([target1, target2], src[N::HYPER.write_pred].values)
+      src.save!
+      assert_equal([target1, target2], src[N::HYPER.write_pred].values)
+    end
+
+    def test_assign_predicate
+      src = ActiveSource.new('http://activesourcetest/testclearpred')
+      src['http://activesourcetest/write_predicate'] << 'foo'
+      src['http://activesourcetest/write_predicate'] << 'bar'
+      src['http://activesourcetest/write_predicate2'] << 'bar'
+      src.save!
+      assert_equal(2, src['http://activesourcetest/write_predicate'].size)
+    end
+
+    def test_double_add_new_source
+      src = ActiveSource.new('http://activesourcetest/doubletest')
+      src2 = ActiveSource.new('http://activesourcetest/doubletest2')
+      src3 = ActiveSource.new('http://activesourcetest/doubletest2')
+      src[N::HYPER.bar] << src2
+      src[N::HYPER.bar] << src3
+      src.save!
+      assert_equal([src2, src2], src[N::HYPER.bar].values)
+    end
+
+    def test_double_add
+      src = ActiveSource.new('http://activesourcetest/doubleadd/test')
+      src[N::HYPER.bar] << 'foo'
+      src.save!
+      src2 =  ActiveSource.find(src.uri)
+      src2[N::HYPER.bar] << 'bar'
+      src2.save!
+      assert_property(ActiveSource.find(src.uri)[N::HYPER.bar], 'foo', 'bar')
+    end
+
+    def test_double_add_and_reset
+      src = ActiveSource.new('http://activesourcetest/doubleaddload/test')
+      src[N::HYPER.bar] << 'foo'
+      src.save!
+      src2 =  ActiveSource.find(src.uri)
+      src2[N::HYPER.bar] << 'bar'
+      src2.save!
+      src.reset!
+      assert_property(src[N::HYPER.bar], 'foo', 'bar')
+    end
+    
+    def test_db_attributes
+      assert(ActiveSource.db_attr?(:type))
+      assert(ActiveSource.db_attr?('type'))
+      assert(!ActiveSource.db_attr?('footype'))
+      assert(!ActiveSource.db_attr?('http://www.foobar.org/'))
+    end
+    
+    def test_expand_uri
+      assert_equal(N::LOCAL.foo.to_s, ActiveSource.expand_uri(':foo'))
+      assert_equal(N::LOCAL.foo.to_s, ActiveSource.expand_uri('foo'))
+      assert_equal(N::LOCAL.foo.to_s, ActiveSource.expand_uri('local:foo'))
+      assert_equal(N::RDF.foo.to_s, ActiveSource.expand_uri('rdf:foo'))
+      assert_equal('http://barf.org/foo', ActiveSource.expand_uri('http://barf.org/foo'))
+    end
+    
+    def test_update_attributes_on_saved
+      src = ActiveSource.new('http://as_test/test_update_attributes_on_saved')
+      src.save!
+      src.update_attributes(:uri => 'http://as_test/test_update_attributes_on_2', 'rdf:foo' => 'value', N::LOCAL.relatit.to_s => "<#{N::LOCAL + 'attr_on_save_test_dummy'}>" )
+      src = ActiveSource.find('http://as_test/test_update_attributes_on_2')
+      assert_kind_of(DummySource, src[N::LOCAL.relatit].first)
+      assert_equal(N::LOCAL + 'attr_on_save_test_dummy', src[N::LOCAL.relatit].first.uri)
+      assert_equal('value', src[N::RDF.foo].first)
+    end
+    
+    def test_update_attributes_lists
+      src = ActiveSource.new('http://as_test/test_update_attributes_on_saved_lists')
+      src.update_attributes(N::LOCAL.relatit.to_s => ["<#{N::LOCAL + 'attr_update_test_dummy'}>" , "<:another_attribute_save_dummy>"])
+      assert_property(src[N::LOCAL.relatit], N::LOCAL.attr_update_test_dummy, N::LOCAL.another_attribute_save_dummy)
+    end
+    
+    def test_update_adding
+      src = ActiveSource.new('http://as_test/test_update_adding')
+      src[N::RDF.something] << 'value1'
+      src.update_attributes!('rdf:something' => ['value2', 'value3'])
+      assert_property(src[N::RDF.something], 'value1', 'value2', 'value3')
+    end
+    
+    def test_rewrite
+      src = ActiveSource.new('http://as_test/test_update_rewrite')
+      src[N::RDF.something] << 'value1'
+      src.rewrite_attributes!('rdf:something' => ['value2', 'value3'])
+      assert_property(src[N::RDF.something], 'value2', 'value3')
+    end
+    
+    def test_rewrite_type
+      src = ActiveSource.new('http://as_test/test_update_rewrite_type')
+      src.rewrite_attributes!({}) { |src| src.type = 'SingularAccessorTest' }
+      assert_kind_of(SingularAccessorTest, ActiveSource.find(src.uri))
+    end
+    
+    def test_rewrite_type
+      src = ActiveSource.new('http://as_test/test_update_type')
+      src.update_attributes!({}) { |src| src.type = 'SingularAccessorTest' }
+      assert_kind_of(SingularAccessorTest, ActiveSource.find(src.uri))
+    end
+    
+    def test_update_static
+      src = ActiveSource.new('http://as_test/test_update_static')
+      src[N::RDF.something] << 'value1'
+      src.save!
+      ActiveSource.update(src.uri, 'rdf:something' => ['value2', 'value3'])
+      src = ActiveSource.find(src.uri)
+      assert_property(src[N::RDF.something], 'value1', 'value2', 'value3')
+    end
+    
+    def test_rewrite_static
+      src = ActiveSource.new('http://as_test/test_update_rewrite')
+      src[N::RDF.something] << 'value1'
+      src.save!
+      ActiveSource.rewrite(src.id, 'rdf:something' => ['value2', 'value3'])
+      src = ActiveSource.find(src.id)
+      assert_property(src[N::RDF.something], 'value2', 'value3')
+    end
+    
+    def test_create_with_attributes
+      src = ActiveSource.new(:uri => 'http://as_test/create_with_attributes', ':localthi' => 'value', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_1>"])
+      assert_equal('http://as_test/create_with_attributes', src.uri)
+      assert_equal('value', src[N::LOCAL.localthi].first)
+      assert_property(src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_1)
+    end
+    
+    def test_create_source
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_with_type', ':localthi' => 'value', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_1>"], 'type' => 'SingularAccessorTest')
+      assert_kind_of(SingularAccessorTest, src)
+      assert_equal('value', src[N::LOCAL.localthi].first)
+      assert_property(src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_1)
+      assert_property(src.types, N::TALIA.foo)
+    end
+    
+    def test_create_for_existing
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_forth_and_existing', ':localthi' => 'valueFOOOO', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_1>"], 'type' => 'SingularAccessorTest')
+      src.save!
+      assert_equal('valueFOOOO', src[N::LOCAL.localthi].first)
+      xml = src.to_xml
+      # Quickly change something inside, but leave the URL
+      xml.gsub!('valueFOOOO', 'valorz')
+      new_src = ActiveSource.create_from_xml(xml)
+      # Now test as above
+      assert_equal(src.uri.to_s, new_src.uri.to_s)
+      assert_equal('valorz', new_src[N::LOCAL.localthi].first)
+      assert_property(new_src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_1)
+      assert_property(new_src.types, N::TALIA.foo)
+    end
+    
+    def test_create_multi
+      src_attribs = [
+        { :uri => N::LOCAL.test_create_multi_stuff, 'rdf:relatit' => [ "<#{N::LOCAL.test_create_multi_stuff_two}>" ], 'type' => 'SingularAccessorTest' },
+        { :uri => N::LOCAL.test_create_multi_stuff_two, ':localthi' => 'valueFOOOO', 'rdf:relatit' => ["<#{N::LOCAL.test_create_multi_stuff}>"], 'type' => 'SingularAccessorTest' }
+      ]
+      ActiveSource.create_multi_from(src_attribs)
+      src = TaliaCore::ActiveSource.find(N::LOCAL.test_create_multi_stuff)
+      src_two = TaliaCore::ActiveSource.find(N::LOCAL.test_create_multi_stuff_two)
+      assert(src && src_two)
+      assert_kind_of(SingularAccessorTest, src)
+      assert_kind_of(SingularAccessorTest, src_two)
+      assert_property(src_two[N::RDF.relatit], N::LOCAL.test_create_multi_stuff)
+      assert_property(src[N::RDF.relatit], N::LOCAL.test_create_multi_stuff_two)
+      assert_property(src_two[N::LOCAL.localthi], 'valueFOOOO')
+    end
+    
+    
+    def test_xml_forth_and_back
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_forth_and_back', ':localthi' => 'value', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_1>"], 'type' => 'DummySource')
+      xml = src.to_xml
+      assert_kind_of(TaliaCore::DummySource, src)
+      # Quickly change the URI for the new thing
+      xml.gsub!(src.uri.to_s, 'http://as_test/create_forth_and_forth')
+      xml.gsub!('DummySource', 'SingularAccessorTest')
+      new_src = ActiveSource.create_from_xml(xml)
+      assert_kind_of(TaliaCore::SingularAccessorTest, new_src)
+      # Now test as above
+      assert_equal('http://as_test/create_forth_and_forth', new_src.uri.to_s)
+      assert_equal('value', new_src[N::LOCAL.localthi].first)
+      assert_property(new_src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_1)
+      assert_property(new_src.types, N::TALIA.foo)
+    end
+    
+    def test_create_with_file
+      test_file = File.join(Test::Unit::TestCase.fixture_path, 'generic_test.xml')
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_forth_and_back', 'type' => 'Source', 'files' => {'url' => test_file })
+      assert_equal(1, src.data_records.size)
+      src.save!
+      assert(!src.data_records.first.new_record?)
+      assert_kind_of(DataTypes::XmlData, src.data_records.first)
+      File.open(test_file) do |io|
+        assert_equal(src.data_records.first.all_text, io.read)
+      end
+    end
+    
+    # Test if accessing the data on a Source works
+    def test_data_access
+      data = @data_source.data
+      assert_equal(2, data.size)
+    end
+    
+    # Test if accessing the data on a Source works
+    def test_data_access_by_type
+      data = @data_source.data("SimpleText")
+      assert_equal(1, data.size)
+      assert_kind_of(DataTypes::SimpleText, data.first)
+    end
+    
+    # Test if accessing the data on a Source works
+    def test_data_access_by_type_and_location
+      data = @data_source.data("ImageData", "image.jpg")
+      assert_kind_of(DataTypes::ImageData, data)
+    end
+    
+    # Test accessing inexistent data
+    def test_data_access_inexistent
+      data = @data_source.data("Foo")
+      assert_equal(0, data.size)
+      data = @data_source.data("SimpleText", "noop.txt")
+      assert_nil(data)
+    end 
+    
+    
+  end
+  
+end