talia_core 0.4.0

data/lib/talia_util/test_helpers.rb

@@ -0,0 +1,151 @@
+module TaliaUtil
+  
+  # Test helper mixin for unit tests
+  module TestHelpers
+    
+    # Test the types of an element. Asserts if the source has the same types as
+    # given in the types argument(s)
+    def assert_types(source, *types)
+      assert_kind_of(TaliaCore::Source, source) # Just to be sure
+      type_list = ""
+      source.types.each { |type| type_list << "- Type: #{type.local_name}\n" }
+      assert_equal(types.size, source.types.size, "Type size mismatch: Source has #{source.types.size} instead of #{types.size}.\n#{type_list}")
+      types.each { |type| assert(source.types.include?(type), "#{source.uri.local_name} should have type #{type}\n#{type_list}") }
+      rdf_types = source.my_rdf[N::RDF.type].collect { |type| type.uri.to_s }
+      types.each { |type| assert(rdf_types.include?(type.to_s), "#{source.uri.local_name} should have RDF type #{type}\n#{rdf_types}")}
+    end
+    
+    # Checks if the given property has the values given to this assertion. If
+    # a value is an N::URI, this will assert if the property refers to the 
+    # 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}")
+      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
+    end
+    
+    # Creates a dummy Source and saves it
+    def make_dummy_source(uri, *types)
+      src = TaliaCore::Source.new(uri)
+      src.primary_source = true
+      types.each do |t| 
+        TaliaCore::ActiveSource.new(t).save! unless(TaliaCore::ActiveSource.exists?(:uri => t.to_s))
+        src.types << t 
+      end
+      src.save!
+      return src
+    end
+    
+    # Helper to create a variable only once. This should be used from the
+    # setup method, and will assign the given block to the given class variable.
+    # 
+    # The block will only be executed once, after that the value for the
+    # class variable will be retrieved from a cache. 
+    #
+    # This is a workaround because the Ruby test framework doesn't provide 
+    # a setup_once method or something like this, and in fact re-creates the
+    # Test case object for every single test (go figure). It would be 
+    # worth switching to RSpec just for this, but it's a heap of work so... the
+    # test framework has just the braindead "fixtures" mechanism...
+    #
+    # The thing is that's a good practice to have reasonably fine-grained tests,
+    # and you often have objects that are re-used often, are read-only for all
+    # the tests and expensive to create. So you basically want to create them
+    # only once.
+    #
+    # This thing is less than perfect, but it should work for now. Basically it
+    # assumes that all tests for a TestCase will be run in a row, and the
+    # setup method will execute before the first test and that no other tests
+    # will execute before all tests of the TestCase are executed.
+    def setup_once(variable, &block)
+      variable = variable.to_sym
+      value = self.class.obj_cache[variable]
+      unless(value)
+        value = block.call
+        self.class.obj_cache[variable] = value
+      end
+      assit_not_nil(value)
+      value ||= false # We can't have a nil value (will cause the block to re-run)
+      instance_variable_set(:"@#{variable}", value)
+    end
+    
+    # Creates a source for the given uri
+    def create_source(uri)
+      TaliaCore::Source.create!(uri)
+    end
+    
+    # Assert the given condition is false
+    def assert_not(condition, message = nil)
+      assert !condition, message
+    end
+    alias_method :assert_false, :assert_not
+
+    # Assert the given collection is empty.
+    def assert_empty(condition, message = nil)
+      assert condition.empty?, message
+    end
+    
+    # Assert the given collection is not empty.
+    def assert_not_empty(condition, message = nil)
+      assert_not condition.empty?, message
+    end
+    
+    # Assert the given element is included into the given collection.
+    def assert_included(collection, element, message = nil)
+      assert collection.include?(element), message
+    end
+    
+    # Assert the given object is instance of one of those classes.
+    def assert_kind_of_classes(object, *classes)
+      assert_included(classes, object.class,
+        "#{object} should be instance of one of those classes: #{classes.to_sentence}")
+    end
+    
+    # Assert the given object is a boolean.
+    def assert_boolean(object)
+      assert_kind_of_classes(object, TrueClass, FalseClass)
+    end
+    
+    # Assert the source for the given uri exists.
+    def assert_source_exist(uri, message = nil)
+      assert TaliaCore::Source.exists?(uri), message
+    end
+    alias_method :assert_source_exists, :assert_source_exist
+  end
+end
+
+# Add some stuff to the basic test case
+class Test::Unit::TestCase
+  include TaliaUtil::TestHelpers
+
+  protected
+  
+  # Helper variable in the class for setup_once
+  def self.obj_cache
+    @obj_cache ||= {}
+  end
+  
+  # Lets the class suppress the fixtures for the tests
+  def self.suppress_fixtures
+    @suppress_fixtures = true
+  end
+  
+  def self.suppress_fixtures?
+    @suppress_fixtures
+  end
+  
+  # Adds the possibility to completely disable the fixture mechanism of rails
+  if(method_defined?(:setup_with_fixtures) && method_defined?(:teardown_with_fixtures))
+    alias_method :setup_with_fixtures_orig, :setup_with_fixtures
+    define_method(:setup_with_fixtures) do
+      setup_with_fixtures_orig unless(self.class.suppress_fixtures?)
+    end
+    alias_method :teardown_with_fixtures_orig, :teardown_with_fixtures
+    define_method(:teardown_with_fixtures) do
+      teardown_with_fixtures_orig unless(self.class.suppress_fixtures?)
+    end
+  end
+  
+end

data/lib/talia_util/util.rb

@@ -0,0 +1,226 @@
+# Utility module for tests, rake tasks etc.
+module TaliaUtil
+  
+  # Main utility functions for Talia
+  class Util
+    class << self
+    
+      # Get the list of files from the "files" option
+      def get_files
+        puts "Files given: #{ENV['files']}"
+        unless(ENV['files'])
+          puts("This task needs files to work. Pass them like this files='something/*.x'")
+          print_options
+          exit(1)
+        end
+    
+        FileList.new(ENV['files'])
+      end
+
+      # Get the configured folder for the ontologies
+      def ontology_folder
+        ENV['ontology_folder'] || File.join(RAILS_ROOT, 'ontologies')
+      end
+
+      # Set up the ontologies from the given folder
+      def setup_ontologies
+        # Clear the ontologies from RDF, if possible
+        adapter = ConnectionPool.write_adapter
+        if(adapter.supports_context?)
+          TaliaCore::RdfImport.clear_file_contexts
+        else
+          puts "WARNING: Cannot remove old ontologies, adapter doesn't support contexts."
+        end
+
+        puts "Ontologies loaded from: #{ontology_folder}"
+        files = Dir[File.join(ontology_folder, '*.{rdf*,owl}')]
+        ENV['rdf_syntax'] ||= 'rdfxml'
+        params = [ENV['rdf_syntax'], files]
+        params << :auto if(adapter.supports_context?)
+        TaliaCore::RdfImport::import(*params)
+        RdfUpdate::owl_to_rdfs
+      end
+
+      # Init the talia core system
+      def init_talia
+        return if(TaliaCore::Initializer.initialized)
+    
+        # If options are not set, the initializer will fall back to the internal default
+        TaliaCore::Initializer.talia_root = ENV['talia_root']
+        TaliaCore::Initializer.environment = ENV['environment']
+    
+        config_file = ENV['config'] ? ENV['config'] : 'talia_core'
+    
+        # run the initializer
+        TaliaCore::Initializer.run(config_file) do |config|
+          unless(flag?('no_standalone'))
+            puts "Always using standalone db from utilities."
+            puts "Give the no_standalone option to override it."
+            config['standalone_db'] = "true"
+          end
+        end
+    
+        puts("\nTaliaCore initialized")
+    
+        # # Flush the database if requested
+        if(flag?('reset_db'))
+          flush_db
+          puts "DB flushed"
+        end
+    
+        # Flus the rdf if requested
+        if(flag?('reset_rdf'))
+          flush_rdf
+          puts "RDF flushed"
+        end
+      end
+  
+      # Get info from the Talia configuraion
+      def talia_config
+        puts "Talia configuration"
+        puts ""
+        puts "TALIA_ROOT: #{TALIA_ROOT}"
+        puts "Environment: #{TaliaCore::CONFIG['environment']}"
+        puts "Standalone DB: #{TaliaCore::CONFIG['standalone_db']}"
+        puts "Data Directory: #{TaliaCore::CONFIG['data_directory_location']}"
+        puts "Local Domain: #{N::LOCAL}"
+      end
+  
+      # Put the title for Talia
+      def title
+        puts "\nTalia Digital Library system. Version: #{TaliaCore::Version::STRING}" 
+        puts "http://www.talia.discovery-project.eu/\n\n"
+      end
+  
+      # Flush the database. This only flushes the main data tables!
+      def flush_db
+        [ 'active_sources', 'data_records', 'semantic_properties', 'semantic_relations'].reverse.each { |f| ActiveRecord::Base.connection.execute "DELETE FROM #{f}" }
+        # Also remove the "unsaved cache" for the wrappers (may be important during testing)
+        TaliaCore::SemanticCollectionWrapper.instance_variable_set(:'@unsaved_source_cache', {})
+      end
+  
+      # Flush the RDF store
+      def flush_rdf
+        ConnectionPool.write_adapter.clear
+      end
+      
+      # Remove the data directories
+      def clear_data
+        data_dir = TaliaCore::CONFIG['data_directory_location']
+        iip_dir = TaliaCore::CONFIG['iip_root_directory_location']
+        FileUtils.rm_rf(data_dir) if(File.exist?(data_dir))
+        FileUtils.rm_rf(iip_dir) if(File.exist?(iip_dir))
+      end
+      
+      
+      # Do a full reset of the data store
+      def full_reset
+        flush_db
+        flush_rdf
+        clear_data
+        setup_ontologies
+      end
+
+      # Rewrite the RDF for the whole database. Will yield without parameters
+      # for progress-reporting blocks.
+      # FIXME: At the moment, this
+      # looses all RDF data that is not in the database.
+      def rewrite_rdf
+        flush_rdf
+        # We'll get all data from single query.
+        fat_rels = TaliaCore::SemanticRelation.find(:all, :joins => fat_record_joins,
+          :select => fat_record_select)
+        fat_rels.each do |rec|
+          subject = N::URI.new(rec.subject_uri)
+          predicate = N::URI.new(rec.predicate_uri)
+          object = if(rec.object_uri)
+            N::URI.new(rec.object_uri)
+          else
+            rec.property_value
+          end
+          FederationManager.add(subject, predicate, object)
+          yield if(block_given?)
+        end
+
+        # Rewriting all the "runtime type" rdf triples
+        # We'll select the type as something else, so that it doesn't try to do
+        # STI instantiation (which would cause this to blow for classes that
+        # are defined outside the core.
+        TaliaCore::ActiveSource.find(:all, :select => 'uri, type AS runtime_type').each do |src|
+          type = (src.runtime_type || 'ActiveSource')
+          FederationManager.add(src, N::RDF.type, N::TALIA + type)
+          yield if(block_given?)
+        end
+      end
+
+      # This gives the number of triples that would be rewritten on #rewrite_rdf
+      def rewrite_count
+        TaliaCore::SemanticRelation.count + TaliaCore::ActiveSource.count
+      end
+
+      # Load the fixtures
+      def load_fixtures
+        # fixtures = ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(File.dirname(__FILE__), 'test', 'fixtures', '*.{yml,csv}'))  
+        fixtures = [ 'active_sources', 'semantic_relations', 'semantic_properties' 'data_records']
+        fixtures.reverse.each { |f| ActiveRecord::Base.connection.execute "DELETE FROM #{f}" }
+        fixtures.each do |fixture_file|
+          Fixtures.create_fixtures(File.join('test', 'fixtures'), File.basename(fixture_file, '.*'))  
+        end  
+      end
+  
+      # Do migrations
+      def do_migrations
+        migration_path = File.join("generators", "talia", "templates", "migrations")
+        ActiveRecord::Migrator.migrate(migration_path, ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
+      end
+  
+      # Check if the given flag is set on the command line
+      def flag?(the_flag)
+        assit_not_nil(the_flag)
+        ENV[the_flag] && (ENV[the_flag] == "yes" || ENV[the_flag] == "true")
+      end
+
+      # For selecting "fat" records on the semantic properties, including the
+      # objects. Used for rewriting the rdf. TODO: Review after merging
+      # with optimized branch
+      def fat_record_select
+        select = 'semantic_relations.id AS id, semantic_relations.created_at AS created_at, '
+        select << 'semantic_relations.updated_at AS updated_at, '
+        select << 'object_id, object_type, subject_id, predicate_uri, '
+        select << 'obj_props.created_at AS property_created_at, '
+        select << 'obj_props.updated_at AS property_updated_at, '
+        select << 'obj_props.value AS property_value, '
+        select << 'obj_sources.created_at AS object_created_at, '
+        select << 'obj_sources.updated_at AS object_updated_at, obj_sources.type AS  object_realtype, '
+        select << 'obj_sources.uri AS object_uri, '
+        select << 'subject_sources.uri AS subject_uri'
+        select
+      end
+
+      # Select semantic properties joined with all connected tables.
+      # TODO: Review after merging with optimized branch
+      def fat_record_joins
+        joins =  " LEFT JOIN active_sources AS obj_sources ON semantic_relations.object_id = obj_sources.id AND semantic_relations.object_type = 'TaliaCore::ActiveSource'"
+        joins << " LEFT JOIN semantic_properties AS obj_props ON semantic_relations.object_id = obj_props.id AND semantic_relations.object_type = 'TaliaCore::SemanticProperty'"
+        joins << " LEFT JOIN active_sources AS subject_sources ON semantic_relations.subject_id = subject_sources.id"
+        joins
+      end
+
+      # print the common options for the tasks
+      def print_options
+        puts "\nGeneral options (not all options are valid for all tasks):"
+        puts "files=<pattern>     - Files for the task (a pattern to match the files)"
+        puts "talia_root=<path>   - Manually configure the TALIA_ROOT path"
+        puts "                      (default:autodetect)"
+        puts "reset_rdf={yes|no}  - Flush the RDF store (default:no)"
+        puts "reset_db={yes|no}   - Flush the database (default:no)"
+        puts "config=<filename>   - Talia configuration file (default: talia_core)"
+        puts "environment=<env>   - Environment for configuration (default: development)"
+        puts "data_dir=<dir>      - Directory for the data files"
+        puts "verbose={yes|no}    - Show some additional info"
+        puts ""
+      end
+  
+    end
+  end
+end

data/lib/talia_util/yaml_import.rb

@@ -0,0 +1,80 @@
+module TaliaUtil
+  
+  # Import module for Talia data contained in YAML files
+  class YamlImport
+    class << self
+      
+      # Register the namespaces define in the data file
+      def register_namespaces(data)
+        if(data["namespaces"])
+          data["namespaces"].each do |shortcut, uri|
+            if(N::URI.shortcut_exists?(shortcut))
+              if(!N::URI[shortcut].to_s == shortcut)
+                puts "WARNING: Namespace for #{shortcut} already registered with #{N::URI[shortcut]} instead of #{uri}."
+              else
+                puts "Namespace #{shortcut} already registered."
+              end
+            else
+              N::Namespace.shortcut(shortcut, uri)
+              puts "Registered namespace #{shortcut} for #{uri}"
+            end
+          end
+          data.delete("namespaces")
+        end
+      end
+    
+      # Process multiple YAML files
+      def import_multi_files(files)
+        files.each do |file|
+          import_file(file)
+        end
+      end
+    
+      # Import the data from a YAML file
+      def import_file(datafile)
+        data = YAML::load(File.open(datafile))
+      
+        register_namespaces(data)
+      
+        progress = ProgressBar.new("Importing", data.size)
+      
+        puts "Importing data from #{datafile}..."
+      
+        data.each do |source_name, data_set|
+          puts "Processing #{source_name}" if(Util::flag?("verbose"))
+          primary_source = (data_set.delete("primary_source") == "true") ? 'true' : 'false'
+          types = data_set.delete("type")
+          types = [types] unless(types.kind_of?(Array))
+          types.compact!
+          # Create the type uris
+          types = types.collect { |type| N::URI.make_uri(type) }
+        
+          # Create the source
+          source = TaliaCore::Source.new(source_name)
+          source.talias::primary_source << primary_source ? 'true' : 'false'
+          source.types << types
+          source.save! # save the thing
+        
+          # Now add the rdf elements
+          data_set.each do |name, value|
+            uri = N::URI.make_uri(name, "#")
+            value = [value] unless(value.kind_of?(Array))
+          
+            value.each do |val|
+              val = TaliaCore::Source.new(N::URI.make_uri(val)) if(val.index(":"))
+              source[uri] << val
+            end
+          end
+        
+          source.save! # Save all
+        
+          progress.inc
+        end
+      
+        progress.finish
+        puts "Done"
+      end
+    end
+  end
+end
+  

data/lib/talia_util.rb

@@ -0,0 +1,13 @@
+# TaliaCore loader
+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'
+
+# Stuff we just load from the gems
+gem "builder"
+require "builder"

data/lib/user.rb

@@ -0,0 +1,116 @@
+require 'digest/sha1'
+class User < ActiveRecord::Base
+  include ActsAsRoled
+  has_and_belongs_to_many :roles
+  attr_accessor :roles_attributes
+  attr_accessible :roles_attributes
+  after_update :save_roles
+
+  # authorized_as? simply needs to return true or false whether a user has a role or not.  
+  # It may be a good idea to have "admin" roles return true always
+  def authorized_as?(role_name)
+    return true if role_names.include?("admin")
+    has_role?(role_name)
+  end
+
+  def has_role?(role_name)
+    role_names.include? role_name.to_s
+  end
+
+  def roles_to_sentence
+    role_names.to_sentence
+  end
+
+  # Virtual attribute for the unencrypted password
+  attr_accessor :password
+
+  validates_presence_of     :login, :email
+  validates_presence_of     :password,                   :if => :password_required?
+  validates_presence_of     :password_confirmation,      :if => :password_required?
+  validates_length_of       :password, :within => 4..40, :if => :password_required?
+  validates_confirmation_of :password,                   :if => :password_required?
+  validates_length_of       :login,    :within => 3..40
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :login, :email, :case_sensitive => false
+  before_save :encrypt_password, :normalize_open_id
+  
+  # prevents a user from submitting a crafted form that bypasses activation
+  # anything else you want your user to change should be added here.
+  attr_accessible :login, :email, :password, :password_confirmation, :open_id
+
+  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
+  def self.authenticate(login, password)
+    u = find_by_login(login) # need to get the salt
+    u && u.authenticated?(password) ? u : nil
+  end
+  
+  # Authenticates a user by their open id indentifier.  Returns the user or nil.
+  def self.open_id_authentication(identity_url)
+    u = find_by_open_id(identity_url) # need to get the salt
+    u ? u : nil
+  end
+
+  # Encrypts some data with the salt.
+  def self.encrypt(password, salt)
+    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+  end
+
+  # Encrypts the password with the user salt
+  def encrypt(password)
+    self.class.encrypt(password, salt)
+  end
+
+  def authenticated?(password)
+    crypted_password == encrypt(password)
+  end
+
+  def remember_token?
+    remember_token_expires_at && Time.now.utc < remember_token_expires_at 
+  end
+
+  # These create and unset the fields required for remembering users between browser closes
+  def remember_me
+    remember_me_for 2.weeks
+  end
+
+  def remember_me_for(time)
+    remember_me_until time.from_now.utc
+  end
+
+  def remember_me_until(time)
+    self.remember_token_expires_at = time
+    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
+    save(false)
+  end
+
+  def forget_me
+    self.remember_token_expires_at = nil
+    self.remember_token            = nil
+    save(false)
+  end
+
+  protected
+  # before filter 
+  def encrypt_password
+    return if password.blank?
+    self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
+    self.crypted_password = encrypt(password)
+  end
+
+  def normalize_open_id
+    self.open_id = OpenIdAuthentication.normalize_url(open_id) unless open_id.blank?
+  end
+
+  def password_required?
+    crypted_password.blank? || !password.blank?
+  end
+    
+  def role_names
+    @role_names ||= self.roles.map(&:name)
+  end
+    
+  def save_roles
+    return if roles_attributes.nil?
+    self.roles = Role.find_by_names(roles_attributes)
+  end
+end

data/lib/version.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+
+module TaliaCore #:nodoc:
+  module Version #:nodoc:
+    
+    version = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'VERSION.yml'))
+
+    MAJOR = version[:major]
+    MINOR = version[:minor]
+    TINY  = version[:patch]
+
+    STRING = [ MAJOR, MINOR, TINY ].join(".")
+
+  end
+end

data/test/core_ext/string_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'core_ext', 'string')
+
+class StringTest < Test::Unit::TestCase
+  def test_to_permalink
+    assert_equal('Should_Strip_All_Non_Word_Chars', 'should strip *all* non-word chars!'.to_permalink)
+    assert_equal('Should_Strip_White_Spaces', 'should strip    white    spaces'.to_permalink)
+    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
+end

data/test/custom_template_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CustomTemplateTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/talia_core/active_source_predicate_test.rb

@@ -0,0 +1,54 @@
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+module TaliaCore
+
+  # Test the ActiveSource
+  class ActiveSourcePredicateTest < Test::Unit::TestCase
+
+    def setup
+      setup_once(:flush) do
+        TaliaUtil::Util.flush_rdf
+        TaliaUtil::Util.flush_db
+        true
+      end
+    end
+
+    def test_each_cached
+      src = ActiveSource.new('http://pred_test/each_cached')
+      src[N::RDF.rew] << 'value'
+      cached = []
+      src.each_cached_wrapper do |w|
+        cached << w
+      end
+      assert_equal(1, cached.size)
+    end
+    
+    def test_cached_predicate
+      src = ActiveSource.new('http://pred_test/cached_predicate')
+      src[N::RDF.rew] << 'value'
+      # We assume that the cached thing is now in the internal structure
+      w = src.instance_variable_get(:@type_cache)[N::RDF.rew.to_s]
+      items = w.instance_variable_get(:@items)
+      assert_kind_of(Array, items)
+      assert_equal(['value'], items.collect { |i| i.value })
+      assert_same(src[N::RDF.rew], w)
+    end
+
+    def test_cached_after_save
+      src = ActiveSource.new('http://pred_test/cached_after_save')
+      src[N::RDF.rew] << 'value'
+      src.save!
+      # We assume that the cached thing is now in the internal structure
+      w = src.instance_variable_get(:@type_cache)[N::RDF.rew.to_s]
+      items = w.send(:items) # This should correctly reload the items
+      assert_kind_of(Array, items)
+      assert_equal(['value'], items.collect { |i| i.value })
+      assert_same(src[N::RDF.rew], w)
+      # Check if the RDF was updated. The RDF must be updated from the cached wrappers
+      # before the wrappers are saved themselves
+      assert_equal(['value'], src.my_rdf[N::RDF.rew], "Mismatch of the RDF, maybe the callbacks in wrong order?")
+    end
+
+  end
+end