zvec-ruby 0.1.0 → 0.2.0

data/test/test_edge_cases.rb

@@ -0,0 +1,380 @@
+require_relative "test_helper"
+
+class TestEdgeCases < Minitest::Test
+  include TempDirHelper
+
+  # --- Empty vectors ---
+
+  def test_empty_vector_in_doc_without_schema
+    doc = Zvec::Doc.new
+    doc["vec"] = []
+    result = doc["vec"]
+    assert(result.nil? || result == [])
+  end
+
+  def test_empty_vector_in_doc_with_schema
+    schema = Zvec::Schema.new("test") do
+      vector "embedding", dimension: 4
+    end
+    doc = Zvec::Doc.new(schema: schema)
+    # Empty vectors should be accepted (no dimension to check)
+    doc["embedding"] = []
+    # Should not raise
+  end
+
+  # --- Single-element vectors ---
+
+  def test_single_element_vector
+    doc = Zvec::Doc.new
+    doc["vec"] = [42.0]
+    result = doc["vec"]
+    assert_kind_of Array, result
+    assert_equal 1, result.size
+    assert_in_delta 42.0, result[0], 0.001
+  end
+
+  def test_single_element_vector_with_schema
+    schema = Zvec::Schema.new("test") do
+      vector "embedding", dimension: 1
+    end
+    doc = Zvec::Doc.new(schema: schema)
+    doc["embedding"] = [3.14]
+    result = doc["embedding"]
+    assert_equal 1, result.size
+    assert_in_delta 3.14, result[0], 0.001
+  end
+
+  def test_single_element_vector_query
+    q = Zvec::VectorQuery.new(field_name: "vec", vector: [1.0])
+    assert_kind_of Zvec::VectorQuery, q
+  end
+
+  # --- Very large dimension vectors ---
+
+  def test_large_dimension_schema
+    schema = Zvec::Schema.new("test") do
+      vector "big_vec", dimension: 10_000
+    end
+    assert schema.has_field?("big_vec")
+    assert_equal 10_000, schema.field_dimension("big_vec")
+  end
+
+  def test_large_dimension_doc
+    schema = Zvec::Schema.new("test") do
+      vector "big_vec", dimension: 10_000
+    end
+    doc = Zvec::Doc.new(schema: schema)
+    big_vector = Array.new(10_000) { |i| i.to_f / 10_000 }
+    doc["big_vec"] = big_vector
+    result = doc["big_vec"]
+    assert_equal 10_000, result.size
+    assert_in_delta 0.0, result[0], 0.001
+    assert_in_delta 0.9999, result[9_999], 0.001
+  end
+
+  def test_large_dimension_mismatch
+    schema = Zvec::Schema.new("test") do
+      vector "big_vec", dimension: 10_000
+    end
+    doc = Zvec::Doc.new(schema: schema)
+    small_vector = [1.0, 2.0, 3.0]
+    assert_raises(Zvec::DimensionError) do
+      doc["big_vec"] = small_vector
+    end
+  end
+
+  def test_large_dimension_query
+    big_vector = Array.new(10_000) { 0.1 }
+    q = Zvec::VectorQuery.new(field_name: "big_vec", vector: big_vector)
+    assert_kind_of Zvec::VectorQuery, q
+  end
+
+  # --- Special characters in field names ---
+
+  def test_special_chars_in_field_name
+    doc = Zvec::Doc.new
+    doc["field-with-dashes"] = "dash"
+    assert_equal "dash", doc["field-with-dashes"]
+  end
+
+  def test_dot_in_field_name
+    doc = Zvec::Doc.new
+    doc["meta.title"] = "dotted"
+    assert_equal "dotted", doc["meta.title"]
+  end
+
+  def test_underscore_field_name
+    doc = Zvec::Doc.new
+    doc["_private_field"] = "private"
+    assert_equal "private", doc["_private_field"]
+  end
+
+  def test_numeric_string_field_name
+    doc = Zvec::Doc.new
+    doc["123"] = "numeric name"
+    assert_equal "numeric name", doc["123"]
+  end
+
+  def test_space_in_field_name
+    doc = Zvec::Doc.new
+    doc["field name"] = "spaced"
+    assert_equal "spaced", doc["field name"]
+  end
+
+  def test_special_chars_in_schema_field_name
+    schema = Zvec::Schema.new("test") do
+      string "field-with-dashes"
+      string "meta.title"
+      string "_private"
+    end
+    assert schema.has_field?("field-with-dashes")
+    assert schema.has_field?("meta.title")
+    assert schema.has_field?("_private")
+  end
+
+  # --- Unicode field names ---
+
+  def test_unicode_field_name
+    doc = Zvec::Doc.new
+    doc["\u30BF\u30A4\u30C8\u30EB"] = "Japanese title field"
+    assert_equal "Japanese title field", doc["\u30BF\u30A4\u30C8\u30EB"]
+  end
+
+  def test_emoji_field_name
+    doc = Zvec::Doc.new
+    doc["\u{1F680}rocket"] = "launched"
+    assert_equal "launched", doc["\u{1F680}rocket"]
+  end
+
+  def test_chinese_field_name
+    doc = Zvec::Doc.new
+    doc["\u6807\u9898"] = "Chinese title"
+    assert_equal "Chinese title", doc["\u6807\u9898"]
+  end
+
+  def test_unicode_schema_field_name
+    schema = Zvec::Schema.new("test") do
+      string "\u30BF\u30A4\u30C8\u30EB"
+    end
+    assert schema.has_field?("\u30BF\u30A4\u30C8\u30EB")
+    assert_equal Zvec::DataTypes::STRING, schema.field_type("\u30BF\u30A4\u30C8\u30EB")
+  end
+
+  # --- Unicode values ---
+
+  def test_unicode_string_value
+    doc = Zvec::Doc.new
+    doc["title"] = "\u3053\u3093\u306B\u3061\u306F\u4E16\u754C"
+    assert_equal "\u3053\u3093\u306B\u3061\u306F\u4E16\u754C", doc["title"]
+  end
+
+  def test_unicode_in_string_array
+    doc = Zvec::Doc.new
+    doc["tags"] = ["\u30BF\u30B0\u4E00", "\u30BF\u30B0\u4E8C"]
+    result = doc["tags"]
+    assert_equal ["\u30BF\u30B0\u4E00", "\u30BF\u30B0\u4E8C"], result
+  end
+
+  # --- Custom exception classes ---
+
+  def test_schema_error_is_zvec_error
+    assert Zvec::SchemaError < Zvec::Error
+  end
+
+  def test_query_error_is_zvec_error
+    assert Zvec::QueryError < Zvec::Error
+  end
+
+  def test_collection_error_is_zvec_error
+    assert Zvec::CollectionError < Zvec::Error
+  end
+
+  def test_dimension_error_is_zvec_error
+    assert Zvec::DimensionError < Zvec::Error
+  end
+
+  def test_schema_error_raised_for_nil_name
+    assert_raises(Zvec::SchemaError) { Zvec::Schema.new(nil) }
+  end
+
+  def test_schema_error_raised_for_empty_field
+    schema = Zvec::Schema.new("test")
+    assert_raises(Zvec::SchemaError) { schema.field("", Zvec::DataTypes::STRING) }
+  end
+
+  def test_query_error_raised_for_bad_vector
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: "vec", vector: [])
+    end
+  end
+
+  def test_query_error_raised_for_nil_field
+    assert_raises(Zvec::QueryError) do
+      Zvec::VectorQuery.new(field_name: nil, vector: [1.0])
+    end
+  end
+
+  # --- Collection close/reopen lifecycle ---
+
+  def test_collection_closed_flag
+    with_temp_dir("zvec_edge") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", make_schema)
+      refute col.closed?
+      col.close
+      assert col.closed?
+    end
+  end
+
+  def test_collection_close_prevents_operations
+    with_temp_dir("zvec_edge") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", make_schema)
+      col.close
+
+      assert_raises(Zvec::CollectionError) { col.doc_count }
+      assert_raises(Zvec::CollectionError) { col.stats }
+      assert_raises(Zvec::CollectionError) { col.flush }
+      assert_raises(Zvec::CollectionError) { col.optimize }
+      assert_raises(Zvec::CollectionError) do
+        col.add(pk: "x", title: "t", embedding: [1.0, 2.0, 3.0, 4.0])
+      end
+      assert_raises(Zvec::CollectionError) do
+        col.search([1.0, 2.0, 3.0, 4.0])
+      end
+    end
+  end
+
+  def test_collection_double_close_raises
+    with_temp_dir("zvec_edge") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", make_schema)
+      col.close
+      assert_raises(Zvec::CollectionError) { col.close }
+    end
+  end
+
+  def test_collection_destroy_marks_closed
+    with_temp_dir("zvec_edge") do |dir|
+      col = Zvec::Collection.create_and_open("#{dir}/col", make_schema)
+      col.destroy
+      assert col.closed?
+    end
+  end
+
+  # --- Edge cases in coercion ---
+
+  def test_coerce_empty_string_to_integer_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("", Zvec::Ext::DataType::INT64)
+    end
+  end
+
+  def test_coerce_empty_string_to_float_raises
+    assert_raises(ArgumentError) do
+      Zvec::DataTypes.coerce_value("", Zvec::Ext::DataType::DOUBLE)
+    end
+  end
+
+  def test_coerce_very_large_integer
+    result = Zvec::DataTypes.coerce_value(2**62, Zvec::Ext::DataType::INT64)
+    assert_equal 2**62, result
+  end
+
+  def test_coerce_negative_float_to_integer
+    result = Zvec::DataTypes.coerce_value(-3.7, Zvec::Ext::DataType::INT64)
+    assert_equal(-3, result)
+  end
+
+  # --- Edge cases in type detection ---
+
+  def test_detect_type_mixed_array_starts_with_float
+    # Mixed arrays: type detected from first non-nil element
+    assert_equal Zvec::Ext::DataType::VECTOR_FP32, Zvec::DataTypes.detect_type([1.0, "mixed"])
+  end
+
+  def test_detect_type_symbol
+    # Symbols are not a recognized type, returns nil
+    assert_nil Zvec::DataTypes.detect_type(:symbol)
+  end
+
+  def test_detect_type_hash
+    # Hashes are not a recognized type, returns nil
+    assert_nil Zvec::DataTypes.detect_type({ a: 1 })
+  end
+
+  # --- Collection with special character schema names ---
+
+  def test_schema_with_unicode_name
+    schema = Zvec::Schema.new("\u30C6\u30B9\u30C8") do
+      string "title"
+      vector "embedding", dimension: 4
+    end
+    assert_equal "\u30C6\u30B9\u30C8", schema.name
+  end
+
+  def test_schema_with_hyphenated_name
+    schema = Zvec::Schema.new("my-collection") do
+      string "title"
+    end
+    assert_equal "my-collection", schema.name
+  end
+
+  # --- Doc with many fields ---
+
+  def test_doc_with_many_fields
+    doc = Zvec::Doc.new
+    100.times do |i|
+      doc["field_#{i}"] = "value_#{i}"
+    end
+    assert_equal 100, doc.field_names.size
+    assert_equal "value_0", doc["field_0"]
+    assert_equal "value_99", doc["field_99"]
+  end
+
+  # --- Vector with all zeros ---
+
+  def test_zero_vector
+    doc = Zvec::Doc.new
+    doc["vec"] = [0.0, 0.0, 0.0, 0.0]
+    result = doc["vec"]
+    assert_equal [0.0, 0.0, 0.0, 0.0], result
+  end
+
+  # --- Vector with negative values ---
+
+  def test_negative_vector
+    doc = Zvec::Doc.new
+    doc["vec"] = [-1.0, -2.5, -0.001, 0.0]
+    result = doc["vec"]
+    assert_in_delta(-1.0, result[0], 0.001)
+    assert_in_delta(-2.5, result[1], 0.001)
+    assert_in_delta(-0.001, result[2], 0.001)
+  end
+
+  # --- Query with very large topk ---
+
+  def test_query_with_large_topk
+    q = Zvec::VectorQuery.new(field_name: "vec", vector: [1.0], topk: 100_000)
+    assert_equal 100_000, q.ext_query.topk
+  end
+
+  # --- Doc pk edge cases ---
+
+  def test_doc_empty_string_pk
+    doc = Zvec::Doc.new(pk: "")
+    assert_equal "", doc.pk
+  end
+
+  def test_doc_very_long_pk
+    long_pk = "x" * 10_000
+    doc = Zvec::Doc.new(pk: long_pk)
+    assert_equal long_pk, doc.pk
+  end
+
+  private
+
+  def make_schema
+    Zvec::Schema.new("edge_test") do
+      string "title"
+      vector "embedding", dimension: 4
+    end
+  end
+end

data/test/test_helper.rb

@@ -14,6 +14,10 @@ rescue LoadError
   # Minimal stubs so pure-Ruby logic can be tested without the compiled extension.
   module Zvec
     class Error < StandardError; end
+    class DimensionError < Error; end
+    class SchemaError < Error; end
+    class QueryError < Error; end
+    class CollectionError < Error; end
 
     module Ext
       # Stub enums as simple modules with constants
@@ -68,9 +72,9 @@ rescue LoadError
         def get_int64(f); @fields[f].is_a?(Integer) ? @fields[f] : nil; end
         def get_float(f); @fields[f].is_a?(Float) ? @fields[f] : nil; end
         def get_double(f); @fields[f].is_a?(Float) ? @fields[f] : nil; end
-        def get_float_vector(f); @fields[f].is_a?(Array) && @fields[f].first.is_a?(Float) ? @fields[f] : nil; end
+        def get_float_vector(f); @fields[f].is_a?(Array) && (@fields[f].empty? || @fields[f].first.is_a?(Float)) ? @fields[f] : nil; end
         def get_double_vector(f); get_float_vector(f); end
-        def get_string_array(f); @fields[f].is_a?(Array) && @fields[f].first.is_a?(String) ? @fields[f] : nil; end
+        def get_string_array(f); @fields[f].is_a?(Array) && !@fields[f].empty? && @fields[f].first.is_a?(String) ? @fields[f] : nil; end
         def to_s; "[pk:#{@pk}, score:#{@score}, fields:#{@fields.size}]"; end
       end
 
@@ -90,7 +94,6 @@ rescue LoadError
         def has_field?(n); @fields.key?(n); end
         def field_names; @fields.keys; end
         def all_field_names; @fields.keys; end
-        alias_method :field_names, :all_field_names
         def fields; @fields.values; end
         def vector_fields; @fields.values.select(&:vector_field?); end
         def forward_fields; @fields.values.reject(&:vector_field?); end
@@ -118,6 +121,15 @@ rescue LoadError
         def initialize(ef: 200); @ef = ef; end
       end
 
+      class IVFQueryParams
+        attr_reader :nprobe
+        def initialize(nprobe: 10); @nprobe = nprobe; end
+      end
+
+      class FlatQueryParams
+        def initialize; end
+      end
+
       class CollectionOptions
         attr_accessor :read_only, :enable_mmap, :max_buffer_size
         def initialize; @read_only = false; @enable_mmap = true; @max_buffer_size = 64 * 1024 * 1024; end
@@ -131,6 +143,9 @@ rescue LoadError
         def set_query_vector(arr); @query_vector = arr; end
         def set_output_fields(f); @output_fields = f; end
         def set_query_params(p); @query_params = p; end
+        def set_hnsw_query_params(p); @query_params = p; end
+        def set_ivf_query_params(p); @query_params = p; end
+        def set_flat_query_params(p); @query_params = p; end
         alias_method :include_vector?, :include_vector
       end
 
@@ -147,6 +162,89 @@ rescue LoadError
         def message; @msg; end
         def to_s; @ok ? "OK" : @msg; end
       end
+
+      # Stub Collection for pure-Ruby testing of the wrapper layer
+      class Collection
+        attr_reader :path_value, :schema_value, :docs
+
+        def initialize
+          @docs = {}
+          @stats = CollectionStats.new
+          @path_value = ""
+          @closed = false
+        end
+
+        def self.create_and_open(path, ext_schema, opts)
+          c = new
+          c.instance_variable_set(:@path_value, path)
+          c.instance_variable_set(:@schema_value, ext_schema)
+          c
+        end
+
+        def self.open(path, opts)
+          c = new
+          c.instance_variable_set(:@path_value, path)
+          c
+        end
+
+        def path; @path_value; end
+        def schema; @schema_value; end
+        def closed?; @closed; end
+
+        def close
+          @closed = true
+        end
+
+        def stats
+          s = CollectionStats.new
+          s.doc_count = @docs.size
+          s
+        end
+
+        def insert(ext_docs)
+          ext_docs.each { |d| @docs[d.pk] = d }
+          ext_docs.map { |_| [true, ""] }
+        end
+
+        def upsert(ext_docs)
+          ext_docs.each { |d| @docs[d.pk] = d }
+          ext_docs.map { |_| [true, ""] }
+        end
+
+        def update(ext_docs)
+          ext_docs.each { |d| @docs[d.pk] = d if @docs.key?(d.pk) }
+          ext_docs.map { |_| [true, ""] }
+        end
+
+        def delete_pks(pks)
+          pks.each { |pk| @docs.delete(pk) }
+          pks.map { |_| [true, ""] }
+        end
+
+        def delete_by_filter(filter)
+          # no-op in stub
+        end
+
+        def query(vq)
+          @docs.values.first(vq.topk).map do |d|
+            h = { "pk" => d.pk, "score" => 0.95 }
+            d.field_names.each { |f| h[f] = d.get_string(f) || d.get_int64(f) || d.get_float(f) || d.get_double(f) || d.get_bool(f) || d.get_float_vector(f) || d.get_string_array(f) }
+            h
+          end
+        end
+
+        def fetch(pks)
+          result = {}
+          pks.each { |pk| result[pk] = @docs[pk] if @docs.key?(pk) }
+          result
+        end
+
+        def create_index(field_name, index_params); end
+        def drop_index(field_name); end
+        def optimize; end
+        def flush; end
+        def destroy; end
+      end
     end
 
     require_relative "../lib/zvec/version"
@@ -154,6 +252,7 @@ rescue LoadError
     require_relative "../lib/zvec/schema"
     require_relative "../lib/zvec/doc"
     require_relative "../lib/zvec/query"
+    require_relative "../lib/zvec/collection"
 
     include DataTypes
   end