vedeu 0.8.4 → 0.8.5

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

@@ -57,12 +57,7 @@ module Vedeu
         context 'when the mouse input was not recognised' do
           let(:input) { "\e[Mb0(" }
 
-          it do
-            Vedeu.expects(:trigger).with(:_mouse_event_, input)
-            subject.
-              must_equal("\e[93m[input]    \e[39m\e[33mVedeu does not " \
-                         "support mouse button '66' yet.\e[39m")
-          end
+          it { subject.must_equal(false) }
         end
       end
 

data/test/lib/vedeu/logging/log_test.rb

@@ -20,9 +20,20 @@ module Vedeu
       describe '.log' do
         subject { described.log(message: _message, force: force, type: type) }
 
-        it { subject.must_equal(
-          "\e[97m[info]     \e[39m\e[37mSome message...\e[39m"
-        ) }
+        context 'when :force is true' do
+          let(:force) { true }
+          let(:expected) {
+            "\e[97m[info]     \e[39m\e[37mSome message...\e[39m"
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when :force is false' do
+          let(:force) { false }
+
+          it { subject.must_equal(nil) }
+        end
       end
 
       describe '.log_stdout' do

data/test/lib/vedeu/presentation/colour_test.rb

@@ -26,6 +26,44 @@ module Vedeu
       let(:foreground) { '#aadd00' }
       let(:parent)     { Vedeu::ParentPresentationColourTestClass.new }
 
+      describe '#background' do
+        subject { includer.background }
+
+        it { subject.must_be_instance_of(Vedeu::Colours::Background) }
+
+        context 'when a colour is not set' do
+          let(:colour) {}
+
+          context 'when a parent is not available' do
+            let(:parent) {}
+
+            it { subject.colour.must_equal('') }
+          end
+
+          context 'when a parent is available' do
+            it { subject.colour.must_equal('#330000') }
+          end
+        end
+
+        context 'when a colour is set' do
+          it { subject.colour.must_equal('#000033') }
+        end
+
+        # @todo Add more tests.
+      end
+
+      describe '#background=' do
+        subject { includer.background = '#987654' }
+
+        it do
+          includer.colour.background.colour.must_equal('#000033')
+          subject
+          includer.colour.background.colour.must_equal('#987654')
+        end
+
+        it { subject.must_equal('#987654') }
+      end
+
       describe '#colour' do
         subject { includer.colour }
 
@@ -63,6 +101,45 @@ module Vedeu
         it { subject.must_be_instance_of(Vedeu::Colours::Colour) }
       end
 
+      describe '#foreground' do
+        subject { includer.foreground }
+
+        it { subject.must_be_instance_of(Vedeu::Colours::Foreground) }
+        it { subject.colour.must_equal('#aadd00') }
+
+        context 'when a colour is not set' do
+          let(:colour) {}
+
+          context 'when a parent is not available' do
+            let(:parent) {}
+
+            it { subject.colour.must_equal('') }
+          end
+
+          context 'when a parent is available' do
+            it { subject.colour.must_equal('#00aadd') }
+          end
+        end
+
+        context 'when a colour is set' do
+          it { subject.colour.must_equal('#aadd00') }
+        end
+
+        # @todo Add more tests.
+      end
+
+      describe '#foreground=' do
+        subject { includer.foreground = '#123456' }
+
+        it do
+          includer.colour.foreground.colour.must_equal('#aadd00')
+          subject
+          includer.colour.foreground.colour.must_equal('#123456')
+        end
+
+        it { subject.must_equal('#123456') }
+      end
+
     end # Colour
 
   end # Presentation

data/test/lib/vedeu/{geometries/positionable_test.rb → presentation/position_test.rb}

@@ -4,9 +4,9 @@ require 'test_helper'
 
 module Vedeu
 
-  module Geometries
+  module Presentation
 
-    describe Positionable do
+    describe Position do
 
       # describe '#position' do
       #   subject { instance.position }
@@ -62,8 +62,8 @@ module Vedeu
       #   end
       # end
 
-    end # Positionable
+    end # Position
 
-  end # Positionable
+  end # Presentation
 
 end # Vedeu

data/test/lib/vedeu/sentence_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Sentence do
+
+    let(:described) { Vedeu::Sentence }
+    let(:elements)  { ['Hydrogen'] }
+    let(:label)     { 'elements' }
+
+    describe '.construct' do
+      subject { described.construct(elements, label) }
+
+      context 'when there is one element' do
+        let(:elements) { ['Hydrogen'] }
+
+        it 'returns the element as a string' do
+          subject.must_equal('Hydrogen')
+        end
+      end
+
+      context 'when there are two elements' do
+        let(:elements) { %w(Hydrogen Helium) }
+
+        it "returns the elements joined with 'and'" do
+          subject.must_equal('Hydrogen and Helium')
+        end
+      end
+
+      context 'when there are more than two elements' do
+        let(:elements) { %w(Hydrogen Helium Lithium) }
+
+        it 'returns the elements as a sentence list' do
+          subject.must_equal('Hydrogen, Helium and Lithium')
+        end
+      end
+
+      context 'when there are no elements' do
+        let(:elements) { [] }
+
+        it 'returns a polite message' do
+          subject.must_equal('No elements have been assigned.')
+        end
+      end
+    end
+
+  end # Sentence
+
+end # Vedeu

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

@@ -0,0 +1,139 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Point do
+
+    let(:described) { Vedeu::Point }
+    let(:instance)  { described.new(value: _value, min: min, max: max) }
+    let(:_value)    { 5 }
+    let(:min)       { 2 }
+    let(:max)       { 9 }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+      it { instance.instance_variable_get('@min').must_equal(min) }
+      it { instance.instance_variable_get('@max').must_equal(max) }
+      it { instance.instance_variable_get('@value').must_equal(_value) }
+    end
+
+    describe '.coerce' do
+      subject { described.coerce(value: _value, min: min, max: max) }
+
+      context 'when :min is not a Fixnum' do
+        let(:min) { :invalid }
+
+        it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      end
+
+      context 'when :max is not a Fixnum' do
+        let(:max) { :invalid }
+
+        it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      end
+
+      context 'when :min > :max' do
+        let(:max) { 4 }
+        let(:min) { 7 }
+
+        it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      end
+
+      context 'when :value is nil' do
+        let(:_value) {}
+
+        it {
+          subject.must_be_instance_of(Vedeu::Point)
+          subject.value.must_equal(min)
+        }
+      end
+
+      context 'when :value is not nil' do
+        context 'when :value is less than min' do
+          let(:_value) { 1 }
+
+          it {
+            subject.must_be_instance_of(Vedeu::Point)
+            subject.value.must_equal(min)
+          }
+        end
+
+        context 'when :value is greater than max' do
+          let(:_value) { 11 }
+
+          it {
+            subject.must_be_instance_of(Vedeu::Point)
+            subject.value.must_equal(max)
+          }
+        end
+
+        context 'when :value > :min and :value < :max' do
+          it {
+            subject.must_be_instance_of(Vedeu::Point)
+            subject.value.must_equal(_value)
+          }
+        end
+      end
+    end
+
+    describe '.valid?' do
+      subject { described.valid?(value: _value, min: min, max: max) }
+
+      context 'when the value is not a Fixnum' do
+        let(:_value) { :invalid }
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the value is a Fixnum' do
+        context 'but the value < min' do
+          let(:_value) { 1 }
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'but the value >= min' do
+          let(:_value) { 5 }
+
+          it { subject.must_equal(true) }
+        end
+
+        context 'but the value > max' do
+          let(:_value) { 11 }
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'but the value <= max' do
+          let(:_value) { 7 }
+
+          it { subject.must_equal(true) }
+        end
+      end
+    end
+
+    describe '#coerce' do
+      it { instance.must_respond_to(:coerce) }
+    end
+
+    describe '#valid?' do
+      it { instance.must_respond_to(:valid?) }
+    end
+
+    describe '#value' do
+      subject { instance.value }
+
+      context 'when :value is nil' do
+        let(:_value) {}
+
+        it { subject.must_equal(min) }
+      end
+
+      context 'when :value is not nil' do
+        it { subject.must_equal(_value) }
+      end
+    end
+
+  end # Point
+
+end # Vedeu

data/test/lib/vedeu/terminal/terminal_test.rb

@@ -112,20 +112,12 @@ module Vedeu
         subject.must_equal(["\e[?25h"])
       end
 
-      it 'hides the cursor in raw mode' do
+      it 'leaves the cursor hidden in raw mode' do
         described.raw_mode!
         subject.must_equal(nil)
       end
     end
 
-
-    describe '.cursor' do
-      subject { described.cursor }
-
-      #it { subject.must_be_instance_of(Array) }
-      #it { subject.must_be_instance_of(Vedeu::Geometries::Position) }
-    end
-
     describe '.centre' do
       subject { described.centre }
 
@@ -161,50 +153,17 @@ module Vedeu
 
       it { subject.must_be_instance_of(Fixnum) }
       it { subject.must_equal(1) }
-      it { described.must_respond_to(:x) }
-      it { described.must_respond_to(:y) }
       it { described.must_respond_to(:tx) }
       it { described.must_respond_to(:ty) }
     end
 
-    describe '.width' do
-      subject { Vedeu::Terminal.width }
-
-      it { subject.must_be_instance_of(Fixnum) }
-      it { described.must_respond_to(:xn) }
-      it { described.must_respond_to(:txn) }
-
-      context 'when the terminal is an odd number of characters in width' do
-        it 'returns the width' do
-          subject.must_equal(40)
-        end
-      end
-    end
-
-    describe '.height' do
-      subject { Vedeu::Terminal.height }
-
-      it { subject.must_be_instance_of(Fixnum) }
-      it { described.must_respond_to(:yn) }
-      it { described.must_respond_to(:tyn) }
-
-      context 'when the terminal is an odd number of characters in height' do
-        it 'returns the height' do
-          subject.must_equal(24)
-        end
-      end
-    end
-
     describe '.size' do
       subject { Vedeu::Terminal.size }
 
       it { subject.must_be_instance_of(Array) }
 
-      context 'when the terminal is an odd number of characters in height or ' \
-              'width' do
-        it 'returns the width and height' do
-          subject.must_equal([24, 40])
-        end
+      it 'returns the width and height' do
+        subject.must_equal([25, 40])
       end
     end
 

data/test/lib/vedeu/views/composition_test.rb

@@ -44,10 +44,6 @@ module Vedeu
         it { instance.instance_variable_get('@value').must_equal(_value) }
       end
 
-      describe '#attributes' do
-        it { instance.must_respond_to(:attributes) }
-      end
-
       describe '#parent' do
         it { instance.must_respond_to(:parent) }
       end
@@ -72,6 +68,30 @@ module Vedeu
         it { instance.must_respond_to(:<<) }
       end
 
+      describe '#attributes' do
+        subject { instance.attributes }
+
+        it { subject.must_be_instance_of(Hash) }
+      end
+
+      describe '#update_buffers' do
+        let(:refresh) {}
+
+        before { Vedeu.stubs(:trigger) }
+
+        subject { instance.update_buffers(refresh) }
+
+        it { subject.must_be_instance_of(described) }
+
+        context 'when the instance has views defined' do
+          # @todo Add more tests.
+        end
+
+        context 'when the instance has no views defined' do
+          # @todo Add more tests.
+        end
+      end
+
     end # Composition
 
   end # Views