rom-repository 1.4.0 → 2.0.0.beta1

data/spec/integration/command_macros_spec.rb

@@ -1,191 +0,0 @@
-RSpec.describe ROM::Repository, '.command' do
-  include_context 'database'
-  include_context 'relations'
-
-  it 'allows configuring a create command' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands :create
-    end.new(rom)
-
-    user = repo.create(name: 'Jane')
-
-    expect(user.id).to_not be(nil)
-    expect(user.name).to eql('Jane')
-  end
-
-  it 'allows configuring an update and delete commands' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands :create, update: :by_pk, delete: :by_pk
-    end.new(rom)
-
-    user = repo.create(name: 'Jane')
-
-    repo.update(user.id, name: 'Jane Doe')
-
-    user = repo.users.by_pk(user.id).one
-
-    expect(user.name).to eql('Jane Doe')
-
-    repo.delete(user.id)
-
-    expect(repo.users.by_pk(user.id).one).to be(nil)
-  end
-
-  it 'configures an update command with custom restriction' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands update: :by_name
-    end.new(rom)
-
-    repo.relations.users.insert(name: 'Jade')
-
-    user = repo.update('Jade', name: 'Jade Doe')
-    expect(user.name).to eql('Jade Doe')
-
-    expect(repo.update('Oops', name: 'Jade')).to be(nil)
-  end
-
-  it 'allows to configure update command without create one' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands update: :by_pk
-    end.new(rom)
-
-    user = repo.command(create: :users)[name: 'Jane']
-
-    repo.update(user.id, name: 'Jane Doe')
-
-    updated_user = repo.users.by_pk(user.id).one
-
-    expect(updated_user.name).to eql('Jane Doe')
-  end
-
-  it 'allows to configure :delete command without args' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands :delete
-    end.new(rom)
-
-    repo.users.insert(name: 'Jane')
-    repo.users.insert(name: 'John')
-
-    repo.delete
-
-    expect(repo.users.count).to be_zero
-  end
-
-  it 'allows defining a single command with multiple views' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands :create, update: [:by_pk, :by_name]
-    end.new(rom)
-
-    user = repo.create(name: 'Jane')
-
-    repo.update_by_pk(user.id, name: 'Jane Doe')
-    user = repo.users.by_pk(user.id).one
-    expect(user.name).to eql('Jane Doe')
-
-    repo.update_by_name(user.name, name: 'Jane')
-    user = repo.users.by_pk(user.id).one
-    expect(user.name).to eql('Jane')
-  end
-
-  it 'uses a mapper built from AST by default' do
-    repo = Class.new(ROM::Repository[:users]) do
-      commands :create
-    end.new(rom)
-
-    user = repo.create(name: 'Jane')
-
-    expect(user).to be_kind_of Dry::Struct
-
-    struct_definition = [:users, [:header, [
-                                    [:attribute, repo.users.schema[:id]],
-                                    [:attribute, repo.users.schema[:name]]]]]
-
-    expect(user).to be_an_instance_of ROM::Repository::StructBuilder.cache[struct_definition.hash]
-  end
-
-  describe 'using plugins' do
-    include_context 'plugins'
-
-    before do
-      conn.alter_table :users do
-        add_column :created_at, :timestamp, null: false
-        add_column :updated_at, :timestamp, null: false
-      end
-    end
-
-    it 'allows to use plugins in generated commands' do
-      repo = Class.new(ROM::Repository[:users]) do
-        commands :create, update: :by_pk, use: :timestamps
-      end.new(rom)
-
-      user = repo.create(name: 'Jane')
-      expect(user.created_at).to be_within(1).of Time.now
-      expect(user.created_at).to eql(user.updated_at)
-
-      repo.update(user.id, **user, name: 'Jane Doe')
-      updated_user = repo.users.by_pk(user.id).one
-      expect(updated_user.created_at).to eql(user.created_at)
-      expect(updated_user.updated_at).to be > updated_user.created_at
-    end
-
-    it 'allows to use several plugins' do
-      repo = Class.new(ROM::Repository[:users]) do
-        commands :create, use: %i(upcase_name timestamps)
-      end.new(rom)
-
-      user = repo.create(name: 'Jane')
-      expect(user.created_at).to be_within(1).of Time.now
-      expect(user.name).to eql('JANE')
-    end
-  end
-
-  describe 'using custom mappers' do
-    before do
-      configuration.mappers do
-        register :users,
-                 name_list: -> users { users.map { |u| u[:name] } },
-                 id_list: -> users { users.map { |u| u[:id] } }
-      end
-    end
-
-    it 'allows to use named mapper in commands' do
-      repo = Class.new(ROM::Repository[:users]).new(rom)
-
-      name = repo.command(create: :users, mapper: :name_list).call(name: 'Jane')
-
-      expect(name).to eql('Jane')
-    end
-
-    it 'caches command pipeline using mapper option' do
-      repo = Class.new(ROM::Repository[:users]).new(rom)
-
-      c1 = repo.command(create: :users, mapper: :name_list)
-      c2 = repo.command(create: :users, mapper: :name_list)
-      c3 = repo.command(create: :users, mapper: :id_list)
-
-      name = c1.call(name: 'Jane')
-      id = c3.call(name: 'John')
-
-      expect(c1).to be c2
-      expect(c3).not_to be c1
-
-      expect(name).to eql('Jane')
-      expect(id).to eql(2)
-    end
-
-    it 'allows to set a mapper with a class-level macro' do
-      repo = Class.new(ROM::Repository[:users]) do
-        commands :create, update: :by_pk, delete: :by_pk, mapper: :name_list
-      end.new(rom)
-
-      name = repo.create(name: 'Jane')
-      expect(name).to eql('Jane')
-
-      updated_name = repo.update(1, name: 'Jane Doe')
-      expect(updated_name).to eql('Jane Doe')
-
-      deleted_name = repo.delete(1)
-      expect(deleted_name).to eql('Jane Doe')
-    end
-  end
-end

data/spec/integration/command_spec.rb

@@ -1,228 +0,0 @@
-RSpec.describe ROM::Repository, '#command' do
-  include_context 'database'
-  include_context 'relations'
-  include_context 'repo'
-
-  context 'accessing custom command from the registry' do
-    before do
-      configuration.commands(:users) do
-        define(:upsert, type: ROM::SQL::Commands::Create)
-        define(:create)
-      end
-
-      configuration.commands(:tasks) do
-        define(:create)
-      end
-    end
-
-    it 'returns registered command' do
-      expect(repo.command(:users).upsert).to be(rom.command(:users).upsert)
-      expect(repo.command(:users)[:upsert]).to be(rom.command(:users).upsert)
-    end
-
-    it 'exposes command builder DSL' do
-      command = repo.command.create(user: :users) { |user| user.create(:tasks) }
-
-      expect(command).to be_instance_of(ROM::Command::Graph)
-    end
-  end
-
-  context ':create' do
-    it 'builds Create command for a relation' do
-      create_user = repo.command(create: :users)
-
-      user = create_user.call(name: 'Jane Doe')
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane Doe')
-    end
-
-    it 'uses input_schema for command input' do
-      create_user = repo.command(create: :users)
-      expect(create_user.input).to eql(repo.users.input_schema)
-    end
-
-    it 'caches commands' do
-      create_user = -> { repo.command(create: :users) }
-
-      expect(create_user.()).to be(create_user.())
-    end
-
-    it 'builds Create command for a relation graph with one-to-one' do
-      create_user = repo.command(
-        :create,
-        repo.users.combine_children(one: repo.tasks)
-      )
-
-      user = create_user.call(name: 'Jane Doe', task: { title: 'Task one' })
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane Doe')
-      expect(user.task.title).to eql('Task one')
-    end
-
-    it 'builds Create command for a deeply nested relation graph' do
-      create_user = repo.command(
-        :create,
-        repo.users.combine_children(one: repo.tasks.combine_children(many: repo.tags))
-      )
-
-      user = create_user.call(
-        name: 'Jane Doe', task: { title: 'Task one', tags: [{ name: 'red' }] }
-      )
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane Doe')
-      expect(user.task.title).to eql('Task one')
-      expect(user.task.tags).to be_instance_of(Array)
-      expect(user.task.tags.first.name).to eql('red')
-    end
-
-    it 'builds Create command for a relation graph with one-to-many' do
-      create_user = repo.command(
-        :create,
-        repo.users.combine_children(many: repo.tasks)
-      )
-
-      user = create_user.call(name: 'Jane Doe', tasks: [{ title: 'Task one' }])
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane Doe')
-      expect(user.tasks).to be_instance_of(Array)
-      expect(user.tasks.first.title).to eql('Task one')
-    end
-
-    it 'builds Create command for a relation graph with one-to-many with aliased association' do
-      create_user = repo.command(:create, repo.users.combine(:aliased_posts))
-
-      user = create_user.call(name: 'Jane Doe', aliased_posts: [{ title: 'Post one' }, { title: 'Post two' }])
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane Doe')
-      expect(user.aliased_posts.size).to be(2)
-    end
-
-    it 'builds Create command for a deeply nested graph with one-to-many' do
-      create_user = repo.command(
-        :create,
-        repo.aggregate(many: repo.tasks.combine_children(many: repo.tags))
-      )
-
-      user = create_user.call(
-        name: 'Jane',
-        tasks: [{ title: 'Task', tags: [{ name: 'red' }]}]
-      )
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane')
-      expect(user.tasks).to be_instance_of(Array)
-      expect(user.tasks.first.title).to eql('Task')
-      expect(user.tasks.first.tags).to be_instance_of(Array)
-      expect(user.tasks.first.tags.first.name).to eql('red')
-    end
-
-    it 'builds Create command for a deeply nested graph with many-to-one & one-to-many' do
-      create_user = repo.command(
-        :create,
-        repo.aggregate(one: repo.tasks.combine_children(many: repo.tags))
-      )
-
-      user = create_user.call(
-        name: 'Jane', task: { title: 'Task', tags: [{ name: 'red' }, { name: 'blue' }] }
-      )
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane')
-      expect(user.task.title).to eql('Task')
-      expect(user.task.tags).to be_instance_of(Array)
-      expect(user.task.tags.size).to be(2)
-      expect(user.task.tags[0].name).to eql('red')
-      expect(user.task.tags[1].name).to eql('blue')
-    end
-
-    it 'builds Create command for a deeply nested graph with many-to-one' do
-      create_user = repo.command(
-        :create,
-        repo.aggregate(one: repo.tasks.combine_children(one: repo.tags))
-      )
-
-      user = create_user.call(
-        name: 'Jane', task: { title: 'Task', tag: { name: 'red' } }
-      )
-
-      expect(user.id).to_not be(nil)
-      expect(user.name).to eql('Jane')
-      expect(user.task.id).to_not be(nil)
-      expect(user.task.title).to eql('Task')
-      expect(user.task.tag.id).to_not be(nil)
-      expect(user.task.tag.name).to eql('red')
-    end
-
-    it 'builds Create command for a nested graph with many-to-many' do
-      user = repo.command(:create, repo.users).(name: 'Jane')
-
-      create_post = repo.command(
-        :create, repo.posts.combine_children(many: { labels: repo.labels })
-      )
-
-      post = create_post.call(
-        author_id: user.id, title: 'Jane post', labels: [{ name: 'red' }]
-      )
-
-      expect(post.labels.size).to be(1)
-    end
-
-    context 'relation with a custom dataset name' do
-      it 'allows configuring a create command' do
-        create_comment = comments_repo.command(create: :comments)
-
-        comment = create_comment.(author: 'gerybabooma', body: 'DIS GUY MUST BE A ALIEN OR SUTIN')
-
-        expect(comment.message_id).to eql(1)
-        expect(comment.author).to eql('gerybabooma')
-        expect(comment.body).to eql('DIS GUY MUST BE A ALIEN OR SUTIN')
-      end
-
-      it 'allows configuring a create command with aliased one-to-many' do
-        pending 'custom association names in the input are not yet support'
-
-        create_comment = comments_repo.command(:create, comments_repo.comments.combine(:emotions))
-
-        comment = create_comment.(author: 'Jane',
-                                  body: 'Hello Joe',
-                                  emotions: [{ author: 'Joe' }])
-
-        expect(comment.message_id).to eql(1)
-        expect(comment.author).to eql('Jane')
-        expect(comment.body).to eql('Hello Joe')
-        expect(comment.emotions.size).to eql(1)
-        expect(comment.emotions[0].author).to eql('Joe')
-      end
-    end
-  end
-
-  context ':update' do
-    it 'builds Update command for a relation' do
-      repo.users.insert(id: 3, name: 'Jane')
-
-      update_user = repo.command(:update, repo.users)
-
-      user = update_user.by_pk(3).call(name: 'Jane Doe')
-
-      expect(user.id).to be(3)
-      expect(user.name).to eql('Jane Doe')
-    end
-  end
-
-  context ':delete' do
-    it 'builds Delete command for a relation' do
-      repo.users.insert(id: 3, name: 'Jane')
-
-      delete_user = repo.command(:delete, repo.users)
-
-      delete_user.by_pk(3).call
-
-      expect(repo.users.by_pk(3).one).to be(nil)
-    end
-  end
-end

data/spec/integration/multi_adapter_spec.rb

@@ -1,73 +0,0 @@
-# coding: utf-8
-RSpec.describe 'Repository with multi-adapters configuration' do
-  let(:configuration) {
-    ROM::Configuration.new(default: [:sql, DB_URI], memory: [:memory])
-  }
-
-  let(:sql_conn) { configuration.gateways[:default].connection }
-
-  let(:rom) { ROM.container(configuration) }
-
-  let(:users) { rom.relation(:sql_users) }
-  let(:tasks) { rom.relation(:memory_tasks) }
-
-  let(:repo) { Test::Repository.new(rom) }
-
-  before do
-    [:tags, :tasks, :posts, :books, :users, :posts_labels, :labels,
-     :reactions, :messages].each { |table| sql_conn.drop_table?(table) }
-
-    sql_conn.create_table :users do
-      primary_key :id
-      column :name, String
-    end
-
-    module Test
-      class Users < ROM::Relation[:sql]
-        schema(:users, as: :sql_users, infer: true)
-      end
-
-      class Tasks < ROM::Relation[:memory]
-        schema(:tasks, as: :memory_tasks) do
-          attribute :user_id, ROM::Types::Int
-          attribute :title, ROM::Types::String
-        end
-
-        gateway :memory
-
-        use :key_inference
-
-        view(:base, [:user_id, :title]) do
-          self
-        end
-
-        def for_users(users)
-          restrict(user_id: users.pluck(:id))
-        end
-      end
-
-      class Repository < ROM::Repository[:sql_users]
-        relations :memory_tasks
-
-        def users_with_tasks(id)
-          aggregate(many: { tasks: memory_tasks }).where(id: id)
-        end
-      end
-    end
-
-    configuration.register_relation(Test::Users)
-    configuration.register_relation(Test::Tasks)
-
-    user_id = configuration.gateways[:default].dataset(:users).insert(name: 'Jane')
-    configuration.gateways[:memory].dataset(:tasks).insert(user_id: user_id, title: 'Jane Task')
-  end
-
-  specify 'ᕕ⁞ ᵒ̌ 〜 ᵒ̌ ⁞ᕗ' do
-    user = repo.users_with_tasks(users.last[:id]).first
-
-    expect(user.name).to eql('Jane')
-
-    expect(user.tasks[0].user_id).to eql(user.id)
-    expect(user.tasks[0].title).to eql('Jane Task')
-  end
-end