vedeu 0.4.13 → 0.4.14

data/test/lib/vedeu/repositories/collections_test.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Chars do
-
-    let(:described) { Vedeu::Chars }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Chars) }
-    end
-
-  end # Chars
-
-  describe Events do
-
-    let(:described) { Vedeu::Events }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Events) }
-    end
-
-  end # Events
-
-  describe Interfaces do
-
-    let(:described) { Vedeu::Interfaces }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Interfaces) }
-    end
-
-  end # Interfaces
-
-  describe Keys do
-
-    let(:described) { Vedeu::Keys }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Keys) }
-    end
-
-  end # Keys
-
-  describe Lines do
-
-    let(:described) { Vedeu::Lines }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Lines) }
-    end
-
-  end # Lines
-
-  describe Streams do
-
-    let(:described) { Vedeu::Streams }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Streams) }
-    end
-
-  end # Streams
-
-end # Vedeu

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

@@ -1,84 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  class CoercionsTestClass
-
-    include Coercions
-
-    attr_reader :attributes
-
-    def initialize(attributes = {})
-      @attributes = attributes
-    end
-
-  end # CoercionsTestClass
-
-  describe Coercions do
-
-    describe '.coerce' do
-      let(:described) { Vedeu::Style }
-      let(:value)     { 'bold' }
-
-      subject { described.coerce(value) }
-
-      it { subject.must_be_instance_of(described) }
-
-      context 'when the value is nil' do
-        let(:value) { nil }
-
-        it { subject.must_be_instance_of(described) }
-      end
-
-      context 'when the value is a Style already' do
-        let(:value) { Vedeu::Style.new('bold') }
-
-        it { subject.must_equal(value) }
-      end
-
-      context 'when the value is an Array' do
-        let(:value)  { [:bold, :blink] }
-
-        it { subject.value.must_equal([:bold, :blink]) }
-      end
-    end
-
-    describe '.coercer' do
-      [nil, [], {}].each do |empty_value|
-        it 'returns an empty collection when nil or empty' do
-          CoercionsTestClass.coercer(empty_value).must_equal([])
-        end
-      end
-
-      it 'returns when an object' do
-        klass = CoercionsTestClass.new
-
-        CoercionsTestClass.coercer([klass]).must_equal([klass])
-      end
-
-      it 'returns a collection of models when a single hash' do
-        coerced = CoercionsTestClass.coercer({ name: 'test1' })
-        coerced.must_be_instance_of(Array)
-        coerced.first.attributes.must_equal({ name: 'test1' })
-      end
-
-      it 'returns a collection of models when multiple hashes' do
-        coerced = CoercionsTestClass.coercer([
-          { name: 'test1' }, { name: 'test2' }
-        ])
-        coerced.size.must_equal(2)
-        coerced.map(&:attributes).must_equal(
-          [{ name: 'test1' }, { name: 'test2' }]
-        )
-      end
-
-      it 'returns a collection of models when a single array' do
-        coerced = CoercionsTestClass.coercer([{ name: 'test3' }])
-        coerced.size.must_equal(1)
-        coerced.first.attributes.must_equal({ name: "test3" })
-      end
-    end
-
-  end # Coercions
-
-end # Vedeu

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

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Sentence do
-
-    let(:described) { Vedeu::Sentence }
-    let(:instance)  { described.new(elements, label) }
-    let(:elements)  { ['Hydrogen'] }
-    let(:label)     { 'elements' }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Sentence) }
-      it { instance.instance_variable_get('@elements').must_equal(elements) }
-      it { instance.instance_variable_get('@label').must_equal(label) }
-    end
-
-    describe '.construct' do
-      subject { Sentence.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/visible_test.rb

@@ -1,161 +0,0 @@
-require 'test_helper'
-
-require 'vedeu/support/visible'
-
-module Vedeu
-
-  describe Visible do
-
-    let(:described) { Vedeu::Visible }
-    let(:instance)  { described.new(visible) }
-    let(:visible)   { true }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Visible) }
-      it { instance.instance_variable_get('@visible').must_equal(visible) }
-    end
-
-    describe '#visible' do
-      subject { instance.visible }
-
-      context 'when visible is :hide' do
-        let(:visible) { :hide }
-
-        it { subject.must_equal(false) }
-      end
-
-      context 'when visible is :show' do
-        let(:visible) { :show }
-
-        it { subject.must_equal(true) }
-      end
-
-      context 'when visible is nil' do
-        let(:visible) { nil }
-
-        it { subject.must_equal(false) }
-      end
-
-      context 'when visible is false' do
-        let(:visible) { false }
-
-        it { subject.must_equal(false) }
-      end
-
-      context 'when visible is anything else that evaluates to true' do
-        let(:visible) { 'yeah show it!' }
-
-        it { subject.must_equal(true) }
-      end
-    end
-
-    describe '.coerce' do
-      subject { described.coerce(value) }
-
-      context 'when the value is a Visible' do
-        let(:value) { described.new }
-
-        it { subject.must_be_instance_of(Visible) }
-        it { subject.visible?.must_equal(false) }
-      end
-
-      context 'when the value is not a Visible' do
-        let(:value) { :show }
-
-        it { subject.must_be_instance_of(Visible) }
-        it { subject.visible?.must_equal(true) }
-      end
-    end
-
-    describe '#to_s' do
-      subject { instance.to_s }
-
-      it { subject.must_be_instance_of(String) }
-
-      context 'when visible' do
-        it { subject.must_equal('visible') }
-      end
-
-      context 'when not visible' do
-        let(:visible) { false }
-
-        it { subject.must_equal('invisible') }
-      end
-    end
-
-    describe '#cursor' do
-      subject { instance.cursor }
-
-      it { subject.must_be_instance_of(String) }
-
-      context 'when visible' do
-        it { subject.must_equal("\e[?25h") }
-      end
-
-      context 'when not visible' do
-        let(:visible) { false }
-
-        it { subject.must_equal("\e[?25l") }
-      end
-    end
-
-    describe '#visible?' do
-      subject { instance.visible? }
-
-      context 'when visible' do
-        it { subject.must_be_instance_of(TrueClass) }
-      end
-
-      context 'when not visible' do
-        let(:visible) { false }
-
-        it { subject.must_be_instance_of(FalseClass) }
-      end
-    end
-
-    describe '#invisible?' do
-      subject { instance.invisible? }
-
-      context 'when not visible' do
-        let(:visible) { false }
-
-        it { subject.must_be_instance_of(TrueClass) }
-      end
-
-      context 'when visible' do
-        it { subject.must_be_instance_of(FalseClass) }
-      end
-    end
-
-    describe '#hide' do
-      subject { instance.hide }
-
-      it { subject.must_be_instance_of(Visible) }
-      it { subject.visible?.must_equal(false) }
-    end
-
-    describe '#show' do
-      subject { instance.show }
-      it { subject.must_be_instance_of(Visible) }
-      it { subject.visible?.must_equal(true) }
-    end
-
-    describe '#toggle' do
-      subject { instance.toggle }
-
-      it { subject.must_be_instance_of(Visible) }
-
-      context 'when visible' do
-        it { subject.visible?.must_be_instance_of(FalseClass) }
-      end
-
-      context 'when not visible' do
-        let(:visible) { false }
-
-        it { subject.visible?.must_be_instance_of(TrueClass) }
-      end
-    end
-
-  end # Visible
-
-end # Vedeu