rom-repository 1.4.0 → 2.0.0.beta1

data/spec/integration/root_repository_spec.rb

@@ -1,106 +0,0 @@
-RSpec.describe ROM::Repository::Root do
-  subject(:repo) do
-    Class.new(ROM::Repository[:users]) do
-      relations :tasks, :posts, :labels
-    end.new(rom)
-  end
-
-  include_context 'database'
-  include_context 'relations'
-
-  describe '.[]' do
-    it 'creates a pre-configured root repo class' do
-      klass = ROM::Repository[:users]
-
-      expect(klass.relations).to eql([:users])
-      expect(klass.root).to be(:users)
-
-      child = klass[:users]
-
-      expect(child.relations).to eql([:users])
-      expect(child.root).to be(:users)
-      expect(child < klass).to be(true)
-    end
-  end
-
-  describe 'inheritance' do
-    it 'inherits root and relations' do
-      klass = Class.new(repo.class)
-
-      expect(klass.relations).to eql([:users, :tasks, :posts, :labels])
-      expect(klass.root).to be(:users)
-    end
-
-    it 'creates base root class' do
-      klass = Class.new(ROM::Repository)[:users]
-
-      expect(klass.relations).to eql([:users])
-      expect(klass.root).to be(:users)
-    end
-  end
-
-  describe '#root' do
-    it 'returns configured root relation' do
-      expect(repo.root.relation).to be(rom.relations[:users])
-    end
-  end
-
-  describe '#changeset' do
-    it 'returns a changeset automatically set for root relation' do
-      klass = Class.new(ROM::Changeset::Create)
-
-      changeset = repo.changeset(klass)
-
-      expect(changeset.relation).to be(repo.users)
-      expect(changeset).to be_kind_of(klass)
-    end
-  end
-
-  describe '#aggregate' do
-    include_context 'seeds'
-
-    it 'builds an aggregate from the root relation and other relation(s)' do
-      user = repo.aggregate(many: repo.tasks).where(name: 'Jane').one
-
-      expect(user.name).to eql('Jane')
-      expect(user.tasks.size).to be(1)
-      expect(user.tasks[0].title).to eql('Jane Task')
-    end
-
-    context 'with associations' do
-      it 'builds an aggregate from a canonical association' do
-        user = repo.aggregate(:labels).where(name: 'Joe').one
-
-        expect(user.name).to eql('Joe')
-        expect(user.labels.size).to be(1)
-        expect(user.labels[0].name).to eql('green')
-      end
-
-      it 'builds an aggregate with nesting level = 2' do
-        user = repo.aggregate(posts: [:labels, :author]).where(name: 'Joe').one
-
-        expect(user.name).to eql('Joe')
-        expect(user.posts.size).to be(1)
-        expect(user.posts[0].title).to eql('Hello From Joe')
-        expect(user.posts[0].labels.size).to be(1)
-      end
-
-      it 'builds a command from an aggregate' do
-        command = repo.command(:create, repo.aggregate(:posts))
-
-        result = command.call(name: 'Jade', posts: [{ title: 'Jade post' }])
-
-        expect(result.name).to eql('Jade')
-        expect(result.posts.size).to be(1)
-        expect(result.posts[0].title).to eql('Jade post')
-      end
-
-      it 'builds same relation as manual combine' do
-        left = repo.aggregate(:posts)
-        right = repo.users.combine_children(many: repo.posts)
-
-        expect(left.to_ast).to eql(right.to_ast)
-      end
-    end
-  end
-end

data/spec/integration/typed_structs_spec.rb

@@ -1,64 +0,0 @@
-RSpec.describe 'ROM repository with typed structs' do
-  subject(:repo) do
-    Class.new(ROM::Repository[:books]) { commands :create }.new(rom)
-  end
-
-  include_context 'database'
-  include_context 'seeds'
-
-  context 'typed projections' do
-    before do
-      configuration.relation(:books) do
-        schema(infer: true)
-
-        view(:index) do
-          schema { project(:id, :title, :created_at) }
-          relation { order(:title) }
-        end
-      end
-
-      rom.relations[:books].insert(title: 'Hello World', created_at: Time.now)
-    end
-
-    it 'loads typed structs' do
-      book = repo.books.index.first
-
-      expect(book).to be_kind_of(Dry::Struct)
-
-      expect(book.id).to be_kind_of(Integer)
-      expect(book.title).to eql('Hello World')
-      expect(book.created_at).to be_kind_of(Time)
-    end
-  end
-
-  context 'read-write type coercions' do
-    before do
-      configuration.relation(:books) do
-        schema(infer: true) do
-          attribute :title,
-                    ROM::Types::Coercible::String.meta(
-                      read: ROM::Types::Symbol.constructor(&:to_sym)
-                    )
-        end
-      end
-
-      configuration.commands(:books) do
-        define(:create) { result(:one) }
-      end
-    end
-
-    it 'loads typed structs' do
-      created_book = repo.create(title: :'Hello World', created_at: Time.now)
-
-      expect(created_book).to be_kind_of(Dry::Struct)
-
-      expect(created_book.id).to be_kind_of(Integer)
-      expect(created_book.title).to eql(:'Hello World')
-      expect(created_book.created_at).to be_kind_of(Time)
-
-      book = repo.books.to_a.first
-
-      expect(book).to eql(created_book)
-    end
-  end
-end

data/spec/shared/database.rb

@@ -1,79 +0,0 @@
-RSpec.shared_context 'database setup' do
-  let(:configuration) { ROM::Configuration.new(:sql, DB_URI) }
-
-  let(:conn) { configuration.gateways[:default].connection }
-
-  let(:rom) { ROM.container(configuration) }
-
-  before do
-    conn.loggers << LOGGER
-  end
-end
-
-RSpec.shared_context 'database' do
-  include_context 'database setup'
-
-  before do
-    [:tags, :tasks, :posts, :books, :users, :posts_labels, :labels,
-     :reactions, :messages].each { |table| conn.drop_table?(table) }
-
-    conn.create_table :users do
-      primary_key :id
-      column :name, String
-    end
-
-    conn.create_table :books do
-      primary_key :id
-      foreign_key :author_id, :users, on_delete: :cascade
-      column :title, String
-      column :created_at, Time
-      column :updated_at, Time
-    end
-
-    conn.create_table :tasks do
-      primary_key :id
-      foreign_key :user_id, :users, null: false, on_delete: :cascade
-      column :title, String
-    end
-
-    conn.create_table :tags do
-      primary_key :id
-      foreign_key :task_id, :tasks, null: false, on_delete: :cascade
-      column :name, String
-    end
-
-    conn.create_table :labels do
-      primary_key :id
-      column :name, String
-    end
-
-    conn.create_table :posts do
-      primary_key :id
-      foreign_key :author_id, :users, null: false, on_delete: :cascade
-      column :title, String, null: false
-      column :body, String
-    end
-
-    conn.create_table :posts_labels do
-      foreign_key :post_id, :labels, null: false, on_delete: :cascade
-      foreign_key :label_id, :labels, null: false, on_delete: :cascade
-      primary_key [:post_id, :label_id]
-    end
-
-    conn.create_table :messages do
-      primary_key :message_id
-      column :author, String
-      column :body, String
-    end
-
-    conn.create_table :reactions do
-      primary_key :reaction_id
-      foreign_key :message_id, :messages, null: false
-      column :author, String
-    end
-  end
-
-  after do
-    rom.disconnect
-  end
-end

data/spec/shared/mappers.rb

@@ -1,35 +0,0 @@
-RSpec.shared_context 'mappers' do
-  let(:user_mappers) { users.mappers[:user] }
-  let(:task_mappers) { tasks.mappers[:task] }
-  let(:tag_mappers) { tags.mappers[:tag] }
-
-  before do
-    configuration.mappers do
-      define(:users) do
-        model Test::Models::User
-        register_as :user
-
-        attribute :id
-        attribute :name
-      end
-
-      define(:tasks) do
-        model Test::Models::Task
-        register_as :task
-
-        attribute :id
-        attribute :user_id
-        attribute :title
-      end
-
-      define(:tags) do
-        model Test::Models::Tag
-        register_as :tag
-
-        attribute :id
-        attribute :task_id
-        attribute :name
-      end
-    end
-  end
-end

data/spec/shared/models.rb

@@ -1,41 +0,0 @@
-RSpec.shared_context 'models' do
-  let(:user_model) { Test::Models::User }
-  let(:task_model) { Test::Models::Task }
-  let(:tag_model) { Test::Models::Tag }
-
-  before do
-    module Test
-      module Models
-        class User
-          include Dry::Equalizer(:id, :name)
-
-          attr_reader :id, :name
-
-          def initialize(attrs)
-            @id, @name = attrs[:id], attrs[:name]
-          end
-        end
-
-        class Task
-          include Dry::Equalizer(:id, :user_id, :title)
-
-          attr_reader :id, :user_id, :title
-
-          def initialize(attrs)
-            @id, @name, @title = attrs[:id], attrs[:name], attrs[:title]
-          end
-        end
-
-        class Tag
-          include Dry::Equalizer(:id, :task_id, :name)
-
-          attr_reader :id, :task_id, :name
-
-          def initialize(attrs)
-            @id, @task_id, @name = attrs[:id], attrs[:task_id], attrs[:name]
-          end
-        end
-      end
-    end
-  end
-end

data/spec/shared/plugins.rb

@@ -1,66 +0,0 @@
-RSpec.shared_context 'plugins' do
-  before do
-    module Test
-      class WrappingInput
-        def initialize(input)
-          @input = input || Hash
-        end
-      end
-
-      module Timestamps
-        class InputWithTimestamp < WrappingInput
-          def [](value)
-            v = @input[value]
-            now = Time.now
-
-            if v[:created_at]
-              v.merge(updated_at: now)
-            else
-              v.merge(created_at: now, updated_at: now)
-            end
-          end
-        end
-
-        module ClassInterface
-          def build(relation, options = {})
-            super(relation, options.merge(input: InputWithTimestamp.new(input)))
-          end
-        end
-
-        def self.included(klass)
-          super
-
-          klass.extend ClassInterface
-        end
-      end
-
-      module UpcaseName
-        class UpcaseNameInput < WrappingInput
-          def [](value)
-            v = @input[value]
-            v.merge(name: value.fetch(:name).upcase)
-          end
-        end
-
-        module ClassInterface
-          def build(relation, options = {})
-            super(relation, options.merge(input: UpcaseNameInput.new(options.fetch(:input))))
-          end
-        end
-
-        def self.included(klass)
-          super
-
-          klass.extend ClassInterface
-        end
-      end
-    end
-
-    ROM.plugins do
-      adapter :sql do
-        register :timestamps, Test::Timestamps, type: :command
-        register :upcase_name, Test::UpcaseName, type: :command
-      end
-    end
-  end
-end

data/spec/shared/relations.rb

@@ -1,115 +0,0 @@
-RSpec.shared_context 'relations' do
-  let(:users) { rom.relations[:users] }
-  let(:tasks) { rom.relations[:tasks] }
-  let(:tags) { rom.relations[:tags] }
-  let(:posts) { rom.relations[:posts] }
-  let(:books) { rom.relations[:books] }
-
-  before do
-    configuration.relation(:books) do
-      schema(:books) do
-        attribute :id, ROM::SQL::Types::Serial
-        attribute :author_id, ROM::SQL::Types.ForeignKey(:users)
-        attribute :title, ROM::SQL::Types::String
-        attribute :created_at, ROM::SQL::Types::Time
-        attribute :updated_at, ROM::SQL::Types::Time
-
-        associations do
-          belongs_to :users, as: :author, relation: :authors, foreign_key: :author_id
-        end
-      end
-    end
-
-    configuration.relation(:users) do
-      schema(infer: true) do
-        associations do
-          has_many :posts
-          has_many :posts, as: :aliased_posts
-          has_many :labels, through: :posts
-          has_many :books, foreign_key: :author_id
-        end
-      end
-
-      def by_name(name)
-        where(name: name)
-      end
-
-      def all
-        select(:id, :name).order(:name, :id)
-      end
-
-      def find(criteria)
-        where(criteria)
-      end
-    end
-
-    configuration.relation(:authors) do
-      schema(:users, infer: true)
-    end
-
-    configuration.relation(:tasks) do
-      schema(infer: true) do
-        associations do
-          belongs_to :user
-          belongs_to :users, as: :assignee
-        end
-      end
-
-      def find(criteria)
-        where(criteria)
-      end
-
-      def for_users(users)
-        where(user_id: users.map { |u| u[:id] })
-      end
-    end
-
-    configuration.relation(:tags) do
-      schema(infer: true)
-    end
-
-    configuration.relation(:labels) do
-      schema(infer: true) do
-        associations do
-          has_many :posts_labels
-          has_many :posts, through: :posts_labels
-        end
-      end
-    end
-
-    configuration.relation(:posts) do
-      schema(:posts, infer: true) do
-        associations do
-          has_many :labels, through: :posts_labels
-          belongs_to :user, as: :author
-        end
-      end
-    end
-
-    configuration.relation(:posts_labels) do
-      schema(infer: true) do
-        associations do
-          belongs_to :post
-          belongs_to :label
-        end
-      end
-    end
-
-    configuration.relation(:comments) do
-      schema(:messages, as: :comments, infer: true) do
-        associations do
-          has_many :reactions, relation: :likes
-          has_many :reactions, relation: :likes, as: :emotions
-        end
-      end
-    end
-
-    configuration.relation(:likes) do
-      schema(:reactions, as: :likes, infer: true) do
-        associations do
-          belongs_to :message, relation: :comments
-        end
-      end
-    end
-  end
-end