vedeu 0.4.18 → 0.4.19

data/test/lib/vedeu/buffers/buffer_test.rb

@@ -4,22 +4,26 @@ module Vedeu
 
   describe Buffer do
 
-    let(:described)   { Vedeu::Buffer }
-    let(:instance)    { described.new(attributes) }
-    let(:attributes)  {
+    let(:described)  { Vedeu::Buffer }
+    let(:instance)   { described.new(attributes) }
+    let(:attributes) {
       {
-        name:       _name,
-        back:       back,
-        front:      front,
-        previous:   previous,
+        name:     _name,
+        back:     back,
+        front:    front,
+        previous: previous,
       }
     }
-    let(:_name) { 'krypton' }
-    let(:back)        {}
-    let(:front)       {}
-    let(:previous)    {}
-
-    before { Vedeu.stubs(:trigger) }
+    let(:_name)     { 'krypton' }
+    let(:back)      {}
+    let(:front)     {}
+    let(:previous)  {}
+    let(:interface) {}
+
+    before do
+      Vedeu.stubs(:trigger)
+      # Vedeu.interfaces.stubs(:by_name).returns(interface)
+    end
 
     describe '#initialize' do
       it { instance.must_be_instance_of(described) }
@@ -61,6 +65,37 @@ module Vedeu
       end
     end
 
+    describe '#clear' do
+      subject { instance.clear }
+
+      context 'when the clear buffer is empty' do
+      end
+
+      context 'when the clear buffer is not empty' do
+      end
+    end
+
+    describe '#hide' do
+      subject { instance.hide }
+
+      context 'when the interface is visible' do
+      end
+
+      context 'when the interface is not visible' do
+        it { subject.must_be_instance_of(NilClass) }
+      end
+    end
+
+    describe '#show' do
+      subject { instance.show }
+
+      context 'when the interface is visible' do
+      end
+
+      context 'when the interface is not visible' do
+      end
+    end
+
     # describe '#render' do
     #   before { Vedeu::Output.stubs(:render) }
 

data/test/lib/vedeu/configuration/cli_test.rb

@@ -6,16 +6,17 @@ module Vedeu
 
     describe CLI do
 
-      let(:described) { CLI.new(args) }
+      let(:described) { Vedeu::Config::CLI }
+      let(:instance)  { described.new(args) }
       let(:args)      { [] }
 
       before { Configuration.reset! }
       after  { test_configuration }
 
       describe '#initialize' do
-        it { described.must_be_instance_of(CLI) }
-        it { described.instance_variable_get('@args').must_equal(args) }
-        it { described.instance_variable_get('@options').must_equal({}) }
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@args').must_equal(args) }
+        it { instance.instance_variable_get('@options').must_equal({}) }
       end
 
       describe '#colour_mode' do

data/test/lib/vedeu/cursor/refresh_cursor_test.rb

@@ -7,9 +7,20 @@ module Vedeu
     let(:described) { Vedeu::RefreshCursor }
     let(:instance)  { described.new(_name) }
     let(:_name)     { 'refresh_cursor' }
+    let(:expected)  {}
+    let(:ox)        { 0 }
+    let(:oy)        { 0 }
 
     before do
-      Vedeu::Terminal.stubs(:output)
+      Vedeu.geometry 'refresh_cursor' do
+        x  1
+        xn 3
+        y  1
+        yn 3
+      end
+      Vedeu::Cursor.new({ name: 'refresh_cursor', ox: ox, oy: oy }).store
+
+      Vedeu::Terminal.stubs(:output).returns(expected)
     end
 
     describe '#initialize' do
@@ -17,20 +28,31 @@ module Vedeu
       it { instance.instance_variable_get('@name').must_equal(_name) }
     end
 
-    # describe '.render' do
-    #   subject { described.render(_name) }
-
-    #   it 'renders the cursor in the terminal' do
-    #     Vedeu::Terminal.expects(:output).with("\e[1;1H\e[?25l")
-    #     subject
-    #   end
-
-    #   context 'when the view should be refreshed' do
-    #   end
-
-    #   context 'when the view should not be refreshed' do
-    #   end
-    # end
+    describe '.render' do
+      subject { described.render(_name) }
+
+      it 'renders the cursor in the terminal' do
+        Vedeu::Terminal.expects(:output).with("\e[1;1H\e[?25l")
+        subject
+      end
+
+      context 'when the cursors offset position is outside the viewable area' do
+        let(:ox) { 3 }
+        let(:oy) { 3 }
+
+        it 'refreshes the view' do
+          Vedeu::Refresh.expects(:by_name)
+          subject
+        end
+      end
+
+      context 'when the cursors offset position is inside the viewable area' do
+        it 'does not refresh the view' do
+          Vedeu::Refresh.expects(:by_name).never
+          subject
+        end
+      end
+    end
 
   end # RefreshCursor
 

data/test/lib/vedeu/distributed/subprocess_test.rb

@@ -15,6 +15,7 @@ module Vedeu
       it do
         subject.instance_variable_get('@application').must_equal(application)
       end
+      it { subject.instance_variable_get('@pid').must_equal(nil) }
     end
 
   end # Subprocess

data/test/lib/vedeu/dsl/shared/use_test.rb

@@ -24,13 +24,8 @@ module Vedeu
         end
       end
 
-      describe '.use' do
+      describe '#use' do
         context 'when the model exists' do
-          context 'and the attribute exists' do
-          end
-
-          context 'but the attribute does not exist' do
-          end
         end
 
         context 'when the model does not exist' do

data/test/lib/vedeu/main_loop_test.rb

@@ -19,6 +19,17 @@ module Vedeu
       it { subject; described.instance_variable_get('@loop').must_equal(false) }
     end
 
+    describe '.safe_exit_point!' do
+      subject { described.safe_exit_point! }
+
+      context 'when the application has started' do
+      end
+
+      context 'when the application has not started' do
+        it { Vedeu.expects(:trigger); subject }
+      end
+    end
+
   end # MainLoop
 
 end # Vedeu

data/test/lib/vedeu/null/interface_test.rb

@@ -6,6 +6,33 @@ module Vedeu
 
     describe Interface do
 
+      let(:described) { Vedeu::Null::Interface }
+      let(:instance)  { described.new(_name) }
+      let(:_name)     {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(Vedeu::Null::Interface) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+      end
+
+      describe '#attributes' do
+        subject { instance.attributes }
+
+        it { subject.must_be_instance_of(Hash) }
+      end
+
+      describe '#store' do
+        subject { instance.store }
+
+        it { subject.must_be_instance_of(Vedeu::Null::Interface) }
+      end
+
+      describe '#visible?' do
+        subject { instance.visible? }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+
     end # Interface
 
   end # Null

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

@@ -24,16 +24,23 @@ module Vedeu
       subject { described.render(content) }
 
       context 'when DRb is enabled' do
-        let(:drb) { true }
-
-        it { }
-      end
-
-      context 'when DRb is not enabled' do
-      #   it 'sends the rendered interface to the Terminal' do
-      #     Vedeu::Renderers::Terminal.expects(:render)
-      #     subject.must_be_instance_of(Array)
-      #   end
+        let(:drb)            { true }
+        let(:virtual_buffer) { [] }
+
+        before do
+          Vedeu::Renderers::HTML.stubs(:to_file)
+          Vedeu::VirtualBuffer.stubs(:retrieve).returns(virtual_buffer)
+        end
+
+        it {
+          Vedeu.expects(:trigger).with(:_drb_store_output_, content)
+          subject
+        }
+
+        it 'writes the virtual buffer to a file' do
+          Vedeu::Renderers::HTML.expects(:to_file).with(virtual_buffer)
+          subject
+        end
       end
 
       it { Vedeu.renderers.expects(:render).with(content); subject }

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

@@ -20,40 +20,68 @@ module Vedeu
   class PresentationTestClass
     include Presentation
 
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
     def parent
       ParentPresentationTestClass.new
     end
 
-    def attributes
-      {
-        colour: { background: '#000033', foreground: '#aadd00' },
-        style:  ['bold']
-      }
-    end
   end # PresentationTestClass
 
   describe Presentation do
 
-    let(:receiver) { PresentationTestClass.new }
+    let(:receiver) { PresentationTestClass.new(attributes) }
+    let(:attributes) {
+      {
+        colour: { background: background, foreground: foreground },
+        style:  ['bold']
+      }
+    }
+    let(:background) { '#000033' }
+    let(:foreground) { '#aadd00' }
 
     describe '#background' do
       subject { receiver.background }
 
       it { subject.must_be_instance_of(Vedeu::Background) }
+      it { subject.colour.must_equal('#000033') }
+
+      context 'no background value' do
+        let(:background) {}
+
+        it { subject.must_be_instance_of(Vedeu::Background) }
+        it { subject.colour.must_equal('') }
+      end
     end
 
     describe '#foreground' do
       subject { receiver.foreground }
 
       it { subject.must_be_instance_of(Vedeu::Foreground) }
+      it { subject.colour.must_equal('#aadd00') }
+
+      context 'no foreground value' do
+        let(:foreground) {}
+
+        it { subject.must_be_instance_of(Vedeu::Foreground) }
+        it { subject.colour.must_equal('') }
+      end
     end
 
     describe '#parent_background' do
       subject { receiver.parent_background }
+
+      it { subject.must_be_instance_of(Vedeu::Background) }
     end
 
     describe '#parent_foreground' do
       subject { receiver.parent_foreground }
+
+      it { subject.must_be_instance_of(Vedeu::Foreground) }
     end
 
     describe '#colour' do

data/test/lib/vedeu/output/renderers/escape_sequence_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Renderers
+
+    describe EscapeSequence do
+
+      let(:described) { Vedeu::Renderers::EscapeSequence }
+      let(:instance)  { described.new(output) }
+      let(:output)    {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@output').must_equal(output) }
+      end
+
+      describe '.render' do
+        subject { described.render(output) }
+
+        it { subject.must_be_instance_of(String) }
+
+        context 'when there is no output' do
+          it { subject.must_equal('') }
+        end
+
+        context 'when there is output' do
+          let(:output) {
+            [
+              Vedeu::Char.new(value: 't', colour: { background: '#ff0000', foreground: '#ffffff' }),
+              Vedeu::Char.new(value: 'e', colour: { background: '#ffff00', foreground: '#000000' }),
+              Vedeu::Char.new(value: 's', colour: { background: '#00ff00', foreground: '#000000' }),
+              Vedeu::Char.new(value: 't', colour: { background: '#00ffff', foreground: '#000000' }),
+             ]
+          }
+
+          it { subject.must_equal(
+            "\\e[38;2;255;255;255m\\e[48;2;255;0;0mt\n" \
+            "\\e[38;2;0;0;0m\\e[48;2;255;255;0me\n"     \
+            "\\e[38;2;0;0;0m\\e[48;2;0;255;0ms\n"       \
+            "\\e[38;2;0;0;0m\\e[48;2;0;255;255mt\n")
+          }
+        end
+      end
+
+    end # EscapeSequence
+
+  end # Renderers
+
+end # Vedeu

data/test/lib/vedeu/output/renderers/file_test.rb

@@ -2,46 +2,50 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Renderers::File do
-
-    let(:described) { Vedeu::Renderers::File }
-    let(:instance)  { described.new(output, options) }
-    let(:output)    {}
-    let(:options)   {
-      {
-        timestamp: timestamp
+  module Renderers
+
+    describe File do
+
+      let(:described) { Vedeu::Renderers::File }
+      let(:instance)  { described.new(output, options) }
+      let(:output)    {}
+      let(:options)   {
+        {
+          timestamp: timestamp
+        }
       }
-    }
-    let(:timestamp) { true }
+      let(:timestamp) { true }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@output').must_equal(output) }
+        it { instance.instance_variable_get('@options').must_equal(options) }
+      end
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@output').must_equal(output) }
-      it { instance.instance_variable_get('@options').must_equal(options) }
-    end
+      describe '.render' do
+        let(:_time) { Time.new(2015, 4, 12, 20, 05) }
 
-    describe '.render' do
-      let(:_time) { Time.new(2015, 4, 12, 20, 05) }
+        before { File.stubs(:open) }
 
-      before { File.stubs(:open) }
+        subject { described.render(output, options) }
 
-      subject { described.render(output, options) }
+        it { subject.must_be_instance_of(String) }
 
-      it { subject.must_be_instance_of(String) }
+        # context 'when the timestamp option is true' do
+        #   before { Time.stubs(:now).returns(_time) }
 
-      # context 'when the timestamp option is true' do
-      #   before { Time.stubs(:now).returns(_time) }
+        #   it { File.expects(:open).with('/tmp/out_1428865500.0', 'w'); subject }
+        # end
 
-      #   it { File.expects(:open).with('/tmp/out_1428865500.0', 'w'); subject }
-      # end
+        # context 'when the timestamp option is false' do
+        #   let(:timestamp) { false }
 
-      # context 'when the timestamp option is false' do
-      #   let(:timestamp) { false }
+        #   it { File.expects(:open).with('/tmp/out', 'w'); subject }
+        # end
+      end
 
-      #   it { File.expects(:open).with('/tmp/out', 'w'); subject }
-      # end
-    end
+    end # File
 
-  end # Renderers::File
+  end # Renderers
 
 end # Vedeu

data/test/lib/vedeu/output/renderers/html_test.rb

@@ -2,85 +2,89 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Renderers::HTML do
+  module Renderers
 
-    let(:described) { Vedeu::Renderers::HTML }
-    let(:instance)  { described.new(output) }
-    let(:output)    {}
+    describe HTML do
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@output').must_equal(output) }
-    end
+      let(:described) { Vedeu::Renderers::HTML }
+      let(:instance)  { described.new(output) }
+      let(:output)    {}
 
-    describe '.render' do
-      before { File.stubs(:open) }
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@output').must_equal(output) }
+      end
+
+      describe '.render' do
+        before { ::File.stubs(:open) }
 
-      subject { described.render(output) }
+        subject { described.render(output) }
 
-      it { subject.must_be_instance_of(String) }
-    end
+        it { subject.must_be_instance_of(String) }
+      end
 
-    describe '.to_file' do
-      before { File.stubs(:open) }
+      describe '.to_file' do
+        before { ::File.stubs(:open) }
 
-      subject { described.to_file(output, path) }
+        subject { described.to_file(output, path) }
 
-      context 'when a path is given' do
-        let(:path) { '/tmp/test_vedeu_html_renderer.html' }
+        context 'when a path is given' do
+          let(:path) { '/tmp/test_vedeu_html_renderer.html' }
 
-        it do
-          File.expects(:open)
-          subject
+          it do
+            ::File.expects(:open)
+            subject
+          end
         end
-      end
 
-      context 'when a path is not given' do
-        let(:path) {}
-        let(:_time) { Time.new(2015, 4, 12, 16, 55) }
+        context 'when a path is not given' do
+          let(:path) {}
+          let(:_time) { Time.new(2015, 4, 12, 16, 55) }
 
-        before { Time.stubs(:now).returns(_time) }
+          before { Time.stubs(:now).returns(_time) }
 
-        it do
-          File.expects(:open)#.with('/tmp/vedeu_html_1428854100.html', 'w')
-          subject
+          it do
+            ::File.expects(:open)#.with('/tmp/vedeu_html_1428854100.html', 'w')
+            subject
+          end
         end
       end
-    end
 
-    describe '#html_body' do
-      subject { instance.html_body }
+      describe '#html_body' do
+        subject { instance.html_body }
 
-      it { subject.must_be_instance_of(String) }
+        it { subject.must_be_instance_of(String) }
 
-      it { subject.must_equal('') }
+        it { subject.must_equal('') }
 
-      context 'when there is output' do
-        let(:output) {
-          [
+        context 'when there is output' do
+          let(:output) {
             [
-              Vedeu::Char.new(value: 't'),
-              Vedeu::Char.new(value: 'e'),
-              Vedeu::Char.new(value: 's'),
-              Vedeu::Char.new(value: 't'),
+              [
+                Vedeu::Char.new(value: 't'),
+                Vedeu::Char.new(value: 'e'),
+                Vedeu::Char.new(value: 's'),
+                Vedeu::Char.new(value: 't'),
+              ]
             ]
-          ]
-        }
-
-        it { subject.must_equal(
-          "<tr>\n" \
-          "<td style='background:#000;color:#222;border:1px #000 solid;'>"   \
-          "t</td>\n" \
-            "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
-          "e</td>\n" \
-            "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
-          "s</td>\n" \
-            "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
-          "t</td>\n" \
-          "</tr>\n") }
+          }
+
+          it { subject.must_equal(
+            "<tr>\n" \
+            "<td style='background:#000;color:#222;border:1px #000 solid;'>"   \
+            "t</td>\n" \
+              "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
+            "e</td>\n" \
+              "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
+            "s</td>\n" \
+              "<td style='background:#000;color:#222;border:1px #000 solid;'>" \
+            "t</td>\n" \
+            "</tr>\n") }
+        end
       end
-    end
 
-  end # Renderers::HTML
+    end # HTML
+
+  end # Renderers
 
 end # Vedeu