rroonga 1.2.0 → 1.2.1

data/test/groonga-test-utils.rb

@@ -18,12 +18,7 @@ require 'pathname'
 require 'time'
 require 'erb'
 require 'stringio'
-begin
-  require 'json'
-rescue LoadError
-  require 'rubygems'
-  require 'json'
-end
+require 'json'
 require 'pkg-config'
 
 require 'groonga'

data/test/run-test.rb

@@ -20,44 +20,27 @@ $VERBOSE = true
 $KCODE = "u" if RUBY_VERSION < "1.9"
 
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-test_unit_dir = File.join(base_dir, "test-unit")
-test_unit_lib_dir = File.join(test_unit_dir, "lib")
-test_unit_notify_dir = File.join(base_dir, "test-unit-notify")
-test_unit_notify_lib_dir = File.join(test_unit_notify_dir, "lib")
 ext_dir = File.join(base_dir, "ext", "groonga")
 lib_dir = File.join(base_dir, "lib")
 test_dir = File.join(base_dir, "test")
 
 make = nil
-if system("which gmake > /dev/null")
-  make = "gmake"
-elsif system("which make > /dev/null")
-  make = "make"
+if ENV["NO_MAKE"] != "yes"
+  if system("which gmake > /dev/null")
+    make = "gmake"
+  elsif system("which make > /dev/null")
+    make = "make"
+  end
 end
 if make
   system("cd #{base_dir.dump} && #{make} > /dev/null") or exit(false)
 end
 
-test_unit_repository_base = "http://test-unit.rubyforge.org/svn/"
-unless File.exist?(test_unit_dir)
-  test_unit_repository = "#{test_unit_repository_base}trunk/"
-  system("svn", "co", test_unit_repository, test_unit_dir) or exit(false)
-end
-
-unless File.exist?(test_unit_notify_dir)
-  test_unit_notify_repository = "#{test_unit_repository_base}/extensions/test-unit-notify/trunk/"
-  system("svn", "co", test_unit_notify_repository, test_unit_notify_dir) or exit(false)
-  system("svn", "up", test_unit_dir) or exit(false)
-end
+require "rubygems"
+gem "test-unit-notify"
+require "test/unit/notify"
 
-$LOAD_PATH.unshift(test_unit_lib_dir)
-$LOAD_PATH.unshift(test_unit_notify_lib_dir)
-
-require 'test/unit'
-require 'test/unit/notify'
-
-ARGV.unshift("--priority-mode")
-ARGV.unshift("--notify")
+Test::Unit::Priority.enable
 
 $LOAD_PATH.unshift(ext_dir)
 $LOAD_PATH.unshift(lib_dir)
@@ -73,4 +56,6 @@ Dir.glob("#{base_dir}/test/**/test{_,-}*.rb") do |file|
   require file.sub(/\.rb$/, '')
 end
 
-exit Test::Unit::AutoRunner.run(false)
+ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] ||= "5000"
+
+exit Test::Unit::AutoRunner.run

data/test/test-column.rb

@@ -316,6 +316,10 @@ class ColumnTest < Test::Unit::TestCase
                  title.indexes)
   end
 
+  def test_builtin?
+    assert_not_predicate(@users_name_column, :builtin?)
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records

data/test/test-database-dumper.rb

@@ -21,6 +21,13 @@ class DatabaseDumperTest < Test::Unit::TestCase
   setup
   def setup_tables
     Groonga::Schema.define do |schema|
+      schema.create_table("Tags",
+                          :type => :hash,
+                          :key_type => :short_text,
+                          :default_tokenizer => :delimit) do |table|
+        table.text("name")
+      end
+
       schema.create_table("Users",
                           :type => :hash,
                           :key_type => "ShortText") do |table|
@@ -32,7 +39,8 @@ class DatabaseDumperTest < Test::Unit::TestCase
         table.reference("author", "Users")
         table.integer("rank")
         table.unsigned_integer("n_goods")
-        table.text("tags", :type => :vector)
+        table.short_text("tag_text")
+        table.reference("tags", "Tags", :type => :vector)
         table.boolean("published")
         table.time("created_at")
       end
@@ -40,6 +48,10 @@ class DatabaseDumperTest < Test::Unit::TestCase
       schema.change_table("Users") do |table|
         table.index("Posts.author")
       end
+
+      schema.change_table("Tags") do |table|
+        table.index("Posts.tag_text")
+      end
     end
   end
 
@@ -59,13 +71,19 @@ column_create Posts created_at COLUMN_SCALAR Time
 column_create Posts n_goods COLUMN_SCALAR UInt32
 column_create Posts published COLUMN_SCALAR Bool
 column_create Posts rank COLUMN_SCALAR Int32
-column_create Posts tags COLUMN_VECTOR Text
+column_create Posts tag_text COLUMN_SCALAR ShortText
 column_create Posts title COLUMN_SCALAR Text
 
+table_create Tags TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenDelimit
+column_create Tags name COLUMN_SCALAR Text
+
 table_create Users TABLE_HASH_KEY --key_type ShortText
 column_create Users name COLUMN_SCALAR Text
 
 column_create Posts author COLUMN_SCALAR Users
+column_create Posts tags COLUMN_VECTOR Tags
+
+column_create Tags Posts_tag_text COLUMN_INDEX Posts tag_text
 
 column_create Users Posts_author COLUMN_INDEX Posts author
 EOS
@@ -85,6 +103,7 @@ EOS
                 :n_goods => 4,
                 :published => true,
                 :rank => 10,
+                :tag_text => "search mori",
                 :tags => ["search", "mori"],
                 :title => "Why search engine find?")
     end
@@ -95,8 +114,15 @@ EOS
 
 load --table Posts
 [
-["_id","author","created_at","n_goods","published","rank","tags","title"],
-[1,"mori",1268034720.0,4,true,10,["search","mori"],"Why search engine find?"]
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
 ]
 
 load --table Users
@@ -113,8 +139,8 @@ EOS
 
 load --table Posts
 [
-["_id","author","created_at","n_goods","published","rank","tags","title"],
-[1,"mori",1268034720.0,4,true,10,["search","mori"],"Why search engine find?"]
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
 ]
 EOS
     end
@@ -125,8 +151,8 @@ EOS
 
 load --table Posts
 [
-["_id","author","created_at","n_goods","published","rank","tags","title"],
-[1,"mori",1268034720.0,4,true,10,["search","mori"],"Why search engine find?"]
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
 ]
 EOS
     end
@@ -135,8 +161,15 @@ EOS
       assert_equal(<<-EOS, dump(:dump_schema => false))
 load --table Posts
 [
-["_id","author","created_at","n_goods","published","rank","tags","title"],
-[1,"mori",1268034720.0,4,true,10,["search","mori"],"Why search engine find?"]
+["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
+[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
+]
+
+load --table Tags
+[
+["_key","name"],
+["search",""],
+["mori",""]
 ]
 
 load --table Users
@@ -153,4 +186,14 @@ EOS
 EOS
     end
   end
+
+  class PluginTest < DatabaseDumperTest
+    def test_standard_plugin
+      Groonga::Plugin.register("suggest/suggest")
+      assert_equal("register suggest/suggest\n" +
+                   "\n" +
+                   dumped_schema,
+                   dump)
+    end
+  end
 end

data/test/test-hash.rb

@@ -253,8 +253,8 @@ class HashTest < Test::Unit::TestCase
     key = "niku"
     niku = users.add(key)
     assert_equal({
-                   "id" => niku.id,
-                   "key" => key,
+                   "_id" => niku.id,
+                   "_key" => key,
                    "self_introduction" => nil,
                    "age" => 0,
                  },
@@ -264,8 +264,8 @@ class HashTest < Test::Unit::TestCase
       "age" => 29
     }
     assert_equal({
-                   "id" => niku.id,
-                   "key" => key,
+                   "_id" => niku.id,
+                   "_key" => key,
                    "self_introduction" => "I'm a meet lover.",
                    "age" => 29,
                  },
@@ -285,8 +285,8 @@ class HashTest < Test::Unit::TestCase
     }
 
     assert_equal({
-                   "id" => users[key].id,
-                   "key" => key,
+                   "_id" => users[key].id,
+                   "_key" => key,
                    "self_introduction" => "I'm a meet lover.",
                    "age" => 29,
                  },

data/test/test-index-cursor.rb

@@ -0,0 +1,93 @@
+class IndexCursorTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+    setup_schema
+    setup_records
+  end
+
+  def test_open_cursor
+    postings = []
+    @terms.open_cursor do |table_cursor|
+      index_cursor = nil
+      @content_index.open_cursor(table_cursor) do |cursor|
+        cursor.each do |posting|
+          postings << posting.to_hash
+        end
+        index_cursor = cursor
+      end
+      assert_predicate(index_cursor, :closed?)
+    end
+
+    assert_equal(expected_postings, postings)
+  end
+
+  def test_enumerable
+    postings = nil
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        postings = cursor.collect do |posting|
+          posting.to_hash
+        end
+      end
+    end
+
+    assert_equal(expected_postings, postings)
+  end
+
+  private
+  def create_hashes(keys, values)
+    hashes = []
+    values.each do |value|
+      hash = {}
+      keys.each_with_index do |key, i|
+        hash[key] = value[i]
+      end
+      hashes << hash
+    end
+    hashes
+  end
+
+  def setup_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Articles") do |table|
+        table.text("content")
+      end
+
+      schema.create_table("Terms",
+                          :type => :hash,
+                          :default_tokenizer => :bigram_split_symbol_alpha) do |table|
+        table.index("Articles.content")
+      end
+    end
+
+    @articles = Groonga["Articles"]
+    @terms = Groonga["Terms"]
+    @content_index = Groonga["Terms.Articles_content"]
+  end
+
+  def setup_records
+    @articles.add(:content => "l")
+    @articles.add(:content => "ll")
+    @articles.add(:content => "hello")
+  end
+
+  def expected_postings
+    parameters = [:record_id, :section_id, :term_id, :position,
+                  :term_frequency, :weight, :n_rest_postings]
+
+    expected = [
+                [1, 1, 1, 0, 1, 0, 1],
+                [2, 1, 1, 0, 1, 0, 1],
+                [2, 1, 2, 0, 1, 0, 1],
+                [3, 1, 2, 0, 1, 0, 1],
+                [3, 1, 3, 0, 1, 0, 0],
+                [3, 1, 4, 1, 1, 0, 0],
+                [3, 1, 5, 3, 1, 0, 0],
+                [3, 1, 6, 4, 1, 0, 0]
+               ]
+
+    create_hashes(parameters, expected)
+  end
+end

data/test/test-plugin.rb

@@ -26,4 +26,10 @@ class PluginTest < Test::Unit::TestCase
     context.register_plugin("suggest/suggest")
     assert_not_nil(context["suggest"])
   end
+
+  def test_system_plugins_dir
+    suggest_plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"
+    suggest_plugin_path << "suggest/suggest#{Groonga::Plugin.suffix}"
+    assert_send([File, :exist?, suggest_plugin_path])
+  end
 end

data/test/test-record.rb

@@ -300,12 +300,156 @@ class RecordTest < Test::Unit::TestCase
       "comment" => "Grate!"
     }
     groonga = @bookmarks.add(values)
-    assert_equal(values.merge("id" => groonga.id,
+    assert_equal(values.merge("_id" => groonga.id,
                               "content" => nil,
                               "user" => nil),
                  groonga.attributes)
   end
 
+  def test_recursive_attributes
+    @bookmarks.define_column("next", @bookmarks)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+
+    top_page_record["next"] = doc_page_record
+    doc_page_record["next"] = top_page_record
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "next" => {
+        "_id" => 2,
+        "user" => nil,
+        "uri" => "http://groonga.org/document.html",
+        "rate" => 8,
+        "next" => {
+          "_table" => "Bookmarks",
+          "_id" => 1,
+        },
+        "content" => nil,
+        "comment" => "Informative"
+      },
+      "content" => nil,
+      "comment" => "Great!"
+    }
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_select_result_attributes
+    top_page_record = @bookmarks.add(top_page)
+    select_result = @bookmarks.select
+    select_result_result = select_result.first
+
+    expected_attributes = {
+      "_id" => 1,
+      "_key" => {
+        "comment" => "Great!",
+        "content" => nil,
+        "_id" => 1,
+        "rate" => 5,
+        "uri" => "http://groonga.org/",
+        "user" => nil
+      },
+      "_nsubrecs" => 1,
+      "_score" => 1,
+    }
+
+    assert_equal(expected_attributes, select_result_result.attributes)
+  end
+
+  def test_self_referencing_attributes
+    @bookmarks.define_column("next", @bookmarks)
+
+    top_page_record = @bookmarks.add(top_page)
+    top_page_record["next"] = top_page_record
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "next" => {
+        "_table" => "Bookmarks",
+        "_id" => 1
+      },
+      "content" => nil,
+      "comment" => "Great!"
+    }
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_vector_attributes
+    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+    top_page_record["related_bookmarks"] = [doc_page_record]
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "related_bookmarks" => [
+        {
+          "_id" => 2,
+          "comment" => "Informative",
+          "content" => nil,
+          "rate" => 8,
+          "related_bookmarks" => [],
+          "uri" => "http://groonga.org/document.html",
+          "user" => nil,
+        }
+      ],
+      "content" => nil,
+      "comment" => "Great!"
+    }
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_self_referencing_vector_attributes
+    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+    top_page_record["related_bookmarks"] = [
+      top_page_record,
+      doc_page_record
+    ]
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "related_bookmarks" => [
+        {
+          "_table" => "Bookmarks",
+          "_id" => 1
+        },
+        {
+          "_id" => 2,
+          "comment" => "Informative",
+          "content" => nil,
+          "rate" => 8,
+          "related_bookmarks" => [],
+          "uri" => "http://groonga.org/document.html",
+          "user" => nil,
+        }
+      ],
+      "content" => nil,
+      "comment" => "Great!"
+    }
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
   def test_dynamic_accessor
     groonga = @bookmarks.add
     assert_equal([],
@@ -358,4 +502,21 @@ class RecordTest < Test::Unit::TestCase
     kou = @users.add("kou")
     kou.addresses = array_like_object
   end
+
+  private
+  def top_page
+    {
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "comment" => "Great!",
+    }
+  end
+
+  def doc_page
+    {
+      "uri" => "http://groonga.org/document.html",
+      "rate" => 8,
+      "comment" => "Informative"
+    }
+  end
 end