vigilem-core 0.0.9

data/spec/vigilem/core/hooks/inheritable_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks'
+
+require 'vigilem/support/lazy_simple_delegator'
+
+require 'vigilem/support/system'
+
+require 'vigilem/core'
+
+describe Vigilem::Core::Hooks::Inheritable do
+  subject { Vigilem::Core::Device }
+  
+  context 'will inherit hooks' do
+    it 'will have at least one callback from AbstractDevice' do
+      expect(subject.hooks.find {|hook| hook.name == :after_init }.owner).to eql(Vigilem::Core::AbstractDevice)
+    end
+  end
+end

data/spec/vigilem/core/hooks/meta_callback_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks'
+
+require 'vigilem/core/hooks/meta_callback'
+describe Vigilem::Core::Hooks::MetaCallback do
+  subject do
+    described_class.new do
+      self
+    end
+  end
+  
+  describe '#ran?' do
+    it 'will start false because nothing has ran' do
+      expect(subject.ran?).to be_falsey
+    end
+  end
+  
+  context 'private' do
+    describe '#ran=' do
+      it 'sets ran' do
+        subject.send(:ran=, true)
+        expect(subject.ran?).to be_truthy
+      end
+    end
+  end
+  
+  shared_examples 'evaluatable' do 
+    before(:all) { Context = Class.new unless defined? :Context}
+    
+    let(:instance) { Context.new }
+      
+    let!(:result) { subject.send(method_name, instance) }
+    
+    it 'flags ran? to true' do
+      expect(subject.ran?).to be_truthy
+    end
+    
+    it 'runs callbackproc #evaluate' do
+      expect(result).to eql(instance)
+    end
+  end
+  
+  describe '#evaluate' do
+    
+    it_behaves_like 'evaluatable' do
+      let(:method_name) { :evaluate }
+    end
+  end
+  
+  describe '#[]' do
+    it_behaves_like 'evaluatable' do
+      let(:method_name) { :[] }
+    end
+  end
+  
+  describe '#call' do
+    When(:result) { subject.call }
+    
+    it 'flags ran to true' do
+      expect(subject.ran?).to be_truthy
+    end
+    
+    it 'will run like Proc' do
+      expect(result).to eql(self)
+    end
+  end
+  
+end

data/spec/vigilem/core/hooks/utils_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks/utils'
+
+describe Vigilem::Core::Hooks::Utils do
+  
+  before(:all) { TmpClass = Class.new }
+  
+  # @todo test instances
+  describe '#callback_is_in_subclass?' do
+    
+    before :all do
+      TempSubclass = Class.new(TmpClass) do
+        def self.callback 
+          lambda { puts self }
+        end
+      end
+    end
+    
+    it 'will determine whether the callback binding is a subclass of context' do
+      expect(described_class.callback_is_in_subclass?(TmpClass, TempSubclass.callback)).to be_truthy
+    end
+    
+  end
+end

data/spec/vigilem/core/hooks_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks'
+
+describe Vigilem::Core::Hooks do
+  
+  it 'will have hooks as instance method' do
+    expect(described_class.method_defined?(:hooks)).to be_truthy
+  end
+  
+  let!(:base) do
+    dc = described_class
+    Class.new do
+      extend dc
+    end
+  end
+  
+  let(:callback) do
+    Class.new do
+      def name
+        :testr
+      end
+      def run
+        self
+      end
+    end
+  end
+  
+  it 'will have class level run_hook method' do
+    expect(base).to respond_to(:run_hook)
+  end
+  
+  it 'will have an instance level run_hooks' do
+    expect(base.method_defined?(:run_hook)).to be_truthy
+  end
+  
+  it 'will have class level hooks' do
+    expect(base).to respond_to(:hooks)
+  end
+  
+  let(:base_instance) { base.new }
+  
+  let!(:hooks) { base.hooks << callback.new }
+  
+  it 'will call run on every hook' do
+    expect(base.hooks.first).to receive(:run)
+    base_instance.run_hook :testr
+  end
+  
+end

data/spec/vigilem/core/hub_spec.rb

@@ -0,0 +1,51 @@
+require 'vigilem/core/hub'
+
+describe Vigilem::Core::Hub do
+  
+  subject { described_class.new([]) }
+  
+  describe '#initialize' do
+    it 'will initialize the buffers' do
+      expect(subject.buffers).to_not be_nil
+    end
+  end
+  
+  describe '#add_buffer' do
+    let(:buffer) { Object.new }
+    
+    it 'will add to the buffers' do
+      subject.add_buffer(buffer)
+      expect(subject.buffers).to include(buffer)
+    end
+  end
+  
+  describe '#<<' do
+    let(:buffer) { Object.new }
+    
+    it 'will add to the buffers' do
+      subject << buffer
+      expect(subject.buffers).to include(buffer)
+    end
+  end
+  
+  describe '#demux' do
+    
+    let(:buffer) { [1,2,3] }
+    
+    let(:buffer2) { %w(a b c) }
+    
+    let!(:reg) do 
+      subject.add_buffer(buffer)
+      subject.add_buffer(buffer2)
+    end
+    
+    it 'returns buffers that get the new messages' do
+      expect(subject.demux(buffer2, 5)).to eql([buffer])
+    end
+    
+    it 'updates the buffers except the link' do
+      subject.demux([], 5)
+      expect(buffer).to eql([1,2,3,5])
+    end
+  end
+end

data/spec/vigilem/core/input_system_handler_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+require 'vigilem/core/input_system_handler'
+
+describe Vigilem::Core::InputSystemHandler do
+  
+  after(:each) do
+    (described_class.instance_variables).each do |ivar| 
+        described_class.send(:remove_instance_variable, ivar)
+    end
+  end
+  
+  class FakeHandler
+    include Vigilem::Core::InputSystemHandler
+    def initialize
+      initialize_input_system_handler
+    end
+  end
+  
+  let(:handler) { FakeHandler.new }
+  
+  describe '#initialize' do
+    
+    it 'will initialize inbox/buffer' do
+      expect(handler.inbox).to_not be_nil
+    end
+    
+    it 'will register the base class when initialized' do
+      expect(FakeHandler.all).to include handler
+    end
+  end
+  
+end

data/spec/vigilem/core/lockable_pipeline_component_spec.rb

@@ -0,0 +1,19 @@
+require 'vigilem/core/lockable_pipeline_component'
+
+describe Vigilem::Core::LockablePipelineComponent do
+  
+  class LPCHost
+    include Vigilem::Core::LockablePipelineComponent
+  end
+  
+  subject { LPCHost.new }
+  
+  describe '#semaphore' do
+    it 'pulls from #source if available' do
+      allow(subject).to receive(:source)
+      expect(subject).to receive(:source)
+      subject.semaphore
+    end
+  end
+  
+end

data/spec/vigilem/core/multiplexer_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+require 'tempfile'
+
+require 'vigilem/support/core_ext'
+
+require 'vigilem/core/multiplexer'
+
+describe Vigilem::Core::Multiplexer do
+  
+  before(:each) do
+    @out = Tempfile.new('out')
+    @ios = [Tempfile.new('foo'), Tempfile.new('bar'),
+                      Tempfile.new('fizz'), Tempfile.new('buzz')]
+  end
+  
+  class MultiplexerHost
+    include Vigilem::Core::Multiplexer
+    def initialize(inpts, out=nil)
+      initialize_multiplexer(inpts, out)
+    end
+    
+  end
+  
+  after(:each) do
+    @out.respond(:close)
+    @ios.each {|io| io.respond.close }
+  end
+  
+  let(:out) { @out }
+  
+  let(:io_objs) { @ios[0..1] }
+  
+  describe '::initialize' do
+    
+    it 'updates inputs array' do
+      expect(MultiplexerHost.new(io_objs.sample(2), out).inputs).to match [duck_type(:fileno)]  * 2
+    end
+    
+  end
+  
+  context 'post init' do
+    
+    let(:plex) { MultiplexerHost.new(@ios, out) }
+    
+    describe '#ready?' do
+      
+      context 'all ready' do
+        
+        it 'returns the ready files' do
+          expect(plex.ready?).to match(@ios)
+        end
+      end
+      context 'some not ready' do
+        let(:rw) { IO.pipe }
+        
+        let(:pipes) do 
+          rw.last << 'ready'
+          [IO.pipe, *rw].flatten
+        end
+        
+        let(:mplex) { MultiplexerHost.new(pipes) }
+        
+        it 'returns the ready files' do
+          #expect(mplex.ready?).to eql([rw]) #hangs
+          expect(mplex.ready?.first).to eql(rw.first)
+        end
+      end
+      
+    end
+    
+    context 'private' do
+      describe '#recursive_check' do
+        it %q<checks to make sure an input on the multiplexer isn't the same as the output> do
+          a = []
+          plex.inputs << a
+          plex.output = a
+          expect do
+            plex.send(:recursive_check)
+          end.to raise_error(ArgumentError)
+        end
+      end
+    end
+    
+    describe '::add_inputs' do
+      it %q<raises error if an input and matches the output> do
+        expect do
+          plex.add_inputs(plex.output)
+        end.to raise_error(ArgumentError)
+      end
+      
+      it %q<runs a uniq! to prevent duplicate items in the inputs> do
+        ipt = plex.inputs.first
+        expect(plex.add_inputs(ipt).count(ipt)).to eql(1)
+      end
+    end
+    
+    describe '#mux' do
+      
+      before(:each) do
+        allow(plex).to receive(:sweep).with(3) { [1,2,3] }
+      end
+      
+      it 'takes the return from sweep and adds it to #out' do
+        plex.mux(3)
+        expect((f = File.open(plex.out)).each_char.to_a).to eql(%w(1 2 3))
+        f.close
+      end
+      
+    end
+    
+  end
+end

data/spec/vigilem/core/pipeline_spec.rb

@@ -0,0 +1,5 @@
+require 'vigilem/core/pipeline'
+
+describe Vigilem::Core::Pipeline do
+
+end

data/spec/vigilem/core/stat_spec.rb

@@ -0,0 +1,63 @@
+require 'vigilem/core/stat'
+
+# @TODO cleanup commented out parts
+describe Vigilem::Core::Stat do
+  
+  context 'class level' do
+    describe 'initialize' do
+      it 'setup class level platform masks' do
+        arg = described_class.new('FakeInputSystem', 'fake_input_system_gem', :platforms => /.+/ )
+        expect(arg.platform_masks).to eql([/.+/])
+      end
+      
+      it 'will have more granular proc check than just platforms' do
+        check = lambda { 'test' }
+        arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /.+/, &check)
+        expect(arg.send :api_check).to eql(check)
+      end
+      
+      describe '::api_check?' do
+        it 'will run the api check and "convert" the result to [TrueClass || FalseClass]' do
+          arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /.+/) { 'test' }
+          expect(arg.api_check?).to be_truthy
+        end
+      end
+      
+      describe '::available_on?' do
+        it 'will test the platforms set in new against a given String' do
+          arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /darwin/)
+          expect(arg.available_on?('darwin')).to be_truthy
+        end
+      end
+        #alias_method :is_available_on?, :available_on?
+      
+      describe '::available?' do
+        let(:check) { lambda { true } }
+        
+        context 'platforms match' do
+          
+          it 'will call check' do
+            arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /.+/, &check)
+            expect(check).to receive(:call).and_return(true)
+            arg.available?
+          end
+          
+          it 'available? will be true' do
+            arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /.+/, &check)
+            expect(arg.available?).to be_truthy
+          end
+        end
+        context %q<platforms don't match> do
+          
+          it '#available? will be false' do
+            arg = described_class.new('FakeInputSystem', 'fake_input_system_gem',  :platforms => /1234/, &check)
+            expect(arg.available?).to be_falsey
+          end
+        end
+        
+      end
+      
+    end
+  end
+  
+end