talia_core 0.4.3 → 0.4.4

data/lib/talia_util/rake_tasks.rb

@@ -6,16 +6,15 @@ require 'talia_core'
 require 'talia_util'
 require 'talia_util/util'
 require 'rake/testtask'
-require 'rake/rdoctask'
 require 'progressbar'
 
 include TaliaUtil
 
 namespace :talia_core do
-  
+
   # Standard initialization
   desc "Initialize the TaliaCore"
-  task :talia_init do
+  task :init do
     Util::title
     Util::init_talia
     TLoad::force_rails_parts unless(defined?(ActiveRecord))
@@ -25,15 +24,15 @@ namespace :talia_core do
     model_path = File.join(TALIA_ROOT, 'app', 'models')
     ActiveSupport::Dependencies.load_paths << model_path if(File.directory?(model_path))
   end
-  
+
   # Removes all data
   desc "Reset the Talia data store"
-  task :clear_store => :talia_init do
+  task :clear_store => :init do
     Util::flush_db
     Util::flush_rdf
     puts "Flushed data store"
   end
-  
+
   # Init for the unit tests
   desc "Initialize Talia for the tests"
   task :test_setup do
@@ -43,9 +42,9 @@ namespace :talia_core do
     end
 
     # Invoke the init after the setup
-    Rake::Task["talia_core:talia_init"].invoke
+    Rake::Task["talia_core:init"].invoke
   end
-  
+
   # Test task
   desc 'Test the talia_core plugin.'
   task :test => :test_setup
@@ -56,46 +55,46 @@ namespace :talia_core do
     t.test_files = FileList["#{File.dirname(__FILE__)}/../../test/**/*_test.rb"]
     t.verbose = true
   end
-  
+
   # Queue an import in the background
   desc "Xml Background import. Options: [index=<indexfile>] [xml=<datafile>] [importer=<importclass>] [reset_store=true] [...]"
   task :xml_background_import do 
     background_job('xml_import', :tag => 'import')
     puts "Queued XML background import."
   end
-  
+
   desc "Xml Import. Options: see xml_background_import"
-  task :xml_import => :talia_init do
+  task :xml_import => :init do
     importer = TaliaUtil::ImportJobHelper.new(STDOUT, TaliaUtil::BarProgressor)
     importer.do_import
   end
-  
+
   # Just run the Talia init to test it
   desc "Test the TaliaCore startup"
-  task :init_test => :talia_init do
+  task :init_test => :init do
     Util::talia_config
   end
- 
+
   # Task for importing ontologies/raw RDF data
   desc "Import ontologies. This imports the given rdf files (same as rdf_import), and sets the context automatically"
-  task :ontology_import => :talia_init do
+  task :ontology_import => :init do
     TaliaCore::RdfImport::import(ENV['rdf_syntax'], TaliaUtil::Util::get_files, :auto)
   end
-  
+
   # RDF importing task. A context can be freely assigned.
   desc "Import RDF data directly into the triple store. Option: rdf_syntax={ntriples|rdfxml} [context=<context>]"
-  task :rdf_import => :talia_init do
+  task :rdf_import => :init do
     TaliaCore::RdfImport::import(ENV['rdf_syntax'], TaliaUtil::Util::get_files, ENV['context'])
   end
 
   desc "Update the Ontologies. Options [ontologies=<ontology_folder>]"
-  task :setup_ontologies => :talia_init do
+  task :setup_ontologies => :init do
     Util::setup_ontologies
   end
 
   # Rewrite your base URL. This will loose any comments in the config file
   desc "Rewrite the database to move it to a new URL. Options new_home=<url>."
-  task :move_site => :talia_init do
+  task :move_site => :init do
     new_site = ENV['new_home']
     # Check if this looks like an URL
     raise(RuntimeError, "Illegal new_home given. (It must start with http(s):// and end with a slash)") unless(new_site =~ /^https?:\/\/\S+\/$/)
@@ -121,56 +120,12 @@ namespace :talia_core do
     puts "New configuration saved. Finished site rebuilding."
   end
 
-  # Task for importing YAML data into the data store
-  desc "Import YAML data file in Talia format."
-  task :yaml_import => :talia_init do
-    YamlImport::import_multi_files(TaliaUtil::Util::get_files)
-  end
-  
   # Task for updating the OWL classes with RDFS class information
   desc "Update OWL classes with RDFS class information."
-  task :owl_to_rdfs_update => :talia_init do
+  task :owl_to_rdfs_update => :init do
     RdfUpdate::owl_to_rdfs
   end
-  
-  # Task to import data files into the Talia system
-  desc "Import data files. Options data_type=<data_type> replace_files={yes|no}"
-  task :data_import => :talia_init do
-    DataImport::import(TaliaUtil::Util::get_files, ENV['data_type'])
-  end
-  
-  # Task to import demo data from a demo directory
-  desc "Import demo data (for default demo data). Opions: demodir=<dir> [owlify=no]"
-  task :demo_import do
-    unless(demodir = ENV['demodir'])
-      puts "ERROR: Need demodir option for import"
-      Util::print_options
-      exit(1)
-    end
-    
-    # Force some options to default
-    ENV['reset_db'] = "yes" unless(ENV['reset_db'])
-    ENV['reset_rdf'] = "yes" unless(ENV['reset_rdf'])
-    
-    # Invoke the init after the setup
-    Rake::Task["talia_core:talia_init"].invoke
-    
-    puts "Importing ontologies..."
-    RdfImport::import("rdfxml", FileList.new(File.join(demodir, '*.rdf*'), File.join(demodir, '*.owl')))
-    puts "Importing data records..."
-    YamlImport::import_multi_files([File.join(demodir, "demo_data.yml")])
-    puts "Importing files..."
-    Dir.foreach(File.join(demodir)) do |entry|
-      if(FileTest.directory?(File.join(demodir,entry)) && entry != ".." && entry != "." && entry != ".svn")
-        puts "Importing for type #{entry}"
-        DataImport::import(FileList.new(File.join(demodir, entry, '*')), entry)
-      end
-    end
-    if(ENV['owlify'].to_s.downcase == 'yes')
-      RdfUpdate::owl_to_rdfs
-    end
-  end
-  
+
   # Helper task to bootstrap Redland RDF (should usually only be a problem when
   # using Redland with mysql store)
   desc "Initialize Redland RDF store. Option: rdfconf=<rdfconfig_file> [environment=env]"
@@ -180,12 +135,12 @@ namespace :talia_core do
     environment = ENV['environment'] || "development"
     raise(ArgumentError, "Must have rdfconf=<config_file>") unless(ENV['rdfconf'])
     options = YAML::load(File.open(ENV['rdfconf']))[environment]
-    
+
     rdf_cfg = Hash.new
     options.each { |key, value| rdf_cfg[key.to_sym] = value }
-    
+
     rdf_cfg[:new] = "yes"
-    
+
     ConnectionPool.add_data_source(rdf_cfg)
   end
 
@@ -198,7 +153,7 @@ namespace :talia_core do
   end
 
   desc "Rebuild the RDF store from the database. Option [hard_reset=(true|false)]"
-  task :rebuild_rdf => :talia_init do
+  task :rebuild_rdf => :init do
     count = TaliaCore::SemanticRelation.count
     puts "Rebuilding RDF for #{count} triples."
     prog = ProgressBar.new('Rebuilding', count)
@@ -206,9 +161,30 @@ namespace :talia_core do
     prog.finish
     puts "Finished rewriting. ATTENTION: You may want to call setup_ontologies now."
   end
-  
+
+  desc "Generate large database for load tests. [count=<number of sources>]"
+  task :generate_large_data => :init do
+    count = (ENV['count'] || '10000').to_i
+    prog = ProgressBar.new('Creating', count)
+    (1..count).each do |idx|
+      src = TaliaCore::ActiveSource.new(:uri => N::LOCAL + "large_sample_#{idx}")
+      if(idx > 1)
+        # For now an easy approach: Each source has 10 connections to the previous
+        # one.
+        prev = TaliaCore::ActiveSource.find(N::LOCAL + "large_sample_#{idx - 1}")
+        (1..10).each do |rel_idx|
+          src[N::RDF + "dummy_rel_#{rel_idx}"] << prev
+          src[N::RDFS + "dummy_prop_#{rel_idx}"] << 'Some property'
+        end
+      end
+      src.save!
+      prog.inc
+    end
+    prog.finish
+  end
+
   # Helper methods
-  
+
   # Queue the long-running task in the background processing queue.
   # This will simply queue the job, and doesn't start the runner
   # by itself
@@ -219,5 +195,5 @@ namespace :talia_core do
     options[:no_tickle] = true
     TaliaCore::BackgroundJobs::Job.submit_with_progress(job, options)
   end
-  
+
 end

data/lib/talia_util/rdf_update.rb

@@ -38,29 +38,38 @@ module TaliaUtil
         # Remove previous auto rdfs triples
         FederationManager.clear(N::TALIA.auto_rdfs.context)
         
-        # Get all OWL classes
-        qry = Query.new(N::URI).distinct.select(:klass, :type)
-        qry.where(:klass, N::RDF::type, N::OWL + 'Class')
-        qry.where(:klass, N::RDF::type, :type)
-        classes_with_types = qry.execute
+        # This gets all OWL classes in the store
+        all_qry = Query.new(N::URI).distinct.select(:class)
+        all_qry.where(:class, N::RDF::type, N::OWL.Class)
+        all_owl = all_qry.execute
+        
+        # This gets all OWL classes that already have an RDF class attached
+        qry_rdfs = Query.new(N::URI).distinct.select(:class)
+        qry_rdfs.where(:class, N::RDF::type, N::OWL.Class)
+        qry_rdfs.where(:class, N::RDF::type, N::RDFS.Class)
+        classes_with_rdfs = qry_rdfs.execute
+        
+        
         modified = 0
         blanks = 0
         
         class_hash = {}
         
-        # We have a list of all combinations of klass elements with their types
-        # The next step is to find all things where a RDFS.Class type already
-        # exists
-        classes_with_types.each do |class_with_type|
-          if(class_with_type.first.is_a?(RDFS::BNode))
+        # Put all the existing owl classes in a hash
+        all_owl.each do |owl_class|
+          if(owl_class.is_a?(RDFS::BNode))
             blanks = blanks + 1
             next
           end
           
-          klass, type = class_with_type
+          class_hash[owl_class] = :has_rdfs_class
+        end
+        
+        # Now remove the ones that already have an RDF class
+        classes_with_rdfs.each do |owl_class|
+          next if(owl_class.is_a?(RDFS::BNode))
           
-          class_hash[klass.to_s] ||= :no_rdfs_class
-          class_hash[klass.to_s] = :has_rdfs_class if(type == N::RDFS.Class)
+          class_hash[owl_class] = :no_rdfs_class
         end
         
         # Now go through all klasses and add the missing triples

data/lib/talia_util/test_helpers.rb

@@ -20,7 +20,7 @@ module TaliaUtil
     # Source given by the URI.
     def assert_property(property, *values)
       assert_kind_of(TaliaCore::SemanticCollectionWrapper, property) # Just to be sure
-      assert_equal(values.size, property.size, "Expected #{values.size} values instead of #{property.size}")
+      assert_equal(values.size, property.size, "Expected #{values.size} values instead of #{property.size}.")
       property.each do |value|
         assert(values.detect { |val| val.respond_to?(:uri) ? (val.uri.to_s == value.uri.to_s) : (value == val) }, "Found unexpected value #{value}. Value is a #{value.class}\nExpected:\n#{values.join("\n")}")
       end

data/lib/talia_util.rb

@@ -2,9 +2,7 @@
 require File.join(File.dirname(__FILE__), 'talia_dependencies')
 
 require 'core_ext'
-require 'talia_util/data_import'
 require 'talia_core/rdf_import'
-require 'talia_util/yaml_import'
 require 'talia_util/rdf_update'
 require 'talia_util/progressbar'
 

data/test/core_ext/string_test.rb

@@ -8,4 +8,9 @@ class StringTest < Test::Unit::TestCase
     assert_equal('Should_Titleize_Mixed_Case_Strings', 'sHoULD tItLEIzE mIxEd cAsE sTrINgS'.to_permalink)
     assert_equal('Should_Replace_Spaces_With_Underscores', 'should replace spaces with underscores'.to_permalink)
   end
+  
+  def test_to_uri
+    assert_equal(N::URI.new('http://foo-foo.com'), 'http://foo-foo.com'.to_uri)
+    assert_kind_of(N::URI, 'foo-foo.com'.to_uri)
+  end
 end

data/test/talia_core/active_source_test.rb

@@ -12,6 +12,10 @@ module TaliaCore
     fixtures :active_sources, :semantic_properties, :semantic_relations, :data_records
     
     N::Namespace.shortcut(:as_test_preds, 'http://testvalue.org/')
+    
+    def setup
+      setup_once(:test_file) { File.join(ActiveSupport::TestCase.fixture_path, 'generic_test.xml') }
+    end
 
     def test_has_type
       src = ActiveSource.new('http://xsource/has_type_test')
@@ -20,8 +24,8 @@ module TaliaCore
     end
     
     def test_type_field
-      src = DummySource.new('http://xsource/has_type_test')
-      assert_equal(src.type, 'TaliaCore::DummySource')
+      src = SourceTypes::DummySource.new('http://xsource/has_type_test')
+      assert_equal(src.type, 'TaliaCore::SourceTypes::DummySource')
     end
 
     def test_exists
@@ -207,11 +211,71 @@ module TaliaCore
       assert_equal(4, preds.size)
       assert(preds.include?('http://testvalue.org/pred_b'), "#{preds} does not include the expected value")
     end
+    
+    def test_i18n_predicates
+      src = active_sources(:i18n_test)
+      assert_property(src.predicate(:as_test_preds, :i18n), 'value', 'wert')
+    end
+    
+    def test_values_with_lang
+      src = active_sources(:i18n_test)
+      assert_equal(src.predicate(:as_test_preds, :i18n).values_with_lang('de'), ['wert'])
+      assert_equal(src.predicate(:as_test_preds, :i18n).values_with_lang('en'), ['value'])
+    end
+    
+    def test_values_with_lang_fallback
+      src = active_sources(:i18n_test)
+      assert_equal(src.predicate(:as_test_preds, :i18n).values_with_lang('ar'), ['value'])
+    end
+    
+    def test_values_with_lang_fallback_unset
+      src_preds = active_sources(:testy).predicate(:as_test_preds, :the_rel1)
+      assert_equal(src_preds.values_with_lang('de'), ['The test value'])
+      assert_equal(src_preds.values_with_lang('en'), ['The test value'])
+    end
+    
+    def test_property_string_values
+      src = active_sources(:i18n_test)
+      pred = src.predicate(:as_test_preds, :i18n).first
+      assert_kind_of(PropertyString, pred)
+      assert(!pred.lang.blank?)
+    end
+    
+    def test_property_string_adding
+      src = TaliaCore::ActiveSource.new('http://testy.org/do_the_property_string')
+      src[N::RDF.testpred] << PropertyString.new('value', 'en', 'string')
+      assert(src[N::RDF.testpred].first.lang, 'en')
+      src.save!
+      src_new = TaliaCore::ActiveSource.find(src.uri)
+      assert_property(src_new[N::RDF.testpred], 'value')
+      pred = src_new[N::RDF.testpred].first
+      assert_equal(pred.lang, 'en')
+      assert_equal(pred.type, 'string')
+    end
 
-    def tes_predicates_prefetch
+    def test_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])
+      assert_equal(true, src.instance_variable_get(:@prefetched))
+      type_cache = src.instance_variable_get(:@type_cache)
+      assert_equal('The test value', type_cache[N::AS_TEST_PREDS.the_rel1.to_s].first)
+    end
+    
+    def test_prefetch_finder
+      srcs = TaliaCore::ActiveSource.find(:all, :prefetch_relations => true)
+      src = srcs.detect { |s| s.uri.to_s == 'http://testy.com/testme/hard'}
+      assert(src)
+      assert_equal(true, src.instance_variable_get(:@prefetched))
+      type_cache = src.instance_variable_get(:@type_cache)
+      assert(type_cache)
+      assert_equal('The test value', type_cache[N::AS_TEST_PREDS.the_rel1.to_s].first)
+      assert_equal('The test value', src.predicate(:as_test_preds, :the_rel1).first)
+    end
+    
+    def test_prefetch_count
+      count = TaliaCore::ActiveSource.count(:prefetch_relations => true)
+      real_count = TaliaCore::ActiveSource.count
+      assert_equal(count, real_count)
     end
     
     def test_inverse_predicates
@@ -308,6 +372,11 @@ module TaliaCore
       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)
+    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)
@@ -446,6 +515,13 @@ module TaliaCore
       assert(!ActiveSource.db_attr?('http://www.foobar.org/'))
     end
     
+    def test_db_id
+      assert(ActiveSource.db_attr?(:id))
+      assert(ActiveSource.db_attr?('id'))
+      assert_equal(active_sources(:testy)['id'], active_sources(:testy)[:id])
+      assert_equal(active_sources(:testy)['id'], active_sources(:testy).id)
+    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'))
@@ -459,7 +535,7 @@ module TaliaCore
       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_kind_of(SourceTypes::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
@@ -521,6 +597,11 @@ module TaliaCore
       assert_property(src[N::RDF.relatit], N::LOCAL.as_create_attr_dummy_1, N::LOCAL.as_create_attr_dummy_1)
     end
     
+    def test_create_with_attributes_plain_uri
+      src = ActiveSource.new(:uri => 'test_create_with_attributes_plain_uri')
+      assert_equal(N::LOCAL.test_create_with_attributes_plain_uri, src.uri)
+    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)
@@ -536,7 +617,7 @@ module TaliaCore
       xml = src.to_xml
       # Quickly change something inside, but leave the URL
       xml.gsub!('valueFOOOO', 'valorz')
-      new_src = ActiveSource.create_from_xml(xml)
+      new_src = ActiveSource.create_from_xml(xml, 'duplicates' => 'update')
       # Now test as above
       assert_equal(src.uri.to_s, new_src.uri.to_s)
       assert_equal('valorz', new_src[N::LOCAL.localthi].first)
@@ -549,7 +630,7 @@ module TaliaCore
         { :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' }
       ]
-      ActiveSource.create_multi_from(src_attribs)
+      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)
@@ -562,13 +643,16 @@ module TaliaCore
     
     
     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' => 'TaliaCore::DummySource')
+      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' => 'TaliaCore::SourceTypes::DummySource')
       xml = src.to_xml
-      assert_kind_of(TaliaCore::DummySource, src)
+      assert_kind_of(TaliaCore::SourceTypes::DummySource, src)
       # 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')
+      # The next is for the 'type' semantic triple already existing
       xml.gsub!('DummySource', 'SingularAccessorTest')
-      new_src = ActiveSource.create_from_xml(xml)
+      new_src = ActiveSource.create_from_xml(xml, :duplicates => :update)
       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)
@@ -578,13 +662,12 @@ module TaliaCore
     end
     
     def test_create_with_file
-      test_file = File.join(ActiveSupport::TestCase.fixture_path, 'generic_test.xml')
-      src = ActiveSource.create_source(:uri => 'http://as_test/create_with_file', 'type' => 'TaliaCore::Source', 'files' => {'url' => test_file })
+      src = ActiveSource.create_source(:uri => 'http://as_test/create_with_file', 'type' => 'TaliaCore::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|
+      File.open(@test_file) do |io|
         assert_equal(src.data_records.first.all_text, io.read)
       end
     end
@@ -615,7 +698,61 @@ module TaliaCore
       assert_equal(0, data.size)
       data = data_source.data("SimpleText", "noop.txt")
       assert_nil(data)
-    end 
+    end
+    
+    def test_update_source_skip
+      src = ActiveSource.create_source(:uri => 'http://as_test/update_source_skip', ':localthi' => 'value', 'rdf:somethi' => 'value2', 'type' => 'TaliaCore::Source', 'files' => {'url' => @test_file })
+      src.save!
+      src.update_source({ ':localthi' => ['value2', 'value3'] }, :skip)
+      assert_property(src[N::LOCAL.localthi], 'value')
+      assert_property(src[N::RDF.somethi], 'value2')
+      assert_equal(1, src.data_records.size)
+    end
+    
+    def test_update_source_skip_dummy
+      src = ActiveSource.create_source(:uri => 'http://as_test/update_source_skip_dummy', ':localthi' => 'value', 'rdf:somethi' => 'value2', 'type' => 'TaliaCore::SourceTypes::DummySource')
+      src.save!
+      assert_kind_of(SourceTypes::DummySource, src)
+      src.update_source({ ':localthi' => ['value2', 'value3'] }, :skip)
+      assert_property(src[N::LOCAL.localthi], 'value2', 'value3')
+      assert_property(src[N::RDF.somethi], 'value2')
+    end
+    
+    def test_update_source_overwrite
+      src = ActiveSource.create_source(:uri => 'http://as_test/update_source_overwrite', ':localthi' => 'value', 'rdf:somethi' => 'value2', 'type' => 'TaliaCore::Source', 'files' => {'url' => @test_file })
+      src.save!
+      new_file = File.join(ActiveSupport::TestCase.fixture_path, 'tiny.jpg')
+      src.update_source({ ':localthi' => ['value2', 'value3'] }, :overwrite)
+      assert_property(src[N::LOCAL.localthi], 'value2', 'value3')
+      assert_property(src[N::RDF.somethi])
+      assert_equal(0, src.data_records.size)
+    end
+    
+    def test_update_source_update
+      src = ActiveSource.create_source(:uri => 'http://as_test/update_source_update', ':localthi' => 'value', 'rdf:somethi' => 'value2', 'type' => 'TaliaCore::Source', 'files' => {'url' => @test_file })
+      src.save!
+      new_file = File.join(ActiveSupport::TestCase.fixture_path, 'tiny.jpg')
+      src.update_source({ ':localthi' => ['value2', 'value3'], 'files' => {'url' => new_file } }, :update)
+      assert_property(src[N::LOCAL.localthi], 'value2', 'value3')
+      assert_property(src[N::RDF.somethi], 'value2')
+      assert_kind_of(DataTypes::IipData, src.data_records.first)
+    end
+    
+    def test_update_source_add
+      src = ActiveSource.create_source(:uri => 'http://as_test/update_source_add', ':localthi' => 'value', 'rdf:somethi' => 'value2', 'type' => 'TaliaCore::Source', 'files' => {'url' => @test_file })
+      src.save!
+      new_file = File.join(ActiveSupport::TestCase.fixture_path, 'tiny.jpg')
+      src.update_source({ ':localthi' => ['value2', 'value3'], 'files' => {'url' => new_file } }, :add)
+      assert_property(src[N::LOCAL.localthi], 'value', 'value2', 'value3')
+      assert_property(src[N::RDF.somethi], 'value2')
+      # Expect 2 records: The original, the iip image and the orig_image
+      assert_equal(3, src.data_records.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
     
     private
     

data/test/talia_core/generic_xml_test.rb

@@ -36,10 +36,11 @@ module TaliaCore
       setup_once(:test_xml) do
         File.open(TestHelper.fixture_file('generic_test.xml')) { |io| io.read }
       end
+      
       setup_once(:imported) do
-        import = GenericImporterTest.sources_from(@test_xml)
-        import
+        GenericImporterTest.sources_from(@test_xml)
       end
+      
       setup_once(:sources) do
         sources = {}
         @imported.each do |el| 
@@ -48,6 +49,17 @@ module TaliaCore
         end
         sources
       end
+      
+      setup_once(:reader_fs) do
+        GenericImporterTest.new(@test_xml)
+      end
+      
+      setup_once(:reader_net) do
+        reader = GenericImporterTest.new(@test_xml)
+        reader.base_file_url = 'http://www.talia.org/foobar/moff'
+        reader
+      end
+      
       # setup_once(:source_objects) do 
       #   ActiveSource.create_from_xml(@test_xml, "TaliaCore::GenericImporterTest")
       # end
@@ -75,6 +87,38 @@ module TaliaCore
       assert_equal(['<http://www.otherfoo.com/>'], @sources['http://first_sub/Y'][N::TALIA.part_of.to_s])
     end
     
+    def test_absolute_url_absolute
+      assert_equal('/file', @reader_fs.send(:get_absolute_file_url, '/file'))
+    end
+    
+    def test_absolute_url_relative
+      assert_equal(File.join(TALIA_ROOT, 'file'), @reader_fs.send(:get_absolute_file_url, 'file'))
+    end
+    
+    def test_absolute_net_url_on_fs
+      assert_equal('http://foobar.com/', @reader_fs.send(:get_absolute_file_url, 'http://foobar.com/'))
+    end
+    
+    def test_absolute_net_url
+      assert_equal('http://foobar.com/', @reader_net.send(:get_absolute_file_url, 'http://foobar.com/'))
+    end
+    
+    def test_relative_net_path
+       assert_equal('http://www.talia.org/foobar/file', @reader_net.send(:get_absolute_file_url, 'file'))
+    end
+    
+    def test_absolute_net_path
+       assert_equal('http://www.talia.org/file', @reader_net.send(:get_absolute_file_url, '/file'))
+    end
+    
+    def test_file_url_on_net_absolute
+      assert_equal('/test/file', @reader_net.send(:get_absolute_file_url, 'file:///test/file'))
+    end
+    
+    def test_file_url_on_net_relative
+      assert_equal('test/file', @reader_net.send(:get_absolute_file_url, 'file://test/file'))
+    end
+    
     # def test_create
     #   assert(@source_objects)
     # end

data/test/talia_core/initializer_test.rb

@@ -19,7 +19,6 @@ module TaliaCore
     # Test namespaces
     def test_namespaces
       assert(N::LOCAL.to_s, "http://localnode.org/")
-      assert_equal(N::DEFAULT.to_s, "http://default.talia.eu/")
       assert_equal(N::FOO.to_s, "http://foo.com/")
       assert_kind_of(N::Namespace, N::FOO)
     end