talia_core 0.4.0

data/test/talia_core/data_types/data_loader_test.rb

@@ -0,0 +1,123 @@
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+  # Test the DataRecord storage class
+  class DataLoaderTest < Test::Unit::TestCase
+
+    fixtures :active_sources, :data_records
+
+    WEB_TEST_URL = 'http://net7sviluppo.com/talia_test_files/'
+
+    def setup
+      setup_once(:web_test) do
+        web_test_good = false
+        begin
+          open(WEB_TEST_URL + 'generic_test.xml') do |io|
+            io.read
+          end
+          web_test_good = true
+        rescue
+          puts "*** Cannot find: #{WEB_TEST_URL + 'generic_test.xml'}, web loading test will be disabled!"
+        end
+        web_test_good
+      end
+    end
+
+    def test_create_from_file
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('generic_test.xml'))
+      assert_equal(1, loaded.size)
+      assert_kind_of(DataTypes::XmlData, loaded.first)
+    end
+
+    def test_options
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('generic_test.xml'), :location => 'foo.xml', :mime_type => 'application/pdf')
+      assert_equal(1, loaded.size)
+      assert_equal('foo.xml', loaded.first.location)
+      assert_equal('application/pdf', loaded.first.mime)
+    end
+
+    def test_data_loaded
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('generic_test.xml')).first
+      loaded.source = active_sources(:something)
+      loaded.save!
+      File.open(fixture_file('generic_test.xml')) do |io|
+        assert_equal(io.read, loaded.all_text)
+      end
+    end
+
+    def test_create_from_web
+      return unless(@web_test)
+      loaded = DataTypes::FileRecord.create_from_url(WEB_TEST_URL + 'generic_test.xml')
+      assert_equal(1, loaded.size)
+      loaded = loaded.first
+      loaded.source = active_sources(:something)
+      loaded.save!
+      File.open(fixture_file('generic_test.xml')) do |io|
+        assert_equal(io.read, loaded.all_text)
+      end
+    end
+
+    def test_create_from_image
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('tiny.jpg'))
+      assert_equal(2, loaded.size)
+      assert_equal([DataTypes::IipData, DataTypes::ImageData], loaded.collect { |t| t.class })
+      assert_equal('tiny.jpg', loaded.last.location)
+    end
+
+    def test_web_create_from_image
+      return unless(@web_test)
+      loaded = DataTypes::FileRecord.create_from_url(WEB_TEST_URL + 'tiny.jpg')
+      assert_equal(2, loaded.size)
+      assert_equal([DataTypes::IipData, DataTypes::ImageData], loaded.collect { |t| t.class })
+      assert_equal('tiny.jpg', loaded.last.location)
+    end
+    
+    def test_image_creation
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('tiny.jpg')).last
+      loaded.source = active_sources(:something)
+      loaded.save!
+      assert_equal(loaded.all_bytes, File.open(fixture_file('tiny.jpg')) { |io| io.read.unpack("C*") } )
+    end
+    
+    def test_web_image_creation
+      return unless(@web_test)
+      loaded = DataTypes::FileRecord.create_from_url(WEB_TEST_URL + 'tiny.jpg').last
+      loaded.source = active_sources(:something)
+      loaded.save!
+      assert_equal(loaded.all_bytes, File.open(fixture_file('tiny.jpg')) { |io| io.read.unpack("C*") } )
+    end
+
+    def test_create_from_image_and_convert
+      loaded = DataTypes::FileRecord.create_from_url(fixture_file('tiny.gif'))
+      assert_equal(2, loaded.size)
+      assert_equal([DataTypes::IipData, DataTypes::ImageData], loaded.collect { |t| t.class })
+      loaded.each { |element| element.source = active_sources(:something) ; element.save! }
+      assert_equal('image/png', loaded.last.mime)
+      assert_equal('tiny.png', loaded.last.location)
+    end
+
+    def test_web_create_from_image_and_convert
+      return unless(@web_test)
+      loaded = DataTypes::FileRecord.create_from_url(WEB_TEST_URL + 'tiny.gif')
+      assert_equal(2, loaded.size)
+      assert_equal([DataTypes::IipData, DataTypes::ImageData], loaded.collect { |t| t.class })
+      loaded.each { |element| element.source = active_sources(:something) ; element.save! }
+      assert_equal('image/png', loaded.last.mime)
+      assert_equal('tiny.png', loaded.last.location)
+    end
+
+    def test_convert_original_method
+      assert(DataTypes::FileRecord.convert_original?(Mime::Type.lookup('image/tiff')))
+      assert(!DataTypes::FileRecord.convert_original?(Mime::Type.lookup('image/jpeg')))
+      assert(!DataTypes::FileRecord.convert_original?(:jpeg))
+    end
+
+    private
+
+    def fixture_file(name)
+      @fixture_files = File.join(Test::Unit::TestCase.fixture_path, name)
+    end
+
+  end
+end

data/test/talia_core/data_types/data_record_test.rb

@@ -0,0 +1,40 @@
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+  # Test the DataRecord storage class
+  class DataRecordTest < Test::Unit::TestCase
+
+    fixtures :active_sources, :data_records
+
+    def setup
+      @test_records = DataTypes::DataRecord.find_data_records(Fixtures.identify(:something))
+
+      @image_mime_types = ['image/gif', 'image/jpeg', 'image/png', 'image/tiff', 'image/bmp']
+    end
+
+    # test not nil and records numbers
+    def test_records_numbers
+      assert_not_equal [], @test_records
+      assert_equal 15, @test_records.size
+    end
+
+    # test class type and mime_type
+    def test_mime_types
+      assert_kind_of(DataTypes::SimpleText, @test_records[0])
+      assert_kind_of(DataTypes::SimpleText, @test_records[1])
+      assert_equal("text/plain", @test_records[0].mime_type)
+      assert_equal("text/plain", @test_records[1].mime_type)
+    end
+
+
+
+    # test for specific classes methods
+    def test_specific_classes_methods
+      # Get a line
+      line = "LINE1: This is a simple text to check the DataRecords class\n"
+      assert_equal(line, @test_records[0].get_line)
+    end
+
+  end  
+end

data/test/talia_core/data_types/file_record_test.rb

@@ -0,0 +1,171 @@
+require 'test/unit'
+require 'fileutils'
+
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class UploadedFile < File
+  include ActionController::UploadedFile
+  attr_accessor_with_default(:content_type) { 'text/plain' }
+  alias_method :original_path, :path
+  
+  def size
+    self.class.size(original_path)
+  end
+end
+
+module TaliaCore
+
+  # Test the DataRecord storage class
+  class FileRecordTest < Test::Unit::TestCase
+  
+    fixtures :active_sources, :data_records
+    
+    def setup
+      @test_records = DataTypes::DataRecord.find_data_records(Fixtures.identify(:something))
+    end
+    
+    def test_create_from_data
+      create_from do |record|
+        record.create_from_data('loc', 'abc')
+      end
+    end
+    
+    def test_create_from_file_and_delete
+      from_file = File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'test_source_file')
+      tmp_file = File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'test_source_file_copy')
+      FileUtils.copy(from_file, tmp_file)
+      assert(File.exist?(tmp_file))
+      create_from do |record|
+        record.create_from_file('loc', tmp_file, true)
+      end
+      assert(!File.exist?(tmp_file))
+    end
+    
+    def test_create_from_file
+      create_from do |record|
+        from_file = File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'test_source_file')
+        record.create_from_file('loc', from_file)
+      end
+    end
+
+    def test_extract_filename
+      assert_equal('1', DataTypes::FileRecord.extract_filename(file))
+    end
+    
+    def test_file_should_always_return_nil
+      assert_nil(DataTypes::FileRecord.new.file)
+    end
+    
+    def test_full_filename
+      data_record = DataTypes::FileRecord.new do |dr|
+        dr.source_id = 1
+        dr.location  = 'image.jpg'
+        dr.assign_type 'image/jpeg'
+      end
+      data_record.save
+      expected = File.expand_path(File.join(File.dirname(__FILE__), '..','..', 'data_for_test', 'FileRecord', ("00" + data_record.id.to_s)[-3..-1], data_record.id.to_s)) #File.join(DataTypes::DataRecord.data_path, data_record.type, data_record.location)
+      assert_equal(expected, data_record.send(:full_filename))
+    end
+    
+        
+    def test_paths
+      tempfile_path = File.join(TALIA_ROOT, 'tmp', 'data_records')
+      data_path     = File.join(TALIA_ROOT, 'data')
+      assert_equal(tempfile_path, DataTypes::FileRecord.tempfile_path)
+      assert_equal(tempfile_path, DataTypes::FileRecord.new.send(:tempfile_path))
+      assert_equal(data_path, DataTypes::FileRecord.data_path)
+      assert_equal(data_path, DataTypes::FileRecord.new.send(:data_path))
+    end
+    
+    # test binary access
+    def test_binary_access
+      # Check initial position
+      assert_equal(0, @test_records[0].position)
+      
+      # Try to read all bytes
+      bytes = @test_records[0].all_bytes
+      assert_equal(180, bytes.size)
+      assert_equal(false, @test_records[0].is_file_open?)
+
+      # Re-check position (it should be 0)
+      assert_equal(0, @test_records[0].position)
+      
+      # Read only one bytes and check position
+      byte = @test_records[0].get_byte
+      # check byte by code (76 == 'L')
+      assert_equal(76, byte)
+      # Re-check position (it should be 1)
+      assert_equal(1, @test_records[0].position)
+    end
+    
+    # test data directory
+    def test_data_directory
+      dir_for_test = File.expand_path(@test_records[0].data_directory)
+      assert_equal(data_path_test(@test_records[0].id), dir_for_test)
+      assert( File.exists?(dir_for_test) )
+      assert_equal('temp1.txt', @test_records[0].location)
+      assert( File.exists?(File.join(data_path_test(@test_records[0]),@test_records[0].id.to_s)), "#{File.join(data_path_test(@test_records[0]), @test_records[0].id.to_s)} does not exist" )
+    end
+
+    def test_should_find_or_create_and_assign_file
+      # FIXME: I use #file and #source_id instead of fixtures,
+      # due to unpredictable ids assignment.
+      # Because test process doesn't drop tables, but just empty and re-fill them.
+      params = {:file => file, :source_id => source_id}
+      assert(DataTypes::FileRecord.find_or_create_and_assign_file(params))
+    end
+
+    # test file size
+    def test_file_size
+      assert_equal(180, @test_records[0].size)
+    end
+    
+        
+    def test_should_save_attachment
+      assert(!DataTypes::FileRecord.new.send(:save_attachment?))
+      data_record = DataTypes::FileRecord.new do |dr|
+        dr.file = file
+      end
+      assert(data_record.send(:save_attachment?))
+    end
+    
+    private
+    def data_path_test(id=nil)
+      @data_path_test ||= File.expand_path(File.join(File.dirname(__FILE__), '..','..', 'data_for_test', 'SimpleText', ("00" + id.to_s)[-3..-1]))
+    end
+
+    def file
+      UploadedFile.new(File.join(data_path_test(DataTypes::DataRecord.find(:first).id), DataTypes::DataRecord.find(:first).id.to_s))
+    end
+    
+    
+    def source_id
+      Source.find(:first)[:id]
+    end
+
+    def create_from(expected_content = 'abc')
+      data_record = DataTypes::FileRecord.new
+      yield(data_record)
+      data_record.source = TaliaCore::Source.find(:first)
+      data_record.save!
+      new_rec = DataTypes::DataRecord.find(data_record.id)
+      assert_equal(expected_content, new_rec.content_string)
+    end
+  
+    def test_class_type_from
+      ['text/plain'].each do |mime|
+        assert_equal('SimpleText', DataTypes::FileRecord.class_type_from(mime))
+      end
+
+      @image_mime_types.each { |mime| assert_equal('ImageData', DataTypes::FileRecord.class_type_from(mime)) }
+      
+      ['text/xml', 'application/xml'].each do |mime|
+        assert_equal('XmlData', DataTypes::FileRecord.class_type_from(mime))
+      end
+      
+      assert_equal('DataRecord', DataTypes::FileRecord.class_type_from('application/rtf'))
+    end
+    
+  end
+end

data/test/talia_core/data_types/iip_data_test.rb

@@ -0,0 +1,130 @@
+require 'test/unit'
+
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+  module DataType
+    
+    # Test the DataRecord storage class
+    class IipDataTest < Test::Unit::TestCase
+    
+      fixtures :active_sources, :data_records
+  
+      def setup
+        # Sets the file that is used by one test
+        @test_record = data_records(:fifteen)
+      end
+      
+      def teardown
+        # remove all subdirectory of iip root
+        Dir.foreach(TaliaCore::CONFIG["iip_root_directory_location"]) do |entry|
+          path = File.join(TaliaCore::CONFIG["iip_root_directory_location"], entry)
+          if(!['.', '..', '.svn'].include?(entry) && File.exist?(path))
+            FileUtils.remove_dir(path)
+          end
+        end
+      end
+      
+      def test_get_static_path
+        TaliaCore::CONFIG['static_data_prefix'] = nil
+        assert_nil(@test_record.static_path)
+        TaliaCore::CONFIG['static_data_prefix'] = 'preef'
+        assert_equal((N::LOCAL + 'preef/IipData/015/15').to_s, @test_record.static_path)
+      end
+      
+      # test class type and mime_type and subtype
+      def test_mime_types
+        assert_kind_of DataTypes::IipData, @test_record
+        assert_equal 'image/tiff', @test_record.mime_type
+      end
+    
+      # test data directory
+      def test_data_directory
+        dir_for_test  = File.expand_path(@test_record.data_directory)
+        assert_equal(base_dir_name(@test_record.id), dir_for_test)
+        assert(File.exists?(dir_for_test))
+        assert_equal('PATH/TO/IIPSERVER', @test_record.location)
+        assert_equal('PATH/TO/IIPSERVER', @test_record.iip_server_path)
+        assert(File.exists?(File.join(dir_for_test, @test_record.id.to_s)), "#{File.join(dir_for_test, @test_record.id.to_s)} does not exist" )
+      end
+      
+      # test file size
+      def test_file_size
+        assert_equal(711, @test_record.size)
+      end
+      
+      # test binary access
+      def test_binary_access
+        # Check initial position
+        assert_equal(0, @test_record.position)
+      
+        # Try to read all bytes
+        bytes = @test_record.all_bytes
+        assert_equal(711, bytes.size)
+        assert_equal(false, @test_record.is_file_open?)
+
+        # Try to read all bytes by alias method
+        bytes = @test_record.get_thumbnail
+        assert_equal(711, bytes.size)
+        assert_equal(false, @test_record.is_file_open?)
+      
+        # Re-check position (it should be 0)
+        assert_equal(0, @test_record.position)
+      end
+      
+      # test create from data method
+      def test_create_from_data
+        data = @test_record.all_text
+        
+        creation_test do |record|
+          record.create_from_data('', data)
+        end
+      end
+      
+      def test_create_from_file
+        creation_test do |record|
+          data_file = File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'test.jpg')
+          record.create_from_file('', data_file)
+        end
+      end
+      
+      def test_create_from_existing
+        creation_test do |record|
+          data_file = File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'test.jpg')
+          data_file = File.expand_path(data_file)
+          record.create_from_existing(data_file, data_file)
+        end
+      end
+          
+      private
+      def base_dir_name(id=nil)
+        @data_path_test ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'IipData', ("00" + id.to_s)[-3..-1]))
+      end
+      
+      def creation_test
+        new_record = DataTypes::IipData.new
+        new_record.location = ''
+        new_record.source_id = "something"
+        yield(new_record)
+        new_record.save!
+        
+        # Try to read all bytes by alias method
+        bytes = new_record.get_thumbnail
+        assert(bytes.size > 100)
+        assert_equal(false, new_record.is_file_open?)
+        # Check if the mime was written correctly
+        assert_equal('image/gif', DataTypes::IipData.find(new_record.id).mime_type)
+        
+        assert(File.exists?(new_record.file_path))
+        
+        # delete record and file
+        File.delete(new_record.file_path)
+        Dir.delete new_record.data_directory
+        DataTypes::IipData.delete new_record.id
+      end
+      
+    end
+    
+  end
+end

data/test/talia_core/data_types/image_data_test.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+
+  # Test the DataRecord storage class
+  class ImageDataTest < Test::Unit::TestCase
+  
+    fixtures :active_sources, :data_records
+     
+    def setup
+      @test_records = DataTypes::DataRecord.find_data_records(Fixtures.identify(:something))
+    end
+    
+    # test not nil and records numbers
+    def test_records_numbers
+      assert_not_equal [], @test_records
+      assert_equal 15, @test_records.size
+    end
+  
+    # test class type and mime_type and subtype
+    def test_mime_types
+      assert_kind_of(DataTypes::ImageData, @test_records[7])
+      assert_kind_of(DataTypes::ImageData, @test_records[8])
+      assert_kind_of(DataTypes::ImageData, @test_records[9])
+      assert_kind_of(DataTypes::ImageData, @test_records[10])
+      assert_kind_of(DataTypes::ImageData, @test_records[11])
+      assert_kind_of(DataTypes::ImageData, @test_records[12])
+      assert_equal("image/bmp", @test_records[7].mime_type)
+      assert_equal("image/fits", @test_records[8].mime_type)
+      assert_equal("image/gif", @test_records[9].mime_type)
+      assert_equal("image/jpeg", @test_records[10].mime_type)
+      assert_equal("image/png", @test_records[11].mime_type)
+      assert_equal("image/tiff", @test_records[12].mime_type)
+    end
+    
+    # test data directory
+    def test_data_directory
+      #base_dir_name = File.expand_path(File.join(File.dirname(__FILE__), '..', '..' , 'data_for_test', 'ImageData'))
+      dir_for_test  = File.expand_path(@test_records[7].data_directory)
+      assert_equal(base_dir_name(@test_records[7].id), dir_for_test)
+      assert(File.exists?(dir_for_test))
+      assert_equal(File.join(base_dir_name(@test_records[7].id), 'temp1.bmp'), File.join(dir_for_test, @test_records[7].location))
+      assert( File.exists?(File.join(dir_for_test, @test_records[7].id.to_s)), "#{File.join(dir_for_test, @test_records[7].id.to_s)} does not exist" )
+    end
+
+    # test file size
+    def test_file_size
+      assert_equal(1254, @test_records[7].size)
+    end
+    
+    # test binary access
+    def test_binary_access
+      # Check initial position
+      assert_equal(0, @test_records[7].position)
+      
+      # Try to read all bytes
+      bytes = @test_records[7].all_bytes
+      assert_equal(1254, bytes.size)
+      assert_equal(false, @test_records[7].is_file_open?)
+
+      
+      # Re-check position (it should be 0)
+      assert_equal(0, @test_records[7].position)
+    end
+    
+    def test_attach_image
+      test_uri = 'http://testy.com/image_attach'
+      src = Source.new(test_uri)
+      data_record = DataTypes::ImageData.new do |dr|
+        dr.location = 'my_file.jpg'
+      end
+      src.data_records << data_record
+      src.save!
+      rel = Source.find(src.id)
+      assert_equal(1, rel.data_records.size)
+      assert_kind_of(DataTypes::ImageData, rel.data_records[0])
+    end
+        
+    private
+    def base_dir_name(id=nil)
+      @data_path_test ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'ImageData', ("00" + id.to_s)[-3..-1]))
+    end
+  end
+end
+

data/test/talia_core/data_types/pdf_data_test.rb

@@ -0,0 +1,68 @@
+require 'test/unit'
+
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+  module DataType
+    
+    # Test the DataRecord storage class
+    class PdfDataTest < Test::Unit::TestCase
+    
+      fixtures :active_sources, :data_records
+  
+      def setup
+        # Sets the file that is used by one test
+        @test_records = DataTypes::DataRecord.find_data_records(Fixtures.identify(:something))
+      end
+      
+      # test not nil and records numbers
+      def test_records_numbers
+        assert_not_equal [], @test_records
+        assert_equal 15, @test_records.size
+      end
+      
+      # test class type and mime_type and subtype
+      def test_mime_types
+        assert_kind_of DataTypes::PdfData, @test_records[13]
+        assert_equal 'application/pdf', @test_records[13].mime_type
+      end
+      
+      # test data directory
+      def test_data_directory
+        dir_for_test  = File.expand_path(@test_records[13].data_directory)
+        assert_equal(base_dir_name(@test_records[13].id), dir_for_test)
+        assert(File.exists?(dir_for_test))
+        assert_equal(File.join(base_dir_name(@test_records[13].id), 'temp1.pdf'), File.join(dir_for_test, @test_records[13].location))
+        assert( File.exists?(File.join(dir_for_test, @test_records[13].id.to_s)), "#{File.join(dir_for_test, @test_records[13].id.to_s)} does not exist" )
+      end
+      
+      # test file size
+      def test_file_size
+        assert_equal(104463, @test_records[13].size)
+      end
+      
+      # test binary access
+      def test_binary_access
+        # Check initial position
+        assert_equal(0, @test_records[13].position)
+      
+        # Try to read all bytes
+        bytes = @test_records[13].all_bytes
+        assert_equal(104463, bytes.size)
+        assert_equal(false, @test_records[13].is_file_open?)
+
+      
+        # Re-check position (it should be 0)
+        assert_equal(0, @test_records[13].position)
+      end
+    
+      private
+      def base_dir_name(id=nil)
+        @data_path_test ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data_for_test', 'PdfData', ("00" + id.to_s)[-3..-1]))
+      end
+    
+    end
+    
+  end
+end