tarantool-model 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb88c7317a6b38d448f89c6ca24ad43f2e7c4b3da9a936795fae74a966b4873e
-  data.tar.gz: c098a1157a2539596e6789d9717c883ed1d135f260d49b44d2018e1b42f53243
+  metadata.gz: 3b70f00434a73dd90e2c7fcd3b6fa9e73e3e9f2a4809da099d22301d6e64f024
+  data.tar.gz: cdd55a36929dd8d4a3cb8c10ff4e39e90c1aa304b2ccea431db3354caf80830b
 SHA512:
-  metadata.gz: 16b134ac4b0b0efe415455fcd09b4e314bc5ac91ed5e0408cac646298ce49a78d59ce86d74afe981edc9b0c4aacf2bb1ce395206912151e67c637555537d6303
-  data.tar.gz: f9bf98de1e3c83bae3ccf399965e877887556683b8575fc54aa8ac75af2adf53412ee0af175d24dc4e589b01bf564652240cf00c0eab2ebabcbe574f6e515f06
+  metadata.gz: 0f63d44c5c2cf9d9ac311efcfe0ee7a46d7819ce4c5681c9200eaaa0116aad14b810b36acdc39480c28cc2fbc9679cedace62acb02cb41da3ee55965d5928ea2
+  data.tar.gz: 912d7c7254e2c5e9aa4d8e045da95b04c18570eff8b0dd3ee4b8b088ce9837917e11776bfb350e86c648467f7bfba1d7af8627f0bc7dd63701e2ad8d573f1c99

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## 0.1.0 (unreleased)
+## 0.2.0 (2026-10-17)
+
+- `Storage::Box` converts rows with tarantool-client (`as: :row`), by the format of the schema each request ran against, and no longer looks up `space_info` before every operation.
+- `Testing::MemoryStorage` (`require 'tarantool/model/testing'`): in-memory storage for application tests that
+  keeps the `Storage::Box` or `Storage::Crud` contract, with spaces declared in tarantool-schema's format.
+- Depends on `tarantool-client ~> 0.2.0`.
+
+## 0.1.0 (2026-10-16)
 
 First release.
 

data/README.md

@@ -105,6 +105,9 @@ Callbacks: `before_validation`, `after_validation`, `before_save`, `around_save`
 `before_create`, `around_create`, `after_create`, `before_update`, `around_update`, `after_update`,
 `before_destroy`, `around_destroy`, `after_destroy`.
 
+Models talk to Tarantool through the client given to their storage, so the client's `instrumenter:` and
+`logger:` report every read and write; see the tarantool-client README.
+
 ### Counters
 
 ```ruby
@@ -205,6 +208,81 @@ by key with crud `get` and does not use it. Make sure the index name matches the
 Keyset pagination with `after` requires a tuple, which `select` returns but single-row operations (`find`,
 `find_by`) do not. Calling `after` on a record loaded with `find` raises `ArgumentError`.
 
+## Testing
+
+`Tarantool::Model::Testing::MemoryStorage` keeps rows in memory, so model specs run without a Tarantool server.
+It is loaded only on request:
+
+```ruby
+# spec/spec_helper.rb
+require 'tarantool/model/testing'
+
+USERS_SPACE = {
+  format: [{ name: :id, type: :unsigned }, { name: :email, type: :string },
+           { name: :age, type: :unsigned, is_nullable: true }],
+  indexes: [{ name: :primary, parts: [:id], sequence: true },
+            { name: :email, parts: [:email] },
+            { name: :age, parts: [:age], unique: false }]
+}.freeze
+
+RSpec.configure do |config|
+  config.before do
+    User.storage = Tarantool::Model::Testing::MemoryStorage.new({ users: USERS_SPACE })
+  end
+end
+```
+
+Build a new storage for every example; separate instances share nothing.
+
+Spaces are declared like the `ensure_space` arguments of tarantool-schema: `format` entries are
+`{ name:, type:, is_nullable: }`; `indexes` is an Array of `{ name:, parts:, unique:, type:, sequence: }` and the
+first one is primary; `unique` defaults to true and `type` to `tree`. Parts are field names or
+`{ field:, type:, is_nullable: }`. Unknown keys and types raise `ArgumentError`, and so do indexes Tarantool
+refuses to create: a non-unique primary or `hash` index, a nullable part in either. Spaces are passed as one Hash,
+`MemoryStorage.new({ users: SCHEMA, accounts: OTHER }, behaves_like: :crud)`; `behaves_like:` is the only keyword.
+A tarantool-schema definition can be passed as is: `MemoryStorage.from_definition(definition)` duck-types
+`definition.to_h`.
+
+`behaves_like: :box` (default) keeps the `Storage::Box` contract; `behaves_like: :crud` keeps the
+`Storage::Crud` one. What Tarantool would reject is raised with the class the application gets in production:
+
+| Situation | `:box` | `:crud` |
+|---|---|---|
+| duplicate unique key | `RecordNotUnique` | `RecordNotUnique` |
+| nil in a non-nullable field | `Tarantool::ServerError`, code 23 | `Tarantool::Crud::InsertError` / `UpdateError` |
+| update of a primary key field | `Tarantool::ServerError`, code 94 | `Tarantool::Crud::UpdateError` |
+| `+`/`-` on a non-number | `Tarantool::ServerError`, code 26 | `Tarantool::Crud::UpdateError` |
+| key with more parts than the index | `Tarantool::ServerError`, code 31 | — |
+| `get` by a key without every primary key part | first matching row | `Tarantool::Crud::GetError` |
+| partial key on a multi-part hash index | `Tarantool::ServerError`, code 136 | — |
+| unsupported iterator or `after` on a hash index | `Tarantool::ServerError`, code 112 | — |
+| unknown space | `Tarantool::SchemaError` | `Tarantool::Crud::<Operation>Error` |
+| `count` | `NotSupportedError` | counts |
+| `transaction` | rolls back when the block raises | `NotSupportedError` |
+| single-row results | with a tuple | `tuple` is nil |
+
+`verify` (the schema check `Storage::Box` runs on first use) does nothing in `:crud` mode. A nil primary key gets
+the next sequence value when the primary index has `sequence: true` (`:box` only). `transaction` accepts
+`isolation:` and `timeout:` and ignores them. In `:crud` mode a missing `bucket_id` is filled from the primary key:
+the same key always gets the same value, but not the bucket vshard would compute. Values, keys and `after` tuples
+are copied through the client's msgpack codec, so they behave as on the wire: Symbols become Strings (incl. Hash
+keys in any/map fields), and changing a returned value never changes the store.
+
+Not modelled:
+
+- value types: only nullability is checked, so a String in an `unsigned` field is stored;
+- update operators other than `=`, `+` and `-` (`NotSupportedError`);
+- MVCC and concurrency: writes are visible at once, and a transaction is a snapshot restored on error;
+- Strings compare bytewise like Tarantool's default collation; values of different classes in one index raise
+  `ArgumentError`;
+- a `hash` index walks in key order, Tarantool's order is unspecified;
+- `get`, `update` and `delete` match primary keys by Ruby equality, so `[1.0]` does not find a row stored as `[1]`,
+  while Tarantool does;
+- in `:crud` mode, a condition through a name that is a field but not an index: crud filters by that field,
+  MemoryStorage returns nothing;
+- JSON path parts, `rtree` and `bitset` indexes (`ArgumentError`);
+- thread safety.
+
 ## Rails
 
 `to_param` joins a composite key with `-` (e.g. `"7-1"`) for route helpers. `as_json` works through
@@ -260,8 +338,8 @@ TARANTOOL_MODEL_CRUD_URI=tcp://app:secret@localhost:3332 bundle exec rspec --tag
 
 ## Public API
 
-`Tarantool::Model`, `Storage::Box`, `Storage::Crud`, `Types::UUID`, `Types::Interval`, `Types::Binary`,
-`Relation`, and the error classes above.
+`Tarantool::Model`, `Storage::Box`, `Storage::Crud`, `Testing::MemoryStorage`, `Types::UUID`, `Types::Interval`,
+`Types::Binary`, `Relation`, and the error classes above.
 
 Everything else, including anything tagged `@api private` in its source comment, is an implementation detail
 and may change in any release.

data/lib/tarantool/model/storage/box/layout.rb

@@ -4,8 +4,7 @@ module Tarantool
   module Model
     module Storage
       class Box
-        # Field order of a space: converts attribute Hashes to tuples and back, and checks a model against the
-        # format. Fields the model does not declare go out as nil and are ignored on read.
+        # Checks a model against the space format.
         # @api private
         class Layout
           def initialize(space_info)
@@ -13,14 +12,6 @@ module Tarantool
             @names = space_info.fields.map { |field| field.name.to_sym }
           end
 
-          def to_tuple(attributes)
-            @names.map { |name| attributes[name] }
-          end
-
-          def to_row(tuple)
-            Row.new(attributes: @names.zip(tuple).to_h, tuple:)
-          end
-
           def verify!(attributes:, primary_key:)
             missing = attributes - @names
             raise SchemaMismatchError, "space #{@space_info.name} has no field #{missing.join(', ')}" if missing.any?

data/lib/tarantool/model/storage/box.rb

@@ -4,9 +4,9 @@ module Tarantool
   module Model
     module Storage
       # Storage over a Tarantool::Client or Client::Pool. `read` options go to get and select, `write` options
-      # to insert, update and delete, verbatim. The format comes from the client's schema on every call, so
-      # alter and reconnect are picked up without a cache here. Inside Model.transaction operations, including
-      # space_info, go through the open stream.
+      # to insert, update and delete, verbatim. The client converts tuples by the format of the schema each request
+      # ran against, so alter and reconnect are picked up without a cache here. Inside Model.transaction operations,
+      # including space_info, go through the open stream.
       class Box
         ER_TUPLE_FOUND = 3
         private_constant :ER_TUPLE_FOUND
@@ -22,43 +22,30 @@ module Tarantool
         end
 
         def verify(space, attributes:, primary_key:)
-          layout(space, read).verify!(attributes:, primary_key:)
+          Layout.new(client.space_info(space, **read.slice(:mode, :timeout))).verify!(attributes:, primary_key:)
         end
 
         def get(space, key)
-          layout = layout(space, read)
-          tuple = client.select(space, key, limit: 1, **read).first
-
-          tuple && layout.to_row(tuple)
+          row(client.select(space, key, limit: 1, as: :row, **read).first)
         end
 
         def insert(space, attributes)
-          layout = layout(space, write)
-          tuple = unique { client.insert(space, layout.to_tuple(attributes), **write) }
-
-          layout.to_row(tuple)
+          row(unique { client.insert(space, attributes, as: :row, **write) })
         end
 
         def update(space, key, operations)
-          layout = layout(space, write)
-          tuple = unique { client.update(space, key, operations, **write) }
-
-          tuple && layout.to_row(tuple)
+          row(unique { client.update(space, key, operations, as: :row, **write) })
         end
 
         def delete(space, key)
-          layout = layout(space, write)
-          tuple = client.delete(space, key, **write)
-
-          tuple && layout.to_row(tuple)
+          row(client.delete(space, key, as: :row, **write))
         end
 
         def select(space, index:, key:, iterator:, limit:, after:)
-          layout = layout(space, read)
-          options = { index: index || 0, iterator:, after:, **read }
+          options = { index: index || 0, iterator:, after:, as: :row, **read }
           options[:limit] = limit if limit
 
-          client.select(space, key, **options).map { |tuple| layout.to_row(tuple) }
+          client.select(space, key, **options).map { |found| row(found) }
         end
 
         # IPROTO has no count request, and calling box.space.X.index.Y:count needs execute grants
@@ -91,8 +78,8 @@ module Tarantool
           Transactions.handle(self) ? options.except(:mode) : options
         end
 
-        def layout(space, options)
-          Layout.new(client.space_info(space, **options.slice(:mode, :timeout)))
+        def row(found)
+          found && Row.new(attributes: found.attributes, tuple: found.tuple)
         end
 
         def unique

data/lib/tarantool/model/testing/memory_storage/box_mode.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Storage::Box behaviour: schema checks, a tuple on every row, transactions, no count, server errors.
+        # @api private
+        class BoxMode
+          def verify(attributes:, primary_key:)
+            yield.layout.verify!(attributes:, primary_key:)
+          end
+
+          def sequences? = true
+
+          def transaction! = nil
+
+          def get(space, key)
+            space.get(key)
+          end
+
+          def to_tuple(space, attributes)
+            space.info.to_tuple(attributes)
+          end
+
+          def row(space, tuple, **)
+            Row.new(attributes: space.info.to_hash(tuple), tuple:)
+          end
+
+          def count!
+            raise NotSupportedError, 'MemoryStorage behaves like Storage::Box, which does not count'
+          end
+
+          def scan(space, **)
+            space.scan(**)
+          end
+
+          def error(violation, _operation)
+            return Tarantool::SchemaError.new(violation.message) if %i[space index].include?(violation.kind)
+
+            Tarantool::ServerError.new(violation.message, code: violation.code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/crud_mode.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Storage::Crud behaviour: no schema check, count, no transactions, no tuple on single-row results, no
+        # sequences, bucket_id filled in, and the tarantool-crud error class of each operation.
+        # @api private
+        class CrudMode
+          BUCKET_ID = 'bucket_id'
+          BUCKET_COUNT = 30_000
+          FLATTEN = 'Failed to flatten object: FlattenError: Object is specified in bad format: FlattenError: ' \
+                    'Field "%s" isn\'t nullable (set skip_nullability_check_on_flatten option to true to skip check)'
+
+          def verify(**) = nil
+
+          def count! = nil
+
+          def transaction!
+            raise NotSupportedError, 'crud has no interactive transactions'
+          end
+
+          def sequences? = false
+
+          def get(space, key)
+            parts = space.info.primary_index.parts.size
+            raise Violation.exact_match(parts, key.size) unless key.size == parts
+
+            space.get(key)
+          end
+
+          def to_tuple(space, attributes)
+            tuple = space.info.to_tuple(attributes)
+            fieldno = space.info.fields.index { |field| field.name == BUCKET_ID }
+            tuple[fieldno] ||= bucket(space, tuple) if fieldno
+
+            tuple
+          end
+
+          def row(space, tuple, single:)
+            Row.new(attributes: space.info.to_hash(tuple), tuple: single ? nil : tuple)
+          end
+
+          # Without a condition crud scans the primary index. With one, crud reads a name that is not an index as a
+          # field name and filters by that field; this returns nothing instead, as crud does for a name that is
+          # neither.
+          def scan(space, index:, key:, iterator:, after:)
+            return space.scan(index: nil, key: [], iterator: :all, after:) if iterator == :all || key.empty?
+            return [] unless space.index?(index)
+
+            space.scan(index:, key:, iterator:, after:)
+          end
+
+          def error(violation, operation)
+            raise Error, "tarantool-crud is not loaded; require 'tarantool/crud'" unless defined?(Tarantool::Crud)
+
+            Tarantool::Crud.const_get("#{operation.capitalize}Error").new(message(violation, operation))
+          end
+
+          private
+
+          def bucket(space, tuple)
+            key = space.info.primary_index.parts.map { |part| tuple[part.fieldno] }
+
+            (Zlib.crc32(Marshal.dump(key)) % BUCKET_COUNT) + 1
+          end
+
+          def message(violation, operation)
+            return %(Space "#{violation.subject}" doesn't exist) if violation.kind == :space
+            return format(FLATTEN, violation.subject) if violation.kind == :nil_field && operation == :insert
+
+            "Failed to #{operation}: #{violation.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/declaration.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # One space in tarantool-schema's ensure_space shape, checked and turned into the SpaceInfo that
+        # Storage::Box::Layout reads. Types are checked here but values are not type-checked.
+        # @api private
+        class Declaration
+          SPACE_KEYS = %i[engine format indexes].freeze
+          FIELD_KEYS = %i[name type is_nullable].freeze
+          TYPES = %w[unsigned string integer number double boolean decimal uuid datetime interval varbinary scalar
+                     array map any].freeze
+
+          attr_reader :space_info, :sequence
+
+          def initialize(name, schema)
+            owner = "space #{name}"
+            Keys.check!(schema, SPACE_KEYS, owner)
+            fields = Keys.fetch!(schema, :format, owner).map { |entry| field(entry, owner) }
+            Keys.distinct!(fields.map(&:name), owner)
+            indexes = index_declarations(Keys.fetch!(schema, :indexes, owner), fields, owner)
+            @space_info = build_space_info(name, fields, indexes)
+            @sequence = indexes.first.sequence
+          end
+
+          private
+
+          def build_space_info(name, fields, indexes)
+            Tarantool::Client::SpaceInfo.new(
+              id: 0, name: name.to_s, fields:, indexes: indexes.to_h { |index| [index.info.name, index.info] }
+            )
+          end
+
+          def field(entry, owner)
+            Keys.check!(entry, FIELD_KEYS, "#{owner} field")
+            name = Keys.fetch!(entry, :name, "#{owner} field").to_s
+            type = Keys.one_of!(entry.fetch(:type, 'any'), TYPES, "#{owner} field #{name}")
+
+            Tarantool::Client::SpaceInfo::Field.new(name:, type:, is_nullable: entry.fetch(:is_nullable, false))
+          end
+
+          def index_declarations(entries, fields, owner)
+            raise ArgumentError, "#{owner} has no indexes" if entries.empty?
+
+            entries.each_with_index.map { |entry, id| IndexDeclaration.new(entry, id:, fields:, owner:) }
+                   .tap { |indexes| Keys.distinct!(indexes.map { |index| index.info.name }, owner) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/index_declaration.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # One index of a space declaration; the first index of a space is the primary one.
+        # @api private
+        class IndexDeclaration
+          KEYS = %i[name parts unique type sequence].freeze
+          PART_KEYS = %i[field type is_nullable path].freeze
+          TYPES = %w[tree hash].freeze
+          SEQUENCE_TYPES = %w[unsigned integer].freeze
+
+          attr_reader :info, :sequence
+
+          def initialize(entry, id:, fields:, owner:)
+            Keys.check!(entry, KEYS, "#{owner} index")
+            @owner = "#{owner} index #{Keys.fetch!(entry, :name, "#{owner} index")}"
+            @fields = fields
+            @info = Tarantool::Client::IndexInfo.new(
+              id:, name: entry[:name].to_s, type: Keys.one_of!(entry.fetch(:type, 'tree'), TYPES, @owner),
+              unique: entry.fetch(:unique, true), parts: parts(Keys.fetch!(entry, :parts, @owner))
+            )
+            check_unique!
+            check_nullable!
+            @sequence = sequence?(entry.fetch(:sequence, false))
+          end
+
+          private
+
+          def parts(entries)
+            raise ArgumentError, "#{@owner} has no parts" if entries.empty?
+
+            entries.map { |entry| part(entry.is_a?(Hash) ? entry : { field: entry }) }
+          end
+
+          def part(entry)
+            Keys.check!(entry, PART_KEYS, "#{@owner} part")
+            raise ArgumentError, "#{@owner}: path parts are not supported" if entry[:path]
+
+            name = Keys.fetch!(entry, :field, "#{@owner} part").to_s
+            fieldno = @fields.index { |field| field.name == name }
+            raise ArgumentError, "#{@owner} has no field #{name}" unless fieldno
+
+            field = @fields[fieldno]
+            type = Keys.one_of!(entry.fetch(:type, field.type), Declaration::TYPES, "#{@owner} part #{name}")
+
+            Tarantool::Client::IndexInfo::Part.new(
+              fieldno:, name:, type:, is_nullable: entry.fetch(:is_nullable, field.is_nullable), path: nil
+            )
+          end
+
+          def check_unique!
+            return if @info.unique
+
+            raise ArgumentError, "#{@owner}: a primary index must be unique" if @info.id.zero?
+            raise ArgumentError, "#{@owner}: a hash index must be unique" if @info.type == 'hash'
+          end
+
+          def check_nullable!
+            return unless @info.parts.any?(&:is_nullable)
+
+            raise ArgumentError, "#{@owner}: a primary index can not contain nullable parts" if @info.id.zero?
+            raise ArgumentError, "#{@owner}: a hash index does not support nullable parts" if @info.type == 'hash'
+          end
+
+          def sequence?(requested)
+            return false unless requested
+            return true if @info.id.zero? && @info.parts.size == 1 && SEQUENCE_TYPES.include?(@info.parts.first.type)
+
+            raise ArgumentError, "#{@owner}: a sequence needs a primary index with one unsigned or integer part"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/keys.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Shape checks shared by the declaration classes; a bad declaration raises ArgumentError naming its owner.
+        # @api private
+        module Keys
+          module_function
+
+          def check!(declaration, allowed, owner)
+            raise ArgumentError, "#{owner} must be a Hash, got #{declaration.inspect}" unless declaration.is_a?(Hash)
+
+            unknown = declaration.keys - allowed
+            raise ArgumentError, "#{owner} has unknown keys #{unknown.join(', ')}" if unknown.any?
+          end
+
+          def fetch!(declaration, key, owner)
+            declaration.fetch(key) { raise ArgumentError, "#{owner} has no #{key}" }
+          end
+
+          def one_of!(value, allowed, owner)
+            name = value.to_s
+            raise ArgumentError, "#{owner} has unknown type #{value.inspect}" unless allowed.include?(name)
+
+            name
+          end
+
+          def distinct!(names, owner)
+            duplicates = names.tally.select { |_name, count| count > 1 }.keys
+            raise ArgumentError, "#{owner} has duplicate names #{duplicates.join(', ')}" if duplicates.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/operations.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Update operators the model sends: '=' from save, '+' and '-' from the counters. Returns a new tuple.
+        # @api private
+        class Operations
+          ARITHMETIC = %w[+ -].freeze
+
+          def initialize(space_info)
+            @names = space_info.fields.map(&:name)
+          end
+
+          def apply(tuple, operations)
+            operations.each_with_object(tuple.dup) do |(operator, name, value), result|
+              fieldno = @names.index(name.to_s) || raise(Violation.unknown_field(name))
+              result[fieldno] = value_after(operator.to_s, name, result[fieldno], value)
+            end
+          end
+
+          private
+
+          def value_after(operator, name, current, value)
+            return value if operator == '='
+            unless ARITHMETIC.include?(operator)
+              raise NotSupportedError, "MemoryStorage has no #{operator} update operator"
+            end
+            raise Violation.operand(operator, name) unless current.is_a?(Numeric) && value.is_a?(Numeric)
+
+            current.public_send(operator, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/order.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Tree index order of keys of equal length: nil first, as MP_NIL, then false before true, then Ruby's
+        # <=>. Values Ruby cannot compare, such as mixed types in a scalar field, raise ArgumentError.
+        # @api private
+        module Order
+          module_function
+
+          def compare(left, right)
+            left.zip(right).each do |a, b|
+              result = value(a, b)
+              return result unless result.zero?
+            end
+
+            0
+          end
+
+          def value(left, right)
+            return nil_rank(left) <=> nil_rank(right) if left.nil? || right.nil?
+            return as_int(left) <=> as_int(right) if boolean?(left) && boolean?(right)
+
+            (left <=> right) || raise(ArgumentError, "MemoryStorage cannot order #{left.inspect} and #{right.inspect}")
+          end
+
+          def nil_rank(value)
+            value.nil? ? 0 : 1
+          end
+
+          def boolean?(value)
+            [true, false].include?(value)
+          end
+
+          def as_int(value)
+            value ? 1 : 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/scan.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Tuples one select or count sees through an index: ordered by the index key, then the primary key (le and
+        # lt walk backwards), filtered by the key prefix condition, then continued strictly past `after`.
+        # @api private
+        class Scan
+          MATCHES = {
+            eq: :zero?.to_proc, ge: ->(result) { result >= 0 }, gt: :positive?.to_proc,
+            le: ->(result) { result <= 0 }, lt: :negative?.to_proc, all: ->(_result) { true }
+          }.freeze
+          DESCENDING = %i[le lt].freeze
+          HASH_ITERATORS = %i[eq gt all].freeze
+
+          def initialize(space_info, index)
+            @space_info = space_info
+            @index = index
+            @primary = space_info.primary_index
+          end
+
+          def call(tuples, key:, iterator:, after:)
+            match = matcher(iterator)
+            raise Violation.key_part_count(@index.parts.size, key.size) if key.size > @index.parts.size
+
+            check_hash!(key, iterator, after)
+            sign = sign_for(iterator)
+            found = matching(sorted(tuples, sign), key, match)
+
+            after ? strictly_after(found, after, sign) : found
+          end
+
+          private
+
+          # memtx starts a tree :all at the key, like :ge; a hash :all ignores the key.
+          def matcher(iterator)
+            return MATCHES[:ge] if iterator == :all && @index.type == 'tree'
+
+            MATCHES.fetch(iterator) { raise ArgumentError, "unsupported iterator #{iterator.inspect}" }
+          end
+
+          def sign_for(iterator)
+            DESCENDING.include?(iterator) ? -1 : 1
+          end
+
+          def matching(tuples, key, match)
+            tuples.select { |tuple| key.empty? || match.call(compare_key(tuple, key)) }
+          end
+
+          def strictly_after(tuples, after, sign)
+            tuples.select { |tuple| Order.compare(position(tuple), position(after)) * sign == 1 }
+          end
+
+          def sorted(tuples, sign)
+            tuples.sort { |left, right| Order.compare(position(left), position(right)) * sign }
+          end
+
+          def compare_key(tuple, key)
+            Order.compare(@index.parts.first(key.size).map { |part| tuple[part.fieldno] }, key)
+          end
+
+          def position(tuple)
+            (@index.parts + @primary.parts).map { |part| tuple[part.fieldno] }
+          end
+
+          def check_hash!(key, iterator, after)
+            return unless @index.type == 'hash'
+            raise Violation.partial_hash_key(@index.parts.size, key.size) if partial?(key)
+            raise Violation.iterator(@index.name, @space_info.name) unless HASH_ITERATORS.include?(iterator)
+            raise Violation.pagination(@index.name, @space_info.name) if after
+          end
+
+          def partial?(key)
+            !key.empty? && key.size != @index.parts.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/sequence.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # The sequence of a primary key field: fills nil from 1 and moves past explicit Integer values. Never
+        # restored by a rollback, as in Tarantool.
+        # @api private
+        class Sequence
+          def initialize(fieldno)
+            @fieldno = fieldno
+            @counter = 0
+          end
+
+          def fill(tuple)
+            value = tuple[@fieldno]
+            if value.nil?
+              tuple[@fieldno] = @counter += 1
+            elsif value.is_a?(Integer)
+              @counter = [@counter, value].max
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/space.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Rows of one space keyed by primary key, with the checks Tarantool makes on write. Values are deep-copied
+        # in and out, and a stored tuple is never changed in place, so a snapshot is a shallow copy of the rows.
+        # @api private
+        class Space
+          attr_reader :info, :layout
+
+          def initialize(info, sequence:)
+            @info = info
+            @layout = Storage::Box::Layout.new(info)
+            @primary = info.primary_index
+            @sequence = Sequence.new(@primary.parts.first.fieldno) if sequence
+            @required = required_fieldnos
+            @rows = {}
+          end
+
+          # Storage::Box gets by a select with limit 1, so a partial key gives its first match.
+          def get(key)
+            return scan(index: nil, key:, iterator: :eq, after: nil).first unless key.size == @primary.parts.size
+
+            copy(@rows[copy(key)])
+          end
+
+          def insert(tuple)
+            tuple = copy(tuple)
+            @sequence&.fill(tuple)
+
+            store(tuple, replacing: nil)
+          end
+
+          def update(key, operations)
+            key = exact(key)
+            current = @rows[key]
+            return unless current
+
+            updated = Operations.new(@info).apply(current, copy(operations))
+            raise Violation.primary_key_update(@info.name) unless key_of(updated, @primary) == key
+
+            store(updated, replacing: key)
+          end
+
+          def delete(key)
+            copy(@rows.delete(exact(key)))
+          end
+
+          def scan(index:, key:, iterator:, after:)
+            Scan.new(@info, index_info(index)).call(@rows.values, key: copy(key), iterator:, after: copy(after))
+                .map { |tuple| copy(tuple) }
+          end
+
+          def index?(name)
+            name.nil? || name.is_a?(Integer) || @info.indexes.key?(name.to_s)
+          end
+
+          def snapshot
+            @rows.dup
+          end
+
+          def restore(rows)
+            @rows = rows
+          end
+
+          private
+
+          def index_info(name)
+            return @primary if name.nil?
+
+            found = name.is_a?(Integer) ? @info.indexes.each_value.find { |index| index.id == name } : by_name(name)
+            found || raise(Violation.unknown_index(name, @info.name))
+          end
+
+          def by_name(name)
+            @info.indexes[name.to_s]
+          end
+
+          def store(tuple, replacing:)
+            check_nils(tuple)
+            check_unique(tuple, replacing)
+            @rows.delete(replacing) if replacing
+            @rows[key_of(tuple, @primary)] = tuple
+
+            copy(tuple)
+          end
+
+          def check_nils(tuple)
+            @required.each do |fieldno|
+              raise Violation.nil_field(fieldno, @info.fields[fieldno]) if tuple[fieldno].nil?
+            end
+          end
+
+          def check_unique(tuple, replacing)
+            @info.indexes.each_value.select(&:unique).each do |index|
+              key = key_of(tuple, index)
+              next if key.include?(nil)
+
+              _, old = @rows.find { |row_key, row| row_key != replacing && key_of(row, index) == key }
+              next unless old
+
+              raise RecordNotUnique, duplicate_key_message(index, old, tuple)
+            end
+          end
+
+          def duplicate_key_message(index, old, tuple)
+            "Duplicate key exists in unique index \"#{index.name}\" in space \"#{@info.name}\" with old tuple - " \
+              "#{old.inspect} and new tuple - #{tuple.inspect}"
+          end
+
+          def required_fieldnos
+            strict_parts = @info.indexes.each_value.flat_map(&:parts).reject(&:is_nullable).map(&:fieldno)
+
+            @info.fields.each_index.select do |fieldno|
+              field = @info.fields[fieldno]
+              strict_parts.include?(fieldno) || !(field.is_nullable || field.type == 'any')
+            end
+          end
+
+          def exact(key)
+            raise Violation.exact_match(@primary.parts.size, key.size) unless key.size == @primary.parts.size
+
+            copy(key)
+          end
+
+          def key_of(tuple, index)
+            index.parts.map { |part| tuple[part.fieldno] }
+          end
+
+          # Codec is @api private in tarantool-client, but released together with tarantool-model in this
+          # monorepo; only the wire round trip turns Symbols into Strings and rejects values Tarantool can't store.
+          def copy(value)
+            value && Client::Protocol::Codec::FACTORY.load(Client::Protocol::Codec::FACTORY.dump(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/violation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # What the server would reject, with its error code and text. Never leaves MemoryStorage: the mode turns it
+        # into the error class the application sees in production. `kind` is :space, :index, :nil_field or :server.
+        # @api private
+        class Violation < StandardError
+          attr_reader :kind, :code, :subject
+
+          def self.nil_field(fieldno, field)
+            new("Tuple field #{fieldno + 1} (#{field.name}) type does not match one required by operation: " \
+                "expected #{field.type}, got nil", kind: :nil_field, code: 23, subject: field.name)
+          end
+
+          def self.primary_key_update(space)
+            new("Attempt to modify a tuple field which is part of primary index in space '#{space}'", code: 94)
+          end
+
+          def self.operand(operator, name)
+            new("Argument type in operation '#{operator}' on field '#{name}' does not match field type: " \
+                'expected a number', code: 26)
+          end
+
+          def self.unknown_field(name)
+            new("Field '#{name}' was not found in the tuple", code: 201)
+          end
+
+          def self.key_part_count(max, got)
+            new("Invalid key part count (expected [0..#{max}], got #{got})", code: 31)
+          end
+
+          def self.exact_match(expected, got)
+            new("Invalid key part count in an exact match (expected #{expected}, got #{got})", code: 19)
+          end
+
+          def self.partial_hash_key(expected, got)
+            new("HASH index  does not support selects via a partial key (expected #{expected} parts, got #{got}). " \
+                'Please Consider changing index type to TREE.', code: 136)
+          end
+
+          def self.iterator(index, space)
+            new("Index '#{index}' (HASH) of space '#{space}' (memtx) does not support requested iterator type",
+                code: 112)
+          end
+
+          def self.pagination(index, space)
+            new("Index '#{index}' (HASH) of space '#{space}' (memtx) does not support pagination", code: 112)
+          end
+
+          def self.unknown_space(name)
+            new("space '#{name}' not found", kind: :space, subject: name)
+          end
+
+          def self.unknown_index(index, space)
+            new("index '#{index}' not found in space #{space}", kind: :index, subject: index)
+          end
+
+          def initialize(message, kind: :server, code: nil, subject: nil)
+            super(message)
+            @kind = kind
+            @code = code
+            @subject = subject
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      # In-memory storage for application tests, without a Tarantool server. Spaces are declared in
+      # tarantool-schema's ensure_space shape. `behaves_like: :box` keeps the Storage::Box contract, `:crud` the
+      # Storage::Crud one: what the server would reject is raised with the classes and codes the application sees
+      # in production. The README lists what it does not model.
+      class MemoryStorage
+        MODES = { box: BoxMode, crud: CrudMode }.freeze
+        private_constant :MODES
+
+        def self.from_definition(definition, **)
+          new(definition.to_h, **)
+        end
+
+        def initialize(spaces, behaves_like: :box)
+          @mode = MODES.fetch(behaves_like) do
+            raise ArgumentError, "behaves_like must be one of #{MODES.keys.join(', ')}, got #{behaves_like.inspect}"
+          end.new
+          Keys.distinct!(spaces.keys.map(&:to_s), 'MemoryStorage')
+          @spaces = spaces.to_h { |name, schema| [name.to_s, build_space(name, schema)] }
+        end
+
+        def verify(space, attributes:, primary_key:)
+          @mode.verify(attributes:, primary_key:) { perform(space, :get, &:itself) }
+        end
+
+        def get(space, key)
+          single(space, :get) { |table| @mode.get(table, key) }
+        end
+
+        def insert(space, attributes)
+          single(space, :insert) { |table| table.insert(@mode.to_tuple(table, attributes)) }
+        end
+
+        def update(space, key, operations)
+          single(space, :update) { |table| table.update(key, operations) }
+        end
+
+        def delete(space, key)
+          single(space, :delete) { |table| table.delete(key) }
+        end
+
+        def select(space, index:, key:, iterator:, limit:, after:)
+          perform(space, :select) do |table|
+            tuples = @mode.scan(table, index:, key:, iterator:, after:)
+
+            (limit ? tuples.first(limit) : tuples).map { |tuple| @mode.row(table, tuple, single: false) }
+          end
+        end
+
+        def count(space, index:, key:, iterator:)
+          @mode.count!
+
+          perform(space, :count) { |table| @mode.scan(table, index:, key:, iterator:, after: nil).size }
+        end
+
+        # Writes apply at once; the rows are restored unless the block finishes normally. `isolation:` and
+        # `timeout:` are accepted and ignored. Sequences are not restored, as in Tarantool.
+        def transaction(**, &)
+          @mode.transaction!
+          raise Tarantool::TransactionError, 'nested transactions are not supported' if Transactions.handle(self)
+
+          snapshots = @spaces.transform_values(&:snapshot)
+          committed = false
+          Transactions.open(self, :memory, &).tap { committed = true }
+        ensure
+          snapshots&.each { |name, rows| @spaces.fetch(name).restore(rows) } unless committed
+        end
+
+        private
+
+        def perform(space, operation)
+          yield @spaces.fetch(space.to_s) { raise Violation.unknown_space(space) }
+        rescue Violation => e
+          raise @mode.error(e, operation)
+        end
+
+        def single(space, operation)
+          perform(space, operation) do |table|
+            tuple = yield table
+
+            tuple && @mode.row(table, tuple, single: true)
+          end
+        end
+
+        def build_space(name, schema)
+          declaration = Declaration.new(name, schema)
+
+          Space.new(declaration.space_info, sequence: declaration.sequence && @mode.sequences?)
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'tarantool/model'
+require 'zlib'
+
+require_relative 'testing/memory_storage/keys'
+require_relative 'testing/memory_storage/violation'
+require_relative 'testing/memory_storage/index_declaration'
+require_relative 'testing/memory_storage/declaration'
+require_relative 'testing/memory_storage/operations'
+require_relative 'testing/memory_storage/order'
+require_relative 'testing/memory_storage/scan'
+require_relative 'testing/memory_storage/sequence'
+require_relative 'testing/memory_storage/space'
+require_relative 'testing/memory_storage/box_mode'
+require_relative 'testing/memory_storage/crud_mode'
+require_relative 'testing/memory_storage'

data/lib/tarantool/model/version.rb

@@ -2,6 +2,6 @@
 
 module Tarantool
   module Model
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tarantool-model
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Starlexxx
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 description: Attributes, validations, callbacks, dirty tracking and index-based queries
   with keyset pagination over Tarantool 2.11+ and 3.x spaces, through tarantool-client
   or tarantool-crud.
@@ -69,6 +69,19 @@ files:
 - lib/tarantool/model/storage/box.rb
 - lib/tarantool/model/storage/box/layout.rb
 - lib/tarantool/model/storage/crud.rb
+- lib/tarantool/model/testing.rb
+- lib/tarantool/model/testing/memory_storage.rb
+- lib/tarantool/model/testing/memory_storage/box_mode.rb
+- lib/tarantool/model/testing/memory_storage/crud_mode.rb
+- lib/tarantool/model/testing/memory_storage/declaration.rb
+- lib/tarantool/model/testing/memory_storage/index_declaration.rb
+- lib/tarantool/model/testing/memory_storage/keys.rb
+- lib/tarantool/model/testing/memory_storage/operations.rb
+- lib/tarantool/model/testing/memory_storage/order.rb
+- lib/tarantool/model/testing/memory_storage/scan.rb
+- lib/tarantool/model/testing/memory_storage/sequence.rb
+- lib/tarantool/model/testing/memory_storage/space.rb
+- lib/tarantool/model/testing/memory_storage/violation.rb
 - lib/tarantool/model/transactional.rb
 - lib/tarantool/model/transactions.rb
 - lib/tarantool/model/types/binary.rb