network_executive 0.0.1.alpha.1 → 0.0.2

data/spec/models/viewer_spec.rb

@@ -0,0 +1,210 @@
+describe NetworkExecutive::Viewer do
+  let(:env) { {} }
+
+  let(:viewer) { described_class.new( env ) }
+
+  subject { viewer }
+
+  describe '#ip' do
+    subject { viewer.ip }
+
+    context 'with a valid HTTP_X_FORWARDED_FOR header' do
+      before do
+        env['HTTP_X_FORWARDED_FOR'] = '255.255.255.255'
+      end
+
+      it { should == '255.255.255.255' }
+    end
+
+    context 'with an invalid HTTP_X_FORWARDED_FOR header' do
+      before do
+        env['HTTP_X_FORWARDED_FOR'] = ''
+        env['REMOTE_ADDR'] = '10.0.0.1'
+      end
+
+      it { should == '10.0.0.1' }
+    end
+
+    context 'with a REMOTE_ADDR header' do
+      before do
+        env['REMOTE_ADDR'] = '255.255.255.255'
+      end
+
+      it { should == '255.255.255.255' }
+    end
+  end
+
+  describe '#channel' do
+    subject { viewer.channel }
+
+    before do
+      described_class.any_instance.stub( :channel_name ).and_return 'test'
+    end
+
+    context 'with a known channel' do
+      it 'should find the channel' do
+        NetworkExecutive::Channel.should_receive( :find_by_name ).with( 'test' ).and_return true
+
+        subject
+      end
+    end
+
+    context 'with an unknown channel' do
+      it 'should raise an exception' do
+        NetworkExecutive::Channel.stub(:find_by_name).and_return nil
+
+        expect{ viewer.channel }.to raise_error NetworkExecutive::ChannelNotFoundError
+      end
+    end
+  end
+
+  describe '#stream' do
+    subject { viewer.stream }
+
+    it 'should be an EventSource' do
+      Faye::EventSource.should_receive( :new )
+
+      subject
+    end
+  end
+
+  describe '#tune_in' do
+    let(:channel) { double('channel').as_null_object }
+    let(:stream)  { double('stream').as_null_object }
+
+    before do
+      described_class.any_instance.stub( :ip )
+      described_class.any_instance.stub( :stream ).and_return stream
+      described_class.any_instance.stub( :channel ).and_return channel
+    end
+
+    subject { viewer.tune_in }
+
+    it 'should subscribe to the channel' do
+      channel.should_receive( :subscribe )
+
+      subject
+    end
+
+    it 'should register an onclose handler' do
+      subject
+
+      stream.onclose.should_not be_nil
+    end
+  end
+
+  describe '#tune_out' do
+    let(:channel) { double('channel').as_null_object }
+    let(:beat)    { double('heartbeat').as_null_object }
+    let(:id)      { 1 }
+
+    before do
+      described_class.any_instance.stub( :id ).and_return id
+      described_class.any_instance.stub( :channel ).and_return channel
+      described_class.any_instance.stub( :heartbeat ).and_return beat
+    end
+
+    subject { viewer.tune_out( nil ) }
+
+    it 'should unsubscribe from the channel' do
+      channel.should_receive( :unsubscribe ).with id
+
+      subject
+    end
+
+    it 'should cancel the heartbeat' do
+      beat.should_receive :cancel
+
+      subject
+    end
+
+    it 'should nullify the stream' do
+      subject
+
+      viewer.instance_variable_get('@stream').should be_nil
+    end
+  end
+
+  describe '#response' do
+    let(:stream) { double('stream') }
+
+    subject { viewer.response }
+
+    before do
+      described_class.any_instance.stub(:stream).and_return stream
+    end
+
+    it 'should return a response for Rack' do
+      stream.should_receive :rack_response
+
+      subject
+    end
+  end
+
+  describe '#channel_name' do
+    before do
+      env['PATH_INFO'] = '/foo/bar/baz'
+    end
+
+    subject { viewer.channel_name }
+
+    it { should == 'baz' }
+  end
+
+  describe '#keep_alive!' do
+    let(:stream) { double('stream') }
+
+    subject { viewer.keep_alive! }
+
+    before do
+      described_class.any_instance.stub :ip
+      described_class.any_instance.stub :channel
+      described_class.any_instance.stub( :stream ).and_return stream
+
+      EM.stub( :add_periodic_timer ).and_yield
+    end
+
+    it 'should send a ping' do
+      stream.should_receive :ping
+
+      subject
+    end
+  end
+
+  describe '.change_channel' do
+    subject { described_class.change_channel env }
+
+    before do
+      described_class.any_instance.stub :tune_in
+      described_class.any_instance.stub :keep_alive!
+      described_class.any_instance.stub :response
+    end
+
+    it 'should tune in to the channel' do
+      viewer = double('viewer').as_null_object
+
+      described_class.should_receive( :new ).with( env ).and_return viewer
+
+      subject
+    end
+
+    it 'should tune in to the channel' do
+      described_class.any_instance.should_receive :tune_in
+
+      subject
+    end
+
+    it 'should keep the connection alive' do
+      described_class.any_instance.should_receive :keep_alive!
+
+      subject
+    end
+
+    it 'should return a Rack response' do
+      described_class.any_instance.should_receive :response
+
+      subject
+    end
+  end
+
+end

data/spec/network_executive_spec.rb

@@ -0,0 +1,15 @@
+describe NetworkExecutive do
+  it { should be_a Module }
+
+  its(:config) { should be_a NetworkExecutive::Configuration }
+
+  describe '.configure' do
+    it 'should yield the config Hash' do
+      config = nil
+
+      described_class.configure { |c| config = c }
+
+      config.should eq described_class.config      
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,37 @@
-ENV['RACK_ENV'] ||= 'test'
+ENV['RACK_ENV']  ||= 'test'
+ENV['RAILS_ENV'] ||= 'test'
 
 require 'rubygems'
 require 'bundler/setup'
+
 require 'awesome_print'
 
+require File.expand_path( '../dummy/config/environment.rb',  __FILE__ )
+
+require 'rails/test_help'
+require 'rspec/rails'
+require 'fakefs/spec_helpers'
+require 'timecop'
+
+Rails.backtrace_cleaner.remove_silencers!
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
+
+  # Because of the use of Rack::Static, we need to initialize the
+  # fake filesystem before NetworkExecutive is loaded.
+  config.before do
+    FakeFS.activate!
+  end
+
+  config.after do
+    FakeFS.deactivate!
+
+    Timecop.return
+
+    NetworkExecutive::Network.channels.clear
+    NetworkExecutive::Network.programming.clear
+  end
 end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,3 @@
+describe NetworkExecutive::Configuration do
+  it { should respond_to :name }
+end

data/spec/unit/producer_spec.rb

@@ -0,0 +1,60 @@
+describe NetworkExecutive::Producer do
+
+  describe '.run!' do
+    subject { described_class.run! }
+
+    before do
+      EM.stub :add_timer
+    end
+
+    it 'should immediately run any scheduled programming' do
+      described_class.should_receive :run_scheduled_programming
+
+      subject
+    end
+
+    it 'should wait for the next 1-minute interval' do
+      Timecop.freeze Time.now.change( sec:59 )
+
+      EM.should_receive( :add_timer ).with 1
+
+      subject
+    end
+
+    it 'should run scheduled programming every minute' do
+      EM.stub( :add_timer ).and_yield
+
+      EM.should_receive( :add_periodic_timer ).with 60
+
+      subject
+    end
+
+    it 'should run any scheduled programming at intervals' do
+      described_class.should_receive( :run_scheduled_programming ).exactly(3).times
+
+      EM.stub( :add_timer ).and_yield
+      EM.stub( :add_periodic_timer ).and_yield
+
+      subject
+    end
+  end
+
+  describe '.run_scheduled_programming' do
+    let(:scheduled)   { double('channel', whats_on?: true) }
+    let(:unscheduled) { double('channel', whats_on?: nil) }
+
+    before do
+      NetworkExecutive::Network.stub(:channels).and_return [ scheduled, unscheduled ]
+    end
+
+    subject { described_class.run_scheduled_programming }
+
+    it 'should show all scheduled programming' do
+      scheduled.should_receive :show
+      unscheduled.should_receive( :show ).never
+
+      subject
+    end
+  end
+
+end

data/spec/unit/scheduling_spec.rb

@@ -0,0 +1,106 @@
+describe NetworkExecutive::Scheduling do
+
+  describe '.every' do
+    it 'should schedule the program' do
+      channel = Class.new( NetworkExecutive::Channel ) do
+        include NetworkExecutive::Scheduling
+
+        every :day, play:'my_show'
+      end
+
+      channel.schedule.first.should be_a NetworkExecutive::ProgramSchedule
+    end
+  end
+
+  describe 'schedule' do
+    it 'should be a ChannelSchedule' do
+      channel = Class.new( NetworkExecutive::Channel ) do
+        include NetworkExecutive::Scheduling
+      end
+
+      channel.schedule.should be_a NetworkExecutive::ChannelSchedule
+    end
+  end
+
+  describe '#whats_on?' do
+    let(:channel) do
+      Class.new( NetworkExecutive::Channel ) do
+        include NetworkExecutive::Scheduling
+      end
+    end
+
+    context 'with nothing scheduled' do
+      it 'should return nil' do
+        channel.new.whats_on?.should be_nil
+      end
+    end
+
+    it 'should return the most appropriate program for a given time' do
+      program_c = double('program c', include?: true)
+
+      channel.schedule.add double('program a', include?: false)
+      channel.schedule.add double('program b', include?: true)
+      channel.schedule.add program_c
+      channel.schedule.add double('program d', include?: false)
+
+      channel.new.whats_on?.should == program_c
+    end
+
+    it 'should return all programs scheduled for a range of times' do
+      program_b = double 'program b'
+      program_b.stub(:include?).and_return true, false
+
+      program_c = double 'program c'
+      program_c.stub(:include?).and_return false, true
+
+      channel.schedule.add double('program a', include?: false)
+      channel.schedule.add program_b
+      channel.schedule.add program_c
+      channel.schedule.add double('program d', include?: false)
+
+      shows = channel.new.whats_on?( 1.hour.ago, 1.hour.from_now )
+
+      shows.first[:program].should be program_b
+      shows.last[:program].should be program_c
+    end
+
+    it 'should yield a block when provided a stop_time' do
+      program_a = double('program a', include?: true)
+      channel.schedule.add program_a
+
+      channel.new.whats_on?( 1.hour.ago, 1.hour.from_now) do |program|
+        program.should be program_a
+      end
+    end
+  end
+
+  describe '#with_showtimes_between' do
+    let(:klass) do
+      Class.new( NetworkExecutive::Channel ) do
+        include NetworkExecutive::Scheduling
+
+        every :day, play:'my_show'
+      end
+    end
+
+    let(:channel) { klass.new }
+
+    subject do
+      program_a = double 'program_a', include?: true
+
+      channel.schedule.add program_a
+
+      range = [ 1.hour.ago, 1.hour.from_now ]
+
+      channel.with_showtimes_between( *range ) do |showtime, program|
+        'block retval'
+      end
+    end
+
+    it 'should contain the blocks return value' do
+      subject.all?{ |x| x == 'block retval' }.should be_true
+    end
+
+  end
+
+end

data/spec/unit/station/local_affiliate_spec.rb

@@ -0,0 +1,41 @@
+describe NetworkExecutive::Station::LocalAffiliate do
+  describe '#initialize' do
+    it 'should run the Producer on the next tick' do
+      EM.stub( :next_tick ).and_yield
+
+      NetworkExecutive::Producer.should_receive( :run! )
+
+      described_class.new
+    end
+  end
+
+  describe '#call' do
+    before { EM.stub( :next_tick ) }
+
+    let(:env) { double('env').as_null_object }
+
+    subject { described_class.new.call( env ) }
+
+    context 'with a request that accepts event streams' do
+      before do
+        Faye::EventSource.stub( :eventsource? ).and_return true
+      end
+
+      it 'should change the channel for the Viewer' do
+        NetworkExecutive::Viewer.should_receive( :change_channel ).with env
+
+        subject
+      end
+    end
+
+    context 'with a request that does not accept event streams' do
+      before do
+        Faye::EventSource.stub( :eventsource? ).and_return false
+      end
+
+      it 'should return a 403' do
+        subject.first.should == 403
+      end
+    end
+  end
+end

data/tasks/network_executive_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :network_executive do
+#   # Task goes here
+# end