phronomy 0.26.0 → 0.27.0

data/lib/phronomy/storage/records.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Compare-and-write records and declared equality indexes.
+    # @api public
+    class Records
+      UNCHECKED = Object.new.freeze
+      attr_reader :resource
+      def initialize(view, resource) = (@view, @resource = view, resource)
+
+      # @api public
+      def insert(key:, revision:, attributes:, record:)
+        @view.validate!
+        entry = Entry::Record.new(key: key, revision: revision, attributes: resource.validate_attributes(attributes), record: record)
+        @view.perform(:insert_record, resource, entry: entry)
+      end
+
+      # @api public
+      def read(key)
+        @view.validate!
+        @view.perform(:read_record, resource, key: Validation.key(key))
+      end
+
+      # @api public
+      def fetch(key)
+        read(key) || raise(NotFoundError, "record not found: #{resource.id}/#{key}")
+      end
+
+      # @api public
+      def replace(key:, expected_revision:, next_revision:, attributes:, record:, expected_attributes: {})
+        @view.validate!
+        expected = Validation.revision(expected_revision)
+        entry = Entry::Record.new(key: key, revision: next_revision, attributes: resource.validate_attributes(attributes), record: record)
+        raise ConflictError, "replace must advance revision exactly once" unless next_revision == expected + 1
+        expected_values = resource.validate_attributes(expected_attributes, partial: true)
+        @view.perform(:replace_record, resource, entry: entry, expected_revision: expected, expected_attributes: expected_values)
+      end
+
+      # @api public
+      def delete(key:, expected_revision: UNCHECKED)
+        @view.validate!
+        expected = expected_revision.equal?(UNCHECKED) ? UNCHECKED : Validation.revision(expected_revision)
+        @view.perform(:delete_record, resource, key: Validation.key(key), expected_revision: expected)
+      end
+
+      # @api public
+      def scan(index:, equals:, after: nil, limit: nil)
+        @view.validate!
+        values = resource.index_values(index, equals)
+        @view.perform(:scan_records, resource, equals: values, after: after.nil? ? nil : Validation.key(after), limit: Validation.limit(limit))
+      end
+
+      # @api public
+      def delete_matching(index:, equals:)
+        @view.validate!
+        @view.perform(:delete_matching_records, resource, equals: resource.index_values(index, equals))
+      end
+    end
+  end
+end

data/lib/phronomy/storage/resource.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Immutable logical schema. Physical drivers receive a separate mapping.
+    # @api public
+    class Resource
+      TYPES = [:string, :integer, :boolean, :nullable_string, :nullable_integer, :nullable_boolean].freeze
+      attr_reader :id, :kind, :attributes, :immutable_attributes, :indexes, :unique, :guard
+
+      # Normalize a schema object or ID before constructing guards and conditions.
+      # @api private
+      def self.normalize_reference(value)
+        value.is_a?(Resource) ? value : Validation.key(value)
+      end
+
+      # @api public
+      def initialize(id:, kind:, attributes: {}, immutable_attributes: [], indexes: {}, unique: [], guard: nil)
+        @id = Validation.key(id)
+        @kind = kind
+        @attributes = Validation.immutable(attributes)
+        @immutable_attributes = Validation.immutable(immutable_attributes)
+        @indexes = Validation.immutable(indexes)
+        @unique = Validation.immutable(unique)
+        @guard = Validation.immutable(guard)
+        validate_shape!
+        validate_indexes!
+        validate_guard!
+        validate_unique!
+        freeze
+      end
+
+      # @api public
+      def validate_attributes(values, partial: false)
+        valid = values.is_a?(Hash) && (values.keys - attributes.keys).empty? && (partial || values.keys.sort == attributes.keys.sort)
+        unless valid
+          raise ArgumentError, "attributes do not match #{id}"
+        end
+        values = values.to_h do |name, value|
+          type = attributes.fetch(name)
+          if type.to_s.start_with?("nullable_") && value.nil?
+            [name, nil]
+          else
+            [name, typed_value(name, type, value)]
+          end
+        end
+        if guard && values.key?(guard[:via])
+          values[guard[:via]] = Validation.key(values.fetch(guard[:via]))
+        end
+        Validation.attributes(values)
+      end
+
+      # @api public
+      def index_values(index, equals)
+        fields = indexes.fetch(index) { raise ArgumentError, "unknown index: #{index}" }
+        raise ArgumentError, "index attributes must match exactly" unless equals.is_a?(Hash) && equals.keys.sort == fields.sort
+        validate_attributes(equals, partial: true)
+      end
+
+      private
+
+      def validate_shape!
+        raise ArgumentError, "unsupported resource kind" unless [:records, :streams, :blobs].include?(kind)
+        unless attributes.is_a?(Hash) && attributes.keys.all? { |key| key.is_a?(Symbol) } && attributes.values.all? { |type| TYPES.include?(type) }
+          raise ArgumentError, "invalid attribute declarations"
+        end
+        unless field_list?(immutable_attributes, empty: true) && indexes.is_a?(Hash) && unique.is_a?(Array)
+          raise ArgumentError, "invalid resource declarations"
+        end
+        if kind != :records && (!immutable_attributes.empty? || !indexes.empty? || !unique.empty?)
+          raise ArgumentError, "only records declare indexes, uniqueness and immutable attributes"
+        end
+        raise ArgumentError, "streams have no indexed attributes" if kind == :streams && !attributes.empty?
+      end
+
+      def validate_indexes!
+        unless indexes.all? { |name, fields| name.is_a?(Symbol) && field_list?(fields) }
+          raise ArgumentError, "indexes need names and known distinct fields"
+        end
+      end
+
+      def validate_unique!
+        names = unique.map do |constraint|
+          unless constraint.is_a?(Hash) && constraint.keys.sort == [:fields, :name, :where] &&
+              constraint[:name].is_a?(Symbol) && field_list?(constraint[:fields])
+            raise ArgumentError, "invalid unique constraint"
+          end
+          validate_attributes(constraint.fetch(:where), partial: true)
+          constraint[:name]
+        end
+        raise ArgumentError, "unique constraints need distinct names" unless names.uniq == names
+      end
+
+      def validate_guard!
+        return unless guard
+        unless guard.is_a?(Hash) && guard.keys.sort == [:resource, :via] && guard[:resource].is_a?(String)
+          raise ArgumentError, "invalid guard declaration"
+        end
+        Validation.key(guard[:resource])
+        allowed = case kind
+        when :records then [:key, *attributes.select { |_, type| type == :string }.keys]
+        when :streams then [:stream]
+        else []
+        end
+        raise ArgumentError, "invalid guard key" unless allowed.include?(guard[:via])
+        if kind == :records && guard[:via] != :key && !immutable_attributes.include?(guard[:via])
+          raise ArgumentError, "guard attributes must be immutable"
+        end
+      end
+
+      def field_list?(values, empty: false)
+        values.is_a?(Array) && (empty || !values.empty?) && values.uniq == values && (values - attributes.keys).empty?
+      end
+
+      def typed_value(name, type, value)
+        valid = case type.to_s.delete_prefix("nullable_")
+        when "string" then value.is_a?(String) && value.valid_encoding? && !value.include?("\0")
+        when "integer" then value.is_a?(Integer)
+        when "boolean" then value.equal?(true) || value.equal?(false)
+        end
+        raise ArgumentError, "invalid #{id}.#{name}" unless valid
+        value.is_a?(String) ? value.encode(Encoding::UTF_8) : value
+      end
+    end
+  end
+end

data/lib/phronomy/storage/scope.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # One synchronous transaction lifetime, independent of physical rollback.
+    # @api private
+    class Scope
+      def initialize
+        @thread = Thread.current
+        @active = true
+        @failed = false
+      end
+
+      def check!
+        raise TransactionError, "transaction belongs to another execution context" unless @thread.equal?(Thread.current)
+        raise TransactionError, "transaction scope is closed" unless @active
+        raise TransactionError, "transaction scope has failed; leave it before continuing" if @failed
+        true
+      end
+
+      def fail! = @failed = true
+      def close! = @active = false
+    end
+  end
+end

data/lib/phronomy/storage/serialization_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # A value cannot be represented by the storage record contract.
+    # @api public
+    class SerializationError < Phronomy::Error; end
+  end
+end

data/lib/phronomy/storage/streams.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Atomic ordered append with a per-stream head and entry identity.
+    # @api public
+    class Streams
+      attr_reader :resource
+      def initialize(view, resource) = (@view, @resource = view, resource)
+
+      # @api public
+      def append(stream:, expected_head:, entries:)
+        @view.validate!
+        key = Validation.key(stream)
+        expected = Validation.revision(expected_head)
+        raise ArgumentError, "entries must be an Array" unless entries.is_a?(Array)
+        values = entries.map do |entry|
+          raise SerializationError, "expected Entry::Append" unless entry.is_a?(Entry::Append)
+          Entry::Append.new(id: entry.id, record: entry.record)
+        end
+        raise ConflictError, "duplicate stream entry identity" unless values.map(&:id).uniq.length == values.length
+        @view.perform(:append_stream, resource, stream: key, expected_head: expected, entries: values.freeze)
+      end
+
+      # @api public
+      def read(stream:, after: 0, limit: nil)
+        @view.validate!
+        @view.perform(:read_stream, resource, stream: Validation.key(stream), after: Validation.revision(after), limit: Validation.limit(limit))
+      end
+
+      # @api public
+      def head(stream:)
+        @view.validate!
+        @view.perform(:stream_head, resource, stream: Validation.key(stream))
+      end
+
+      # @api public
+      def delete(stream:)
+        @view.validate!
+        @view.perform(:delete_stream, resource, stream: Validation.key(stream))
+      end
+    end
+  end
+end

data/lib/phronomy/storage/transaction_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # A neutral storage contract failure.
+    # @api public
+    class TransactionError < Phronomy::Error
+    end
+  end
+end

data/lib/phronomy/storage/unique_constraint_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # A neutral storage contract failure.
+    # @api public
+    class UniqueConstraintError < ConflictError
+      attr_reader :resource, :constraint
+      # @api public
+      def initialize(resource:, constraint:)
+        @resource = resource.id
+        @constraint = constraint
+        super("unique constraint #{resource.id}.#{constraint} failed")
+      end
+    end
+  end
+end

data/lib/phronomy/storage/unsupported_backend_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # A backend does not provide a required storage capability.
+    # @api public
+    class UnsupportedBackendError < Phronomy::Error; end
+  end
+end

data/lib/phronomy/storage/validation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Input validation shared by storage handles; no physical work happens here.
+    # @api private
+    module Validation
+      module_function
+
+      def key(value)
+        raise ArgumentError, "key must be a non-empty String" unless value.is_a?(String) && !value.empty?
+        result = value.encode(Encoding::UTF_8)
+        raise ArgumentError, "key must be valid UTF-8" unless result.valid_encoding? && !result.include?("\0")
+        result.dup.freeze
+      rescue EncodingError
+        raise ArgumentError, "key must be valid UTF-8"
+      end
+
+      def revision(value)
+        raise ArgumentError, "revision must be a non-negative Integer" unless value.is_a?(Integer) && value >= 0
+        value
+      end
+
+      def limit(value)
+        return nil if value.nil?
+        raise ArgumentError, "limit must be a positive Integer" unless value.is_a?(Integer) && value.positive?
+        value
+      end
+
+      def record(value)
+        raise SerializationError, "expected Storage::DurableRecord" unless value.is_a?(DurableRecord)
+        value.copy
+      end
+
+      def attributes(value)
+        unless value.is_a?(Hash) && value.all? { |name, item| name.is_a?(Symbol) && [String, Integer, TrueClass, FalseClass, NilClass].any? { |type| item.is_a?(type) } }
+          raise ArgumentError, "attributes must contain named scalar values"
+        end
+        immutable(value)
+      end
+
+      def immutable(value)
+        case value
+        when Hash then value.to_h { |k, v| [immutable(k), immutable(v)] }.freeze
+        when Array then value.map { |v| immutable(v) }.freeze
+        when String then value.dup.freeze
+        when Symbol, Integer, TrueClass, FalseClass, NilClass then value
+        else raise ArgumentError, "declarations must contain immutable scalar values"
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/storage/view.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Storage
+    # Root handles route to the current scope; bound handles cannot outlive it.
+    # @api public
+    class View
+      def initialize(backend, scope: nil, context: nil)
+        @backend, @scope, @context = backend, scope, context
+        @handles = {}
+      end
+
+      # @api public
+      def records(resource) = handle(resource, :records, Records)
+      # @api public
+      def streams(resource) = handle(resource, :streams, Streams)
+      # @api public
+      def blobs(resource) = handle(resource, :blobs, Blobs)
+
+      # Acquire stable anchors before evaluating conditions in the same view.
+      # @api public
+      def check!(guards:, conditions:)
+        validate!
+        raise ArgumentError, "guards and conditions must be arrays" unless guards.is_a?(Array) && conditions.is_a?(Array)
+        guards.each do |guard|
+          raise ArgumentError, "expected GuardRef" unless guard.is_a?(GuardRef)
+          resolve(guard.resource, :records)
+        end
+        conditions.each do |condition|
+          case condition
+          when Condition::RevisionIs then resolve(condition.resource, :records)
+          when Condition::StreamHeadIs then resolve(condition.resource, :streams)
+          when Condition::NoRows then resolve(condition.resource, :records).index_values(condition.index, condition.equals)
+          else raise ArgumentError, "unsupported condition"
+          end
+          require_guard!(condition, guards)
+        end
+        atomic do |bound|
+          guards.uniq.sort_by { |g| [resolve(g.resource, :records).id.b, g.key.b] }.each do |guard|
+            bound.perform(:lock_guard, resolve(guard.resource, :records), key: guard.key)
+          end
+          conditions.each do |condition|
+            matched = case condition
+            when Condition::RevisionIs then bound.records(condition.resource).read(condition.key)&.revision == condition.expected
+            when Condition::StreamHeadIs then bound.streams(condition.resource).head(stream: condition.stream) == condition.expected
+            when Condition::NoRows then bound.records(condition.resource).scan(index: condition.index, equals: condition.equals, limit: 1).empty?
+            end
+            raise ConditionFailedError, condition unless matched
+          end
+          true
+        end
+      end
+
+      # Keeps domain encoding/response validation inside the physical transaction.
+      # @api private
+      def atomic
+        validate!
+        unless @scope
+          current = @backend.current_view
+          return current.atomic { |bound| yield bound } if current
+          return @backend.transaction { |bound| bound.atomic { yield bound } }
+        end
+        completed = false
+        begin
+          result = yield self
+          @scope.check!
+          completed = true
+          result
+        ensure
+          @scope.fail! unless completed
+        end
+      end
+
+      # @api private
+      def perform(operation, resource, **arguments)
+        atomic { |bound| bound.dispatch(operation, resource, **arguments) }
+      end
+
+      # @api private
+      def dispatch(operation, resource, **arguments)
+        validate!
+        @backend.execute(@context, operation, resource, **arguments)
+      end
+
+      # @api private
+      def validate!
+        @scope&.check!
+        true
+      end
+
+      private
+
+      def require_guard!(condition, guards)
+        resource = @backend.resources.fetch(condition.resource.is_a?(Resource) ? condition.resource.id : condition.resource)
+        guard = resource.guard
+        return unless guard
+        key = case condition
+        when Condition::RevisionIs
+          if guard[:via] == :key
+            condition.key
+          else
+            raise ArgumentError, "revision checks require a key-based guard"
+          end
+        when Condition::StreamHeadIs then condition.stream
+        when Condition::NoRows
+          condition.equals.fetch(guard[:via]) { raise ArgumentError, "condition must constrain its guard attribute" }
+        end
+        covered = guards.any? do |candidate|
+          resolve(candidate.resource, :records).id == guard[:resource] && candidate.key == key
+        end
+        raise ArgumentError, "condition requires its declared guard" unless covered
+      end
+
+      def resolve(resource, kind)
+        id = resource.is_a?(Resource) ? resource.id : resource
+        registered = @backend.resources[id]
+        valid = registered && registered.kind == kind && (!resource.is_a?(Resource) || registered.equal?(resource))
+        unless valid
+          raise UnsupportedBackendError, "unregistered or mismatched #{kind} resource: #{id}"
+        end
+        registered
+      end
+
+      def handle(resource, kind, type)
+        validate!
+        registered = resolve(resource, kind)
+        @handles[registered.id] ||= type.new(self, registered)
+      end
+    end
+  end
+end

data/lib/phronomy/testing/persistence_contract/a_content_store.rb

@@ -21,7 +21,7 @@ RSpec.shared_examples "a persistence content store" do
   it "raises NotFoundError for a missing content_id" do
     expect do
       content_store.fetch("sha256:#{"0" * 64}")
-    end.to raise_error(Phronomy::Persistence::NotFoundError)
+    end.to raise_error(Phronomy::Storage::NotFoundError)
   end
 
   it "isolates durable bytes from mutation of fetched values" do

data/lib/phronomy/testing/persistence_contract/a_journal_repository.rb

@@ -51,7 +51,7 @@ RSpec.shared_examples "a Journal repository" do
         expected_position: 1,
         records: [record]
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "rejects a duplicate record_id already present in the Journal" do
@@ -76,7 +76,7 @@ RSpec.shared_examples "a Journal repository" do
         expected_position: 1,
         records: [duplicate]
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "rejects duplicate record_ids within one append" do
@@ -94,7 +94,7 @@ RSpec.shared_examples "a Journal repository" do
         expected_position: 0,
         records: records
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "rejects records belonging to another Agent" do
@@ -106,7 +106,7 @@ RSpec.shared_examples "a Journal repository" do
         expected_position: 0,
         records: [record]
       )
-    end.to raise_error(Phronomy::Persistence::SerializationError)
+    end.to raise_error(Phronomy::Storage::SerializationError)
   end
 
   it "reads records in sequence order and supports after/limit" do

data/lib/phronomy/testing/persistence_contract/a_persistence_backend.rb

@@ -3,6 +3,9 @@
 require "securerandom"
 
 RSpec.shared_examples "a Persistence backend" do
+  include_examples "neutral storage primitives"
+  include_examples "storage transaction boundaries"
+
   let(:backend_agent_root) do
     Phronomy::Agent::AgentRoot.create(
       agent_id: "backend-agent-#{SecureRandom.uuid}",
@@ -23,8 +26,8 @@ RSpec.shared_examples "a Persistence backend" do
   end
 
   it "advertises every required capability" do
-    Phronomy::Persistence::REQUIRED_CAPABILITIES.each do |name, required_value|
-      expect(persistence.capabilities[name]).to eq(required_value)
+    Phronomy::Storage::Backend::REQUIRED_CAPABILITIES.each do |name, required_value|
+      expect(persistence.backend.capabilities[name]).to eq(required_value)
     end
   end
 
@@ -129,11 +132,11 @@ RSpec.shared_examples "a Persistence backend" do
     expect(persistence.contents.exist?(content_id)).to be(false)
     expect do
       persistence.agents.load(root.agent_id)
-    end.to raise_error(Phronomy::Persistence::NotFoundError)
+    end.to raise_error(Phronomy::Storage::NotFoundError)
     expect(persistence.journals.head(root.agent_id)).to eq(0)
     expect do
       persistence.executions.load(execution.execution_id)
-    end.to raise_error(Phronomy::Persistence::NotFoundError)
+    end.to raise_error(Phronomy::Storage::NotFoundError)
     expect(persistence.workflow_states.load(workflow_id)).to be_nil
   end
 
@@ -162,7 +165,7 @@ RSpec.shared_examples "a Persistence backend" do
         agent_revision: 0,
         journal_position: 0
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "raises ConflictError when the durable Journal position has advanced" do
@@ -188,7 +191,7 @@ RSpec.shared_examples "a Persistence backend" do
         agent_revision: 0,
         journal_position: 0
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "rolls back earlier writes when a watermark precondition fails" do
@@ -209,7 +212,7 @@ RSpec.shared_examples "a Persistence backend" do
           journal_position: 0
         )
       end
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
 
     expect(persistence.contents.exist?(temporary_content_id)).to be(false)
   end

data/lib/phronomy/testing/persistence_contract/a_workflow_state_repository.rb

@@ -54,7 +54,7 @@ RSpec.shared_examples "a workflow state repository" do
         expected_revision: nil,
         snapshot: {fields: {value: 2}, phase: "__end__"}
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "returns a snapshot representation accepted by WorkflowRunner" do
@@ -111,7 +111,7 @@ RSpec.shared_examples "a workflow state repository" do
 
     expect do
       repository.delete(workflow_instance_id, expected_revision: 99)
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
 
     repository.delete(workflow_instance_id, expected_revision: 1)
     expect(repository.load(workflow_instance_id)).to be_nil

data/lib/phronomy/testing/persistence_contract/an_agent_repository.rb

@@ -22,13 +22,13 @@ RSpec.shared_examples "an Agent repository" do
 
     expect do
       agent_repository.create(agent_root)
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "raises NotFoundError for a missing Agent" do
     expect do
       agent_repository.load("missing-#{SecureRandom.uuid}")
-    end.to raise_error(Phronomy::Persistence::NotFoundError)
+    end.to raise_error(Phronomy::Storage::NotFoundError)
   end
 
   it "saves only at the expected revision" do
@@ -54,7 +54,7 @@ RSpec.shared_examples "an Agent repository" do
 
     expect do
       agent_repository.save(agent_root.agent_id, expected_revision: 0, root: stale)
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "rejects an Agent identity mismatch" do
@@ -71,7 +71,7 @@ RSpec.shared_examples "an Agent repository" do
         expected_revision: 0,
         root: other
       )
-    end.to raise_error(Phronomy::Persistence::SerializationError)
+    end.to raise_error(Phronomy::Storage::SerializationError)
   end
 
   it "requires revision to advance exactly once" do
@@ -84,7 +84,7 @@ RSpec.shared_examples "an Agent repository" do
         expected_revision: 0,
         root: skipped
       )
-    end.to raise_error(Phronomy::Persistence::ConflictError)
+    end.to raise_error(Phronomy::Storage::ConflictError)
   end
 
   it "deletes idempotently" do
@@ -94,6 +94,6 @@ RSpec.shared_examples "an Agent repository" do
 
     expect do
       agent_repository.load(agent_root.agent_id)
-    end.to raise_error(Phronomy::Persistence::NotFoundError)
+    end.to raise_error(Phronomy::Storage::NotFoundError)
   end
 end