vedeu 0.1.19 → 0.2.0

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

@@ -2,11 +2,22 @@ require 'test_helper'
 
 module Vedeu
   describe Groups do
-    before { Groups.reset }
-    before { Groups.reset }
+    describe '#add' do
+      before { Groups.reset }
+
+      it 'returns false if the group name is empty' do
+        Groups.add({ group: '', name: 'gallium', delay: 0.0 }).must_equal(false)
+      end
+
+      it 'adds the interface name to the group in storage' do
+        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 })
@@ -19,8 +30,24 @@ module Vedeu
       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 })
@@ -32,30 +59,21 @@ module Vedeu
       end
     end
 
-    describe '#find' do
-      before { Groups.add({ group: 'elements', name: 'zinc', delay: 0.0 }) }
-
-      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
+      it 'returns true when the group is registered' do
+        Groups.add({ group: 'registered' })
 
-    describe '#add' do
-      it 'returns false if the group name is empty' do
-        Groups.add({ group: '', name: 'gallium', delay: 0.0 }).must_equal(false)
+        Groups.registered?('registered').must_equal(true)
       end
 
-      it 'adds the interface name to the group in storage' do
-        Groups.add({ group: 'elements', name: 'germanium', delay: 0.0 })
-        Groups.all.must_equal({ 'elements' => Set['germanium'] })
+      it 'returns false when the group is not registered' do
+        Groups.registered?('not_registered').must_equal(false)
       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'] })

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

@@ -2,5 +2,84 @@ require 'test_helper'
 
 module Vedeu
   describe Interfaces do
+
+    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 'returns the attributes of the named interface' do
+        Interfaces.find('zinc').must_equal({ name: 'zinc' })
+      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 '#registered?' do
+      it 'returns true when the interface is registered' do
+        Interfaces.add({ name: 'registered' })
+
+        Interfaces.registered?('registered').must_equal(true)
+      end
+
+      it 'returns false when the interface is not registered' do
+        Interfaces.registered?('not_registered').must_equal(false)
+      end
+    end
+
+    describe '#reset' do
+      before { Interfaces.reset }
+
+      it 'removes all known interfaces from the storage' do
+        Interfaces.add({ name: 'bromine' })
+        Interfaces.all.must_equal({ 'bromine' => { name: 'bromine' } })
+        Interfaces.reset.must_be_empty
+      end
+    end
+
   end
 end

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

@@ -0,0 +1,244 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Menus do
+
+    describe 'System events defined by Menus' do
+      before do
+        Menus.reset
+        Menus.add({ name:  'elements',
+                    items: Vedeu::Menu.new([:sulphur, :gold, :tin, :helium]) })
+      end
+
+      it 'raises an exception when triggered with an unregistered name' do
+        proc {
+          Vedeu.trigger(:_menu_current_, 'unknown')
+        }.must_raise(MenuNotFound)
+      end
+
+      it '_menu_current_' do
+        Vedeu.trigger(:_menu_current_, 'elements').must_equal(:sulphur)
+      end
+
+      it '_menu_selected_ when no item is selected' do
+        Vedeu.trigger(:_menu_selected_, 'elements').must_equal([nil])
+      end
+
+      it '_menu_selected_ when an item is selected' do
+        Vedeu.trigger(:_menu_next_, 'elements')
+        Vedeu.trigger(:_menu_select_, 'elements')
+        Vedeu.trigger(:_menu_selected_, 'elements').must_equal(:gold)
+      end
+
+      it '_menu_next_' do
+        Vedeu.trigger(:_menu_next_, 'elements').must_equal(
+          [
+            [false, false, :sulphur],
+            [false, true, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_prev_' do
+        Vedeu.trigger(:_menu_prev_, 'elements').must_equal(
+          [
+            [false, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_top_' do
+        Vedeu.trigger(:_menu_top_, 'elements').must_equal(
+          [
+            [false, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_bottom_' do
+        Vedeu.trigger(:_menu_bottom_, 'elements').must_equal(
+          [
+            [false, false, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, true, :helium]
+          ]
+        )
+      end
+
+      it '_menu_select_' do
+        Vedeu.trigger(:_menu_select_, 'elements').must_equal(
+          [
+            [true, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_deselect_' do
+        Vedeu.trigger(:_menu_deselect_, 'elements').must_equal(
+          [
+            [false, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_items_' do
+        Vedeu.trigger(:_menu_items_, 'elements').must_equal(
+          [
+            [false, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+
+      it '_menu_view_' do
+        Vedeu.trigger(:_menu_view_, 'elements').must_equal(
+          [
+            [false, true, :sulphur],
+            [false, false, :gold],
+            [false, false, :tin],
+            [false, false, :helium]
+          ]
+        )
+      end
+    end
+
+    describe '#add' do
+      before { Menus.reset }
+
+      it 'returns false if the menu name is empty' do
+        Menus.add({ name: '' }).must_equal(false)
+      end
+
+      it 'adds the menu to the storage' do
+        collection = [:hydrogen, :helium, :beryllium, :lithium]
+        items      = Vedeu::Menu.new(collection)
+
+        Menus.add({ name: 'elements', items: items })
+        Menus.all.must_equal(
+          {
+            'elements' => { name: 'elements', items: items }
+          }
+        )
+      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.must_equal(
+          {
+            'barium' => { name: 'barium' },
+            'lanthanum' => { name: 'lanthanum' },
+            'cerium' => { name: '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_equal({ name: 'erbium' })
+      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)
+      end
+
+      it 'removes the menu from the repository' do
+        Menus.add({ name: 'antimony' })
+        Menus.registered?('antimony').must_equal(true)
+        Menus.remove('antimony')
+        Menus.registered?('antimony').must_equal(false)
+      end
+
+      it 'returns true when the menu was registered and is now removed' do
+        Menus.add({ name: 'tellurium' })
+        Menus.remove('tellurium').must_equal(true)
+        Menus.registered?('tellurium').must_equal(false)
+      end
+    end
+
+    describe '#reset' do
+      before { Menus.reset }
+
+      it 'removes all known menus from the storage' do
+        Menus.add({ name: 'uranium' })
+        Menus.all.must_equal({ 'uranium' => { name: 'uranium' } })
+        Menus.reset.must_be_empty
+      end
+    end
+
+    describe '#use' do
+      it 'returns the Vedeu::Menu instance stored when the named menu exists' do
+        collection = [:calcium, :fermium, :nitrogen, :palladium]
+        items      = Vedeu::Menu.new(collection)
+        Menus.add({ name: 'elements', items: items })
+
+        Menus.use('elements').must_equal(items)
+      end
+
+      it 'raises an exception if there are no items' do
+        Menus.add({ name: 'elements' })
+
+        proc { Menus.use('elements') }.must_raise(MenuNotFound)
+      end
+    end
+
+  end
+end

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

@@ -5,12 +5,6 @@ module Vedeu
     let(:collection) { ['hydrogen', 'carbon', 'nitrogen', 'oxygen'] }
     let(:menu)       { Menu.new(collection) }
 
-    describe '#events' do
-      it 'returns the events defined for menus' do
-        menu.events.must_be_instance_of(Hash)
-      end
-    end
-
     describe '#current' do
       it 'returns the current index' do
         menu.current.must_equal(0)

data/test/test_helper.rb

@@ -25,35 +25,6 @@ ENV['VEDEU_TERM'] = 'xterm-truecolor'
 
 require 'vedeu'
 
-module Vedeu
-  def self.reset_all!
-    Vedeu::Buffers.reset
-    Vedeu::Configuration.reset
-    Vedeu.events.reset
-    Vedeu::Focus.reset
-    Vedeu::Groups.reset
-    Vedeu::Interfaces.reset
-  end
-end
-
-module MyMiniTestPlugin
-  # Code to run before every test case
-  def before_setup
-    super
-    Vedeu.reset_all!
-  end
-
-  # Code to run after every test case
-  def after_teardown
-    Vedeu.reset_all!
-    super
-  end
-end
-
-class MiniTest::Spec
-  include MyMiniTestPlugin
-end
-
 # commented out by default (makes tests slower)
 # require 'minitest/reporters'
 # Minitest::Reporters.use!(