dry-system 0.7.3 → 0.8.0

data/spec/unit/container/config_spec.rb

@@ -1,38 +0,0 @@
-require 'dry/system/container'
-
-RSpec.describe Dry::System::Container, '.config' do
-  subject(:config) { Test::Container.config }
-  let(:configuration) { proc { } }
-
-  before do
-    class Test::Container < Dry::System::Container
-    end
-    Test::Container.configure(&configuration)
-  end
-
-  describe '#root' do
-    subject(:root) { config.root }
-
-    context 'no value' do
-      it 'defaults to pwd' do
-        expect(root).to eq Pathname.pwd
-      end
-    end
-
-    context 'string provided' do
-      let(:configuration) { proc { |config| config.root = '/tmp' } }
-
-      it 'coerces string paths to pathname' do
-        expect(root).to eq Pathname('/tmp')
-      end
-    end
-
-    context 'pathname provided' do
-      let(:configuration) { proc { |config| config.root = Pathname('/tmp') } }
-
-      it 'accepts the pathname' do
-        expect(root).to eq Pathname('/tmp')
-      end
-    end
-  end
-end

data/spec/unit/container/finalize_spec.rb

@@ -1,97 +0,0 @@
-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.init(:db)
-
-    expect(db).to have_received(:establish_connection)
-    expect(db).to_not have_received(:load)
-  end
-
-  specify 'start triggers init + start' do
-    system.booter.start(:db)
-
-    expect(db).to have_received(:establish_connection)
-    expect(db).to have_received(:load)
-  end
-
-  specify 'start raises error on undefined method or variable' do
-    expect {
-      system.finalize(:db) { oops('arg') }
-      system.booter.start(:db)
-    }.to raise_error(NoMethodError, /oops/)
-
-    expect {
-      system.finalize(:db) { oops }
-      system.booter.start(:db)
-    }.to raise_error(NameError, /oops/)
-  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.start(:db)
-    system.booter.start(:db)
-
-    system.booter.init(:db)
-    system.booter.init(: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

@@ -1,53 +0,0 @@
-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
-
-  it 'imports one container into another' do
-    app.import(persistence: db)
-
-    expect(app.key?('persistence.users')).to be(false)
-
-    app.finalize!
-
-    expect(app['persistence.users']).to eql(%w(jane joe))
-  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

@@ -1,29 +0,0 @@
-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

@@ -1,244 +0,0 @@
-require 'dry/system/container'
-require 'dry/system/stubs'
-
-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
-
-      shared_examples_for 'requireable' 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
-      end
-
-      it_behaves_like 'requireable'
-
-      context 'when already required' do
-        before do
-          Kernel.require('test/foo')
-        end
-
-        it_behaves_like 'requireable'
-      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
-
-      it 'returns for already registered components' do
-        component = container.component('test/foo')
-
-        registrar = -> {
-          container.register(component.identifier) { component.instance }
-        }
-
-        container.require_component(component, &registrar)
-
-        required = false
-        registrar = -> { required = true }
-        container.require_component(component, &registrar)
-        expect(required).to be(false)
-      end
-    end
-
-    describe '.load_component' do
-      it 'loads and registers systems from configured load paths' do
-        container.load_component('test.foo')
-
-        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 '.init' 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.init(:bar)
-
-      expect(Test.const_defined?(:Bar)).to be(true)
-      expect(container.key?('test.bar')).to be(false)
-    end
-  end
-
-  describe '.start' do
-    shared_examples_for 'a booted system' do
-      it 'boots a given system and finalizes it' do
-        container.start(: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.start('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.start(:foo)
-        }.to raise_error(
-          ArgumentError,
-          'component identifier +foo+ is invalid or boot file is missing'
-        )
-      end
-
-      describe "missmatch betwenn finalize name and registered component" do
-        it "raises a meaningful error" do
-          expect{
-            container.start(:hell)
-          }.to raise_error(Dry::System::ComponentFileMismatchError)
-        end
-      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
-
-  describe '.stub' do
-    let(:stubbed_car) do
-      instance_double(Test::Car, wheels_count: 5)
-    end
-
-    before do
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures/stubbing').realpath
-        end
-
-        load_paths!('lib')
-        auto_register!('lib')
-      end
-    end
-
-    describe 'with stubs disabled' do
-      it 'raises error when trying to stub frozen container' do
-        expect { container.stub('test.car', stubbed_car) }.to raise_error(NoMethodError, /stub/)
-      end
-    end
-
-    describe 'with stubs enabled' do
-      before do
-        container.enable_stubs!
-      end
-
-      it 'lazy-loads a component' do
-        expect(container[:db]).to be_instance_of(Test::DB)
-        container.finalize!
-        expect(container[:db]).to be_instance_of(Test::DB)
-      end
-
-      it 'allows to stub components' do
-        container.finalize!
-
-        expect(container['test.car'].wheels_count).to be(4)
-
-        container.stub('test.car', stubbed_car)
-
-        expect(container['test.car'].wheels_count).to be(5)
-      end
-    end
-  end
-end