oklahoma_mixer 0.1.0 → 0.2.0

data/test/key_range_test.rb

@@ -0,0 +1,161 @@
+require "test_helper"
+
+class TestKeyRange < Test::Unit::TestCase
+  def teardown
+    remove_db_files
+  end
+  
+  def test_b_tree_supports_non_range_key_requests
+    abc_db do |db|
+      assert_equal(%w[a b], db.keys(:limit => 2))
+    end
+  end
+  
+  def test_keys_can_return_a_range_of_keys_for_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[b c], db.keys(:range => "b".."c"))
+    end
+  end
+  
+  def test_range_overrides_prefix_and_triggers_a_warning
+    abc_db do |db|
+      warning = capture_stderr do
+        # returns range
+        assert_equal(%w[b c], db.keys(:range => "b".."c", :prefix => "ignored"))
+      end
+      assert(!warning.empty?, "A warning was not issued for a range and prefix")
+    end
+
+    num_db do |db|
+      warning = capture_stderr do
+        # returns range
+        assert_equal([2, 3], db.keys(:range => 2..3, :prefix => "ignored"))
+      end
+      assert(!warning.empty?, "A warning was not issued for a range and prefix")
+    end
+  end
+  
+  def test_b_tree_key_ranges_must_be_passed_a_range_object
+    abc_db do |db|
+      assert_nothing_raised(ArgumentError) do
+        db.keys(:range => "b".."c")
+      end
+      assert_raise(ArgumentError) do
+        db.keys(:range => "not a Range")
+      end
+    end
+  end
+  
+  def test_boundaries_are_converted_to_strings_for_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[b c], db.keys(:range => %w[b]..%w[c]))
+    end
+  end
+  
+  def test_key_ranges_can_exclude_the_last_member_in_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[b], db.keys(:range => "b"..."c"))
+    end
+  end
+  
+  def test_key_ranges_can_exclude_the_first_member_in_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[c], db.keys(:range => "b".."c", :exclude_start => true))
+    end
+  end
+  
+  def test_key_ranges_can_use_values_between_keys_in_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[b c], db.keys(:range => "ab".."f"))
+    end
+  end
+  
+  def test_a_limit_can_be_set_for_key_ranges_in_a_b_tree_database
+    abc_db do |db|
+      assert_equal(%w[b], db.keys(:range => "b".."c", :limit => 1))
+    end
+  end
+  
+  def test_range_queries_work_with_custom_ordering
+    bdb(:cmpfunc => lambda { |a, b| a.to_i <=> b.to_i }) do |db|
+      db.update(1 => :a, 11 => :b, 2 => :c)
+      assert_equal(%w[2 11], db.keys(:range => 2..100))
+    end
+  end
+
+  def test_fixed_length_supports_non_range_key_requests
+    num_db do |db|
+      assert_equal([1, 2], db.keys(:limit => 2))
+    end
+  end
+  
+  def test_keys_can_return_a_range_of_keys_for_a_fixed_length_database
+    num_db do |db|
+      assert_equal([2, 3], db.keys(:range => 2..3))
+    end
+  end
+  
+  def test_fixed_length_key_ranges_must_be_passed_a_range_or_array
+    num_db do |db|
+      assert_nothing_raised(ArgumentError) do
+        db.keys(:range => "min".."max")
+      end
+      assert_nothing_raised(ArgumentError) do
+        db.keys(:range => [:min, 100])
+      end
+      assert_raise(ArgumentError) do
+        db.keys(:range => "not a Range")
+      end
+    end
+  end
+  
+  def test_boundaries_are_converted_to_integers_for_a_fixed_length_database
+    num_db do |db|
+      assert_equal([2, 3], db.keys(:range => "2".."3"))
+    end
+  end
+  
+  def test_key_ranges_can_exclude_the_last_member_in_a_fixed_length_database
+    num_db do |db|
+      assert_equal([2], db.keys(:range => 2...3))
+      assert_equal([2], db.keys(:range => [2, 3], :exclude_end => true))
+    end
+  end
+  
+  def test_key_ranges_can_exclude_the_first_member_in_a_fixed_length_database
+    num_db do |db|
+      assert_equal([3], db.keys(:range => 2..3, :exclude_start => true))
+    end
+  end
+  
+  def test_key_ranges_can_use_values_between_keys_in_a_fixed_length_database
+    num_db do |db|
+      db.update(5 => 500, 6 => 600)
+      assert_equal([5, 6], db.keys(:range => 4..7))
+    end
+  end
+  
+  def test_a_limit_can_be_set_for_key_ranges_in_a_fixed_length_database
+    num_db do |db|
+      assert_equal([2], db.keys(:range => 2..3, :limit => 1))
+    end
+  end
+  
+  #######
+  private
+  #######
+  
+  def abc_db
+    bdb do |db|
+      db.update(:a => 1, :b => 2, :c => 3)
+      yield db
+    end
+  end
+  
+  def num_db
+    fdb do |db|
+      db.update(1 => 100, 2 => 200, 3 => 300)
+      yield db
+    end
+  end
+end

data/test/order_test.rb

@@ -0,0 +1,122 @@
+require "test_helper"
+
+class TestOrder < Test::Unit::TestCase
+  REVERSE_ORDER_CMPFUNC = lambda { |a, b| a == "" ? a <=> b : b <=> a }
+  
+  def teardown
+    remove_db_files
+  end
+  
+  def test_b_tree_databases_default_to_lexical_ordering
+    bdb do |db|
+      db.update(:c => 3, :a => 1, :b => 2)
+      assert_equal(%w[a b c],                   db.keys)
+      assert_equal([%w[a 1], %w[b 2], %w[c 3]], db.to_a)
+    end
+
+    remove_db_files
+    bdb do |db|
+      db.update(1 => :a, 11 => :b, 2 => :c)
+      assert_equal(%w[1 11 2],                   db.keys)
+      assert_equal([%w[1 a], %w[11 b], %w[2 c]], db.to_a)
+    end
+  end
+  
+  def test_b_tree_database_ordering_can_be_changed_with_a_comparison_function
+    bdb(:cmpfunc => REVERSE_ORDER_CMPFUNC) do |db|
+      db.update(:c => 3, :a => 1, :b => 2)
+      assert_equal(%w[c b a],                   db.keys)
+      assert_equal([%w[c 3], %w[b 2], %w[a 1]], db.to_a)
+    end
+
+    remove_db_files
+    cmpfunc = lambda { |a, b| a.to_i <=> b.to_i }  # numerical order
+    bdb(:cmpfunc => cmpfunc) do |db|
+      db.update(1 => :a, 11 => :b, 2 => :c)
+      assert_equal(%w[1 2 11],                   db.keys)
+      assert_equal([%w[1 a], %w[2 c], %w[11 b]], db.to_a)
+    end
+  end
+  
+  def test_each_key_iterates_through_keys_in_order_for_b_trees
+    assert_forward_iteration(%w[a b c], :each_key)
+    assert_reverse_iteration(%w[c b a], :each_key)
+  end
+  
+  def test_each_iterates_through_key_value_pairs_in_order_for_b_trees
+    assert_forward_iteration([%w[a 1], %w[b 2], %w[c 3]], :each)
+    assert_reverse_iteration([%w[c 3], %w[b 2], %w[a 1]], :each)
+  end
+  
+  def test_reverse_each_iterates_through_key_value_pairs_in_revserse_order
+    assert_forward_iteration([%w[c 3], %w[b 2], %w[a 1]], :reverse_each)
+    assert_reverse_iteration([%w[a 1], %w[b 2], %w[c 3]], :reverse_each)
+  end
+  
+  def test_each_value_iterates_through_values_in_order_for_b_trees
+    assert_forward_iteration(%w[1 2 3], :each_value)
+    assert_reverse_iteration(%w[3 2 1], :each_value)
+  end
+  
+  def test_delete_if_iterates_through_key_value_pairs_in_order_for_b_trees
+    assert_forward_iteration([%w[a 1], %w[b 2], %w[c 3]], :delete_if)
+    assert_reverse_iteration([%w[c 3], %w[b 2], %w[a 1]], :delete_if)
+  end
+  
+  def test_fixed_length_databases_have_numerical_ordering_by_keys
+    fdb do |db|
+      db.update(3 => 300, 1 => 100, 2 => 200)
+      assert_equal([1, 2, 3],                            db.keys)
+      assert_equal([[1, "100"], [2, "200"], [3, "300"]], db.to_a)
+    end
+  end
+  
+  def test_each_key_iterates_through_keys_in_order_for_fixed_lengths
+    assert_forward_iteration([1, 2, 3], :each_key, :fdb)
+  end
+  
+  def test_each_iterates_through_key_value_pairs_in_order_for_fixed_lengths
+    assert_forward_iteration([[1, "100"], [2, "200"], [3, "300"]], :each, :fdb)
+  end
+  
+  def test_each_value_iterates_through_values_in_order_for_fixed_lengths
+    assert_forward_iteration(%w[100 200 300], :each_value, :fdb)
+  end
+  
+  def test_delete_if_iterates_through_key_value_pairs_in_order_for_fixed_lengths
+    assert_forward_iteration( [[1, "100"], [2, "200"], [3, "300"]],
+                              :delete_if,
+                              :fdb )
+  end
+  
+  #######
+  private
+  #######
+  
+  def assert_forward_iteration(expected_order, iterator, option = nil)
+    remove_db_files
+    if option == :fdb
+      fdb do |db|
+        db.update(3 => 300, 1 => 100, 2 => 200)
+        actual_order = [ ]
+        db.send(iterator) do |*args|
+          actual_order << (args.size == 1 ? args.first : args)
+        end
+        assert_equal(expected_order, actual_order)
+      end
+    else
+      bdb(:cmpfunc => option) do |db|
+        db.update(:c => 3, :a => 1, :b => 2)
+        actual_order = [ ]
+        db.send(iterator) do |*args|
+          actual_order << (args.size == 1 ? args.first : args)
+        end
+        assert_equal(expected_order, actual_order)
+      end
+    end
+  end
+    
+  def assert_reverse_iteration(expected_order, iterator)
+    assert_forward_iteration(expected_order, iterator, REVERSE_ORDER_CMPFUNC)
+  end
+end

data/test/shared_binary_data.rb

@@ -0,0 +1,14 @@
+module SharedBinaryData
+  def test_null_bytes_are_preserved_during_key_iteration
+    @db.each_key do |key|
+      assert_equal(@key, key)
+    end
+  end
+  
+  def test_null_bytes_are_preserved_during_iteration
+    @db.each do |key, value|
+      assert_equal(@key,   key)
+      assert_equal(@value, value)
+    end
+  end
+end

data/test/shared_iteration.rb

@@ -0,0 +1,99 @@
+module SharedIteration
+  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
+  
+  def test_to_hash_converts_the_database_to_a_hash
+    assert_equal(Hash[*@keys.zip(@values).flatten], @db.to_hash)
+  end
+  
+  def test_to_hash_keeps_a_default_object_by_default
+    @db.default = 0
+    assert_equal(0, @db.to_hash[:missing])
+  end
+  
+  def test_to_hash_keeps_a_default_proc_by_default
+    @db.default = lambda { |key| "is #{key}" }
+    assert_equal("is missing", @db.to_hash[:missing])
+  end
+  
+  def test_to_hash_can_be_told_to_ignore_a_default
+    @db.default = 0
+    assert_nil(@db.to_hash(false)[:missing])
+    @db.default = lambda { |key| "is #{key}" }
+    assert_nil(@db.to_hash(false)[:missing])
+  end
+end

data/test/shared_tuning.rb

@@ -0,0 +1,91 @@
+module SharedTuning
+  def test_a_mutex_can_be_activated_as_the_database_is_created
+    assert_option_calls([:setmutex], :mutex => true)
+  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
+    db(: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|
+      db(: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
+      db("r")
+    end
+  end
+  
+  def test_the_mode_can_be_passed_as_as_option
+    assert_raise(OKMixer::Error::CabinetError) do  # file not found
+      db(:mode => "r")
+    end
+  end
+  
+  def test_an_option_mode_overrides_the_mode_argument_and_triggers_a_warning
+    warning = capture_stderr do
+      db("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
+      db("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(lib, c_call[0]) do
+      db(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