rroonga 2.0.2 → 2.0.3

data/test/test-index-column.rb

@@ -1,180 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 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 IndexColumnTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def setup
-    setup_database
-  end
-
-  def test_index?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_predicate(content_index, :index?)
-  end
-
-  def test_vector?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_not_predicate(content_index, :vector?)
-  end
-
-  def test_scalar?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_not_predicate(content_index, :scalar?)
-  end
-
-  def test_array_set_with_record
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-
-    content = <<-EOC
-    groonga は組み込み型の全文検索エンジンライブラリです。
-    DBMSやスクリプト言語処理系等に組み込むことによって、その
-    全文検索機能を強化することができます。また、リレーショナ
-    ルモデルに基づくデータストア機能を内包しており、groonga
-    単体でも高速なデータストアサーバとして使用することができ
-    ます。
-
-    ■全文検索方式
-    転置索引型の全文検索エンジンです。転置索引は圧縮されてファ
-    イルに格納され、検索時のディスク読み出し量を小さく、かつ
-    局所的に抑えるように設計されています。用途に応じて以下の
-    索引タイプを選択できます。
-    EOC
-
-    groonga = articles.add(:content => content)
-
-    content.split(/\n{2,}/).each_with_index do |sentence, i|
-      content_index[groonga] = {:value => sentence, :section => i + 1}
-    end
-    assert_equal([groonga],
-                 content_index.search("エンジン").collect {|record| record.key})
-  end
-
-  def test_shorter_query_than_ngram
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :source => "Articles.content")
-    articles.add(:content => 'l')
-    articles.add(:content => 'll')
-    articles.add(:content => 'hello')
-
-    assert_search(["hello"], content_index, "he")
-    assert_search(["ll", "hello"], content_index, "ll")
-    assert_search(["l", "ll", "hello"], content_index, "l")
-  end
-
-  def test_with_section?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => true,
-                   :weight => false,
-                   :position => false,
-                 },
-                 {
-                   :section => context["Tags.section"].with_section?,
-                   :weight => context["Tags.weight"].with_section?,
-                   :position => context["Tags.position"].with_section?,
-                 })
-  end
-
-  def test_with_weight?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => false,
-                   :weight => true,
-                   :position => false,
-                 },
-                 {
-                   :section => context["Tags.section"].with_weight?,
-                   :weight => context["Tags.weight"].with_weight?,
-                   :position => context["Tags.position"].with_weight?,
-                 })
-  end
-
-  def test_with_position?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => false,
-                   :weight => false,
-                   :position => true,
-                 },
-                 {
-                   :section => context["Tags.section"].with_position?,
-                   :weight => context["Tags.weight"].with_position?,
-                   :position => context["Tags.position"].with_position?,
-                 })
-  end
-
-  private
-  def assert_search(expected, content_index, keyword)
-    result = content_index.search(keyword).collect do |entry|
-      entry.key["content"]
-    end
-    assert_equal(expected, result)
-  end
-
-  def define_index_column_with_flags
-    Groonga::Schema.define do |schema|
-      schema.create_table("Articles") do |table|
-        table.text("tags", :type => :vector)
-      end
-
-      schema.create_table("Tags",
-                          :type => :patricia_trie,
-                          :key_type => "ShortText",
-                          :default_tokenizer => "TokenDelimit") do |table|
-        table.index("Articles.tags",
-                    :name => "section",
-                    :with_section => true)
-        table.index("Articles.tags",
-                    :name => "weight",
-                    :with_weight => true)
-        table.index("Articles.tags",
-                    :name => "position",
-                    :with_position => true)
-      end
-    end
-  end
-end

data/test/test-index-cursor.rb

@@ -1,93 +0,0 @@
-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-logger.rb

@@ -1,37 +0,0 @@
-# Copyright (C) 2010  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 LoggerTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def setup
-    @default_log_path = Groonga::Logger.log_path
-    @default_query_log_path = Groonga::Logger.query_log_path
-  end
-
-  def teardown
-    Groonga::Logger.log_path = @default_log_path
-    Groonga::Logger.query_log_path = @default_query_log_path
-  end
-
-  def test_reopen
-    if File.exist?(@default_log_path)
-      FileUtils.mv(@default_log_path, "#{@default_log_path}.old")
-    end
-    assert_false(File.exist?(@default_log_path))
-    Groonga::Logger.reopen
-    assert_true(File.exist?(@default_log_path))
-  end
-end

data/test/test-pagination.rb

@@ -1,249 +0,0 @@
-# Copyright (C) 2010  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 PaginationTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  setup
-  def setup_data
-    Groonga::Schema.define do |schema|
-      schema.create_table("Users",
-                          :type => :hash,
-                          :key_type => "ShortText") do |table|
-        table.uint32(:number)
-      end
-    end
-    @users = context["Users"]
-    150.times do |i|
-      @users.add("user#{i + 1}", :number => i + 1)
-    end
-  end
-
-  def test_default
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 10,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => true,
-                      :next_page => 2,
-                      :first_page? => true,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    })
-  end
-
-  def test_no_entries
-    @users.each do |user|
-      user.delete
-    end
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 10,
-                      :n_pages => 1,
-                      :n_records => 0,
-                      :start_offset => nil,
-                      :end_offset => nil,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                      :keys => [],
-                    })
-  end
-
-  def test_page
-    assert_paginate({
-                      :current_page => 6,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 51,
-                      :end_offset => 60,
-                      :have_previous_page? => true,
-                      :previous_page => 5,
-                      :have_next_page? => true,
-                      :next_page => 7,
-                      :first_page? => false,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :page => 6)
-  end
-
-  def test_max_page
-    assert_paginate({
-                      :current_page => 15,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 141,
-                      :end_offset => 150,
-                      :have_previous_page? => true,
-                      :previous_page => 14,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => false,
-                      :last_page? => true,
-                      :have_pages? => true,
-                    },
-                    :page => 15)
-  end
-
-  def test_too_large_page
-    assert_raise(Groonga::TooLargePage) do
-      assert_paginate({},
-                      :page => 16)
-    end
-  end
-
-  def test_zero_page
-    assert_raise(Groonga::TooSmallPage) do
-      assert_paginate({},
-                      :page => 0)
-    end
-  end
-
-  def test_negative_page
-    assert_raise(Groonga::TooSmallPage) do
-      assert_paginate({},
-                      :page => -1)
-    end
-  end
-
-  def test_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 7,
-                      :n_pages => 22,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 7,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => true,
-                      :next_page => 2,
-                      :first_page? => true,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :size => 7)
-  end
-
-  def test_max_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 150,
-                      :n_pages => 1,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 150,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                    },
-                    :size => 150)
-  end
-
-  def test_too_large_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 151,
-                      :n_pages => 1,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 150,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                    },
-                    :size => 151)
-  end
-
-  def test_zero_size
-    assert_raise(Groonga::TooSmallPageSize) do
-      assert_paginate({},
-                      :size => 0)
-    end
-  end
-
-  def test_negative_size
-    assert_raise(Groonga::TooSmallPageSize) do
-      assert_paginate({},
-                      :size => -1)
-    end
-  end
-
-  def test_full
-    assert_paginate({
-                      :current_page => 2,
-                      :page_size => 50,
-                      :n_pages => 3,
-                      :n_records => 150,
-                      :start_offset => 51,
-                      :end_offset => 100,
-                      :have_previous_page? => true,
-                      :previous_page => 1,
-                      :have_next_page? => true,
-                      :next_page => 3,
-                      :first_page? => false,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :page => 2,
-                    :size => 50)
-  end
-
-  private
-  def assert_paginate(expected, options={})
-    users = @users.paginate([["number"]], options)
-    if expected[:keys].nil?
-      range = (expected[:start_offset]..expected[:end_offset])
-      expected[:keys] = range.collect {|i| "user#{i}"}
-    end
-    assert_equal(expected,
-                 :current_page => users.current_page,
-                 :page_size => users.page_size,
-                 :n_pages => users.n_pages,
-                 :n_records => users.n_records,
-                 :start_offset => users.start_offset,
-                 :end_offset => users.end_offset,
-                 :previous_page => users.previous_page,
-                 :have_previous_page? => users.have_previous_page?,
-                 :next_page => users.next_page,
-                 :have_next_page? => users.have_next_page?,
-                 :first_page? => users.first_page?,
-                 :last_page? => users.last_page?,
-                 :have_pages? => users.have_pages?,
-                 :keys => users.collect(&:key))
-  end
-end