vedeu 0.0.30 → 0.0.31

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

@@ -17,66 +17,42 @@ module Vedeu
   end
 
   describe Repository do
-    let(:described_class) { DummyRepository }
-
-    before do
-      @dummy = DummyRepository.create(Dummy.new)
-    end
-
-    after do
-      DummyRepository.reset
-    end
-
     describe '#adaptor' do
-      let(:subject) { described_class.adaptor }
-
       it 'returns a Storage' do
-        subject.must_be_instance_of(Storage)
+        DummyRepository.adaptor.must_be_instance_of(Storage)
       end
     end
 
     describe '#find' do
-      let(:subject)     { described_class.find(record_name) }
-      let(:record_name) { @dummy.name }
-
       it 'returns a Dummy' do
-        subject.must_be_instance_of(Dummy)
+        dummy = DummyRepository.create(Dummy.new)
+        DummyRepository.find(dummy.name).must_be_instance_of(Dummy)
       end
     end
 
     describe '#all' do
-      let(:subject) { described_class.all }
-
       it 'returns all the stored items' do
-        subject.must_be_instance_of(Array)
+        DummyRepository.all.must_be_instance_of(Array)
       end
     end
 
     describe '#query' do
-      let(:subject)   { described_class.query(entity, attribute, value) }
-      let(:entity)     { Dummy }
-      let(:attribute) { :name }
-      let(:value)     { 'dummy' }
-
       it 'returns a Dummy' do
-        subject.must_be_instance_of(Dummy)
+        dummy = DummyRepository.create(Dummy.new)
+        DummyRepository.query(Dummy, :name, 'dummy').must_be_instance_of(Dummy)
       end
     end
 
     describe '#create' do
-      let(:subject) { described_class.create(model) }
-      let(:model)   { @dummy }
-
       it 'returns a Dummy' do
-        subject.must_be_instance_of(Dummy)
+        dummy = DummyRepository.create(Dummy.new)
+        DummyRepository.create(dummy).must_be_instance_of(Dummy)
       end
     end
 
     describe '#reset' do
-      let(:subject) { described_class.reset }
-
       it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+        DummyRepository.reset.must_be_instance_of(Array)
       end
     end
   end

data/test/lib/vedeu/repository/storage_test.rb

@@ -2,76 +2,41 @@ require_relative '../../../test_helper'
 require_relative '../../../support/dummy_command'
 require_relative '../../../../lib/vedeu/repository/storage'
 
-
 module Vedeu
   describe Storage do
-    let(:described_class) { Storage }
-    let(:subject)         { described_class.new }
-    let(:record)          { DummyCommand.new }
-    let(:entity)          {}
-
-    describe '#initialize' do
-      let(:subject) { described_class.new }
-
-      it 'returns a Storage instance' do
-        subject.must_be_instance_of(Storage)
-      end
-
-      it 'sets an instance variable' do
-        subject.instance_variable_get('@map').must_equal({})
-      end
-    end
-
     describe '#create' do
-      let(:subject) { described_class.new.create(record) }
-
       it 'returns the stored record' do
-        subject.must_be_instance_of(DummyCommand)
+        Storage.new.create(DummyCommand.new).must_be_instance_of(DummyCommand)
       end
     end
 
     describe '#delete' do
-      let(:subject) { described_class.new.delete(record) }
-
       it 'returns a NilClass' do
-        subject.must_be_instance_of(NilClass)
+        Storage.new.delete(DummyCommand.new).must_be_instance_of(NilClass)
       end
     end
 
     describe '#reset' do
-      let(:subject) { described_class.new.reset(entity) }
-
       it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+        Storage.new.reset(nil).must_be_instance_of(Array)
       end
     end
 
     describe '#find' do
-      let(:subject)     { described_class.new.find(entity, record_name) }
-      let(:record_name) { 'dummy' }
-
       it 'returns a NilClass' do
-        subject.must_be_instance_of(NilClass)
+        Storage.new.find(nil, 'dummy').must_be_instance_of(NilClass)
       end
     end
 
     describe '#all' do
-      let(:subject) { described_class.new.all(entity) }
-
       it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+        Storage.new.all(nil).must_be_instance_of(Array)
       end
     end
 
     describe '#query' do
-      let(:subject)   { described_class.new.query(entity, attribute, value) }
-      let(:attribute) {}
-      let(:value)     {}
-
-      context 'when the item cannot be found' do
-        it 'returns a NilClass' do
-          subject.must_be_instance_of(NilClass)
-        end
+      it 'returns a FalseClass when the item cannot be found' do
+        Storage.new.query(nil, nil, nil).must_be_instance_of(FalseClass)
       end
     end
   end

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

@@ -3,189 +3,105 @@ require_relative '../../../../lib/vedeu/support/esc'
 
 module Vedeu
   describe Esc do
-    let(:described_class) { Esc }
-
     describe '.background_colour' do
-      let(:subject) { described_class.background_colour }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns an escape sequence' do
-        subject.must_equal("\e[48;5;16m")
+        Esc.background_colour.must_equal("\e[48;5;16m")
       end
     end
 
     describe '.clear_line' do
-      let(:subject) { described_class.clear_line }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns an escape sequence' do
-        subject.must_equal("\e[2K")
+        Esc.clear_line.must_equal("\e[2K")
       end
     end
 
-    describe '.foreground_colour' do
-      let(:subject) { described_class.foreground_colour }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
+    describe '.clear_last_line' do
+      it 'returns an escape sequence to clear the last line' do
+        IO.console.stub :winsize, [25, 25] do
+          Esc.clear_last_line.must_equal("\e[24;1H\e[2K")
+        end
       end
+    end
 
+    describe '.foreground_colour' do
       it 'returns an escape sequence' do
-        subject.must_equal("\e[38;5;231m")
+        Esc.foreground_colour.must_equal("\e[38;5;231m")
       end
     end
 
     describe '.set_position' do
-      let(:subject) { described_class.set_position(y, x) }
-      let(:y)       {}
-      let(:x)       {}
-
-      context 'when no coordinates are provided' do
-        it 'returns a position escape sequence' do
-          subject.must_equal("\e[1;1H")
-        end
+      it 'returns a position escape sequence when no coordinates are provided' do
+        Esc.set_position.must_equal("\e[1;1H")
       end
 
-      context 'when coordinates are provided' do
-        let(:y)       { 12 }
-        let(:x)       { 19 }
-
-        it 'returns a position escape sequence' do
-          subject.must_equal("\e[12;19H")
-        end
+      it 'returns a position escape sequence when coordinates are provided' do
+        Esc.set_position(12, 19).must_equal("\e[12;19H")
       end
     end
 
     describe '.string' do
-      let(:subject) { described_class.string(style) }
-      let(:style)   {}
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
+      it 'returns an empty string when the style is not provided' do
+        Esc.string.must_equal('')
       end
 
-      context 'when the style is not provided' do
-        it 'returns an empty string' do
-          subject.must_equal('')
-        end
+      it 'returns an escape sequence when the style is blink' do
+        Esc.string('blink').must_equal("\e[5m")
       end
 
-      context 'when the style is blink' do
-        let(:style) { 'blink' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[5m")
-        end
+      it 'returns an escape sequence when the style is blink off' do
+        Esc.string('blink_off').must_equal("\e[25m")
       end
 
-      context 'when the style is blink off' do
-        let(:style) { 'blink_off' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[25m")
-        end
+      it 'returns an escape sequence when the style is bold' do
+        Esc.string('bold').must_equal("\e[1m")
       end
 
-      context 'when the style is bold' do
-        let(:style) { 'bold' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[1m")
-        end
+      it 'returns an escape sequence when the style is bold off' do
+        Esc.string('bold_off').must_equal("\e[21m")
       end
 
-      context 'when the style is bold off' do
-        let(:style) { 'bold_off' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[21m")
-        end
+      it 'returns an escape sequence when the style is clear' do
+        Esc.string('clear').must_equal("\e[2J")
       end
 
-      context 'when the style is clear' do
-        let(:style) { 'clear' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[2J")
-        end
+      it 'returns an escape sequence when the style is colour_reset' do
+        Esc.string('colour_reset').must_equal("\e[38;2;39m\e[48;2;49m")
       end
 
-      context 'when the style is hide_cursor' do
-        let(:style) { 'hide_cursor' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[?25l")
-        end
+      it 'returns an escape sequence when the style is hide_cursor' do
+        Esc.string('hide_cursor').must_equal("\e[?25l")
       end
 
-      context 'when the style is negative' do
-        let(:style) { 'negative' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[7m")
-        end
+      it 'returns an escape sequence when the style is negative' do
+        Esc.string('negative').must_equal("\e[7m")
       end
 
-      context 'when the style is positive' do
-        let(:style) { 'positive' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[27m")
-        end
+      it 'returns an escape sequence when the style is positive' do
+        Esc.string('positive').must_equal("\e[27m")
       end
 
-      context 'when the style is reset' do
-        let(:style) { 'reset' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[0m")
-        end
+      it 'returns an escape sequence when the style is reset' do
+        Esc.string('reset').must_equal("\e[0m")
       end
 
-      context 'when the style is normal' do
-        let(:style) { 'normal' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[24m\e[21m\e[27m")
-        end
+      it 'returns an escape sequence when the style is normal' do
+        Esc.string('normal').must_equal("\e[24m\e[21m\e[27m")
       end
 
-      context 'when the style is dim' do
-        let(:style) { 'dim' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[2m")
-        end
+      it 'returns an escape sequence when the style is dim' do
+        Esc.string('dim').must_equal("\e[2m")
       end
 
-      context 'when the style is show_cursor' do
-        let(:style) { 'show_cursor' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[?25h")
-        end
+      it 'returns an escape sequence when the style is show_cursor' do
+        Esc.string('show_cursor').must_equal("\e[?25h")
       end
 
-      context 'when the style is underline' do
-        let(:style) { 'underline' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[4m")
-        end
+      it 'returns an escape sequence when the style is underline' do
+        Esc.string('underline').must_equal("\e[4m")
       end
 
-      context 'when the style is underline off' do
-        let(:style) { 'underline_off' }
-
-        it 'returns an escape sequence' do
-          subject.must_equal("\e[24m")
-        end
+      it 'returns an escape sequence when the style is underline off' do
+        Esc.string('underline_off').must_equal("\e[24m")
       end
     end
   end

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

@@ -0,0 +1,31 @@
+require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/repository/event_repository'
+
+module Vedeu
+  describe EventRepository do
+    describe '#handlers' do
+      it 'returns a Hash' do
+        EventRepository.handlers.must_be_instance_of(Hash)
+      end
+    end
+
+    describe '#register' do
+      it 'returns an Array' do
+        EventRepository.register(:some_event) { proc { |x| x } }
+          .must_be_instance_of(Array)
+      end
+    end
+
+    describe '#trigger' do
+      it 'returns a collection containing the event when the event is pre-registered' do
+        EventRepository.register(:some_event) { proc { |x| x } }
+        EventRepository.trigger(:_exit_, []).first.call
+          .must_equal(:exit)
+      end
+
+      it 'returns an empty collection when the event has not been registered' do
+        EventRepository.trigger(:_not_found_, []).must_be_empty
+      end
+    end
+  end
+end

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

@@ -3,17 +3,9 @@ require_relative '../../../../lib/vedeu/support/exit'
 
 module Vedeu
   describe Exit do
-    let(:described_class) { Exit }
-
     describe '.dispatch' do
-      let(:subject) { described_class.dispatch }
-
-      it 'returns a Symbol' do
-        subject.must_be_instance_of(Symbol)
-      end
-
       it 'returns the symbol :stop' do
-        subject.must_equal(:stop)
+        Exit.dispatch.must_equal(:stop)
       end
     end
   end

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

@@ -4,127 +4,103 @@ require_relative '../../../../lib/vedeu/models/interface'
 
 module Vedeu
   describe Geometry do
-    let(:described_class)    { Geometry }
-    let(:described_instance) { described_class.new(interface, index) }
-    let(:interface)          { Interface.new(attributes) }
-    let(:attributes)         {
-      {
-        name:   'dummy',
-        lines:  [],
-        colour: {
-          foreground: '#ff0000',
-          background: '#000000'
-        },
-        width:  7,
-        height: 3
-      }
-    }
-    let(:index) { 0 }
-
-    before do
-      Terminal.stubs(:width).returns(40)
-      Terminal.stubs(:height).returns(25)
-    end
-
     describe '#origin' do
-      it 'returns a String' do
-        described_instance.origin.must_be_instance_of(String)
-      end
-
       it 'returns the origin for the interface' do
-        described_instance.origin.must_equal("\e[1;1H")
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 5,
+          x:      1,
+          y:      1,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[1;1H")
       end
 
-      context 'when the index is provided' do
-        let(:index) { 3 }
-
-        it 'returns the line position relative to the origin' do
-          described_instance.origin.must_equal("\e[4;1H")
-        end
+      it 'returns the line position relative to the origin' do
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 5,
+          x:      1,
+          y:      1,
+          z:      1
+        })
+        Geometry.new(interface).origin(3).must_equal("\e[4;1H")
       end
 
-      context 'when the interface is at a custom position' do
-        let(:attributes) { { y: 6, x: 3 }}
-
-        it 'returns the origin for the interface' do
-          described_instance.origin.must_equal("\e[6;3H")
-        end
-
-        context 'when the index is provided' do
-          let(:index) { 3 }
-
-          it 'returns the line position relative to the origin' do
-            described_instance.origin.must_equal("\e[9;3H")
-          end
-        end
+      it 'returns the origin for the interface when the interface is at a custom position' do
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 5,
+          x:      3,
+          y:      6,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[6;3H")
       end
-    end
 
-    describe '#max_y' do
-      let(:subject) { described_instance.max_y }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
+      it 'returns the line position relative to the origin when the interface is at a custom position' do
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 5,
+          x:      3,
+          y:      6,
+          z:      1
+        })
+        Geometry.new(interface).origin(3).must_equal("\e[9;3H")
       end
 
-      context 'when the value is greater than the available terminal size' do
-        it 'clips the value to the terminal size' do
-          subject.must_equal(4)
-        end
+      it 'clips the maximum height to the terminal height when the height is more than the terminal height' do
+        skip
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 6,
+          x:      1,
+          y:      20,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[1;1H")
       end
 
-      context 'when the value is less than the available size' do
-        let(:attributes) { { y: 20, height: 4 } }
-
-        it 'returns the value' do
-          subject.must_equal(24)
-        end
+      it 'returns the value when the height is less than the terminal height' do
+        skip
+        interface = Interface.new({
+          name:   'dummy',
+          width:  5,
+          height: 2,
+          x:      1,
+          y:      20,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[1;1H")
       end
-    end
-
-    describe '#max_x' do
-      let(:subject) { described_instance.max_x }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'when the value is greater than the available terminal size' do
-        it 'clips the value to the terminal size' do
-          subject.must_equal(8)
-        end
-      end
-
-      context 'when the value is less than the available size' do
-        let(:attributes) { { x: 17, width: 21 } }
-
-        it 'returns the value' do
-          subject.must_equal(38)
-        end
-      end
-    end
-
-    describe '#virtual_x' do
-      let(:subject) { described_instance.virtual_x }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      it 'returns the value' do
-        subject.must_equal(1)
-      end
-    end
-
-    describe '#virtual_y' do
-      let(:subject) { described_instance.virtual_y }
 
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
+      it 'clips the maximum width to the terminal width when the width is more than the terminal width' do
+        interface = Interface.new({
+          name:   'dummy',
+          width:  20,
+          height: 5,
+          x:      30,
+          y:      1,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[1;30H")
       end
 
-      it 'returns the value' do
-        subject.must_equal(1)
+      it 'returns the value when the width is less than the terminal width' do
+        interface = Interface.new({
+          name:   'dummy',
+          width:  20,
+          height: 5,
+          x:      15,
+          y:      1,
+          z:      1
+        })
+        Geometry.new(interface).origin.must_equal("\e[1;15H")
       end
     end
   end