rom-sql 0.7.0 → 0.8.0

data/spec/support/helpers.rb

@@ -0,0 +1,9 @@
+module Helpers
+  def qualified_attribute(*args)
+    ROM::SQL::QualifiedAttribute[*args]
+  end
+
+  def assoc_name(*args)
+    ROM::SQL::Association::Name[*args]
+  end
+end

data/spec/unit/association/many_to_many_spec.rb

@@ -0,0 +1,89 @@
+RSpec.describe ROM::SQL::Association::ManyToMany, helpers: true do
+  subject(:assoc) do
+    ROM::SQL::Association::ManyToMany.new(source, target, options)
+  end
+
+  let(:options) { { through: :tasks_tags } }
+
+  let(:tags) { double(:tags, primary_key: :id) }
+  let(:tasks) { double(:tasks, primary_key: :id) }
+  let(:tasks_tags) { double(:tasks, primary_key: [:task_id, :tag_id]) }
+
+  let(:source) { :tasks }
+  let(:target) { :tags }
+
+  let(:relations) do
+    { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
+  end
+
+  shared_examples_for 'many-to-many association' do
+    describe '#combine_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.combine_keys(relations)).to eql(id: :tag_id)
+      end
+    end
+  end
+
+  describe '#result' do
+    it 'is :many' do
+      expect(assoc.result).to be(:many)
+    end
+  end
+
+  describe '#associate' do
+    let(:join_assoc) { double(:join_assoc) }
+
+    let(:source) { :tags }
+    let(:target) { :tasks }
+
+    it 'returns a list of join keys for given child tuples' do
+      expect(tasks_tags).to receive(:associations).and_return(assoc.target => join_assoc)
+      expect(join_assoc).to receive(:join_key_map).with(relations).and_return([:task_id, :id])
+      expect(tasks_tags).to receive(:foreign_key).with(:tags).and_return(:tag_id)
+
+      task_tuple = { id: 3 }
+      tag_tuples = [{ id: 1 }, { id: 2 }]
+
+      expect(assoc.associate(relations, tag_tuples, task_tuple)).to eql([
+        { tag_id: 1, task_id: 3 }, { tag_id: 2, task_id: 3 }
+      ])
+    end
+  end
+
+  context 'with default names' do
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
+        )
+      end
+    end
+  end
+
+  context 'with custom relation names' do
+    let(:source) { assoc_name(:tasks, :user_tasks) }
+    let(:target) { assoc_name(:tags, :user_tags) }
+
+    let(:relations) do
+      { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
+    end
+
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:user_tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
+        )
+      end
+    end
+  end
+end

data/spec/unit/association/many_to_one_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
+  subject(:assoc) do
+    ROM::SQL::Association::ManyToOne.new(source, target, options)
+  end
+
+  let(:options) { {} }
+
+  let(:users) { double(:users, primary_key: :id) }
+  let(:tasks) { double(:tasks) }
+
+  let(:source) { :tasks }
+  let(:target) { :users }
+
+  let(:relations) do
+    { users: users, tasks: tasks }
+  end
+
+  describe '#result' do
+    it 'is :one' do
+      expect(assoc.result).to be(:one)
+    end
+  end
+
+  describe '#associate' do
+    it 'returns child tuple with FK set' do
+      expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+      task_tuple = { title: 'Task' }
+      user_tuple = { id: 3 }
+
+      expect(assoc.associate(relations, task_tuple, user_tuple)).to eql(
+        user_id: 3, title: 'Task'
+      )
+    end
+  end
+
+  shared_examples_for 'many-to-many association' do
+    describe '#combine_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.combine_keys(relations)).to eql(user_id: :id)
+      end
+    end
+  end
+
+  context 'with default names' do
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:tasks, :user_id) => qualified_attribute(:users, :id)
+        )
+      end
+    end
+  end
+
+  context 'with custom relation names' do
+    let(:source) { assoc_name(:tasks, :user_tasks) }
+    let(:target) { assoc_name(:users, :people) }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:user_tasks, :user_id) => qualified_attribute(:people, :id)
+        )
+      end
+    end
+  end
+end

data/spec/unit/association/name_spec.rb

@@ -0,0 +1,68 @@
+RSpec.describe ROM::SQL::Association::Name do
+  describe '.[]' do
+    it 'returns a name object from a relation name' do
+      rel_name = ROM::Relation::Name[:users]
+      assoc_name = ROM::SQL::Association::Name[rel_name]
+
+      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :users))
+    end
+
+    it 'returns a name object from a relation and a dataset symbols' do
+      rel_name = ROM::Relation::Name[:users, :people]
+      assoc_name = ROM::SQL::Association::Name[:users, :people]
+
+      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :people))
+    end
+
+    it 'returns a name object from a relation and a dataset symbols and an alias' do
+      rel_name = ROM::Relation::Name[:users, :people]
+      assoc_name = ROM::SQL::Association::Name[:users, :people, :author]
+
+      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :author))
+    end
+
+    it 'caches names' do
+      name = ROM::SQL::Association::Name[:users]
+
+      expect(name).to be(ROM::SQL::Association::Name[:users])
+
+      name = ROM::SQL::Association::Name[:users, :people]
+
+      expect(name).to be(ROM::SQL::Association::Name[:users, :people])
+
+      name = ROM::SQL::Association::Name[:users, :people, :author]
+
+      expect(name).to be(ROM::SQL::Association::Name[:users, :people, :author])
+    end
+  end
+
+  describe '#aliased?' do
+    it 'returns true if a name has an alias' do
+      expect(ROM::SQL::Association::Name[:users, :people, :author]).to be_aliased
+    end
+
+    it 'returns false if a name has no alias' do
+      expect(ROM::SQL::Association::Name[:users, :people]).to_not be_aliased
+    end
+  end
+
+  describe '#inspect' do
+    it 'includes info about the relation name' do
+      expect(ROM::SQL::Association::Name[:users].inspect).to eql(
+        "ROM::SQL::Association::Name(users)"
+      )
+    end
+
+    it 'includes info about the relation name and its dataset' do
+      expect(ROM::SQL::Association::Name[:users, :people].inspect).to eql(
+        "ROM::SQL::Association::Name(users on people)"
+      )
+    end
+
+    it 'includes info about the relation name, its dataset and alias' do
+      expect(ROM::SQL::Association::Name[:users, :people, :author].inspect).to eql(
+        "ROM::SQL::Association::Name(users on people as author)"
+      )
+    end
+  end
+end

data/spec/unit/association/one_to_many_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe ROM::SQL::Association::OneToMany, helpers: true do
+  subject(:assoc) do
+    ROM::SQL::Association::OneToMany.new(source, target, options)
+  end
+
+  let(:options) { {} }
+
+  let(:users) { double(:users, primary_key: :id) }
+  let(:tasks) { double(:tasks) }
+
+  shared_examples_for 'one-to-many association' do
+    describe '#combine_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.combine_keys(relations)).to eql(id: :user_id)
+      end
+    end
+  end
+
+  context 'with default names' do
+    let(:source) { :users }
+    let(:target) { :tasks }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it_behaves_like 'one-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:users, :id) => qualified_attribute(:tasks, :user_id)
+        )
+      end
+    end
+  end
+
+  context 'with custom relation names' do
+    let(:source) { assoc_name(:users, :people) }
+    let(:target) { assoc_name(:tasks, :user_tasks) }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it_behaves_like 'one-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:people, :id) => qualified_attribute(:user_tasks, :user_id)
+        )
+      end
+    end
+  end
+end

data/spec/unit/association/one_to_one_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe ROM::SQL::Association::OneToOne, helpers: true do
+  subject(:assoc) do
+    ROM::SQL::Association::OneToOne.new(source, target, options)
+  end
+
+  let(:options) { {} }
+
+  let(:users) { double(:users, primary_key: :id) }
+  let(:tasks) { double(:tasks) }
+
+  shared_examples_for 'one-to-one association' do
+    describe '#combine_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.combine_keys(relations)).to eql(id: :user_id)
+      end
+    end
+  end
+
+  context 'with default names' do
+    let(:source) { :users }
+    let(:target) { :tasks }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it_behaves_like 'one-to-one association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:users, :id) => qualified_attribute(:tasks, :user_id)
+        )
+      end
+    end
+  end
+
+  context 'with custom relation names' do
+    let(:source) { assoc_name(:users, :people) }
+    let(:target) { assoc_name(:tasks, :user_tasks) }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it_behaves_like 'one-to-one association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:people, :id) => qualified_attribute(:user_tasks, :user_id)
+        )
+      end
+    end
+  end
+end

data/spec/unit/association/one_to_one_through_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe ROM::SQL::Association::OneToOneThrough, helpers: true do
+  subject(:assoc) do
+    ROM::SQL::Association::OneToOneThrough.new(source, target, options)
+  end
+
+  let(:options) { { through: :tasks_tags } }
+
+  let(:tags) { double(:tags, primary_key: :id) }
+  let(:tasks) { double(:tasks, primary_key: :id) }
+  let(:tasks_tags) { double(:tasks, primary_key: [:task_id, :tag_id]) }
+
+  let(:source) { :tasks }
+  let(:target) { :tags }
+
+  describe '#result' do
+    it 'is :one' do
+      expect(assoc.result).to be(:one)
+    end
+  end
+
+  shared_examples_for 'many-to-many association' do
+    describe '#combine_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.combine_keys(relations)).to eql(id: :tag_id)
+      end
+    end
+  end
+
+  context 'with default names' do
+    let(:relations) do
+      { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
+    end
+
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
+        )
+      end
+    end
+  end
+
+  context 'with custom relation names' do
+    let(:source) { assoc_name(:tasks, :user_tasks) }
+    let(:target) { assoc_name(:tags, :user_tags) }
+
+    let(:relations) do
+      { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
+    end
+
+    it_behaves_like 'many-to-many association'
+
+    describe '#join_keys' do
+      it 'returns a hash with combine keys' do
+        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
+
+        expect(assoc.join_keys(relations)).to eql(
+          qualified_attribute(:user_tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
+        )
+      end
+    end
+  end
+end