dry-system 0.5.0

data/spec/unit/container/finalize_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Dry::System::Container, '.finalize' do
+  subject(:system) { Test::App }
+
+  let(:db) { spy(:db) }
+
+  before do
+    Test.const_set(:DB, db)
+
+    module Test
+      class App < Dry::System::Container
+        configure do |config|
+          config.root = SPEC_ROOT.join('fixtures/test')
+        end
+
+        finalize(:db) do
+          register(:db, Test::DB)
+
+          init do
+            db.establish_connection
+          end
+
+          start do
+            db.load
+          end
+
+          stop do
+            db.close_connection
+          end
+        end
+      end
+    end
+  end
+
+  describe '#init' do
+    it 'calls init function' do
+      system.booter.(:db).init
+      expect(db).to have_received(:establish_connection)
+    end
+  end
+
+  describe '#start' do
+    it 'calls start function' do
+      system.booter.(:db).start
+      expect(db).to have_received(:load)
+    end
+  end
+
+  describe '#stop' do
+    it 'calls stop function' do
+      system.booter.(:db).stop
+      expect(db).to have_received(:close_connection)
+    end
+  end
+
+  specify 'boot triggers init' do
+    system.booter.boot(:db)
+
+    expect(db).to have_received(:establish_connection)
+    expect(db).to_not have_received(:load)
+  end
+
+  specify 'boot! triggers init + start' do
+    system.booter.boot!(:db)
+
+    expect(db).to have_received(:establish_connection)
+    expect(db).to have_received(:load)
+  end
+
+  specify 'booter returns cached lifecycle objects' do
+    expect(system.booter.(:db)).to be(system.booter.(:db))
+  end
+
+  specify 'lifecycle triggers are called only once' do
+    system.booter.boot!(:db)
+    system.booter.boot!(:db)
+
+    system.booter.boot(:db)
+    system.booter.boot(:db)
+
+    expect(db).to have_received(:establish_connection).exactly(1)
+    expect(db).to have_received(:load).exactly(1)
+
+    expect(system.booter.(:db).statuses).to eql(%i[init start])
+  end
+end

data/spec/unit/container/import_spec.rb

@@ -0,0 +1,70 @@
+require 'dry/system/container'
+
+RSpec.describe Dry::System::Container, '.import' do
+  subject(:app) { Class.new(Dry::System::Container) }
+
+  let(:db) do
+    Class.new(Dry::System::Container) do
+      register(:users, %w(jane joe))
+    end
+  end
+
+  shared_examples_for 'an extended container' do
+    it 'imports one container into another' do
+      expect(app.key?('persistence.users')).to be(false)
+
+      app.finalize!
+
+      expect(app['persistence.users']).to eql(%w(jane joe))
+    end
+  end
+
+  context 'when a container has a name' do
+    before do
+      db.configure { |c| c.name = :persistence }
+      app.import(db)
+    end
+
+    it_behaves_like 'an extended container'
+  end
+
+  context 'when container does not have a name' do
+    before do
+      app.import(persistence: db)
+    end
+
+    it_behaves_like 'an extended container'
+  end
+
+  describe 'import module' do
+    it 'loads system when it was not loaded in the imported container yet' do
+      class Test::Other < Dry::System::Container
+        configure do |config|
+          config.root = SPEC_ROOT.join('fixtures/import_test').realpath
+        end
+
+        load_paths!('lib')
+      end
+
+      class Test::Container < Dry::System::Container
+        configure do |config|
+          config.root = SPEC_ROOT.join('fixtures/test').realpath
+        end
+
+        load_paths!('lib')
+
+        import other: Test::Other
+      end
+
+      module Test
+        Import = Container.injector
+      end
+
+      class Test::Foo
+        include Test::Import['other.test.bar']
+      end
+
+      expect(Test::Foo.new.bar).to be_instance_of(Test::Bar)
+    end
+  end
+end

data/spec/unit/container/injector_spec.rb

@@ -0,0 +1,29 @@
+require "dry/system/container"
+
+RSpec.describe Dry::System::Container, ".injector" do
+  context "injector_options provided" do
+    it "builds an injector with the provided options" do
+      Test::Foo = Class.new
+
+      Test::Container = Class.new(Dry::System::Container) do
+        register "foo", Test::Foo.new
+      end
+
+      Test::Inject = Test::Container.injector(strategies: {
+        default: Dry::AutoInject::Strategies::Args,
+        australian: Dry::AutoInject::Strategies::Args
+      })
+
+      injected_class = Class.new do
+        include Test::Inject.australian["foo"]
+      end
+
+      obj = injected_class.new
+      expect(obj.foo).to be_a Test::Foo
+
+      another = Object.new
+      obj = injected_class.new(another)
+      expect(obj.foo).to eq another
+    end
+  end
+end

data/spec/unit/container_spec.rb

@@ -0,0 +1,165 @@
+require 'dry/system/container'
+
+RSpec.describe Dry::System::Container do
+  subject(:container) { Test::Container }
+
+  context 'with default core dir' do
+    before do
+      class Test::Container < Dry::System::Container
+        configure do |config|
+          config.root = SPEC_ROOT.join('fixtures/test').realpath
+        end
+
+        load_paths!('lib')
+      end
+
+      module Test
+        Import = Container.injector
+      end
+    end
+
+    describe '.require' do
+      it 'requires a single file' do
+        container.require(Pathname('lib/test/models'))
+
+        expect(Test.const_defined?(:Models)).to be(true)
+      end
+
+      it 'requires many files when glob pattern is passed' do
+        container.require(Pathname('lib/test/models/*.rb'))
+
+        expect(Test::Models.const_defined?(:User)).to be(true)
+        expect(Test::Models.const_defined?(:Book)).to be(true)
+      end
+    end
+
+    describe '.require_component' do
+      it 'requires component file' do
+        component = container.component('test/foo')
+        required = false
+        container.require_component(component) do
+          required = true
+        end
+        expect(required).to be(true)
+      end
+
+      it 'raises when file does not exist' do
+        component = container.component('test/missing')
+        expect { container.require_component(component) }.to raise_error(
+          Dry::System::FileNotFoundError, /test\.missing/
+        )
+      end
+    end
+
+    describe '.load_component' do
+      it 'loads and registers systems from configured load paths' do
+        container.load_component('test.foo')
+
+        expect(Test.const_defined?(:Foo)).to be(true)
+        expect(Test.const_defined?(:Dep)).to be(true)
+
+        expect(Test::Foo.new.dep).to be_instance_of(Test::Dep)
+      end
+
+      it "raises an error if a system's file can't be found" do
+        expect { container.load_component('test.missing') }.to raise_error(
+          Dry::System::ComponentLoadError, /test\.missing/
+        )
+      end
+
+      it "is a no op if a matching system is already registered" do
+        container.register "test.no_matching_file", Object.new
+
+        expect { container.load_component("test.no_matching_file") }.not_to raise_error
+      end
+    end
+  end
+
+  describe '.boot' do
+    before do
+      class Test::Container < Dry::System::Container
+        configure do |config|
+          config.root = SPEC_ROOT.join('fixtures/lazytest').realpath
+        end
+
+        load_paths!('lib')
+      end
+    end
+
+    it 'lazy-boot a given system' do
+      container.boot(:bar)
+
+      expect(Test.const_defined?(:Bar)).to be(true)
+      expect(container.key?('test.bar')).to be(false)
+    end
+  end
+
+  describe '.boot!' do
+    shared_examples_for 'a booted system' do
+      it 'boots a given system and finalizes it' do
+        container.boot!(:bar)
+
+        expect(Test.const_defined?(:Bar)).to be(true)
+        expect(container['test.bar']).to eql('I was finalized')
+      end
+
+      it 'expects a symbol identifier matching file name' do
+        expect {
+          container.boot!('bar')
+        }.to raise_error(ArgumentError, 'component identifier "bar" must be a symbol')
+      end
+
+      it 'expects identifier to point to an existing boot file' do
+        expect {
+          container.boot!(:foo)
+        }.to raise_error(
+          ArgumentError,
+          'component identifier +foo+ is invalid or boot file is missing'
+        )
+      end
+    end
+
+    context 'with the default core dir' do
+      it_behaves_like 'a booted system' do
+        before do
+          class Test::Container < Dry::System::Container
+            configure do |config|
+              config.root = SPEC_ROOT.join('fixtures/test').realpath
+            end
+
+            load_paths!('lib')
+          end
+        end
+      end
+    end
+
+    context 'with a custom core dir' do
+      it_behaves_like 'a booted system' do
+        before do
+          class Test::Container < Dry::System::Container
+            configure do |config|
+              config.root = SPEC_ROOT.join('fixtures/other').realpath
+              config.system_dir = 'config'
+            end
+
+            load_paths!('lib')
+          end
+        end
+      end
+    end
+
+    it 'passes container to the finalizer block' do
+      class Test::Container < Dry::System::Container
+        configure { |c| c.name = :awesome }
+
+        finalize(:foo) do |container|
+          register(:w00t, container.config.name)
+        end
+      end
+
+      Test::Container.booter.(:foo)
+
+      expect(Test::Container[:w00t]).to be(:awesome)
+    end
+  end
+end

data/spec/unit/injector_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe Dry::System::Injector do
+  before do
+    class Test::Container < Dry::System::Container
+      configure do |config|
+        config.root = SPEC_ROOT.join('fixtures/test').realpath
+      end
+
+      load_paths! 'lib'
+    end
+
+    Test::Inject = Test::Container.injector
+  end
+
+  it 'supports args injection by default' do
+    obj = Class.new do
+      include Test::Inject['test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+  end
+
+  it 'supports args injection with explicit method' do
+    obj = Class.new do
+      include Test::Inject.args['test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+  end
+
+  it 'supports hash injection' do
+    obj = Class.new do
+      include Test::Inject.hash['test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+  end
+
+  it 'support kwargs injection' do
+    obj = Class.new do
+      include Test::Inject.kwargs['test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+  end
+
+  it 'allows injection strategies to be swapped' do
+    obj = Class.new do
+      include Test::Inject.kwargs.hash['test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+  end
+
+  it 'supports aliases' do
+    obj = Class.new do
+      include Test::Inject['test.dep', foo: 'test.dep']
+    end.new
+
+    expect(obj.dep).to be_a Test::Dep
+    expect(obj.foo).to be_a Test::Dep
+  end
+
+  context 'singleton' do
+    it 'supports injection' do
+      obj = Class.new do
+        include Test::Inject[foo: 'test.singleton_dep']
+      end.new
+
+      expect(obj.foo).to be_a Test::SingletonDep
+    end
+  end
+end

data/spec/unit/loader_spec.rb

@@ -0,0 +1,64 @@
+require 'dry/system/loader'
+require 'singleton'
+
+RSpec.describe Dry::System::Loader, '#call' do
+  shared_examples_for 'object loader' do
+    let(:instance) { loader.call }
+
+    context 'not singleton' do
+      it 'returns a new instance of the constant' do
+        expect(instance).to be_instance_of(constant)
+        expect(instance).not_to be(loader.call)
+      end
+    end
+
+    context 'singleton' do
+      before { constant.send(:include, Singleton) }
+
+      it 'returns singleton instance' do
+        expect(instance).to be(constant.instance)
+      end
+    end
+  end
+
+  context 'with a singular name' do
+    subject(:loader) { Dry::System::Loader.new('test/bar') }
+
+    let(:constant) { Test::Bar }
+
+    before do
+      module Test;class Bar;end;end
+    end
+
+    it_behaves_like 'object loader'
+  end
+
+  context 'with a plural name' do
+    subject(:loader) { Dry::System::Loader.new('test/bars') }
+
+    let(:constant) { Test::Bars }
+
+    before do
+      module Test;class Bars;end;end
+    end
+
+    it_behaves_like 'object loader'
+  end
+
+  context 'with a constructor accepting args' do
+    subject(:loader) { Dry::System::Loader.new('test/bar') }
+
+    before do
+      module Test
+        Bar = Struct.new(:one, :two)
+      end
+    end
+
+    it 'passes args to the constructor' do
+      instance = loader.call(1, 2)
+
+      expect(instance.one).to be(1)
+      expect(instance.two).to be(2)
+    end
+  end
+end