vedeu 0.0.14 → 0.0.15

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

@@ -5,12 +5,16 @@ module Vedeu
     let(:described_class)    { Position }
     let(:described_instance) { described_class.new }
 
-    it { described_instance.must_be_instance_of(Position) }
+    it 'returns a Position instance' do
+      described_instance.must_be_instance_of(Position)
+    end
 
     describe '.set' do
       let(:subject) { described_class.set }
 
-      it { subject.must_be_instance_of(String) }
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
 
       context 'when no coordinates are provided' do
         it 'returns a position escape sequence' do
@@ -32,7 +36,9 @@ module Vedeu
     describe '.reset' do
       let(:subject) { described_class.reset }
 
-      it { subject.must_be_instance_of(String) }
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
 
       it 'returns a position escape sequence' do
         subject.must_equal("\e[1;1H")

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

@@ -6,21 +6,31 @@ module Vedeu
     let(:described_instance) { described_class.new(composition) }
     let(:composition)        { [] }
 
-    it { described_instance.must_be_instance_of(Renderer) }
+    it 'returns a Renderer instance' do
+      described_instance.must_be_instance_of(Renderer)
+    end
 
     describe '.write' do
       let(:subject) { described_class.write(composition) }
 
-      it { subject.must_be_instance_of(Array) }
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
+      end
 
-      it { subject.must_equal([]) }
+      it 'returns an empty array' do
+        subject.must_equal([])
+      end
 
       context 'capturing i/o' do
         let(:captured) { capture_io { subject }.join }
 
-        it { captured.must_be_instance_of(String) }
+        it 'returns a String' do
+          captured.must_be_instance_of(String)
+        end
 
-        it { captured.must_equal("") }
+        it 'returns an empty string' do
+          captured.must_equal("")
+        end
       end
     end
   end

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

@@ -8,56 +8,76 @@ module Vedeu
       let(:subject) { described_class.set(style) }
       let(:style) {}
 
-      it { subject.must_be_instance_of(String) }
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
 
-      it { subject.must_equal('') }
+      it 'returns an empty string' do
+        subject.must_equal('')
+      end
 
       context 'when the style is bold' do
         let(:style) { :bold }
 
-        it { subject.must_equal("\e[1m") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[1m")
+        end
       end
 
       context 'when the style is clear' do
         let(:style) { :clear }
 
-        it { subject.must_equal("\e[2J") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[2J")
+        end
       end
 
       context 'when the style is hide_cursor' do
         let(:style) { :hide_cursor }
 
-        it { subject.must_equal("\e[?25l") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[?25l")
+        end
       end
 
       context 'when the style is inverse' do
         let(:style) { :inverse }
 
-        it { subject.must_equal("\e[7m") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[7m")
+        end
       end
 
       context 'when the style is reset' do
         let(:style) { :reset }
 
-        it { subject.must_equal("\e[0m") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[0m")
+        end
       end
 
       context 'when the style is normal' do
         let(:style) { :normal }
 
-        it { subject.must_equal("\e[0m") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[0m")
+        end
       end
 
       context 'when the style is show_cursor' do
         let(:style) { :show_cursor }
 
-        it { subject.must_equal("\e[?25h") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[?25h")
+        end
       end
 
       context 'when the style is underline' do
         let(:style) { :underline }
 
-        it { subject.must_equal("\e[4m") }
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[4m")
+        end
       end
     end
   end

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

@@ -5,7 +5,9 @@ module Vedeu
     let(:described_class) { Translator }
     let(:html_colour) {}
 
-    it { described_class.new(html_colour).must_be_instance_of(Translator) }
+    it 'returns a Translator instance' do
+      described_class.new(html_colour).must_be_instance_of(Translator)
+    end
 
     describe '#translate' do
       {

data/test/lib/vedeu/process/event_loop_test.rb

@@ -12,20 +12,28 @@ module Vedeu
       Output.stubs(:render)
     end
 
-    it { subject.must_be_instance_of(EventLoop) }
+    it 'returns an EventLoop instance' do
+      subject.must_be_instance_of(EventLoop)
+    end
 
-    it { subject.instance_variable_get("@running").must_equal(true) }
+    it 'sets an instance variable' do
+      subject.instance_variable_get("@running").must_equal(true)
+    end
 
     describe '.main_sequence' do
       let(:subject) { described_class.main_sequence }
 
-      # it { subject.must_be_instance_of(FalseClass) }
+      it 'returns a FalseClass' do
+        subject.must_be_instance_of(FalseClass)
+      end
     end
 
     describe '#stop' do
       let(:subject) { described_class.new.stop }
 
-      # it { subject.must_be_instance_of(FalseClass) }
+      it 'returns a FalseClass' do
+        subject.must_be_instance_of(FalseClass)
+      end
     end
   end
 end

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

@@ -7,9 +7,13 @@ module Vedeu
     describe '.dispatch' do
       let(:subject) { described_class.dispatch }
 
-      it { subject.must_be_instance_of(Symbol) }
+      it 'returns a Symbol' do
+        subject.must_be_instance_of(Symbol)
+      end
 
-      it { subject.must_equal(:stop) }
+      it 'returns the symbol :stop' do
+        subject.must_equal(:stop)
+      end
     end
   end
 end

data/test/lib/vedeu/process/input_test.rb

@@ -8,14 +8,20 @@ module Vedeu
 
     before { Terminal.stubs(:input).returns(input) }
 
-    it { subject.must_be_instance_of(Input) }
+    it 'return an Input instance' do
+      subject.must_be_instance_of(Input)
+    end
 
     describe '.capture' do
       let(:subject) { described_class.capture }
 
-      it { subject.must_be_instance_of(Array) }
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
+      end
 
-      it { subject.wont_be_empty }
+      it 'returns the entered characters' do
+        subject.wont_be_empty
+      end
     end
   end
 end

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

@@ -12,21 +12,29 @@ module Vedeu
       Queue.stubs(:dequeue).returns(result)
     end
 
-    it { subject.must_be_instance_of(Output) }
+    it 'returns an Output instance' do
+      subject.must_be_instance_of(Output)
+    end
 
     describe '.render' do
       let(:subject) { described_class.render }
 
-      it { subject.must_be_instance_of(NilClass) }
+      it 'returns a NilClass' do
+        subject.must_be_instance_of(NilClass)
+      end
 
       context 'when the result is empty' do
-        it { subject.must_be_instance_of(NilClass) }
+        it 'returns a NilClass' do
+          subject.must_be_instance_of(NilClass)
+        end
       end
 
       context 'when the result is not empty' do
         let(:result) { { 'dummy' => [['test...']] } }
 
-        it { subject.must_be_instance_of(Array) }
+        it 'returns an Array' do
+          subject.must_be_instance_of(Array)
+        end
       end
     end
   end

data/test/lib/vedeu/process/process_test.rb

@@ -7,7 +7,9 @@ module Vedeu
     let(:result)          {}
     let(:subject)         { described_class.new }
 
-    it { subject.must_be_instance_of(Process) }
+    it 'returns a Process instance' do
+      subject.must_be_instance_of(Process)
+    end
 
     describe '.evaluate' do
       let(:subject) { described_class.evaluate }
@@ -23,26 +25,34 @@ module Vedeu
       after { Queue.clear }
 
       context 'when there is no input' do
-        it { subject.must_be_instance_of(NilClass) }
+        it 'returns a NilClass' do
+          subject.must_be_instance_of(NilClass)
+        end
       end
 
       context 'when the input is a keypress' do
         let(:input) { "q" }
 
         context 'but there is no result' do
-          it { subject.must_be_instance_of(NilClass) }
+          it 'returns a NilClass' do
+            subject.must_be_instance_of(NilClass)
+          end
         end
 
         context 'or the result is :stop' do
           let(:result) { :stop }
 
-          it { proc { subject }.must_raise(Collapse) }
+          it 'raises an exception' do
+            proc { subject }.must_raise(Collapse)
+          end
         end
 
         context 'or the result is anything else' do
           let(:result) { :something_else }
 
-          it { subject.must_be_instance_of(Array) }
+          it 'returns an Array' do
+            subject.must_be_instance_of(Array)
+          end
         end
       end
 
@@ -50,19 +60,25 @@ module Vedeu
         let(:input) { "quit" }
 
         context 'but there is no result' do
-          it { subject.must_be_instance_of(NilClass) }
+          it 'returns a NilClass' do
+            subject.must_be_instance_of(NilClass)
+          end
         end
 
         context 'or the result is :stop' do
           let(:result) { :stop }
 
-          it { proc { subject }.must_raise(Collapse) }
+          it 'raises an exception' do
+            proc { subject }.must_raise(Collapse)
+          end
         end
 
         context 'or the result is anything else' do
           let(:result) { :something_else }
 
-          it { subject.must_be_instance_of(Array) }
+          it 'returns an Array' do
+            subject.must_be_instance_of(Array)
+          end
         end
       end
     end

data/test/lib/vedeu/process/queue_test.rb

@@ -10,13 +10,17 @@ module Vedeu
       let(:subject) { described_class.dequeue }
 
       context 'when the queue is empty' do
-        it { subject.must_be_instance_of(NilClass) }
+        it 'returns a NilClass' do
+          subject.must_be_instance_of(NilClass)
+        end
       end
 
       context 'when the queue is not empty' do
         before { described_class.enqueue(:result) }
 
-        it { subject.must_be_instance_of(Symbol) }
+        it 'returns the first entry added' do
+          subject.must_be_instance_of(Symbol)
+        end
       end
     end
 
@@ -24,29 +28,49 @@ module Vedeu
       let(:subject) { described_class.enqueue(result) }
       let(:result)  { :result }
 
-      it { subject.must_be_instance_of(Array) }
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
+      end
 
-      it { subject.size.must_equal(1) }
+      it 'contains the enqueued item' do
+        subject.size.must_equal(1)
+      end
     end
 
     describe '.size' do
       let(:subject) { described_class.size }
 
-      it { subject.must_be_instance_of(Fixnum) }
+      it 'returns a Fixnum' do
+        subject.must_be_instance_of(Fixnum)
+      end
+
+      it 'returns the size of the queue' do
+        subject.must_equal(0)
+      end
     end
 
     describe '.clear' do
       let(:subject) { described_class.clear }
 
-      it { subject.must_be_instance_of(Array) }
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
+      end
 
-      it { subject.must_be_empty }
+      it 'returns an empty array' do
+        subject.must_be_empty
+      end
     end
 
     describe '.view' do
       let(:subject) { described_class.view }
 
-      it { subject.must_be_instance_of(String) }
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns the queue as a String' do
+        subject.must_equal("[]")
+      end
     end
   end
 end

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

@@ -24,13 +24,21 @@ module Vedeu
       context 'when the command was found by keypress' do
         let(:input) { 'b' }
 
-        it { subject.must_be_instance_of(Command) }
+        it 'returns the Command instance' do
+          subject.must_be_instance_of(Command)
+        end
 
-        it { subject.name.must_equal('banana') }
+        it 'returns the correct command' do
+          subject.name.must_equal('banana')
+        end
 
-        it { subject.name.wont_equal('apple') }
+        it 'returns the correct command' do
+          subject.name.wont_equal('apple')
+        end
 
-        it { subject.keypress.must_equal('b') }
+        it 'returns the correct command' do
+          subject.keypress.must_equal('b')
+        end
       end
     end
 
@@ -40,20 +48,30 @@ module Vedeu
       context 'when the command was found by keyword' do
         let(:input) { 'apple' }
 
-        it { subject.must_be_instance_of(Command) }
+        it 'returns the Command instance' do
+          subject.must_be_instance_of(Command)
+        end
 
-        it { subject.keypress.must_equal('a') }
+        it 'returns the correct command' do
+          subject.keypress.must_equal('a')
+        end
 
-        it { subject.keypress.wont_equal('b') }
+        it 'returns the correct command' do
+          subject.keypress.wont_equal('b')
+        end
 
-        it { subject.name.wont_equal('banana') }
+        it 'returns the correct command' do
+          subject.name.wont_equal('banana')
+        end
       end
     end
 
     describe '.klass' do
       let(:subject) { described_class.klass }
 
-      it { subject.must_equal(Command) }
+      it 'returns Command' do
+        subject.must_equal(Command)
+      end
     end
   end
 end