payload 0.1.0

data/spec/payload/container_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'payload/container'
+require 'payload/testing'
+
+describe Payload::Container do
+  include Payload::Testing
+
+  describe '#factory' do
+    it 'returns an object that responds to new' do
+      container = build_container
+        .service(:from_container) { |config| 'From container' }
+        .factory(:example) do |config|
+          "#{config[:from_new]} and #{config[:from_container]}"
+        end
+
+      result = container[:example].new(from_new: 'From new')
+
+      expect(result).to eq('From new and From container')
+    end
+  end
+
+  describe '#service' do
+    it 'returns a container with the given dependency defined' do
+      container = build_container
+        .service(:example) { |config| 'expected result' }
+
+      expect(container[:example]).to eq('expected result')
+    end
+
+    it "doesn't mutate the container" do
+      original = build_container
+      original.service(:example) { |config| 'expected result' }
+
+      expect { original[:example] }
+        .to raise_error(Payload::UndefinedDependencyError)
+    end
+
+    it 'provides access to other dependencies' do
+      container = build_container
+        .service(:example) { |config| "got #{config[:dependency].inspect}" }
+        .service(:dependency) { |config| 'expected result' }
+
+      expect(container[:example]).to eq('got "expected result"')
+    end
+  end
+
+  describe '#decorate' do
+    it 'returns a container with the given dependency decorated' do
+      container = build_container
+        .service(:example) { |config| 'expected component' }
+        .decorate(:example) do |component, config|
+          "decorated #{component.inspect} with #{config[:param].inspect}"
+        end
+        .decorate(:example) { |component, config| "redecorated #{component}" }
+        .service(:param) { |config| 'expected param' }
+
+      expect(container[:example]).to eq(
+        'redecorated decorated "expected component" with "expected param"'
+      )
+    end
+
+    it "doesn't mutate the container" do
+      original = build_container
+        .service(:example) { |config| 'expected component' }
+      original
+        .decorate(:example) { |component, config| "decorated #{component}" }
+
+      expect(original[:example]).to eq('expected component')
+    end
+
+    it 'raises an exception for an unknown dependency' do
+      container = build_container
+
+      expect { container.decorate(:anything) }
+        .to raise_error(Payload::UndefinedDependencyError)
+    end
+  end
+
+  describe '#export' do
+    it 'allows access to exported definitions' do
+      exports = build_container.
+        service(:example) { |config| 'expected component' }.
+        export(:example)
+      container = build_container.import(exports)
+
+      expect(container[:example]).to eq('expected component')
+    end
+
+    it 'does not allow access to private definitions' do
+      exports = build_container.
+        service(:exported) { |config| 'exported' }.
+        service(:private) { |config| 'private' }.
+        export(:exported)
+      container = build_container.import(exports)
+
+      expect { container[:private] }.
+        to raise_error(Payload::UndefinedDependencyError)
+    end
+
+    it 'allows exported definitions to reference private definitions' do
+      exports = build_container.
+        service(:exported) { |config| "got #{config[:private].inspect}" }.
+        service(:private) { |config| 'private' }.
+        export(:exported)
+      container = build_container.import(exports)
+
+      expect(container[:exported]).to eq('got "private"')
+    end
+
+    it 'exposes local definitions to private definitions' do
+      exports = build_container.
+        service(:exported) { |config| "got #{config[:local].inspect}" }.
+        export(:exported)
+      container = build_container.
+        service(:local) { |config| 'local' }.
+        import(exports)
+
+      expect(container[:exported]).to eq('got "local"')
+    end
+  end
+
+  describe '#import' do
+    it 'returns a new container with the given definitions' do
+      first_export =
+        Payload::ServiceDefinition.new(lambda { |config| 'one' })
+      second_export =
+        Payload::ServiceDefinition.new(lambda { |config| 'two' })
+      definitions = Payload::DefinitionList.
+        new.
+        add(:one, first_export).
+        add(:two, second_export)
+      container = build_container.
+        service(:original) { |config| 'original' }.
+        import(definitions)
+
+      expect(container[:original]).to eq('original')
+      expect(container[:one]).to eq('one')
+      expect(container[:two]).to eq('two')
+    end
+  end
+
+  describe '#[]' do
+    context 'with an undefined dependency' do
+      it 'raises an undefined dependency error' do
+        container = build_container
+
+        expect { container[:undefined] }.to raise_error(
+          Payload::UndefinedDependencyError,
+          'No definition for dependency: undefined'
+        )
+      end
+    end
+  end
+end

data/spec/payload/controller_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'payload/controller'
+
+describe Payload::Controller do
+  describe '#dependencies' do
+    it 'looks for dependencies from the Rack environment' do
+      dependency = double('dependency')
+      container = { lookup: dependency }
+      env = { dependencies: container }
+      request = double('request', env: env)
+      controller_class = Class.new do
+        include Payload::Controller
+
+        def initialize(request)
+          @request = request
+        end
+
+        def lookup
+          dependencies[:lookup]
+        end
+
+        private
+
+        attr_reader :request
+      end
+
+      result = controller_class.new(request).lookup
+
+      expect(result).to eq(dependency)
+    end
+  end
+end

data/spec/payload/decorator_chain_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'payload/decorator_chain'
+
+describe Payload::DecoratorChain do
+  describe '#decorate' do
+    it 'applies a series of decorators to a component' do
+      chain = Payload::DecoratorChain
+        .new
+        .add(lambda { |base, config| "Decorated #{base} with #{config[:one]}" })
+        .add(lambda { |base, config| "#{base} and #{config[:two]}" })
+
+      result = chain.decorate('original', one: 'one', two: 'two')
+
+      expect(result).to eq('Decorated original with one and two')
+    end
+
+    it "doesn't mutate" do
+      chain = Payload::DecoratorChain
+        .new
+        .add(lambda { |base, config| "Decorated #{base}" })
+
+      chain.add(lambda { |base, config| 'Unreferenced decorator' })
+
+      result = chain.decorate('original', {})
+
+      expect(result).to eq('Decorated original')
+    end
+  end
+end

data/spec/payload/definition_list_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'payload/definition_list'
+
+describe Payload::DefinitionList do
+  describe '#add' do
+    it 'adds a dependency to be found later' do
+      definition = double('definition')
+      definition_list = Payload::DefinitionList.new
+
+      defined = definition_list.add(:example, definition)
+
+      expect(defined.find(:example)).to eq(definition)
+    end
+
+    it 'does not mutate the list' do
+      definition = double('definition')
+      definition_list = Payload::DefinitionList.new
+
+      definition_list.add(:example, definition)
+
+      expect { definition_list.find(:example) }.
+        to raise_error(Payload::UndefinedDependencyError)
+    end
+  end
+
+  describe '#export' do
+    it 'returns a new list with only the given dependencies' do
+      definition_list = Payload::DefinitionList.
+        new.
+        add(:one, 'first').
+        add(:two, 'second').
+        add(:three, 'third')
+      first_exported = double('exported_first')
+      allow(Payload::ExportedDefinition).
+        to receive(:new).
+        with('first', definition_list).
+        and_return(first_exported)
+      second_exported = double('exported_second')
+      allow(Payload::ExportedDefinition).
+        to receive(:new).
+        with('second', definition_list).
+        and_return(second_exported)
+
+      exported = definition_list.export([:one, :two])
+
+      expect(exported.find(:one)).to eq(first_exported)
+      expect(exported.find(:two)).to eq(second_exported)
+      expect { exported.find(:three) }.
+        to raise_error(Payload::UndefinedDependencyError)
+    end
+  end
+
+  describe '#import' do
+    it 'returns a new list with old dependencies and the given dependencies' do
+      left = Payload::DefinitionList.new.add(:one, 'first')
+      right = Payload::DefinitionList.new.add(:two, 'second')
+      merged = left.import(right)
+
+      expect(merged.find(:one)).to eq('first')
+      expect(merged.find(:two)).to eq('second')
+    end
+  end
+
+  describe '#find' do
+    it 'raises for an unknown definition' do
+      definition_list = Payload::DefinitionList.new
+
+      expect { definition_list.find(:example) }.
+        to raise_error(Payload::UndefinedDependencyError)
+    end
+
+    it 'returns an existing definition' do
+      definition = double('definition')
+      definition_list =
+        Payload::DefinitionList.new.add(:example, definition)
+
+      expect(definition_list.find(:example)).to eq(definition)
+    end
+  end
+end

data/spec/payload/exported_definition_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'payload/exported_definition'
+require 'payload/testing'
+
+describe Payload::ExportedDefinition do
+  include Payload::Testing
+
+  describe '#resolve' do
+    it 'finds definitions from both the source and argument containers' do
+      block = lambda do |container|
+        "Ran with #{container[:private]} " \
+          "and #{container[:container]}"
+      end
+
+      private_definition =
+        Payload::ServiceDefinition.new(lambda { |config| 'private' })
+      private_definitions = Payload::DefinitionList.
+        new.
+        add(:private, private_definition)
+      container = build_container.service(:container) { |config| 'container' }
+      definition = Payload::ServiceDefinition.new(block)
+      exported_definition =
+        Payload::ExportedDefinition.new(definition, private_definitions)
+
+      result = exported_definition.resolve(container)
+
+      expect(result).to eq('Ran with private and container')
+    end
+  end
+end

data/spec/payload/factory_definition_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'payload/factory_definition'
+require 'payload/testing'
+
+describe Payload::FactoryDefinition do
+  include Payload::Testing
+
+  describe '#resolve' do
+    it 'returns an object that responds to new' do
+      block = lambda do |config|
+        "#{config[:from_new]} and #{config[:from_container]}"
+      end
+      container = build_container
+        .service(:from_container) { 'From container' }
+      definition = Payload::FactoryDefinition.new(block)
+
+      result = definition.resolve(container).new(from_new: 'From new')
+
+      expect(result).to eq('From new and From container')
+    end
+  end
+
+  describe '#decorate' do
+    it 'returns a decorated object' do
+      block = lambda do |config|
+        "#{config[:from_new]} and #{config[:from_container]}"
+      end
+      first = lambda do |component, config|
+        "Decorated #{component.inspect} with #{config[:from_new]}"
+      end
+      second = lambda do |component, config|
+        "#{component} and #{config[:other]}"
+      end
+      container = build_container
+        .service(:from_container) { 'From container' }
+        .service(:other) { 'Other' }
+      definition = Payload::FactoryDefinition
+        .new(block)
+        .decorate(first)
+        .decorate(second)
+
+      result = definition.resolve(container).new(from_new: 'From new')
+
+      expect(result).to eq(
+        'Decorated "From new and From container" with From new and Other'
+      )
+    end
+  end
+end

data/spec/payload/factory_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'payload/factory'
+require 'payload/decorator_chain'
+require 'payload/testing'
+
+describe Payload::Factory do
+  include Payload::Testing
+
+  describe '#new' do
+    it 'instantiates the dependency' do
+      decorator = lambda do |component, config|
+        "Decorated #{component.inspect} " \
+          "with #{config[:from_container]} " \
+          "and #{config[:from_new]}"
+      end
+      block = lambda do |config|
+        "Component with #{config[:from_container]} and #{config[:from_new]}"
+      end
+      decorators = Payload::DecoratorChain.new.add(decorator)
+      container = build_container
+        .service(:from_container) { 'From container' }
+      factory = Payload::Factory.new(container, block, decorators)
+
+      result = factory.new(from_new: 'From new')
+
+      expect(result).to eq(
+        'Decorated "Component with From container and From new" ' \
+          'with From container and From new'
+      )
+    end
+
+    it 'instantiates the dependency without arguments' do
+      block = lambda do |config|
+        "Component with #{config[:from_container]}"
+      end
+      decorators = Payload::DecoratorChain.new
+      container = build_container
+        .service(:from_container) { 'From container' }
+      factory = Payload::Factory.new(container, block, decorators)
+
+      result = factory.new
+
+      expect(result).to eq('Component with From container')
+    end
+  end
+end

data/spec/payload/mutable_container_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'payload/mutable_container'
+
+describe Payload::MutableContainer do
+  %w(service factory decorate).each do |method_name|
+    describe "##{method_name}" do
+      it "redefines the container with a #{method_name}" do
+        base_container = double('base_container')
+        modified_container = double('modified_container')
+        allow(base_container).
+          to receive(method_name).
+          with(:example).
+          and_return(modified_container)
+        container = Payload::MutableContainer.new(base_container)
+
+        result = container.send(method_name, :example)
+
+        expect(container.build).to eq(modified_container)
+        expect(result).to eq(container)
+      end
+    end
+  end
+
+  describe '#respond_to_missing?' do
+    context 'for a method defined on its base container' do
+      it 'returns true' do
+        base_container = double('base_container')
+        allow(base_container).to receive(:example)
+        container = Payload::MutableContainer.new(base_container)
+
+        expect(container.method(:example)).not_to be_nil
+      end
+    end
+
+    context 'for an undefined method' do
+      it 'returns false' do
+        base_container = double('base_container')
+        container = Payload::MutableContainer.new(base_container)
+
+        expect { container.method(:unknown) }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe '#export' do
+    it 'adds dependencies to the export list' do
+      exports = double('exports')
+      immutable_container = double('base_container')
+      allow(immutable_container).
+        to receive(:service).
+        and_return(immutable_container)
+      allow(immutable_container).
+        to receive(:export).
+        with(:one, :two, :three).
+        and_return(exports)
+      container = Payload::MutableContainer.new(immutable_container)
+
+      container.service(:one)
+      container.service(:two)
+      container.service(:three)
+      container.service(:unexported)
+      container.export(:one, :two)
+      container.export(:three)
+
+      expect(container.exports).to eq(exports)
+    end
+  end
+end