activegroonga 0.0.7 → 1.0.0

data/test/fixtures/site.rb

@@ -0,0 +1,2 @@
+class Site < ActiveGroonga::Base
+end

data/test/run-test.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-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
@@ -17,13 +17,30 @@
 
 # $VERBOSE = true
 
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-test_unit_dir = File.join(base_dir, "test-unit", "lib")
-ruby_groonga_dir = File.expand_path(File.join(base_dir, "..", "groonga"))
-lib_dir = File.join(base_dir, "lib")
-test_dir = File.join(base_dir, "test")
+require 'pathname'
+require 'shellwords'
 
-if File.exist?(ruby_groonga_dir)
+base_dir = Pathname(__FILE__).dirname.parent.expand_path
+test_unit_dir = base_dir + "test-unit"
+test_unit_notify_dir = base_dir + "test-unit-notify"
+test_unit_repository_base = "http://test-unit.rubyforge.org/svn"
+unless test_unit_dir.exist?
+  system("svn", "co", "#{test_unit_repository_base}/trunk",
+         test_unit_dir.to_s)
+end
+unless test_unit_notify_dir.exist?
+  test_unit_notify_repository = "#{test_unit_repository_base}/extensions/test-unit-notify/trunk/"
+  system("svn", "co",
+         test_unit_notify_repository.to_s,
+         test_unit_notify_dir.to_s) or exit(false)
+  system("svn", "up", test_unit_dir.to_s) or exit(false)
+end
+
+rroonga_dir = base_dir.parent + "rroonga"
+lib_dir = base_dir + "lib"
+test_dir = base_dir + "test"
+
+if rroonga_dir.exist?
   make = nil
   if system("which gmake > /dev/null")
     make = "gmake"
@@ -31,13 +48,23 @@ if File.exist?(ruby_groonga_dir)
     make = "make"
   end
   if make
-    system("cd #{ruby_groonga_dir.dump} && #{make} > /dev/null") or exit(1)
+    escaped_rroonga_dir = Shellwords.escape(rroonga_dir.to_s)
+    system("cd #{escaped_rroonga_dir} && #{make} > /dev/null") or exit(false)
   end
+  $LOAD_PATH.unshift(rroonga_dir + "ext" + "groonga")
+  $LOAD_PATH.unshift(rroonga_dir + "lib")
 end
 
-$LOAD_PATH.unshift(test_unit_dir)
+$LOAD_PATH.unshift(test_unit_notify_dir + "lib")
+$LOAD_PATH.unshift(test_unit_dir + "lib")
+
+ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] = "10000"
 
 require 'test/unit'
+require 'test/unit/notify'
+
+ARGV.unshift("--priority-mode")
+ARGV.unshift("--notify")
 
 $LOAD_PATH.unshift(lib_dir)
 

data/test/test-associations.rb

@@ -18,7 +18,10 @@ class TestAssociations < Test::Unit::TestCase
   include ActiveGroongaTestUtils
 
   def test_belongs_to
-    groonga = Bookmark.find_by_uri("http://groonga.org/")
-    assert_equal(User.find_by_name("daijiro"), groonga.user)
+    groonga = Bookmark.select do |record|
+      record.uri == "http://groonga.org/"
+    end.first
+    assert_equal(User.select {|record| record.name == "daijiro"}.first,
+                 groonga.user)
   end
 end

data/test/test-base.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-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
@@ -17,19 +17,19 @@
 class TestBase < Test::Unit::TestCase
   include ActiveGroongaTestUtils
 
-  def test_find
-    bookmarks = Bookmark.find(:all)
+  def test_select
+    bookmarks = Bookmark.select
     assert_equal(["http://groonga.org/", "http://cutter.sourceforge.net/"].sort,
                  bookmarks.collect(&:uri).sort)
   end
 
-  def test_find_by_id
+  def test_find
     groonga = Bookmark.find(@bookmark_records[:groonga].id)
     assert_equal("http://groonga.org/", groonga.uri)
   end
 
-  def test_find_by_attribute
-    daijiro = User.find_by_name("daijiro")
+  def test_select_by_attribute
+    daijiro = User.select {|record| record.name == "daijiro"}.first
     assert_equal("daijiro", daijiro.name)
   end
 
@@ -78,11 +78,14 @@ class TestBase < Test::Unit::TestCase
   end
 
   def test_mass_updates
-    groonga = Bookmark.find_by_uri("http://groonga.org/")
+    groonga = Bookmark.select do |record|
+      record.uri == "http://groonga.org/"
+    end.first
     groonga.update_attributes({
                                 "uri" => "http://google.com/",
                                 "comment" => "a search engine",
                               })
+    groonga.reload
 
     google = Bookmark.find(groonga.id)
     assert_equal({
@@ -98,22 +101,24 @@ class TestBase < Test::Unit::TestCase
 
   def test_destroy
     before_count = Bookmark.count
-    Bookmark.find_by_uri("http://groonga.org/").destroy
+    Bookmark.select {|record| record.uri == "http://groonga.org/"}.first.destroy
     assert_equal(before_count - 1, Bookmark.count)
   end
 
   def test_inspect
-    assert_equal("Bookmark(user: references, uri: string, " +
-                 "updated_at: time, created_at: time, " +
-                 "content: text, comment: text)",
+    assert_equal("Bookmark(user: users, uri: ShortText, " +
+                 "updated_at: Time, created_at: Time, " +
+                 "content: LongText, comment: Text)",
                  Bookmark.inspect)
 
-    daijiro = User.find_by_name("daijiro")
-    groonga = Bookmark.find_by_uri("http://groonga.org/")
-    assert_equal("#<Bookmark user: #{daijiro.inspect}, " +
+    daijiro = User.select {|record| record.name == "daijiro"}.first
+    groonga = Bookmark.select {|record| record.uri == "http://groonga.org/"}.first
+    assert_equal("#<Bookmark " +
+                 "id: #{groonga.id}, " +
+                 "user: #{daijiro.inspect}, " +
                  "uri: \"http://groonga.org/\", " +
-                 "updated_at: \"2009-02-09 02:29:00\", " +
-                 "created_at: \"2009-02-09 02:09:29\", " +
+                 "updated_at: 2009-02-09 02:29:00 +0900, " +
+                 "created_at: 2009-02-09 02:09:29 +0900, " +
                  "content: \"<html><body>groonga</body></html>\", " +
                  "comment: \"fulltext search engine\">",
                  groonga.inspect)
@@ -128,17 +133,17 @@ class TestBase < Test::Unit::TestCase
     }
     google.save!
 
-    bookmarks = Bookmark.find(:all) {|record| record["content"] =~ "Google"}
-    assert_equal([google], bookmarks)
+    bookmarks = Bookmark.select {|record| record["content"] =~ "Google"}
+    assert_equal([google], bookmarks.to_a)
 
     google.content = "<html><body>...Empty...</body></html>"
     google.save!
 
-    bookmarks = Bookmark.find(:all) {|record| record["content"] =~ "Google"}
-    assert_equal([], bookmarks)
+    bookmarks = Bookmark.select {|record| record["content"] =~ "Google"}
+    assert_equal([], bookmarks.to_a)
 
-    bookmarks = Bookmark.find(:all) {|record| record["content"] =~ "Empty"}
-    assert_equal([google], bookmarks)
+    bookmarks = Bookmark.select {|record| record["content"] =~ "Empty"}
+    assert_equal([google], bookmarks.to_a)
   end
 
   def test_update_index
@@ -150,25 +155,27 @@ class TestBase < Test::Unit::TestCase
     }
     google.save!
 
-    bookmarks = Bookmark.find_all_by_user(daijiro)
+    bookmarks = Bookmark.select do |record|
+      record.user == daijiro
+    end
     assert_equal([Bookmark.find(@bookmark_records[:groonga].id), google],
-                 bookmarks)
+                 bookmarks.to_a)
   end
 
   def test_find_reference_by_id
     daijiro = @user_records[:daijiro]
-    bookmarks = Bookmark.find_all_by_user(daijiro.id)
+    bookmarks = Bookmark.select {|record| record.user == daijiro}
     assert_equal([Bookmark.find(@bookmark_records[:groonga])],
-                 bookmarks)
+                 bookmarks.to_a)
   end
 
-  def test_create
+  def test_find_all_with_block
     google = Bookmark.create("uri" => "http://google.com/",
                              "comment" => "a search engine",
                              "content" => "<html><body>...Google...</body></html>")
 
     assert_equal([google],
-                 Bookmark.find(:all) {|record| record["content"] =~ "Google"})
+                 Bookmark.select {|record| record["content"] =~ "Google"}.to_a)
   end
 
   def test_find_by_model
@@ -181,11 +188,12 @@ class TestBase < Test::Unit::TestCase
     google = Bookmark.create("uri" => "http://google.com/",
                              "comment" => "a search engine")
     assert_not_equal(Time.at(0), google.created_at)
-    assert_not_equal(Time.at(0), google.updated_at)
+    assert_equal(Time.at(0), google.updated_at)
   end
 
   def test_reload
-    groonga = Bookmark.find_by_uri("http://groonga.org/")
+    records = Bookmark.select {|record| record.uri == "http://groonga.org/"}
+    groonga = records.first
     groonga.comment = "changed!"
     assert_equal("changed!", groonga.comment)
     groonga.reload
@@ -199,6 +207,6 @@ class TestBase < Test::Unit::TestCase
 
 
     assert_equal([google],
-                 Bookmark.find(:all) {|record| record.content =~ "Google"})
+                 Bookmark.select {|record| record.content =~ "Google"}.to_a)
   end
 end

data/test/test-callbacks.rb

@@ -18,10 +18,20 @@ class TestCallbacks < Test::Unit::TestCase
   include ActiveGroongaTestUtils
 
   def test_before_save
-    bookmark = Bookmark.new
-    def bookmark.before_save
-      @called = true
+    callbacked_bookmark_class = Class.new(Bookmark) do
+      class << self
+        def model_name
+          Bookmark.model_name
+        end
+      end
+
+      set_callback :save, :before, :before_save
+
+      def before_save
+        @called = true
+      end
     end
+    bookmark = callbacked_bookmark_class.new
     bookmark.instance_variable_set("@called", false)
     assert_equal(false, bookmark.instance_variable_get("@called"))
     bookmark.save

data/test/test-persistence.rb

@@ -0,0 +1,53 @@
+# 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 as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# 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 TestPersistence < Test::Unit::TestCase
+  include ActiveGroongaTestUtils
+
+  def test_save_hash
+    key = "http://groonga.org/"
+    title = "groonga"
+
+    site = Site.new
+    site.key = key
+    site.title = title
+    assert_true(site.save)
+    found_site = Site.find(key)
+    assert_equal([key, title],
+                 [found_site.key, found_site.title])
+  end
+
+  def test_create_hash
+    groonga = Site.create(:key => "http://groonga.org/",
+                          :title => "groonga")
+    found_groonga = Site.find("http://groonga.org/")
+    assert_equal(["http://groonga.org/", "groonga"],
+                 [found_groonga.key, found_groonga.title])
+  end
+
+  def test_update
+    groonga = Site.new
+    groonga.key = "http://groonga.org/"
+    assert_true(groonga.save)
+
+    groonga.title = "groonga"
+    assert_true(groonga.save)
+
+    reloaded_groonga = Site.find("http://groonga.org/")
+    assert_equal(["http://groonga.org/", "groonga"],
+                 [reloaded_groonga.key, reloaded_groonga.title])
+  end
+end

data/{lib/active_groonga/observer.rb → test/test-result-set.rb}

@@ -1,8 +1,9 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# 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.
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
 #
 # This library is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -13,17 +14,18 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-module ActiveGroonga
-  module Observing
-    class << self
-      def included(base)
-        base.class_eval do
-          include ActiveRecord::Observing
-        end
-      end
-    end
+class TestResultSet < Test::Unit::TestCase
+  include ActiveGroongaTestUtils
+
+  def test_paginate
+    bookmarks = Bookmark.select
+    assert_equal(["http://cutter.sourceforge.net/"].sort,
+                 bookmarks.paginate(["uri"], :size => 1).collect(&:uri))
   end
 
-  class Observer < ActiveRecord::Observer
+  def test_sort
+    bookmarks = Bookmark.select
+    assert_equal(["http://cutter.sourceforge.net/"].sort,
+                 bookmarks.sort(["uri"], :limit => 1).collect(&:uri))
   end
 end

data/test/test-schema.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-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
@@ -18,60 +18,123 @@ class TestSchema < Test::Unit::TestCase
   include ActiveGroongaTestUtils
 
   def test_create_table
-    table_file = @tables_dir + "posts.groonga"
+    table_file = @tables_dir + "posts"
     assert_not_predicate(table_file, :exist?)
-    ActiveGroonga::Schema.create_table(:posts) do |table|
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:posts) do |table|
+      end
     end
     assert_predicate(table_file, :exist?)
   end
 
   def test_string_column
-    column_file = @tables_dir + "posts" + "columns" + "title.groonga"
+    column_file = @tables_dir + "posts.columns" + "title"
     assert_not_predicate(column_file, :exist?)
-    ActiveGroonga::Schema.create_table(:posts) do |table|
-      table.string :title
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:posts) do |table|
+        table.string :title
+      end
     end
     assert_predicate(column_file, :exist?)
   end
 
   def test_reference_column
-    ActiveGroonga::Schema.create_table(:categories) do |table|
-      table.string :name
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:categories) do |table|
+        table.string(:name)
+      end
     end
 
-    column_file = @tables_dir + "posts" + "columns" + "category.groonga"
+    column_file = @tables_dir + "posts.columns" + "category"
     assert_not_predicate(column_file, :exist?)
-    ActiveGroonga::Schema.create_table(:posts) do |table|
-      table.reference :category
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:posts) do |table|
+        table.reference(:category)
+      end
     end
     assert_predicate(column_file, :exist?)
   end
 
   def test_add_index
-    columns_dir = @tables_dir + "words" + "columns" + "posts"
-    index_file = columns_dir + "posts_content.groonga"
+    columns_dir = @tables_dir + "words.columns"
+    index_file = columns_dir + "posts_content"
     assert_not_predicate(index_file, :exist?)
 
-    ActiveGroonga::Schema.create_table(:posts) do |table|
-      table.string :content
-    end
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:posts) do |table|
+        table.string(:content)
+      end
 
-    ActiveGroonga::Schema.create_table(:words) do |table|
-      table.index :posts, :content
+      schema.create_table(:words) do |table|
+        table.index(:posts, :content)
+      end
     end
 
     assert_predicate(index_file, :exist?)
   end
 
   def test_remove_column
-    column_file = @tables_dir + "posts" + "columns" + "title.groonga"
+    column_file = @tables_dir + "posts.columns" + "title"
     assert_not_predicate(column_file, :exist?)
-    ActiveGroonga::Schema.create_table(:posts) do |table|
-      table.string :title
+    ActiveGroonga::Schema.define do |schema|
+      schema.create_table(:posts) do |table|
+        table.string(:title)
+      end
     end
     assert_predicate(column_file, :exist?)
 
-    ActiveGroonga::Schema.remove_column(:posts, :title)
+    ActiveGroonga::Schema.define do |schema|
+      schema.remove_column(:posts, :title)
+    end
     assert_not_predicate(column_file, :exist?)
   end
+
+  def test_dump
+    assert_equal(<<-EOS, ActiveGroonga::Schema.dump)
+ActiveGroonga::Schema.define(:version => 0) do |schema|
+  schema.instance_eval do
+    create_table("bookmarks",
+                 :force => true) do |table|
+      table.text("comment")
+      table.long_text("content")
+      table.time("created_at")
+      table.time("updated_at")
+      table.short_text("uri")
+    end
+
+    create_table("sites",
+                 :type => :hash,
+                 :key_type => "ShortText",
+                 :force => true) do |table|
+      table.unsigned_integer32("score")
+      table.short_text("title")
+    end
+
+    create_table("tasks",
+                 :force => true) do |table|
+      table.short_text("name")
+    end
+
+    create_table("terms",
+                 :type => :patricia_trie,
+                 :key_type => "ShortText",
+                 :force => true) do |table|
+    end
+
+    create_table("users",
+                 :force => true) do |table|
+      table.short_text("name")
+    end
+
+    change_table("bookmarks") do |table|
+      table.reference("user", "users")
+    end
+
+    change_table("terms") do |table|
+      table.index("bookmarks", "content", :name => "bookmarks_content")
+    end
+  end
+end
+EOS
+  end
 end