vedeu 0.6.10 → 0.6.11

data/test/lib/vedeu/repositories/repository_test.rb

@@ -2,268 +2,272 @@ require 'test_helper'
 
 module Vedeu
 
-  class RepositoriesTestClass < Vedeu::Repository
+  module Repositories
 
-    attr_accessor :storage
-    alias_method :in_memory, :storage
+    class RepositoriesTestClass < Vedeu::Repositories::Repository
 
-    def initialize(storage = {})
-      @storage = storage
-    end
-
-    def add(model)
-      if storage.is_a?(Hash)
-        @storage = in_memory.merge!(model)
-
-      else
-        @storage << model
+      attr_accessor :storage
+      alias_method :in_memory, :storage
 
+      def initialize(storage = {})
+        @storage = storage
       end
-    end
 
-  end # RepositoriesTestClass
+      def add(model)
+        if storage.is_a?(Hash)
+          @storage = in_memory.merge!(model)
 
-  class TestRepository < Vedeu::Repository
-  end
+        else
+          @storage << model
 
-  class TestModel
-    include Vedeu::Model
+        end
+      end
 
-    attr_accessor :name
+    end # RepositoriesTestClass
 
-    def initialize(name = nil)
-      @name = name
-      @repository = Vedeu::TestRepository.new(self.class)
+    class TestRepository < Vedeu::Repositories::Repository
     end
-  end
 
-  describe Repository do
+    class TestModel
+      include Vedeu::Repositories::Model
 
-    let(:described)      { Vedeu::Repository }
-    let(:instance)       { described.new(model, storage) }
-    let(:model)          { Vedeu::TestModel }
-    let(:model_instance) { model.new(model_name) }
-    let(:model_name)     { 'terbium' }
-    let(:storage)        { {} }
+      attr_accessor :name
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@model').must_equal(model) }
-      it { instance.instance_variable_get('@storage').must_equal(storage) }
+      def initialize(name = nil)
+        @name = name
+        @repository = Vedeu::Repositories::TestRepository.new(self.class)
+      end
     end
 
-    describe 'accessors' do
-      it { instance.must_respond_to(:model) }
-      it { instance.must_respond_to(:storage) }
-    end
+    describe Repository do
 
-    describe '#all' do
-      subject { instance.all }
+      let(:described)      { Vedeu::Repositories::Repository }
+      let(:instance)       { described.new(model, storage) }
+      let(:model)          { Vedeu::Repositories::TestModel }
+      let(:model_instance) { model.new(model_name) }
+      let(:model_name)     { 'terbium' }
+      let(:storage)        { {} }
 
-      context 'when there are no models stored in the repository' do
-        before { instance.reset }
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@model').must_equal(model) }
+        it { instance.instance_variable_get('@storage').must_equal(storage) }
+      end
 
-        it { subject.must_equal([]) }
+      describe 'accessors' do
+        it { instance.must_respond_to(:model) }
+        it { instance.must_respond_to(:storage) }
       end
 
-      context 'when there are models stored in the repository' do
-        context 'when the repository is a glorified Hash' do
-          let(:storage) {
-            {
-              oxygen:    :life,
-              plutonium: :death,
-            }
-          }
-          it { subject.must_equal([:life, :death]) }
-        end
+      describe '#all' do
+        subject { instance.all }
 
-        context 'when the repository is a glorified Set' do
-          let(:storage) { Set[:oxygen, :hydrogen] }
+        context 'when there are no models stored in the repository' do
+          before { instance.reset }
 
-          it { subject.must_equal([:oxygen, :hydrogen]) }
+          it { subject.must_equal([]) }
         end
 
-        context 'when the repository is unknown' do
-          let(:storage) { [:hydrogen, :helium] }
+        context 'when there are models stored in the repository' do
+          context 'when the repository is a glorified Hash' do
+            let(:storage) {
+              {
+                oxygen:    :life,
+                plutonium: :death,
+              }
+            }
+            it { subject.must_equal([:life, :death]) }
+          end
+
+          context 'when the repository is a glorified Set' do
+            let(:storage) { Set[:oxygen, :hydrogen] }
 
-          it { subject.must_equal([:hydrogen, :helium]) }
+            it { subject.must_equal([:oxygen, :hydrogen]) }
+          end
+
+          context 'when the repository is unknown' do
+            let(:storage) { [:hydrogen, :helium] }
+
+            it { subject.must_equal([:hydrogen, :helium]) }
+          end
         end
       end
-    end
 
-    describe '#by_name' do
-      let(:_name) { 'carbon' }
+      describe '#by_name' do
+        let(:_name) { 'carbon' }
 
-      subject { instance.by_name(_name) }
+        subject { instance.by_name(_name) }
 
-      context 'when the model exists' do
-        # it { skip }
-      end
+        context 'when the model exists' do
+          # it { skip }
+        end
 
-      context 'when the model does not exist' do
-        # it { skip }
+        context 'when the model does not exist' do
+          # it { skip }
+        end
       end
-    end
 
-    describe '#current' do
-      subject { instance.current }
+      describe '#current' do
+        subject { instance.current }
 
-      context 'when there is nothing in focus' do
-        before { Vedeu.stubs(:focus) }
+        context 'when there is nothing in focus' do
+          before { Vedeu.stubs(:focus) }
 
-        it { subject.must_be_instance_of(NilClass) }
-      end
+          it { subject.must_be_instance_of(NilClass) }
+        end
 
-      context 'when there something in focus' do
-        before { Vedeu.stubs(:focus).returns('zinc') }
+        context 'when there something in focus' do
+          before { Vedeu.stubs(:focus).returns('zinc') }
 
-        it { subject.must_be_instance_of(Vedeu::TestModel) }
+          it { subject.must_be_instance_of(Vedeu::Repositories::TestModel) }
+        end
       end
-    end
 
-    describe '#find' do
-      subject { instance.find(model_name) }
+      describe '#find' do
+        subject { instance.find(model_name) }
 
-      context 'when the model cannot be found' do
-        let(:model_name) { 'not_found' }
+        context 'when the model cannot be found' do
+          let(:model_name) { 'not_found' }
 
-        it { subject.must_be_instance_of(NilClass) }
-      end
+          it { subject.must_be_instance_of(NilClass) }
+        end
 
-      context 'when the model is found' do
-        let(:model_instance) { model.new('terbium') }
+        context 'when the model is found' do
+          let(:model_instance) { model.new('terbium') }
 
-        before { instance.store(model_instance) }
+          before { instance.store(model_instance) }
 
-        it 'returns the stored model' do
-          subject.must_equal(model_instance)
+          it 'returns the stored model' do
+            subject.must_equal(model_instance)
+          end
         end
       end
-    end
 
-    describe '#find!' do
-      subject { instance.find!(model_name) }
+      describe '#find!' do
+        subject { instance.find!(model_name) }
 
-      context 'when the model cannot be found' do
-        let(:model_name) { 'not_found' }
+        context 'when the model cannot be found' do
+          let(:model_name) { 'not_found' }
 
-        it { proc { subject }.must_raise(Vedeu::Error::ModelNotFound) }
-      end
+          it { proc { subject }.must_raise(Vedeu::Error::ModelNotFound) }
+        end
 
-      context 'when the model is found' do
-        let(:model_instance) { model.new('terbium') }
+        context 'when the model is found' do
+          let(:model_instance) { model.new('terbium') }
 
-        before { instance.store(model_instance) }
+          before { instance.store(model_instance) }
 
-        it 'returns the stored model' do
-          subject.must_equal(model_instance)
+          it 'returns the stored model' do
+            subject.must_equal(model_instance)
+          end
         end
       end
-    end
 
-    describe '#find_or_create' do
-      let(:model_instance) { TestModel.new('niobium') }
+      describe '#find_or_create' do
+        let(:model_instance) { Vedeu::Repositories::TestModel.new('niobium') }
 
-      subject { instance.find_or_create(model_name) }
+        subject { instance.find_or_create(model_name) }
 
-      context 'when the model exists' do
-        let(:model_name) { 'niobium' }
+        context 'when the model exists' do
+          let(:model_name) { 'niobium' }
 
-        before { instance.store(model_instance) }
+          before { instance.store(model_instance) }
 
-        it { subject.must_equal(model_instance) }
-      end
+          it { subject.must_equal(model_instance) }
+        end
 
-      context 'when the model does not exist' do
-        let(:model_name) { 'zinc'}
+        context 'when the model does not exist' do
+          let(:model_name) { 'zinc'}
 
-        it 'creates and stores a new instance of the model' do
-          subject.must_be_instance_of(Vedeu::TestModel)
+          it 'creates and stores a new instance of the model' do
+            subject.must_be_instance_of(Vedeu::Repositories::TestModel)
+          end
         end
       end
-    end
-
-    describe '#inspect' do
-      subject { instance.inspect }
 
-      it { subject.must_be_instance_of(String) }
-      it { subject.must_equal('<Vedeu::Repository>') }
-    end
+      describe '#inspect' do
+        subject { instance.inspect }
 
-    describe '#registered?' do
-      it 'returns false with no name' do
-        RepositoriesTestClass.new.registered?('').must_equal(false)
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('<Vedeu::Repositories::Repository>') }
       end
 
-      it 'returns false with no name' do
-        RepositoriesTestClass.new.registered?(nil).must_equal(false)
-      end
+      describe '#registered?' do
+        it 'returns false with no name' do
+          RepositoriesTestClass.new.registered?('').must_equal(false)
+        end
 
-      it 'returns false when the storage is empty' do
-        RepositoriesTestClass.new.registered?('terbium').must_equal(false)
-      end
+        it 'returns false with no name' do
+          RepositoriesTestClass.new.registered?(nil).must_equal(false)
+        end
+
+        it 'returns false when the storage is empty' do
+          RepositoriesTestClass.new.registered?('terbium').must_equal(false)
+        end
 
-      it 'returns false when the model is not registered' do
-        repo = RepositoriesTestClass.new
-        repo.add(name: 'samarium')
+        it 'returns false when the model is not registered' do
+          repo = RepositoriesTestClass.new
+          repo.add(name: 'samarium')
 
-        repo.registered?('terbium').must_equal(false)
+          repo.registered?('terbium').must_equal(false)
+        end
       end
-    end
 
-    describe '#remove' do
-      subject { instance.remove('francium') }
+      describe '#remove' do
+        subject { instance.remove('francium') }
 
-      it { instance.must_respond_to(:destroy) }
-      it { instance.must_respond_to(:delete) }
-      it { instance.must_respond_to(:deregister) }
+        it { instance.must_respond_to(:destroy) }
+        it { instance.must_respond_to(:delete) }
+        it { instance.must_respond_to(:deregister) }
 
-      context 'when the storage is empty' do
-        before { instance.reset }
+        context 'when the storage is empty' do
+          before { instance.reset }
 
-        it { subject.must_be_instance_of(FalseClass) }
-      end
+          it { subject.must_be_instance_of(FalseClass) }
+        end
 
-      context 'when the model is not registered' do
-        before {
-          instance.reset
-          instance.store(Vedeu::TestModel.new('zinc'))
-        }
+        context 'when the model is not registered' do
+          before {
+            instance.reset
+            instance.store(Vedeu::Repositories::TestModel.new('zinc'))
+          }
 
-        it { subject.must_be_instance_of(FalseClass) }
-      end
+          it { subject.must_be_instance_of(FalseClass) }
+        end
 
-      context 'when the model is registered' do
-        before {
-          instance.reset
-          instance.store(Vedeu::TestModel.new('gadolinium'))
-          instance.store(Vedeu::TestModel.new('francium'))
-        }
+        context 'when the model is registered' do
+          before {
+            instance.reset
+            instance.store(Vedeu::Repositories::TestModel.new('gadolinium'))
+            instance.store(Vedeu::Repositories::TestModel.new('francium'))
+          }
 
-        it 'returns the storage with the model removed' do
-          subject.size.must_equal(1)
+          it 'returns the storage with the model removed' do
+            subject.size.must_equal(1)
+          end
         end
       end
-    end
 
-    describe '#store' do
-      subject { instance.store(model_instance) }
+      describe '#store' do
+        subject { instance.store(model_instance) }
 
-      it { instance.must_respond_to(:register) }
+        it { instance.must_respond_to(:register) }
 
-      context 'when a name attribute is empty or nil' do
-        before { model_instance.name = '' }
+        context 'when a name attribute is empty or nil' do
+          before { model_instance.name = '' }
 
-        it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
-      end
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        end
 
-      context 'when a name attributes is provided' do
-        let(:model_name) { 'hydrogen' }
+        context 'when a name attributes is provided' do
+          let(:model_name) { 'hydrogen' }
 
-        it { subject.must_be_instance_of(Vedeu::TestModel) }
+          it { subject.must_be_instance_of(Vedeu::Repositories::TestModel) }
+        end
       end
-    end
 
-  end # Repository
+    end # Repository
+
+  end # Repositories
 
 end # Vedeu