live_f1-core 0.0.1

data/spec/live_f1/packet/sys/key_frame_spec.rb

@@ -0,0 +1,39 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::KeyFrame do
+  it_behaves_like LiveF1::Packet::Type::Short
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+
+  describe "#number" do
+    # `data` for a KeyFrame packet represents a little-endian integer
+    it "reads its keyframe number from the data" do
+      # Binary: "00000000/00000011"
+      subject.data = [3,0].pack("c*")
+      subject.number.should == 3
+
+      # Binary: "00000001/00000011"
+      subject.data = [3,1].pack("c*")
+      subject.number.should == 259
+    end
+  end
+  
+  # describe "#inspect" do
+  #   it "returns a string representation of the keyframe" do
+  #     subject.stub(:number) { 25 }
+  #     subject.inspect.should == "Keyframe 25"
+  #   end
+  # end
+end

data/spec/live_f1/packet/sys/notice_spec.rb

@@ -0,0 +1,20 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::Notice do
+  it_behaves_like LiveF1::Packet::Type::Long
+  it_behaves_like LiveF1::Packet::Decryptable
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+end

data/spec/live_f1/packet/sys/reset_spec.rb

@@ -0,0 +1,26 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::Reset do
+  it_behaves_like LiveF1::Packet::Type::Special
+
+  subject { packet }
+
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+
+  # describe "#inspect" do
+  #   it "returns a string representation of the keyframe" do
+  #     subject.stub(:number) { 25 }
+  #     subject.inspect.should == "Keyframe 25"
+  #   end
+  # end
+end

data/spec/live_f1/packet/sys/session_start_spec.rb

@@ -0,0 +1,31 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::SessionStart do
+  it_behaves_like LiveF1::Packet::Type::Short
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header, :data => "0000010".to_i(2)) }
+  let(:data)   { "\x005678" }
+  let(:packet) do
+    described_class.new(source, header).tap do |packet|
+      packet.send :set_data, data
+    end
+  end
+  
+  describe "#session_number" do
+    it "reads a session number from the data" do
+      subject.session_number.should == 5678
+    end
+  end
+  
+  describe "#event_type" do
+    it "returns the event type indicated in the first data byte" do
+      subject.event_type.should == 2
+    end
+  end
+end

data/spec/live_f1/packet/sys/speed_spec.rb

@@ -0,0 +1,20 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::Speed do
+  it_behaves_like LiveF1::Packet::Type::Long
+  it_behaves_like LiveF1::Packet::Decryptable
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+end

data/spec/live_f1/packet/sys/timestamp_spec.rb

@@ -0,0 +1,34 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::Timestamp do
+  it_behaves_like LiveF1::Packet::Type::Timestamp
+  it_behaves_like LiveF1::Packet::Decryptable
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "\x03\x00" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+
+  describe "#number" do
+    # `data` for a KeyFrame packet represents a little-endian integer
+    it "read a session number from the data" do
+      # Binary: "00000000/00000011"
+      subject.send :set_data, [3,0].pack("c*")
+      subject.number.should == 3
+  
+  
+      # Binary: "00000001/00000011"
+      subject.send :set_data, [3,1].pack("c*")
+      subject.number.should == 259
+    end
+  end
+end

data/spec/live_f1/packet/sys/track_status_spec.rb

@@ -0,0 +1,20 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::TrackStatus do
+  it_behaves_like LiveF1::Packet::Type::Short
+  it_behaves_like LiveF1::Packet::Decryptable
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+end

data/spec/live_f1/packet/sys/weather_spec.rb

@@ -0,0 +1,20 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet::Sys::Weather do
+  it_behaves_like LiveF1::Packet::Type::Short
+  it_behaves_like LiveF1::Packet::Decryptable
+
+  subject { packet }
+  
+  let(:source) { mock(:source) }
+  let(:header) { mock(:header) }
+  let(:data)   { "" }
+  let(:packet) do
+    packet = described_class.new(source, header)
+    packet.send :set_data, data
+    packet
+  end
+end

data/spec/live_f1/packet_spec.rb

@@ -0,0 +1,112 @@
+require 'live_f1/packet'
+require 'spec_helper'
+
+module LiveF1
+  class Packet
+    module Spec
+      class Base < Packet; def length; 0; end; end
+      class Decryptable < Packet; include Packet::Type::Short; include Packet::Decryptable; end
+      class Short < Packet; include Packet::Type::Short; end
+      class Long < Packet; include Packet::Type::Long; end
+      class Special < Packet; include Packet::Type::Special; end
+      class Timestamp < Packet; include Packet::Type::Timestamp; end
+    end
+  end
+end
+
+def mock_packet stubs = {}
+  base_stubs = {
+    :data => "",
+    :data= => nil,
+    :length => 0
+  }
+  mock("packet", base_stubs.merge(stubs))
+end
+
+extend PacketTypeExamples
+
+describe LiveF1::Packet do
+  describe "::from_source" do
+    let(:source) { mock("source", :read_bytes => "") }
+    let(:header) { mock("header", :packet_klass => LiveF1::Packet::Spec::Base) }
+    let(:packet) { mock_packet :length => 7 }
+    let(:event_type) { LiveF1::Event::QUALIFYING }
+    before do
+      LiveF1::Packet::Header.stub(:from_source).with(source, event_type) { header }
+    end
+
+    it "extracts a packet header from the source" do
+      LiveF1::Packet::Header.should_receive(:from_source).with(source, event_type) { header }
+
+      described_class.from_source(source, event_type)
+    end
+
+    it "returns the kind of packet specified in the header" do
+      described_class.from_source(source, event_type).should be_a_kind_of(LiveF1::Packet::Spec::Base)
+    end
+
+    it "reads bytes from the source depending on its determined length" do
+      described_class.stub(:new) { packet }
+
+      source.should_receive(:read_bytes).with(7) { "       " }
+
+      described_class.from_source(source, event_type)
+    end
+
+    it "sets the packet data to the data read from the source" do
+      described_class.stub(:new) { packet }
+      source.stub(:read_bytes).with(7) { "abcdefg" }
+
+      packet.should_receive(:data=).with("abcdefg")
+
+      described_class.from_source(source, event_type)
+    end
+  end
+
+  describe "(constructor)" do
+    let(:source) { mock("source") }
+    let(:header) { mock("header") }
+    let(:packet) { LiveF1::Packet::Spec::Base.new(source, header) }
+
+    it "sets the source property" do
+      packet.source.should == source
+    end
+
+    it "sets the header property" do
+      packet.header.should == header
+    end
+  end
+
+  describe "(instance methods)" do
+    subject { packet }
+    let(:source) { mock("source") }
+    let(:header) { mock("header", :packet_type => 0, :data => 0) }
+    let(:packet) { LiveF1::Packet::Spec::Base.new(source, header) }
+
+    describe "#inspect" do
+      it "include the class name" do
+        subject.inspect.should include("Spec::Base")
+      end
+    end
+  end
+end
+
+describe LiveF1::Packet::Spec::Decryptable do
+  it_behaves_like LiveF1::Packet::Decryptable
+end
+
+describe LiveF1::Packet::Spec::Long do
+  it_behaves_like LiveF1::Packet::Type::Long
+end
+
+describe LiveF1::Packet::Spec::Short do
+  it_behaves_like LiveF1::Packet::Type::Short
+end
+
+describe LiveF1::Packet::Spec::Special do
+  it_behaves_like LiveF1::Packet::Type::Special
+end
+
+describe LiveF1::Packet::Spec::Timestamp do
+  it_behaves_like LiveF1::Packet::Type::Timestamp
+end

data/spec/live_f1/source/keyframe_spec.rb

@@ -0,0 +1,56 @@
+require 'live_f1/source'
+
+describe LiveF1::Source::Keyframe do
+  let(:io) { mock(:io) }
+  let(:parent) { mock(:source) }
+  
+  describe "(constructor)" do
+    let(:source) { described_class.new(io, parent) }
+    let(:data) { "" }
+    
+    it "takes an io object as the first parameter" do
+      source.io.should == io
+    end
+
+    it "takes a password as the second parameter" do
+      source.parent.should == parent
+    end
+  end
+  
+  describe "(instance methods)" do
+    let(:source) { described_class.new(io, parent) }
+    
+    describe "#read_bytes" do
+      it "reads from the keyframe data" do
+        io.should_receive(:read).with(2) { "xx" }
+        
+        source.read_bytes(2)
+      end
+    end
+    
+    describe "#session" do
+      it "uses its parent source's session" do
+        session = mock(:session)
+        parent.stub(:session) { session }
+        source.session.should == session
+      end
+    end
+    
+    describe "#session=" do
+      it "sets its parent source's session" do
+        session = mock(:session)
+        parent.should_receive(:session=).with(session)
+
+        source.session = session
+      end
+    end
+    
+    describe "#decryption_key" do
+      it "uses its parent source's decryption key" do
+        parent.should_receive(:decryption_key).with(1234) { "5caff01d" }
+        
+        source.decryption_key(1234).should == "5caff01d"
+      end
+    end
+  end
+end

data/spec/live_f1/source/live_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'live_f1/source'
+
+describe LiveF1::Source::Live do
+  let(:username) { "username@example.com" }
+  let(:password) { "swordfish" }
+
+  describe "(constructor)" do
+    let(:source) { described_class.new(username, password) }
+
+    it "takes a username as the first parameter" do
+      source.username.should == username
+    end
+
+    it "takes a password as the second parameter" do
+      source.password.should == password
+    end
+  end
+
+  describe "(instance methods)" do
+    let(:source) { described_class.new(username, password) }
+
+    describe "#read_bytes" do
+      let(:socket) { mock(:socket) }
+      it "reads from the live f1 socket" do
+        source.stub(:socket) { socket }
+        socket.should_receive(:read).with(2) { "xx" }
+
+        source.read_bytes(2)
+      end
+    end
+
+    describe "#socket" do
+      it "opens a TCPSocket to the live timing server" do
+        TCPSocket.should_receive(:open).with("80.231.178.249", 4321) { mock("socket") }
+        source.send(:socket)
+      end
+
+      it "uses an existing socket if available" do
+        TCPSocket.should_receive(:open).once { mock("socket") }
+        source.send(:socket)
+        source.send(:socket)
+      end
+    end
+
+    describe "#keyframe" do
+      let(:io) { mock(:io, :read => "", :rewind => 0) }
+
+      context "without a keyframe number" do
+        it "returns a Keyframe source initialised with the correct URL and parent source" do
+          source.should_receive(:open).with("http://80.231.178.249/keyframe.bin") { io }
+          LiveF1::Source::Keyframe.should_receive(:new).with(io, source)
+
+          source.keyframe
+        end
+      end
+
+      context "with a keyframe number" do
+        it "returns a Keyframe source initialised with the correct URL and parent source" do
+          source.should_receive(:open).with("http://80.231.178.249/keyframe_00012.bin") { io }
+          LiveF1::Source::Keyframe.should_receive(:new).with(io, source)
+
+          source.keyframe(12)
+        end
+      end
+
+      context "on SocketError" do
+        before do
+          source.stub(:open).and_raise(SocketError)
+        end
+
+        it "raises ConnectionError" do
+          lambda { source.keyframe }.should raise_error(LiveF1::Source::Live::ConnectionError)
+        end
+      end
+    end
+
+    describe "#decryption_key" do
+      let(:decryption_url) { "http://80.231.178.249/reg/getkey/1234.asp?auth=ABC123DEF" }
+
+      before do
+        source.stub(:auth) { "ABC123DEF" }
+      end
+
+      it "uses the live source's authorization to request decryption key from the live timing servers" do
+        source.should_receive(:open).with(decryption_url) { mock(:io, :read => "5caff01d") }
+        source.decryption_key(1234).should == "5caff01d".to_i(16)
+      end
+
+      it "raises a ConnectionError when decryption key service returns 0" do
+        source.should_receive(:open).with(decryption_url) { mock(:io, :read => "0") }
+        lambda { source.decryption_key(1234) }.should raise_error(LiveF1::Source::Live::ConnectionError, /session key/)
+      end
+    end
+
+    describe "#auth" do
+      before do
+        FakeWeb.register_uri :post, "http://80.231.178.249/reg/login", :set_cookie => "USER=abcdef"
+      end
+
+      it "loads authentication from the live timing servers" do
+        source.send(:auth).should == "abcdef"
+      end
+    end
+  end
+end

data/spec/live_f1/source/session_spec.rb

@@ -0,0 +1,39 @@
+require 'live_f1/source/session'
+
+describe LiveF1::Source::Session do
+  describe "(constructor)" do
+    let(:session) { described_class.new(1, 2, 3) }
+
+    it "sets the session number, event type and decryption key" do
+      session.number.should == 1
+      session.event_type.should == 2
+      session.decryption_key.should == 3
+    end
+    
+    it "initializes the decryption salt" do
+      session.decryption_salt.should == 0x55555555
+    end
+  end
+  
+  describe "(instance methods)" do
+    let(:session) { described_class.new(1, 2, 3) }
+    
+    describe "#decrypt" do
+      let(:decryption_key) { "B247A746".to_i(16) }
+      let(:encrypted) { "\xBC\x9A\x1E\x9AH>\xCB\xE4\xFE\xE0v!h\r\xF9" }
+      let(:decrypted) { "Please Wait ..." }
+      it "decrypts data" do
+        session.stub(:decryption_key) { decryption_key }
+        session.decrypt(encrypted).should == decrypted
+      end
+    end
+    
+    describe "#reset_decryption_salt!" do
+      it "resets the decryption salt" do
+        session.decryption_salt = 0x01010101
+        session.reset_decryption_salt!
+        session.decryption_salt.should == 0x55555555
+      end
+    end
+  end
+end

data/spec/live_f1/source_spec.rb

@@ -0,0 +1,140 @@
+require 'live_f1/source'
+
+class TestSource < LiveF1::Source
+end
+
+module LiveF1
+  class Packet
+  end
+end
+
+describe LiveF1::Source do
+  describe "(instance methods)" do
+    let(:source) { TestSource.new }
+    let(:session) { mock(:session) }
+    
+    before do
+      source.stub(:session) { session }
+    end
+    
+    describe "#run" do
+      let(:packets) { [mock("packet"),mock("packet"),mock("packet")] }
+
+      before do
+        p = packets ? packets.dup : []
+        source.stub(:read_packet) { p.shift }
+      end
+
+      context "with keyframes available" do
+        let(:keyframe_source) { mock("keyframe source") }
+        before do
+          source.stub(:keyframe) { keyframe_source }
+        end
+
+        it "runs the keyframe" do
+          keyframe_source.should_receive(:run)
+
+          source.run { }
+        end
+      end
+
+      it "reads packets" do
+        source.should_receive(:read_packet) { nil }
+        source.run { }
+      end
+
+      it "yields as many packets as are available" do
+        @packets = []
+        source.run do |p|
+          @packets << p
+        end
+        @packets.should == packets
+      end
+
+      describe "running" do
+        let(:header) { mock("header") }
+        let(:decryption_key) { "5caff01d".to_i(16) }
+        let(:session_number) { 1234 }
+        
+        before do
+          source.stub(:decryption_key).with(session_number) { decryption_key }
+        end
+        
+        context "when an SessionStart packet is yielded" do
+          let(:packets) do
+            packet = LiveF1::Packet::Sys::SessionStart.new(source, header)
+            packet.stub(:session_number) { session_number }
+            packet.stub(:event_type) { 3 }
+            [packet]
+          end
+          
+          it "creates a source session with the correct data" do
+            LiveF1::Source::Session.should_receive(:new).with(1234, 3, decryption_key) { mock(:session) }
+            
+            source.run { }
+          end
+
+          it "sets the source's session to the new session object" do
+            LiveF1::Source::Session.stub(:new) { session }
+            source.should_receive(:session=).with(session)
+
+            source.run {  }
+          end
+        end
+
+        context "when an KeyFrame packet is yielded" do
+          let(:packets) do
+            packet = LiveF1::Packet::Sys::KeyFrame.new(source, header)
+            packet.stub(:number) { 123 }
+            [packet]
+          end
+          let(:session) { mock(:session, :reset_decryption_salt! => true) }
+          
+          before do
+            source.stub(:session) { session }
+          end
+          
+          it "resets the session's decryption data" do
+            session.should_receive(:reset_decryption_salt!) { true }
+            source.run { }
+          end
+
+        end
+      end
+    end
+
+    describe "#read_packet" do
+      let(:packet) { mock("packet") }
+      let(:session) { mock(:session, :event_type => 3) }
+
+      before do
+        LiveF1::Packet.stub(:from_source).with(source, 3) { packet }
+        source.session = session
+      end
+
+      it "extracts a packet from itself" do
+        LiveF1::Packet.should_receive(:from_source).with(source, 3) { packet }
+
+        source.read_packet
+      end
+
+      it "returns the extracted packet" do
+        source.read_packet.should == packet
+      end
+    end
+    
+    describe "#decrypt" do
+      let(:input)  { "encrypted" }
+      let(:output) { "plaintext" }
+      it "calls its session's decryptor" do
+        session.should_receive(:decrypt).with(input)
+        source.decrypt(input)
+      end
+
+      it "returns the decrypted bytes" do
+        session.stub(:decrypt) { output }
+        source.decrypt(input).should == output
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'fakeweb'
+
+Dir["spec/support/**/*.rb"].each { |f| require File.join(File.expand_path(File.dirname(__FILE__)),"..",f) }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+end
+
+FakeWeb.allow_net_connect = false