rom 0.5.0 → 0.6.0.beta1

data/spec/integration/commands/try_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'Commands / Try api' do
-  include_context 'users and tasks'
-
-  before do
-    setup.relation(:users)
-
-    setup.commands(:users) do
-      define(:create)
-    end
-  end
-
-  let(:user_commands) { rom.command(:users) }
-
-  it 'exposes command functions inside the block' do
-    input = { name: 'Piotr', email: 'piotr@test.com' }
-
-    result = user_commands.try { create(input) }
-
-    expect(result.value).to eql([input])
-  end
-
-  it 'raises on method missing' do
-    expect { users.try { not_here } }.to raise_error(NameError)
-  end
-end

data/spec/integration/schema_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe 'Defining schema' do
-  let(:setup) { ROM.setup(memory: 'memory://localhost') }
-  let(:rom) { setup.finalize }
-  let(:schema) { rom.schema }
-
-  shared_context 'valid schema' do
-    before do
-      setup.schema do
-        base_relation(:users) do
-          repository :memory
-
-          attribute :id
-          attribute :name
-        end
-      end
-    end
-
-    it 'returns schema with relations' do
-      users = schema.users
-
-      expect(users.dataset.to_a).to eql(rom.memory.users.to_a)
-      expect(users.header).to eql([:id, :name])
-    end
-  end
-
-  describe '.schema' do
-    it 'returns an empty schema if it was not defined' do
-      expect { schema.users }.to raise_error(NoMethodError)
-    end
-
-    context 'with an adapter that supports header injection' do
-      it_behaves_like 'valid schema'
-    end
-
-    context 'can be called multiple times' do
-      before do
-        setup.schema do
-          base_relation(:tasks) do
-            repository :memory
-            attribute :title
-          end
-        end
-
-        setup.schema do
-          base_relation(:tags) do
-            repository :memory
-            attribute :name
-          end
-        end
-      end
-
-      it_behaves_like 'valid schema' do
-        it 'registers all base relations' do
-          expect(schema.tasks.dataset).to be(rom.memory.tasks)
-          expect(schema.tasks.header).to eql([:title])
-
-          expect(schema.tags.dataset).to be(rom.memory.tags)
-          expect(schema.tags.header).to eql([:name])
-        end
-      end
-    end
-
-    context 'with an adapter that does not support header injection' do
-      before do
-        ROM::Adapter::Memory::Dataset.send(:undef_method, :header)
-      end
-
-      after do
-        ROM::Adapter::Memory::Dataset.send(:attr_reader, :header)
-      end
-
-      it_behaves_like 'valid schema'
-    end
-  end
-end

data/spec/unit/config_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Config do
-  describe '.build' do
-    let(:raw_config) do
-      { adapter: 'memory', hostname: 'localhost', database: 'test' }
-    end
-
-    it 'returns rom repository configuration hash' do
-      config = ROM::Config.build(raw_config)
-
-      expect(config).to eql(default: 'memory://localhost/test')
-    end
-
-    it 'sets additional options' do
-      config = ROM::Config.build(raw_config.update(port: 312, root: '/somewhere'))
-
-      expect(config).to eql(
-        default: { uri: 'memory://localhost/test', options: { port: 312 } }
-      )
-
-      config = ROM::Config.build('memory://localhost/test', super: :option)
-
-      expect(config).to eql(
-        default: { uri: 'memory://localhost/test', options: { super: :option } }
-      )
-    end
-
-    it 'builds absolute path to the database file when database is a file' do
-      expect(ROM::Adapter[:memory]).to receive(:database_file?)
-        .with('memory').and_return(true)
-
-      config = ROM::Config.build(
-        adapter: 'memory', database: 'test', root: '/somewhere'
-      )
-
-      expect(config).to eql(default: 'memory:///somewhere/test')
-    end
-
-    it 'sets default password to an empty string' do
-      config = ROM::Config.build(raw_config.update(username: 'root'))
-      expect(config).to eql(default: 'memory://root:@localhost/test')
-    end
-
-    it 'turns a uri into configuration hash' do
-      config = ROM::Config.build('test://localhost/rom')
-      expect(config).to eql(default: 'test://localhost/rom')
-    end
-
-    it 'returns original config hash if it is already in rom format' do
-      config = ROM::Config.build(test: 'test://localhost/rom')
-      expect(config).to eql(test: 'test://localhost/rom')
-    end
-
-    it 'asks adapters to normalize scheme' do
-      expect(ROM::Adapter[:memory]).to receive(:normalize_scheme).with('memory')
-      ROM::Config.build(raw_config)
-    end
-  end
-end

data/spec/unit/rom/adapter_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Adapter do
-  before do
-    class TestAdapter < ROM::Adapter
-      def self.schemes
-        [:test_scheme]
-      end
-    end
-  end
-
-  describe '.setup' do
-    it 'sets up connection based on a uri' do
-      adapter = ROM::Adapter.setup("test_scheme::memory")
-
-      expect(adapter).to be_instance_of(TestAdapter)
-    end
-
-    it 'raises an exception if the scheme is not supported' do
-      expect {
-        ROM::Adapter.setup("bogus://any-host")
-      }.to raise_error(ArgumentError, '"bogus://any-host" uri is not supported')
-    end
-  end
-
-  describe '.[]' do
-    it "looks up and return the adapter class for the given schema" do
-      expect(ROM::Adapter[:test_scheme]).to eq TestAdapter
-    end
-  end
-
-  describe 'Registration order' do
-    it "prefers the last-defined adapter" do
-      class OrderTestFirst < TestAdapter
-        def self.schemes
-          [:order_test]
-        end
-      end
-
-      adapter = ROM::Adapter.setup("order_test::memory")
-      expect(adapter).to be_instance_of(OrderTestFirst)
-
-      OrderTestSecond = Class.new(OrderTestFirst)
-
-      adapter = ROM::Adapter.setup("order_test::memory")
-
-      expect(adapter).to be_instance_of(OrderTestSecond)
-    end
-  end
-
-  describe '#disconnect' do
-    it 'does nothing' do
-      adapter_class = Class.new(ROM::Adapter) {
-        def self.schemes
-          [:bazinga]
-        end
-      }
-
-      adapter = adapter_class.new('bazinga://localhost')
-
-      expect(adapter.disconnect).to be(nil)
-    end
-  end
-
-  describe '.setup' do
-    it 'supports connection uri and additional options' do
-      Class.new(ROM::Adapter) {
-        def self.schemes
-          [:bazinga]
-        end
-      }
-
-      adapter = ROM::Adapter.setup('bazinga://localhost', super: :option)
-
-      expect(adapter.uri).to eql(Addressable::URI.parse('bazinga://localhost'))
-      expect(adapter.options).to eql(super: :option)
-    end
-  end
-end

data/spec/unit/rom_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe ROM do
-  describe '.setup' do
-    it 'creates a boot instance using a database config hash' do
-      boot = ROM.setup(
-        adapter: 'memory', database: 'test', hostname: 'localhost'
-      )
-
-      expect(boot[:default]).to be(boot.repositories[:default])
-      expect(boot.default.adapter.uri.to_s).to eql("memory://localhost/test")
-    end
-  end
-end