ruby-magic 0.0.1 → 0.2.0

data/test/test_constants.rb

@@ -5,7 +5,7 @@
 #
 # test_constants.rb
 #
-# Copyright 2013-2014 Krzysztof Wilczynski
+# Copyright 2013-2015 Krzysztof Wilczynski
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -27,19 +27,68 @@ rescue LoadError
   STDERR.puts 'The Coveralls gem is not installed, skipping ...'
 end
 
-gem 'test-unit', '>= 2.5.2'
+gem 'test-unit', '>= 3.0.0'
 
 require 'test/unit'
 require 'magic'
 
 class MagicConstantsTest < Test::Unit::TestCase
   def setup
+    @version = Magic.version rescue nil
   end
 
-  def teardown
+  def test_constants_defiend
+    [
+      :NONE,
+      :DEBUG,
+      :SYMLINK,
+      :COMPRESS,
+      :DEVICES,
+      :MIME_TYPE,
+      :CONTINUE,
+      :CHECK,
+      :PRESERVE_ATIME,
+      :RAW,
+      :ERROR,
+      :MIME_ENCODING,
+      :MIME,
+      :APPLE,
+      :NO_CHECK_COMPRESS,
+      :NO_CHECK_TAR,
+      :NO_CHECK_SOFT,
+      :NO_CHECK_APPTYPE,
+      :NO_CHECK_ELF,
+      :NO_CHECK_TEXT,
+      :NO_CHECK_CDF,
+      :NO_CHECK_TOKENS,
+      :NO_CHECK_ENCODING,
+      :NO_CHECK_BUILTIN,
+      :NO_CHECK_ASCII,
+      :NO_CHECK_FORTRAN,
+      :NO_CHECK_TROFF,
+    ].each {|i| assert_const_defined(Magic, i) }
   end
 
-  def test_constants
+  def test_MIME_constant
+    assert_equal(Magic::MIME, Magic::MIME_TYPE | Magic::MIME_ENCODING)
+  end
+
+  def test_NO_CHECK_BUILTIN_constat
+    # Any recent version of libmagic will have 0x37b000 by default.
+    custom_NO_CHECK_BUILTIN = Magic::NO_CHECK_COMPRESS | Magic::NO_CHECK_TAR |
+      Magic::NO_CHECK_APPTYPE | Magic::NO_CHECK_ELF | Magic::NO_CHECK_TEXT |
+      Magic::NO_CHECK_CDF | Magic::NO_CHECK_TOKENS | Magic::NO_CHECK_ENCODING
+
+    # Older versions of libmagic will have 0x3fb000 here historically ...
+    if @version.nil? && Magic::NO_CHECK_BUILTIN != 0x37b000
+      custom_NO_CHECK_BUILTIN ^= 0x080000 # 0x37b000 ^ 0x080000 is 0x3fb000
+    end
+
+    assert_equal(Magic::NO_CHECK_BUILTIN, custom_NO_CHECK_BUILTIN)
+  end
+
+  def check_NO_CHECK_ASCII_constant
+    assert_equal(Magic::NO_CHECK_ASCII, Magic::NO_CHECK_TEXT)
   end
 end
 

data/test/test_magic.rb

@@ -5,7 +5,7 @@
 #
 # test_magic.rb
 #
-# Copyright 2013-2014 Krzysztof Wilczynski
+# Copyright 2013-2015 Krzysztof Wilczynski
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -27,108 +27,261 @@ rescue LoadError
   STDERR.puts 'The Coveralls gem is not installed, skipping ...'
 end
 
-gem 'test-unit', '>= 2.5.2'
+gem 'test-unit', '>= 3.0.0'
 
 require 'test/unit'
+require "mocha/test_unit"
 require 'magic'
 
-DEFAULT_SINGLETON_METHODS = [
-  :open,
-  :mime,
-  :type,
-  :encoding,
-  :compile,
-  :check,
-  :version,
-  :version_to_a,
-  :version_to_s
-]
-
-DEFAULT_INSTANCE_METHODS = [
-  :close,
-  :closed?,
-  :path,
-  :flags,
-  :flags_array,
-  :file,
-  :buffer,
-  :descriptor,
-  :load,
-  :compile,
-  :check
-]
-
-DEFAULT_INTEGRATION_METHODS = [
-  :magic,
-  :mime,
-  :type
-]
+require_relative 'helpers/magic_test_helper'
 
 class MagicTest < Test::Unit::TestCase
+  include MagicTestHelpers
+
   def setup
     @magic = Magic.new
+    @version = Magic.version rescue nil
   end
 
-  def teardown
-    @magic.close
+  def test_magic_alias
+    assert_same(FileMagic, Magic)
   end
 
-  def test_magic_alias
-    assert(FileMagic == Magic)
+  def test_magic_flags_alias
+    assert_alias_method(@magic, :flags_array, :flags_to_a)
+  end
+
+  def test_magic_check_alias
+    assert_alias_method(@magic, :valid?, :check)
+  end
+
+  def test_magic_version_to_a_alias
+    assert_alias_method(Magic, :version_array, :version_to_a)
+  end
+
+  def test_magic_version_to_s_alias
+    assert_alias_method(Magic, :version_string, :version_to_s)
   end
 
   def test_magic_singleton_methods
-    assert_block do
-      DEFAULT_SINGLETON_METHODS.all? {|i| Magic.respond_to?(i) }
-    end
+    [
+      :open,
+      :mime,
+      :type,
+      :encoding,
+      :compile,
+      :check,
+      :version,
+      :version_to_a,
+      :version_to_s
+    ].each {|i| assert_respond_to(Magic, i) }
   end
 
   def test_magic_new_instance
     assert(@magic.class == Magic)
   end
 
-  def test_magic_instance_methods
-    assert_block do
-      DEFAULT_INSTANCE_METHODS.all? {|i| @magic.respond_to?(i) }
+  def test_magic_new_instance_default_flags
+    assert_equal(@magic.flags, 0)
+  end
+
+  def test_magic_new_with_block
+    magic, output = capture_stderr do
+      Magic.new {}
     end
+
+    expected = "Magic::new() does not take block; use Magic::open() instead\n"
+    assert_kind_of(Magic, magic)
+    assert_equal(output.split(/\.rb:\d+\:\s+?|warning:\s+?/).pop, expected)
+  end
+
+  def test_magic_instance_methods
+    [
+      :close,
+      :closed?,
+      :path,
+      :flags,
+      :flags_array,
+      :file,
+      :buffer,
+      :descriptor,
+      :load,
+      :compile,
+      :check
+    ].each {|i| assert_respond_to(@magic, i) }
+  end
+
+  def test_magic_string_integration_methods
+    [
+      :magic,
+      :mime,
+      :type
+    ].each {|i| assert_respond_to(String.allocate, i) }
+  end
+
+  def test_magic_file_integration_singleton_methods
+    [
+      :magic,
+      :mime,
+      :type
+    ].each {|i| assert_respond_to(File, i) }
+  end
+
+  def test_magic_file_integration_instance_methods
+    [
+      :magic,
+      :mime,
+      :type
+    ].each {|i| assert_respond_to(File.allocate, i) }
   end
 
   def test_magic_close
     @magic.close
+    assert_true(@magic.closed?)
+  end
+
+  def test_magic_close_twice
+    assert_nothing_raised do
+      @magic.close
+      @magic.close
+    end
+  end
 
-    assert(@magic.closed?)
+  def test_magic_close_error
+    @magic.close
     assert_raise Magic::LibraryError do
-      @magic.file('')
+      @magic.flags
     end
   end
 
+  def test_magic_close_error_message
+    @magic.close
+    @magic.flags
+  rescue Magic::LibraryError => error
+    assert_equal(error.message, 'Magic library is not open')
+  end
+
   def test_magic_closed?
-    assert_equal(@magic.closed?, false)
+    assert_false(@magic.closed?)
     @magic.close
-    assert_equal(@magic.closed?, true)
+    assert_true(@magic.closed?)
+  end
+
+  def test_magic_inspect_when_magic_open
+    assert_match(%r{^#<Magic:0x.+>$}, @magic.inspect)
   end
 
-  def test_magic_inspect
-    assert(@magic.inspect.match(%r{^#<Magic:0x.+>$}))
+  def test_magic_inspect_when_magic_closed
     @magic.close
-    assert(@magic.inspect.match(%r{^#<Magic:0x.+ \(closed\)>$}))
+    assert_match(%r{^#<Magic:0x.+ \(closed\)>$}, @magic.inspect)
   end
 
   def test_magic_path
+    assert_kind_of(Array, @magic.path)
+    assert_not_equal(@magic.path.size, 0)
+  end
+
+  def test_magic_path_with_MAGIC_environment_variable
+    # XXX(krzysztof): How to override "MAGIC" environment
+    # variable so that the C extension will pick it up?
+  end
+
+  def test_magic_flags_with_NONE_flag
+    @magic.flags = 0x000000 # Flag: NONE
+    assert_kind_of(Fixnum, @magic.flags)
+    assert_equal(@magic.flags, Magic::NONE)
+  end
+
+  def test_magic_flags_with_MIME_TYPE_flag
+    @magic.flags = 0x000010 # Flag: MIME_TYPE
+    assert_kind_of(Fixnum, @magic.flags)
+    assert_equal(@magic.flags, Magic::MIME_TYPE)
+  end
+
+  def test_magic_flags_with_MIME_ENCODING_flag
+    @magic.flags = 0x000400 # Flag: MIME_ENCODING
+    assert_kind_of(Fixnum, @magic.flags)
+    assert_equal(@magic.flags, Magic::MIME_ENCODING)
+  end
+
+  def test_magic_flags_with_MIME_flag
+    @magic.flags = 0x000410 # Flag: MIME_TYPE, MIME_ENCODING
+    assert_kind_of(Fixnum, @magic.flags)
+    assert_equal(@magic.flags, Magic::MIME)
+  end
+
+  def test_magic_flags_to_a_with_NONE_flag
+    @magic.flags = 0x000000 # Flag: NONE
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a, [Magic::NONE])
+  end
+
+  def test_magic_flags_to_a_with_MIME_TYPE_flag
+    @magic.flags = 0x000010 # Flag: MIME_TYPE
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a, [Magic::MIME_TYPE])
+  end
+
+  def test_magic_flags_to_a_with_MIME_ENCODING_flag
+    @magic.flags = 0x000400 # Flag: MIME_ENCODING
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a, [Magic::MIME_ENCODING])
   end
 
-  def test_magic_path_MAGIC_environment_variable
+  def test_magic_flags_to_a_with_MIME_flag
+    @magic.flags = 0x000410 # Flag: MIME_TYPE, MIME_ENCODING
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a, [Magic::MIME_TYPE, Magic::MIME_ENCODING])
   end
 
-  def test_magic_flags
+  def test_magic_flags_to_a_with_NONE_flag_and_argument_true
+    @magic.flags = 0x000000 # Flag: NONE
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a(true), ['NONE'])
   end
 
-  def test_magic_flags_to_a
+  def test_magic_flags_to_a_with_MIME_TYPE_flag_and_argument_true
+    @magic.flags = 0x000010 # Flag: MIME_TYPE
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a(true), ['MIME_TYPE'])
+  end
+
+  def test_magic_flags_to_a_with_MIME_ENCODING_flag_and_argument_true
+    @magic.flags = 0x000400 # Flag: MIME_ENCODING
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a(true), ['MIME_ENCODING'])
+  end
+
+  def test_magic_flags_to_a_with_MIME_flag_and_argument_true
+    @magic.flags = 0x000410 # Flag: MIME_TYPE, MIME_ENCODING
+    assert_kind_of(Array, @magic.flags_to_a)
+    assert_equal(@magic.flags_to_a(true), ['MIME_TYPE', 'MIME_ENCODING'])
+  end
+
+  def test_magic_flags_error_lower_boundary
+    assert_raise Magic::FlagsError do
+      @magic.flags = -0xffffff
+    end
+  end
+
+  def test_magic_flags_error_upper_boundary
+    assert_raise Magic::FlagsError do
+      @magic.flags = 0xffffff
+    end
+  end
+
+  def test_magic_flags_error_message
+    @magic.flags = 0xffffff
+  rescue Magic::FlagsError => error
+    assert_equal(error.message, 'unknown or invalid flag specified')
   end
 
   def test_magic_file
   end
 
+  def test_magic_file_with_ERROR_flag
+  end
+
   def test_magic_file_with_MAGIC_CONTINUE_flag
   end
 
@@ -147,19 +300,66 @@ class MagicTest < Test::Unit::TestCase
   def test_magic_load
   end
 
-  def test_magic_load_MAGIC_environment_variable
+  def test_magic_load_with_custom_Magic_file_path
   end
 
-  def test_magic_check
+  def test_magic_with_new_instance_custom_Magic_file_path
   end
 
-  def test_magic_valid?
+  def test_magic_load_with_MAGIC_environment_variable
+  end
+
+  def test_magic_check
   end
 
   def test_magic_compile
   end
 
   def test_magic_version
+    if @version.nil? || @version < 0
+      Magic.stubs(:version).returns(518)
+    end
+
+    assert_kind_of(Fixnum, Magic.version)
+    assert(Magic.version > 0)
+  end
+
+  def test_magic_version_error
+    if @version
+      Magic.stubs(:version).raises(Magic::NotImplementedError)
+    end
+
+    assert_raise Magic::NotImplementedError do
+      Magic.version
+    end
+  end
+
+  def test_magic_version_error_message
+    if @version
+      Magic.stubs(:version).raises(Magic::NotImplementedError, 'function is not implemented')
+    end
+
+    Magic.version
+  rescue Magic::NotImplementedError => error
+    assert_equal(error.message, 'function is not implemented')
+  end
+
+  def test_magic_version_to_a
+    if @version.nil? || @version < 0
+      Magic.stubs(:version).returns(518)
+    end
+
+    expected = [Magic.version / 100, Magic.version % 100]
+    assert_equal(Magic.version_to_a, expected)
+  end
+
+  def test_magic_version_to_s
+    if @version.nil? || @version < 0
+      Magic.stubs(:version).returns(518)
+    end
+
+    expected = '%d.%02d' % Magic.version_to_a
+    assert_equal(Magic.version_to_s, expected)
   end
 
   def test_magic_singleton_open
@@ -198,25 +398,29 @@ class MagicTest < Test::Unit::TestCase
   def test_magic_singleton_check
   end
 
-  def test_magic_flags_error
-  end
-
   def test_magic_magic_error
-  end
+    message = 'The quick brown fox jumps over the lazy dog'
+    error = Magic::Error.new(message)
 
-  def test_magic_library_error
+    assert_respond_to(error, :errno)
+    assert_equal(error.message, message)
+    assert_nil(error.errno)
   end
 
-  def test_magic_new_instance_with_arguments
+  def test_magic_error_attribute_errno
+    @magic.flags = 0xffffff # Should raise Magic::FlagsError.
+  rescue Magic::Error => error
+    assert_kind_of(Magic::FlagsError, error)
+    assert_equal(error.errno, Errno::EINVAL::Errno)
   end
 
-  def test_file_integration
+  def test_magic_new_instance_with_arguments
   end
 
   def test_file_integration_magic
   end
 
-  def test_file_integration_magic_custom_flag
+  def test_file_integration_magic_with_custom_flag
   end
 
   def test_file_integration_mime
@@ -228,7 +432,7 @@ class MagicTest < Test::Unit::TestCase
   def test_file_integration_singleton_magic
   end
 
-  def test_file_integration_singleton_magic_custom_flag
+  def test_file_integration_singleton_magic_with_custom_flag
   end
 
   def test_file_integration_singleton_mime
@@ -237,13 +441,10 @@ class MagicTest < Test::Unit::TestCase
   def test_file_integration_singleton_type
   end
 
-  def test_string_integration
-  end
-
   def test_string_integration_magic
   end
 
-  def test_string_integration_magic_custom_flag
+  def test_string_integration_magic_with_custom_flag
   end
 
   def test_string_integration_mime