rom-repository 1.4.0 → 2.0.0.beta1

data/spec/unit/changeset/map_spec.rb

@@ -1,111 +0,0 @@
-RSpec.describe ROM::Changeset, '.map' do
-  context 'single mapping with transaction DSL' do
-    subject(:changeset) do
-      Class.new(ROM::Changeset::Create[:users]) do
-        map do
-          unwrap :address
-          rename_keys street: :address_street, city: :address_city, country: :address_country
-        end
-
-        def default_command_type
-          :test
-        end
-      end.new(relation, __data__: user_data)
-    end
-
-    let(:relation) { double(:relation) }
-
-    context 'with a hash' do
-      let(:user_data) do
-        { name: 'Jane', address: { street: 'Street 1', city: 'NYC', country: 'US' } }
-      end
-
-      it 'sets up custom data pipe' do
-        expect(changeset.to_h)
-          .to eql(name: 'Jane', address_street: 'Street 1', address_city: 'NYC', address_country: 'US' )
-      end
-    end
-
-    context 'with an array' do
-      let(:user_data) do
-        [{ name: 'Jane', address: { street: 'Street 1', city: 'NYC', country: 'US' } },
-         { name: 'Joe', address: { street: 'Street 2', city: 'KRK', country: 'PL' } }]
-      end
-
-      it 'sets up custom data pipe' do
-        expect(changeset.to_a)
-          .to eql([
-                    { name: 'Jane', address_street: 'Street 1', address_city: 'NYC', address_country: 'US' },
-                    { name: 'Joe', address_street: 'Street 2', address_city: 'KRK', address_country: 'PL' }
-                  ])
-      end
-    end
-  end
-
-  context 'accessing data in a map block' do
-    subject(:changeset) do
-      Class.new(ROM::Changeset::Create[:users]) do
-        map do |tuple|
-          extend_data(tuple)
-        end
-
-        private
-
-        def extend_data(tuple)
-          tuple.merge(email: "#{self[:name].downcase}@test.com")
-        end
-      end.new(relation).data(user_data)
-    end
-
-    let(:relation) { double(:relation) }
-    let(:user_data) { { name: 'Jane' } }
-
-    it 'extends data in a map block' do
-      expect(changeset.to_h).to eql(name: 'Jane', email: 'jane@test.com')
-    end
-  end
-
-  context 'multi mapping with custom blocks' do
-    subject(:changeset) do
-      Class.new(ROM::Changeset::Create[:users]) do
-        map do |tuple|
-          tuple.merge(one: next_value)
-        end
-
-        map do |tuple|
-          tuple.merge(two: next_value)
-        end
-
-        map do |three: next_value, **other|
-          { three: three, **other }
-        end
-
-        def initialize(*args)
-          super
-          @counter = 0
-        end
-
-        def default_command_type
-          :test
-        end
-
-        def next_value
-          @counter += 1
-        end
-      end.new(relation).data(user_data)
-    end
-
-    let(:relation) { double(:relation) }
-    let(:user_data) { { name: 'Jane' } }
-
-    it 'applies mappings in order of definition' do
-      expect(changeset.to_h).to eql(name: 'Jane', one: 1, two: 2, three: 3)
-    end
-
-    it 'inherits pipes' do
-      klass = Class.new(changeset.class)
-
-      expect(klass.pipes).to eql(changeset.class.pipes)
-    end
-  end
-end

data/spec/unit/changeset_spec.rb

@@ -1,186 +0,0 @@
-require 'ostruct'
-
-RSpec.describe ROM::Changeset do
-  let(:jane) { { id: 2, name: "Jane" } }
-  let(:relation) { double(ROM::Relation, name: :users) }
-
-  describe '.[]' do
-    it 'returns a changeset preconfigured for a specific relation' do
-      klass = ROM::Changeset::Create[:users]
-
-      expect(klass.relation).to be(:users)
-      expect(klass < ROM::Changeset::Create).to be(true)
-    end
-
-    it 'caches results' do
-      create = ROM::Changeset::Create[:users]
-      update = ROM::Changeset::Update[:users]
-
-      expect(create).to be(ROM::Changeset::Create[:users])
-      expect(create < ROM::Changeset::Create).to be(true)
-
-      expect(update).to be(ROM::Changeset::Update[:users])
-      expect(update < ROM::Changeset::Update).to be(true)
-    end
-  end
-
-  describe '#diff' do
-    it 'returns a hash with changes' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane Doe" })
-
-      expect(changeset.diff).to eql(name: "Jane Doe")
-    end
-
-    it 'does not consider keys that are not present on the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation).data(foo: 'bar')
-
-      expect(changeset.diff).to eql({})
-    end
-  end
-
-  describe '#diff?' do
-    it 'returns true when data differs from the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation).data(name: "Jane Doe")
-
-      expect(changeset).to be_diff
-    end
-
-    it 'returns false when data are equal to the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation).data(name: 'Jane')
-
-      expect(changeset).to_not be_diff
-    end
-
-    it 'returns false when data contains keys that are not available on the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation).data(foo: 'bar')
-
-      expect(changeset).to_not be_diff
-    end
-
-    it 'uses piped data for diff' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation).data(name: "Jane").map { |name: | { name: name.upcase } }
-
-      expect(changeset).to be_diff
-    end
-  end
-
-  describe '#clean?' do
-    it 'returns true when data are equal to the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane" })
-
-      expect(changeset).to be_clean
-    end
-
-    it 'returns false when data differs from the original tuple' do
-      expect(relation).to receive(:one).and_return(jane)
-
-      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane Doe" })
-
-      expect(changeset).to_not be_clean
-    end
-  end
-
-  describe 'quacks like a hash' do
-    subject(:changeset) { ROM::Changeset::Create.new(relation, __data__: data) }
-
-    let(:data) { instance_double(Hash, class: Hash) }
-
-    it 'delegates to its data hash' do
-      expect(data).to receive(:[]).with(:name).and_return('Jane')
-
-      expect(changeset[:name]).to eql('Jane')
-    end
-
-    it 'maintains its own type' do
-      expect(data).to receive(:merge).with(foo: 'bar').and_return(foo: 'bar')
-
-      new_changeset = changeset.merge(foo: 'bar')
-
-      expect(new_changeset).to be_instance_of(ROM::Changeset::Create)
-      expect(new_changeset.options).to eql(changeset.options.merge(__data__: { foo: 'bar' }))
-      expect(new_changeset.to_h).to eql(foo: 'bar')
-    end
-
-    it 'raises NoMethodError when an unknown message was sent' do
-      expect { changeset.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe 'quacks like an array' do
-    subject(:changeset) { ROM::Changeset::Create.new(relation, __data__: data) }
-
-    let(:data) { instance_double(Array, class: Array) }
-
-    it 'delegates to its data hash' do
-      expect(data).to receive(:[]).with(1).and_return('Jane')
-
-      expect(changeset[1]).to eql('Jane')
-    end
-
-    it 'maintains its own type' do
-      expect(data).to receive(:+).with([1, 2]).and_return([1, 2])
-
-      new_changeset = changeset + [1, 2]
-
-      expect(new_changeset).to be_instance_of(ROM::Changeset::Create)
-      expect(new_changeset.options).to eql(changeset.options.merge(__data__: [1, 2]))
-      expect(new_changeset.to_a).to eql([1, 2])
-    end
-
-    it 'raises NoMethodError when an unknown message was sent' do
-      expect { changeset.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe 'quacks like a custom object' do
-    subject(:changeset) { ROM::Changeset::Create.new(relation, __data__: data) }
-
-    let(:data) { OpenStruct.new(name: 'Jane') }
-
-    it 'delegates to its data hash' do
-      expect(changeset[:name]).to eql('Jane')
-    end
-
-    it 'raises NoMethodError when an unknown message was sent' do
-      expect { changeset.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-
-    it 'has correct result type' do
-      expect(changeset.result).to be(:one)
-    end
-  end
-
-  describe '#inspect' do
-    context 'with a stateful changeset' do
-      subject(:changeset) { ROM::Changeset::Create.new(relation).data(name: 'Jane') }
-
-      specify do
-        expect(changeset.inspect).
-          to eql('#<ROM::Changeset::Create relation=:users data={:name=>"Jane"}>')
-      end
-    end
-
-    context 'with a data-less changeset' do
-      subject(:changeset) { ROM::Changeset::Delete.new(relation) }
-
-      specify do
-        expect(changeset.inspect).
-          to eql('#<ROM::Changeset::Delete relation=:users>')
-      end
-    end
-  end
-end

data/spec/unit/relation_proxy_spec.rb

@@ -1,202 +0,0 @@
-require 'dry-struct'
-
-RSpec.describe 'loading proxy' do
-  include_context 'database'
-  include_context 'relations'
-  include_context 'repo'
-  include_context 'structs'
-  include_context 'seeds'
-
-  let(:users_proxy) do
-    repo.users
-  end
-
-  let(:tasks_proxy) do
-    repo.tasks
-  end
-
-  let(:tags_proxy) do
-    repo.tags
-  end
-
-  describe '#inspect' do
-    specify do
-      expect(users_proxy.inspect).
-        to eql("#<ROM::Relation[Users] name=users dataset=#{users.dataset.inspect}>")
-    end
-  end
-
-  describe '#each' do
-    it 'yields loaded structs' do
-      result = []
-
-      users_proxy.each { |user| result << user }
-
-      expect(result).to eql([jane, joe])
-    end
-
-    it 'returns an enumerator when block is not given' do
-      expect(users_proxy.each.to_a).to eql([jane, joe])
-    end
-  end
-
-  describe '#map_with/#as' do
-    context 'with custom mappers' do
-      before do
-        configuration.mappers do
-          register :users, {
-            name_list: -> users { users.map { |u| u[:name] } },
-            upcase_names: -> names { names.map(&:upcase) },
-            identity: -> users { users }
-          }
-        end
-      end
-
-      it 'sends the relation through custom mappers' do
-        expect(users_proxy.map_with(:name_list, :upcase_names).to_a).to match_array(%w(JANE JOE))
-      end
-
-      it 'does not use the default(ROM::Struct) mapper' do
-        expect(users_proxy.map_with(:identity).to_a).to match_array(
-          [{ id: 1, name: 'Jane' }, {id: 2, name: 'Joe' }]
-        )
-      end
-
-      it 'raises error when custom mapper is used with a model class' do
-        expect { users_proxy.map_with(:name_list, Class.new) }.
-          to raise_error(ArgumentError, 'using custom mappers and a model is not supported')
-      end
-    end
-
-    context 'setting custom model type' do
-      let(:user_type) do
-        Class.new(Dry::Struct) do
-          attribute :id, Dry::Types['strict.int']
-          attribute :name, Dry::Types['strict.string']
-        end
-      end
-
-      let(:custom_users) { users_proxy.as(user_type) }
-
-      it 'instantiates custom model' do
-        expect(custom_users.where(name: 'Jane').one).to be_instance_of(user_type)
-      end
-    end
-  end
-
-  describe 'retrieving a single struct' do
-    describe '#first' do
-      it 'returns exactly one struct' do
-        expect(users_proxy.first).to eql(jane)
-      end
-    end
-
-    describe '#one' do
-      it 'returns exactly one struct' do
-        expect(users_proxy.find(id: 1).one).to eql(jane)
-
-        expect(users_proxy.find(id: 3).one).to be(nil)
-
-        expect { users_proxy.find(id: [1,2]).one }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-
-    describe '#one!' do
-      it 'returns exactly one struct' do
-        expect(users_proxy.find(id: 1).one!).to eql(jane)
-
-        expect { users_proxy.find(id: [1, 2]).one! }.to raise_error(ROM::TupleCountMismatchError)
-        expect { users_proxy.find(id: [3]).one! }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns valid ast for a single relation' do
-      expect(users_proxy.to_ast).to eql(
-        [:relation, [
-          :users,
-          { dataset: :users },
-          [:header, [[:attribute, users_proxy.schema[:id]], [:attribute, users_proxy.schema[:name]]]]]
-        ]
-      )
-    end
-
-    it 'returns valid ast for a combined relation' do
-      relation = users_proxy.combine(many: { user_tasks: [tasks_proxy, id: :user_id] })
-
-      expect(relation.to_ast).to eql(
-        [:relation, [
-          :users,
-          { dataset: :users },
-          [:header, [
-            [:attribute, users_proxy.schema[:id]],
-            [:attribute, users_proxy.schema[:name]],
-            [:relation, [
-              :tasks,
-              { dataset: :tasks, keys: { id: :user_id },
-                combine_type: :many, combine_name: :user_tasks },
-              [:header, [
-                 [:attribute, tasks_proxy.schema[:id]],
-                 [:attribute, tasks_proxy.schema[:user_id]],
-                 [:attribute, tasks_proxy.schema[:title]]]]
-            ]]
-          ]
-        ]]]
-      )
-    end
-
-    it 'returns valid ast for a wrapped relation' do
-      relation = tags_proxy.wrap_parent(task: tasks_proxy)
-
-      tags_schema = tags_proxy.schema.qualified
-      tasks_schema = tasks_proxy.schema.wrap
-
-      expect(relation.to_ast).to eql(
-        [:relation, [
-          :tags,
-          { dataset: :tags },
-          [:header, [
-            [:attribute, tags_schema[:id]],
-            [:attribute, tags_schema[:task_id]],
-            [:attribute, tags_schema[:name]],
-            [:relation, [
-              :tasks,
-              { dataset: :tasks, keys: { id: :task_id },
-                wrap_from_assoc: false, wrap: true, combine_name: :task },
-              [:header, [
-                 [:attribute, tasks_schema[:id]],
-                 [:attribute, tasks_schema[:user_id]],
-                 [:attribute, tasks_schema[:title]]]]
-            ]]
-          ]]
-        ]]
-      )
-    end
-  end
-
-  describe '#method_missing' do
-    it 'proxies to the underlying relation' do
-      expect(users_proxy.gateway).to be(:default)
-    end
-
-    it 'returns proxy when response was not materialized' do
-      expect(users_proxy.by_pk(1)).to be_instance_of(ROM::Repository::RelationProxy)
-    end
-
-    it 'returns curried proxy when response was curried' do
-      expect(users_proxy.by_pk).to be_instance_of(ROM::Repository::RelationProxy)
-    end
-
-    it 'raises when method is missing' do
-      expect { users_proxy.not_here }.to raise_error(NoMethodError, "undefined method `not_here' for ROM::Relation[Users]")
-    end
-
-    it 'proxies Kernel methods when using with SimpleDelegator' do
-      proxy = Class.new(SimpleDelegator).new(users_proxy)
-
-      expect(users_proxy.select(:name)).to be_instance_of(ROM::Repository::RelationProxy)
-      expect(proxy.select(:name)).to be_instance_of(ROM::Repository::RelationProxy)
-    end
-  end
-end