rom-repository 1.4.0 → 2.0.0.beta1

data/spec/unit/repository/changeset_spec.rb

@@ -1,197 +0,0 @@
-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 be commited' do
-        expect(changeset.commit).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 be commited' do
-        expect(changeset.commit).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
-      end
-    end
-  end
-
-  describe ROM::Changeset::Update do
-    let(:data) do
-      { name: 'Jane Doe' }
-    end
-
-    shared_context 'a valid update changeset' do
-      let!(:jane) do
-        repo.command(:create, repo.users).call(name: 'Jane')
-      end
-
-      let!(:joe) do
-        repo.command(:create, repo.users).call(name: 'Joe')
-      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.one).to eql(repo.users.by_pk(jane[:id]).one)
-      end
-
-      it 'can be commited' do
-        expect(changeset.commit).to eql(id: 1, name: 'Jane Doe')
-        expect(repo.users.by_pk(joe[:id]).one).to eql(joe)
-      end
-    end
-
-    context 'using PK to restrict a relation' do
-      let(:changeset) do
-        repo.changeset(:users, jane[:id], data)
-      end
-
-      include_context 'a valid update changeset'
-    end
-
-    context 'using custom relation' do
-      let(:changeset) do
-        repo.changeset(update: repo.users.by_pk(jane[:id])).data(data)
-      end
-
-      include_context 'a valid update changeset'
-    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 be commited' do
-      expect(changeset.commit.to_h).to eql(id: 1, name: 'Jane')
-      expect(relation.one).to be(nil)
-    end
-  end
-
-  describe 'custom changeset class' do
-    context 'with a Create' 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 be commited' do
-        expect(changeset.commit).to eql(id: 1, name: 'Jane')
-      end
-    end
-
-    context 'with an Update' do
-      let(:changeset) do
-        repo.changeset(changeset_class).by_pk(user.id, name: 'Jade')
-      end
-
-      let(:changeset_class) do
-        Class.new(ROM::Changeset::Update[:users]) do
-          map { |t| t.merge(name: "#{t[:name]} Doe") }
-        end
-      end
-
-      let(:user) do
-        repo.command(:create, repo.users).call(name: 'Jane')
-      end
-
-      it 'has data' do
-        expect(changeset.to_h).to eql(name: 'Jade Doe')
-      end
-
-      it 'has relation restricted by pk' do
-        expect(changeset.relation.dataset).to eql(repo.users.by_pk(user.id).dataset)
-      end
-
-      it 'can be commited' do
-        expect(changeset.commit).to eql(id: 1, name: 'Jade Doe')
-      end
-    end
-  end
-
-  it 'raises ArgumentError when unknown type was used' do
-    expect { repo.changeset(not_here: repo.users) }.
-      to raise_error(
-           ArgumentError,
-           '+:not_here+ is not a valid changeset type. Must be one of: [:create, :update, :delete]'
-         )
-  end
-
-  it 'raises ArgumentError when unknown class was used' do
-    klass = Class.new {
-      def self.name
-        'SomeClass'
-      end
-    }
-
-    expect { repo.changeset(klass) }.
-      to raise_error(ArgumentError, /SomeClass/)
-  end
-end

data/spec/unit/repository/inspect_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe ROM::Repository, '#inspect' do
-  subject(:repo) do
-    Class.new(ROM::Repository) do
-      relations :users
-
-      def self.to_s
-        'UserRepo'
-      end
-    end.new(rom)
-  end
-
-  include_context 'database'
-  include_context 'relations'
-
-  specify do
-    expect(repo.inspect).to eql('#<UserRepo relations=[:users]>')
-  end
-end

data/spec/unit/repository/session_spec.rb

@@ -1,251 +0,0 @@
-RSpec.describe ROM::Repository, '#session' do
-  subject(:repo) do
-    Class.new(ROM::Repository) { relations :users, :posts, :labels }.new(rom)
-  end
-
-  include_context 'database'
-  include_context 'relations'
-
-  describe 'with :create command' do
-    let(:user_changeset) do
-      repo.changeset(:users, name: 'Jane')
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |s|
-        s.add(user_changeset)
-      end
-
-      user = repo.users.where(name: 'Jane').one
-      expect(user.to_h).to eql(id: 1, name: 'Jane')
-    end
-  end
-
-  describe 'with :update command' do
-    let(:user_changeset) do
-      repo.changeset(:users, user.id, user.to_h.merge(name: 'Jane Doe'))
-    end
-
-    let(:user) do
-      repo.users.where(name: 'Jane').one
-    end
-
-    before do
-      repo.command(:create, repo.users).call(name: 'John')
-      repo.command(:create, repo.users).call(name: 'Jane')
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |s|
-        s.add(user_changeset)
-      end
-
-      updated_user = repo.users.fetch(user.id)
-
-      expect(updated_user).to eql(id: 2, name: 'Jane Doe')
-    end
-  end
-
-  describe 'with :delete command' do
-    let(:user) do
-      repo.users.where(name: 'Jane').one
-    end
-
-    before do
-      repo.command(:create, repo.users).call(name: 'John')
-      repo.command(:create, repo.users).call(name: 'Jane')
-    end
-
-    let(:user_changeset) do
-      repo.changeset(delete: repo.users.by_pk(user.id))
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |t|
-        t.add(user_changeset)
-      end
-
-      expect(repo.users.by_pk(user.id).one).to be(nil)
-      expect(repo.users.count).to be(1)
-    end
-  end
-
-  describe 'with :custom command', :postgres do
-    before do
-      configuration.commands(:users) do
-        define(:create) do
-          register_as :custom
-        end
-      end
-    end
-
-    let(:user_changeset) do
-      repo.changeset(:users, name: 'John').with(command_type: :custom)
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |t|
-        t.add(user_changeset)
-      end
-
-      user = repo.users.first
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('John')
-      expect(repo.users.count).to be(1)
-    end
-  end
-
-  describe 'creating a user with its posts' do
-    let(:posts_changeset) do
-      repo.changeset(:posts, [{ title: 'Post 1' }, { title: 'Post 2' }])
-    end
-
-    let(:user_changeset) do
-      repo.changeset(:users, name: 'Jane')
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |s|
-        s.add(user_changeset.associate(posts_changeset, :author))
-      end
-
-      user = repo.users.combine(:posts).one
-
-      expect(user.name).to eql('Jane')
-      expect(user.posts.size).to be(2)
-      expect(user.posts[0].title).to eql('Post 1')
-      expect(user.posts[1].title).to eql('Post 2')
-    end
-  end
-
-  describe 'creating a user with its posts and their labels' do
-    let(:posts_data) do
-      { title: 'Post 1' }
-    end
-
-    let(:posts_changeset) do
-      repo.
-        changeset(:posts, posts_data).
-        associate(labels_changeset, :posts)
-    end
-
-    let(:labels_changeset) do
-      repo.changeset(:labels, [{ name: 'red' }, { name: 'green' }])
-    end
-
-    let(:user_changeset) do
-      repo.
-        changeset(:users, name: 'Jane').
-        associate(posts_changeset, :author)
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |t|
-        t.add(user_changeset)
-      end
-
-      user = repo.users.combine(posts: [:labels]).one
-
-      expect(user.name).to eql('Jane')
-      expect(user.posts.size).to be(1)
-      expect(user.posts[0].title).to eql('Post 1')
-      expect(user.posts[0].labels.size).to be(2)
-      expect(user.posts[0].labels[0].name).to eql('red')
-      expect(user.posts[0].labels[1].name).to eql('green')
-    end
-
-    context 'with invalid data' do
-      let(:posts_data) do
-        [{ title: nil }]
-      end
-
-      it 'rolls back the transaction' do
-        expect {
-          repo.session do |t|
-            t.add(user_changeset)
-          end
-        }.to raise_error(ROM::SQL::ConstraintError)
-
-        expect(repo.users.count).to be(0)
-        expect(repo.posts.count).to be(0)
-        expect(repo.labels.count).to be(0)
-      end
-    end
-  end
-
-  describe 'creating new posts for existing user' do
-    let(:posts_changeset) do
-      repo.
-        changeset(:posts, [{ title: 'Post 1' }, { title: 'Post 2' }]).
-        associate(user, :author)
-    end
-
-    let(:user) do
-      repo.command(:create, repo.users).call(name: 'Jane')
-    end
-
-    it 'saves data in a transaction' do
-      repo.session do |s|
-        s.add(posts_changeset)
-      end
-
-      user = repo.users.combine(:posts).one
-
-      expect(user.posts.size).to be(2)
-      expect(user.posts[0].title).to eql('Post 1')
-      expect(user.posts[1].title).to eql('Post 2')
-    end
-  end
-
-  describe 'nesting sessions' do
-    let(:user_changeset) do
-      repo.changeset(:users, name: 'Jane')
-    end
-
-    let(:posts_changeset) do
-      repo.changeset(:posts, post_data)
-    end
-
-    let(:user) do
-      repo.users.where(name: 'Jane').one
-    end
-
-    context 'when data is valid' do
-      let(:post_data) do
-        [{ title: 'Post 1' }, { title: 'Post 2' }]
-      end
-
-      it 'saves data in transactions' do
-        repo.send(:transaction) do |t|
-          repo.session { |s| s.add(user_changeset) }
-          repo.session { |s| s.add(posts_changeset.associate(user, :author)) }
-        end
-
-        user = repo.users.combine(:posts).one
-
-        expect(user.posts.size).to be(2)
-        expect(user.posts[0].title).to eql('Post 1')
-        expect(user.posts[1].title).to eql('Post 2')
-      end
-    end
-
-    context 'when data is not valid' do
-      let(:post_data) do
-        [{ title: 'Post 1' }, { title: nil }]
-      end
-
-      it 'rolls back transaction' do
-        expect {
-          repo.send(:transaction) do |t|
-            repo.session { |s| s.add(user_changeset) }
-            repo.session { |s| s.add(posts_changeset.associate(user, :author)) }
-          end
-        }.to raise_error(ROM::SQL::ConstraintError, /title/)
-
-        expect(repo.users.count).to be(0)
-        expect(repo.posts.count).to be(0)
-      end
-    end
-  end
-end