rom 3.3.3 → 4.0.0.beta1

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

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation do
-  include_context 'gateway only'
-  include_context 'users and tasks'
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def by_name(name)
-        restrict(name: name)
-      end
-
-      def by_name_sorted(name, order_by = :name)
-        by_name(name).order(order_by)
-      end
-
-      def by_email(email)
-        restrict(name: email)
-      end
-
-      def by_name_and_email(name, email)
-        by_name(name).by_email(email)
-      end
-
-      def by_name_and_email_sorted(name, email, order_by)
-        by_name_and_email(name, email).order(order_by)
-      end
-
-      def all(*args)
-        if args.any?
-          restrict(*args)
-        else
-          self
-        end
-      end
-    end.new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def for_users(users)
-        names = users.map { |u| u[:name] }
-        restrict { |t| names.include?(t[:name]) }
-      end
-    end.new(tasks_dataset)
-  end
-
-  it_behaves_like 'a relation that returns one tuple' do
-    let(:relation) { users_relation }
-  end
-
-  describe '#map_with' do
-    it 'raises error when unknown mapper was selected' do
-      expect {
-        users_relation.as(:not_here)
-      }.to raise_error(ROM::MapperMissingError, /not_here/)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'forwards to relation and auto-curries' do
-      relation = users_relation.by_name_and_email_sorted('Jane')
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name_and_email_sorted])
-      expect(relation.curry_args).to eql(['Jane'])
-
-      relation = relation['jane@doe.org']
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name_and_email_sorted])
-      expect(relation.curry_args).to eql(['Jane', 'jane@doe.org'])
-
-      expect(relation[:email]).to match_array(
-        users_relation.by_name_and_email_sorted('Jane', 'jane@doe.org', :email)
-      )
-    end
-
-    it 'forwards to relation and does not auto-curry when it is not needed' do
-      relation = users_relation.by_name('Jane')
-
-      expect(relation).to_not be_curried
-      expect(relation).to match_array(users_relation.by_name('Jane'))
-    end
-
-    it 'forwards to relation and return lazy when arity is unknown' do
-      relation = users_relation.all(name: 'Jane')
-      expect(relation).to_not be_curried
-      expect(relation).to match_array(users_relation.by_name('Jane').to_a)
-    end
-
-    it 'returns original response if it is not a relation' do
-      expect(users_relation.gateway).to be(:default)
-    end
-
-    it 'raises NoMethodError when relation does not respond to a method' do
-      expect { users_relation.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe '#call' do
-    it 'auto-curries' do
-      relation = users_relation.by_name
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name])
-      expect(relation['Jane'].to_a).to eql(users_relation.by_name('Jane').to_a)
-    end
-
-    it 'returns relation' do
-      expect(users_relation.call.to_a).to eql(users_relation.to_a)
-    end
-
-    describe 'using mappers' do
-      subject(:users) { users_relation.with(mappers: mappers) }
-
-      let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
-      let(:upcaser) { proc { |r| r.map(&:upcase) } }
-      let(:mappers) { { name_list: name_list, upcaser: upcaser } }
-
-      it 'sends relation through mappers' do
-        relation = users.map_with(:name_list, :upcaser).by_name('Jane')
-
-        expect(relation.call.to_a).to eql(['JANE'])
-      end
-    end
-  end
-
-  describe '#first' do
-    it 'return first tuple' do
-      expect(users_relation.first).to eql(name: 'Joe', email: 'joe@doe.org')
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.first }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Joe').first }.to_not raise_error
-    end
-  end
-
-  describe '#each' do
-    it 'yields relation tuples' do
-      result = []
-      users_relation.each do |tuple|
-        result << tuple
-      end
-      expect(result).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'returns an enumerator if block is not provided' do
-      expect(users_relation.each.to_a).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.each {} }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
-    end
-  end
-
-  describe '#to_ary' do
-    it 'returns an array with relation tuples' do
-      expect(users_relation.to_ary).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.to_ary }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
-    end
-  end
-
-  describe '#>>' do
-    it 'composes two relations' do
-      other = users_relation.by_name('Jane') >> tasks_relation.for_users
-
-      expect(other).to match_array([
-        { name: 'Jane', title: 'be cool', priority: 2 }
-      ])
-    end
-
-    it_behaves_like 'a relation that returns one tuple' do
-      let(:relation) { users_relation >> proc { |r| r } }
-
-      describe 'using a mapper' do
-        it 'returns one mapped tuple' do
-          mapper = proc { |r| r.map { |t| t[:name].upcase } }
-          relation = users_relation.by_name('Jane') >> mapper
-
-          expect(relation.one).to eql('JANE')
-          expect(relation.one!).to eql('JANE')
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation::Loaded do
-  include_context 'no container'
-  include_context 'users and tasks'
-
-  subject(:users) { ROM::Relation::Loaded.new(users_relation) }
-
-  describe '#each' do
-    it 'yields tuples from relation' do
-      result = []
-
-      users.each do |tuple|
-        result << tuple
-      end
-
-      expect(result).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'returns enumerator when block is not provided' do
-      expect(users.each.to_a).to eql(users.collection.to_a)
-    end
-  end
-
-  describe '#to_ary' do
-    it 'coerces to an array' do
-      expect(users.to_ary).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-  end
-
-  describe '#pluck' do
-    it 'returns a list of values under provided key' do
-      expect(users.pluck(:email)).to eql(%w(joe@doe.org jane@doe.org))
-    end
-  end
-
-  describe '#primary_keys' do
-    it 'returns a list of primary key values' do
-      expect(users.source).to receive(:primary_key).and_return(:name)
-      expect(users.primary_keys).to eql(%w(Joe Jane))
-    end
-  end
-
-  it_behaves_like 'a relation that returns one tuple' do
-    let(:relation) { users }
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'rom/relation/name'
-
-RSpec.describe ROM::Relation::Name do
-  describe '.[]' do
-    it 'returns a new name from args' do
-      expect(ROM::Relation::Name[:users]).to eql(
-        ROM::Relation::Name.new(:users)
-      )
-
-      expect(ROM::Relation::Name[:authors, :users]).to eql(
-        ROM::Relation::Name.new(:authors, :users)
-      )
-    end
-
-    it 'returns name object when it was passed in as arg' do
-      name = ROM::Relation::Name[:users]
-      expect(ROM::Relation::Name[name]).to be(name)
-    end
-
-    it 'caches name instances' do
-      name = ROM::Relation::Name[:users]
-      expect(ROM::Relation::Name[:users]).to be(name)
-    end
-  end
-
-  describe '#inspect' do
-    it 'provides relation name' do
-      name = ROM::Relation::Name.new(:users)
-      expect(name.inspect).to eql("ROM::Relation::Name(users)")
-    end
-
-    it 'provides dataset and relation names' do
-      name = ROM::Relation::Name.new(:authors, :users)
-      expect(name.inspect).to eql("ROM::Relation::Name(authors on users)")
-    end
-  end
-
-  describe '#with' do
-    it 'returns a new name with the same dataset but for a different relation name' do
-      name = ROM::Relation::Name[:users]
-      expect(name.with(:people)).to be(ROM::Relation::Name[:people, :users])
-    end
-  end
-
-  describe '#to_sym' do
-    it 'returns relation name' do
-      expect(ROM::Relation::Name.new(:users).to_sym).to be(:users)
-      expect(ROM::Relation::Name.new(:authors, :users).to_sym).to be(:authors)
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns stringified relation name' do
-      expect(ROM::Relation::Name.new(:users).to_s).to eql('users')
-      expect(ROM::Relation::Name.new(:authors, :users).to_s).to eql('authors on users')
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require  'rom/memory'
-
-RSpec.describe ROM::Relation, '#output_schema' do
-  subject(:relation) do
-    Class.new(ROM::Relation[:memory]) do
-      schema do
-        attribute :id, ROM::Types::String, read: ROM::Types::Int
-        attribute :name, ROM::Types::String
-      end
-    end.new(ROM::Memory::Dataset.new([]))
-  end
-
-  let(:schema) do
-    relation.schema
-  end
-
-  it 'returns output_schema based on canonical schema' do
-    expect(relation.output_schema).
-      to eql(ROM::Types::Coercible::Hash.schema(id: schema[:id].to_read_type, name: schema[:name].type))
-  end
-
-  it 'returns output_schema based on projected schema' do
-    projected = relation.project(schema[:id].aliased(:user_id))
-
-    expect(projected.output_schema).
-      to eql(ROM::Types::Coercible::Hash.schema(user_id: projected.schema[:id].to_read_type))
-  end
-end

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

@@ -1,259 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe ROM::Relation, '.schema' do
-  it 'defines a canonical schema for a relation' do
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :id, Types::Int.meta(primary_key: true)
-        attribute :name, Types::String
-        attribute :admin, Types::Bool
-      end
-    end
-
-    Test::Users.schema.finalize!
-
-    relation_name = ROM::Relation::Name[:test_users]
-
-    schema = ROM::Memory::Schema.define(
-      ROM::Relation::Name.new(:test_users),
-      attributes: [
-        ROM::Memory::Types::Int.meta(primary_key: true, name: :id, source: relation_name),
-        ROM::Memory::Types::String.meta(name: :name, source: relation_name),
-        ROM::Memory::Types::Bool.meta(name: :admin, source: relation_name)
-      ]
-    ).finalize!
-
-    expect(Test::Users.schema.primary_key).to eql([Test::Users.schema[:id]])
-
-    expect(Test::Users.schema).to eql(schema)
-
-    expect(Test::Users.schema.relations).to be_empty
-  end
-
-  it 'allows defining types for reading tuples' do
-    module Test
-      module Types
-        CoercibleDate = ROM::Types::Date.constructor(Date.method(:parse))
-      end
-    end
-
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :id, Types::Int
-        attribute :date, Types::Coercible::String, read: Test::Types::CoercibleDate
-      end
-    end
-
-    schema = Test::Users.schema
-
-    expect(schema.to_output_hash).
-      to eql(ROM::Types::Coercible::Hash.schema(id: schema[:id].type, date: schema[:date].meta[:read]))
-  end
-
-  it 'allows setting composite primary key' do
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :name, Types::String
-        attribute :email, Types::String
-
-        primary_key :name, :email
-      end
-    end
-
-    schema = Test::Users.schema.finalize!
-
-    expect(schema.primary_key).to eql([schema[:name], schema[:email]])
-  end
-
-  it 'allows setting foreign keys' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :author_id, Types::ForeignKey(:users)
-        attribute :title, Types::String
-      end
-    end
-
-    schema = Test::Posts.schema
-
-    expect(schema[:author_id].primitive).to be(Integer)
-
-    expect(schema.foreign_key(:users)).to be(schema[:author_id])
-  end
-
-  it 'allows JSON read/write coersion', aggregate_failures: true do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::JSON
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = '{"foo":"bar"}'
-    hash_payload = { "foo" => "bar" }
-
-    expect(schema[:payload][hash_payload]).to eq(json_payload)
-    expect(schema[:payload].meta[:read][json_payload]).to eq(hash_payload)
-  end
-
-  it 'allows JSON/Hash read/write coersion using symbols as keys', aggregate_failures: true do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::JSON(symbol_keys: true)
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = '{"foo":"bar"}'
-    hash_payload = { foo: "bar" }
-
-    expect(schema[:payload][hash_payload]).to eq(json_payload)
-    expect(schema[:payload].meta[:read][json_payload]).to eq(hash_payload)
-  end
-
-  it 'allows JSON to Hash coersion only' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::JSONHash
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = '{"foo":"bar"}'
-    hash_payload = { "foo" => "bar" }
-
-    expect(schema[:payload][json_payload]).to eq(hash_payload)
-  end
-
-  it 'returns original payload in JSON to Hash coersion when json is invalid' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::JSONHash
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = 'invalid: json'
-
-    expect(schema[:payload][json_payload]).to eq(json_payload)
-  end
-
-  it 'allows JSON to Hash coersion only using symbols as keys' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::JSONHash(symbol_keys: true)
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = '{"foo":"bar"}'
-    hash_payload = { foo: "bar" }
-
-    expect(schema[:payload][json_payload]).to eq(hash_payload)
-  end
-
-  it 'allows Hash to JSON coersion only' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :payload, Types::Coercible::HashJSON
-      end
-    end
-
-    schema = Test::Posts.schema
-    json_payload = '{"foo":"bar"}'
-    hash_payload = { "foo" => "bar" }
-
-    expect(schema[:payload][hash_payload]).to eq(json_payload)
-  end
-
-  it 'sets register_as and dataset' do
-    class Test::Users < ROM::Relation[:memory]
-      schema(:users) do
-        attribute :id, Types::Int
-        attribute :name, Types::String
-      end
-    end
-
-    expect(Test::Users.dataset).to be(:users)
-    expect(Test::Users.register_as).to be(:users)
-  end
-
-  it 'sets dataset and respects custom register_as' do
-    class Test::Users < ROM::Relation[:memory]
-      register_as :test_users
-
-      schema(:users) do
-        attribute :id, Types::Int
-        attribute :name, Types::String
-      end
-    end
-
-    expect(Test::Users.dataset).to be(:users)
-    expect(Test::Users.register_as).to be(:test_users)
-  end
-
-  it 'allows setting both dataset and relation alias' do
-    class Test::Users < ROM::Relation[:memory]
-      schema(:test_users, as: :users) { }
-    end
-
-    expect(Test::Users.register_as).to be(:users)
-    expect(Test::Users.dataset).to be(:test_users)
-  end
-
-  it 'raises error when schema_class is missing' do
-    class Test::Users < ROM::Relation[:memory]
-      schema_class nil
-    end
-
-    expect { Test::Users.schema(:test) { } }.
-      to raise_error(ROM::MissingSchemaClassError, "Test::Users relation is missing schema_class")
-  end
-
-  describe '#schema' do
-    it 'returns defined schema' do
-      class Test::Users < ROM::Relation[:memory]
-        schema do
-          attribute :id, Types::Int.meta(primary_key: true)
-          attribute :name, Types::String
-          attribute :admin, Types::Bool
-        end
-      end
-
-      users = Test::Users.new([])
-
-      expect(users.schema).to be(Test::Users.schema)
-    end
-
-    it 'uses custom schema dsl' do
-      class Test::SchemaDSL < ROM::Schema::DSL
-        def bool(name)
-          attribute(name, ::ROM::Types::Bool)
-        end
-      end
-
-      class Test::Users < ROM::Relation[:memory]
-        schema_dsl Test::SchemaDSL
-
-        schema do
-          bool :admin
-        end
-      end
-
-      expect(Test::Users.schema[:admin]).to eql(ROM::Types::Bool.meta(name: :admin, source: ROM::Relation::Name[:test_users]))
-    end
-
-    it 'raises an error on double definition' do
-      expect {
-        class Test::Users < ROM::Relation[:memory]
-          schema do
-            attribute :id, Types::Int.meta(primary_key: true)
-            attribute :name, Types::String
-            attribute :id, Types::Int
-          end
-        end
-      }.to raise_error(ROM::Schema::AttributeAlreadyDefinedError,
-                       /:id already defined/)
-    end
-  end
-end