network_executive 0.0.4 → 0.0.7

data/lib/network_executive/time_calculations.rb

@@ -0,0 +1,10 @@
+module NetworkExecutive
+  module TimeCalculations
+
+    # Rounds the specific time to the nearest interval
+    def floor( nearest )
+      Time.at( (self.to_f / nearest.to_i).floor * nearest.to_i )
+    end
+
+  end
+end

data/lib/network_executive/version.rb

@@ -1,3 +1,3 @@
 module NetworkExecutive
-  VERSION = '0.0.4'
+  VERSION = '0.0.7'
 end

data/lib/network_executive.rb

@@ -1,7 +1,8 @@
 require 'network_executive/version'
 require 'network_executive/configuration'
-require 'network_executive/engine'
+require 'network_executive/components'
 require 'network_executive/station'
+require 'network_executive/engine'
 
 module NetworkExecutive
 

data/network_executive.gemspec

@@ -19,9 +19,14 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency             'activesupport',   '~> 3.2.0'
   gem.add_dependency             'faye-websocket',  '~> 0.4.6'
+  gem.add_dependency             'ice_cube',        '~> 0.8.1'
 
+  gem.add_dependency             'twitter',         '~> 4.0.0'
+
+  # TODO: Where should these live?
   gem.add_runtime_dependency     'sass-rails'
   gem.add_runtime_dependency     'uglifier'
+  gem.add_runtime_dependency     'coffee-rails'
 
   gem.add_development_dependency 'awesome_print'
   gem.add_development_dependency 'rails',           '~> 3.2.8'

data/spec/models/channel_spec.rb

@@ -11,29 +11,47 @@ describe NetworkExecutive::Channel do
   subject { MyChannel.new }
 
   its(:name)         { should == 'my_channel' }
+  its(:to_s)         { should == 'my_channel' }
   its(:display_name) { should == 'my channel' }
-  its(:to_s)         { should == 'my channel' }
 
-  describe '#show' do
-    context 'for a program that exists' do
-      let(:scheduled_double) { double('program', program_name:'name') }
-      let(:program_double)   { double('program') }
+  describe '#play' do
+    let(:program_double) { double('program', occurs_at?: starting ) }
+
+    context 'at a programs start time' do
+      let(:starting) { true }
 
       it 'should play the program' do
-        NetworkExecutive::Program.stub( :find_by_name ).and_return program_double
+        program_double.should_receive( :play ).and_yield( {} )
 
-        program_double.should_receive :play
         described_class.any_instance.should_receive :push
 
-        subject.show scheduled_double
+        subject.play program_double
       end
     end
 
-    context 'for a program that does not exist' do
-      it 'should raise a ProgramNotFoundError' do
-        program = double('scheduled_program', program_name:'noop')
+    context 'after a programs start time' do
+      let(:starting) { false }
+
+      it 'should update the program' do
+        program_double.should_receive( :update ).and_yield( {} )
+
+        described_class.any_instance.should_receive :push
+
+        subject.play program_double
+      end
+    end
+  end
+
+  describe '#play_whats_on' do
+    let(:program) { double('program') }
+
+    it 'should ask what is on and play the program' do
+      described_class.any_instance.should_receive( :whats_on? ).and_return program
+
+      program.should_receive( :play ).and_yield( {} )
 
-        expect{ subject.show program }.to raise_error NetworkExecutive::ProgramNotFoundError
+      subject.play_whats_on do |m|
+        m.should == {}
       end
     end
   end

data/spec/models/{lineup_spec.rb → guide_spec.rb}

@@ -1,4 +1,4 @@
-describe NetworkExecutive::Lineup do
+describe NetworkExecutive::Guide do
 
   let(:show) do
     show = double('show', program_name:'show 1')
@@ -7,7 +7,7 @@ describe NetworkExecutive::Lineup do
   let(:channel) do
     channel = double('channel', display_name:'channel a').as_null_object
 
-    channel.stub(:whats_on?).and_yield( show ).and_return [ show ]
+    channel.stub(:whats_on_between?).and_return [ show ]
 
     channel
   end
@@ -25,6 +25,8 @@ describe NetworkExecutive::Lineup do
   end
 
   describe '#start_time' do
+    before { described_class.any_instance.stub(:generate) }
+
     context 'the default value' do
       subject { described_class.new.start_time }
 
@@ -45,6 +47,8 @@ describe NetworkExecutive::Lineup do
   end
 
   describe '#stop_time' do
+    before { described_class.any_instance.stub(:generate) }
+
     context 'the default value' do
       subject { described_class.new.stop_time }
 
@@ -64,6 +68,20 @@ describe NetworkExecutive::Lineup do
     end
   end
 
+  describe '#times' do
+    it 'should start with the start time' do
+      subject.times.first.should eq Time.now
+    end
+
+    it 'should contain 15 minute intervals' do
+      subject.times.size.should eq 6
+    end
+
+    it 'should end with 1.5 hours after start time' do
+      subject.times.last.should eq Time.now + 1.5.hours - 15.minutes
+    end
+  end
+
   describe '#channels' do
     subject { described_class.new[:channels] }
 
@@ -73,14 +91,18 @@ describe NetworkExecutive::Lineup do
       subject.first[:channel].should == channel
     end
 
-    it 'should contain an array of scheduled programs' do
-      subject.first[:schedule].should be_an Array
+    it 'should contain a collection of programs' do
+      subject.first[:programs].should be_an Array
     end
 
     it 'should ask the channel what is on' do
-      args = [ Time.now, 1.5.hours.from_now, kind_of(Hash) ]
+      args = [
+        Time.now,
+        (Time.now + 1.5.hours),
+        15.minutes
+      ]
 
-      channels.first.should_receive(:whats_on?).with( *args )
+      channels.first.should_receive(:whats_on_between?).with( *args )
 
       subject
     end

data/spec/models/program_spec.rb

@@ -11,14 +11,57 @@ describe NetworkExecutive::Program do
   subject { MyProgram.new }
 
   its(:name) { should == 'my_program' }
+  its(:display_name) { should == 'My Program' }
   its(:url)  { should == '' }
-  its(:play) { should == %q[{"name":"my_program","url":""}] }
+  its(:refresh) { should == :auto }
+  its(:onload) { should == {} }
+  its(:onupdate) { should == {} }
 
-  describe '#as_json' do
-    subject { MyProgram.new.as_json }
+  describe '#play' do
+    before { EM.stub( :defer ).and_yield }
+
+    it 'should return an EventSource payload' do
+      msg = nil
+
+      subject.play { |m| msg = m }
+
+      msg.should == %q[{"name":"my_program","url":"","onLoad":{},"refresh":"auto","event":"show:program"}]
+    end
+  end
+
+  describe '#onshow' do
+    subject { MyProgram.new.onshow }
 
     it { should include( name:'my_program' ) }
     it { should include( url: '' ) }
+    it { should include( onLoad: {} ) }
+    it { should include( refresh: :auto ) }
+  end
+
+  describe '#update' do
+    context 'when #refresh is set to :auto' do
+      it 'should play the program' do
+        subject.stub(:refresh).and_return :auto
+
+        subject.should_receive( :play )
+
+        subject.update
+      end
+    end
+
+    context 'when #refresh is NOT set to :auto' do
+      before { EM.stub(:defer).and_yield }
+
+      it 'should return the contents of #onupdate' do
+        subject.stub(:refresh).and_return 'zomg'
+
+        msg = nil
+
+        subject.update { |m| msg = m }
+
+        msg.should == %q[{"event":"update:program"}]
+      end
+    end
   end
 
   describe '.find_by_name' do

data/spec/models/viewer_spec.rb

@@ -69,7 +69,7 @@ describe NetworkExecutive::Viewer do
   end
 
   describe '#tune_in' do
-    let(:channel) { double('channel').as_null_object }
+    let(:channel) { double('channel', subscribe:true, play_whats_on:true) }
     let(:stream)  { double('stream').as_null_object }
 
     before do
@@ -91,6 +91,14 @@ describe NetworkExecutive::Viewer do
 
       stream.onclose.should_not be_nil
     end
+
+    it 'should immediately play whatever is currently scheduled' do
+      channel.should_receive( :play_whats_on ).and_yield( {} )
+
+      stream.should_receive( :send ).with kind_of(Hash)
+
+      subject
+    end
   end
 
   describe '#tune_out' do

data/spec/programs/off_air_spec.rb

@@ -0,0 +1,9 @@
+describe NetworkExecutive::OffAir do
+  it { should be_a NetworkExecutive::Program }
+
+  its(:display_name) { should == 'Off Air' }
+
+  its(:duration) { should == 15.minutes }
+
+  its(:url) { should == '/programs/off_air' }
+end

data/spec/spec_helper.rb

@@ -31,7 +31,8 @@ RSpec.configure do |config|
 
     Timecop.return
 
-    NetworkExecutive::Network.channels.clear
-    NetworkExecutive::Network.programming.clear
+    # Clear out any non-built-in instances
+    NetworkExecutive::Network.channels.reject! { |c| c.class.name.deconstantize != 'NetworkExecutive' }
+    NetworkExecutive::Network.programming.reject! { |p| p.class.name.deconstantize != 'NetworkExecutive' }
   end
 end

data/spec/unit/channel_schedule_spec.rb

@@ -0,0 +1,67 @@
+describe NetworkExecutive::ChannelSchedule do
+
+  let(:time)     { Time.now.change(min:45, sec:0) }
+  let(:interval) { 15.minutes }
+  let(:schedule) { described_class.new }
+
+  let(:program_schedule) do
+    occ = double('occurrence').tap do |o|
+      o.stub(:start_time).and_return time + interval
+      o.stub(:duration).and_return 20.minutes
+      o.stub(:end_time).and_return time + interval + 20.minutes - 1
+    end
+
+    double('program_schedule').tap do |ps|
+      ps.stub(:occurring_at?).and_return false
+      ps.stub(:occurring_at?).with( time + 15.minutes).and_return true
+      ps.stub(:duration).and_return 20.minutes
+      ps.stub(:occurrence_at).and_return occ
+    end
+  end
+
+  describe '#add' do
+    subject do
+      schedule.add( 'foo', foo:'bar' )
+    end
+
+    it 'should prepend a ProgramSchedule' do
+      NetworkExecutive::ProgramSchedule
+        .should_receive( :new )
+        .with( 'foo', { foo:'bar' } )
+        .and_return( program_schedule )
+
+      described_class.any_instance.should_receive( :unshift ).with program_schedule
+
+      subject
+    end
+  end
+
+  describe '#whats_on_between?' do
+    let(:start)    { time }
+    let(:stop)     { start + 1.hour }
+
+    before do
+      schedule.unshift program_schedule
+    end
+
+    subject do
+      schedule.whats_on_between? start, stop, interval
+    end
+
+    it 'should start with 15-minutes of Off Air time' do
+      subject.first.program.should be_a NetworkExecutive::OffAirSchedule
+      subject.first.remainder.should == 15.minutes - 1
+    end
+
+    it 'should contain a scheduled program at the apporiate time' do
+      subject[1].program.should eq program_schedule
+      subject[1].remainder.should eq 20.minutes - 1
+    end
+
+    it 'should fill the remaining time slots of Off Air time' do
+      subject.last.program.should be_a NetworkExecutive::OffAirSchedule
+      subject.last.remainder.should == 25.minutes
+    end
+  end
+
+end

data/spec/unit/components/photo_player_spec.rb

@@ -0,0 +1,76 @@
+describe NetworkExecutive::Components::PhotoPlayer do
+
+  let(:klass) do
+    Class.new.send :include, described_class
+  end
+
+  before do
+    stub_const 'MyProgram', klass
+  end
+
+  subject { MyProgram.new }
+
+  its(:url) { should == '/slideshow' }
+  its(:refresh) { should be_false }
+  its(:onload) { should include(photos:[]) }
+  its(:photos) { should be_empty }
+
+  describe '#feed_url' do
+    it 'should raise' do
+      expect { subject.feed_url }.to raise_error NotImplementedError
+    end
+  end
+
+  describe '#feed' do
+    let(:request)  { double('request').as_null_object }
+    let(:response) { double('response', body:'{}') }
+
+    before do
+      Net::HTTP::Get.stub(:new).and_return request
+      Net::HTTP.any_instance.stub(:request).and_return response
+    end
+
+    context 'with a HTTP feed URL' do
+      before do
+        subject.class.send(:define_method, :feed_url) do
+          'http://example.org'
+        end
+      end
+
+      it 'should not use SSL' do
+        Net::HTTP.any_instance.should_receive(:use_ssl=).with( true ).never
+
+        subject.feed
+      end
+
+      it 'should parse JSON' do
+        subject.feed.should == {}
+      end
+    end
+
+    context 'with a HTTPS feed URL' do
+      before do
+        subject.class.send(:define_method, :feed_url) do
+          'https://example.org'
+        end
+      end
+
+      it 'should use SSL' do
+        Net::HTTP.any_instance.should_receive(:use_ssl=).with true
+
+        subject.feed
+      end
+
+      it 'should not verify the certificate' do
+        Net::HTTP.any_instance.should_receive(:verify_mode=).with 0
+
+        subject.feed
+      end
+
+      it 'should parse JSON' do
+        subject.feed.should == {}
+      end
+    end
+  end
+
+end

data/spec/unit/components/tweet_player_spec.rb

@@ -0,0 +1,68 @@
+describe NetworkExecutive::Components::TweetPlayer do
+
+  let(:klass) do
+    Class.new do
+      def name; 'foo'; end
+    end.send :include, described_class
+  end
+
+  before do
+    stub_const 'MyProgram', klass
+  end
+
+  subject { MyProgram.new }
+
+  its(:url) { should == '/twitter' }
+
+  its(:refresh) { should be_false }
+
+  describe '#onload' do
+    it 'should include the Twitter search results' do
+      subject.class.should_receive( :tweets ).and_return( statuses: [] )
+
+      subject.onload.should include(:tweets)
+    end
+  end
+
+  describe '.tweets' do
+    it 'should delegate to the class' do
+      described_class.should_receive :tweets
+
+      described_class.tweets
+    end
+  end
+
+  describe '.client' do
+    it 'should be a Twitter Client' do
+      subject.class.client.should be_a Twitter::Client
+    end
+  end
+
+  describe '.configure' do
+    it 'should yield the client' do
+      arg = nil
+
+      subject.class.configure { |c| arg = c }
+
+      arg.should eq subject.class.client
+    end
+  end
+
+  describe '.search' do
+    it 'should configure the search query' do
+      subject.class.search 'search term', count: 4
+
+      subject.class.query.should eq [ 'search term', { count: 4 }]
+    end
+  end
+
+  describe '.tweets' do
+    it 'should search with the client instance' do
+      subject.class.search 'foo'
+
+      Twitter::Client.any_instance.should_receive( :search ).with 'foo'
+
+      subject.class.tweets
+    end
+  end
+end

data/spec/unit/components/you_tube_player_spec.rb

@@ -0,0 +1,17 @@
+describe NetworkExecutive::Components::YouTubePlayer do
+
+  let(:klass) do
+    Class.new.send :include, described_class
+  end
+
+  before do
+    stub_const 'MyProgram', klass
+  end
+
+  subject { MyProgram.new }
+
+  its(:url) { should == '/you_tube' }
+
+  its(:refresh) { should be_false }
+
+end

data/spec/unit/off_air_schedule_spec.rb

@@ -0,0 +1,28 @@
+describe NetworkExecutive::OffAirSchedule do
+
+  its(:program)  { should be_a NetworkExecutive::OffAir }
+  its(:duration) { should == 59.seconds }
+
+  it 'should be subclass ProgramSchedule' do
+    subject.is_a? NetworkExecutive::ProgramSchedule
+  end
+
+  describe '#occurrence_at' do
+    let(:time) { Time.now.change(min:0, sec:0) }
+
+    subject { described_class.new.occurrence_at time }
+
+    it 'return build a ProgramSchedule Occurrence' do
+      args = [
+        time,
+        59.seconds,
+        time + 59.seconds
+      ]
+
+      NetworkExecutive::ProgramSchedule::Occurrence.should_receive(:new).with( *args )
+
+      subject
+    end
+  end
+
+end

data/spec/unit/producer_spec.rb

@@ -41,17 +41,15 @@ describe NetworkExecutive::Producer do
 
   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 ]
+      NetworkExecutive::Network.stub(:channels).and_return [ scheduled ]
     end
 
     subject { described_class.run_scheduled_programming }
 
     it 'should show all scheduled programming' do
-      scheduled.should_receive :show
-      unscheduled.should_receive( :show ).never
+      scheduled.should_receive :play
 
       subject
     end

data/spec/unit/program_schedule_proxy_spec.rb

@@ -0,0 +1,102 @@
+describe NetworkExecutive::ProgramScheduleProxy do
+
+  describe '#initialize' do
+
+    context 'start time' do
+      context 'when specified' do
+        let(:time) { 1.hour.ago }
+
+        subject { described_class.new( time ) }
+
+        it 'should be the specified time' do
+          subject.start_time.should == time
+        end
+      end
+
+      context 'when unspecified' do
+        it 'should default to the beginning of the day' do
+          subject.start_time.should == Time.now.beginning_of_day
+        end
+      end
+    end
+
+    context 'duration' do
+      context 'when set' do
+        subject do
+          described_class.new( nil, 15.minutes ).duration
+        end
+
+        it 'should have the specified duration' do
+          subject.should == 15.minutes
+        end
+      end
+
+      context 'when not set' do
+        subject do
+          described_class.new.duration
+        end
+
+        it 'should default to a full day' do
+          subject.should == 24.hours
+        end
+      end
+    end
+
+    context 'block evaluation' do
+      it 'should evaluate the block' do
+        evald = false
+
+        described_class.new { evald = true }
+
+        evald.should be_true
+      end
+    end
+  end
+
+  describe '#to_schedule' do
+    it 'should return the internal IceCube::Schedule instance' do
+      subject.to_schedule.should be_a IceCube::Schedule
+    end
+  end
+
+  describe '#respond_to_missing?' do
+    context 'when parsing a schedule block' do
+      # TODO: Not the best test setup in the world...
+      before { subject.instance_variable_set('@parsing_schedule', true) }
+
+      it 'should respond to anything that IceCube::Rule does' do
+        subject.respond_to_missing?( :minutely ).should be_true
+      end
+    end
+
+    context 'when outside a schedule parsing block' do
+      it 'should respond to anything that IceCube::Rule does' do
+        subject.respond_to_missing?( :all_occurrences ).should be_true
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    context 'when parsing a schedule block' do
+      it 'should add a recurrence rule' do
+        IceCube::Schedule.any_instance.should_receive( :add_recurrence_rule )
+          .twice
+          .with kind_of( IceCube::Rule )
+
+        described_class.new do
+          minutely 30
+          minutely 45
+        end
+      end
+    end
+
+    context 'when outside a schedule parsing block' do
+      it 'should attempt to forward to the schedule' do
+        IceCube::Schedule.any_instance.should_receive( :all_occurrences )
+
+        described_class.new.all_occurrences
+      end
+    end
+  end
+
+end