rom 0.2.0 → 0.3.0

data/spec/integration/ra/group_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Group operation' do
+  include_context 'users and tasks'
+
+  specify 'defining a grouped relation' do
+    setup.relation(:users) do
+
+      def with_tasks
+        in_memory {
+          group(join(tasks), tasks: [:title, :priority])
+        }
+      end
+
+      def by_name(name)
+        restrict(name: name)
+      end
+
+    end
+
+    users = rom.relations.users
+
+    expect(users.with_tasks.to_a).to eql(
+      [
+        {
+          name: "Joe", email: "joe@doe.org", tasks: [
+            { title: "be nice", priority: 1 },
+            { title: "sleep well", priority: 2 }
+          ]
+        },
+        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
+      ]
+    )
+
+    expect(users.with_tasks.by_name("Jane").to_a).to eql(
+      [
+        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
+      ]
+    )
+
+    expect(users.by_name("Jane").with_tasks.to_a).to eql(
+      [
+        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
+      ]
+    )
+  end
+end

data/spec/integration/ra/join_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe 'Join operation' do
+  include_context 'users and tasks'
+
+  specify 'defining a joined relation' do
+    setup.relation(:users) do
+      def with_tasks
+        in_memory { join(tasks) }
+      end
+    end
+
+    users = rom.relations.users
+
+    expect(users.with_tasks.to_a).to eql(
+      [
+        { name: 'Joe', email: 'joe@doe.org', title: 'be nice', priority: 1 },
+        { name: 'Joe', email: 'joe@doe.org', title: 'sleep well', priority: 2 },
+        { name: 'Jane', email: 'jane@doe.org', title: 'be cool', priority: 2 }
+      ]
+    )
+  end
+
+end

data/spec/integration/ra/wrap_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Wrap operation' do
+  include_context 'users and tasks'
+
+  subject(:rom) { setup.finalize }
+
+  specify 'defining a wrapped relation' do
+    setup.relation(:users) do
+      def with_task
+        in_memory { wrap(join(tasks), task: [:title, :priority]) }
+      end
+    end
+
+    users = rom.relations.users
+
+    expect(users.with_task.to_a).to eql(
+      [
+        {
+          name: "Joe",
+          email: "joe@doe.org",
+          task: { title: "be nice", priority: 1 }
+        },
+        {
+          name: "Joe",
+          email: "joe@doe.org",
+          task: { title: "sleep well", priority: 2 }
+        },
+        {
+          name: "Jane",
+          email: "jane@doe.org",
+          task: { title: "be cool", priority: 2 }
+        }
+      ]
+    )
+  end
+end

data/spec/integration/relations/reading_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe 'Reading relations' do
+  include_context 'users and tasks'
+
+  it 'exposes a relation reader' do
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+
+      def sorted
+        order(:name, :email)
+      end
+    end
+
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+      end
+    end
+
+    rom = setup.finalize
+
+    users = rom.read(:users).sorted.by_name('Jane')
+    user = users.first
+
+    expect(user).to be_an_instance_of(User)
+    expect(user.name).to eql 'Jane'
+    expect(user.email).to eql 'jane@doe.org'
+  end
+
+  it 'maps grouped relations' do
+    setup.relation(:users) do
+      def with_tasks
+        in_memory { group(join(tasks), tasks: [:title, :priority]) }
+      end
+
+      def sorted
+        order(:name)
+      end
+    end
+
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+      end
+
+      define(:with_tasks, parent: :users) do
+        model name: 'UserWithTasks'
+
+        group tasks: [:title, :priority]
+      end
+    end
+
+    rom = setup.finalize
+
+    User.send(:include, Equalizer.new(:name, :email))
+    UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
+
+    expect(rom.read(:users).with_tasks.header).to eql([:name, :email, :tasks])
+
+    user = rom.read(:users).sorted.first
+
+    expect(user).to eql(
+      User.new(name: "Jane", email: "jane@doe.org")
+    )
+
+    user = rom.read(:users).with_tasks.sorted.first
+
+    expect(user).to eql(
+      UserWithTasks.new(
+        name: "Jane",
+        email: "jane@doe.org",
+        tasks: [{ title: "be cool", priority: 2 }])
+    )
+  end
+
+  it 'maps wrapped relations' do
+    setup.relation(:users) do
+      def with_task
+        in_memory { wrap(join(tasks), task: [:title, :priority]) }
+      end
+
+      def sorted
+        order(:name)
+      end
+    end
+
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+      end
+
+      define(:with_task, parent: :users) do
+        model name: 'UserWithTask'
+
+        wrap task: [:title, :priority]
+      end
+    end
+
+    rom = setup.finalize
+
+    User.send(:include, Equalizer.new(:name, :email))
+    UserWithTask.send(:include, Equalizer.new(:name, :email, :task))
+
+    expect(rom.read(:users).with_task.header).to eql([:name, :email, :task])
+
+    user = rom.read(:users).sorted.with_task.first
+
+    expect(user).to eql(
+      UserWithTask.new(name: "Jane", email: "jane@doe.org",
+                       task: { title: "be cool", priority: 2 })
+    )
+  end
+end

data/spec/integration/relations/registry_dsl_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'Relation registration DSL' do
+  include_context 'users and tasks'
+
+  it 'allows to expose chainable relations' do
+    setup.relation(:tasks) do
+      def high_priority
+        restrict { |tuple| tuple[:priority] < 2 }
+      end
+
+      def by_title(title)
+        restrict(title: title)
+      end
+    end
+
+    setup.relation(:users) do
+      def with_tasks
+        in_memory { join(tasks) }
+      end
+    end
+
+    tasks = rom.relations.tasks
+
+    expect(tasks.class.name).to eql("ROM::Relation[Tasks]")
+    expect(tasks.high_priority.inspect).to include("#<ROM::Relation[Tasks]")
+
+    expect(tasks.high_priority.by_title("be nice")).to match_array(
+      [name: "Joe", title: "be nice", priority: 1]
+    )
+
+    expect(tasks.by_title("be cool")).to match_array(
+      [name: "Jane", title: "be cool", priority: 2]
+    )
+
+    users = rom.relations.users
+
+    expect(users.with_tasks.to_a).to eql(
+      [{ name: "Joe", email: "joe@doe.org", title: "be nice", priority: 1 },
+       { name: "Joe", email: "joe@doe.org", title: "sleep well", priority: 2 },
+       { name: "Jane", email: "jane@doe.org", title: "be cool", priority: 2 }]
+    )
+  end
+end

data/spec/integration/schema_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Defining schema' do
+  let(:setup) { ROM.setup(memory: 'memory://localhost') }
+  let(:rom) { setup.finalize }
+  let(:schema) { rom.schema }
+
+  describe '.schema' do
+    it 'returns schema with relations' do
+      setup.schema do
+        base_relation(:users) do
+          repository :memory
+
+          attribute :id
+          attribute :name
+        end
+      end
+
+      users = schema.users
+
+      expect(users.dataset.to_a).to eql(rom.memory.users.to_a)
+      expect(users.header).to eql([:id, :name])
+    end
+
+    it 'returns an empty schema if it was not defined' do
+      expect(schema.users).to be_nil
+    end
+  end
+end

data/spec/integration/setup_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Setting up ROM' do
+  include_context 'users and tasks'
+
+  let(:jane) { { name: 'Jane', email: 'jane@doe.org' } }
+  let(:joe) { { name: 'Joe', email: 'joe@doe.org' } }
+
+  it 'configures relations' do
+    expect(rom.memory.users).to match_array([joe, jane])
+  end
+
+  it 'raises on double-finalize' do
+    expect {
+      2.times { setup.finalize }
+    }.to raise_error(ROM::EnvAlreadyFinalizedError)
+  end
+end

data/spec/shared/users_and_tasks.rb

@@ -0,0 +1,34 @@
+RSpec.shared_context 'users and tasks' do
+  subject(:rom) { setup.finalize }
+
+  let(:setup) { ROM.setup(memory: "memory://localhost") }
+
+  before do
+    setup.schema do
+      base_relation(:users) do
+        repository :memory
+
+        attribute :name
+        attribute :email
+      end
+
+      base_relation(:tasks) do
+        repository :memory
+
+        attribute :name
+        attribute :title
+        attribute :priority
+      end
+    end
+
+    db = setup.memory
+
+    db[:users].insert(name: "Joe", email: "joe@doe.org")
+    db[:users].insert(name: "Jane", email: "jane@doe.org")
+
+    db[:tasks].insert(name: "Joe", title: "be nice", priority: 1)
+    db[:tasks].insert(name: "Joe", title: "sleep well", priority: 2)
+
+    db[:tasks].insert(name: "Jane", title: "be cool", priority: 2)
+  end
+end

data/spec/spec_helper.rb

@@ -1,49 +1,27 @@
 # encoding: utf-8
 
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  require 'coveralls'
+# this is needed for guard to work, not sure why :(
+require "bundler"
+Bundler.setup
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name 'spec:unit'
-
-    add_filter 'config'
-    add_filter 'lib/rom/support'
-    add_filter 'spec'
-  end
+if RUBY_ENGINE == "rbx"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
 end
 
-require 'devtools/spec_helper'
-
 require 'rom'
+require 'rom/adapter/memory'
 
-require 'bogus/rspec'
-
-include ROM
-include SpecHelper
-include Morpher::NodeHelpers
-
-TEST_ENV = Environment.setup(test: 'memory://test') do
-  schema do
-    base_relation :users do
-      repository :test
+root = Pathname(__FILE__).dirname
 
-      attribute :id,   Integer
-      attribute :name, String
+Dir[root.join('shared/*.rb').to_s].each { |f| require f }
 
-      key :id
-    end
+RSpec.configure do |config|
+  config.before do
+    @constants = Object.constants
   end
 
-  mapping do
-    relation(:users) do
-      model mock_model(:id, :name)
-      map :id, :name
-    end
+  config.after do
+    (Object.constants - @constants).each { |name| Object.send(:remove_const, name) }
   end
 end

data/spec/unit/rom/adapter_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe ROM::Adapter do
+  before do
+    class TestAdapter < ROM::Adapter
+      def self.schemes
+        [:test_scheme]
+      end
+
+      def initialize(uri); end
+
+      ROM::Adapter.register(self)
+    end
+  end
+
+  describe '.setup' do
+    it 'sets up connection based on a uri' do
+      adapter = ROM::Adapter.setup("test_scheme::memory")
+
+      expect(adapter).to be_instance_of(TestAdapter)
+    end
+
+    it 'raises an exception if the scheme is not supported' do
+      expect {
+        ROM::Adapter.setup("bogus:///non-existent")
+      }.to raise_error(ArgumentError, '"bogus:///non-existent" uri is not supported')
+    end
+  end
+
+  describe '.[]' do
+    it "looks up and return the adapter class for the given schema" do
+      expect(ROM::Adapter[:test_scheme]).to eq TestAdapter
+    end
+  end
+
+  describe 'Registration order' do
+    it "prefers the last-defined adapter" do
+      class OrderTestFirst < TestAdapter
+        def self.schemes
+          [:order_test]
+        end
+
+        ROM::Adapter.register(self)
+      end
+
+      adapter = ROM::Adapter.setup("order_test::memory")
+      expect(adapter).to be_instance_of(OrderTestFirst)
+
+      class OrderTestSecond < OrderTestFirst
+        ROM::Adapter.register(self)
+      end
+
+      adapter = ROM::Adapter.setup("order_test::memory")
+
+      expect(adapter).to be_instance_of(OrderTestSecond)
+    end
+  end
+
+end