rom 0.9.1 → 1.0.0.beta1

data/spec/unit/rom/environment_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+RSpec.describe ROM::Environment do
+  let(:environment) { ROM::Environment.new(*params) }
+  let(:params) { [] }
+  let(:gateways) { environment.gateways }
+  let(:gateways_map) { environment.gateways_map }
+
+  context 'with an adapter identifier' do
+    let(:params) { [:memory] }
+    
+    it 'configures the gateways hash' do
+      expect(gateways).to be_kind_of(Hash)
+      expect(gateways.keys).to eq([:default])
+      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
+    end
+    
+    it 'configures the gateways_map hash' do
+      expect(gateways_map).to be_kind_of(Hash)
+      expect(gateways_map.values).to eq([:memory])
+      expect(gateways_map.keys.first).to be_kind_of(ROM::Memory::Gateway)
+      expect(gateways_map.keys.first).to be(gateways[:default])
+    end
+  end
+  
+  context 'with a hash' do
+    let(:params) { [{default: :memory}] }
+
+    it 'configures the gateways hash' do
+      expect(gateways).to be_kind_of(Hash)
+      expect(gateways.keys).to eq([:default])
+      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
+    end
+    
+    it 'configures the gateways_map hash' do
+      expect(gateways_map).to be_kind_of(Hash)
+      expect(gateways_map.values).to eq([:memory])
+      expect(gateways_map.keys.first).to be_kind_of(ROM::Memory::Gateway)
+      expect(gateways_map.keys.first).to be(gateways[:default])
+    end
+  end
+  
+  context 'with multiple gateways' do
+    let(:params) { [{foo: :memory, default: :memory}] }
+    
+    it 'configures the gateways hash' do
+      expect(gateways).to be_kind_of(Hash)
+      expect(gateways.keys).to eq([:foo, :default])
+      expect(gateways[:default]).to be_kind_of(ROM::Memory::Gateway)
+      expect(gateways[:foo]).to be_kind_of(ROM::Memory::Gateway)
+      expect(gateways[:default]).not_to be(gateways[:foo])
+    end
+    
+    it 'configures the gateways_map hash' do
+      expect(gateways_map).to be_kind_of(Hash)
+      expect(gateways_map.values).to eq([:memory, :memory])
+      expect(gateways_map.keys.map(&:class)).to eq([ROM::Memory::Gateway, ROM::Memory::Gateway])
+      expect(gateways_map.keys).to match_array(gateways.values)
+    end
+  end
+  
+  context 'with settings' do
+    before do
+      module Test
+        class Gateway < ROM::Gateway
+          attr_reader :settings
+
+          def initialize settings = {}
+            @settings = settings
+          end
+        end
+      end
+      
+      ROM.register_adapter(:test, Test)
+    end
+
+    context 'as a hash' do
+      let(:params) { [{foo: [:test, "foo"], bar: [:test, ["bar"]]}] }
+    
+      it 'configures the gateway instance' do
+        expect(gateways.values.map(&:settings)).to match_array(["foo", "bar"])
+      end
+    end
+    
+    context 'as flat args' do
+      let(:params) { [:test, "foo"] }
+    
+      it 'configures the gateway instance' do
+        expect(gateways.values.map(&:settings)).to match_array(["foo"])
+      end
+    end
+  end
+  
+  context 'with a Gateway instance' do
+    before do
+      module Test
+        class Gateway < ROM::Gateway
+          attr_reader :settings
+
+          def initialize settings = {}
+            @settings = settings
+          end
+        end
+      end
+      
+      ROM.register_adapter(:test, Test)
+    end
+    
+    let(:gateway) { Test::Gateway.new }
+    let(:params) { [gateway] }
+    
+    it 'configures the gateways hash' do
+      expect(gateways).to be_kind_of(Hash)
+      expect(gateways.keys).to eq([:default])
+      expect(gateways[:default]).to be(gateway)
+    end
+    
+    it 'configures the gateways_map hash' do
+      expect(gateways_map).to be_kind_of(Hash)
+      expect(gateways_map).to be_empty
+    end
+  end
+end

data/spec/unit/rom/gateway_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe ROM::Gateway do
+
+  subject(:gateway) { Class.new(ROM::Gateway).new }
+
   describe '.setup' do
     it 'sets up a gateway based on a type' do
       gateway_class = Class.new(ROM::Gateway) do
@@ -82,9 +85,62 @@ describe ROM::Gateway do
 
   describe '#disconnect' do
     it 'does nothing' do
-      gateway_class = Class.new(ROM::Gateway)
-      gateway = gateway_class.new
       expect(gateway.disconnect).to be(nil)
     end
   end
+
+  describe '#logger' do
+    it 'does nothing' do
+      expect(gateway.logger).to be(nil)
+    end
+  end
+
+  describe '#use_logger' do
+    it 'does nothing' do
+      expect(gateway.use_logger).to be(nil)
+    end
+
+    it 'accepts parameters' do
+      params = [5, "mutations", "are", "nice"]
+
+      expect { gateway.use_logger(params) }.to_not raise_error
+    end
+  end
+
+  describe '#extend_command_class' do
+    it 'returns the class sent as 1st parameter' do
+      klass = Class.new.freeze
+
+      expect(gateway.extend_command_class(klass, "foo")).to eq(klass)
+    end
+  end
+
+  describe '.adapter' do
+    let(:gateway_class) { Class.new(ROM::Gateway) }
+
+    it 'gets/sets the adapter' do
+      expect { gateway_class.adapter :custom }
+        .to change { gateway_class.adapter }
+        .from(nil)
+        .to(:custom)
+    end
+  end
+
+  describe "#adapter" do
+    before { Test::CustomGateway = Class.new(ROM::Gateway) }
+
+    let(:gateway) { Test::CustomGateway.new }
+
+    it 'returns class adapter' do
+      Test::CustomGateway.adapter :custom
+      expect(gateway.adapter).to eql :custom
+    end
+
+    it 'requires the adapter to be defined' do
+      expect { gateway.adapter }.to raise_error(
+        ROM::MissingAdapterIdentifierError, /Test::CustomGateway/
+      )
+    end
+  end # describe #adapter
+
 end

data/spec/unit/rom/global_spec.rb

@@ -1,15 +1,18 @@
 require 'spec_helper'
 
 describe ROM do
-  describe '.setup' do
-    it 'allows passing in gateway instances' do
-      klass = Class.new(ROM::Gateway)
-      repo = klass.new
+  include_context 'container'
 
-      setup = ROM.setup(test: repo)
+  describe '.env' do
+    it 'is nil by default' do
+      container
 
-      expect(setup.gateways[:test]).to be(repo)
+      expect(ROM.env).to be(nil)
     end
-  end
 
+    it 'is assignable' do
+      ROM.env = container
+      expect(ROM.env).to be(container)
+    end
+  end
 end

data/spec/unit/rom/plugin_spec.rb

@@ -1,12 +1,10 @@
 require 'spec_helper'
 
 describe "ROM::PluginRegistry" do
-  subject(:env) { setup.finalize }
-
-  let(:setup) { ROM.setup(:memory) }
+  include_context 'container'
 
   before do
-    Test::EnvironmentPlugin = Module.new
+    Test::ConfigurationPlugin = Module.new
     Test::CommandPlugin     = Module.new
     Test::MapperPlugin      = Module.new
     Test::RelationPlugin    = Module.new do
@@ -16,11 +14,13 @@ describe "ROM::PluginRegistry" do
     end
 
     ROM.plugins do
-      register :registration, Test::EnvironmentPlugin, type: :environment
+      register :registration, Test::ConfigurationPlugin, type: :configuration
       register :publisher,    Test::CommandPlugin,     type: :command
       register :pager,        Test::RelationPlugin,    type: :relation
       register :translater,   Test::MapperPlugin,      type: :mapper
     end
+
+    configuration
   end
 
   around do |example|
@@ -29,45 +29,56 @@ describe "ROM::PluginRegistry" do
     ROM.instance_variable_set('@plugin_registry', orig_plugins)
   end
 
-  it "makes environment plugins available" do
-    expect(ROM.plugin_registry.environment[:registration].mod).to eq Test::EnvironmentPlugin
+  it "makes configuration plugins available" do
+    expect(ROM.plugin_registry.configuration[:registration].mod).to eq Test::ConfigurationPlugin
   end
 
   it "includes relation plugins" do
-    setup.relation(:users) do
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
       use :pager
     end
+    configuration.register_relation(users)
 
-    expect(env.relation(:users).plugged_in).to eq "a relation"
+    expect(container.relation(:users).plugged_in).to eq "a relation"
   end
 
   it "makes command plugins available" do
-    setup.relation(:users)
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
+    end
 
-    Class.new(ROM::Commands::Create[:memory]) do
+    create_user = Class.new(ROM::Commands::Create[:memory]) do
       relation :users
       register_as :create
       use :publisher
     end
 
-    expect(env.command(:users).create).to be_kind_of Test::CommandPlugin
+    configuration.register_relation(users)
+    configuration.register_command(create_user)
+
+    expect(container.command(:users).create).to be_kind_of Test::CommandPlugin
   end
 
   it "inclues plugins in mappers" do
-    setup.relation(:users)
-
-    Class.new(ROM::Mapper) do
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
+    end
+    translator = Class.new(ROM::Mapper) do
       relation :users
       register_as :translator
       use :translater
     end
 
-    expect(env.mappers[:users][:translator]).to be_kind_of Test::MapperPlugin
+    configuration.register_relation(users)
+    configuration.register_mapper(translator)
+
+    expect(container.mappers[:users][:translator]).to be_kind_of Test::MapperPlugin
   end
 
   it "restricts plugins to defined type" do
     expect {
-      setup.relation(:users) do
+      configuration.relation(:users) do
         use :publisher
       end
     }.to raise_error ROM::UnknownPluginError
@@ -86,11 +97,13 @@ describe "ROM::PluginRegistry" do
       end
     end
 
-    setup.relation(:users) do
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
       use :lazy
     end
+    configuration.register_relation(users)
 
-    expect(env.relation(:users)).to be_lazy
+    expect(container.relation(:users)).to be_lazy
   end
 
   it "respects adapter restrictions" do
@@ -110,22 +123,28 @@ describe "ROM::PluginRegistry" do
       end
     end
 
-    setup.relation(:users)
+    users = Class.new(ROM::Relation[:memory]) do
+      register_as :users
+    end
 
-    Class.new(ROM::Commands::Create[:memory]) do
+    create_user = Class.new(ROM::Commands::Create[:memory]) do
       relation :users
       register_as :create
       use :lazy
     end
 
-    Class.new(ROM::Commands::Update[:memory]) do
+    update_user = Class.new(ROM::Commands::Update[:memory]) do
       relation :users
       register_as :update
       use :lazy_command
     end
 
-    expect(env.command(:users).create).not_to be_kind_of Test::LazySQLPlugin
-    expect(env.command(:users).create).to be_kind_of Test::LazyPlugin
-    expect(env.command(:users).update).to be_kind_of Test::LazyMemoryPlugin
+    configuration.register_relation(users)
+    configuration.register_command(create_user)
+    configuration.register_command(update_user)
+
+    expect(container.command(:users).create).not_to be_kind_of Test::LazySQLPlugin
+    expect(container.command(:users).create).to be_kind_of Test::LazyPlugin
+    expect(container.command(:users).update).to be_kind_of Test::LazyMemoryPlugin
   end
 end

data/spec/unit/rom/plugins/relation/key_inference_spec.rb

@@ -0,0 +1,27 @@
+require 'rom'
+require 'rom/memory'
+require 'rom/plugins/relation/key_inference'
+
+RSpec.describe ROM::Plugins::Relation::KeyInference do
+  subject(:relation) { relation_class.new([]) }
+
+  let(:relation_class) do
+    Class.new(ROM::Memory::Relation) do
+      use :key_inference
+
+      dataset :users
+    end
+  end
+
+  describe '#base_name' do
+    it 'returns dataset name by default' do
+      expect(relation.base_name).to be(:users)
+    end
+  end
+
+  describe '#foreign_key' do
+    it 'returns default value' do
+      expect(relation.foreign_key).to be(:user_id)
+    end
+  end
+end

data/spec/unit/rom/plugins/relation/view_spec.rb

@@ -0,0 +1,47 @@
+require 'rom'
+require 'rom/memory'
+require 'rom/plugins/relation/view'
+
+RSpec.describe ROM::Plugins::Relation::View do
+  subject(:relation) { relation_class.new([]) }
+
+  let(:relation_class) do
+    Class.new(ROM::Memory::Relation) do
+      use :view
+
+      view(:base, [:id, :name]) do
+        self
+      end
+
+      view(:ids, [:id]) do
+        self
+      end
+
+      view(:names, [:name]) do |id|
+        self
+      end
+    end
+  end
+
+  describe '#attributes' do
+    it 'returns base view attributes by default' do
+      expect(relation.attributes).to eql([:id, :name])
+    end
+
+    it 'returns attributes for a view' do
+      expect(relation.ids.attributes).to eql([:id])
+    end
+
+    it 'returns attributes for a view with args' do
+      expect(relation.names(1).attributes).to eql([:name])
+    end
+
+    it 'returns attributes for a curried view' do
+      expect(relation.names.attributes).to eql([:name])
+    end
+
+    it 'returns correct arity for a curried view' do
+      expect(relation.names.arity).to be(1)
+    end
+  end
+end