rom 3.3.3 → 4.0.0.beta1

data/spec/unit/rom/relation/view_spec.rb

@@ -1,158 +0,0 @@
-require 'rom'
-require 'rom/memory'
-
-RSpec.describe ROM::Relation, '.view' do
-  subject(:relation) { relation_class.new(ROM::Memory::Dataset.new([])) }
-
-  let(:registry) do
-    { tasks: tasks }
-  end
-
-  let(:tasks) do
-    Class.new(ROM::Relation[:memory]) do
-      schema do
-        attribute :title, ROM::Types::String
-      end
-    end.new([])
-  end
-
-  it 'returns view method name' do
-    klass = Class.new(ROM::Relation[:memory]) {
-      schema { attribute :id, ROM::Types::Int }
-    }
-
-    name = klass.view(:by_id, klass.schema) { self }
-
-    expect(name).to be(:by_id)
-  end
-
-  shared_context 'relation with views' do
-    before do
-      relation << { id: 1, name: 'Joe' }
-      relation << { id: 2, name: 'Jane' }
-    end
-
-    it 'appends foreign attributes' do
-      expect(relation.schemas[:foreign_attributes].map(&:name)).to eql(%i[id name title])
-    end
-
-    it 'uses projected schema for view schema' do
-      expect(relation.schemas[:names].map(&:name)).to eql(%i[name])
-    end
-
-    it 'auto-projects the relation via schema' do
-      new_rel = relation_class.new([{ name: 'Jane' }, { name: 'Joe' }])
-      names_schema = relation_class.schemas[:names]
-
-      expect(names_schema).to receive(:call).with(relation).and_return(new_rel)
-      expect(relation.names).to eql(new_rel)
-    end
-
-    it 'auto-projects a restricted relation via schema' do
-      new_rel = relation_class.new([{ id: 2 }])
-      ids_schema = relation_class.schemas[:ids_for_names]
-
-      expect(ids_schema).to receive(:call).with(relation.restrict(name: ['Jane'])).and_return(new_rel)
-      expect(relation.ids_for_names(['Jane'])).to eql(new_rel)
-    end
-  end
-
-  context 'with an explicit schema' do
-    before do
-      # this is normally called automatically during setup
-      relation_class.finalize(registry, relation)
-    end
-
-    include_context 'relation with views' do
-      let(:relation_class) do
-        Class.new(ROM::Memory::Relation) do
-          schema(:users) do
-            attribute :id, ROM::Types::Int
-            attribute :name, ROM::Types::String
-          end
-
-          view(:foreign_attributes) do
-            schema do
-              append(relations[:tasks][:title])
-            end
-
-            relation do
-              self
-            end
-          end
-
-          view(:names) do
-            schema do
-              project(:name)
-            end
-
-            relation do
-              self
-            end
-          end
-
-          view(:ids_for_names) do
-            schema do
-              project(:id)
-            end
-
-            relation do |names|
-              restrict(name: names)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context 'with an inferred schema' do
-    before do
-      # this is normally called automatically during setup
-      relation_class.schema.finalize!
-      relation_class.finalize(registry, relation)
-    end
-
-    include_context 'relation with views' do
-      let(:relation_class) do
-        Class.new(ROM::Memory::Relation) do
-          schema_inferrer -> dataset, gateway {
-            [[ROM::Types::Int.meta(name: :id, source: :users),
-             ROM::Types::String.meta(name: :name, source: :users)], []]
-          }
-
-          schema(:users, infer: true)
-
-          view(:foreign_attributes) do
-            schema do
-              append(relations[:tasks][:title])
-            end
-
-            relation do
-              self
-            end
-          end
-
-          view(:names) do
-            schema do
-              project(:name)
-            end
-
-            relation do
-              self
-            end
-          end
-
-          view(:ids_for_names) do
-            schema do
-              project(:id)
-            end
-
-            relation do |names|
-              restrict(name: names)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/rom/relation_spec.rb

@@ -1,252 +0,0 @@
-require 'rom/memory'
-
-RSpec.describe ROM::Relation do
-  subject(:relation) { Class.new(ROM::Relation).new(dataset) }
-
-  let(:dataset) { ROM::Memory::Dataset.new([jane, joe]) }
-
-  let(:jane) { { id: 1, name: 'Jane' } }
-  let(:joe) { { id: 2, name: 'Joe' } }
-
-  describe '.[]' do
-    before do
-      module Test::TestAdapter
-        class Relation < ROM::Relation
-          adapter :test
-
-          def test_relation?
-            true
-          end
-        end
-      end
-
-      module Test::BrokenAdapter
-        class Relation < ROM::Relation
-          def test_relation?
-            true
-          end
-        end
-      end
-
-      ROM.register_adapter(:test, Test::TestAdapter)
-      ROM.register_adapter(:broken, Test::BrokenAdapter)
-    end
-
-    it 'returns relation subclass from the registered adapter' do
-      subclass = Class.new(ROM::Relation[:test])
-
-      relation = subclass.new([])
-
-      expect(relation).to be_test_relation
-    end
-
-    it 'raises error when adapter relation has no identifier' do
-      expect {
-        Class.new(ROM::Relation[:broken])
-      }.to raise_error(ROM::MissingAdapterIdentifierError, /Test::BrokenAdapter::Relation/)
-    end
-  end
-
-  describe ".dataset" do
-    it 'allows setting dataset name' do
-      rel_class = Class.new(ROM::Relation[:memory]) { dataset :users }
-
-      expect(rel_class.dataset).to be(:users)
-    end
-  end
-
-  describe ".register_as" do
-    it "defaults to dataset with a generated class" do
-      rel = Class.new(ROM::Relation[:memory]) { dataset :users }
-      expect(rel.register_as).to eq(:users)
-      rel.register_as(:guests)
-      expect(rel.register_as).to eq(:guests)
-    end
-
-    it "defaults to dataset with a defined class that has dataset inferred" do
-      class Test::Users < ROM::Relation[:memory]; end
-      expect(Test::Users.register_as).to eq(:test_users)
-    end
-
-    it "defaults to dataset with a defined class that has dataset set manually" do
-      class Test::Users < ROM::Relation[:memory]
-        dataset :guests
-      end
-      expect(Test::Users.register_as).to eq(:guests)
-    end
-
-    it "defaults to :dataset of parent class" do
-      class Test::SuperUsers < ROM::Relation[:memory]
-        dataset :users
-      end
-
-      class Test::DescendantUsers < Test::SuperUsers; end
-
-      expect(Test::DescendantUsers.register_as).to be(:users)
-    end
-
-    it "sets custom value for super and descendant classes" do
-      class Test::SuperUsers < ROM::Relation[:memory]
-        register_as :users
-      end
-
-      class Test::DescendantUsers < Test::SuperUsers
-        register_as :descendant_users
-      end
-
-      expect(Test::SuperUsers.register_as).to eq(:users)
-      expect(Test::DescendantUsers.register_as).to eq(:descendant_users)
-    end
-
-    it "sets provided value overriding inherited value" do
-      module Test
-        class BaseRelation < ROM::Relation[:memory]
-        end
-
-        class UsersRelation < BaseRelation
-          register_as :users
-          dataset :users
-        end
-      end
-
-      expect(Test::UsersRelation.register_as).to be(:users)
-    end
-  end
-
-  describe '#name' do
-    context 'missing dataset' do
-      context 'with Relation inside module' do
-        before do
-          module Test::Test
-            class SuperRelation < ROM::Relation[:memory]; end
-          end
-        end
-
-        it 'returns name based on module and class' do
-          relation = Test::Test::SuperRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_test_super_relation))
-        end
-      end
-
-      context 'with Relation without module' do
-        before do
-          class Test::SuperRelation < ROM::Relation[:memory]; end
-        end
-
-        it 'returns name based only on class' do
-          relation = Test::SuperRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_super_relation))
-        end
-      end
-
-      context 'with a descendant relation' do
-        before do
-          class Test::SuperRelation < ROM::Relation[:memory]; end
-          class Test::DescendantRelation < Test::SuperRelation; end
-        end
-
-        it 'inherits :name from the super relation' do
-          relation = Test::DescendantRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_super_relation))
-        end
-      end
-    end
-
-    context 'manualy set dataset' do
-      before do
-        module Test::TestAdapter
-          class Relation < ROM::Relation[:memory]
-            dataset :foo_bar
-          end
-        end
-      end
-
-      it 'returns name based on dataset' do
-        relation = Test::TestAdapter::Relation.new([])
-
-        expect(relation.name).to eql(ROM::Relation::Name.new(:foo_bar))
-      end
-    end
-  end
-
-  describe "#each" do
-    it "yields all objects" do
-      result = []
-
-      relation.each do |user|
-        result << user
-      end
-
-      expect(result).to eql([jane, joe])
-    end
-
-    it "returns an enumerator if block is not provided" do
-      expect(relation.each).to be_instance_of(Enumerator)
-    end
-  end
-
-  describe "#to_a" do
-    it "materializes relation to an array" do
-      expect(relation.to_a).to eql([jane, joe])
-    end
-  end
-
-  describe "#with" do
-    it "returns a new instance with the original dataset and given custom options" do
-      relation = Class.new(ROM::Relation) { option :custom }.new([], custom: true)
-
-      custom_opts = { mappers: "Custom Mapper Registry" }
-      new_relation = relation.with(custom_opts).with(custom: true)
-
-      expect(new_relation.dataset).to be(relation.dataset)
-      expect(new_relation.options).to include(custom_opts.merge(custom: true))
-    end
-  end
-
-  describe '#graph?' do
-    it 'returns false' do
-      expect(relation.graph?).to be(false)
-    end
-
-    it 'returns false when curried' do
-      relation = Class.new(ROM::Relation[:memory]) { def by_name(_); self; end }.new([])
-      expect(relation.by_name.graph?).to be(false)
-    end
-  end
-
-  describe '#schema' do
-    it 'returns an empty schema by default' do
-      relation = Class.new(ROM::Relation) {
-        def self.name
-          'Test::SomeRelation'
-        end
-      }.new([])
-
-      expect(relation.schema).to be_empty
-      expect(relation.schema.inferrer).to be(ROM::Schema::DEFAULT_INFERRER)
-      expect(relation.schema.name).to be(:test_some_relation)
-      expect(relation.schema?).to be(false)
-    end
-  end
-
-  describe '#input_schema' do
-    it 'returns a schema hash type' do
-      relation = Class.new(ROM::Relation[:memory]) do
-        schema { attribute :id, ROM::Types::Coercible::Int }
-      end.new([])
-
-      expect(relation.input_schema[id: '1']).to eql(id: 1)
-    end
-
-    it 'returns a plain Hash coercer when there is no schema' do
-      relation = Class.new(ROM::Relation[:memory]).new([])
-
-      tuple = [[:id, '1']]
-
-      expect(relation.input_schema[tuple]).to eql(id: '1')
-    end
-  end
-end

data/spec/unit/rom/schema/accessing_attributes_spec.rb

@@ -1,52 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#[]' do
-  context 'with a schema' do
-    subject(:schema) do
-      define_schema(:users, id: :Int, name: :String, email: :String)
-    end
-
-    it 'returns an attribute identified by its canonical name' do
-      expect(schema[:email]).to eql(define_type(:email, :String, source: :users))
-    end
-
-    it 'returns an aliased attribute identified by its canonical name' do
-      expect(schema.rename(id: :user_id)[:id]).to eql(define_type(:id, :Int, source: :users, alias: :user_id))
-    end
-
-    it 'raises KeyError when attribute is not found' do
-      expect { schema[:not_here] }.to raise_error(KeyError, /not_here/)
-    end
-  end
-
-  context 'with a merged schema' do
-    subject(:schema) do
-      left.merge(right.__send__(:new, right.map { |attr| attr.meta(source: :tasks) }))
-    end
-
-    let(:left) do
-      define_schema(:users, id: :Int, name: :String)
-    end
-
-    let(:right) do
-      define_schema(:tasks, id: :Int, title: :String)
-    end
-
-    it 'returns an attribute identified by its canonical name' do
-      expect(schema[:id]).to eql(define_type(:id, :Int, source: :users))
-    end
-
-    it 'returns an attribute identified by its canonical name when its unique' do
-      expect(schema[:title]).to eql(define_type(:title, :String, source: :tasks))
-    end
-
-    it 'returns an attribute identified by its canonical name and its source' do
-      expect(schema[:id, :tasks]).to eql(define_type(:id, :Int, source: :tasks))
-    end
-
-    it 'raises KeyError when attribute is not found' do
-      expect { schema[:not_here] }.to raise_error(KeyError, /not_here/)
-      expect { schema[:not_here, :tasks] }.to raise_error(KeyError, /not_here/)
-    end
-  end
-end

data/spec/unit/rom/schema/append_spec.rb

@@ -1,17 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#append' do
-  subject(:schema) { left.append(*right) }
-
-  let(:left) do
-    define_schema(:users, id: :Int, name: :String)
-  end
-
-  let(:right) do
-    define_schema(:tasks, user_id: :Int)
-  end
-
-  it 'returns a new schema with attributes from two schemas' do
-    expect(schema.map(&:name)).to eql(%i[id name user_id])
-  end
-end

data/spec/unit/rom/schema/exclude_spec.rb

@@ -1,15 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#exclude' do
-  subject(:schema) do
-    define_schema(:users, id: :Int, name: :String, email: :String)
-  end
-
-  let(:excluded) do
-    schema.exclude(:id, :name)
-  end
-
-  it 'returns projected schema with renamed attributes using provided prefix' do
-    expect(excluded.map(&:name)).to eql(%i[email])
-  end
-end

data/spec/unit/rom/schema/finalize_spec.rb

@@ -1,59 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#finalize!' do
-  context 'without inferrer' do
-    subject(:schema) do
-      define_schema(:users, id: :Int, name: :String)
-    end
-
-    before { schema.finalize! }
-
-    it 'returns a frozen canonical schema' do
-      expect(schema).to be_frozen
-    end
-  end
-
-  context 'with inferrer' do
-    subject(:schema) do
-      ROM::Schema.define(:users, attributes: attributes, inferrer: inferrer)
-    end
-
-    let(:inferrer) do
-      proc { [[define_type(:name, :String)], [:id, :age]]}
-    end
-
-    context 'when all required attributes are present' do
-      let(:attributes) do
-        [define_type(:id, :Int), define_type(:age, :Int)]
-      end
-
-      it 'concats defined attributes with inferred attributes' do
-        expect(schema.finalize!.map(&:name)).to eql(%i[id age name])
-      end
-    end
-
-    context 'when inferred attributes are overridden' do
-      let(:attributes) do
-        [define_type(:id, :Int),
-         define_type(:age, :Int),
-         define_type(:name, :String).meta(custom: true)]
-      end
-
-      it 'respects overridden attributes' do
-        expect(schema.finalize!.map(&:name)).to eql(%i[id age name])
-        expect(schema[:name].meta[:custom]).to be(true)
-      end
-    end
-
-    context 'when some attributes are missing' do
-      let(:attributes) do
-        []
-      end
-
-      it 'raises error' do
-        expect { schema.finalize! }.
-          to raise_error(ROM::Schema::MissingAttributesError, /missing attributes in :users schema: :id, :age/)
-      end
-    end
-  end
-end

data/spec/unit/rom/schema/key_predicate_spec.rb

@@ -1,15 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#key?' do
-  subject(:schema) do
-    define_schema(:users, name: :String)
-  end
-
-  it 'returns true when an attribute exists' do
-    expect(schema.key?(:name)).to be(true)
-  end
-
-  it 'returns false when an attribute does not exist' do
-    expect(schema.key?(:foo)).to be(false)
-  end
-end

data/spec/unit/rom/schema/merge_spec.rb

@@ -1,17 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#merge' do
-  subject(:schema) { left.merge(right) }
-
-  let(:left) do
-    define_schema(:users, id: :Int, name: :String)
-  end
-
-  let(:right) do
-    define_schema(:tasks, user_id: :Int)
-  end
-
-  it 'returns a new schema with attributes from two schemas' do
-    expect(schema.map(&:name)).to eql(%i[id name user_id])
-  end
-end

data/spec/unit/rom/schema/prefix_spec.rb

@@ -1,16 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#prefix' do
-  subject(:schema) do
-    define_schema(:users, id: :Int, name: :String)
-  end
-
-  let(:prefixed) do
-    schema.prefix(:user)
-  end
-
-  it 'returns projected schema with renamed attributes using provided prefix' do
-    expect(prefixed.map(&:alias)).to eql(%i[user_id user_name])
-    expect(prefixed.map { |attr| attr.meta[:name] }).to eql(%i[id name])
-  end
-end

data/spec/unit/rom/schema/project_spec.rb

@@ -1,15 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#project' do
-  subject(:schema) do
-    define_schema(:users, id: :Int, name: :String, age: :Int)
-  end
-
-  it 'projects provided attribute names' do
-    expect(schema.project(:name, :age).map(&:name)).to eql(%i[name age])
-  end
-
-  it 'projects provided attributes' do
-    expect(schema.project(schema[:name], schema[:age]).map(&:name)).to eql(%i[name age])
-  end
-end

data/spec/unit/rom/schema/rename_spec.rb

@@ -1,22 +0,0 @@
-require 'rom/schema'
-
-RSpec.describe ROM::Schema, '#rename' do
-  subject(:schema) do
-    define_schema(
-      :users,
-      user_id: :Int, user_name: :String, user_email: :String
-    )
-  end
-
-  let(:renamed) do
-    schema.rename(user_id: :id, user_name: :name)
-  end
-
-  it 'returns projected schema with renamed attributes' do
-    expect(renamed.map(&:name)).to eql(%i[user_id user_name user_email])
-    expect(renamed.map(&:alias)).to eql([:id, :name, nil])
-    expect(renamed.all?(&:aliased?)).to be(false)
-    expect(renamed[:user_id]).to be_aliased
-    expect(renamed[:user_name]).to be_aliased
-  end
-end

data/spec/unit/rom/schema/type_spec.rb

@@ -1,49 +0,0 @@
-require 'rom/schema/attribute'
-
-RSpec.describe ROM::Schema::Attribute do
-  describe '#inspect' do
-    context 'with a primitive definition' do
-      subject(:type) do
-        ROM::Schema::Attribute.new(ROM::Types::Int).meta(name: :id, primary_key: true)
-      end
-
-      specify do
-        expect(type.inspect).to eql("#<ROM::Schema::Attribute[Integer] name=:id primary_key=true>")
-      end
-    end
-
-    context 'with a sum' do
-      subject(:type) do
-        ROM::Schema::Attribute.new(ROM::Types::Bool).meta(name: :admin)
-      end
-
-      specify do
-        expect(type.inspect).to eql("#<ROM::Schema::Attribute[TrueClass | FalseClass] name=:admin>")
-      end
-    end
-  end
-
-  describe '#aliased' do
-    subject(:type) do
-      ROM::Schema::Attribute.new(ROM::Types::String).meta(name: :user_name)
-    end
-
-    specify do
-      expect(type.as(:name).meta[:alias]).to eql(:name)
-    end
-  end
-
-  describe '#method_missing' do
-    subject(:type) do
-      ROM::Schema::Attribute.new(ROM::Types::Int).meta(name: :id, primary_key: true)
-    end
-
-    specify do
-      expect(type.meta).to eql(name: :id, primary_key: true)
-    end
-
-    specify do
-      expect { type.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-end