vedeu 0.2.12 → 0.3.0

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

@@ -0,0 +1,271 @@
+require 'test_helper'
+
+module Vedeu
+
+  class TestRepository < Repository
+  end
+
+  class TestModel
+    include Vedeu::Model
+
+    attr_accessor :name
+
+    def initialize(name = nil)
+      @name = name
+      @repository = Vedeu::TestRepository.new(self.class)
+    end
+  end
+
+  describe Repository do
+
+    let(:described)      { Vedeu::Repository }
+    let(:instance)       { described.new(model, storage) }
+    let(:model)          { Vedeu::TestModel }
+    let(:model_instance) { model.new(model_name) }
+    let(:model_name)     { 'terbium' }
+    let(:storage)        { {} }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Vedeu::Repository) }
+      it { subject.instance_variable_get('@model').must_equal(model) }
+      it { subject.instance_variable_get('@storage').must_equal(storage) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Repository (0)>') }
+    end
+
+    describe '#all' do
+      subject { instance.all }
+
+      it 'returns the whole repository' do
+        subject.must_equal(storage)
+      end
+    end
+
+    # describe '#current' do
+    #   # before { Focus.stubs(:current).returns('francium') }
+
+    #   subject { instance.current }
+
+    #   it { Vedeu.focus.must_be_instance_of(NilClass) }
+
+    #   context 'when the model exists' do
+    #     # before { Cursor.new({ name: 'francium', state: false, x: 12, y: 4 }).store }
+
+    #     # it 'has the same attributes it was stored with' do
+    #     #   subject.x.must_equal(12)
+    #     #   subject.y.must_equal(4)
+    #     # end
+    #   end
+
+    #   context 'when the model does not exist' do
+    #     # it 'is created, stored, and has the default attributes' do
+    #     #   subject.x.must_equal(1)
+    #     #   subject.y.must_equal(1)
+    #     # end
+    #   end
+    # end
+
+    describe '#each' do
+      subject { instance.each }
+
+      it { subject.must_be_instance_of(Enumerator) }
+    end
+
+    describe '#empty?' do
+      subject { instance.empty? }
+
+      context 'when the storage is empty' do
+        it { subject.must_equal(true) }
+      end
+
+      context 'when the storage is not empty' do
+        let(:storage) { [mock] }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#find' do
+      subject { instance.find(model_name) }
+
+      context 'when the model cannot be found' do
+        let(:model_name) { 'not_found' }
+
+        it { proc { subject }.must_raise(ModelNotFound) }
+      end
+
+      context 'when the model is found' do
+        let(:model_instance) { model.new('terbium') }
+
+        before { instance.store(model_instance) }
+
+        it 'returns the stored model' do
+          subject.must_equal(model_instance)
+        end
+      end
+    end
+
+    describe '#find_or_create' do
+      let(:model_instance) { TestModel.new('niobium') }
+
+      subject { instance.find_or_create(model_name) }
+
+      it { instance.find_or_create('zinc').must_be_instance_of(Vedeu::TestModel) }
+
+      context 'when the model exists' do
+        let(:model_name) { 'niobium' }
+
+        before { instance.store(model_instance) }
+
+        it { subject.must_equal(model_instance) }
+      end
+
+      context 'when the model does not exist' do
+        let(:model_name) { 'zinc'}
+
+        it 'creates and stores a new instance of the model' do
+          subject.must_be_instance_of(Vedeu::TestModel)
+        end
+      end
+    end
+
+    describe '#registered' do
+      it 'returns an Array' do
+        RepositoriesTestClass.new.registered.must_be_instance_of(Array)
+      end
+
+      context 'when the storage is a Hash' do
+        it 'returns a collection of the names of all the registered entities' do
+          repo = RepositoriesTestClass.new
+          repo.add({ 'rutherfordium' => { name: 'rutherfordium' } })
+
+          repo.registered.must_equal(['rutherfordium'])
+        end
+      end
+
+      context 'when the storage is an Array' do
+        it 'returns the registered entities' do
+          repo = RepositoriesTestClass.new([])
+          repo.add('rutherfordium')
+
+          repo.registered.must_equal(['rutherfordium'])
+        end
+      end
+
+      context 'when the storage is a Set' do
+        it 'returns the registered entities' do
+          repo = RepositoriesTestClass.new(Set.new)
+          repo.add('rutherfordium')
+
+          repo.registered.must_equal(['rutherfordium'])
+        end
+      end
+
+      it 'returns an empty collection when the storage is empty' do
+        RepositoriesTestClass.new.registered.must_equal([])
+      end
+    end
+
+    describe '#registered?' do
+      it 'returns false with no name' do
+        RepositoriesTestClass.new.registered?('').must_equal(false)
+      end
+
+      it 'returns false with no name' do
+        RepositoriesTestClass.new.registered?(nil).must_equal(false)
+      end
+
+      it 'returns false when the storage is empty' do
+        RepositoriesTestClass.new.registered?('terbium').must_equal(false)
+      end
+
+      it 'returns false when the model is not registered' do
+        repo = RepositoriesTestClass.new
+        repo.add({ name: 'samarium' })
+
+        repo.registered?('terbium').must_equal(false)
+      end
+    end
+
+    describe '#remove' do
+      subject { instance.remove('francium') }
+
+      context 'when the storage is empty' do
+        before { instance.reset }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+
+      context 'when the model is not registered' do
+        before do
+          instance.reset
+          instance.store(Vedeu::TestModel.new('zinc'))
+        end
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+
+      context 'when the model is registered' do
+        before do
+          instance.reset
+          instance.store(Vedeu::TestModel.new('gadolinium'))
+          instance.store(Vedeu::TestModel.new('francium'))
+        end
+
+        it 'returns the storage with the model removed' do
+          subject.size.must_equal(1)
+        end
+      end
+    end
+
+    describe '#reset' do
+      it 'returns a Hash' do
+        instance.reset.must_be_instance_of(Hash)
+      end
+
+      it 'resets the repository' do
+        instance.reset.must_equal({})
+      end
+    end
+
+    describe '#store' do
+      subject { instance.store(model_instance) }
+
+      context 'when a name attribute is empty or nil' do
+        before { model_instance.name = '' }
+
+        it { proc { subject }.must_raise(MissingRequired) }
+      end
+
+      context 'when a name attributes is provided' do
+        let(:model_name) { 'hydrogen' }
+
+        it { subject.must_be_instance_of(Vedeu::TestModel) }
+      end
+    end
+
+    describe '#use' do
+      subject { instance.use(model_name) }
+
+      context 'when the model exists' do
+        before { instance.store(model_instance) }
+
+        it { subject.must_equal(model_instance) }
+      end
+
+      context 'when the model does not exist' do
+        let(:model_name) { 'not_found' }
+
+        it { subject.must_be_instance_of(NilClass) }
+      end
+    end
+
+  end # Repository
+
+end # Vedeu

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

@@ -9,9 +9,9 @@ module Vedeu
     let(:width)     { 40 }
 
     describe '#initialize' do
-      it { return_type_for(described, BoundingArea) }
-      it { assigns(described, '@height', height) }
-      it { assigns(described, '@width', width) }
+      it { described.must_be_instance_of(BoundingArea) }
+      it { described.instance_variable_get('@height').must_equal(height) }
+      it { described.instance_variable_get('@width').must_equal(width) }
     end
 
     describe '#height' do

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

@@ -2,8 +2,47 @@ 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

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

@@ -1,32 +1,47 @@
 require 'test_helper'
 
-class VedeuCommonClass
-  include Vedeu::Common
-
-  def defined_value_test(variable)
-    defined_value?(variable)
-  end
-end # VedeuCommonClass
-
 module Vedeu
 
   describe Common do
 
+    let(:described) { Vedeu::VedeuCommonClass.new }
+
     describe '#defined_value?' do
-      it 'return true when the variable is not nil or empty' do
-        VedeuCommonClass.new.defined_value_test('not empty').must_equal(true)
+      subject { described.defined_value_test(value) }
+
+      context 'when the variable is a Fixnum' do
+        let(:value) { 17 }
+
+        it { subject.must_equal(true) }
       end
 
-      it 'returns false when the variable is nil or empty' do
-        VedeuCommonClass.new.defined_value_test([]).must_equal(false)
+      context 'when the variable is not nil or empty' do
+        let(:value) { 'not empty' }
+
+        it { subject.must_equal(true) }
       end
 
-      it 'returns false when dealing with hash keys which may not exist or ' \
-         'have a value' do
-        attributes = {}
+      context 'when the variable is nil or empty' do
+        let(:value) { [] }
 
-        VedeuCommonClass.new.defined_value_test(attributes[:misc]).must_equal(false)
+        it { subject.must_equal(false) }
       end
+
+      context 'when dealing with keys which may not exist or have a value' do
+        let(:attributes) { {} }
+        let(:value)      { attributes[:not_found] }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#to_sentence' do
+      let(:array) { %w{ hydrogen helium lithium } }
+
+      subject { described.to_sentence(array) }
+
+      it { subject.must_be_instance_of(String) }
+      it { subject.must_equal('hydrogen, helium and lithium') }
     end
 
   end # Common

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

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Console do
+
+    let(:described) { Vedeu::Console }
+    let(:instance) { described.new(height, width) }
+    let(:height) { 24 }
+    let(:width) { 32 }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@height').must_equal(height) }
+      it { subject.instance_variable_get('@width').must_equal(width) }
+
+      context 'when the height is not given' do
+        let(:height) {}
+
+        it { subject.instance_variable_get('@height').must_equal(25) }
+      end
+
+      context 'when the width is not given' do
+        let(:width) {}
+
+        it { subject.instance_variable_get('@width').must_equal(80) }
+      end
+    end
+
+    describe '#input' do
+      let(:data) {}
+
+      subject { instance.input(data) }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+    describe '#output' do
+      let(:data) {}
+
+      subject { instance.output(data) }
+
+      it { subject.must_be_instance_of(Array) }
+    end
+
+    describe '#centre' do
+      subject { instance.centre }
+
+      it { subject.must_be_instance_of(Array) }
+      it { subject.must_equal([12, 16]) }
+    end
+
+    describe '#centre_y' do
+      subject { instance.centre_y }
+
+      it { subject.must_be_instance_of(Fixnum) }
+      it { subject.must_equal(12) }
+    end
+
+    describe '#centre_x' do
+      subject { instance.centre_x }
+
+      it { subject.must_be_instance_of(Fixnum) }
+      it { subject.must_equal(16) }
+    end
+
+    describe '#origin' do
+      subject { instance.origin }
+
+      it { subject.must_be_instance_of(Fixnum) }
+      it { subject.must_equal(1) }
+    end
+
+    describe '#size' do
+      subject { instance.size }
+
+      it { subject.must_be_instance_of(Array) }
+      it { subject.must_equal([24, 32]) }
+    end
+
+  end # Console
+
+end # Vedeu

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

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe ContentGeometry do
+
+    let(:described) { Vedeu::ContentGeometry }
+    let(:instance)  { described.new(interface) }
+    let(:interface) {
+      Vedeu::Interface.build do
+        geometry do
+          height 3
+          width  5
+        end
+        name 'content_geometry'
+      end
+    }
+    let(:lines) { [] }
+
+    before do
+      Vedeu.interfaces.reset
+      interface.stubs(:lines).returns(lines)
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@interface').must_equal(interface) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::ContentGeometry (y:1 x:1 yn:3 xn:5)>') }
+    end
+
+    describe '#yn' do
+      subject { instance.yn }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      context 'when the interface has content' do
+        context 'when there is more lines than height' do
+          let(:lines) {
+            [
+              [:line_1],
+              [:line_2],
+              [:line_3],
+              [:line_4]
+            ]
+          }
+
+          it { subject.must_equal(4) }
+        end
+
+        context 'when there is less lines than height' do
+          it { subject.must_equal(3) }
+        end
+      end
+
+      context 'when the interface does not have content' do
+        it { subject.must_equal(3) }
+      end
+    end
+
+    describe '#xn' do
+      subject { instance.xn }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      context 'when the interface has content' do
+        context 'when there are more characters than width' do
+          let(:lines) {
+            [
+              ['S', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't', '.'],
+              ['S', 'o', 'm', 'e'],
+              ['S', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't', '.', '.', '.'],
+              ['S', 'o', 'm', 'e', ' ', 't', 'e'],
+            ]
+          }
+
+          it { subject.must_equal(12) }
+        end
+
+        context 'when there are less characters than width' do
+          let(:lines) {
+            [
+              ['S', 'o', 'm', 'e'],
+              ['S', 'o', 'm', 'e'],
+              ['S', 'o', 'm', 'e'],
+              ['S', 'o', 'm', 'e'],
+            ]
+          }
+
+          it { subject.must_equal(5) }
+        end
+      end
+
+      context 'when the interface does not have content' do
+        it { subject.must_equal(5) }
+      end
+    end
+
+  end # ContentGeometry
+
+end # Vedeu