vedeu 0.2.12 → 0.3.0

data/test/lib/vedeu/input/mapper_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Mapper do
+
+    let(:described)  { Vedeu::Mapper }
+    let(:instance)   { described.new(key, keymap, repository) }
+    let(:key)        {}
+    let(:keymap)     {}
+    let(:repository) {}
+
+    before do
+      Vedeu.keymaps.reset
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@key').must_equal(key) }
+      it { subject.instance_variable_get('@name').must_equal(keymap) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.keymaps) }
+
+      context 'when the repository is provided' do
+        let(:repository) { Vedeu::Repository.new }
+
+        it { subject.instance_variable_get('@repository').must_equal(repository) }
+      end
+    end
+
+    describe '.keypress' do
+      let(:keymap) { 'test' }
+
+      subject { described.keypress(key, keymap) }
+
+      context 'when the key is not provided' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the key is provided' do
+        let(:key) { 'a' }
+
+        context 'and the key is defined' do
+          let(:key_test) { Key.new('a') { :do_something } }
+          let(:keymap_test) { Keymap.new('test', [key_test]) }
+
+          before do
+            Vedeu.keymaps.reset
+            Vedeu.keymaps.store(keymap_test)
+          end
+
+          it { subject.must_equal(true) }
+        end
+
+        context 'and the key is not defined' do
+          it { subject.must_equal(false) }
+        end
+      end
+    end
+
+    describe '.valid?' do
+      let(:keymap) { 'test' }
+
+      subject { described.valid?(key, keymap) }
+
+      context 'when the key is not provided' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the key is provided' do
+        let(:key) { 'a' }
+
+        context 'and the key is defined' do
+          let(:key_test) { Key.new('a') { :do_something } }
+          let(:keymap_test) { Keymap.new('test', [key_test]) }
+
+          before do
+            Vedeu.keymaps.reset
+            Vedeu.keymaps.store(keymap_test)
+          end
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'and the key is not defined' do
+          it { subject.must_equal(true) }
+        end
+      end
+    end
+
+  end # Mapper
+
+end # Vedeu

data/test/lib/vedeu/launcher_test.rb

@@ -3,6 +3,7 @@ require 'test_helper'
 module Vedeu
 
   describe Launcher do
+
     let(:described) { Launcher.new }
 
     before do
@@ -12,18 +13,14 @@ module Vedeu
       Kernel.stubs(:puts)
     end
 
-    describe '.execute' do
-      it { skip }
-    end
-
     describe '#initialize' do
-      it { return_type_for(described, Launcher) }
-      it { assigns(described, '@argv', []) }
-      it { assigns(described, '@stdin', STDIN) }
-      it { assigns(described, '@stdout', STDOUT) }
-      it { assigns(described, '@stderr', STDERR) }
-      it { assigns(described, '@kernel', Kernel) }
-      it { assigns(described, '@exit_code', 1) }
+      it { described.must_be_instance_of(Launcher) }
+      it { described.instance_variable_get('@argv').must_equal([]) }
+      it { described.instance_variable_get('@stdin').must_equal(STDIN) }
+      it { described.instance_variable_get('@stdout').must_equal(STDOUT) }
+      it { described.instance_variable_get('@stderr').must_equal(STDERR) }
+      it { described.instance_variable_get('@kernel').must_equal(Kernel) }
+      it { described.instance_variable_get('@exit_code').must_equal(1) }
     end
 
     describe '#execute!' do
@@ -31,15 +28,17 @@ module Vedeu
         Launcher.new.execute!.must_equal(0)
       end
 
-      context 'when execution causes an uncaught exception' do
-        before { Application.stubs(:start).raises(StandardError) }
-
-        it 'returns 1 for unsuccessful execution' do
-          skip 'This test is incorrect and fails.'
-
-          Launcher.new.execute!.must_equal(1)
-        end
-      end
+      # context 'when an exception is raised' do
+      #   before do
+      #     Application.stubs(:start).raises(StandardError)
+      #   end
+
+      #   it 'displays the exception' do
+      #     capture_io do
+      #       Launcher.new.execute!
+      #     end.must_equal(["", ""])
+      #   end
+      # end
     end
 
   end # Launcher

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

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Model
+
+    describe Collection do
+
+      let(:described)  { Collection }
+      let(:instance)   { described.new(collection, parent, model_name) }
+      let(:collection) { [] }
+      let(:model_name) { 'elements' }
+      let(:parent)     { Vedeu::ModelTestClass.new }
+
+      describe '#initialize' do
+        subject { instance }
+
+        it { subject.must_be_instance_of(Collection) }
+        it { subject.instance_variable_get('@collection').must_equal([]) }
+        it { subject.instance_variable_get('@name').must_equal(model_name) }
+        it { subject.instance_variable_get('@parent').must_equal(parent) }
+      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 { 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
+
+      describe '#all' do
+        subject { instance.all }
+
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal([]) }
+
+        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
+
+      describe '#empty?' do
+        subject { instance.empty? }
+
+        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) }
+
+          it { subject.must_be_instance_of(FalseClass) }
+        end
+      end
+
+      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
+
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
+
+          it { subject.must_equal(1) }
+        end
+      end
+
+      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
+
+        context 'when the collection is not empty' do
+          before { instance.add(:hydrogen) }
+
+          it { subject.must_equal('hydrogen') }
+        end
+      end
+
+    end # Collection
+
+  end # Model
+
+end # Vedeu

data/test/lib/vedeu/{repositories → models}/focus_test.rb

@@ -4,8 +4,9 @@ module Vedeu
 
   describe Focus do
 
+    let(:described) { Vedeu::Focus }
+
     before { Focus.reset }
-    after  { Focus.reset }
 
     describe '#add' do
       it 'adds an interface to storage' do
@@ -18,6 +19,14 @@ module Vedeu
         Focus.registered.must_equal(['thallium'])
       end
 
+      it 'does not add it again if already exists' do
+        Focus.add('thallium')
+        Focus.add('lead')
+        Focus.add('bismuth')
+        Focus.add('bismuth', true)
+        Focus.registered.must_equal(['bismuth', 'thallium', 'lead'])
+      end
+
       it 'adds the interface to storage focussed' do
         Focus.add('thallium')
         Focus.add('lead', true)
@@ -42,30 +51,44 @@ module Vedeu
       it 'raises an exception if the interface does not exist' do
         proc { Focus.by_name('not_found') }.must_raise(ModelNotFound)
       end
+
+      context 'API methods' do
+        it 'the named interface is focussed when the method is called' do
+          Focus.add('thallium')
+          Focus.add('lead')
+          Focus.add('bismuth')
+          Vedeu.focus_by_name('lead').must_equal('lead')
+        end
+
+        it 'raises an exception if the interface does not exist' do
+          proc { Vedeu.focus_by_name('not_found') }.must_raise(ModelNotFound)
+        end
+      end
     end
 
     describe '#current' do
+      subject { described.current }
+
       it 'returns the name of the interface currently in focus' do
         Focus.add('thallium')
         Focus.add('lead')
         Focus.add('bismuth')
-        Focus.current.must_equal('thallium')
+        subject.must_equal('thallium')
       end
 
-      it 'raises an exception if there are no interfaces defined' do
-        proc { Focus.current }.must_raise(NoInterfacesDefined)
-      end
-    end
+      context 'when no interfaces are defined' do
+        before { Focus.reset }
 
-    describe '#cursor' do
-      before do
-        Interfaces.add({ name: 'thallium' })
-        Focus.add('thallium')
+        it { subject.must_equal(nil) }
       end
 
-      it 'returns the escape sequence to render the cursor for the focussed ' \
-         'interface' do
-        Focus.cursor.must_equal("\e[1;1H\e[?25l")
+      context 'API methods' do
+        it 'returns the name of the interface currently in focus' do
+          Focus.add('thallium')
+          Focus.add('lead')
+          Focus.add('bismuth')
+          Vedeu.focus.must_equal('thallium')
+        end
       end
     end
 
@@ -79,6 +102,16 @@ module Vedeu
       context 'when the interface is not currently in focus' do
         it { Focus.current?('bismuth').must_equal(false) }
       end
+
+      context 'API methods' do
+        context 'when the interface is currently in focus' do
+          it { Vedeu.focussed?('lead').must_equal(true) }
+        end
+
+        context 'when the interface is not currently in focus' do
+          it { Vedeu.focussed?('bismuth').must_equal(false) }
+        end
+      end
     end
 
     describe '#next_item' do

data/test/lib/vedeu/models/geometry_test.rb

@@ -5,6 +5,7 @@ module Vedeu
   describe Geometry do
 
     let(:described)  { Geometry.new(attributes) }
+    let(:instance)   { Geometry.new(attributes) }
     let(:attributes) { {} }
 
     before do
@@ -12,20 +13,40 @@ module Vedeu
     end
 
     describe '#initialize' do
-      it { return_type_for(described, Geometry) }
-      it { assigns(described, '@attributes', {
-          centred: false,
-          height:  25,
-          width:   80,
-          x:       1,
-          xn:      nil,
-          y:       1,
-          yn:      nil,
-        })
-      }
-      it { assigns(described, '@centred', false) }
-      it { assigns(described, '@height', 25) }
-      it { assigns(described, '@width', 80) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Geometry) }
+
+      context 'with default attributes' do
+        it { subject.instance_variable_get('@attributes').must_equal({
+            centred: false,
+            height:  25,
+            name:    '',
+            width:   80,
+            x:       1,
+            xn:      80,
+            y:       1,
+            yn:      25,
+          })
+        }
+        it { subject.instance_variable_get('@centred').must_equal(false) }
+        it { subject.instance_variable_get('@height').must_equal(25) }
+        it { subject.instance_variable_get('@name').must_equal('') }
+        it { subject.instance_variable_get('@width').must_equal(80) }
+        it { subject.instance_variable_get('@x').must_equal(1) }
+        it { subject.instance_variable_get('@xn').must_equal(80) }
+        it { subject.instance_variable_get('@y').must_equal(1) }
+        it { subject.instance_variable_get('@yn').must_equal(25) }
+        it { subject.instance_variable_get('@repository').must_equal(Vedeu.geometries) }
+      end
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal(
+        '<Vedeu::Geometry (height:(25/24) width:(80/79) top:1 bottom:25 left:1 right:80)>'
+      ) }
     end
 
     describe '#y' do
@@ -291,31 +312,6 @@ module Vedeu
       end
     end
 
-    describe '#to_h' do
-      it 'returns all the values within the instance as a hash' do
-        geometry = Geometry.new({ height: 6, width: 6, x: 3, y: 3 })
-        geometry.to_h.must_equal(
-          {
-            centred:         false,
-            height:          6,
-            width:           6,
-            x:               3,
-            y:               3,
-            top:             3,
-            right:           9,
-            bottom:          9,
-            left:            3,
-            north:           2,
-            east:            10,
-            south:           10,
-            west:            2,
-            virtual_x:       [3, 4, 5, 6, 7, 8],
-            virtual_y:       [3, 4, 5, 6, 7, 8]
-          }
-        )
-      end
-    end
-
   end # Geometry
 
 end # Vedeu

data/test/lib/vedeu/models/group_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Group do
+
+    let(:described) { Vedeu::Group }
+    let(:instance)  { described.new(_name, members) }
+    let(:_name)     { 'organics' }
+    let(:members)   { ['carbon', 'nitrogen', 'oxygen'] }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Group) }
+      it { subject.instance_variable_get('@members').must_equal(members) }
+      it { subject.instance_variable_get('@name').must_equal(_name) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.groups) }
+    end
+
+    describe '#add' do
+      subject { instance.add('hydrogen') }
+
+      it { subject.must_be_instance_of(Group) }
+
+      context 'when the member already exists' do
+        it 'does not add the member again but returns a new Group' do
+          subject.wont_equal(instance)
+        end
+      end
+
+      context 'when the member does not exist' do
+        it 'adds the member and returns a new Group' do
+          subject.wont_equal(instance)
+        end
+      end
+    end
+
+    describe '#members' do
+      subject { instance.members }
+
+      it { subject.must_be_instance_of(Set) }
+
+      context 'when the group has no members' do
+        let(:members) { [] }
+
+        it 'returns an empty Set' do
+          subject.must_be_empty
+        end
+      end
+
+      context 'when the group has members' do
+        it 'returns a set of members' do
+          subject.wont_be_empty
+        end
+      end
+    end
+
+    describe '#name' do
+      subject { instance.name }
+
+      it { subject.must_equal('organics') }
+    end
+
+    describe '#remove' do
+      let(:member) { 'hydrogen' }
+
+      subject { instance.remove(member) }
+
+      it { subject.must_be_instance_of(described) }
+
+      context 'when the group is already empty' do
+        let(:members) { [] }
+
+        it { subject.wont_equal(instance) }
+      end
+
+      context 'when the member exists' do
+        let(:member) { 'oxygen' }
+
+        it { subject.wont_equal(instance) }
+        it { subject.members.wont_include(member) }
+      end
+
+      context 'when the member does not exist' do
+        it { subject.wont_equal(instance) }
+        it { subject.members.wont_include(member) }
+      end
+    end
+
+    describe '#reset' do
+      subject { instance.reset }
+
+      it { subject.must_be_instance_of(Group) }
+      it { subject.members.must_be_empty }
+    end
+
+  end # Group
+
+end # Vedeu