talia_core 0.5.4 → 0.7.0

data/test/talia_core/active_source_finder_interface_test.rb

@@ -0,0 +1,30 @@
+#http://m.onkey.org/2010/1/22/active-record-query-interface
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+module TaliaCore
+
+  # Test the ActiveSource
+  class ActiveSourceFinderInterfaceTest < ActiveSupport::TestCase
+    fixtures :active_sources, :semantic_properties, :semantic_relations, :data_records
+    
+     
+    def setup
+      setup_once(:test_file) { File.join(ActiveSupport::TestCase.fixture_path, 'generic_test.xml') }
+      setup_once(:default_sources) do
+        raise NotImplementedError
+      end
+    end
+    
+    def test_where
+      #result = ActiveSource.find(:all, :find_through => ['http://testvalue.org/pred_find_through', active_sources(:find_through_target).uri])
+      result = ActiveSource.where('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
+    
+    
+    
+  end
+  
+end

data/test/talia_core/active_source_test.rb

@@ -1,10 +1,31 @@
+# -*- coding: utf-8 -*-
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 module TaliaCore
   
-  class SingularAccessorTest < ActiveSource
-    singular_property :siglum, N::RDFS.siglum
+  class DefinedAccessorTest < ActiveSource
+    autofill_uri
+    singular_property :siglum, N::RDFS.siglum, :dependent => :destroy
+    multi_property :authors, N::RDFS.author
+    singular_property :forcy_single, N::RDFS.forcy_single, :type => TaliaCore::ActiveSource
+    multi_property :forcy, N::RDFS.forcy, :type => TaliaCore::Source, :dependent => :destroy
+    manual_property :blinko
+    
+    multi_property :optionated, N::RDFS.optionated, :type => TaliaCore::ActiveSource
+    
     has_rdf_type N::TALIA.foo
+    
+    attr_accessor :blinko
+  end
+  
+  class DefinedAccessorSubTest < DefinedAccessorTest
+    singular_property :title, N::RDFS.title
+    
+    property_options N::RDFS.optionated, :dependent => :destroy
+    multi_property :optionated2, N::RDFS.optionated2, :type => TaliaCore::ActiveSource
+  end
+  
+  class DefinedAccessorSubNaked < DefinedAccessorTest
   end
   
   # Test the ActiveSource
@@ -20,6 +41,7 @@ module TaliaCore
     def test_has_type
       src = ActiveSource.new('http://xsource/has_type_test')
       src.types << N::HYPER.testtype
+      
       assert(src.has_type?(N::HYPER.testtype))
     end
     
@@ -305,8 +327,8 @@ module TaliaCore
     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))
+      assert_kind_of(TaliaCore::Collection, ActiveSource.find(:first, :conditions => { :uri => active_sources(:sti_source).uri.to_s }  ))
+      assert_kind_of(TaliaCore::Collection, active_sources(:sti_source))
     end
     
     def test_sti_relation_create
@@ -316,14 +338,14 @@ module TaliaCore
       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::Collection, 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(TaliaCore::Collection, active_sources(:sti_source_b).subjects[0].class)
+      assert_equal(TaliaCore::Collection, 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
     
@@ -354,6 +376,11 @@ module TaliaCore
       assert_equal(N::LOCAL.testlocalthing, src.uri)
     end
     
+    def test_create_local_strange
+      src = ActiveSource.new(:uri => '504-10,E2')
+      assert_equal(N::LOCAL + '504-10,E2', 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')
@@ -385,6 +412,27 @@ module TaliaCore
       assert_equal(active_sources(:find_through_test), result[0])
     end
     
+    def test_find_through_evil # Checks what happens if #to_s returns a random string instead of the uri
+      foo = Object.new 
+      class << foo
+        def uri
+          @uri
+        end
+        
+        def to_s
+          'abcd'
+        end
+      end
+      foo.instance_variable_set(:@uri, active_sources(:find_through_target).uri)
+      
+      assert_equal(active_sources(:find_through_target).uri, foo.uri)
+      assert_equal('abcd', foo.to_s)
+      
+      result = ActiveSource.find(:all, :find_through => ['http://testvalue.org/pred_find_through', foo])
+      assert_equal(1, result.size)
+      assert_equal(active_sources(:find_through_test), result[0])
+    end
+    
     def test_count_through
       result = ActiveSource.count(:find_through => ['http://testvalue.org/pred_find_through', active_sources(:find_through_target).uri])
       assert_equal(1, result)
@@ -413,8 +461,18 @@ module TaliaCore
       assert_equal(active_sources(:find_through_test), result[0])
     end
     
+    def test_singular_accessor_on_brackets
+      src = DefinedAccessorTest.new('http://testvalue.org/singular_acc_test')
+      assert_equal(nil, src[N::RDFS.siglum])
+      src[N::RDFS.siglum] = 'foo'
+      src.save!
+      assert_equal('foo', src[N::RDFS.siglum])
+      src.siglum = 'bar'
+      assert_equal('bar', src[N::RDFS.siglum])
+    end
+    
     def test_singular_accessor
-      src = SingularAccessorTest.new('http://testvalue.org/singular_acc_test')
+      src = DefinedAccessorTest.new('http://testvalue.org/singular_acc_test')
       assert_equal(nil, src.siglum)
       src.siglum = 'foo'
       src.save!
@@ -423,14 +481,101 @@ module TaliaCore
       assert_equal('bar', src.siglum)
     end
     
-    def test_singular_accessor_finder
-      src = SingularAccessorTest.new('http://testvalue.org/singular_find_test')
+    def test_singular_accessor_forcing
+      src = DefinedAccessorTest.new('http://testvalue.org/singular_acc_forcing_test')
+      assert_equal(nil, src.forcy_single)
+      src.forcy_single = active_sources(:testy).uri.to_s
+      src.save!
+      assert_kind_of(TaliaCore::ActiveSource, src.forcy_single)
+      assert_equal(active_sources(:testy).uri, src.forcy_single.uri)
+    end
+    
+    def test_singular_accessor_destroy_dependent
+      src = DefinedAccessorTest.new('http://testvalue.org/test_update_attribute_multi_forced')
+      assert(src.forcy.blank?)
+      src.update_attributes(:siglum => active_sources(:deltest))
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src.destroy
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+    end
+    
+    def test_multi_accessor_forcing
+      src = DefinedAccessorTest.new('http://testvalue.org/multi_acc_forcing_test')
+      assert(src.forcy.blank?)
+      src.forcy = [ active_sources(:testy).uri.to_s, active_sources(:testy_two).uri.to_s ]
+      src.save!
+      assert_property(src.forcy, active_sources(:testy), active_sources(:testy_two))
+    end
+    
+    def test_multi_accessor
+      src = DefinedAccessorTest.new('http://testvalue.org/multi_acc_test')
+      assert(src.authors.blank?)
+      src.authors = [ "foo", "bar", "dingdong" ]
+      src.save!
+      assert_equal([ "foo", "bar", "dingdong" ].sort, src.authors.sort)
+      src.authors = 'bar'
+      assert_equal(['bar'], src.authors.values)
+    end
+    
+    def test_multi_accessor_destroy_dependent
+      src = DefinedAccessorTest.new('http://testvalue.org/test_update_attribute_multi_forced')
+      assert(src.forcy.blank?)
+      src.update_attributes(:forcy => [ active_sources(:deltest).uri.to_s ])
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src.destroy
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+    end
+    
+    def test_singular_accessor_with_blank
+      src = DefinedAccessorTest.new('http://testvalue.org/singular_acc_test')
+      assert_equal(nil, src.siglum)
       src.siglum = 'foo'
       src.save!
-      src2 = SingularAccessorTest.new('http://testvalue.org/singular_find_test2')
+      assert_equal('foo', src.siglum)
+      src.siglum = ''
+      assert_equal(nil, src.siglum)
+    end
+    
+    def test_defined_accessor_finder
+      src = DefinedAccessorTest.new('http://testvalue.org/singular_find_test')
+      src.siglum = 'foo'
+      src.save!
+      src2 = DefinedAccessorTest.new('http://testvalue.org/singular_find_test2')
       src2.siglum = 'bar'
       src2.save!
-      assert_equal(SingularAccessorTest.find_by_siglum('foo'), [ src ])
+      assert_equal(DefinedAccessorTest.find_by_siglum('foo'), [ src ])
+    end
+    
+    def test_wrapper_destroy_dependent_on_remove
+      src = DefinedAccessorTest.new('http://testvalue.org/test_wrapper_destroy_dependent_on_remove')
+      assert(src[N::RDFS.forcy].blank?)
+      src[N::RDFS.forcy] = active_sources(:deltest)
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src[N::RDFS.forcy].remove
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+    end
+    
+    def test_wrapper_destroy_rdf_dependent_on_remove
+      src = DefinedAccessorTest.new('test_wrapper_destroy_rdf_dependent_on_remove')
+      assert(src[N::RDFS.forcy].blank?)
+      src[N::RDFS.forcy] = active_sources(:deltest)
+      src.save!
+      src[N::RDFS.forcy].remove
+      assert_equal([], ActiveRDF::Query.new(N::URI).select(:a, :b).where(active_sources(:deltest), :a, :b).execute)
+      assert_equal([], ActiveRDF::Query.new(N::URI).select(:a, :b).where(:a, :b, active_sources(:deltest)).execute)
+    end
+    
+    def test_wrapper_not_destroy_nondependent_on_remove
+      src = DefinedAccessorTest.new('test_wrapper_not_destroy_nondependent_on_remove')
+      assert(src[N::RDFS.fuzzy].blank?)
+      src[N::RDFS.fuzzy] = active_sources(:deltest)
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src[N::RDFS.fuzzy].remove
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
     end
     
     def test_autosave_rdf
@@ -489,6 +634,49 @@ module TaliaCore
       src.save!
       assert_equal(2, src['http://activesourcetest/write_predicate'].size)
     end
+    
+    def test_replace_predicate
+       src = ActiveSource.new('http://activesourcetest/test_replace_predicate')
+       src[N::RDF.foo] = [ active_sources(:testy), active_sources(:deltest) ]
+       src.save!
+       assert_property(src[N::RDF.foo], active_sources(:testy), active_sources(:deltest))
+       src[N::RDF.foo].replace(active_sources(:testy_two))
+       assert_property(src[N::RDF.foo], active_sources(:testy_two))
+    end
+    
+    def test_replace_predicate_no_dependent_on_base_class
+      src = ActiveSource.new('http://activesourcetest/test_replace_predicate')
+      src[N::RDFS.forcy] = [ active_sources(:testy), active_sources(:deltest) ]
+      src.save!
+      assert_property(src[N::RDFS.forcy], active_sources(:testy), active_sources(:deltest))
+      src[N::RDFS.forcy].replace(active_sources(:testy_two), active_sources(:testy))
+      assert_property(src[N::RDFS.forcy], active_sources(:testy_two), active_sources(:testy))
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:testy).id), "Source shouldn't be destroyed")
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id), "Source shouldn't be destroyed")
+    end
+
+    def test_replace_predicate_with_dependent_destroy
+      src = DefinedAccessorTest.new('http://activesourcetest/test_replace_predicate_with_dependent_destroy')
+      src[N::RDFS.forcy] = [ active_sources(:testy), active_sources(:deltest) ]
+      src.save!
+      assert_property(src[N::RDFS.forcy], active_sources(:testy), active_sources(:deltest))
+      src[N::RDFS.forcy].replace(active_sources(:testy_two).uri.to_s, active_sources(:testy))
+      assert_property(src[N::RDFS.forcy], active_sources(:testy_two), active_sources(:testy))
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:testy).id), "Remaining source should still exist")
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id), "Removed source should be deleted")
+    end
+    
+    def test_replace_with_string_for_source
+      src = DefinedAccessorTest.new('http://activesourcetest/test_replace_with_string_for_source')
+      src[N::RDFS.forcy] = [ active_sources(:deltest) ]
+      src.save!
+      assert_property(src[N::RDFS.forcy], active_sources(:deltest))
+      src[N::RDFS.forcy].replace(active_sources(:deltest).uri.to_s)
+      src.save!
+      src.reload
+      assert_property(src[N::RDFS.forcy], active_sources(:deltest))
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id), "Source shouldn't have been destroyed")
+    end
 
     def test_double_add_new_source
       src = ActiveSource.new('http://activesourcetest/doubletest')
@@ -504,7 +692,7 @@ module TaliaCore
       src = ActiveSource.new('http://activesourcetest/doubleadd/test')
       src[N::HYPER.bar] << 'foo'
       src.save!
-      src2 =  ActiveSource.find(src.uri)
+      src2 = ActiveSource.find(src.uri)
       src2[N::HYPER.bar] << 'bar'
       src2.save!
       assert_property(ActiveSource.find(src.uri)[N::HYPER.bar], 'foo', 'bar')
@@ -559,6 +747,51 @@ module TaliaCore
       assert_property(src[N::LOCAL.relatit], N::LOCAL.attr_update_test_dummy, N::LOCAL.another_attribute_save_dummy)
     end
     
+    def test_update_attribute_singular
+      src = DefinedAccessorTest.new('http://as_test/test_update_attribute_singular')
+      src.update_attributes(:siglum => "foo my ass")
+      assert_equal('foo my ass', src.siglum)
+    end
+    
+    def test_update_attribute_singular_forced
+      src = DefinedAccessorTest.new('http://as_test/test_update_attribute_singular_forced')
+      src.update_attributes(:forcy_single => active_sources(:testy).uri.to_s)
+      assert_kind_of(TaliaCore::ActiveSource, src.forcy_single)
+      assert_equal(active_sources(:testy).uri, src.forcy_single.uri)
+    end
+    
+    def test_update_attribute_singular_destroy
+      src = DefinedAccessorTest.new(:uri => 'http://as_test/test_update_attribute_singular_destroy', 
+      :siglum => active_sources(:deltest))
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src.update_attributes(:siglum => "")
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+    end
+    
+    def test_update_attribute_multi
+      src = DefinedAccessorTest.new('http://as_test/test_update_attribute_multi')
+      src.update_attributes(:authors => [ "fooby", "barni", "doc garfield" ])
+      assert_equal([ "fooby", "barni", "doc garfield" ].sort, src.authors.sort)
+    end
+    
+    def test_update_attribute_multi_forced
+      src = DefinedAccessorTest.new('http://testvalue.org/test_update_attribute_multi_forced')
+      assert(src.forcy.blank?)
+      src.update_attributes(:forcy => [ active_sources(:testy).uri.to_s, active_sources(:testy_two).uri.to_s ])
+      src.save!
+      assert_property(src.forcy, active_sources(:testy), active_sources(:testy_two))
+    end
+    
+    def test_update_attribute_multi_destroy
+      src = DefinedAccessorTest.new(:uri => 'http://as_test/test_update_attribute_multi_destroy', 
+      :forcy => active_sources(:deltest))
+      src.save!
+      assert(TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+      src.update_attributes(:forcy => [])
+      assert(!TaliaCore::ActiveSource.exists?(active_sources(:deltest).id))
+    end
+    
     def test_update_adding
       src = ActiveSource.new('http://as_test/test_update_adding')
       src[N::RDF.something] << 'value1'
@@ -575,14 +808,14 @@ module TaliaCore
     
     def test_rewrite_type
       src = ActiveSource.new('http://as_test/test_update_rewrite_type')
-      src.rewrite_attributes!({}) { |src| src.type = 'TaliaCore::SingularAccessorTest' }
-      assert_kind_of(SingularAccessorTest, ActiveSource.find(src.uri))
+      src.rewrite_attributes!({}) { |src| src.type = 'TaliaCore::DefinedAccessorTest' }
+      assert_kind_of(DefinedAccessorTest, ActiveSource.find(src.uri))
     end
     
     def test_rewrite_type
       src = ActiveSource.new('http://as_test/test_update_type')
-      src.update_attributes!({}) { |src| src.type = 'TaliaCore::SingularAccessorTest' }
-      assert_kind_of(SingularAccessorTest, ActiveSource.find(src.uri))
+      src.update_attributes!({}) { |src| src.type = 'TaliaCore::DefinedAccessorTest' }
+      assert_kind_of(DefinedAccessorTest, ActiveSource.find(src.uri))
     end
     
     def test_update_static
@@ -604,10 +837,24 @@ module TaliaCore
     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>"])
+      src = ActiveSource.new(:uri => 'http://as_test/create_with_attributes', ':localthi' => 'value', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_2>"])
       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)
+      assert_property(src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_2)
+    end
+    
+    def test_create_with_duplicate_attributes
+      src = ActiveSource.new(:uri => 'http://as_test/create_with_attributes', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_1>"])
+      assert_property(src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1)
+    end
+    
+    def test_create_with_attributes_and_forcing
+      src = DefinedAccessorTest.new(:uri => 'test_create_with_attributes_and_forcing', 'forcy_single' => active_sources(:deltest).uri.to_s)
+      assert_kind_of(ActiveSource, src.forcy_single)
+      assert_equal(active_sources(:deltest).uri, src.forcy_single.uri)
+      src.save!
+      src.reload
+      assert_kind_of(ActiveSource, src.forcy_single)
     end
     
     def test_create_with_attributes_plain_uri
@@ -616,15 +863,15 @@ module TaliaCore
     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' => 'TaliaCore::SingularAccessorTest')
-      assert_kind_of(SingularAccessorTest, src)
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_with_type', ':localthi' => 'value', 'rdf:relatit' => ["<:as_create_attr_dummy_1>", "<:as_create_attr_dummy_2>"], 'type' => 'TaliaCore::DefinedAccessorTest')
+      assert_kind_of(DefinedAccessorTest, 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[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_2)
       assert_property(src.types, N::TALIA.foo, src.rdf_selftype)
     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' => 'TaliaCore::SingularAccessorTest')
+      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_2>"], 'type' => 'TaliaCore::DefinedAccessorTest')
       src.save!
       assert_equal('valueFOOOO', src[N::LOCAL.localthi].first)
       xml = src.to_xml
@@ -634,21 +881,21 @@ module TaliaCore
       # 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[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_2)
       assert_property(new_src.types, N::TALIA.foo, new_src.rdf_selftype)
     end
     
     def test_create_multi
       src_attribs = [
-        { :uri => N::LOCAL.test_create_multi_stuff, 'rdf:relatit' => [ "<#{N::LOCAL.test_create_multi_stuff_two}>" ], 'type' => 'TaliaCore::SingularAccessorTest' },
-        { :uri => N::LOCAL.test_create_multi_stuff_two, ':localthi' => 'valueFOOOO', 'rdf:relatit' => ["<#{N::LOCAL.test_create_multi_stuff}>"], 'type' => 'TaliaCore::SingularAccessorTest' }
+        { :uri => N::LOCAL.test_create_multi_stuff, 'rdf:relatit' => [ "<#{N::LOCAL.test_create_multi_stuff_two}>" ], 'type' => 'TaliaCore::DefinedAccessorTest' },
+        { :uri => N::LOCAL.test_create_multi_stuff_two, ':localthi' => 'valueFOOOO', 'rdf:relatit' => ["<#{N::LOCAL.test_create_multi_stuff}>"], 'type' => 'TaliaCore::DefinedAccessorTest' }
       ]
       ActiveSource.create_multi_from(src_attribs, :duplicates => :update)
       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_kind_of(DefinedAccessorTest, src)
+      assert_kind_of(DefinedAccessorTest, 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')
@@ -662,11 +909,11 @@ module TaliaCore
       # Quickly change the URI for the new thing
       xml.gsub!(src.uri.to_s, 'http://as_test/create_forth_and_forth')
       # this is for the type attribute in the xml
-      xml.gsub!('SourceTypes::DummySource', 'SingularAccessorTest')
+      xml.gsub!('SourceTypes::DummySource', 'DefinedAccessorTest')
       # The next is for the 'type' semantic triple already existing
-      xml.gsub!('DummySource', 'SingularAccessorTest')
+      xml.gsub!('DummySource', 'DefinedAccessorTest')
       new_src = ActiveSource.create_from_xml(xml, :duplicates => :update)
-      assert_kind_of(TaliaCore::SingularAccessorTest, new_src)
+      assert_kind_of(TaliaCore::DefinedAccessorTest, 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)
@@ -762,11 +1009,178 @@ module TaliaCore
       assert_equal(3, src.data_records.size)
     end
     
+    def test_destroy_source
+      # Set up some sources that are interlinked
+      sources = (0..2).collect do |idx|
+        src = ActiveSource.new("http://as_test/destroy_source_#{idx}")
+        src.save!
+        src
+      end
+      
+      sources[0][N::TALIA.test_pred] << sources[1]
+      sources[0][N::TALIA.test_pred] << sources[2]
+      sources[1][N::TALIA.testy_pred] << sources[0]
+      sources[1][N::TALIA.testy_pred] << sources[2]
+      
+      sources.each { |s| s.save! }
+      
+      # Check if everything is set up correctly
+      assert_property(sources[0][N::TALIA.test_pred], sources[1], sources[2])
+      assert_property(sources[1][N::TALIA.testy_pred], sources[0], sources[2])
+      
+      # Destroy one source
+      destroyed_id = sources[1].id
+      sources[1].destroy
+      
+      # Check if it took all the links with it
+      test_source = TaliaCore::ActiveSource.find(sources[0].id)
+      assert_property(test_source[N::TALIA.test_pred], sources[2]) # This one should have the "destroyed" connection removed
+      # All relations related to that source should be gone
+      assert_equal(0, TaliaCore::SemanticRelation.all(:conditions => { :subject_id => destroyed_id }).size)
+      assert_equal(0, TaliaCore::SemanticRelation.all(:conditions => { :object_id => destroyed_id }).size)
+      # The source should be gone
+      assert(!TaliaCore::ActiveSource.exists?(sources[1].uri))
+      # The RDF should be gone
+      forward_result = ActiveRDF::Query.new(N::URI).select(:thing).where(sources[0], N::TALIA.test_pred, :thing).execute
+      assert_equal(1, forward_result.size, "Found more than one : #{forward_result.inspect}")
+      backward_result = ActiveRDF::Query.new(N::URI).select(:thing).where(sources[1], :all, :thing).execute
+      assert_equal(0, backward_result.size)
+    end
+    
     def test_to_uri
       src = ActiveSource.new('http://xsource/has_type_test')
       assert_equal(N::URI.new('http://xsource/has_type_test'), src.to_uri)
     end
     
+    def test_property_options_on_superclass
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorTest.property_options_for(N::RDFS.optionated)[:type])
+      assert_nil(DefinedAccessorTest.property_options_for(N::RDFS.optionated2)[:type])
+    end
+    
+    def test_property_options_on_subclass
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorSubTest.property_options_for(N::RDFS.optionated)[:type])
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorSubTest.property_options_for(N::RDFS.optionated2)[:type])
+    end
+    
+    def test_inherited_property_values_on_superclass
+      assert_equal({ :type => TaliaCore::ActiveSource, :singular_property => false }, DefinedAccessorTest.property_options_for(N::RDFS.optionated))
+    end
+    
+    def test_inherited_property_values_on_subclass
+      assert_equal({ :type => TaliaCore::ActiveSource, :dependent => :destroy, :singular_property => false}, DefinedAccessorSubTest.property_options_for(N::RDFS.optionated))
+    end
+    
+    def test_property_options_on_defined_super
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorTest.property_options_for(:optionated)[:type])
+      assert_nil(DefinedAccessorTest.property_options_for(:optionated2)[:type])
+    end
+    
+    def test_property_options_on_defined_sub
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorSubTest.property_options_for(:optionated)[:type])
+      assert_equal(TaliaCore::ActiveSource, DefinedAccessorSubTest.property_options_for(:optionated2)[:type])
+    end
+    
+    def test_has_defined_property
+      assert(DefinedAccessorTest.defined_property?(:siglum))
+      assert(!DefinedAccessorTest.defined_property?(:title))
+    end
+    
+    def test_no_defined_property
+      assert(!ActiveSource.defined_property?(:siglum))
+    end
+    
+    def test_has_defined_property_on_subclass
+      assert(DefinedAccessorSubTest.defined_property?(:title))
+      assert(DefinedAccessorSubTest.defined_property?(:siglum))
+    end
+    
+    def test_naked_has_defined_property_on_subclass
+      assert(DefinedAccessorSubNaked.defined_property?(:siglum))
+    end
+    
+    def test_singular_property_bracket_access
+      singi = DefinedAccessorTest.new('http://www.test.org/singular_property_bracket_access')
+      singi.siglum = 'foo'
+      assert_equal('foo', singi[:siglum])
+      singi[:siglum] = 'bar'
+      assert_equal('bar', singi.siglum)
+    end
+    
+    def test_singular_property_with_source
+      related = ActiveSource.new('http://www.test.org/prop_with_sources_friend/')
+      related.save!
+      singi = DefinedAccessorTest.new('http://www.test.org/singular_property_with_source')
+      singi.siglum = related
+      singi.save!
+      singi = DefinedAccessorTest.find(singi.id)
+      assert_kind_of(ActiveSource, singi.siglum)
+      assert_equal(related.uri, singi.siglum.uri)
+    end
+    
+    def test_singular_property_with_uri
+      related = ActiveSource.new('http://www.test.org/prop_with_uri_friend/')
+      related.save!
+      singi = DefinedAccessorTest.new('http://www.test.org/singular_property_with_uri')
+      singi.siglum = related.to_uri
+      singi.save!
+      singi = DefinedAccessorTest.find(singi.id)
+      assert_kind_of(ActiveSource, singi.siglum)
+      assert_equal(related.uri, singi.siglum.uri)
+    end
+    
+    def test_assign_throug_uri
+      related = ActiveSource.new('http://www.test.org/assign_through_friend/')
+      related.save!
+      src = ActiveSource.new('http://www.test.org/assign_throug_uri')
+      src[N::RDF.foo] = related.to_uri
+      src.save!
+      src = ActiveSource.find(src.id)
+      assert_property(src[N::RDF.foo], related)
+    end
+    
+    def test_autofill_url
+      new_thing = DefinedAccessorTest.new
+      assert(!new_thing.uri.blank?)
+    end
+    
+    def test_autofill_url_params
+      new_thing = DefinedAccessorTest.new(:siglumm => "foo")
+      assert(!new_thing.uri.blank?)
+    end
+    
+    def test_autofill_url_params_and_save
+      new_thing = DefinedAccessorTest.new(:siglumm => "foo")
+      new_thing.save!
+      assert(DefinedAccessorTest.exists?(new_thing.uri))
+    end
+    
+    def test_autofill_url_not
+      new_thing = DefinedAccessorSubNaked.new(:siglum => "foo")
+      assert(new_thing.uri.blank?)
+    end
+    
+    def test_manual_url_and_save
+      new_thing = DefinedAccessorTest.new(:siglumm => "foo", :uri => "http://foobar.com")
+      new_thing.save!
+      assert(DefinedAccessorTest.exists?(new_thing.uri))
+    end
+    
+    def test_manual_property
+      new_thing = DefinedAccessorTest.new(:blinko => "Bing!")
+      assert_equal(new_thing.blinko, "Bing!")
+    end
+    
+    def test_reload
+      new_thing = ActiveSource.new('http://testme/testing_reload')
+      new_thing.save!
+      assert_property(new_thing[N::RDF.somethink])
+      other_thing = ActiveSource.find(new_thing.id)
+      other_thing[N::RDF.somethink] << "Bongo"
+      other_thing.save!
+      new_thing.reload
+      assert_property(new_thing[N::RDF.somethink], "Bongo")
+    end
+    
     private
     
     def make_data_source
@@ -780,8 +1194,5 @@ module TaliaCore
       data_source.save!
       data_source
     end
-    
-    
   end
-  
 end