vedeu 0.4.13 → 0.4.14

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

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Buffers do
+
+    let(:described) { Vedeu::Buffers }
+    let(:instance)  { described.buffers }
+
+    describe '.buffers' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+    describe '#clear' do
+      let(:_name)  { 'silicon' }
+      let(:buffer) { Vedeu::Buffer.new }
+
+      subject { instance.clear(_name) }
+
+      context 'when the buffer exists' do
+        before { instance.stubs(:find!).returns(buffer) }
+
+        it { buffer.expects(:clear); subject }
+      end
+
+      context 'when the buffer does not exist' do
+        it { proc { subject }.must_raise(ModelNotFound) }
+      end
+    end
+
+    describe '#render' do
+      let(:_name) { 'silicon' }
+      let(:buffer) { Vedeu::Buffer.new }
+
+      subject { instance.render(_name) }
+
+      context 'when the buffer exists' do
+        before { instance.stubs(:find!).returns(buffer) }
+
+        it { buffer.expects(:render); subject }
+      end
+
+      context 'when the buffer does not exist' do
+        it { proc { subject }.must_raise(ModelNotFound) }
+      end
+    end
+
+  end # Buffers
+
+end # Vedeu

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

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Colours do
+
+    let(:described) { Vedeu::Colours }
+    let(:instance) { described.new }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+    end
+
+  end # Colours
+
+end # Vedeu

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

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Cursors do
+
+    let(:described) { Vedeu::Cursors }
+
+    describe '.cursors' do
+      subject { described.cursors }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+    describe '.cursor' do
+      subject { Vedeu.cursor }
+
+      context 'when there are cursors are defined' do
+        before do
+          Vedeu::Focus.add('Vedeu.cursor')
+          Vedeu::Cursor.new(name: 'Vedeu.cursor').store
+        end
+
+        it { subject.must_be_instance_of(Vedeu::Cursor) }
+      end
+
+      context 'when there are no cursors defined' do
+        before do
+          Vedeu::Focus.reset
+          Vedeu.cursors.reset
+        end
+
+        it { subject.must_be_instance_of(NilClass) }
+      end
+    end
+
+  end # Cursors
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe EventsRepository do
+
+    let(:described) { Vedeu::EventsRepository }
+
+    describe '.events' do
+      subject { described.events }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # EventsRepository
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe ForegroundColours do
+
+    let(:described) { Vedeu::ForegroundColours }
+
+    describe '.foreground_colours' do
+      subject { described.foreground_colours }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # ForegroundColours
+
+end # Vedeu

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

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Geometries do
+
+    let(:described) { Vedeu::Geometries }
+
+    describe '.geometries' do
+      subject { described.geometries }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+    describe '#by_name' do
+      let(:_name) { 'carbon' }
+
+      subject { described.geometries.by_name(_name) }
+
+      context 'when the geometry exists' do
+        before do
+          Vedeu.geometry 'carbon' do
+            x  1
+            xn 3
+            y  1
+            yn 3
+          end
+        end
+
+        it { subject.must_be_instance_of(Vedeu::Geometry) }
+      end
+
+      context 'when the geometry does not exist' do
+        let(:_name) { 'nitrogen' }
+
+        it { subject.must_be_instance_of(Vedeu::NullGeometry) }
+      end
+    end
+
+  end # Geometries
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Groups do
+
+    let(:described) { Vedeu::Groups }
+
+    describe '.groups' do
+      subject { described.groups }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # Groups
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe InterfacesRepository do
+
+    let(:described) { Vedeu::InterfacesRepository }
+
+    describe '.interfaces' do
+      subject { described.interfaces }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # InterfacesRepository
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Keymaps do
+
+    let(:described) { Vedeu::Keymaps }
+
+    describe '.keymaps' do
+      subject { described.keymaps }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # Keymaps
+
+end # Vedeu

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

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Menus do
+
+    let(:described) { Vedeu::Menus }
+
+    describe '.menus' do
+      subject { described.menus }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+  end # Menus
+
+end # Vedeu

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

@@ -39,36 +39,28 @@ module Vedeu
       it { instance.instance_variable_get('@storage').must_equal(storage) }
     end
 
-    describe '#all' do
-      subject { instance.all }
-
-      it 'returns the whole repository' do
-        subject.must_equal(storage)
-      end
-    end
-
-    describe '#each' do
-      subject { instance.each }
-
-      it { subject.must_be_instance_of(Enumerator) }
-    end
+    describe '#find' do
+      subject { instance.find(model_name) }
 
-    describe '#empty?' do
-      subject { instance.empty? }
+      context 'when the model cannot be found' do
+        let(:model_name) { 'not_found' }
 
-      context 'when the storage is empty' do
-        it { subject.must_equal(true) }
+        it { subject.must_be_instance_of(NilClass) }
       end
 
-      context 'when the storage is not empty' do
-        let(:storage) { [:item] }
+      context 'when the model is found' do
+        let(:model_instance) { model.new('terbium') }
 
-        it { subject.must_equal(false) }
+        before { instance.store(model_instance) }
+
+        it 'returns the stored model' do
+          subject.must_equal(model_instance)
+        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' }
@@ -92,8 +84,6 @@ module Vedeu
 
       subject { instance.find_or_create(model_name) }
 
-      it { instance.find_or_create('zinc').must_be_instance_of(Vedeu::TestModel) }
-
       context 'when the model exists' do
         let(:model_name) { 'niobium' }
 
@@ -119,7 +109,7 @@ module Vedeu
       context 'when the storage is a Hash' do
         it 'returns a collection of the names of all the registered entities' do
           repo = RepositoriesTestClass.new
-          repo.add({ 'rutherfordium' => { name: 'rutherfordium' } })
+          repo.add('rutherfordium' => { name: 'rutherfordium' })
 
           repo.registered.must_equal(['rutherfordium'])
         end
@@ -163,7 +153,7 @@ module Vedeu
 
       it 'returns false when the model is not registered' do
         repo = RepositoriesTestClass.new
-        repo.add({ name: 'samarium' })
+        repo.add(name: 'samarium')
 
         repo.registered?('terbium').must_equal(false)
       end
@@ -200,16 +190,6 @@ module Vedeu
       end
     end
 
-    describe '#reset' do
-      it 'returns a Hash' do
-        instance.reset.must_be_instance_of(Hash)
-      end
-
-      it 'resets the repository' do
-        instance.reset.must_equal({})
-      end
-    end
-
     describe '#store' do
       subject { instance.store(model_instance) }
 

data/test/lib/vedeu/storage/associative_store_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe AssociativeStore do
+
+    let(:described) { Vedeu::AssociativeStore }
+    let(:instance)  { described.new(storage) }
+    let(:storage)   { {} }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(Vedeu::AssociativeStore) }
+      it { instance.instance_variable_get('@storage').must_equal(storage) }
+    end
+
+    describe '#load' do
+      let(:_name) {}
+
+      subject { instance.load(_name) }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { { hydrogen: '1', helium: '2' } }
+
+        context 'when the named entry exists' do
+          let(:_name) { :helium }
+
+          it { subject.must_equal('2') }
+        end
+
+        context 'when the named entry does not exist' do
+          let(:_name) { :beryllium }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+    end
+
+    describe '#save' do
+      let(:data)  { [:some_data] }
+      let(:_name) {}
+
+      subject { instance.save(data, _name) }
+
+      context 'when a name is given' do
+        let(:_name) { :hydrogen }
+
+        it { subject.must_equal(hydrogen: [:some_data]) }
+      end
+
+      context 'when a name is not given' do
+        context 'when the data respond to name' do
+          let(:data) { ModelTestClass.new(name: 'helium')}
+
+          it { subject.key?('helium').must_equal(true) }
+        end
+
+        context 'when the data does not respond to name' do
+          it { subject.must_equal({}) }
+        end
+      end
+    end
+
+  end # AssociativeStore
+
+end # Vedeu

data/test/lib/vedeu/storage/conveyor_store_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe ConveyorStore do
+
+    let(:described) { Vedeu::ConveyorStore }
+    let(:instance)  { described.new(storage) }
+    let(:storage)   { [] }
+
+    describe 'alias methods' do
+      it { instance.must_respond_to(:current) }
+    end
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(Vedeu::ConveyorStore) }
+      it { instance.instance_variable_get('@storage').must_equal(storage) }
+    end
+
+    describe '#load' do
+      subject { instance.load }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:hydrogen] }
+
+        it { subject.must_equal(:hydrogen) }
+      end
+    end
+
+    describe '#load_named' do
+      let(:_name) {}
+
+      subject { instance.load_named(_name) }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:lithium, :helium, :hydrogen] }
+
+        context 'when the named entry exists' do
+          let(:_name) { :helium }
+
+          it { subject.must_equal(:helium) }
+
+          it 'rotates the store to the named entry' do
+            instance.storage.must_equal([:lithium, :helium, :hydrogen])
+            subject
+            instance.storage.must_equal([:helium, :hydrogen, :lithium])
+          end
+        end
+
+        context 'when the named entry does not exist' do
+          let(:_name) { :beryllium }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+    end
+
+    describe '#load_next' do
+      subject { instance.load_next }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:lithium, :helium, :hydrogen] }
+
+        it { subject.must_equal(:helium) }
+
+        it 'rotates the store' do
+          instance.storage.must_equal([:lithium, :helium, :hydrogen])
+          instance.load_next
+          instance.load_next
+          instance.storage.must_equal([:hydrogen, :lithium, :helium])
+        end
+      end
+    end
+
+    describe '#load_previous' do
+      subject { instance.load_previous }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:lithium, :helium, :hydrogen] }
+
+        it { subject.must_equal(:hydrogen) }
+
+        it 'rotates the store' do
+          instance.storage.must_equal([:lithium, :helium, :hydrogen])
+          instance.load_previous
+          instance.load_previous
+          instance.storage.must_equal([:helium, :hydrogen, :lithium])
+        end
+      end
+    end
+
+    describe '#save' do
+      let(:data)  { :beryllium }
+      let(:front) { false }
+
+      subject { instance.save(data, front) }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal([:beryllium]) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:lithium, :helium, :hydrogen] }
+
+        context 'and `front` is false' do
+          it { subject.must_equal([:beryllium, :lithium, :helium, :hydrogen]) }
+        end
+
+        context 'and `front` is true' do
+          let(:front) { true }
+
+          it { subject.must_equal([:lithium, :helium, :hydrogen, :beryllium]) }
+        end
+      end
+    end
+
+  end # ConveyorStore
+
+end # Vedeu

data/test/lib/vedeu/storage/fifo_store_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe FifoStore do
+
+    let(:described) { Vedeu::FifoStore }
+    let(:instance)  { described.new(storage) }
+    let(:storage)   { [] }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(Vedeu::FifoStore) }
+      it { instance.instance_variable_get('@storage').must_equal(storage) }
+    end
+
+    describe '#load' do
+      subject { instance.load }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(nil) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [:lithium, :helium, :hydrogen] }
+
+        it { subject.must_equal(:hydrogen) }
+
+        it 'removes the item from storage on retrieval' do
+          instance.size.must_equal(3)
+          subject
+          instance.size.must_equal(2)
+        end
+      end
+    end
+
+    describe '#save' do
+      let(:data)    { :beryllium }
+      let(:storage) { [:lithium, :helium, :hydrogen] }
+
+      subject { instance.save(data) }
+
+      it { subject.must_equal([:beryllium, :lithium, :helium, :hydrogen]) }
+    end
+
+  end # FifoStore
+
+end # Vedeu