oklahoma_mixer 0.1.0

data/test/getting_and_setting_keys_test.rb

@@ -0,0 +1,218 @@
+require "test_helper"
+
+class TestGettingAndSettingKeys < Test::Unit::TestCase
+  def setup
+    @db = hdb
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+
+  def test_a_key_value_pair_can_be_stored_and_fetched_from_the_database
+    assert_equal("value", @db.store("key", "value"))
+    assert_equal("value", @db.fetch("key"))  # later
+  end
+  
+  def test_both_keys_and_values_are_converted_to_strings
+    assert_equal(42,   @db.store(:num, 42))
+    assert_equal("42", @db.fetch("num"))  # effectively the same key
+  end
+  
+  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_storing_with_keep_mode_adds_a_value_only_if_it_didnt_already_exist
+    assert(@db.store(:key, :new, :keep), "Failed to store a new key")
+    assert_equal("new", @db.fetch(:key))
+    assert(!@db.store(:key, :replace, :keep), "Replaced an existing key")
+    assert_equal("new", @db.fetch(:key))
+  end
+  
+  def test_storing_with_cat_mode_concatenates_content_onto_an_existing_value
+    assert_equal("One",      @db.store(:list, "One", :cat))
+    assert_equal("One",      @db.fetch(:list))
+    assert_equal(", Two",    @db.store(:list, ", Two", :cat))
+    assert_equal("One, Two", @db.fetch(:list))
+  end
+  
+  def test_storing_with_async_mode_is_buffered_writing
+    args = capture_args(OKMixer::HashDatabase::C, :putasync) do
+      assert_equal(:buffered, @db.store(:key, :buffered, :async))
+    end
+    assert_instance_of(FFI::Pointer, args[0])
+    assert_equal(["key", 3, "buffered", 8], args[1..-1])
+  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_storing_with_a_block_allows_duplicate_resolution
+    @db[:key] = :old
+    assert_equal( :new, @db.store(:key, :new) { |key, old, new|
+                                                "#{key}=#{old}&#{new}" } )
+    assert_equal("key=old&new", @db[:key])
+  end
+
+  def test_storing_with_a_block_overrides_a_mode_and_triggers_a_warning
+    warning = capture_stderr do
+      assert_equal(:new, @db.store(:key, :new, :async) { |key, old, new| })
+    end
+    assert(!warning.empty?, "A warning was not issued for a mode and block")
+  end
+  
+  def test_store_and_fetch_can_also_be_used_through_the_indexing_brackets
+    assert_equal(42,   @db[:num] = 42)
+    assert_equal("42", @db[:num])
+  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_include_and_aliases_can_be_used_to_check_for_the_existance_of_a_key
+    @db[:exist] = true
+    %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_values_at_once_overwriting_old_values
+    @db[:b] = "old_b"
+    assert_equal(@db, @db.update(:a => "new_a", :b => "new_b", :c => "new_c"))
+    assert_equal(%w[new_a new_b new_c], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_update_can_be_passed_a_block_for_handling_duplicates
+    @db[:b] = "old"
+    assert_equal( @db, @db.update( :a => "new",
+                                   :b => "new",
+                                   :c => "new") { |key, old, new|
+                                                  "#{key}=#{old}&#{new}" } )
+    assert_equal(%w[new b=old&new new], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_values_at_can_be_used_to_retrieve_multiple_values_at_once
+    @db[:a] = 1
+    @db[:c] = 2
+    assert_equal([ ],             @db.values_at)
+    assert_equal(["1", nil, "2"], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_values_at_supports_defaults
+    @db.default = 42
+    @db[:a] = 1
+    @db[:c] = 2
+    assert_equal(["1", 42, "2"], @db.values_at(:a, :b, :c))
+  end
+  
+  def test_keys_returns_all_keys_in_the_database
+    @db.update(:a => 1, :b => 2, :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( "names:1:first" => "James",
+                "names:1:last"  => "Gray", 
+                "names:2:first" => "Other",
+                "names:2:last"  => "Guy" )
+    assert_equal( %w[names:1:first names:1:last],
+                  @db.keys(:prefix => "names:1:").sort )
+  end
+  
+  def test_keys_can_take_a_limit_of_keys_to_return
+    @db.update(:a => 1, :b => 2, :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 => 1, :b => 2, :c => 3)
+    assert_equal(%w[1 2 3], @db.values.sort)
+  end
+  
+  def test_delete_removes_a_key_from_the_database
+    @db[:key] = :value
+    assert_equal("value", @db.delete(:key))
+    assert_nil(@db[:key])
+  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
+  
+  def test_clear_removes_all_keys_from_the_database
+    @db.update(:a => 1, :b => 2, :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 => 1, :b => 2, :c => 3)
+    assert_equal(3, @db.size)
+    assert_equal(3, @db.length)
+  end
+end

data/test/iteration_test.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class TestIteration < Test::Unit::TestCase
+  def setup
+    @db     = hdb
+    @keys   = %w[a b c]
+    @values = @keys.map { |key| key * 2 }
+    @keys.zip(@values) do |key, value|
+      @db[key] = value
+    end
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  def test_each_key_iterates_over_all_keys_in_the_database
+    @db.each_key do |key|
+      @keys.delete(key)
+    end
+    assert(@keys.empty?, "All keys were not iterated over")
+  end
+  
+  def test_each_iterates_over_all_key_value_pairs_in_arrays
+    @db.each do |key_value_array|
+      assert_instance_of(Array, key_value_array)
+      assert_equal(2, key_value_array.size)
+      key, value = key_value_array
+      assert_equal(key * 2, value)
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert( @keys.empty? && @values.empty?,
+            "All key/value pairs were not iterated over" )
+  end
+  
+  def test_the_arrays_passed_to_each_can_be_split
+    @db.each do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert( @keys.empty? && @values.empty?,
+            "All key/value pairs were not iterated over" )
+  end
+  
+  def test_each_pair_is_an_alias_for_each
+    each_arrays = [ ]
+    @db.each do |array|
+      each_arrays << array
+    end
+    @db.each_pair do |array|
+      each_arrays.delete(array)
+    end
+    each_keys_and_values = [ ]
+    @db.each do |key, value|
+      each_keys_and_values << [key, value]
+    end
+    @db.each_pair do |key, value|
+      each_keys_and_values.delete([key, value])
+    end
+    assert( each_arrays.empty? && each_keys_and_values.empty?,
+            "The iterations did not match" )
+  end
+  
+  def test_each_value_iterates_over_all_values_in_the_database
+    @db.each_value do |value|
+      @values.delete(value)
+    end
+    assert(@values.empty?, "All values were not iterated over")
+  end
+  
+  def test_the_standard_iterators_are_supported
+    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" },
+            "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)
+  end
+  
+  def test_iterators_return_self_to_match_hash_interface
+    %w[each_key each each_pair each_value delete_if].each do |iterator|
+      assert_equal(@db, @db.send(iterator) { })
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,51 @@
+require "stringio"
+require "test/unit"
+
+require "rubygems"  # for FFI
+
+require "oklahoma_mixer"
+
+module TestHelper
+  def capture_stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = STDERR
+  end
+  
+  def capture_args(receiver, method)
+    called_with = nil
+    singleton   = class << receiver; self end
+    singleton.send(:define_method, method) do |*args|
+      called_with = args
+    end
+    yield
+    called_with
+  end
+  
+  def db_path(ext)
+    File.join( File.dirname(__FILE__),
+               "#{self.class.to_s.sub(/\ATest/, '').downcase}.#{ext}" )
+  end
+
+  def hdb(*args)
+    db = OKMixer::HashDatabase.new(db_path("tch"), *args)
+    if block_given?
+      begin
+        yield db
+      ensure
+        db.close
+      end
+    else
+      db
+    end
+  end
+  
+  def remove_db_files
+    Dir.glob(db_path("*")) do |file|
+      File.unlink(file)
+    end
+  end
+end
+Test::Unit::TestCase.send(:include, TestHelper)

data/test/top_level_interface_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class TestTopLevelInterface < Test::Unit::TestCase
+  def teardown
+    remove_db_files
+  end
+  
+  def test_the_version_constant_contains_the_current_version_number
+    assert_match(/\A\d\.\d\.\d\z/, OKMixer::VERSION)
+  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)
+    end
+  end
+  
+  def test_open_of_an_unrecognized_extension_fails_with_an_error
+    assert_raise(ArgumentError) do
+      OKMixer.open("unrecognized")
+    end
+  end
+  
+  def test_open_with_a_block_returns_the_value_of_the_last_expression
+    assert_equal(42, OKMixer.open(db_path("tch")) { 42 })
+  end
+  
+  def test_open_with_a_block_automatically_closes_the_database
+    OKMixer.open(db_path("tch")) do |db|
+      db[:data] = :saved
+    end
+    OKMixer.open(db_path("tch")) do |db|  # we can reopen since the lock is gone
+      assert_equal("saved", db[:data])
+    end
+  end
+  
+  def test_open_without_a_block_returns_the_still_open_database
+    db = OKMixer.open(db_path("tch"))
+    assert_nil(db[:unset])  # we can fetch a value since it's still open
+  ensure
+    db.close if db
+  end
+  
+  def test_ok_mixer_is_a_shortcut_for_oklahoma_mixer
+    assert_same(OklahomaMixer, OKMixer)
+  end
+end

data/test/transactions_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class TestTransactions < Test::Unit::TestCase
+  def setup
+    @db        = hdb
+    @db[:data] = "before transaction"
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  def test_a_transaction_returns_the_value_of_the_last_expression
+    assert_equal(42, @db.transaction { 42 })
+  end
+  
+  def test_a_transaction_is_automatically_committed_if_the_block_finishes
+    @db.transaction do
+      @db[:data] = "after transaction"
+    end
+    assert_equal("after transaction", @db[:data])
+  end
+  
+  def test_failing_with_an_error_aborts_the_transaction
+    assert_raise(RuntimeError) do
+      @db.transaction do
+        @db[:data] = "after transaction"
+        fail "Testing abort"
+      end
+    end
+    assert_equal("before transaction", @db[:data])
+  end
+  
+  def test_a_transaction_can_be_committed_before_the_end_of_the_block
+    @db.transaction do
+      @db[:data] = "after transaction"
+      @db.commit
+      @db[:other] = "set"  # not executed
+    end
+    assert_equal("after transaction", @db[:data])
+    assert_nil(@db[:other])
+  end
+  
+  def test_a_transaction_can_be_aborted_before_the_end_of_the_block
+    @db.transaction do
+      @db[:data] = "after transaction"
+      @db.abort
+      @db[:other] = "set"  # not executed
+    end
+    assert_equal("before transaction", @db[:data])
+    assert_nil(@db[:other])
+  end
+  
+  def test_commit_fails_with_an_error_if_called_outside_a_transaction
+    assert_raise(OKMixer::Error::TransactionError) do
+      @db.commit
+    end
+  end
+  
+  def test_abort_fails_with_an_error_if_called_outside_a_transaction
+    assert_raise(OKMixer::Error::TransactionError) do
+      @db.abort
+    end
+  end
+end

data/test/tuning_test.rb

@@ -0,0 +1,173 @@
+require "test_helper"
+
+class TestTuning < Test::Unit::TestCase
+  def teardown
+    remove_db_files
+  end
+  
+  def test_a_mutex_can_be_activated_as_the_database_is_created
+    assert_option_calls([:setmutex], :mutex => true)
+  end
+  
+  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" => OKMixer::HashDatabase::C::OPTS[:HDBTLARGE],
+             "b" => OKMixer::HashDatabase::C::OPTS[:HDBTBZIP] }
+    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
+    hdb do |db|
+      args = capture_args(OKMixer::HashDatabase::C, :optimize) do
+        db.optimize(:apow => "42", :opts => "ld")
+      end
+      assert_instance_of(FFI::Pointer, args[0])
+      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
+  
+  def test_a_size_can_be_set_for_extra_mapped_memory
+    size = rand(1_000) + 1
+    assert_option_calls([:setxmsiz, size], :xmsiz => size)
+  end
+  
+  def test_extra_mapped_memory_size_is_converted_to_an_int
+    assert_option_calls([:setxmsiz, 42], :xmsiz => "42")
+  end
+  
+  def test_a_step_unit_can_be_set_for_auto_defragmentation
+    unit = rand(1_000) + 1
+    assert_option_calls([:setdfunit, unit], :dfunit => unit)
+  end
+  
+  def test_auto_defragmentation_step_unit_is_converted_to_an_int
+    assert_option_calls([:setdfunit, 42], :dfunit => "42")
+  end
+  
+  def test_nested_transactions_can_be_ignored
+    hdb(:nested_transactions => :ignore) do |db|
+      result = db.transaction {
+        db.transaction {  # ignored
+          41
+        } + 1             # ignored
+      }
+      assert_equal(42, result)
+    end
+  end
+  
+  def test_nested_transactions_can_be_set_to_fail_with_an_error
+    [:fail, :raise].each do |setting|
+      hdb(:nested_transactions => setting) do |db|
+        db.transaction do
+          assert_raise(OKMixer::Error::TransactionError) do
+            db.transaction {  }  # nested fails with error
+          end
+        end
+      end
+    end
+  end
+  
+  def test_a_mode_string_can_be_passed
+    assert_raise(OKMixer::Error::CabinetError) do  # file not found
+      hdb("r")
+    end
+  end
+  
+  def test_the_mode_can_be_passed_as_as_option
+    assert_raise(OKMixer::Error::CabinetError) do  # file not found
+      hdb(:mode => "r")
+    end
+  end
+  
+  def test_an_option_mode_overrides_the_mode_argument_and_triggers_a_warning
+    warning = capture_stderr do
+      hdb("r", :mode => "wc") do
+        # just open and close
+      end
+    end
+    assert( !warning.empty?,
+            "A warning was not issued for an option mode with a mode argument" )
+  end
+  
+  def test_an_unknown_mode_triggers_a_warning
+    warning = capture_stderr do
+      hdb("wcu") do
+        # just open and close
+      end
+    end
+    assert(!warning.empty?, "A warning was not issued for an unknown mode")
+  end
+  
+  #######
+  private
+  #######
+  
+  def assert_option_calls(c_call, options)
+    args = capture_args(OKMixer::HashDatabase::C, c_call[0]) do
+      hdb(options) do
+        # just open and close
+      end
+    end
+    assert_instance_of(FFI::Pointer, args[0])
+    assert_equal(c_call[1..-1], args[1..-1])
+  end
+end