oklahoma_mixer 0.2.0 → 0.3.0

data/test/{getting_and_setting_by_id_test.rb → fixed_length_database/getting_and_setting_by_id_test.rb}

@@ -266,6 +266,14 @@ class TestGettingAndSettingByID < Test::Unit::TestCase
     assert_equal(3, @db.length)
   end
   
+  def test_empty_returns_true_while_no_pairs_are_in_the_database
+    assert(@db.empty?, "An empty database was not detected")
+    @db[42] = :value
+    assert(!@db.empty?, "A non-empty database was reported empty")
+    @db.delete(42)
+    assert(@db.empty?, "An empty database was not detected")
+  end
+  
   def test_each_key_iterates_over_ids
     @db.update(1 => 100, 2 => 200, 3 => 300)
     keys = [1, 2, 3]

data/test/{shared_binary_data.rb → shared/binary_data_tests.rb}

@@ -1,4 +1,4 @@
-module SharedBinaryData
+module BinaryDataTests
   def test_null_bytes_are_preserved_during_key_iteration
     @db.each_key do |key|
       assert_equal(@key, key)

data/test/{tuning_test.rb → shared/hash_tuning_tests.rb}

@@ -1,69 +1,66 @@
-require "test_helper"
-require "shared_tuning"
+require "shared/tuning_tests"
+
+module HashTuningTests
+  include TuningTests
 
-class TestTuning < Test::Unit::TestCase
-  def teardown
-    remove_db_files
-  end
-  
-  include SharedTuning
-  
   def test_a_bucket_array_size_can_be_set_with_other_tuning_defaults
     size = rand(1_000) + 1
     assert_option_calls([:tune, size, -1, -1, 0xFF], :bnum => size)
   end
-  
+
   def test_bucket_array_size_is_converted_to_an_int
     assert_option_calls([:tune, 42, -1, -1, 0xFF], :bnum => "42")
   end
-  
+
   def test_a_record_alignment_power_can_be_set_with_other_tuning_defaults
     pow = rand(10) + 1
     assert_option_calls([:tune, 0, pow, -1, 0xFF], :apow => pow)
   end
-  
+
   def test_record_alignment_power_is_converted_to_an_int
     assert_option_calls([:tune, 0, 42, -1, 0xFF], :apow => "42")
   end
-  
+
   def test_a_max_free_block_power_can_be_set_with_other_tuning_defaults
     pow = rand(10) + 1
     assert_option_calls([:tune, 0, -1, pow, 0xFF], :fpow => pow)
   end
-  
+
   def test_max_free_block_power_is_converted_to_an_int
     assert_option_calls([:tune, 0, -1, 42, 0xFF], :fpow => "42")
   end
-  
+
   def test_options_can_be_set_with_other_tuning_defaults
     assert_option_calls([:tune, 0, -1, -1, 1 | 2], :opts => "ld")
   end
-  
+
   def test_options_is_a_string_of_characters_mapped_to_enums_and_ored_together
-    opts = {"l" => lib::OPTS[:HDBTLARGE], "b" => lib::OPTS[:HDBTBZIP]}
+    db_prefix = self.class.name.include?("Table") ? "T" : "H"
+    opts = { "l" => lib::OPTS["#{db_prefix}DBTLARGE".to_sym],
+             "b" => lib::OPTS["#{db_prefix}DBTBZIP".to_sym]}
     assert_option_calls( [ :tune, 0, -1, -1,
                            opts.values.inject(0) { |o, v| o | v } ],
                          :opts => opts.keys.join )
   end
-  
+
   def test_the_options_string_is_not_case_sensative
     assert_option_calls([:tune, 0, -1, -1, 1 | 2], :opts => "ld")
     assert_option_calls([:tune, 0, -1, -1, 1 | 2], :opts => "LD")
   end
-  
+
   def test_unknown_options_are_ignored_with_a_warning
     warning = capture_stderr do
       assert_option_calls([:tune, 0, -1, -1, 1 | 8], :opts => "ltu")
     end
     assert(!warning.empty?, "A warning was not issued for an unknown option")
   end
-  
+
   def test_multiple_tuning_parameters_can_be_set_at_the_same_time
     size = rand(1_000) + 1
     assert_option_calls( [:tune, size, -1, -1, 1 | 2],
                          :bnum => size, :opts => "ld" )
   end
-  
+
   def test_optimize_allows_the_adjustment_of_tune_options_for_an_open_database
     db do |db|
       args = capture_args(lib, :optimize) do
@@ -73,25 +70,4 @@ class TestTuning < Test::Unit::TestCase
       assert_equal([0, 42, -1, 1 | 2], args[1..-1])
     end
   end
-  
-  def test_limit_for_cached_records_can_be_set
-    limit = rand(1_000) + 1
-    assert_option_calls([:setcache, limit], :rcnum => limit)
-  end
-  
-  def test_limit_for_cached_records_is_converted_to_an_int
-    assert_option_calls([:setcache, 42], :rcnum => "42")
-  end
-  
-  #######
-  private
-  #######
-  
-  def lib
-    OKMixer::HashDatabase::C
-  end
-  
-  def db(*args, &block)
-    hdb(*args, &block)
-  end
 end

data/test/{shared_iteration.rb → shared/iteration_tests.rb}

@@ -1,4 +1,4 @@
-module SharedIteration
+module IterationTests
   def test_each_key_iterates_over_all_keys_in_the_database
     @db.each_key do |key|
       @keys.delete(key)
@@ -11,7 +11,7 @@ module SharedIteration
       assert_instance_of(Array, key_value_array)
       assert_equal(2, key_value_array.size)
       key, value = key_value_array
-      assert_equal(key * 2, value)
+      assert_equal(@values[@keys.index(key)], value)
       @keys.delete(key)
       @values.delete(value)
     end
@@ -58,16 +58,17 @@ module SharedIteration
     assert_kind_of(Enumerable, @db)
     
     # examples
-    assert_equal(%w[b bb], @db.find { |_, value| value == "bb" })
-    assert_nil(@db.find { |_, value| value == "dd" })
-    assert_equal(%w[aaa bbb ccc], @db.map { |key, value| key + value }.sort)
-    assert( @db.any? { |_, value| value.include? "c" },
+    assert_equal( ["b", @values[@keys.index("b")]],
+                  @db.find { |key, _| key == "b" } )
+    assert_nil(@db.find { |key, _| key == "d" })
+    assert_equal(%w[aaa bbb ccc], @db.map { |key, _| key * 3 }.sort)
+    assert( @db.any? { |_, value| value.include?("c") or value.include?("cc") },
             "A value was not found during iteration" )
   end
   
   def test_delete_if_removes_all_keys_for_which_the_block_returns_true
     @db.delete_if { |key, _| key != "a" }
-    assert_equal([%w[a aa]], @db.to_a)
+    assert_equal(%w[a], @db.keys)
   end
   
   def test_iterators_return_self_to_match_hash_interface

data/test/shared/storage_tests.rb

@@ -0,0 +1,65 @@
+module StorageTests
+  def test_fetching_a_missing_value_fails_with_an_index_error
+    assert_raise(IndexError) do
+      @db.fetch(:missing)
+    end
+  end
+  
+  def test_fetch_can_return_a_default_for_a_missing_value
+    assert_equal(42, @db.fetch(:missing, 42))
+  end
+  
+  def test_fetch_can_run_a_block_returning_its_result_for_a_missing_value
+    assert_equal(:missing, @db.fetch(:missing) { |key| key })
+  end
+  
+  def test_fetching_with_a_block_overrides_a_default_and_triggers_a_warning
+    warning = capture_stderr do
+      assert_equal(42, @db.fetch(:missing, 13) { 42 })
+    end
+    assert(!warning.empty?, "A warning was not issued for a default and block")
+  end
+  
+  def test_store_and_fetch_can_also_be_used_through_the_indexing_brackets
+    assert_equal({:a => 1, :b => 2},       @db[:doc] = {:a => 1, :b => 2})
+    assert_equal({"a" => "1", "b" => "2"}, @db[:doc])
+  end
+  
+  def test_indexing_returns_nil_instead_of_failing_with_index_error
+    assert_nil(@db[:missing])
+  end
+  
+  def test_a_default_can_be_set_for_indexing_to_return
+    @db.default = 42
+    assert_equal(42, @db[:missing])
+  end
+  
+  def test_the_indexing_default_will_be_run_if_it_is_a_proc
+    @db.default = lambda { |key| "is #{key}" }
+    assert_equal("is missing", @db[:missing])
+  end
+  
+  def test_the_indexing_default_for_a_given_key_can_be_retrieved
+    @db.default = lambda { |key| "is #{key}" }
+    assert_equal("is ",        @db.default)
+    assert_equal("is missing", @db.default(:missing))
+  end
+  
+  def test_the_indexing_default_can_be_changed
+    assert_nil(@db[:missing])
+    assert_equal(42, @db.default = 42)
+    assert_equal(42, @db[:missing])
+    proc = lambda { |key| fail RuntimeError, "%p not found" % [key]}
+    assert_equal(proc, @db.default = proc)
+    error = assert_raise(RuntimeError) { @db[:missing] }
+    assert_equal(":missing not found", error.message)
+  end
+  
+  def test_delete_returns_nil_for_a_missing_key
+    assert_nil(@db.delete(:missing))
+  end
+  
+  def test_delete_can_be_passed_a_block_to_handle_missing_keys
+    assert_equal(42, @db.delete(:missing) { 42 })
+  end
+end

data/test/{top_level_interface_test.rb → shared/top_level_interface_test.rb}

@@ -5,10 +5,33 @@ class TestTopLevelInterface < Test::Unit::TestCase
     remove_db_files
   end
   
+  def test_ok_mixer_is_a_shortcut_for_oklahoma_mixer
+    assert_same(OklahomaMixer, OKMixer)
+  end
+  
   def test_the_version_constant_contains_the_current_version_number
     assert_match(/\A\d\.\d\.\d\z/, OKMixer::VERSION)
   end
   
+  def test_the_hash_database_interface_is_autoloaded_as_needed
+    assert_loads(%w[hash], %Q{OKMixer.open(#{db_path('tch').inspect}) { }})
+  end
+  
+  def test_the_b_tree_database_interface_is_autoloaded_as_needed
+    assert_loads( %w[b_tree hash],
+                  %Q{OKMixer.open(#{db_path('tcb').inspect}) { }} )
+  end
+  
+  def test_the_fixed_length_database_interface_is_autoloaded_as_needed
+    assert_loads( %w[fixed_length hash],
+                  %Q{OKMixer.open(#{db_path('tcf').inspect}) { }} )
+  end
+  
+  def test_the_table_database_interface_is_autoloaded_as_needed
+    assert_loads( %w[hash table],
+                  %Q{OKMixer.open(#{db_path('tct').inspect}) { }} )
+  end
+  
   def test_open_of_a_tch_extension_file_creates_a_hash_database
     OKMixer.open(db_path("tch")) do |db|
       assert_instance_of(OKMixer::HashDatabase, db)
@@ -27,6 +50,12 @@ class TestTopLevelInterface < Test::Unit::TestCase
     end
   end
   
+  def test_open_of_a_tct_extension_file_creates_a_table_database
+    OKMixer.open(db_path("tct")) do |db|
+      assert_instance_of(OKMixer::TableDatabase, db)
+    end
+  end
+  
   def test_open_of_an_unrecognized_extension_fails_with_an_error
     assert_raise(ArgumentError) do
       OKMixer.open("unrecognized")
@@ -53,7 +82,15 @@ class TestTopLevelInterface < Test::Unit::TestCase
     db.close if db
   end
   
-  def test_ok_mixer_is_a_shortcut_for_oklahoma_mixer
-    assert_same(OklahomaMixer, OKMixer)
+  private
+  
+  def assert_loads(fields, ruby_code)
+    run_ruby <<-END_RUBY
+    loaded_dbs = lambda { $".grep(/\\b(\\w+)_database\\.rb\\z/) { $1 }.sort }
+    before     = loaded_dbs.call
+    #{ruby_code}
+    puts loaded_dbs.call - before
+    END_RUBY
+    assert_equal(fields, @output.scan(/\w+/))
   end
 end

data/test/{shared_tuning.rb → shared/tuning_tests.rb}

@@ -1,4 +1,4 @@
-module SharedTuning
+module TuningTests
   def test_a_mutex_can_be_activated_as_the_database_is_created
     assert_option_calls([:setmutex], :mutex => true)
   end

data/test/table_database/document_iteration_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+require "shared/iteration_tests"
+
+class TestDocumentIteration < Test::Unit::TestCase
+  def setup
+    @db     = tdb
+    @keys   = %w[a b c]
+    @values = @keys.map { |key|
+      Hash[*@keys.map { |k| [key + k, "abc".index(k).to_s] }.flatten]
+    }
+    @keys.zip(@values) do |key, value|
+      @db[key] = value
+    end
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  include IterationTests
+end

data/test/table_database/document_storage_test.rb

@@ -0,0 +1,225 @@
+require "test_helper"
+require "shared/storage_tests"
+
+class TestDocumentStorage < Test::Unit::TestCase
+  def setup
+    @db = tdb
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  include StorageTests
+
+  def test_a_document_can_be_stored_and_fetched_from_the_database
+    document = {"a" => "1", "b" => "2"}
+    assert_equal(document, @db.store("document", document))
+    assert_equal(document, @db.fetch("document"))  # later
+  end
+  
+  def test_both_all_keys_and_values_are_converted_to_strings
+    assert_equal({:a => 1, :b => 2}, @db.store(:document, {:a => 1, :b => 2}))
+    assert_equal( {"a" => "1", "b" => "2"},
+                  @db.fetch("document") )  # effectively the same key
+  end
+  
+  def test_storing_with_keep_mode_adds_a_document_only_if_it_didnt_already_exist
+    original    = {"a" => "1", "b" => "2"}
+    replacement = {"a" => "1", "c" => "3"}
+    assert(@db.store(:doc, original, :keep), "Failed to store a new key")
+    assert_equal(original, @db.fetch(:doc))
+    assert(!@db.store(:doc, replacement, :keep), "Replaced an existing key")
+    assert_equal(original, @db.fetch(:doc))
+  end
+  
+  def test_storing_with_cat_mode_concatenates_new_columns_onto_a_document
+    original = {"a" => "1",       "b" => "2"}
+    added    = {"a" => "ignored", "c" => "new"}
+    assert_equal(original,                     @db.store(:cols, original, :cat))
+    assert_equal(original,                     @db.fetch(:cols))
+    assert_equal(added,                        @db.store(:cols, added, :cat))
+    assert_equal(original.merge("c" => "new"), @db.fetch(:cols))
+  end
+  
+  def test_storing_with_add_mode_adds_to_an_existing_value
+    assert_equal(0, @db.store(:i,  0, :add))
+    assert_equal(1, @db.store(:i,  1, :add))
+    assert_equal(2, @db.store(:i,  1, :add))
+    assert_equal(1, @db.store(:i, -1, :add))
+    
+    assert_in_delta(1.5, @db.store(:f,  1.5, :add), 2 ** -20)
+    assert_in_delta(3.5, @db.store(:f,  2.0, :add), 2 ** -20)
+    assert_in_delta(2.5, @db.store(:f, -1.0, :add), 2 ** -20)
+  end
+  
+  def test_additions_are_stored_in_a_document
+    assert_equal(42,               @db.store(:i, 42, :add))
+    assert_equal({"_num" => "42"}, @db.fetch(:i))
+
+    assert_equal(3.14,               @db.store(:f, 3.14, :add))
+    assert_equal({"_num" => "3.14"}, @db.fetch(:f))
+  end
+  
+  def test_additions_can_be_added_to_a_document
+    int = {"type" => "Integer"}
+    assert_equal(int,                       @db.store(:i, int))
+    assert_equal(42,                        @db.store(:i, 42, :add))
+    assert_equal(int.merge("_num" => "42"), @db.fetch(:i))
+
+    flt = {"type" => "Float"}
+    assert_equal(flt,                         @db.store(:f, flt))
+    assert_equal(3.14,                        @db.store(:f, 3.14, :add))
+    assert_equal(flt.merge("_num" => "3.14"), @db.fetch(:f))
+  end
+  
+  def test_adding_to_a_non_added_number_clobbers_the_column
+    junk = {"_num" => "junk"}
+    assert_equal(junk,            @db.store(:i, junk))
+    assert_equal(1,               @db.store(:i, 1, :add))
+    assert_equal({"_num" => "1"}, @db.fetch(:i))
+  end
+  
+  def test_addition_types_can_be_switched_as_needed
+    assert_equal(1,                 @db.store(:num,   1, :add))
+    assert_equal(2.0,               @db.store(:num, 1.0, :add))
+    assert_equal(2.1,               @db.store(:num, 0.1, :add))
+    assert_equal(3,                 @db.store(:num,   1, :add))  # truncated
+    assert_equal(3.5,               @db.store(:num, 0.4, :add))
+    assert_equal(4,                 @db.store(:num,   1, :add))  # truncated
+    assert_equal({"_num" => "4.5"}, @db.fetch(:num))
+  end
+  
+  def test_storing_with_a_block_allows_duplicate_resolution
+    @db[:key] = {:a => 1, :b => 2}
+    assert_equal( {:b => 2.5, :c => 3},
+                  @db.store(:key, {:b => 2.5, :c => 3}) { |key, old, new|
+                    old.merge(new).merge("" => key)
+                  } )
+    assert_equal({"" => "key", "a" => "1", "b" => "2.5", "c" => "3"}, @db[:key])
+  end
+  
+  def test_storing_with_a_block_overrides_a_mode_and_triggers_a_warning
+    warning = capture_stderr do
+      assert_equal({ }, @db.store(:key, { }, :keep) { |key, old, new| })
+    end
+    assert(!warning.empty?, "A warning was not issued for a mode and block")
+  end
+  
+  def test_include_and_aliases_can_be_used_to_check_for_the_existance_of_a_key
+    @db[:exist] = {"I" => "exist"}
+    %w[include? has_key? key? member?].each do |query|
+      assert(@db.send(query,  :exist),   "Failed to detect an existing key")
+      assert(!@db.send(query, :missing), "Failed to detect an missing key")
+    end
+  end
+  
+  def test_update_sets_multiple_documents_at_once_overwriting_old_documents
+    @db[:b] = {"b" => "old"}
+    assert_equal( @db,                @db.update( :a => {"a" => "new"},
+                                                  :b => {"b" => "new"},
+                                                  :c => {"c" => "new"}) )
+    assert_equal( [ {"a" => "new"},
+                    {"b" => "new"},
+                    {"c" => "new"} ], @db.values_at(:a, :b, :c) )
+  end
+  
+  def test_update_can_be_passed_a_block_for_handling_duplicates
+    @db[:b] = {:keep => 1, :replace => 2}
+    assert_equal( @db, @db.update( :a => {:new => 1},
+                                   :b => {:replace => 2.5, :add => 3},
+                                   :c => {:new => 2} ) { |key, old, new|
+                         old.merge(new).merge("" => key)
+                       } )
+    assert_equal( [ {"new"      => "1"},
+                    { ""        => "b",
+                      "keep"    => "1",
+                      "replace" => "2.5",
+                      "add"     => "3" },
+                    {"new"      => "2"} ], @db.values_at(:a, :b, :c) )
+  end
+  
+  def test_values_at_can_be_used_to_retrieve_multiple_documents_at_once
+    @db[:a] = {:a => 1}
+    @db[:c] = {:c => 2}
+    assert_equal([ ],               @db.values_at)
+    assert_equal( [ {"a" => "1"},
+                    nil,
+                    {"c" => "2"} ], @db.values_at(:a, :b, :c) )
+  end
+  
+  def test_values_at_supports_defaults
+    @db.default = { }
+    @db[:a]     = {:a => 1}
+    @db[:c]     = {:c => 2}
+    assert_equal( [ {"a" => "1"},
+                    { },
+                    {"c" => "2"} ], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_keys_returns_all_keys_in_the_database
+    @db.update(:a => {:a => 1}, :b => {:b => 2}, :c => {:c => 3})
+    assert_equal(%w[a b c], @db.keys.sort)
+  end
+  
+  def test_keys_can_take_a_prefix_which_all_returned_keys_must_start_with
+    @db.update(:a => {:a => 1}, :ab => {:ab => 2}, :c => {:c => 3})
+    assert_equal(%w[a ab], @db.keys(:prefix => :a).sort)
+  end
+  
+  def test_keys_can_take_a_limit_of_keys_to_return
+    @db.update(:a => {:a => 1}, :b => {:b => 2}, :c => {:c => 3})
+    keys = @db.keys(:limit => 2)
+    assert_equal(2, keys.size)
+    keys.each do |key|
+      assert(%w[a b c].include?(key), "Key wasn't in known keys")
+    end
+  end
+  
+  def test_values_returns_all_values_in_the_database
+    @db.update(:a => {:a => 1}, :b => {:b => 2}, :c => {:c => 3})
+    assert_equal( [ {"a" => "1"},
+                    {"b" => "2"},
+                    {"c" => "3"} ], @db.values.sort_by { |h| h.to_a } )
+  end
+  
+  def test_delete_removes_a_document_from_the_database
+    @db[:doc] = {"a" => "1"}
+    assert_equal({"a" => "1"}, @db.delete(:doc))
+    assert_nil(@db[:doc])
+  end
+  
+  def test_clear_removes_all_keys_from_the_database
+    @db.update(:a => {:a => 1}, :b => {:b => 2}, :c => {:c => 3})
+    assert_equal(@db, @db.clear)
+    assert_equal([nil, nil, nil], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_size_and_length_return_the_count_of_key_value_pairs_in_the_database
+    assert_equal(0, @db.size)
+    assert_equal(0, @db.length)
+    @db.update(:a => {:a => 1}, :b => {:b => 2}, :c => {:c => 3})
+    assert_equal(3, @db.size)
+    assert_equal(3, @db.length)
+  end
+  
+  def test_empty_returns_true_while_no_pairs_are_in_the_database
+    assert(@db.empty?, "An empty database was not detected")
+    @db[:doc] = {"a" => "1"}
+    assert(!@db.empty?, "A non-empty database was reported empty")
+    @db.delete(:doc)
+    assert(@db.empty?, "An empty database was not detected")
+  end
+  
+  def test_generate_unique_id_and_uid_can_be_used_to_manage_increasing_ids
+    assert_equal(1, @db.generate_unique_id)
+    assert_equal([2, 3, 4, 5], Array.new(4) { @db.uid })
+  end
+  
+  def test_uids_are_not_stored_in_documents
+    assert_equal(0, @db.size)
+    assert_equal(1, @db.uid)
+    assert_equal(0, @db.size)
+  end
+end