zvec-ruby 0.1.0 → 0.2.0

data/test/test_type_detection.rb

@@ -0,0 +1,258 @@
+require_relative "test_helper"
+
+class TestTypeDetection < Minitest::Test
+  # --- DataTypes.detect_type ---
+
+  def test_detect_type_nil
+    assert_nil Zvec::DataTypes.detect_type(nil)
+  end
+
+  def test_detect_type_string
+    assert_equal Zvec::Ext::DataType::STRING, Zvec::DataTypes.detect_type("hello")
+  end
+
+  def test_detect_type_integer
+    assert_equal Zvec::Ext::DataType::INT64, Zvec::DataTypes.detect_type(42)
+  end
+
+  def test_detect_type_float
+    assert_equal Zvec::Ext::DataType::DOUBLE, Zvec::DataTypes.detect_type(3.14)
+  end
+
+  def test_detect_type_true
+    assert_equal Zvec::Ext::DataType::BOOL, Zvec::DataTypes.detect_type(true)
+  end
+
+  def test_detect_type_false
+    assert_equal Zvec::Ext::DataType::BOOL, Zvec::DataTypes.detect_type(false)
+  end
+
+  # Integer vs Float distinction: 1 should be INT64, 1.0 should be DOUBLE
+  def test_detect_type_integer_one
+    assert_equal Zvec::Ext::DataType::INT64, Zvec::DataTypes.detect_type(1)
+  end
+
+  def test_detect_type_float_one
+    assert_equal Zvec::Ext::DataType::DOUBLE, Zvec::DataTypes.detect_type(1.0)
+  end
+
+  # --- Array type detection ---
+
+  def test_detect_type_empty_array
+    # Empty arrays default to VECTOR_FP32
+    assert_equal Zvec::Ext::DataType::VECTOR_FP32, Zvec::DataTypes.detect_type([])
+  end
+
+  def test_detect_type_float_array
+    assert_equal Zvec::Ext::DataType::VECTOR_FP32, Zvec::DataTypes.detect_type([1.0, 2.0])
+  end
+
+  def test_detect_type_integer_array
+    # Integers in arrays are treated as vectors (float)
+    assert_equal Zvec::Ext::DataType::VECTOR_FP32, Zvec::DataTypes.detect_type([1, 2, 3])
+  end
+
+  def test_detect_type_string_array
+    assert_equal Zvec::Ext::DataType::ARRAY_STRING, Zvec::DataTypes.detect_type(["a", "b"])
+  end
+
+  def test_detect_type_bool_array
+    assert_equal Zvec::Ext::DataType::ARRAY_BOOL, Zvec::DataTypes.detect_type([true, false])
+  end
+
+  def test_detect_type_nil_filled_array
+    # Array of all nils defaults to VECTOR_FP32
+    assert_equal Zvec::Ext::DataType::VECTOR_FP32, Zvec::DataTypes.detect_type([nil, nil, nil])
+  end
+
+  def test_detect_type_array_with_leading_nil
+    # Skips nils to find first real element
+    assert_equal Zvec::Ext::DataType::ARRAY_STRING, Zvec::DataTypes.detect_type([nil, "hello", "world"])
+  end
+
+  # --- DataTypes.coerce_value ---
+
+  def test_coerce_nil_returns_nil
+    assert_nil Zvec::DataTypes.coerce_value(nil, Zvec::Ext::DataType::STRING)
+  end
+
+  def test_coerce_to_string
+    assert_equal "42", Zvec::DataTypes.coerce_value(42, Zvec::Ext::DataType::STRING)
+  end
+
+  def test_coerce_string_true_to_bool
+    assert_equal true, Zvec::DataTypes.coerce_value("true", Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_string_false_to_bool
+    assert_equal false, Zvec::DataTypes.coerce_value("false", Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_actual_bool_true
+    assert_equal true, Zvec::DataTypes.coerce_value(true, Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_actual_bool_false
+    assert_equal false, Zvec::DataTypes.coerce_value(false, Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_integer_to_bool_nonzero
+    assert_equal true, Zvec::DataTypes.coerce_value(1, Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_integer_to_bool_zero
+    assert_equal false, Zvec::DataTypes.coerce_value(0, Zvec::Ext::DataType::BOOL)
+  end
+
+  def test_coerce_invalid_string_to_bool_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("maybe", Zvec::Ext::DataType::BOOL)
+    end
+  end
+
+  def test_coerce_float_to_integer
+    assert_equal 3, Zvec::DataTypes.coerce_value(3.7, Zvec::Ext::DataType::INT64)
+  end
+
+  def test_coerce_string_to_integer
+    assert_equal 42, Zvec::DataTypes.coerce_value("42", Zvec::Ext::DataType::INT64)
+  end
+
+  def test_coerce_bad_string_to_integer_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("abc", Zvec::Ext::DataType::INT64)
+    end
+  end
+
+  def test_coerce_integer_to_float
+    assert_in_delta 42.0, Zvec::DataTypes.coerce_value(42, Zvec::Ext::DataType::DOUBLE), 0.001
+  end
+
+  def test_coerce_string_to_float
+    assert_in_delta 3.14, Zvec::DataTypes.coerce_value("3.14", Zvec::Ext::DataType::DOUBLE), 0.001
+  end
+
+  def test_coerce_bad_string_to_float_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("xyz", Zvec::Ext::DataType::DOUBLE)
+    end
+  end
+
+  # --- Vector coercion ---
+
+  def test_coerce_integer_array_to_vector
+    result = Zvec::DataTypes.coerce_value([1, 2, 3], Zvec::Ext::DataType::VECTOR_FP32)
+    assert_equal [1.0, 2.0, 3.0], result
+  end
+
+  def test_coerce_nil_in_vector_becomes_zero
+    result = Zvec::DataTypes.coerce_value([1.0, nil, 3.0], Zvec::Ext::DataType::VECTOR_FP32)
+    assert_equal [1.0, 0.0, 3.0], result
+  end
+
+  def test_coerce_non_numeric_in_vector_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value([1.0, "bad", 3.0], Zvec::Ext::DataType::VECTOR_FP32)
+    end
+  end
+
+  def test_coerce_non_array_to_vector_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("not array", Zvec::Ext::DataType::VECTOR_FP32)
+    end
+  end
+
+  # --- String array coercion ---
+
+  def test_coerce_string_array
+    result = Zvec::DataTypes.coerce_value(["a", "b"], Zvec::Ext::DataType::ARRAY_STRING)
+    assert_equal ["a", "b"], result
+  end
+
+  def test_coerce_nil_in_string_array_becomes_empty
+    result = Zvec::DataTypes.coerce_value(["a", nil, "c"], Zvec::Ext::DataType::ARRAY_STRING)
+    assert_equal ["a", "", "c"], result
+  end
+
+  def test_coerce_non_array_to_string_array_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("not array", Zvec::Ext::DataType::ARRAY_STRING)
+    end
+  end
+
+  # --- Coerce error messages include field name ---
+
+  def test_coerce_error_message_includes_field_name
+    err = assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("abc", Zvec::Ext::DataType::INT64, field_name: "count")
+    end
+    assert_includes err.message, "count"
+  end
+
+  # --- Doc auto-detection edge cases ---
+
+  def test_doc_auto_detect_integer_vs_float
+    doc = Zvec::Doc.new
+    doc["int_val"] = 42
+    doc["float_val"] = 42.0
+    # int_val stored via set_int64, float_val via set_double
+    assert_equal 42, doc["int_val"]
+    assert_in_delta 42.0, doc["float_val"], 0.001
+  end
+
+  def test_doc_auto_detect_true_boolean
+    doc = Zvec::Doc.new
+    doc["flag"] = true
+    assert_equal true, doc["flag"]
+  end
+
+  def test_doc_auto_detect_false_boolean
+    doc = Zvec::Doc.new
+    doc["flag"] = false
+    assert_equal false, doc["flag"]
+  end
+
+  def test_doc_string_true_stays_string
+    # Without schema, "true" is a String, not a Boolean
+    doc = Zvec::Doc.new
+    doc["val"] = "true"
+    assert_equal "true", doc["val"]
+  end
+
+  def test_doc_string_false_stays_string
+    doc = Zvec::Doc.new
+    doc["val"] = "false"
+    assert_equal "false", doc["val"]
+  end
+
+  def test_doc_nil_value_in_array_auto_detect
+    doc = Zvec::Doc.new
+    doc["vec"] = [1.0, nil, 3.0]
+    result = doc["vec"]
+    assert_kind_of Array, result
+    assert_equal 3, result.size
+    assert_in_delta 0.0, result[1], 0.001
+  end
+
+  def test_doc_empty_array_auto_detect
+    doc = Zvec::Doc.new
+    doc["vec"] = []
+    # Should not crash
+    result = doc["vec"]
+    assert(result.nil? || result == [])
+  end
+
+  def test_doc_schema_coerces_string_bool
+    schema = Zvec::Schema.new("test") { bool "active" }
+    doc = Zvec::Doc.new(schema: schema)
+    doc["active"] = "true"
+    assert_equal true, doc["active"]
+  end
+
+  def test_doc_schema_coerces_int_to_float
+    schema = Zvec::Schema.new("test") { double "score" }
+    doc = Zvec::Doc.new(schema: schema)
+    doc["score"] = 42
+    assert_in_delta 42.0, doc["score"], 0.001
+  end
+end

data/test/test_validation.rb

@@ -0,0 +1,305 @@
+require_relative "test_helper"
+
+class TestValidation < Minitest::Test
+  include TempDirHelper
+
+  def setup
+    @schema = Zvec::Schema.new("test_validation") do
+      string "title"
+      int32 "count"
+      float "rating"
+      bool "active"
+      vector "embedding", dimension: 4
+    end
+  end
+
+  # --- Schema validation ---
+
+  def test_schema_rejects_nil_name
+    assert_raises(Zvec::SchemaError) { Zvec::Schema.new(nil) }
+  end
+
+  def test_schema_rejects_empty_name
+    assert_raises(Zvec::SchemaError) { Zvec::Schema.new("") }
+  end
+
+  def test_schema_rejects_blank_name
+    assert_raises(Zvec::SchemaError) { Zvec::Schema.new("   ") }
+  end
+
+  def test_schema_field_rejects_empty_name
+    schema = Zvec::Schema.new("test")
+    assert_raises(Zvec::SchemaError) { schema.field("", Zvec::DataTypes::STRING) }
+  end
+
+  def test_schema_vector_rejects_zero_dimension
+    assert_raises(ArgumentError) do
+      Zvec::Schema.new("test") { vector "v", dimension: 0 }
+    end
+  end
+
+  def test_schema_vector_rejects_negative_dimension
+    assert_raises(ArgumentError) do
+      Zvec::Schema.new("test") { vector "v", dimension: -1 }
+    end
+  end
+
+  def test_schema_vector_rejects_non_integer_dimension
+    assert_raises(ArgumentError) do
+      Zvec::Schema.new("test") { vector "v", dimension: 3.5 }
+    end
+  end
+
+  def test_schema_field_dimension_tracking
+    schema = Zvec::Schema.new("test") do
+      vector "embedding", dimension: 128
+    end
+    assert_equal 128, schema.field_dimension("embedding")
+  end
+
+  def test_schema_field_dimension_nil_for_non_vector
+    schema = Zvec::Schema.new("test") do
+      string "title"
+    end
+    assert_nil schema.field_dimension("title")
+  end
+
+  def test_schema_vector_fields_with_dimensions
+    schema = Zvec::Schema.new("test") do
+      string "title"
+      vector "embedding", dimension: 128
+      vector "small_embedding", dimension: 32
+    end
+    dims = schema.vector_fields_with_dimensions
+    assert_equal 128, dims["embedding"]
+    assert_equal 32, dims["small_embedding"]
+    refute dims.key?("title")
+  end
+
+  # --- Doc field name validation ---
+
+  def test_doc_set_rejects_empty_field_name
+    doc = Zvec::Doc.new
+    assert_raises(ArgumentError) { doc.set("", "value") }
+  end
+
+  def test_doc_set_rejects_blank_field_name
+    doc = Zvec::Doc.new
+    assert_raises(ArgumentError) { doc.set("   ", "value") }
+  end
+
+  # --- Dimension validation in Doc ---
+
+  def test_doc_dimension_mismatch_raises_error
+    doc = Zvec::Doc.new(schema: @schema)
+    assert_raises(Zvec::DimensionError) do
+      doc["embedding"] = [1.0, 2.0, 3.0]  # expects 4
+    end
+  end
+
+  def test_doc_dimension_mismatch_error_message
+    doc = Zvec::Doc.new(schema: @schema)
+    err = assert_raises(Zvec::DimensionError) do
+      doc["embedding"] = [1.0, 2.0]
+    end
+    assert_includes err.message, "embedding"
+    assert_includes err.message, "4"
+    assert_includes err.message, "2"
+  end
+
+  def test_doc_correct_dimension_accepted
+    doc = Zvec::Doc.new(schema: @schema)
+    doc["embedding"] = [1.0, 2.0, 3.0, 4.0]
+    result = doc["embedding"]
+    assert_equal 4, result.size
+  end
+
+  def test_doc_empty_vector_accepted
+    doc = Zvec::Doc.new(schema: @schema)
+    doc["embedding"] = []
+    # Empty vectors should be accepted (no dimension to check)
+  end
+
+  # --- VectorQuery validation ---
+
+  def test_query_rejects_nil_field_name
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: nil, vector: [1.0])
+    end
+  end
+
+  def test_query_rejects_empty_field_name
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "", vector: [1.0])
+    end
+  end
+
+  def test_query_rejects_empty_vector
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: [])
+    end
+  end
+
+  def test_query_rejects_non_array_vector
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: "not an array")
+    end
+  end
+
+  def test_query_rejects_non_numeric_vector_elements
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: [1.0, "bad", 3.0])
+    end
+  end
+
+  def test_query_rejects_zero_topk
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: [1.0], topk: 0)
+    end
+  end
+
+  def test_query_rejects_negative_topk
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: [1.0], topk: -1)
+    end
+  end
+
+  # --- Collection validation (using stubs) ---
+
+  def test_collection_create_rejects_nil_path
+    assert_raises(ArgumentError) do
+      Zvec::Collection.create_and_open(nil, @schema)
+    end
+  end
+
+  def test_collection_create_rejects_empty_path
+    assert_raises(ArgumentError) do
+      Zvec::Collection.create_and_open("", @schema)
+    end
+  end
+
+  def test_collection_create_rejects_non_schema
+    assert_raises(ArgumentError) do
+      Zvec::Collection.create_and_open("/tmp/test", "not a schema")
+    end
+  end
+
+  def test_collection_open_rejects_nil_path
+    assert_raises(ArgumentError) do
+      Zvec::Collection.open(nil)
+    end
+  end
+
+  def test_collection_add_rejects_nil_pk
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(ArgumentError) do
+        col.add(pk: nil, title: "test")
+      end
+    end
+  end
+
+  def test_collection_search_rejects_empty_vector
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(ArgumentError) do
+        col.search([])
+      end
+    end
+  end
+
+  def test_collection_search_rejects_non_array_vector
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(ArgumentError) do
+        col.search("not an array")
+      end
+    end
+  end
+
+  def test_collection_delete_rejects_empty_pks
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(ArgumentError) do
+        col.delete
+      end
+    end
+  end
+
+  def test_collection_fetch_rejects_empty_pks
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(ArgumentError) do
+        col.fetch
+      end
+    end
+  end
+
+  def test_collection_query_dimension_mismatch
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_raises(Zvec::DimensionError) do
+        col.query(field_name: "embedding", vector: [1.0, 2.0], topk: 5)
+      end
+    end
+  end
+
+  def test_collection_query_dimension_mismatch_message
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      err = assert_raises(Zvec::DimensionError) do
+        col.query(field_name: "embedding", vector: [1.0, 2.0], topk: 5)
+      end
+      assert_includes err.message, "embedding"
+      assert_includes err.message, "4"
+      assert_includes err.message, "2"
+      assert_includes err.message, "test_validation"
+    end
+  end
+
+  def test_collection_query_correct_dimension_accepted
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      col.add(pk: "d1", title: "Test", count: 1, rating: 1.0, active: true,
+              embedding: [1.0, 2.0, 3.0, 4.0])
+      results = col.query(field_name: "embedding", vector: [1.0, 2.0, 3.0, 4.0], topk: 5)
+      assert_kind_of Array, results
+    end
+  end
+
+  # --- Error context includes collection name ---
+
+  def test_error_prefix_includes_collection_name
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      err = assert_raises(ArgumentError) do
+        col.delete  # no pks
+      end
+      assert_includes err.message, "test_validation"
+    end
+  end
+
+  # --- DimensionError is subclass of Error ---
+
+  def test_dimension_error_is_zvec_error
+    assert Zvec::DimensionError < Zvec::Error
+  end
+
+  # --- Collection name is accessible ---
+
+  def test_collection_name_from_schema
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_equal "test_validation", col.collection_name
+    end
+  end
+
+  # --- Thread safety: collection has a monitor ---
+
+  def test_collection_has_monitor
+    with_temp_dir("zvec_val") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", @schema)
+      assert_respond_to col.instance_variable_get(:@monitor), :synchronize
+    end
+  end
+end

data/test/test_version.rb

@@ -14,6 +14,6 @@ class TestVersion < Minitest::Test
   end
 
   def test_version_value
-    assert_equal "0.1.0", Zvec::VERSION
+    assert_equal "0.2.0", Zvec::VERSION
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zvec-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Johannes Dwi Cahyo
@@ -94,11 +94,14 @@ files:
 - test/test_collection.rb
 - test/test_data_types.rb
 - test/test_doc.rb
+- test/test_edge_cases.rb
 - test/test_ext_bindings.rb
 - test/test_helper.rb
 - test/test_query.rb
 - test/test_ruby_llm_store.rb
 - test/test_schema.rb
+- test/test_type_detection.rb
+- test/test_validation.rb
 - test/test_version.rb
 - zvec.gemspec
 homepage: https://github.com/johannesdwicahyo/zvec-ruby