rohbau 0.1.0

data/lib/rohbau/shared_specs/default_gateway.rb

@@ -0,0 +1,305 @@
+module Rohbau
+  module SharedSpecs
+    DefaultGateway = Proc.new do
+
+      describe 'add' do
+        it 'inserts an entity' do
+          subject.add entity
+          assert_equal 1, subject.size
+        end
+
+        it 'returns a copied entity' do
+          new_entity = subject.add entity
+          refute_equal new_entity.object_id, entity.object_id
+        end
+
+        it 'assigns a string uid to the entity' do
+          new_entity = subject.add entity
+          refute_nil new_entity.uid
+          assert_kind_of String, new_entity.uid
+        end
+
+        it 'raises an error if entity is nil' do
+          assert_raises ArgumentError do
+            subject.add nil
+          end
+        end
+
+        it 'raises an error if entity has already an uid' do
+          entity.uid = '45'
+          assert_raises ArgumentError do
+            subject.add entity
+          end
+        end
+      end
+
+      describe 'bulk_add' do
+        it 'inserts a collection of entities' do
+          entities = [entity, updated_entity]
+
+          subject.bulk_add entities
+          assert_equal 2, subject.size
+        end
+
+        it 'returns a collection copied entities' do
+          entities = [entity]
+
+          new_entities = subject.bulk_add entities
+          refute_equal new_entities[0].object_id, entities[0].object_id
+        end
+
+        it 'assigns a string uid to the entities' do
+          entities = [entity]
+
+          new_entities = subject.bulk_add entities
+          refute_nil new_entities[0].uid
+          assert_kind_of String, new_entities[0].uid
+        end
+
+        it 'raises an error if entities are nil' do
+          assert_raises ArgumentError do
+            subject.bulk_add [nil]
+          end
+        end
+
+        it 'raises an error if entity has already an uid' do
+          entity.uid = '45'
+          assert_raises ArgumentError do
+            subject.bulk_add [entity]
+          end
+        end
+      end
+
+      describe 'all' do
+
+        it 'returns an empty array' do
+          assert_equal [], subject.all
+        end
+
+        it 'returns added entities' do
+          entities = [entity, updated_entity].map do |e|
+            subject.add e
+          end
+
+          assert_equal entities, subject.all
+        end
+
+      end
+
+      describe 'get' do
+        it 'returns nothing if uid not found' do
+          assert_equal nil, subject.get('23')
+        end
+
+        it 'raises an error if uid is an invalid value' do
+          ["", nil, 22].each do |value|
+            assert_raises ArgumentError do
+              subject.get(value)
+            end
+          end
+        end
+
+        it 'returns the entity for a known uid' do
+          entities = [entity, updated_entity].map do |e|
+            subject.add e
+          end
+
+          assert_equal entities.first,  subject.get(entities.first.uid)
+          assert_equal entities.last,   subject.get(entities.last.uid)
+        end
+      end
+
+      describe 'entity duplication' do
+        it 'returns a copy of the stored entity on get' do
+          uid = subject.add(entity).uid
+
+          e = subject.get(uid)
+          e.uid = uid + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'returns a copy of the stored entity on add' do
+          result = subject.add(entity)
+          uid = result.uid
+
+          result.uid = uid + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'adds a copy as stored entity on add' do
+          uid = subject.add(entity).uid
+
+          entity.uid = uid  + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'returns copies of the stored entities on all' do
+          uid = subject.add(entity).uid
+
+          e = subject.all.first
+          e.uid = uid + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'returns a copy of the stored entity on update' do
+          stored = subject.add(entity)
+          uid = stored.uid
+
+          result = subject.update(stored)
+
+          result.uid = uid + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'returns copies of the stored entities on bulk_add' do
+          entities = [entity]
+
+          results = subject.bulk_add(entities)
+          uid = results[0].uid
+
+          results[0].uid = uid + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+
+        it 'adds copies as stored entities on bulk_add' do
+          entities = [entity]
+
+          results = subject.bulk_add(entities)
+          uid = results[0].uid
+
+          entity.uid = uid  + '1'
+
+          assert_equal uid, subject.get(uid).uid
+        end
+      end
+
+      describe 'update' do
+        it 'fails if nil is given' do
+          assert_raises ArgumentError do
+            subject.update(nil)
+          end
+        end
+
+        it 'fails if uid is nil' do
+          assert_raises ArgumentError do
+            entity.uid = nil
+            subject.update(entity)
+          end
+        end
+
+        it 'fails if uid is not known' do
+          assert_raises ArgumentError do
+            entity.uid = "22"
+            subject.update(entity)
+          end
+        end
+
+        it 'updates and returns the entity' do
+          added_entity = subject.add(entity)
+          uid = added_entity.uid
+
+          updated_entity.uid = uid
+          result = subject.update(updated_entity)
+
+          assert_equal subject.get(uid),  result
+          refute_equal added_entity,      result
+        end
+      end
+
+      describe 'delete' do
+        it 'fails if nil is given' do
+          assert_raises ArgumentError do
+            subject.delete(nil)
+          end
+        end
+
+        it 'fails if uid is not known' do
+          assert_raises ArgumentError do
+            subject.delete('22')
+          end
+        end
+
+        it 'deletes the entity' do
+          uid = subject.add(entity).uid
+
+          assert subject.get(uid)
+
+          subject.delete(uid)
+
+          refute subject.get(uid)
+        end
+
+        it 'returns deleted entity' do
+          uid = subject.add(entity).uid
+
+          persisted_entity = subject.get(uid)
+
+          assert_equal persisted_entity, subject.delete(uid)
+        end
+
+        it 'removes the entity from the collection' do
+          uid = subject.add(entity).uid
+          subject.add(updated_entity)
+
+          subject.delete(uid)
+
+          assert_equal 1, subject.all.size
+          refute_includes subject.all.map(&:uid), uid
+        end
+      end
+
+      describe 'bulk_delete' do
+        it 'raises an error if nil is given' do
+          assert_raises ArgumentError do
+            subject.bulk_delete([nil])
+          end
+        end
+
+        it 'raises an error if uid is not known' do
+          assert_raises ArgumentError do
+            subject.bulk_delete(['22'])
+          end
+        end
+
+        it 'deletes the entities' do
+          uid  = subject.add(entity).uid
+          uids = [uid]
+
+          assert subject.get(uid)
+
+          subject.bulk_delete(uids)
+
+          refute subject.get(uid)
+        end
+
+        it 'returns deleted entity' do
+          uid = subject.add(entity).uid
+          uids = [uid]
+
+          persisted_entity = subject.get(uid)
+
+          assert_equal persisted_entity, subject.bulk_delete(uids)[0]
+        end
+
+        it 'removes the entity from the collection' do
+          uid = subject.add(entity).uid
+          uids = [uid]
+
+          subject.add(updated_entity).uid
+
+          subject.bulk_delete(uids)
+
+          assert_equal 1, subject.all.size
+          refute_includes subject.all.map(&:uid), uid
+        end
+      end
+
+    end
+  end
+end

data/lib/rohbau/use_case.rb

@@ -0,0 +1,25 @@
+require 'bound'
+
+module Rohbau
+
+  class UseCase
+
+    def self.call(request, input = nil)
+      args = [request]
+      args << input if input
+
+      new(*args).call
+    end
+
+    def initialize(request)
+      @request = request
+    end
+
+    protected
+
+    def service(service_name)
+      @request.services.public_send service_name
+    end
+  end
+
+end

data/lib/rohbau/version.rb

@@ -0,0 +1,3 @@
+module Rohbau
+  VERSION = "0.1.0"
+end

data/lib/rohbau.rb

@@ -0,0 +1,5 @@
+require "rohbau/version"
+
+module Rohbau
+  # Your code goes here...
+end

data/rohbau.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rohbau/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rohbau"
+  spec.version       = Rohbau::VERSION
+  spec.authors       = [
+    "Jakob Holderbaum",
+    "Peter Suschlik",
+    "Dax Defranco",
+    "Andreas Busold",
+    "Jan Owiesniak"
+  ]
+  spec.email         = [
+    "rohbau@jakob.io",
+    "ps@neopoly.de",
+    "dd@neopoly.de",
+    "ab@neopoly.de",
+    "jo@neopoly.de"
+  ]
+  spec.summary       = %q{Provides a set of patterns used in Domain Driven Design}
+  spec.homepage      = "http://www.neopoly.de/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thread_safe', '~> 0.3'
+  spec.add_dependency 'bound', '~> 2.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'minitest', '~> 5.4'
+  spec.add_development_dependency 'simplecov'
+end

data/spec/event_tube_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'rohbau/event_tube'
+
+describe Rohbau::EventTube do
+  let(:tube)        { Class.new(Rohbau::EventTube)}
+  let(:event_class) { Struct.new(:arg1) }
+  let(:event)       { event_class.new(22) }
+
+  describe 'without subscribers' do
+    it 'can publish' do
+      tube.publish :my_event, event
+    end
+  end
+
+  describe 'with subscriber' do
+    before do
+      @calls = []
+      tube.subscribe :my_event do |event|
+        @calls << event
+      end
+    end
+
+    it 'can publish' do
+      tube.publish :my_event, event
+      assert_equal [event], @calls
+    end
+  end
+
+  describe 'with multiple subscribers' do
+    before do
+      @calls = []
+
+      tube.subscribe :my_event do |event|
+        @calls << event
+      end
+
+      tube.subscribe :my_event do |event|
+        @calls << event
+      end
+    end
+
+    it 'processes them all on publish' do
+      tube.publish :my_event, event
+      assert_equal [event,event], @calls
+    end
+  end
+
+  describe 'reset' do
+    before do
+      @calls = []
+      tube.subscribe :my_event do |event|
+        @calls << event
+      end
+    end
+
+    it 'does nothin on publish' do
+      tube.reset
+      tube.publish :my_event, event
+      assert_equal [], @calls
+    end
+  end
+
+end

data/spec/runtime_loader_spec.rb

@@ -0,0 +1,72 @@
+require 'minitest/mock'
+
+require 'spec_helper'
+require 'rohbau/runtime_loader'
+
+describe Rohbau::RuntimeLoader do
+  ExampleClass = Class.new
+
+  let(:my_runtime_loader) do
+    Class.new(Rohbau::RuntimeLoader)
+  end
+
+  before do
+    @initializer_result = my_runtime_loader.new(ExampleClass)
+  end
+
+  it 'starts up a given class' do
+    assert_kind_of ExampleClass, my_runtime_loader.instance
+  end
+
+  it 'has a running predicate after init' do
+    assert_predicate my_runtime_loader, :running?
+  end
+
+  it 'returns the loader class on new' do
+    assert_equal my_runtime_loader, @initializer_result
+  end
+
+  describe 'termination' do
+    it 'has no running predicate afterwards' do
+      my_runtime_loader.terminate
+      refute_predicate my_runtime_loader, :running?
+    end
+
+    it 'sets instance to nil' do
+      my_runtime_loader.terminate
+      assert_equal nil, my_runtime_loader.instance
+    end
+
+    it 'calls terminate on instance, if it responds to it' do
+      mocked_instance = inject_mocked_instance_into_my_runtime_loader
+      mocked_instance.expect(:terminate, nil)
+
+      my_runtime_loader.terminate
+
+      assert mocked_instance.verify
+    end
+
+    it 'is initializeable after termination' do
+      my_runtime_loader.terminate
+      my_runtime_loader.new(ExampleClass)
+    end
+  end
+
+  it 'does not instanciate twice' do
+    instance = my_runtime_loader.instance
+
+    my_runtime_loader.new(ExampleClass)
+
+    assert_same instance, my_runtime_loader.instance
+  end
+
+
+  def inject_mocked_instance_into_my_runtime_loader
+    instance = MiniTest::Mock.new
+
+    def my_runtime_loader.instance
+      @__mocked_instance
+    end
+    my_runtime_loader.instance_variable_set :@__mocked_instance, instance
+  end
+end

data/spec/service_factory_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'rohbau/service_factory'
+
+describe Rohbau::ServiceFactory do
+
+  let(:factory_class) do
+    Class.new(Rohbau::ServiceFactory)
+  end
+
+  let(:factory) do
+    factory_class.new(runtime)
+  end
+
+  let(:runtime) do
+    Object.new
+  end
+
+  it 'needs a runtime instance to get instanciated' do
+    raised = assert_raises RuntimeError do
+      factory_class.new(nil)
+    end
+
+    assert_match(/Runtime/, raised.message)
+  end
+
+  describe 'external dependency compliance' do
+    it 'is reached if there are none' do
+      assert_predicate factory_class, :external_dependencies_complied?
+    end
+
+    describe 'with external dependencies' do
+      before do
+        factory_class.external_dependencies :service1, :service2
+      end
+
+      it 'is not reached without any registered external service' do
+        refute_predicate factory_class, :external_dependencies_complied?
+      end
+
+      it 'is not reached with partially registers services' do
+        factory_class.register(:service1) {  }
+        refute_predicate factory_class, :external_dependencies_complied?
+      end
+
+      it 'is reached if all required dependencies are registered' do
+        factory_class.register(:service1) {  }
+        factory_class.register(:service2) {  }
+        assert_predicate factory_class, :external_dependencies_complied?
+      end
+    end
+  end
+
+  describe 'service registration' do
+    describe "with one service registered" do
+      before do
+        factory_class.register :test_service do
+          Struct.new(:a).new(22)
+        end
+      end
+
+      it 'allows access via a named method' do
+        assert_kind_of Struct, factory.test_service
+        assert_equal 22, factory.test_service.a
+      end
+
+      it 'caches service instances' do
+        identity_of_first_call = factory.test_service.object_id
+        identity_of_second_call = factory.test_service.object_id
+        assert_equal identity_of_first_call, identity_of_second_call
+      end
+
+      it "can unregister services" do
+        factory_class.unregister(:test_service)
+
+        assert_raises(NoMethodError) {factory.test_service}
+      end
+
+      describe "with more than one service registered" do
+        before do
+          factory_class.register :test_service do
+            Struct.new(:a).new(23)
+          end
+        end
+
+        it "uses the most recently defined service" do
+          assert_kind_of Struct, factory.test_service
+          refute_equal 22, factory.test_service.a
+          assert_equal 23, factory.test_service.a
+        end
+
+        it "uses the default implementation when unregistered" do
+          factory_class.unregister(:test_service)
+
+          assert_kind_of Struct, factory.test_service
+          assert_equal 22, factory.test_service.a
+        end
+
+        it "removes the service if unregistered twice" do
+          factory_class.unregister(:test_service)
+          factory_class.unregister(:test_service)
+
+          assert_raises(NoMethodError) {factory.test_service}
+        end
+      end
+    end
+
+  end
+
+end

data/spec/shared_spec_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'rohbau/shared_spec'
+
+describe Rohbau::SharedSpec do
+
+  before do
+    Rohbau::SharedSpec::SpecIndex.reset
+  end
+
+  let(:shared_spec_class) { Class.new(Rohbau::SharedSpec) }
+
+  it 'provides access the stored blocks' do
+    blk = -> {}
+
+    shared_spec_class.for :test1, &blk
+
+    assert_equal Proc.new(&blk), shared_spec_class.get(:test1)
+  end
+
+  describe 'index' do
+    let(:second_shared_spec_class) { Class.new(Rohbau::SharedSpec) }
+    let(:index) { Rohbau::SharedSpec::SpecIndex }
+
+    it 'collects all inherited specs' do
+      assert_equal [
+        shared_spec_class,
+        second_shared_spec_class
+      ], index.all
+    end
+
+    it 'looks up spec on all registered children' do
+      blk1 = -> {}
+      blk2 = -> {}
+
+      shared_spec_class.for :test1, &blk1
+      second_shared_spec_class.for :test2, &blk2
+
+      assert_equal Proc.new(&blk1), index.get(:test1)
+      assert_equal Proc.new(&blk2), index.get(:test2)
+      assert_equal nil,             index.get(:something)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+if ENV['coverage']
+  require 'simplecov'
+  SimpleCov.start
+end