vedeu 0.6.10 → 0.6.11

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

@@ -2,138 +2,142 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Collection do
-
-    let(:described)  { Vedeu::Collection }
-    let(:instance)   { described.new(collection, parent, model_name) }
-    let(:collection) { [] }
-    let(:model_name) { 'elements' }
-    let(:parent)     { Vedeu::ModelTestClass.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@collection').must_equal([]) }
-      it { instance.instance_variable_get('@name').must_equal(model_name) }
-      it { instance.instance_variable_get('@parent').must_equal(parent) }
-    end
-
-    describe 'accessors' do
-      it { instance.must_respond_to(:collection) }
-      it { instance.must_respond_to(:all) }
-      it { instance.must_respond_to(:parent) }
-      it { instance.must_respond_to(:parent=) }
-      it { instance.must_respond_to(:name) }
-      it { instance.must_respond_to(:name=) }
-    end
-
-    describe '.coerce' do
-      subject { described.coerce(collection, parent, model_name) }
-
-      # @todo Add more tests.
-      # it { skip }
-    end
-
-    describe '#[]' do
-      let(:collection) { [:hydrogen, :helium, :lithium, :beryllium] }
-      let(:_value) { 1..2 }
-
-      subject { instance[_value] }
-
-      it { subject.must_be_instance_of(Array) }
-      it { subject.must_equal([:helium, :lithium]) }
-    end
-
-    describe '#add' do
-      subject { instance.add(:hydrogen) }
-
-      it { instance.must_respond_to(:<<) }
-      it { subject.must_be_instance_of(Collection) }
-      it { subject.all.must_equal([:hydrogen]) }
-
-      context 'with multiple objects' do
-        subject { instance.add(:hydrogen, :helium) }
-
-        it 'adds all the objects to the collection' do
-          subject.all.must_equal([:hydrogen, :helium])
-        end
-      end
-    end
+  module Repositories
 
-    describe '#all' do
-      subject { instance.all }
+    describe Collection do
 
-      it { subject.must_be_instance_of(Array) }
-      it { subject.must_equal([]) }
+      let(:described)  { Vedeu::Repositories::Collection }
+      let(:instance)   { described.new(collection, parent, model_name) }
+      let(:collection) { [] }
+      let(:model_name) { 'elements' }
+      let(:parent)     { Vedeu::Repositories::ModelTestClass.new }
 
-      context 'when the collection is not empty' do
-        before { instance.add(:hydrogen) }
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@collection').must_equal([]) }
+        it { instance.instance_variable_get('@name').must_equal(model_name) }
+        it { instance.instance_variable_get('@parent').must_equal(parent) }
+      end
 
-        it 'returns the populated collection' do
-          subject.must_equal([:hydrogen])
-        end
+      describe 'accessors' do
+        it { instance.must_respond_to(:collection) }
+        it { instance.must_respond_to(:all) }
+        it { instance.must_respond_to(:parent) }
+        it { instance.must_respond_to(:parent=) }
+        it { instance.must_respond_to(:name) }
+        it { instance.must_respond_to(:name=) }
       end
-    end
 
-    describe '#empty?' do
-      subject { instance.empty? }
+      describe '.coerce' do
+        subject { described.coerce(collection, parent, model_name) }
 
-      context 'when the collection is empty' do
-        it { subject.must_be_instance_of(TrueClass) }
+        # @todo Add more tests.
+        # it { skip }
       end
 
-      context 'when the collection is not empty' do
-        before { instance.add(:hydrogen) }
+      describe '#[]' do
+        let(:collection) { [:hydrogen, :helium, :lithium, :beryllium] }
+        let(:_value) { 1..2 }
 
-        it { subject.must_be_instance_of(FalseClass) }
+        subject { instance[_value] }
+
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal([:helium, :lithium]) }
       end
-    end
 
-    describe '#eql?' do
-      let(:other) { instance }
+      describe '#add' do
+        subject { instance.add(:hydrogen) }
+
+        it { instance.must_respond_to(:<<) }
+        it { subject.must_be_instance_of(Collection) }
+        it { subject.all.must_equal([:hydrogen]) }
+
+        context 'with multiple objects' do
+          subject { instance.add(:hydrogen, :helium) }
 
-      subject { instance.eql?(other) }
+          it 'adds all the objects to the collection' do
+            subject.all.must_equal([:hydrogen, :helium])
+          end
+        end
+      end
 
-      it { subject.must_equal(true) }
+      describe '#all' do
+        subject { instance.all }
 
-      context 'when different to other' do
-        let(:other) { described.new([:different]) }
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal([]) }
 
-        it { subject.must_equal(false) }
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
+
+          it 'returns the populated collection' do
+            subject.must_equal([:hydrogen])
+          end
+        end
       end
-    end
 
-    describe '#size' do
-      subject { instance.size }
+      describe '#empty?' do
+        subject { instance.empty? }
 
-      it { subject.must_be_instance_of(Fixnum) }
+        context 'when the collection is empty' do
+          it { subject.must_be_instance_of(TrueClass) }
+        end
+
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
 
-      context 'when the collection is empty' do
-        it { subject.must_equal(0) }
+          it { subject.must_be_instance_of(FalseClass) }
+        end
       end
 
-      context 'when the collection is not empty' do
-        before { instance.add(:hydrogen) }
+      describe '#eql?' do
+        let(:other) { instance }
 
-        it { subject.must_equal(1) }
+        subject { instance.eql?(other) }
+
+        it { subject.must_equal(true) }
+
+        context 'when different to other' do
+          let(:other) { described.new([:different]) }
+
+          it { subject.must_equal(false) }
+        end
       end
-    end
 
-    describe '#to_s' do
-      subject { instance.to_s }
+      describe '#size' do
+        subject { instance.size }
+
+        it { subject.must_be_instance_of(Fixnum) }
+
+        context 'when the collection is empty' do
+          it { subject.must_equal(0) }
+        end
 
-      it { subject.must_be_instance_of(String) }
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
 
-      context 'when the collection is empty' do
-        it { subject.must_equal('') }
+          it { subject.must_equal(1) }
+        end
       end
 
-      context 'when the collection is not empty' do
-        before { instance.add(:hydrogen) }
+      describe '#to_s' do
+        subject { instance.to_s }
+
+        it { subject.must_be_instance_of(String) }
+
+        context 'when the collection is empty' do
+          it { subject.must_equal('') }
+        end
 
-        it { subject.must_equal('hydrogen') }
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
+
+          it { subject.must_equal('hydrogen') }
+        end
       end
-    end
 
-  end # Collection
+    end # Collection
+
+  end # Repositories
 
 end # Vedeu

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

@@ -2,82 +2,86 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Model do
+  module Repositories
 
-    let(:described)  { ModelTestClass }
-    let(:instance)   { described.new(attributes) }
-    let(:attributes) {
-      {
-        name: 'hydrogen'
+    describe Model do
+
+      let(:described)  { Vedeu::Repositories::ModelTestClass }
+      let(:instance)   { described.new(attributes) }
+      let(:attributes) {
+        {
+          name: 'hydrogen'
+        }
       }
-    }
 
-    describe 'accessors' do
-      it { instance.must_respond_to(:repository) }
-      it { instance.must_respond_to(:repository=) }
-    end
+      describe 'accessors' do
+        it { instance.must_respond_to(:repository) }
+        it { instance.must_respond_to(:repository=) }
+      end
 
-    describe '.build' do
-      let(:attributes) {}
+      describe '.build' do
+        let(:attributes) {}
 
-      subject { described.build(attributes) { } }
+        subject { described.build(attributes) { } }
 
-      # @todo Add more tests.
-      # it { skip }
-    end
+        # @todo Add more tests.
+        # it { skip }
+      end
 
-    describe '.by_name' do
-      let(:_name) {}
+      describe '.by_name' do
+        let(:_name) {}
 
-      subject { described.by_name(_name) }
+        subject { described.by_name(_name) }
 
-      context 'when the model has no repository set' do
-        it { subject.must_be_instance_of(NilClass) }
-      end
+        context 'when the model has no repository set' do
+          it { subject.must_be_instance_of(NilClass) }
+        end
 
-      context 'when the model has a repository set' do
-        # @todo Add more tests.
-        # it { skip }
+        context 'when the model has a repository set' do
+          # @todo Add more tests.
+          # it { skip }
+        end
       end
-    end
 
-    describe '.child' do
-      let(:klass) {}
+      describe '.child' do
+        let(:klass) {}
 
-      subject { described.child(klass) }
+        subject { described.child(klass) }
 
-      it { described.must_respond_to(:member) }
-      it { described.must_respond_to(:collection) }
+        it { described.must_respond_to(:member) }
+        it { described.must_respond_to(:collection) }
 
-      # @todo Add more tests.
-      # it { skip }
-    end
+        # @todo Add more tests.
+        # it { skip }
+      end
 
-    describe '.repository' do
-      let(:klass) {}
+      describe '.repository' do
+        let(:klass) {}
 
-      subject { described.repository(klass) }
+        subject { described.repository(klass) }
 
-      # @todo Add more tests.
-      # it { skip }
-    end
+        # @todo Add more tests.
+        # it { skip }
+      end
 
-    describe '#deputy' do
-      subject { instance.deputy }
+      describe '#deputy' do
+        subject { instance.deputy }
 
-      it 'returns the DSL instance' do
-        subject.must_be_instance_of(DSL::ModelTestClass)
+        # it 'returns the DSL instance' do
+        #   subject.must_be_instance_of(Vedeu::Repositories::ModelTestClass::DSL)
+        # end
       end
-    end
 
-    describe '#store' do
-      subject { instance.store }
+      describe '#store' do
+        subject { instance.store }
 
-      it 'returns the model' do
-        subject.must_be_instance_of(ModelTestClass)
+        it 'returns the model' do
+          subject.must_be_instance_of(Vedeu::Repositories::ModelTestClass)
+        end
       end
-    end
 
-  end # Model
+    end # Model
+
+  end # Repositories
 
 end # Vedeu

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

@@ -2,54 +2,58 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Registerable do
+  module Repositories
 
-    class RegisterableTestClass
+    describe Registerable do
 
-      include Vedeu::Registerable
+      class RegisterableTestClass
 
-      null Vedeu::ModelTestClass
-      real Vedeu::ModelTestClass
+        include Vedeu::Repositories::Registerable
 
-    end
+        null Vedeu::Repositories::ModelTestClass
+        real Vedeu::Repositories::ModelTestClass
 
-    let(:described) { Vedeu::Registerable }
+      end
 
-    it { RegisterableTestClass.must_respond_to(:repository) }
-    it { RegisterableTestClass.must_respond_to(:register) }
+      let(:described) { Vedeu::Repositories::Registerable }
 
-    describe '.null' do
-      subject { RegisterableTestClass.new }
+      it { RegisterableTestClass.must_respond_to(:repository) }
+      it { RegisterableTestClass.must_respond_to(:register) }
 
-      it { RegisterableTestClass.must_respond_to(:null) }
+      describe '.null' do
+        subject { RegisterableTestClass.new }
 
-      it { subject.must_respond_to(:null_model) }
-      it { subject.null_model.must_equal(Vedeu::ModelTestClass) }
-    end
+        it { RegisterableTestClass.must_respond_to(:null) }
 
-    describe '.real' do
-      subject { RegisterableTestClass.new }
+        it { subject.must_respond_to(:null_model) }
+        it { subject.null_model.must_equal(Vedeu::Repositories::ModelTestClass) }
+      end
 
-      it { RegisterableTestClass.must_respond_to(:real) }
+      describe '.real' do
+        subject { RegisterableTestClass.new }
 
-      it { subject.must_respond_to(:model) }
-      it { subject.model.must_equal(Vedeu::ModelTestClass) }
-    end
+        it { RegisterableTestClass.must_respond_to(:real) }
 
-    describe '.reset' do
-      subject { RegisterableTestClass.reset! }
+        it { subject.must_respond_to(:model) }
+        it { subject.model.must_equal(Vedeu::Repositories::ModelTestClass) }
+      end
 
-      before { RegisterableTestClass.stubs(:register) }
+      describe '.reset' do
+        subject { RegisterableTestClass.reset! }
 
-      it { RegisterableTestClass.must_respond_to(:reset!) }
-      it { RegisterableTestClass.must_respond_to(:reset) }
+        before { RegisterableTestClass.stubs(:register) }
 
-      it {
-        RegisterableTestClass.expects(:register)
-        subject
-      }
-    end
+        it { RegisterableTestClass.must_respond_to(:reset!) }
+        it { RegisterableTestClass.must_respond_to(:reset) }
 
-  end # Registerable
+        it {
+          RegisterableTestClass.expects(:register)
+          subject
+        }
+      end
+
+    end # Registerable
+
+  end # Repositories
 
 end # Vedeu