vedeu 0.2.2 → 0.2.3

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

@@ -10,6 +10,12 @@ module Vedeu
         Buffers.add({ name: 'molybdenum' }).must_equal('molybdenum')
       end
 
+      it 'raises an exception if the attributes does not have a :name key' do
+        attributes = { no_name_key: '' }
+
+        proc { Buffers.add(attributes) }.must_raise(MissingRequired)
+      end
+
       context 'when the buffer is already registered' do
         it 'retrieves the buffer in storage, and adds the attributes to the ' \
            'back buffer, preserving the front which may already have content' do
@@ -25,20 +31,6 @@ module Vedeu
       end
     end
 
-    describe '.find' do
-      context 'when the buffer does not exist by this name' do
-        it '' do
-          skip
-        end
-      end
-
-      context 'when the buffer can be found by name' do
-        it '' do
-          skip
-        end
-      end
-    end
-
     describe '.latest' do
       context 'when the buffer does not exist by this name' do
         it '' do
@@ -53,23 +45,5 @@ module Vedeu
       end
     end
 
-    describe '.registered' do
-      it '' do
-        skip
-      end
-    end
-
-    describe '.registered>' do
-      it '' do
-        skip
-      end
-    end
-
-    describe '.reset' do
-      it '' do
-          skip
-        end
-    end
-
   end
 end

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

@@ -3,7 +3,21 @@ require 'test_helper'
 module Vedeu
   describe Cursors do
 
+    before { Cursors.reset }
+
     describe '#add' do
+      it 'raises an exception if the attributes does not have a :name key' do
+        attributes = { no_name_key: '' }
+
+        proc { Cursors.add(attributes) }.must_raise(MissingRequired)
+      end
+
+      it 'returns something' do
+        skip
+      end
+    end
+
+    describe '#use' do
       it 'returns something' do
         skip
       end

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

@@ -2,68 +2,39 @@ require 'test_helper'
 
 module Vedeu
   describe Events do
-    describe '#event' do
-      it 'adds the event block to the handlers' do
-        events = Events.new
-        events.event(:sulphur) { proc { |x| x } }
-        events.registered.must_equal([:sulphur])
+    describe '#add' do
+      it 'adds the event' do
+        Events.add(:sulphur) { proc { |x| x } }
+        Events.registered.must_include(:sulphur)
       end
     end
 
-    describe '#unevent' do
+    describe '#remove' do
       it 'removes the event by name' do
-        events = Events.new
-        events.event(:chlorine) { proc { |x| x } }
-        events.event(:argon)    { proc { |y| y } }
-        events.unevent(:chlorine)
-        events.registered.must_equal([:argon])
+        Events.add(:chlorine) { proc { |x| x } }
+        Events.add(:argon)    { proc { |y| y } }
+        Events.remove(:chlorine)
+        Events.registered.wont_include(:chlorine)
       end
 
       it 'removes the event by name only if the name exists' do
-        events = Events.new
-        events.event(:chlorine) { proc { |x| x } }
-        events.event(:argon)    { proc { |y| y } }
-        events.unevent(:potassium)
-        events.registered.must_equal([:chlorine, :argon])
+        Events.add(:chlorine) { proc { |x| x } }
+        Events.add(:argon)    { proc { |y| y } }
+        Events.remove(:potassium).must_equal(false)
       end
     end
 
-    describe '#registered' do
-      it 'returns all the registered events by name' do
-        events = Events.new do
-          event(:some_event) { proc { |x| x } }
-        end
-        events.registered.must_equal([:some_event])
-      end
-    end
+    describe '#trigger' do
+      it 'returns the result of triggering the event' do
+        NastyException = Class.new(StandardError)
 
-    describe '#registered?' do
-      it '' do
-        skip
-      end
-    end
+        Events.add(:_nasty_exception_) { fail NastyException }
 
-    describe '#trigger' do
-      it 'returns a collection containing the event when the event is ' \
-         'pre-registered' do
-        events = Events.new do
-          event(:_exit_) { fail StopIteration }
-        end
-        proc { events.trigger(:_exit_) }.must_raise(StopIteration)
+        proc { Events.use(:_nasty_exception_) }.must_raise(NastyException)
       end
 
       it 'returns an empty collection when the event has not been registered' do
-        events = Events.new
-        events.trigger(:_not_found_).must_be_empty
-      end
-    end
-
-    describe '#reset' do
-      it 'removes all events registered' do
-        events = Events.new do
-          event(:potassium) { proc { |x| x } }
-        end
-        events.reset.must_equal({})
+        Events.use(:_not_found_).must_be_empty
       end
     end
   end

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

@@ -15,6 +15,12 @@ module Vedeu
         Focus.add({ name: 'thallium' })
         Focus.registered.must_equal(['thallium'])
       end
+
+      it 'raises an exception if the attributes does not have a :name key' do
+        attributes = { no_name_key: '' }
+
+        proc { Focus.add(attributes) }.must_raise(MissingRequired)
+      end
     end
 
     describe '#by_name' do
@@ -43,6 +49,18 @@ module Vedeu
       end
     end
 
+    describe '#current?' do
+      before { Focus.stubs(:current).returns('lead') }
+
+      context 'when the interface is currently in focus' do
+        it { Focus.current?('lead').must_equal(true) }
+      end
+
+      context 'when the interface is not currently in focus' do
+        it { Focus.current?('bismuth').must_equal(false) }
+      end
+    end
+
     describe '#next_item' do
       it 'the next interface is focussed when the method is called' do
         Focus.add({ name: 'thallium' })
@@ -87,10 +105,5 @@ module Vedeu
       end
     end
 
-    describe '.reset' do
-      it 'returns an empty collection with no focussed interfaces stored' do
-        Focus.reset.must_equal([])
-      end
-    end
   end
 end

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

@@ -13,72 +13,13 @@ module Vedeu
         Groups.add({ group: 'elements', name: 'germanium', delay: 0.0 })
         Groups.all.must_equal({ 'elements' => Set['germanium'] })
       end
-    end
-
-    describe '#all' do
-      before do
-        Groups.reset
-        Groups.add({ group: 'elements', name: 'cobalt', delay: 0.0 })
-        Groups.add({ group: 'elements', name: 'nickel', delay: 0.0 })
-        Groups.add({ group: 'elements', name: 'copper', delay: 0.0 })
-      end
-
-      it 'returns all the groups from storage' do
-        Groups.all.must_equal({
-          "elements" => Set["cobalt", "nickel", "copper"]
-        })
-      end
-    end
-
-    describe '#find' do
-      before do
-        Groups.reset
-        Groups.add({ group: 'elements', name: 'zinc', delay: 0.0 })
-      end
-
-      it 'raises an exception if the group cannot be found' do
-        proc { Groups.find('not_found') }.must_raise(GroupNotFound)
-      end
-
-      it 'returns a collection of interface names belonging to the group' do
-        Groups.find('elements').must_equal(Set['zinc'])
-      end
-    end
-
-    describe '#registered' do
-      before do
-        Groups.reset
-        Groups.add({ group: 'elements', name: 'cobalt', delay: 0.0 })
-        Groups.add({ group: 'minerals', name: 'ruby', delay: 0.0 })
-        Groups.add({ group: 'elements', name: 'copper', delay: 0.0 })
-        Groups.add({ group: 'minerals', name: 'diamond', delay: 0.0 })
-      end
-
-      it 'returns all the groups from storage' do
-        Groups.registered.must_equal(['elements', 'minerals'])
-      end
-    end
 
-    describe '#registered?' do
-      it 'returns true when the group is registered' do
-        Groups.add({ group: 'registered' })
+      it 'raises an exception if the attributes does not have a :name key' do
+        attributes = { no_name_key: '' }
 
-        Groups.registered?('registered').must_equal(true)
-      end
-
-      it 'returns false when the group is not registered' do
-        Groups.registered?('not_registered').must_equal(false)
+        proc { Groups.add(attributes) }.must_raise(MissingRequired)
       end
     end
 
-    describe '#reset' do
-      before { Groups.reset }
-
-      it 'removes all known groups from the storage' do
-        Groups.add({ group: 'elements', name: 'bromine', delay: 0.0 })
-        Groups.all.must_equal({ 'elements' => Set['bromine'] })
-        Groups.reset.must_be_empty
-      end
-    end
   end
 end

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

@@ -6,68 +6,32 @@ module Vedeu
     describe '#add' do
       before { Interfaces.reset }
 
-      it 'returns false if the interface name is empty' do
-        Interfaces.add({ name: '' }).must_equal(false)
-      end
-
       it 'adds the interface to the storage' do
         Interfaces.add({ name: 'germanium' })
         Interfaces.all.must_equal({ 'germanium' => { name: 'germanium' } })
       end
-    end
-
-    describe '#all' do
-      before do
-        Interfaces.reset
-        Interfaces.add({ name: 'cobalt' })
-        Interfaces.add({ name: 'nickel' })
-        Interfaces.add({ name: 'copper' })
-      end
-
-      it 'returns the storage' do
-        Interfaces.all.must_equal(
-          {
-            'cobalt' => { name: 'cobalt' },
-            'nickel' => { name: 'nickel' },
-            'copper' => { name: 'copper' }
-          }
-        )
-      end
-    end
-
-    describe '#find' do
-      before { Interfaces.add({ name: 'zinc' }) }
 
-      it 'raises an exception if the interface cannot be found' do
-        proc { Interfaces.find('not_found') }.must_raise(InterfaceNotFound)
-      end
+      it 'raises an exception if the attributes does not have a :name key' do
+        attributes = { no_name_key: '' }
 
-      it 'returns the attributes of the named interface' do
-        Interfaces.find('zinc').must_equal({ name: 'zinc' })
+        proc { Interfaces.add(attributes) }.must_raise(MissingRequired)
       end
     end
 
-    describe '#registered' do
-      before do
-        Interfaces.reset
-        Interfaces.add({ name: 'cobalt' })
-        Interfaces.add({ name: 'ruby' })
-      end
-
-      it 'returns all the registered interfaces from storage' do
-        Interfaces.registered.must_equal(['cobalt', 'ruby'])
-      end
-    end
+    describe '#build' do
+      let(:attributes) { { name: 'rhenium' } }
 
-    describe '#registered?' do
-      it 'returns true when the interface is registered' do
-        Interfaces.add({ name: 'registered' })
+      before { Interfaces.add(attributes) }
+      after  { Interfaces.reset }
 
-        Interfaces.registered?('registered').must_equal(true)
+      it 'returns a new instance of Interface based on the stored attributes' do
+        Interfaces.build('rhenium').must_be_instance_of(Interface)
       end
 
-      it 'returns false when the interface is not registered' do
-        Interfaces.registered?('not_registered').must_equal(false)
+      context 'when the interface cannot be found' do
+        it 'raises an exception' do
+          proc { Interfaces.build('manganese') }.must_raise(InterfaceNotFound)
+        end
       end
     end
 

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

@@ -19,14 +19,6 @@ module Vedeu
       end
     end
 
-    describe '#all' do
-      before { Keymaps.reset }
-
-      it 'returns all stored keymaps' do
-        Keymaps.all.must_equal({ '_global_keymap_' => {} })
-      end
-    end
-
     describe '#find' do
       let(:attributes) {
         {
@@ -157,15 +149,6 @@ module Vedeu
       end
     end
 
-    describe '#registered' do
-      before { Keymaps.reset }
-
-      it 'returns a collection of the interface names of all registered ' \
-      'keymaps' do
-        Keymaps.registered.must_equal(['_global_keymap_'])
-      end
-    end
-
     describe '#registered?' do
       it 'returns false when the named keymap is not registered' do
         Keymaps.registered?('vanadium').must_equal(false)
@@ -176,12 +159,6 @@ module Vedeu
       end
     end
 
-    describe '#reset' do
-      it 'removes all stored keymaps' do
-        Keymaps.reset.must_equal({ '_global_keymap_' => {} })
-      end
-    end
-
     describe '#system_key?' do
       it 'returns false when the key is not registered as a system key' do
         Keymaps.system_key?('r').must_equal(false)

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

@@ -4,7 +4,7 @@ module Vedeu
 
   describe Menus do
 
-    describe 'System events defined by Menus' do
+    describe ' system events defined by Menus' do
       let(:collection) { [:sulphur, :gold, :tin, :helium] }
       let(:instance)   { Vedeu::Menu.new(collection) }
 
@@ -139,8 +139,8 @@ module Vedeu
         Vedeu::Menu.stubs(:new).returns(instance)
       end
 
-      it 'returns false if the menu name is empty' do
-        Menus.add({ name: '' }).must_equal(false)
+      it 'raises an exception if menu name is empty' do
+        proc { Menus.add({ name: '' }) }.must_raise(MissingRequired)
       end
 
       it 'adds the menu to the storage' do
@@ -153,55 +153,6 @@ module Vedeu
       end
     end
 
-    describe '#all' do
-      before do
-        Menus.reset
-        Menus.add({ name: 'barium' })
-        Menus.add({ name: 'lanthanum' })
-        Menus.add({ name: 'cerium' })
-      end
-
-      it 'returns the storage' do
-        Menus.all.keys.must_equal(['barium', 'lanthanum', 'cerium'])
-      end
-    end
-
-    describe '#find' do
-      before { Menus.add({ name: 'erbium' }) }
-
-      it 'raises an exception if the menu cannot be found' do
-        proc { Menus.find('not_found') }.must_raise(MenuNotFound)
-      end
-
-      it 'returns the attributes of the named menu' do
-        Menus.find('erbium').must_be_instance_of(Hash)
-      end
-    end
-
-    describe '#registered' do
-      before do
-        Menus.reset
-        Menus.add({ name: 'barium' })
-        Menus.add({ name: 'caesium' })
-      end
-
-      it 'returns all the registered menus from storage' do
-        Menus.registered.must_equal(['barium', 'caesium'])
-      end
-    end
-
-    describe '#registered?' do
-      it 'returns true when the menu is registered' do
-        Menus.add({ name: 'registered' })
-
-        Menus.registered?('registered').must_equal(true)
-      end
-
-      it 'returns false when the menu is not registered' do
-        Menus.registered?('not_registered').must_equal(false)
-      end
-    end
-
     describe '#remove' do
       it 'returns false when the menu is not registered' do
         Menus.remove('not_registered').must_equal(false)
@@ -221,16 +172,6 @@ module Vedeu
       end
     end
 
-    describe '#reset' do
-      before { Menus.reset }
-
-      it 'removes all known menus from the storage' do
-        Menus.add({ name: 'uranium' })
-        Menus.all.wont_be_empty
-        Menus.reset.must_be_empty
-      end
-    end
-
     describe '#use' do
       let(:collection) { [:calcium, :fermium, :nitrogen, :palladium] }
       let(:instance)   { Vedeu::Menu.new(collection) }

data/test/lib/vedeu/support/esc_test.rb

@@ -2,6 +2,30 @@ require 'test_helper'
 
 module Vedeu
   describe Esc do
+    describe 'colours defined via define_method' do
+      it 'returns an escape sequence for the foreground colour' do
+        Esc.magenta.must_equal("\e[35m")
+      end
+
+      it 'returns an escape sequence for the foreground colour and resets ' \
+         'after calling the block' do
+        Esc.cyan do
+          'ununpentium'
+        end.must_equal("\e[36mununpentium\e[39m")
+      end
+
+      it 'returns an escape sequence for the background colour' do
+        Esc.on_yellow.must_equal("\e[43m")
+      end
+
+      it 'returns an escape sequence for the background colour and resets ' \
+         'after calling the block' do
+        Esc.on_red do
+          'livermorium'
+        end.must_equal("\e[41mlivermorium\e[49m")
+      end
+    end
+
     describe '.string' do
       it 'returns an empty string when the style is not provided' do
         Esc.string.must_equal('')

data/test/lib/vedeu/support/keymap_validator_test.rb

@@ -16,53 +16,34 @@ module Vedeu
     let(:interface) { 'dubnium' }
 
     describe '.check' do
-      context 'when already in use as a system key' do
-        it 'returns false with a message' do
-          result = KeymapValidator.check(storage, :shift_tab, interface)
-          result.must_include(false)
-          result.last.must_match(/by the system/)
-        end
+      it 'raises an exception when already in use as a system key' do
+        proc {
+          KeymapValidator.check(storage, :shift_tab, interface)
+        }.must_raise(KeyInUse)
       end
 
-      context 'when already in use as a global key' do
-        it 'returns false with a message' do
-          result = KeymapValidator.check(storage, 'g', interface)
-          result.must_include(false)
-          result.last.must_match(/as a global key/)
-        end
+      it 'raises an exception when already in use as a global key' do
+        proc {
+          KeymapValidator.check(storage, 'g', interface)
+        }.must_raise(KeyInUse)
       end
 
-      context 'when already in use by the interface' do
-        it 'returns false with a message' do
-          result = KeymapValidator.check(storage, 'a', interface)
-          result.must_include(false)
-          result.last.must_match(/by this interface/)
-        end
+      it 'raises an exception when already in use by the interface' do
+        proc {
+          KeymapValidator.check(storage, 'a', interface)
+        }.must_raise(KeyInUse)
       end
 
-      context 'when attempting to register a global key which is already in ' \
-              'use by an interface' do
-        it 'returns false with a message' do
-          result = KeymapValidator.check(storage, 'a', '')
-          result.must_include(false)
-          result.last.must_match(/therefore cannot be global/)
-        end
+      it 'raises an exception when already in use' do
+        proc { KeymapValidator.check(storage, 'a', '') }.must_raise(KeyInUse)
       end
 
-      context 'when valid as a global key' do
-        it 'returns true with a message' do
-          result = KeymapValidator.check(storage, 'h', '')
-          result.must_include(true)
-          result.last.must_match(/can be registered/)
-        end
+      it 'returns true when valid as a global key' do
+        KeymapValidator.check(storage, 'h', '').must_equal(true)
       end
 
-      context 'when valid as an interface key' do
-        it 'returns true with a message' do
-          result = KeymapValidator.check(storage, 'b', 'dubnium')
-          result.must_include(true)
-          result.last.must_match(/can be registered/)
-        end
+      it 'returns true when valid as an interface key' do
+        KeymapValidator.check(storage, 'b', 'dubnium').must_equal(true)
       end
     end
 
@@ -73,7 +54,7 @@ module Vedeu
         interface = ''
 
         KeymapValidator.new(storage, key, interface)
-          .must_be_instance_of(KeymapValidator)
+        .must_be_instance_of(KeymapValidator)
       end
     end
 

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

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Vedeu
+  EntityNotFound = Class.new(StandardError)
+
+  class RepositoryTestClass
+    include Repository
+
+    def in_memory
+      {}
+    end
+    alias_method :storage, :in_memory
+
+    def not_found(name)
+      fail EntityNotFound
+    end
+  end
+
+  describe Repository do
+
+    describe '#all' do
+      it 'returns a Hash' do
+        RepositoryTestClass.new.all.must_be_instance_of(Hash)
+      end
+
+      it 'returns the whole repository' do
+        RepositoryTestClass.new.all.must_equal({})
+      end
+    end
+
+    describe '#find' do
+      it 'raises an exception when the entity cannot be found' do
+        proc { RepositoryTestClass.new.find('terbium') }
+          .must_raise(EntityNotFound)
+      end
+    end
+
+    describe '#registered' do
+      it 'returns an Array' do
+        RepositoryTestClass.new.registered.must_be_instance_of(Array)
+      end
+
+      it 'returns a collection of the names of all the registered entities' do
+        RepositoryTestClass.new.registered.must_equal([])
+      end
+    end
+
+    describe '#registered?' do
+      it 'returns a FalseClass' do
+        RepositoryTestClass.new.registered?('terbium')
+          .must_be_instance_of(FalseClass)
+      end
+
+      it 'returns false when the entity is not registered' do
+        RepositoryTestClass.new.registered?('terbium').must_equal(false)
+      end
+    end
+
+    describe '#reset' do
+      it 'returns a Hash' do
+        RepositoryTestClass.new.reset.must_be_instance_of(Hash)
+      end
+
+      it 'resets the repository' do
+        RepositoryTestClass.new.reset.must_equal({})
+      end
+    end
+
+  end
+end