rroonga 2.0.2 → 2.0.3

data/test/test-command-select.rb

@@ -1,147 +0,0 @@
-# Copyright (C) 2010-2012  Kouhei Sutou <kou@clear-code.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-class CommandSelectTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-  setup
-  def setup_data
-    Groonga::Schema.define do |schema|
-      schema.create_table("Books",
-                          :type => :hash, :key_type => "ShortText") do |table|
-        table.time("published")
-      end
-
-      schema.create_table("Users",
-                          :type => :hash, :key_type => "ShortText") do |table|
-        table.reference("book", "Books")
-      end
-
-      schema.create_table("Bigram",
-                          :type => :patricia_trie,
-                          :key_type => "ShortText",
-                          :default_tokenizer => "TokenBigramSplitSymbolAlpha") do |table|
-        table.index("Books._key")
-      end
-    end
-
-    @books = Groonga["Books"]
-    @users = Groonga["Users"]
-
-    @books.add("the groonga book", :published => Time.parse("2010/04/01"))
-    @books.add("the groonga book (2)", :published => Time.parse("2011/04/01"))
-
-    @users.add("morita", :book => "the groonga book")
-    @users.add("gunyara-kun", :book => "the groonga book")
-    @users.add("yu")
-    @users.add("ryoqun", :book => "the groonga book (2)")
-  end
-
-  def test_no_option
-    result = context.select(@users)
-    assert_equal([4,
-                  [{"_id" => 1, "_key" => "morita",
-                     "book" => "the groonga book"},
-                   {"_id" => 2, "_key" => "gunyara-kun",
-                     "book" => "the groonga book"},
-                   {"_id" => 3, "_key" => "yu",
-                     "book" => ""},
-                   {"_id" => 4, "_key" => "ryoqun",
-                     "book" => "the groonga book (2)"}]],
-                 [result.n_hits, result.records])
-  end
-
-  def test_output_columns
-    result = context.select(@users, :output_columns => ["_key"])
-    assert_equal([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}]],
-                 [result.n_hits, result.records])
-  end
-
-  def test_drill_down
-    result = context.select(@users,
-                            :output_columns => ["_key"],
-                            :drill_down => ["_key", "book"],
-                            :drill_down_output_columns => "_key",
-                            :drill_down_limit => 10)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}],
-                  {
-                    "_key" => [4, [{"_key" => "morita"},
-                                   {"_key" => "gunyara-kun"},
-                                   {"_key" => "yu"},
-                                   {"_key" => "ryoqun"}]],
-                    "book" => [2, [{"_key" => "the groonga book"},
-                                   {"_key" => "the groonga book (2)"}]],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-
-  def test_drill_down_with_no_hit
-    result = context.select(@users,
-                            :filter => "_key == \"no\\ hit\"",
-                            :output_columns => ["_key"],
-                            :drill_down => ["_key", "book"],
-                            :drill_down_output_columns => "_key",
-                            :drill_down_limit => 10)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([0, [],
-                  {
-                    "_key" => [0, []],
-                    "book" => [0, []],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-
-  def test_time
-    result = context.select(@books)
-    assert_equal([{
-                    "_id" => 1,
-                    "_key" => "the groonga book",
-                    "published" => Time.parse("2010/04/01"),
-                  },
-                  {
-                    "_id" => 2,
-                    "_key" => "the groonga book (2)",
-                    "published" => Time.parse("2011/04/01"),
-                  }],
-                 result.records)
-  end
-
-  def test_invalid
-    assert_raise(Groonga::SyntaxError) do
-      context.select(@books, :query => "<")
-    end
-  end
-
-  private
-  def normalize_drill_down(drill_down)
-    normalized_drill_down = {}
-    drill_down.each do |key, drill|
-      normalized_drill_down[key] = [drill.n_hits, drill.records]
-    end
-    normalized_drill_down
-  end
-end

data/test/test-context.rb

@@ -1,130 +0,0 @@
-# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-class ContextTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_default
-    context = Groonga::Context.default
-    assert_equal(Groonga::Encoding.default, context.encoding)
-  end
-
-  def test_default_options
-    Groonga::Context.default_options = {
-      :encoding => :utf8,
-    }
-    context = Groonga::Context.default
-    assert_equal(Groonga::Encoding::UTF8, context.encoding)
-  end
-
-  def test_create_database
-    db_path = @tmp_dir + "db"
-    assert_not_predicate(db_path, :exist?)
-    context = Groonga::Context.new
-    assert_equal(nil, context.database)
-    database = context.create_database(db_path.to_s)
-    assert_predicate(db_path, :exist?)
-    assert_not_predicate(database, :closed?)
-    assert_equal(database, context.database)
-  end
-
-  def test_create_temporary_database
-    before_files = @tmp_dir.children
-    context = Groonga::Context.new
-    database = context.create_database
-    assert_nil(database.name)
-    assert_equal(before_files, @tmp_dir.children)
-  end
-
-  def test_open_database
-    db_path = @tmp_dir + "db"
-    database = Groonga::Database.create(:path => db_path.to_s)
-    database.close
-
-    assert_predicate(database, :closed?)
-    called = false
-    context = Groonga::Context.new
-    context.open_database(db_path.to_s) do |_database|
-      database = _database
-      assert_not_predicate(database, :closed?)
-      called = true
-    end
-    assert_true(called)
-    assert_predicate(database, :closed?)
-  end
-
-  def test_encoding
-    context = Groonga::Context.new
-    assert_equal(Groonga::Encoding.default, context.encoding)
-
-    context = Groonga::Context.new(:encoding => :utf8)
-    assert_equal(Groonga::Encoding::UTF8, context.encoding)
-  end
-
-  def test_inspect
-    context = Groonga::Context.new(:encoding => Groonga::Encoding::UTF8)
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <:utf8>, " +
-                 "database: <nil>>",
-                 context.inspect)
-  end
-
-  def test_inspect_with_database
-    db = Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
-                 "database: <#{db.inspect}>>",
-                 context.inspect)
-  end
-
-  def test_array_reference_by_string
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Int32", context["<int>"].name)
-  end
-
-  def test_array_reference_by_symbol
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Bool", context[:Bool].name)
-  end
-
-  def test_shortcut_access
-    Groonga::Database.create
-    assert_equal("ShortText", Groonga["ShortText"].name)
-  end
-
-  def test_support_zlib?
-    assert_boolean(Groonga::Context.default.support_zlib?)
-  end
-
-  def test_support_lzo?
-    assert_boolean(Groonga::Context.default.support_lzo?)
-  end
-
-  def test_match_escalation_threshold
-    assert_equal(0, context.match_escalation_threshold)
-    context.match_escalation_threshold = -1
-    assert_equal(-1, context.match_escalation_threshold)
-  end
-
-  def test_close
-    context = Groonga::Context.new
-    assert_false(context.closed?)
-    context.close
-    assert_true(context.closed?)
-  end
-end

data/test/test-database-dumper.rb

@@ -1,259 +0,0 @@
-# Copyright (C) 2011  Kouhei Sutou <kou@clear-code.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-class DatabaseDumperTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database, :before => :append
-
-  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|
-        table.text("name")
-      end
-
-      schema.create_table("Posts") do |table|
-        table.text("title")
-        table.reference("author", "Users")
-        table.integer("rank")
-        table.unsigned_integer("n_goods")
-        table.short_text("tag_text")
-        table.reference("tags", "Tags", :type => :vector)
-        table.boolean("published")
-        table.time("created_at")
-      end
-
-      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
-
-  private
-  def dump(options={})
-    Groonga::DatabaseDumper.new(options).dump
-  end
-
-  def posts
-    context["Posts"]
-  end
-
-  def dumped_schema
-    <<-EOS
-table_create Posts TABLE_NO_KEY
-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 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
-  end
-
-  class EmptyTest < DatabaseDumperTest
-    def test_default
-      assert_equal(dumped_schema, dump)
-    end
-  end
-
-  class HaveDataTest < DatabaseDumperTest
-    setup
-    def setup_data
-      posts.add(:author => "mori",
-                :created_at => Time.parse("2010-03-08 16:52 JST"),
-                :n_goods => 4,
-                :published => true,
-                :rank => 10,
-                :tag_text => "search mori",
-                :tags => ["search", "mori"],
-                :title => "Why search engine find?")
-    end
-
-    def test_default
-      assert_equal(<<-EOS, dump)
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_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
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_limit_tables
-      assert_equal(<<-EOS, dump(:tables => ["Posts"]))
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_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
-
-    def test_limit_tables_with_regexp
-      assert_equal(<<-EOS, dump(:tables => [/Posts?/]))
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_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
-
-    def test_exclude_tables
-      dump_options = {
-        :exclude_tables => ["Posts"],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_exclude_tables_with_regexp
-      dump_options = {
-        :exclude_tables => [/Posts?/],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_tables_combination
-      dump_options = {
-        :exclude_tables => ["Posts"],
-        :tables => ["Posts", "Users"],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_no_schema
-      assert_equal(<<-EOS, dump(:dump_schema => false))
-load --table Posts
-[
-["_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
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_no_tables
-      assert_equal(<<-EOS, dump(:dump_tables => false))
-#{dumped_schema.chomp}
-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