rom-repository 0.3.1 → 1.0.0.beta1

data/spec/shared/relations.rb

@@ -52,7 +52,9 @@ RSpec.shared_context 'relations' do
       end
     end
 
-    configuration.relation(:tags)
+    configuration.relation(:tags) do
+      schema(infer: true)
+    end
 
     configuration.relation(:labels) do
       schema(infer: true) do

data/spec/shared/repo.rb

@@ -6,7 +6,7 @@ RSpec.shared_context('repo') do
 
   let(:repo_class) do
     Class.new(ROM::Repository[:users]) do
-      relations :tasks, :tags, :posts, :labels
+      relations :tasks, :tags, :posts, :labels, :posts_labels
 
       def find_users(criteria)
         users.find(criteria)
@@ -36,6 +36,18 @@ RSpec.shared_context('repo') do
         aggregate(one: tasks.find(title: title))
       end
 
+      def users_with_posts_and_their_labels
+        users.combine(posts: [:labels])
+      end
+
+      def posts_with_labels
+        posts.combine_children(many: labels)
+      end
+
+      def label_with_posts
+        labels.combine_children(one: posts)
+      end
+
       def tasks_for_users(users)
         tasks.for_users(users)
       end

data/spec/shared/structs.rb

@@ -13,6 +13,22 @@ RSpec.shared_context 'structs' do
     repo.tags.mapper.model
   end
 
+  let(:post_struct) do
+    repo.posts.mapper.model
+  end
+
+  let(:label_struct) do
+    repo.labels.mapper.model
+  end
+
+  let(:post_with_labels_struct) do
+    mapper_for(repo.posts_with_labels).model
+  end
+
+  let(:label_with_posts_struct) do
+    mapper_for(repo.label_with_posts).model
+  end
+
   let(:tag_with_task_struct) do
     mapper_for(repo.tag_with_wrapped_task).model
   end
@@ -25,6 +41,10 @@ RSpec.shared_context 'structs' do
     mapper_for(repo.users_with_task).model
   end
 
+  let(:user_with_posts_struct) do
+    mapper_for(repo.users_with_posts_and_their_labels).model
+  end
+
   let(:task_with_tags_struct) do
     mapper_for(repo.tasks_with_tags).model
   end
@@ -100,4 +120,23 @@ RSpec.shared_context 'structs' do
   let(:joe_task) do
     task_struct.new(id: 1, user_id: 2, title: 'Joe Task')
   end
+
+  let(:jane_with_posts) do
+    user_with_posts_struct.new(id: 1, name: 'Jane', posts: [post_with_label])
+  end
+
+  let(:label_red) do
+    label_with_posts_struct.new(id: 1, name: 'red', post: 1)
+  end
+
+  let(:label_blue) do
+    label_with_posts_struct.new(id: 3, name: 'blue', post: 1)
+  end
+
+  let(:post_with_label) do
+    post_with_labels_struct.new(id: 2, title: 'Hello From Jane',
+                                body: 'Jane Post',
+                                author_id: 1,
+                                labels: [label_red, label_blue])
+  end
 end

data/spec/spec_helper.rb

@@ -4,9 +4,11 @@
 require "bundler"
 Bundler.setup
 
-if RUBY_ENGINE == "ruby" && RUBY_VERSION == '2.3.1'
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
+if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.4.0' && ENV['CI'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
 end
 
 require 'rom-sql'
@@ -28,8 +30,8 @@ Dir[root.join('shared/*.rb').to_s].each do |f|
   require f
 end
 
-require 'rom/support/deprecations'
-ROM::Deprecations.set_logger!(root.join('../log/deprecations.log'))
+require 'dry/core/deprecations'
+Dry::Core::Deprecations.set_logger!(root.join('../log/deprecations.log'))
 
 # Namespace holding all objects created during specs
 module Test

data/spec/support/mutant.rb

@@ -0,0 +1,10 @@
+module Mutant
+  class Selector
+    # Expression based test selector
+    class Expression < self
+      def call(_subject)
+        integration.all_tests
+      end
+    end # Expression
+  end # Selector
+end # Mutant

data/spec/unit/changeset/map_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe ROM::Changeset, '.map' do
+  subject(:changeset) do
+    Class.new(ROM::Changeset) 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

data/spec/unit/changeset_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe ROM::Changeset do
     it 'returns a hash with changes' do
       expect(relation).to receive(:fetch).with(2).and_return(jane)
 
-      changeset = ROM::Changeset::Update.new(relation, { name: "Jane Doe" }, primary_key: 2)
+      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane Doe" }, primary_key: 2)
 
       expect(changeset.diff).to eql(name: "Jane Doe")
     end
@@ -16,7 +16,7 @@ RSpec.describe ROM::Changeset do
     it 'returns true when data differs from the original tuple' do
       expect(relation).to receive(:fetch).with(2).and_return(jane)
 
-      changeset = ROM::Changeset::Update.new(relation, { name: "Jane Doe" }, primary_key: 2)
+      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane Doe" }, primary_key: 2)
 
       expect(changeset).to be_diff
     end
@@ -24,16 +24,16 @@ RSpec.describe ROM::Changeset do
     it 'returns false when data are equal to the original tuple' do
       expect(relation).to receive(:fetch).with(2).and_return(jane)
 
-      changeset = ROM::Changeset::Update.new(relation, { name: "Jane" }, primary_key: 2)
+      changeset = ROM::Changeset::Update.new(relation, __data__: { name: "Jane" }, primary_key: 2)
 
       expect(changeset).to_not be_diff
     end
   end
 
   describe 'quacks like a hash' do
-    subject(:changeset) { ROM::Changeset::Create.new(relation, data) }
+    subject(:changeset) { ROM::Changeset::Create.new(relation, __data__: data) }
 
-    let(:data) { instance_double(Hash) }
+    let(:data) { instance_double(Hash, class: Hash) }
 
     it 'delegates to its data hash' do
       expect(data).to receive(:[]).with(:name).and_return('Jane')
@@ -47,7 +47,7 @@ RSpec.describe ROM::Changeset do
       new_changeset = changeset.merge(foo: 'bar')
 
       expect(new_changeset).to be_instance_of(ROM::Changeset::Create)
-      expect(new_changeset.options).to eql(changeset.options)
+      expect(new_changeset.options).to eql(changeset.options.merge(__data__: { foo: 'bar' }))
       expect(new_changeset.to_h).to eql(foo: 'bar')
     end
 
@@ -55,4 +55,30 @@ RSpec.describe ROM::Changeset 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
 end

data/spec/unit/relation_proxy_spec.rb

@@ -1,3 +1,5 @@
+require 'dry-struct'
+
 RSpec.describe 'loading proxy' do
   include_context 'database'
   include_context 'relations'
@@ -17,6 +19,13 @@ RSpec.describe 'loading proxy' do
     ROM::Repository::RelationProxy.new(rom.relation(:tags), name: :tags)
   end
 
+  describe '#inspect' do
+    specify do
+      expect(users.inspect).
+        to eql("#<ROM::Relation[Users] name=users dataset=#{users.dataset.inspect}>")
+    end
+  end
+
   describe '#each' do
     it 'yields loaded structs' do
       result = []
@@ -56,7 +65,7 @@ RSpec.describe 'loading proxy' do
 
     context 'setting custom model type' do
       let(:user_type) do
-        Class.new(Dry::Types::Struct) do
+        Class.new(Dry::Struct) do
           attribute :id, Dry::Types['strict.int']
           attribute :name, Dry::Types['strict.string']
         end
@@ -103,7 +112,7 @@ RSpec.describe 'loading proxy' do
         [:relation, [
           :users,
           { dataset: :users },
-          [:header, [[:attribute, :id], [:attribute, :name]]]]
+          [:header, [[:attribute, users.schema[:id]], [:attribute, users.schema[:name]]]]]
         ]
       )
     end
@@ -116,12 +125,15 @@ RSpec.describe 'loading proxy' do
           :users,
           { dataset: :users },
           [:header, [
-            [:attribute, :id],
-            [:attribute, :name],
+            [:attribute, users.schema[:id]],
+            [:attribute, users.schema[:name]],
             [:relation, [
               :tasks,
               { dataset: :tasks, keys: { id: :user_id }, combine_type: :many, combine_name: :user_tasks },
-              [:header, [[:attribute, :id], [:attribute, :user_id], [:attribute, :title]]]
+              [:header, [
+                 [:attribute, tasks.schema[:id]],
+                 [:attribute, tasks.schema[:user_id]],
+                 [:attribute, tasks.schema[:title]]]]
             ]]
           ]
         ]]]
@@ -131,18 +143,24 @@ RSpec.describe 'loading proxy' do
     it 'returns valid ast for a wrapped relation' do
       relation = tags.wrap_parent(task: tasks)
 
+      tags_schema = tags.schema.qualified
+      tasks_schema = tasks.schema.wrap.qualified
+
       expect(relation.to_ast).to eql(
         [:relation, [
           :tags,
           { dataset: :tags },
           [:header, [
-            [:attribute, :id],
-            [:attribute, :task_id],
-            [:attribute, :name],
+            [:attribute, tags_schema[:id]],
+            [:attribute, tags_schema[:task_id]],
+            [:attribute, tags_schema[:name]],
             [:relation, [
               :tasks,
               { dataset: :tasks, keys: { id: :task_id }, wrap: true, combine_name: :task },
-              [:header, [ [:attribute, :id], [:attribute, :user_id], [:attribute, :title]]]
+              [:header, [
+                 [:attribute, tasks_schema[:id]],
+                 [:attribute, tasks_schema[:user_id]],
+                 [:attribute, tasks_schema[:title]]]]
             ]]
           ]]
         ]]

data/spec/unit/repository/changeset_spec.rb

@@ -0,0 +1,125 @@
+RSpec.describe ROM::Repository, '#changeset' do
+  subject(:repo) do
+    Class.new(ROM::Repository) { relations :users }.new(rom)
+  end
+
+  include_context 'database'
+  include_context 'relations'
+
+  describe ROM::Changeset::Create do
+    context 'with a hash' do
+      let(:changeset) do
+        repo.changeset(:users, name: 'Jane')
+      end
+
+      it 'has data' do
+        expect(changeset.to_h).to eql(name: 'Jane')
+      end
+
+      it 'has relation' do
+        expect(changeset.relation).to be(repo.users)
+      end
+
+      it 'can return a dedicated command' do
+        expect(changeset.command.call).to eql(id: 1, name: 'Jane')
+      end
+    end
+
+    context 'with an array' do
+      let(:changeset) do
+        repo.changeset(:users, data)
+      end
+
+      let(:data) do
+        [{ name: 'Jane' }, { name: 'Joe' }]
+      end
+
+      it 'has data' do
+        expect(changeset.to_a).to eql(data)
+      end
+
+      it 'has relation' do
+        expect(changeset.relation).to be(repo.users)
+      end
+
+      it 'can return a dedicated command' do
+        expect(changeset.command.call).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
+      end
+    end
+  end
+
+  describe ROM::Changeset::Update do
+    let(:changeset) do
+      repo.changeset(:users, user[:id], name: 'Jane Doe')
+    end
+
+    let(:user) do
+      repo.command(:create, repo.users).call(name: 'Jane')
+    end
+
+    it 'has data' do
+      expect(changeset.to_h).to eql(name: 'Jane Doe')
+    end
+
+    it 'has diff' do
+      expect(changeset.diff).to eql(name: 'Jane Doe')
+    end
+
+    it 'has relation' do
+      expect(changeset.relation).to be(repo.users)
+    end
+
+    it 'can return a dedicated command' do
+      expect(changeset.command.call).to eql(id: 1, name: 'Jane Doe')
+    end
+  end
+
+  describe ROM::Changeset::Delete do
+    let(:changeset) do
+      repo.changeset(delete: relation)
+    end
+
+    let(:relation) do
+      repo.users.by_pk(user[:id])
+    end
+
+    let(:user) do
+      repo.command(:create, repo.users).call(name: 'Jane')
+    end
+
+    it 'has relation' do
+      expect(changeset.relation).to eql(relation)
+    end
+
+    it 'can return a dedicated command' do
+      expect(changeset.command.call.to_h).to eql(id: 1, name: 'Jane')
+      expect(relation.one).to be(nil)
+    end
+  end
+
+  describe 'custom changeset class' do
+    let(:changeset) do
+      repo.changeset(changeset_class[:users]).data({})
+    end
+
+    let(:changeset_class) do
+      Class.new(ROM::Changeset::Create) do
+        def to_h
+          __data__.merge(name: 'Jane')
+        end
+      end
+    end
+
+    it 'has data' do
+      expect(changeset.to_h).to eql(name: 'Jane')
+    end
+
+    it 'has relation' do
+      expect(changeset.relation).to be(repo.users)
+    end
+
+    it 'can return a dedicated command' do
+      expect(changeset.command.call).to eql(id: 1, name: 'Jane')
+    end
+  end
+end