rom 0.5.0 → 0.6.0.beta1

data/spec/integration/setup_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'virtus'
 
 describe 'Setting up ROM' do
   context 'with existing schema' do
@@ -7,8 +8,13 @@ describe 'Setting up ROM' do
     let(:jane) { { name: 'Jane', email: 'jane@doe.org' } }
     let(:joe) { { name: 'Joe', email: 'joe@doe.org' } }
 
+    before do
+      setup.relation(:users)
+      setup.relation(:tasks)
+    end
+
     it 'configures schema relations' do
-      expect(rom.memory.users).to match_array([joe, jane])
+      expect(rom.repositories[:default][:users]).to match_array([joe, jane])
     end
 
     it 'configures rom relations' do
@@ -33,32 +39,58 @@ describe 'Setting up ROM' do
 
   context 'without schema' do
     it 'builds empty registries if there is no schema' do
-      setup = ROM.setup(memory: 'memory://test')
-
-      setup.relation(:users)
+      setup = ROM.setup(:memory)
 
       rom = setup.finalize
 
       expect(rom.relations).to eql(ROM::RelationRegistry.new)
-      expect(rom.mappers).to eql(ROM::ReaderRegistry.new)
+      expect(rom.readers).to eql(ROM::ReaderRegistry.new)
     end
   end
 
-  describe 'quick setup' do
-    it 'exposes boot DSL inside the setup block' do
-      User = Class.new do
-        include Virtus.value_object
-        values { attribute :name, String }
+  describe 'defining classes' do
+    it 'sets up registries based on class definitions' do
+      ROM.setup(:memory)
+
+      class Test::UserRelation < ROM::Relation[:memory]
+        dataset :users
+
+        def by_name(name)
+          restrict(name: name)
+        end
       end
 
-      rom = ROM.setup(memory: 'memory://test') do
-        schema do
-          base_relation(:users) do
-            repository :memory
-            attribute :name
-          end
+      class Test::TaskRelation < ROM::Relation[:memory]
+        dataset :tasks
+      end
+
+      class Test::CreateUser < ROM::Commands::Update[:memory]
+        relation :users
+        register_as :create
+      end
+
+      rom = ROM.finalize.env
+
+      expect(rom.relations.users).to be_kind_of(Test::UserRelation)
+      expect(rom.relations.users.tasks).to be(rom.relations.tasks)
+
+      expect(rom.commands.users[:create]).to be_kind_of(Test::CreateUser)
+
+      expect(rom.relations.tasks).to be_kind_of(Test::TaskRelation)
+      expect(rom.relations.tasks.users).to be(rom.relations.users)
+    end
+  end
+
+  describe 'quick setup' do
+    it 'exposes boot DSL inside the setup block' do
+      module Test
+        User = Class.new do
+          include Virtus.value_object
+          values { attribute :name, String }
         end
+      end
 
+      rom = ROM.setup(:memory) do
         relation(:users) do
           def by_name(name)
             restrict(name: name)
@@ -71,34 +103,29 @@ describe 'Setting up ROM' do
 
         mappers do
           define(:users) do
-            model User
+            model Test::User
           end
         end
       end
 
-      rom.command(:users).try { create(name: 'Jane') }
+      rom.commands.users.create.call(name: 'Jane')
 
       expect(rom.read(:users).by_name('Jane').to_a)
-        .to eql([User.new(name: 'Jane')])
+        .to eql([Test::User.new(name: 'Jane')])
     end
   end
 
   describe 'multi-step setup' do
     it 'exposes boot DSL that can be invoked multiple times' do
-      User = Class.new do
-        include Virtus.value_object
-        values { attribute :name, String }
-      end
-
-      ROM.setup(memory: 'memory://test')
-
-      ROM.schema do
-        base_relation(:users) do
-          repository :memory
-          attribute :name
+      module Test
+        User = Class.new do
+          include Virtus.value_object
+          values { attribute :name, String }
         end
       end
 
+      ROM.setup(:memory)
+
       ROM.relation(:users) do
         def by_name(name)
           restrict(name: name)
@@ -111,7 +138,7 @@ describe 'Setting up ROM' do
 
       ROM.mappers do
         define(:users) do
-          model User
+          model Test::User
         end
       end
 
@@ -120,37 +147,7 @@ describe 'Setting up ROM' do
       rom.command(:users).create.call(name: 'Jane')
 
       expect(rom.read(:users).by_name('Jane').to_a)
-        .to eql([User.new(name: 'Jane')])
-    end
-  end
-
-  describe 'setup with extra options' do
-    shared_examples 'adapter with extra options' do
-      subject(:adapter) { setup.default.adapter }
-
-      it 'has connection uri' do
-        expect(adapter.uri).to eql(
-          Addressable::URI.parse('memory://localhost/test')
-        )
-      end
-
-      it 'has extra options' do
-        expect(adapter.options).to eql(super: 'option')
-      end
-    end
-
-    context 'with a connection uri and options passed separately' do
-      let(:setup) { ROM.setup('memory://localhost/test', super: 'option') }
-
-      it_behaves_like 'adapter with extra options'
-    end
-
-    context 'with option hash' do
-      let(:setup) do
-        ROM.setup(adapter: 'memory', database: 'test', super: 'option')
-      end
-
-      it_behaves_like 'adapter with extra options'
+        .to eql([Test::User.new(name: 'Jane')])
     end
   end
 end

data/spec/shared/enumerable_dataset.rb

@@ -0,0 +1,49 @@
+shared_examples_for "an enumerable dataset" do
+  subject(:dataset) { klass.new(data) }
+
+  let(:data) do
+    [{ 'name' => 'Jane' }, { 'name' => 'Joe' }]
+  end
+
+  describe '#each' do
+    it 'yields tuples through row_proc' do
+      result = []
+
+      dataset.each { |tuple| result << tuple }
+      expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
+    end
+  end
+
+  describe '#to_a' do
+    it 'casts dataset to an array' do
+      expect(dataset.to_a).to eql([{ name: 'Jane' }, { name: 'Joe' }])
+    end
+  end
+
+  describe '#find_all' do
+    it 'yields tuples through row_proc' do
+      result = dataset.find_all { |tuple| tuple[:name] == 'Jane' }
+
+      expect(result).to be_instance_of(klass)
+      expect(result).to match_array([{ name: 'Jane' }])
+    end
+  end
+
+  describe '#kind_of?' do
+    it 'does not forward to data object' do
+      expect(dataset).to be_kind_of(klass)
+    end
+  end
+
+  describe '#instance_of?' do
+    it 'does not forward to data object' do
+      expect(dataset).to be_instance_of(klass)
+    end
+  end
+
+  describe '#is_a?' do
+    it 'does not forward to data object' do
+      expect(dataset.is_a?(klass)).to be(true)
+    end
+  end
+end

data/spec/shared/one_behavior.rb

@@ -0,0 +1,26 @@
+shared_examples_for 'a relation that returns one tuple' do
+  describe '#one' do
+    it 'returns first tuple' do
+      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+      expect(relation.one).to eql(name: 'Jane', email: 'jane@doe.org')
+    end
+
+    it 'raises error when there is more than one tuple' do
+      expect { relation.one }.to raise_error(ROM::TupleCountMismatchError)
+    end
+  end
+
+  describe '#one!' do
+    it 'returns first tuple' do
+      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+      expect(relation.one!).to eql(name: 'Jane', email: 'jane@doe.org')
+    end
+
+    it 'raises error when there is no tuples' do
+      rom.relations.users.delete(name: 'Jane', email: 'jane@doe.org')
+      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+
+      expect { relation.one! }.to raise_error(ROM::TupleCountMismatchError)
+    end
+  end
+end

data/spec/shared/users_and_tasks.rb

@@ -1,34 +1,22 @@
 RSpec.shared_context 'users and tasks' do
+  require 'rom/memory'
+
   subject(:rom) { setup.finalize }
 
-  let(:setup) { ROM.setup(memory: "memory://localhost") }
+  let(:setup) { ROM.setup(:memory) }
 
   before do
-    setup.schema do
-      base_relation(:users) do
-        repository :memory
-
-        attribute :name
-        attribute :email
-      end
-
-      base_relation(:tasks) do
-        repository :memory
-
-        attribute :name
-        attribute :title
-        attribute :priority
-      end
-    end
+    repository = setup.default
 
-    db = setup.memory
+    users = repository.dataset(:users)
+    tasks = repository.dataset(:tasks)
 
-    db[:users].insert(name: "Joe", email: "joe@doe.org")
-    db[:users].insert(name: "Jane", email: "jane@doe.org")
+    users.insert(name: "Joe", email: "joe@doe.org")
+    users.insert(name: "Jane", email: "jane@doe.org")
 
-    db[:tasks].insert(name: "Joe", title: "be nice", priority: 1)
-    db[:tasks].insert(name: "Joe", title: "sleep well", priority: 2)
+    tasks.insert(name: "Joe", title: "be nice", priority: 1)
+    tasks.insert(name: "Joe", title: "sleep well", priority: 2)
 
-    db[:tasks].insert(name: "Jane", title: "be cool", priority: 2)
+    tasks.insert(name: "Jane", title: "be cool", priority: 2)
   end
 end

data/spec/spec_helper.rb

@@ -9,22 +9,31 @@ if RUBY_ENGINE == "rbx"
   CodeClimate::TestReporter.start
 end
 
-require 'virtus'
 require 'rom'
-require 'rom/adapter/memory'
+
+begin
+  require 'byebug'
+rescue LoadError
+end
 
 root = Pathname(__FILE__).dirname
 
 Dir[root.join('support/*.rb').to_s].each { |f| require f }
 Dir[root.join('shared/*.rb').to_s].each { |f| require f }
 
-RSpec.configure do |config|
-  config.before do
-    @constants = Object.constants
+# Namespace holding all objects created during specs
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
   end
+end
 
+RSpec.configure do |config|
   config.after do
-    added_constants = Object.constants - @constants
-    added_constants.each { |name| Object.send(:remove_const, name) }
+    Test.remove_constants
+  end
+
+  config.around do |example|
+    ConstantLeakFinder.find(example)
   end
 end

data/spec/support/constant_leak_finder.rb

@@ -0,0 +1,14 @@
+# Finds leaking constants created during ROM specs
+module ConstantLeakFinder
+  def self.find(example)
+    constants = Object.constants
+
+    example.run
+
+    added_constants = (Object.constants - constants)
+    added = added_constants.map(&Object.method(:const_get))
+    if added.any? { |mod| mod.ancestors.map(&:name).grep(/\AROM/).any? }
+      raise "Leaking constants: #{added_constants.inspect}"
+    end
+  end
+end

data/spec/test/memory_repository_lint_test.rb

@@ -0,0 +1,27 @@
+require 'rom'
+require 'rom/memory'
+require 'rom/lint/test'
+
+require 'minitest/autorun'
+
+class MemoryRepositoryLintTest < Minitest::Test
+  include ROM::Lint::TestRepository
+
+  def setup
+    @repository = ROM::Memory::Repository
+    @identifier = :memory
+  end
+
+  def repository_instance
+    ROM::Memory::Repository.new
+  end
+end
+
+class MemoryDatasetLintTest < Minitest::Test
+  include ROM::Lint::TestEnumerableDataset
+
+  def setup
+    @data  = [{ name: 'Jane', age: 24 }, { name: 'Joe', age: 25 }]
+    @dataset = ROM::Memory::Dataset.new(@data)
+  end
+end

data/spec/unit/rom/command_registry_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'ROM::CommandRegistry' do
+  subject(:env) { setup.finalize }
+
+  let(:setup) { ROM.setup(:memory) }
+  let(:users) { env.command(:users) }
+
+  before do
+    setup.relation(:users)
+
+    setup.commands(:users) do
+      define(:create) do
+        validator proc { |input| raise(ROM::CommandError) unless input[:name] }
+      end
+    end
+  end
+
+  describe '#try' do
+    it 'returns a success result object on successful execution' do
+      result = users.try { users.create.call(name: 'Jane') }
+
+      expect(result).to match_array([{ name: 'Jane' }])
+    end
+
+    it 'returns a success result on successful curried-command execution' do
+      result = users.try { users.create.curry(name: 'Jane') }
+
+      expect(result).to match_array([{ name: 'Jane' }])
+    end
+
+    it 'returns a failure result object on failed execution' do
+      result = users.try { users.create.call({}) }
+
+      expect(result.value).to be(nil)
+    end
+
+    it 'returns a failure result on unsuccessful curried-command execution' do
+      result = users.try { users.create.curry({}) }
+
+      expect(result.value).to be(nil)
+    end
+  end
+end

data/spec/unit/rom/commands/result_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ROM::Commands::Result do
+  describe '#value' do
+    subject(:result) { ROM::Commands::Result::Success }
+
+    it 'bubble up nested values' do
+      data = double(to_ary: ['foo'])
+      r = result.new(result.new(result.new(data)))
+
+      expect(r.value).to eq(data)
+    end
+  end
+end