vedeu 0.0.30 → 0.0.31

data/test/lib/vedeu/models/interface_collection_test.rb

@@ -4,57 +4,25 @@ require_relative '../../../../lib/vedeu/models/composition'
 
 module Vedeu
   describe InterfaceCollection do
-    let(:described_class) { InterfaceCollection }
-
     describe '#coerce' do
-      let(:subject)    { Vedeu::Composition.new({ interfaces: interfaces }).interfaces }
-      let(:interfaces) {}
-
-      context 'when there are no interfaces' do
-        it 'returns a Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns an empty array' do
-          subject.must_equal([])
-        end
+      it 'returns a Array' do
+        Composition.new.interfaces.must_be_instance_of(Array)
       end
 
-      context 'when there is a single interface' do
-        let(:interfaces) { { name: 'dummy' } }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns a collection of Interface objects' do
-          subject.first.must_be_instance_of(Interface)
-        end
-
-        it 'contains a single Interface object' do
-          subject.size.must_equal(1)
-        end
+      it 'returns an empty collection when there are no interfaces' do
+        Composition.new.interfaces.must_equal([])
       end
 
-      context 'when there are multiple interfaces' do
-        let(:interfaces) {
-          [
-            { name: 'dumb' },
-            { name: 'dumber' }
-          ]
-        }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns a collection of Interface objects' do
-          subject.first.must_be_instance_of(Interface)
-        end
+      it 'returns a collection of Interface objects when there is a single interface' do
+        skip
+        Composition.new({ name: 'dummy' }).interfaces.first.must_be_instance_of(Interface)
+      end
 
-        it 'contains multiple Line objects' do
-          subject.size.must_equal(2)
-        end
+      it 'returns a collection of Interface objects when there are multiple interfaces' do
+        Composition.new({ interfaces: [
+          { name: 'dumb' },
+          { name: 'dumber' }
+        ]}).interfaces.size.must_equal(2)
       end
     end
   end

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

@@ -3,237 +3,113 @@ require_relative '../../../../lib/vedeu/models/interface'
 
 module Vedeu
   describe Interface do
-    let(:described_class)    { Interface }
-    let(:described_instance) { described_class.new(attributes) }
-    let(:attributes)         {
-      {
-        name:   'dummy',
-        lines:  [],
-        colour: {
-          foreground: '#ff0000',
-          background: '#000000'
-        },
-        width:  7,
-        height: 3
-      }
-    }
-
-    before do
-      Terminal.stubs(:width).returns(40)
-      Terminal.stubs(:height).returns(25)
+    it 'has a name attribute' do
+      Interface.new({ name: 'dummy' }).name.must_equal('dummy')
     end
 
-    describe '#initialize' do
-      let(:subject) { described_instance }
-
-      it 'returns a Interface instance' do
-        subject.must_be_instance_of(Interface)
-      end
+    it 'has a lines attribute' do
+      Interface.new({ lines: [] }).lines.must_equal([])
     end
 
-    describe '#name' do
-      let(:subject) { described_instance.name }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
-      it 'has a name attribute' do
-        subject.must_equal('dummy')
-      end
+    it 'has a colour attribute' do
+      Interface.new({
+        colour: {
+          foreground: '#ff0000',
+          background: '#000000'
+        }
+      }).colour.must_be_instance_of(Colour)
     end
 
-    describe '#lines' do
-      let(:subject) { described_instance.lines }
-
-      it 'returns an Array' do
-        subject.must_be_instance_of(Array)
-      end
-
-      it 'has a lines attribute' do
-        subject.must_equal([])
-      end
+    it 'has a y attribute' do
+      Interface.new({ y: 17 }).y.must_equal(17)
+      Interface.new.y.must_equal(1)
     end
 
-    describe '#colour' do
-      let(:subject) { described_instance.colour }
+    it 'has an x attribute' do
+      Interface.new({ x: 33 }).x.must_equal(33)
+      Interface.new.x.must_equal(1)
     end
 
-    describe '#y' do
-      let(:subject) { described_instance.y }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'using a value' do
-        let(:attributes) { { y: 17 } }
-
-        it 'returns the value' do
-          subject.must_equal(17)
-        end
-      end
-
-      context 'using the default' do
-        it 'returns the default' do
-          subject.must_equal(1)
-        end
-      end
+    it 'has a z attribute' do
+      Interface.new({ z: 2 }).z.must_equal(2)
+      Interface.new.z.must_equal(1)
     end
 
-    describe '#x' do
-      let(:subject) { described_instance.x }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'using a value' do
-        let(:attributes) { { x: 33 } }
-
-        it 'returns the value' do
-          subject.must_equal(33)
-        end
-      end
-
-      context 'using the default' do
-        it 'return the default' do
-          subject.must_equal(1)
-        end
-      end
+    it 'has a width attribute' do
+      Interface.new({ width: 50 }).width.must_equal(50)
     end
 
-    describe '#z' do
-      let(:subject) { described_instance.z }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'using a value' do
-        let(:attributes) { { z: 2 } }
-
-        it 'returns the value' do
-          subject.must_equal(2)
-        end
-      end
-
-      context 'using the default' do
-        it 'return the default' do
-          subject.must_equal(1)
-        end
-      end
-    end
-
-    describe '#width' do
-      let(:subject) { described_instance.width }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'using a value' do
-        let(:attributes) { { width: 50 } }
-
-        it 'returns the value' do
-          subject.must_equal(50)
-        end
-      end
+    it 'has a height attribute' do
+      Interface.new({ height: 20 }).height.must_equal(20)
     end
 
-    describe '#height' do
-      let(:subject) { described_instance.height }
-
-      it 'returns a Fixnum' do
-        subject.must_be_instance_of(Fixnum)
-      end
-
-      context 'using a value' do
-        let(:attributes) { { height: 20 } }
-
-        it 'returns the value' do
-          subject.must_equal(20)
-        end
-      end
-    end
-
-    describe '#current' do
-      let(:subject) { described_instance.current }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
+    it 'has a current attribute' do
+      Interface.new({ current: '' }).current.must_equal('')
     end
 
-    describe '#cursor' do
-      let(:subject) { described_instance.cursor }
-
-      it 'returns a TrueClass' do
-        subject.must_be_instance_of(TrueClass)
-      end
-
-      context 'when the cursor is off' do
-        before { described_instance.cursor=(false) }
-
-        it 'returns a FalseClass' do
-          subject.must_be_instance_of(FalseClass)
-        end
-      end
+    it 'has a cursor attribute' do
+      Interface.new({ cursor: true }).cursor.must_be :==, true
+      Interface.new({ cursor: false }).cursor.must_be :==, false
+      Interface.new.cursor.must_be :==, true
     end
 
     describe '#refresh' do
-      let(:subject) { described_instance.refresh }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
-      context 'when content is queued up to be displayed' do
-        before { described_instance.enqueue("\e[38;5;196m\e[48;5;16m\e[1;1HContent\e[1;1H\e[2;1HContent\e[2;1H\e[3;1HContent\e[3;1H") }
+      let(:attributes) {
+        {
+          name:   'dummy',
+          lines:  [],
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          width:  3,
+          height: 3
+        }
+      }
 
-        it 'returns the fresh content' do
-          subject.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1HContent\e[1;1H\e[2;1HContent\e[2;1H\e[3;1HContent\e[3;1H")
-        end
+      it 'returns a blank interface when there is no content to display (initial state)' do
+        Interface.new(attributes).refresh.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1H   \e[1;1H\e[2;1H   \e[2;1H\e[3;1H   \e[3;1H")
       end
 
-      context 'when there is no content to display (initial state)' do
-        it 'returns a blank interface' do
-          subject.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1H       \e[1;1H\e[2;1H       \e[2;1H\e[3;1H       \e[3;1H")
-        end
+      it 'returns the fresh content when content is queued up to be displayed' do
+        @interface = Interface.new(attributes).enqueue("\e[38;5;196m\e[48;5;16m\e[1;1HContent\e[1;1H\e[2;1HContent\e[2;1H\e[3;1HContent\e[3;1H")
+        @interface.refresh.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1HContent\e[1;1H\e[2;1HContent\e[2;1H\e[3;1HContent\e[3;1H")
       end
 
-      context 'when there is stale content from last run' do
-        before do
-          described_instance.current = "\e[38;5;196m\e[48;5;16m\e[1;1HOld\e[1;1H\e[2;1HContent\e[2;1H\e[3;1Here\e[3;1H"
-        end
-
-        it 'returns the previously shown content' do
-          subject.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1HOld\e[1;1H\e[2;1HContent\e[2;1H\e[3;1Here\e[3;1H")
-        end
+      it 'returns the previously shown content when there is stale content from last run' do
+        @interface = Interface.new(attributes)
+        @interface.current = "\e[38;5;196m\e[48;5;16m\e[1;1HOld\e[1;1H\e[2;1HContent\e[2;1H\e[3;1Here\e[3;1H"
+        @interface.refresh.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1HOld\e[1;1H\e[2;1HContent\e[2;1H\e[3;1Here\e[3;1H")
       end
     end
 
     describe '#to_s' do
-      let(:subject) { described_instance.to_s }
-
-      it 'returns an String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns an String' do
-        subject.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1H       \e[1;1H\e[2;1H       \e[2;1H\e[3;1H       \e[3;1H")
+        Interface.new({
+          name:   'dummy',
+          lines:  [],
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          width:  3,
+          height: 3
+        }).to_s.must_equal("\e[38;5;196m\e[48;5;16m\e[1;1H   \e[1;1H\e[2;1H   \e[2;1H\e[3;1H   \e[3;1H")
       end
     end
 
     describe '#to_json' do
-      let(:subject) { described_instance.to_json }
-
-      it 'returns an String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns an String' do
-        subject.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\",\"name\":\"dummy\",\"lines\":[],\"y\":1,\"x\":1,\"z\":1,\"width\":7,\"height\":3,\"cursor\":true}")
+        Interface.new({
+          name:   'dummy',
+          lines:  [],
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          width:  3,
+          height: 3
+        }).to_json.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\",\"name\":\"dummy\",\"lines\":[],\"y\":1,\"x\":1,\"z\":1,\"width\":3,\"height\":3,\"cursor\":true}")
       end
     end
   end

data/test/lib/vedeu/models/line_collection_test.rb

@@ -4,65 +4,26 @@ require_relative '../../../../lib/vedeu/models/interface'
 
 module Vedeu
   describe LineCollection do
-    let(:described_class) { LineCollection }
-
     describe '#coerce' do
-      let(:subject) { Vedeu::Interface.new({ lines: lines }).lines }
-      let(:lines) {}
-
-      context 'when there are no lines' do
-        it 'returns a Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns an empty array' do
-          subject.must_equal([])
-        end
+      it 'returns an empty collection when there are no lines' do
+        Interface.new({ lines: {} }).lines.must_equal([])
       end
 
-      context 'when the line is just a String' do
-        let(:lines) { 'some text' }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'contains a single Line object' do
-          subject.size.must_equal(1)
-        end
+      it 'contains a single Line object when the line is just a String' do
+        Interface.new({ lines: 'some text' }).lines.size
+          .must_equal(1)
       end
 
-      context 'when there is a single line' do
-        let(:lines) { { streams: { text: 'some text' } } }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'contains a single Line object' do
-          subject.size.must_equal(1)
-        end
+      it 'contains a single Line object when there is a single line' do
+        Interface.new({ lines: { streams: { text: 'some text' } } })
+          .lines.size.must_equal(1)
       end
 
-      context 'when there are multiple lines' do
-        let(:lines) {
-          [
-            { text: 'some text' },
-            { text: 'some more text' }
-          ]
-        }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns a collection of Line objects' do
-          subject.first.must_be_instance_of(Line)
-        end
-
-        it 'contains multiple Line objects' do
-          subject.size.must_equal(2)
-        end
+      it 'contains multiple Line objects when there are multiple lines' do
+        Interface.new({ lines: [
+          { text: 'some text' },
+          { text: 'some more text' }
+        ] }).lines.size.must_equal(2)
       end
     end
   end

data/test/lib/vedeu/models/line_test.rb

@@ -3,83 +3,39 @@ require_relative '../../../../lib/vedeu/models/line'
 
 module Vedeu
   describe Line do
-    let(:described_class)    { Line }
-    let(:described_instance) { described_class.new(attributes) }
-    let(:subject)            { described_instance }
-    let(:attributes)         {
-      {
-        model:  {},
-        style:  'normal',
-        colour: { foreground: '#ff0000', background: '#000000' },
-        stream: [],
-      }
-    }
-
-    describe '#initialize' do
-      let(:subject) { described_instance }
-
-      it 'returns a Line instance' do
-        subject.must_be_instance_of(Line)
-      end
+    it 'has a style attribute' do
+      Line.new(style:  'normal').style.must_be_instance_of(String)
     end
 
-    describe '#style' do
-      let(:subject) { described_instance.style }
-
-      it 'has a style attribute' do
-        subject.must_be_instance_of(String)
-      end
+    it 'has a colour attribute' do
+      Line.new(colour: { foreground: '#ff0000', background: '#000000' }).colour.must_be_instance_of(Colour)
     end
 
-    describe '#colour' do
-      let(:subject) { described_instance.colour }
-
-      it 'has a colour attribute' do
-        subject.must_be_instance_of(Colour)
-      end
+    it 'has a model attribute' do
+      Line.new(model: {}).model.must_be_instance_of(Hash)
     end
 
-    describe '#model' do
-      let(:subject) { described_instance.model }
-
-      it 'has a model attribute' do
-        subject.must_be_instance_of(Hash)
-      end
-    end
-
-    describe '#streams' do
-      let(:subject) { described_instance.streams }
-
-      it 'has a streams attribute' do
-        subject.must_be_instance_of(Array)
-
-        subject.must_equal([])
-      end
+    it 'has a streams attribute' do
+      Line.new(streams: []).streams.must_equal([])
     end
 
     describe '#to_json' do
-      let(:subject) { described_instance.to_json }
-
-      it 'returns an String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns an String' do
-        subject.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\\u001b[24m\\u001b[21m\\u001b[27m\",\"streams\":[]}")
+        Line.new({
+          style:   'normal',
+          colour:  { foreground: '#ff0000', background: '#000000' },
+          streams: [],
+        }).to_json.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\\u001b[24m\\u001b[21m\\u001b[27m\",\"streams\":[]}")
       end
     end
 
     describe '#to_s' do
-      let(:subject) { described_instance.to_s }
-
       it 'returns an String' do
-        subject.must_be_instance_of(String)
-      end
-
-      it 'returns an String' do
-        subject.must_equal("\e[38;5;196m\e[48;5;16m\e[24m\e[21m\e[27m")
+        Line.new({
+          style:  'normal',
+          colour: { foreground: '#ff0000', background: '#000000' },
+        }).to_s.must_equal("\e[38;5;196m\e[48;5;16m\e[24m\e[21m\e[27m")
       end
     end
   end
 end
-

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

@@ -7,32 +7,19 @@ module Vedeu
   end
 
   describe Presentation do
-    let(:described_module)   { Presentation }
-    let(:described_instance) { TestPresentation.new(attributes) }
-    let(:attributes) {
-      {
-        colour: {},
-        style:  ['bold', 'underline']
-      }
-    }
-
     describe '#colour' do
-      let(:subject) { described_instance.colour }
-
       it 'returns a Colour instance' do
-        subject.must_be_instance_of(Colour)
+        TestPresentation.new({
+          colour: { foreground: '#ff0000', background: '#333333' }
+        }).colour.must_be_instance_of(Colour)
       end
     end
 
     describe '#style' do
-      let(:subject) { described_instance.style }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'has a style attribute' do
-        subject.must_equal("\e[1m\e[4m")
+        TestPresentation.new({
+          style:  ['bold', 'underline']
+        }).style.must_equal("\e[1m\e[4m")
       end
     end
   end

data/test/lib/vedeu/models/stream_collection_test.rb

@@ -4,53 +4,21 @@ require_relative '../../../../lib/vedeu/models/line'
 
 module Vedeu
   describe StreamCollection do
-    let(:described_class) { StreamCollection }
-
     describe '#coerce' do
-      let(:subject) { Vedeu::Line.new({ streams: streams }).streams }
-      let(:streams) {}
-
-      context 'when there is no stream' do
-        it 'returns a Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns an empty array' do
-          subject.must_equal([])
-        end
+      it 'returns an empty array when there is no stream' do
+        Line.new.streams.must_equal([])
       end
 
-      context 'when there is a single stream' do
-        let(:streams) { "some text" }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'contains a single Stream object' do
-          subject.size.must_equal(1)
-        end
+      it 'contains a single Stream when there is a single stream' do
+        Line.new({ streams: 'some text' }).streams.size
+          .must_equal(1)
       end
 
-      context 'when there are multiple streams' do
-        let(:streams) {
-          [
-            { text: 'some text' },
-            { text: 'some more text' }
-          ]
-        }
-
-        it 'returns an Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        it 'returns a collection of Stream objects' do
-          subject.first.must_be_instance_of(Stream)
-        end
-
-        it 'contains multiple Stream objects' do
-          subject.size.must_equal(2)
-        end
+      it 'contains multiple Stream when there are multiple streams' do
+        Line.new({ streams: [
+          { text: 'some text' },
+          { text: 'some more text' }
+        ] }).streams.size.must_equal(2)
       end
     end
   end