ruby_event_store-rom 1.2.1 → 2.0.0

data/lib/ruby_event_store/spec/rom/relations/stream_entries_lint.rb

@@ -1,198 +0,0 @@
-RSpec.shared_examples :stream_entries_relation do |_relation_class|
-  subject(:relation) { rom_container.relations[:stream_entries] }
-
-  let(:env) { rom_helper.env }
-  let(:rom_container) { env.rom_container }
-  let(:rom_db) { rom_container.gateways[:default] }
-
-  around(:each) do |example|
-    rom_helper.run_lifecycle { example.run }
-  end
-
-  it 'just created is empty' do
-    expect(relation.to_a).to be_empty
-  end
-
-  specify '#insert verifies tuple is unique steam and event_id' do
-    stream_entries = [
-      { stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid },
-      { stream: 'stream', position: 1, event_id: SecureRandom.uuid },
-      { stream: 'stream', position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    conflicting_event_id = { stream: 'stream', position: 3, event_id: id1, created_at: Time.now }
-
-    expect(relation.to_a.size).to eq(3)
-    expect do
-      env.handle_error(:unique_violation) { relation.insert(conflicting_event_id) }
-    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
-
-    conflicting_position = { stream: 'stream', position: 2, event_id: SecureRandom.uuid, created_at: Time.now }
-
-    expect do
-      env.handle_error(:unique_violation) { relation.insert(conflicting_position) }
-    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
-  end
-
-  specify '#take ignores nil' do
-    stream_entries = [
-      { stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid },
-      { stream: 'stream', position: 1, event_id: id2 = SecureRandom.uuid },
-      { stream: 'stream', position: 2, event_id: id3 = SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(3)
-    expect(relation.take(nil).to_a.size).to eq(3)
-    expect(relation.take(nil).map { |e| e[:event_id] }).to eq([id1, id2, id3])
-  end
-
-  specify '#take returns specified number of tuples' do
-    stream_entries = [
-      { stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid },
-      { stream: 'stream', position: 1, event_id: id2 = SecureRandom.uuid },
-      { stream: 'stream', position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(3)
-    expect(relation.take(2).to_a.size).to eq(2)
-    expect(relation.take(2).map { |e| e[:event_id] }).to eq([id1, id2])
-  end
-
-  specify '#by_stream returns tuples for the specified stream' do
-    stream_entries = [
-      { stream: 'stream', position: 0, event_id: SecureRandom.uuid },
-      { stream: 'stream', position: 1, event_id: SecureRandom.uuid },
-      { stream: 'stream2', position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(3)
-    expect(relation.by_stream(RubyEventStore::Stream.new('stream')).to_a.size).to eq(2)
-  end
-
-  specify '#by_stream_and_event_id returns a tuple for the specified stream and event_id' do
-    stream = RubyEventStore::Stream.new('stream')
-    stream2 = RubyEventStore::Stream.new('stream2')
-
-    stream_entries = [
-      { stream: stream.name, position: 0, event_id: id = SecureRandom.uuid },
-      { stream: stream.name, position: 1, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(3)
-    expect(relation.by_stream_and_event_id(stream, id)[:event_id]).to eq(id)
-    expect { relation.by_stream_and_event_id(stream2, id) }.to raise_error(ROM::TupleCountMismatchError)
-  end
-
-  specify '#max_position gets the largest position value' do
-    stream = RubyEventStore::Stream.new('stream')
-    stream2 = RubyEventStore::Stream.new('stream2')
-    stream3 = RubyEventStore::Stream.new('stream3')
-
-    stream_entries = [
-      { stream: stream.name, position: 0, event_id: SecureRandom.uuid },
-      { stream: stream.name, position: 2, event_id: SecureRandom.uuid },
-      { stream: stream.name, position: 1, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 1, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 0, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 3, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(7)
-    expect(relation.max_position(stream)).not_to be(nil)
-    expect(relation.max_position(stream)[:position]).to eq(2)
-    expect(relation.max_position(stream).to_h.keys).to eq([:position])
-    expect(relation.max_position(stream3)).to eq(nil)
-  end
-
-  specify '#ordered gets the stream entries :forward' do
-    stream = RubyEventStore::Stream.new('stream')
-    stream2 = RubyEventStore::Stream.new('stream2')
-
-    stream_entries = [
-      { stream: stream.name, position: 0, event_id: SecureRandom.uuid },
-      { stream: stream.name, position: 1, event_id: id1 = SecureRandom.uuid },
-      { stream: stream.name, position: 2, event_id: id2 = SecureRandom.uuid },
-      { stream: stream2.name, position: 0, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 1, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 2, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 3, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(7)
-    expect(relation.ordered(:forward, stream).to_a.size).to eq(3)
-    expect(relation.ordered(:forward, stream).map { |e| e[:position] }).to eq([0, 1, 2])
-
-    offset1 = relation.by_stream_and_event_id(stream, id1)[:id]
-    offset2 = relation.by_stream_and_event_id(stream, id2)[:id]
-
-    expect(relation.ordered(:forward, stream, offset1).map { |e| e[:position] }).to eq([2])
-    expect(relation.ordered(:forward, stream, offset2).map { |e| e[:position] }).to eq([])
-  end
-
-  specify '#ordered gets the stream entries :backward' do
-    stream = RubyEventStore::Stream.new('stream')
-    stream2 = RubyEventStore::Stream.new('stream2')
-
-    stream_entries = [
-      { stream: stream.name, position: 0, event_id: id1 = SecureRandom.uuid },
-      { stream: stream.name, position: 1, event_id: id2 = SecureRandom.uuid },
-      { stream: stream.name, position: 2, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 0, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 1, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 2, event_id: SecureRandom.uuid },
-      { stream: stream2.name, position: 3, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.to_a.size).to eq(7)
-    expect(relation.ordered(:backward, stream).to_a.size).to eq(3)
-    expect(relation.ordered(:backward, stream).map { |e| e[:position] }).to eq([2, 1, 0])
-
-    offset1 = relation.by_stream_and_event_id(stream, id1)[:id]
-    offset2 = relation.by_stream_and_event_id(stream, id2)[:id]
-
-    expect(relation.ordered(:backward, stream, offset1).map { |e| e[:position] }).to eq([])
-    expect(relation.ordered(:backward, stream, offset2).map { |e| e[:position] }).to eq([0])
-  end
-
-  specify 'each method returns proper type' do
-    stream = RubyEventStore::Stream.new('stream')
-    stream_entries = [
-      { stream: 'stream', position: 0, event_id: SecureRandom.uuid },
-      { stream: 'stream', position: 1, event_id: SecureRandom.uuid },
-      { stream: 'stream', position: 2, event_id: SecureRandom.uuid }
-    ]
-
-    relation.command(:create).call(stream_entries)
-
-    expect(relation.take(1)).to be_a(relation.class)
-    # expect(relation.take(1).one).to be_a(::ROM::Struct)
-
-    expect(relation.by_stream(stream)).to be_a(relation.class)
-    # expect(relation.by_stream(stream).take(1).one).to be_a(::ROM::Struct)
-
-    # expect(relation.by_stream_and_event_id(stream, id1)).to be_a(::ROM::Struct)
-
-    # expect(relation.max_position(stream)).to be_a(::ROM::Struct)
-
-    expect(relation.ordered(:forward, stream)).to be_a(relation.class)
-    # expect(relation.ordered(:forward, stream).take(1).one).to be_a(::ROM::Struct)
-  end
-end

data/lib/ruby_event_store/spec/rom/spec_helper_lint.rb

@@ -1,15 +0,0 @@
-module RubyEventStore::ROM
-  RSpec.shared_examples :rom_spec_helper do |_rom_spec_helper_class|
-    let(:env) { rom_helper.env }
-    let(:rom_container) { env.rom_container }
-    let(:rom_db) { rom_container.gateways[:default] }
-
-    around(:each) do |example|
-      rom_helper.run_lifecycle { example.run }
-    end
-
-    specify '#env gives access to ROM container' do
-      expect(subject.env.rom_container).to be_a(::ROM::Container)
-    end
-  end
-end

data/lib/ruby_event_store/spec/rom/unit_of_work_lint.rb

@@ -1,37 +0,0 @@
-module RubyEventStore::ROM
-  RSpec.shared_examples :unit_of_work do |unit_of_work_class|
-    subject(:unit_of_work) { unit_of_work_class.new(rom: env) }
-
-    let(:env) { rom_helper.env }
-    let(:v) { env.rom_container }
-    let(:rom_db) { rom_container.gateways[:default] }
-
-    around(:each) do |example|
-      rom_helper.run_lifecycle { example.run }
-    end
-
-    specify '#env gives access to ROM container' do
-      expect(subject.env.rom_container).to be_a(::ROM::Container)
-    end
-
-    specify '#call to throw an exeption' do
-      expect { subject.call(gateway: nil) {} }.to raise_error(KeyError)
-    end
-
-    specify '#env is the instance we specified' do
-      expect(subject.env).to eq(env)
-    end
-
-    specify '#env is the global instance' do
-      RubyEventStore::ROM.env = rom_helper.class.new.env
-
-      subject2 = unit_of_work_class.new
-
-      expect(subject2.env).to eq(RubyEventStore::ROM.env)
-      expect(subject2.env).not_to eq(subject.env)
-      expect(subject.env).not_to eq(RubyEventStore::ROM.env)
-
-      RubyEventStore::ROM.env = nil
-    end
-  end
-end

data/ruby_event_store-rom.gemspec

@@ -1,37 +0,0 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'ruby_event_store/rom/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'ruby_event_store-rom'
-  spec.version       = RubyEventStore::ROM::VERSION
-  spec.licenses      = ['MIT']
-  spec.authors       = ['Joel Van Horn']
-  spec.email         = ['joel@joelvanhorn.com']
-
-  spec.summary       = 'ROM events repository for Ruby Event Store'
-  spec.description   = "Implementation of events repository based on ROM for Ruby Event Store'"
-  spec.homepage      = 'https://railseventstore.org'
-  spec.metadata    = {
-    'homepage_uri' => 'https://railseventstore.org/',
-    'changelog_uri' => 'https://github.com/RailsEventStore/rails_event_store/releases',
-    'source_code_uri' => 'https://github.com/RailsEventStore/rails_event_store',
-    'bug_tracker_uri' => 'https://github.com/RailsEventStore/rails_event_store/issues'
-  }
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 2.4'
-
-  spec.add_dependency 'dry-container', '>= 0.6'
-  spec.add_dependency 'dry-initializer', '>= 3.0'
-  spec.add_dependency 'dry-types', '>= 1.0'
-  spec.add_dependency 'rom-changeset', '>= 5.0'
-  spec.add_dependency 'rom-repository', '>= 5.0'
-  spec.add_dependency 'rom-sql', '>= 3.0'
-  spec.add_dependency 'ruby_event_store', '= 1.2.1'
-  spec.add_dependency 'sequel', '>= 5.11.0'
-end