vedeu 0.2.11 → 0.2.12

data/test/lib/vedeu/output/output_test.rb

@@ -3,34 +3,36 @@ require 'test_helper'
 module Vedeu
 
   describe Output do
-    # let(:interface) {
-    #   Interface.new({
-    #     name:   'flourine',
-    #     geometry: {
-    #       width:  32,
-    #       height: 3,
-    #     },
-    #     lines:    lines,
-    #     colour:   colour
-    #   })
-    # }
-    # let(:lines) {
-    #   [
-    #     {
-    #       streams: [{ text: 'this is the first' }]
-    #     },
-    #     {
-    #       streams: [{ text: 'this is the second and it is long' }]
-    #     },
-    #     {
-    #       streams: [{ text: 'this is the third, it is even longer and still truncated' }]
-    #     },
-    #     {
-    #       streams: [{ text: 'this should not render' }]
-    #     }
-    #   ]
-    # }
-    # let(:colour) { {} }
+
+    let(:described) { Output.new(interface) }
+    let(:interface) {
+      Interface.new({
+        name:   'flourine',
+        geometry: {
+          width:  32,
+          height: 3,
+        },
+        lines:    lines,
+        colour:   colour
+      })
+    }
+    let(:lines) {
+      [
+        {
+          streams: [{ text: 'this is the first' }]
+        },
+        {
+          streams: [{ text: 'this is the second and it is long' }]
+        },
+        {
+          streams: [{ text: 'this is the third, it is even longer and still truncated' }]
+        },
+        {
+          streams: [{ text: 'this should not render' }]
+        }
+      ]
+    }
+    let(:colour) { {} }
 
     # before do
     #   Buffers.reset
@@ -41,11 +43,10 @@ module Vedeu
     #   Terminal.console.stubs(:print)
     # end
 
-    # describe '#initialize' do
-    #   it 'returns an instance of itself' do
-    #     Output.new(interface).must_be_instance_of(Output)
-    #   end
-    # end
+    describe '#initialize' do
+      it { return_type_for(described, Output) }
+      it { assigns(described, '@interface', interface) }
+    end
 
     # describe '.render' do
     #   it 'returns the content for the interface' do

data/test/lib/vedeu/output/viewport_test.rb

@@ -4,6 +4,7 @@ module Vedeu
 
   describe Viewport do
 
+    let(:described) { Viewport.new(interface) }
     let(:interface) {
       Interface.new({
         name:     'fluorine',
@@ -32,15 +33,14 @@ module Vedeu
     }
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Viewport.new(interface).must_be_instance_of(Viewport)
-      end
+      it { return_type_for(described, Viewport) }
+      it { assigns(described, '@interface', interface) }
+      it { assigns(described, '@top', 0) }
+      it { assigns(described, '@left', 0) }
     end
 
     describe '.show' do
-      it 'returns an Array' do
-        Viewport.show(interface).must_be_instance_of(Array)
-      end
+      it { return_type_for(Viewport.show(interface), Array) }
 
       context 'when there is no content' do
         before { interface.stubs(:content).returns([]) }

data/test/lib/vedeu/repositories/models/buffer_test.rb

@@ -4,6 +4,7 @@ module Vedeu
 
   describe Buffer do
 
+    let(:described) { Buffer.new(attributes) }
     let(:attributes) {
       {
         name:     '',
@@ -17,42 +18,36 @@ module Vedeu
     let(:previous) { {} }
 
     describe '#initialize' do
-      it 'returns an instance of Buffer' do
-        Buffer.new(attributes).must_be_instance_of(Buffer)
-      end
+      it { return_type_for(described, Buffer) }
+      it { assigns(described, '@name', '') }
+      it { assigns(described, '@back', {}) }
+      it { assigns(described, '@front', {}) }
+      it { assigns(described, '@previous', {}) }
     end
 
     describe '#back' do
-      subject { Buffer.new(attributes).back }
-
-      it { subject.must_be_instance_of(Hash) }
+      it { return_type_for(described.back, Hash) }
     end
 
     describe '#front' do
-      subject { Buffer.new(attributes).front }
-
-      it { subject.must_be_instance_of(Hash) }
+      it { return_type_for(described.front, Hash) }
 
       context 'alias method: #current' do
-        subject { Buffer.new(attributes).current }
-
-        it { subject.must_be_instance_of(Hash) }
+        it { return_type_for(described.current, Hash) }
       end
     end
 
     describe '#name' do
-      subject { Buffer.new(attributes).name }
-
-      it { subject.must_be_instance_of(String) }
+      it { return_type_for(described.name, String) }
     end
 
     describe '#previous' do
-      subject { Buffer.new(attributes).previous }
-
-      it { subject.must_be_instance_of(Hash) }
+      it { return_type_for(described.previous, Hash) }
     end
 
     describe '#content' do
+      it { return_type_for(described.content, Array) }
+
       subject { Buffer.new(attributes).content }
 
       context 'when there is content on the back buffer' do

data/test/lib/vedeu/repositories/models/cursor_test.rb

@@ -4,6 +4,7 @@ module Vedeu
 
   describe Cursor do
 
+    let(:described)  { Cursor.new(attributes) }
     let(:attributes) {
       {
         name:  'silver',
@@ -25,23 +26,24 @@ module Vedeu
     end
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Cursor.new(attributes).must_be_instance_of(Cursor)
-      end
+      it { return_type_for(described, Cursor) }
+      it { assigns(described, '@attributes', attributes) }
+      it { assigns(described, '@name', 'silver') }
+      it { assigns(described, '@state', :show) }
+      it { assigns(described, '@x', 19) }
+      it { assigns(described, '@y', 8) }
     end
 
     describe '#attributes' do
       it 'returns a hash containing the attributes of the instance' do
-        Cursor.new(attributes).attributes.must_equal(
+        described.attributes.must_equal(
           { name: 'silver', state: :show, x: 19, y: 8 }
         )
       end
     end
 
     describe '#x' do
-      it 'returns a Fixnum' do
-        Cursor.new(attributes).x.must_be_instance_of(Fixnum)
-      end
+      it { return_type_for(described.x, Fixnum) }
 
       context 'when the cursors position is outside the interface' do
         let(:attributes) { { name: 'silver', state: :show, x: 10, y: 8 } }
@@ -58,22 +60,20 @@ module Vedeu
 
         it 'repositions the cursor at the end of the line' do
           Cursor.new(attributes).attributes.must_equal(
-            { name: 'silver', state: :show, x: 21, y: 8 }
+            { name: 'silver', state: :show, x: 22, y: 8 }
           )
         end
       end
     end
 
     describe '#y' do
-      it 'returns a Fixnum' do
-        Cursor.new(attributes).y.must_be_instance_of(Fixnum)
-      end
+      it { return_type_for(described.y, Fixnum) }
 
       context 'when the cursors position is outside the interface' do
         let(:attributes) { { name: 'silver', state: :show, x: 19, y: 3 } }
 
         it 'repositions the cursor at the start of the line' do
-          Cursor.new(attributes).attributes.must_equal(
+          described.attributes.must_equal(
             { name: 'silver', state: :show, x: 19, y: 5 }
           )
         end
@@ -83,8 +83,8 @@ module Vedeu
         let(:attributes) { { name: 'silver', state: :show, x: 19, y: 12 } }
 
         it 'repositions the cursor at the end of the line' do
-          Cursor.new(attributes).attributes.must_equal(
-            { name: 'silver', state: :show, x: 19, y: 8 }
+          described.attributes.must_equal(
+            { name: 'silver', state: :show, x: 19, y: 9 }
           )
         end
       end
@@ -92,7 +92,7 @@ module Vedeu
 
     describe '#refresh' do
       it 'returns a hash containing the attributes of the instance' do
-        Cursor.new(attributes).refresh.must_equal(
+        described.refresh.must_equal(
           { name: 'silver', state: :show, x: 19, y: 8 }
         )
       end
@@ -100,7 +100,7 @@ module Vedeu
 
     describe '#show' do
       it 'sets the state attribute to :show' do
-        cursor = Cursor.new(attributes)
+        cursor = described
         cursor.hide
         cursor.attributes.must_equal(
           { name: 'silver', state: :hide, x: 19, y: 8 }
@@ -114,7 +114,7 @@ module Vedeu
 
     describe '#hide' do
       it 'sets the state attribute to :hide' do
-        cursor = Cursor.new(attributes)
+        cursor = described
         cursor.hide
         cursor.attributes.must_equal(
           { name: 'silver', state: :hide, x: 19, y: 8 }
@@ -126,7 +126,7 @@ module Vedeu
     describe '#to_s' do
       context 'when the cursor state is :show' do
         it 'returns an escape sequence for showing the cursor (and position)' do
-          cursor = Cursor.new(attributes)
+          cursor = described
           cursor.show
           cursor.to_s.must_equal("\e[8;19H\e[?25h")
         end
@@ -134,7 +134,7 @@ module Vedeu
 
       context 'when the cursor state is :hide' do
          it 'returns an escape sequence for hiding the cursor (and position)' do
-          cursor = Cursor.new(attributes)
+          cursor = described
           cursor.hide
           cursor.to_s.must_equal("\e[8;19H\e[?25l")
         end
@@ -142,12 +142,12 @@ module Vedeu
 
       it 'returns the escape sequence to position and set the visibility of ' \
          'the cursor' do
-        Cursor.new(attributes).to_s.must_equal("\e[8;19H\e[?25h")
+        described.to_s.must_equal("\e[8;19H\e[?25h")
       end
 
       it 'returns the escape sequence to position and set the visibility of ' \
          'the cursor and returns to that position after yielding the block' do
-        Cursor.new(attributes).to_s do
+        described.to_s do
           # ...
         end.must_equal("\e[8;19H\e[?25h\e[8;19H\e[?25h")
       end

data/test/lib/vedeu/repositories/models/event_test.rb

@@ -4,15 +4,21 @@ module Vedeu
 
   describe Event do
 
+    let(:described)  { Event.new(event_name, options, closure) }
     let(:event_name) { :some_event }
     let(:options)    { {} }
     let(:closure)    { proc { :event_triggered } }
 
-
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Event.new(event_name, options, closure).must_be_instance_of(Event)
-      end
+      it { return_type_for(described, Event) }
+      it { assigns(described, '@name', :some_event) }
+      it { assigns(described, '@options', options) }
+
+      it { skip; assigns(described, '@closure', closure) }
+
+      it { assigns(described, '@deadline', 0) }
+      it { assigns(described, '@executed_at', 0) }
+      it { assigns(described, '@now', 0) }
     end
 
     describe '#trigger' do

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

@@ -4,10 +4,13 @@ module Vedeu
 
   describe Group do
 
+    let(:described) { Group.new('organics', *members) }
+    let(:members)   { ['carbon', 'nitrogen', 'oxygen'] }
+
     describe '#initialize' do
-      it 'returns a Group' do
-        Group.new('organics').must_be_instance_of(Group)
-      end
+      it { return_type_for(described, Group) }
+      it { assigns(described, '@members', members.to_set) }
+      it { assigns(described, '@name', 'organics') }
     end
 
     describe '#add' do
@@ -33,9 +36,7 @@ module Vedeu
     end
 
     describe '#members' do
-      it 'returns an instance of Array' do
-        Group.new('organics').members.must_be_instance_of(Array)
-      end
+      it { return_type_for(described.members, Array) }
 
       context 'when the group has no members' do
         it 'returns an empty Set' do
@@ -83,9 +84,7 @@ module Vedeu
     end
 
     describe '#reset' do
-      it 'returns a Group' do
-        Group.new('organics').reset.must_be_instance_of(Group)
-      end
+      it { return_type_for(described.reset, Group) }
 
       it 'returns a Group with no members' do
         group     = Group.new('organics', 'nitrogen', 'carbon')

data/test/lib/vedeu/repositories/models/interface_test.rb

@@ -3,6 +3,9 @@ require 'test_helper'
 module Vedeu
 
   describe Interface do
+    let(:described)  { Interface.new(attributes) }
+    let(:attributes) { {} }
+
     let(:interface) { Vedeu.use('#initialize') }
 
     before do
@@ -18,41 +21,60 @@ module Vedeu
     end
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        interface.must_be_instance_of(Interface)
-      end
+      it { return_type_for(described, Interface) }
+      it { assigns(described, '@attributes', {
+          border:   {},
+          colour:   {},
+          cursor:   :hide,
+          delay:    0.0,
+          geometry: {},
+          group:    '',
+          lines:    [],
+          name:     '',
+          parent:   nil,
+          style:    ''
+        })
+      }
+      it { assigns(described, '@cursor', :hide) }
+      it { assigns(described, '@delay', 0.0) }
+      it { assigns(described, '@group', '') }
+      it { assigns(described, '@name', '') }
+      it { assigns(described, '@parent', nil) }
     end
 
     describe '#attributes' do
       it 'returns the value' do
         interface.attributes.must_equal(
           {
-            cursor: :hide,
-            name: '#initialize',
-            group: 'my_group',
-            lines: [],
+            border: {},
             colour: {
               foreground: '#ff0000',
               background: '#000000'
             },
-            style: '',
+            cursor: :hide,
+            delay: 0.0,
             geometry: {
               y: 3,
               x: 5,
               width: 10,
-              height: 15
+              height: 15,
             },
-            delay: 0.0,
-            parent: nil
+            group: 'my_group',
+            lines: [],
+            name: '#initialize',
+            parent: nil,
+            style: '',
           }
         )
       end
     end
 
+    describe '#border' do
+      it { return_type_for(described.border, Border) }
+    end
+
     describe '#cursor' do
-      it 'returns a Cursor' do
-        interface.cursor.must_be_instance_of(Cursor)
-      end
+      it { return_type_for(described.cursor, Cursor) }
     end
 
     describe '#name' do
@@ -88,9 +110,7 @@ module Vedeu
     end
 
     describe '#geometry' do
-      it 'returns the value' do
-        interface.geometry.must_be_instance_of(Geometry)
-      end
+      it { return_type_for(described.geometry, Geometry) }
     end
 
     describe '#delay' do