rddd 0.2.0 → 0.2.1

data/lib/rddd/views/view.rb

@@ -0,0 +1,38 @@
+require 'rddd/views/cache'
+require 'rddd/views/cacheable'
+
+module Rddd
+  module Views
+    class View
+      include Cacheable
+      extend Caching
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def name
+        self.class.name.downcase.to_sym
+      end
+
+      def build
+        raise NotImplementedError
+      end
+
+      def data
+        return build if self.class.cache_disabled
+
+        cached_data = read_cache
+
+        return cached_data if cached_data
+
+        data = build
+        update_cache(data)
+
+        data
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
-require 'rddd/service'
-require 'rddd/aggregate_root'
-require 'rddd/service_bus'
-require 'rddd/service'
+require 'rddd/aggregates/root'
+require 'rddd/services/service'
+require 'rddd/services/service_bus'
+require 'rddd/services/service'
 
-class Project < Rddd::AggregateRoot
+class Project < Rddd::Aggregates::Root
   attr_accessor :name
 end
 
-class CreateProjectService < Rddd::Service
+class CreateProjectService < Rddd::Services::Service
   def execute
     project = Project.new(@attributes[:id])
     project.name = @attributes[:name]
@@ -24,7 +24,7 @@ class ProjectRepository
 end
 
 class ProjectsController
-  include Rddd::ServiceBus
+  include Rddd::Services::ServiceBus
 
   def create(params)
     execute_service(:create_project, params)
@@ -60,8 +60,8 @@ end
 describe 'NotExistingService' do
   it 'should raise' do
     controller = Object.new
-    controller.extend Rddd::ServiceBus
+    controller.extend Rddd::Services::ServiceBus
 
-    expect { controller.execute_service(:foo) }.to raise_exception Rddd::ServiceFactory::InvalidService
+    expect { controller.execute_service(:foo) }.to raise_exception Rddd::Services::ServiceFactory::InvalidService
   end
 end

data/spec/lib/aggregates/entity_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'rddd/aggregates/entity'
+
+describe Rddd::Aggregates::Entity do
+  it 'should have identity' do
+    entity = Rddd::Aggregates::Entity.new('1234')
+
+    entity.id.should == '1234'
+  end
+
+  it 'two entities with same identity are equal' do
+    a = Rddd::Aggregates::Entity.new('1234')
+    b = Rddd::Aggregates::Entity.new('1234')
+
+    (a == b).should be_true
+  end
+end

data/spec/lib/{aggregate_root_spec.rb → aggregates/root_spec.rb}

@@ -1,22 +1,22 @@
 require 'spec_helper'
-require 'rddd/aggregate_root'
+require 'rddd/aggregates/root'
 
-describe Rddd::AggregateRoot do
+describe Rddd::Aggregates::Root do
   let(:id) { stub('id') }
   
-  let(:aggregate_root) { Rddd::AggregateRoot.new(id) }
+  let(:aggregate_root) { Rddd::Aggregates::Root.new(id) }
 
   it 'should be entity' do
-    aggregate_root.should be_kind_of Rddd::Entity
+    aggregate_root.should be_kind_of Rddd::Aggregates::Entity
   end
 
   describe '#find' do
-    subject { Rddd::AggregateRoot.find(id) }
+    subject { Rddd::Aggregates::Root.find(id) }
 
     let(:repository) { stub('repository') }
 
     before {
-      Rddd::RepositoryFactory.expects(:build).returns(repository)
+      Rddd::Repositories::Factory.expects(:build).returns(repository)
       repository.expects(:find).with(id) 
     }
 
@@ -30,7 +30,7 @@ describe Rddd::AggregateRoot do
       let(:repository) { stub('repository') }
 
       it 'should call #create on repository' do
-        Rddd::RepositoryFactory.expects(:build).with(Rddd::AggregateRoot).returns(repository)
+        Rddd::Repositories::Factory.expects(:build).with(Rddd::Aggregates::Root).returns(repository)
 
         repository.expects(action).with(subject)
         

data/spec/lib/repositories/repository_factory_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'rddd/aggregates/repositories/factory'
+
+module Rddd
+  module Repositories
+    describe Factory do
+      let(:project) { stub('project', :name => 'Foo', :class => stub(:name => 'Foo')) }
+
+      let(:repository_creator) do
+        lambda do |clazz|
+          class_name = "#{clazz.name.to_s.camel_case}Repository"
+          Repositories.const_get(class_name.to_sym)
+        end
+      end
+
+      before do
+        Repositories.const_set(:FooRepository, Class.new)
+      end
+
+      after do
+        Repositories.class_eval { remove_const(:FooRepository) }
+      end
+
+      describe '.build' do
+        context 'configuration repository_creator given' do
+          before do
+            Rddd.configure { |config| config.repository_creator = repository_creator }
+          end
+
+          after do
+            Rddd.configure { |config| config.repository_creator = nil }
+          end
+
+          it 'should call the appropriate service' do
+            FooRepository.expects(:new)
+
+            Factory.build(project.class)
+          end
+        end
+
+        context 'configuration repository_creator not given' do
+          it 'should raise exception' do
+            expect { Factory.build(project.class) }.to raise_exception Factory::CreatorNotGiven
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/repositories/repository_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'rddd/aggregates/repositories/base'
+
+module Rddd
+  module Repositories
+    describe Base do
+      let(:repository) { Base.new }
+
+      let(:aggregate_root) { stub('aggregate_root') }
+
+      describe '#create' do
+        subject { repository.create(aggregate_root) }
+
+        it { expect { subject }.to raise_exception NotImplementedError }
+      end
+
+      describe '#update' do
+        subject { repository.update(aggregate_root) }
+
+        it { expect { subject }.to raise_exception NotImplementedError }
+      end
+
+      describe '#delete' do
+        subject { repository.delete(aggregate_root) }
+
+        it { expect { subject }.to raise_exception NotImplementedError }
+      end
+    end
+  end
+end

data/spec/lib/{service_bus_spec.rb → services/service_bus_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
-require 'rddd/service_bus'
+require 'rddd/services/service_bus'
 
-describe Rddd::ServiceBus do
+describe Rddd::Services::ServiceBus do
   let(:attributes) { stub('attributes') }
 
   let(:controller) do
-    stub('controller').tap { |controller| controller.extend Rddd::ServiceBus }
+    stub('controller').tap { |controller| controller.extend Rddd::Services::ServiceBus }
   end
 
   describe '.execute_service' do
@@ -15,7 +15,7 @@ describe Rddd::ServiceBus do
 
     context 'existing service' do
       it do
-        Rddd::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
+        Rddd::Services::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
         service.expects(:execute)
 
         subject
@@ -27,7 +27,7 @@ describe Rddd::ServiceBus do
         before { service.stubs(:valid?).returns(false) }
 
         it do
-          Rddd::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
+          Rddd::Services::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
           service.expects(:execute).never
 
           subject
@@ -45,7 +45,7 @@ describe Rddd::ServiceBus do
         let(:error_block) { lambda {|errors|} }
 
         it do
-          Rddd::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
+          Rddd::Services::ServiceFactory.expects(:build).with(:foo, attributes).returns(service)
           service.expects(:execute).never
 
           controller.execute_service(:foo, attributes, &error_block)

data/spec/lib/services/service_factory_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'rddd/services/service_factory'
+
+module Rddd
+  module Services
+    describe ServiceFactory do
+      let(:attributes) { stub('attributes') }
+
+      let(:service_creator) do
+        lambda do |name|
+          class_name = "#{name.to_s.camel_case}Service"
+          Services.const_get(class_name.to_sym)
+        end
+      end
+
+      before do
+        Services.const_set(:CreateProjectService, Class.new)
+      end
+
+      after do
+        Services.class_eval {remove_const(:CreateProjectService)}
+      end
+
+      describe '.build' do
+        context 'configuration service_creator given' do
+          before do
+            Rddd.configure { |config| config.service_creator = service_creator }
+          end
+
+          after do
+            Rddd.configure { |config| config.service_creator = nil }
+          end
+
+          it 'should call the appropriate service' do
+            CreateProjectService.expects(:new).with(attributes)
+
+            ServiceFactory.build(:create_project, attributes)
+          end
+        end
+
+        context 'not existing service' do
+          before do
+            Rddd.configure { |config| config.service_creator = service_creator }
+          end
+
+          after do
+            Rddd.configure { |config| config.service_creator = nil }
+          end
+
+          it { expect { ServiceFactory.build(:foo, attributes) }.to raise_exception ServiceFactory::InvalidService }
+        end
+
+        context 'configuration service_creator not given' do
+          it 'should raise exception' do
+            expect { Rddd::Services::ServiceFactory.build(:create_project, attributes) }.to raise_exception Rddd::Services::ServiceFactory::CreatorNotGiven
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/services/service_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rddd/services/service'
+
+module Rddd
+  module Services
+    describe Service do
+      let(:attributes) { stub('attributes') }
+
+      describe '#initialize' do
+        subject { Service.new(attributes) }
+
+        it 'should store attributes' do
+          subject.instance_variable_get(:@attributes).should == attributes
+        end
+      end  
+
+      describe '#valid?' do
+        subject { Service.new.valid? }
+        it { should be_true }
+      end
+
+      describe '#execute' do
+        it 'should raise not implemented' do
+          lambda do
+            Service.new(attributes).execute
+          end.should raise_exception(NotImplementedError)
+        end
+      end
+    end
+  end
+end

data/spec/lib/views/integration_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'rddd/views/view'
+require 'rddd/aggregates/repositories/base'
+
+class ViewRepository < Rddd::Repositories::Base
+  def get(id)
+  end
+
+  def set(id, value, timeout)
+  end
+end
+
+describe Rddd::Views::View do
+  let(:id) { :id }
+
+  let(:view) { Rddd::Views::View.new(id) }
+
+  let(:view_repository) { stub('view_repository') }
+
+  let(:data) { stub('data') }
+
+  subject { view }
+
+  describe '#initialize' do
+    its(:id) { should == id}
+  end
+
+  describe '#name' do
+    its(:name) { should == :'rddd::views::view' }
+  end
+
+  describe '#build' do
+    subject { view.build }
+
+    it { lambda {subject}.should raise_exception NotImplementedError }
+  end
+
+  describe '#warm_cache' do
+    subject { view.warm_cache }
+
+    before do
+      ViewRepository.expects(:new).returns(view_repository)
+
+      view.expects(:build).returns(data)
+
+      view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", data, anything)
+    end
+
+    it { subject }
+  end
+
+  describe '#invalidate' do
+    subject { view.invalidate }
+
+    before do
+      ViewRepository.expects(:new).returns(view_repository)
+
+      view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", nil)
+    end
+
+    it { subject }
+  end
+
+  describe '#data' do
+    subject { view.data }
+
+    context 'without view repository' do
+      before do
+        view.expects(:build).returns(data)
+      end
+
+      it { subject.should == data }
+    end
+
+    context 'not cached' do
+      before do
+        ViewRepository.expects(:new).returns(view_repository)
+      end
+
+      before do
+        view_repository.expects(:get).with("rddd::views::#{:view}#{:id}").returns(nil)
+
+        view.expects(:build).returns(data)
+
+        view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", data, nil)
+      end
+
+      it { subject.should == data }
+    end
+
+    context 'cached' do
+      before do
+        ViewRepository.expects(:new).returns(view_repository)
+        view_repository.expects(:get).with("rddd::views::#{:view}#{:id}").returns(data)
+      end
+
+      it { subject.should == data }
+    end
+  end
+
+  describe 'cache disabling' do
+    class CacheLessView < Rddd::Views::View
+      cache :enabled => false
+
+      def build
+      end
+    end
+
+    let(:id) { stub('id') }
+
+    let(:cache_less_view) do
+      CacheLessView.new(id)
+    end
+
+    it 'should not try to load data from cache' do
+      ViewRepository.expects(:new).never
+
+      cache_less_view.expects(:build).returns(data)
+
+      cache_less_view.data.should == data
+    end
+  end
+
+  describe 'timeout enabling' do
+    class TimeoutingView < Rddd::Views::View
+      cache :timeout => 24 * 60
+
+      def build
+      end
+    end
+
+    let(:id) { :id }
+
+    let(:timeouting_view) do
+      TimeoutingView.new(id)
+    end
+
+    it 'should set timeout to cache data' do
+      ViewRepository.expects(:new).returns(view_repository)
+      view_repository.expects(:get).with("#{:timeoutingview}#{:id}").returns(nil)
+
+      timeouting_view.expects(:build).returns(data)
+
+      view_repository.expects(:set).with do |got_id, got_data, got_time|
+        got_id == "#{:timeoutingview}#{:id}" &&
+        got_data == data &&
+        got_time.to_i == (Time.now + 24 * 60 * 60).to_i
+      end
+
+      timeouting_view.data
+    end
+  end
+end