rail_feeds 0.0.1

data/spec/rail_feeds/network_rail/smart_spec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+describe RailFeeds::NetworkRail::SMART do
+  let :json do
+    '{"BERTHDATA":[{"ROUTE":"2","STANME":"NEWBRGH","BERTHOFFSET":"0","EVENT":"B","COMM' \
+    'ENT":"17/02/2008","PLATFORM":"5","TD":"EA","FROMBERTH":"B674","TOBERTH":"B672","S' \
+    'TANOX":"03211","STEPTYPE":"B","TOLINE":"F","FROMLINE":"S"},{"ROUTE":"","STANME":"' \
+    'DMOORCTRL","BERTHOFFSET":"+60","EVENT":"C","COMMENT":"Migrated on 8/6/2005","PLAT' \
+    'FORM":"","TD":"A2","FROMBERTH":"0759","TOBERTH":"0808","STANOX":"89748","STEPTYPE' \
+    '":"","TOLINE":"","FROMLINE":""},{"ROUTE":"","STANME":"","BERTHOFFSET":"","EVENT":' \
+    '"","COMMENT":"","PLATFORM":"","TD":"","FROMBERTH":"","TOBERTH":"","STANOX":"","ST' \
+    'EPTYPE":"","TOLINE":"","FROMLINE":""}]}'
+  end
+  let(:http_client) { double RailFeeds::NetworkRail::HTTPClient }
+  let(:reader) { double Zlib::GzipReader }
+
+  describe '::download' do
+    let(:http_client) { double RailFeeds::NetworkRail::HTTPClient }
+    let(:temp_file) { double Tempfile }
+
+    it 'Using default credentials' do
+      expect(RailFeeds::NetworkRail::HTTPClient).to receive(:new)
+        .with(credentials: RailFeeds::NetworkRail::Credentials).and_return(http_client)
+      expect(http_client).to receive(:download)
+        .with('ntrod/SupportingFileAuthenticate?type=SMART', 'file')
+      described_class.download 'file'
+    end
+
+    it 'Using passed credentials' do
+      credentials = double RailFeeds::NetworkRail::Credentials
+      expect(RailFeeds::NetworkRail::HTTPClient).to receive(:new)
+        .with(credentials: credentials).and_return(http_client)
+      expect(http_client).to receive(:download)
+      described_class.download 'file', credentials: credentials
+    end
+  end
+
+  describe '::fetch' do
+    let(:http_client) { double RailFeeds::NetworkRail::HTTPClient }
+    let(:temp_file) { double Tempfile }
+
+    it 'Using default credentials' do
+      expect(RailFeeds::NetworkRail::HTTPClient).to receive(:new)
+        .with(credentials: RailFeeds::NetworkRail::Credentials).and_return(http_client)
+      expect(http_client).to receive(:fetch)
+        .with('ntrod/SupportingFileAuthenticate?type=SMART').and_return(temp_file)
+      expect(described_class.fetch).to eq temp_file
+    end
+
+    it 'Using passed credentials' do
+      credentials = double RailFeeds::NetworkRail::Credentials
+      expect(RailFeeds::NetworkRail::HTTPClient).to receive(:new)
+        .with(credentials: credentials).and_return(http_client)
+      expect(http_client).to receive(:fetch).and_return(temp_file)
+      expect(described_class.fetch(credentials: credentials)).to eq temp_file
+    end
+  end
+
+  describe '::load_file' do
+    it 'json file' do
+      expect(Zlib::GzipReader).to receive(:open).with('filename') { fail Zlib::GzipFile::Error }
+      expect(File).to receive(:read).with('filename').and_return(json)
+      data = described_class.load_file('filename')
+      expect(data[0].td_area).to eq 'EA'
+      expect(data[0].from_berth).to eq 'B674'
+      expect(data[0].to_berth).to eq 'B672'
+      expect(data[0].from_line).to eq 'S'
+      expect(data[0].to_line).to eq 'F'
+      expect(data[0].trust_offset).to eq 0
+      expect(data[0].platform).to eq '5'
+      expect(data[0].event_type).to eq :depart
+      expect(data[0].event_direction).to eq :up
+      expect(data[0].route).to eq '2'
+      expect(data[0].stanox).to eq 3211
+      expect(data[0].stanox_name).to eq 'NEWBRGH'
+      expect(data[0].step_type).to eq :between
+      expect(data[0].comment).to eq '17/02/2008'
+      expect(data[1].trust_offset).to eq 60
+      expect(data[2].td_area).to be_nil
+      expect(data[2].from_berth).to be_nil
+      expect(data[2].to_berth).to be_nil
+      expect(data[2].from_line).to be_nil
+      expect(data[2].to_line).to be_nil
+      expect(data[2].trust_offset).to eq 0
+      expect(data[2].platform).to be_nil
+      expect(data[2].event_type).to be_nil
+      expect(data[2].event_direction).to be_nil
+      expect(data[2].route).to be_nil
+      expect(data[2].stanox).to be_nil
+      expect(data[2].stanox_name).to be_nil
+      expect(data[2].step_type).to be_nil
+      expect(data[2].comment).to be_nil
+    end
+
+    it 'json.gz file' do
+      expect(Zlib::GzipReader).to receive(:open).with('filename')
+                                                .and_yield(StringIO.new(json))
+      expect(described_class.load_file('filename').count).to eq 3
+    end
+  end
+
+  it '::build_berths' do
+    # For the trackplan:
+    #   Down ---> Up
+    # --A----B----C--
+    #     \--D-->-E--
+    #      \-F-<-/
+    # And therefore the steps:
+    steps = [
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'A', 'B', :between, :up),   # 0
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'A', 'D', :between, :up),   # 1
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'A', 'F', :between, :up),   # 2
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'B', 'C', :between, :up),   # 3
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'D', 'E', :between, :up),   # 4
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'B', 'A', :between, :down), # 5
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'D', 'A', :between, :down), # 6
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'F', 'A', :between, :down), # 7
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'C', 'B', :between, :down), # 8
+      RailFeeds::NetworkRail::SMART::Step.new('area', 'E', 'F', :between, :down)  # 9
+    ]
+
+    berths = described_class.build_berths(steps)['area']
+    expect(berths['A'].id).to eq 'A'
+    expect(berths['A'].up_steps).to match_array steps.values_at(0, 1, 2, 5, 6, 7)
+    expect(berths['A'].down_steps).to match_array []
+    expect(berths['A'].up_berths).to match_array ['B', 'D', 'F']
+    expect(berths['A'].down_berths).to match_array []
+    expect(berths['B'].id).to eq 'B'
+    expect(berths['B'].up_steps).to match_array steps.values_at(3, 8)
+    expect(berths['B'].down_steps).to match_array steps.values_at(5, 0)
+    expect(berths['B'].up_berths).to match_array ['C']
+    expect(berths['B'].down_berths).to match_array ['A']
+    expect(berths['C'].id).to eq 'C'
+    expect(berths['C'].up_steps).to match_array []
+    expect(berths['C'].down_steps).to match_array steps.values_at(8, 3)
+    expect(berths['C'].up_berths).to match_array []
+    expect(berths['C'].down_berths).to match_array ['B']
+    expect(berths['D'].id).to eq 'D'
+    expect(berths['D'].up_steps).to match_array steps.values_at(4)
+    expect(berths['D'].down_steps).to match_array steps.values_at(6, 1)
+    expect(berths['D'].up_berths).to match_array ['E']
+    expect(berths['D'].down_berths).to match_array ['A']
+    expect(berths['E'].id).to eq 'E'
+    expect(berths['E'].up_steps).to match_array []
+    expect(berths['E'].down_steps).to match_array steps.values_at(4, 9)
+    expect(berths['E'].up_berths).to match_array []
+    expect(berths['E'].down_berths).to match_array ['F']
+    expect(berths['F'].id).to eq 'F'
+    expect(berths['F'].up_steps).to match_array steps.values_at(9)
+    expect(berths['F'].down_steps).to match_array steps.values_at(2, 7)
+    expect(berths['F'].up_berths).to match_array []
+    expect(berths['F'].down_berths).to match_array ['A']
+  end
+
+  it '::fetch_data' do
+    expect(RailFeeds::NetworkRail::HTTPClient)
+      .to receive(:new).with(credentials: RailFeeds::NetworkRail::Credentials)
+                       .and_return(http_client)
+    expect(http_client).to receive(:fetch_unzipped)
+      .with('ntrod/SupportingFileAuthenticate?type=SMART')
+      .and_yield(reader)
+    expect(reader).to receive(:read).and_return(json)
+    expect(described_class.fetch_data.count).to eq 3
+  end
+
+  describe 'Helping methods' do
+    it '::event_type' do
+      expect(described_class.send(:event_type, 'A')).to eq :arrive
+      expect(described_class.send(:event_type, 'B')).to eq :depart
+      expect(described_class.send(:event_type, 'C')).to eq :arrive
+      expect(described_class.send(:event_type, 'D')).to eq :depart
+      expect(described_class.send(:event_type, 'Z')).to be_nil
+    end
+
+    it '::event_direction' do
+      expect(described_class.send(:event_direction, 'A')).to eq :up
+      expect(described_class.send(:event_direction, 'B')).to eq :up
+      expect(described_class.send(:event_direction, 'C')).to eq :down
+      expect(described_class.send(:event_direction, 'D')).to eq :down
+      expect(described_class.send(:event_direction, 'Z')).to be_nil
+    end
+
+    it '::step_type' do
+      expect(described_class.send(:step_type, 'B')).to eq :between
+      expect(described_class.send(:step_type, 'F')).to eq :from
+      expect(described_class.send(:step_type, 'T')).to eq :to
+      expect(described_class.send(:step_type, 'D')).to eq :intermediate_first
+      expect(described_class.send(:step_type, 'C')).to eq :clearout
+      expect(described_class.send(:step_type, 'I')).to eq :interpose
+      expect(described_class.send(:step_type, 'E')).to eq :intermediate
+      expect(described_class.send(:step_type, 'Z')).to be_nil
+    end
+  end
+end

data/spec/rail_feeds/network_rail/stomp_client_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+describe RailFeeds::NetworkRail::StompClient do
+  before :each do
+    RailFeeds::NetworkRail::Credentials.configure(
+      username: 'a',
+      password: 'b'
+    )
+  end
+
+  describe 'Sets correct options when delegating #connect' do
+    let(:logger) { double Logger }
+
+    it 'With no credentials passed' do
+      stomp_client = double Stomp::Client
+      options = {
+        hosts: [{
+          host: 'datafeeds.networkrail.co.uk',
+          port: '61618',
+          login: 'a',
+          password: 'b'
+        }],
+        connect_headers: {
+          'host' => 'datafeeds.networkrail.co.uk',
+          'client-id' => 'a',
+          'accept-version' => '1.1',
+          'heart-beat' => '5000,10000'
+        },
+        logger: logger
+      }
+      subject = described_class.new logger: logger
+      expect(Stomp::Client).to receive(:new).with(options).and_return(stomp_client)
+      subject.connect
+    end
+
+    it 'With credentials passed' do
+      credentials = RailFeeds::NetworkRail::Credentials.new(
+        username: 'A',
+        password: 'B'
+      )
+      stomp_client = double Stomp::Client
+      options = {
+        hosts: [{
+          host: 'datafeeds.networkrail.co.uk',
+          port: '61618',
+          login: 'A',
+          password: 'B'
+        }],
+        connect_headers: {
+          'host' => 'datafeeds.networkrail.co.uk',
+          'client-id' => 'A',
+          'accept-version' => '1.1',
+          'heart-beat' => '5000,10000'
+        },
+        logger: logger
+      }
+      subject = described_class.new credentials: credentials, logger: logger
+      expect(Stomp::Client).to receive(:new).with(options).and_return(stomp_client)
+      subject.connect
+    end
+  end
+
+  describe 'Sets correct options when delegating #subscribe' do
+    let(:stomp_client) { double Stomp::Client }
+
+    before :each do
+      allow(Socket).to receive(:gethostname).and_return('hostname')
+      allow(stomp_client).to receive(:uuid).and_return('uuid')
+      expect(Stomp::Client).to receive(:new).and_return(stomp_client)
+    end
+
+    describe 'When connected' do
+      before :each do
+        subject.connect
+        allow(stomp_client).to receive(:closed?).and_return(false)
+      end
+
+      it 'No headers passes' do
+        headers = {
+          'activemq.subscriptionName' => 'hostname+topic',
+          'id' => 'uuid',
+          'ack' => 'client'
+        }
+        expect(stomp_client).to receive(:subscribe).with('/topic/topic', headers)
+        subject.subscribe('topic') { |m| puts m }
+      end
+
+      it 'Appends to added headers' do
+        headers = {
+          'activemq.subscriptionName' => 'hostname+topic',
+          'id' => 'uuid',
+          'ack' => 'client',
+          'test' => 'TEST'
+        }
+        expect(stomp_client).to receive(:subscribe).with('/topic/topic', headers)
+        subject.subscribe('topic', 'test' => 'TEST') { |m| puts m }
+      end
+
+      it "Doesn't overwrite passed headers" do
+        headers = {
+          'activemq.subscriptionName' => 'a',
+          'id' => 'b',
+          'ack' => 'c'
+        }
+        expect(stomp_client).to receive(:subscribe).with('/topic/topic', headers)
+        subject.subscribe('topic', headers) { |m| puts m }
+      end
+    end
+
+    it 'When not connected' do
+      headers = {
+        'activemq.subscriptionName' => 'hostname+topic',
+        'id' => 'uuid',
+        'ack' => 'client'
+      }
+      expect(stomp_client).to receive(:subscribe).with('/topic/topic', headers)
+      expect { subject.subscribe('topic') { |m| puts m } }.to_not raise_error
+    end
+  end
+
+  describe '#disconnect delegates #close' do
+    it 'When connected' do
+      stomp_client = double Stomp::Client
+      expect(Stomp::Client).to receive(:new).and_return(stomp_client)
+      subject.connect
+      expect(stomp_client).to receive(:close)
+      subject.disconnect
+    end
+
+    it 'When not connected' do
+      expect { subject.disconnect }.to_not raise_error
+    end
+  end
+
+  describe 'Delegates methods to Stomp::Client' do
+    delegates = %i[
+      ack acknowledge nack unreceive create_error_handler open? closed? join
+      running? begin abort commit unsubscribe uuid poll hbsend_interval
+      hbrecv_interval hbsend_count hbrecv_count
+    ]
+    delegates.each do |method|
+      it method do
+        stomp_client = double Stomp::Client
+        expect(Stomp::Client).to receive(:new).and_return(stomp_client)
+        expect(stomp_client).to receive(method)
+        subject.connect
+        subject.send method
+      end
+    end
+  end
+end

data/spec/rail_feeds/network_rail_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe RailFeeds::NetworkRail do
+  it 'Has NetRailFeeds as an alias' do
+    expect(::NetRailFeeds).to be RailFeeds::NetworkRail
+  end
+end

data/spec/rail_feeds_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+describe RailFeeds do
+  it 'Has a version' do
+    expect(RailFeeds::Version).to_not be_nil
+    expect(RailFeeds::Version::MAJOR).to_not be_nil
+    expect(RailFeeds::Version::MINOR).to_not be_nil
+    expect(RailFeeds::Version::PATCH).to_not be_nil
+    expect(RailFeeds::Version.to_s).to_not be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'timecop'
+require 'yaml'
+
+require 'simplecov'
+SimpleCov.coverage_dir(File.join('tmp', 'coverage'))
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+require 'coveralls'
+Coveralls.wear! if ENV['TRAVIS']
+
+RSPEC_ROOT = File.dirname __FILE__
+RSPEC_FIXTURES = File.join RSPEC_ROOT, 'fixtures'
+Dir[File.join(RSPEC_ROOT, '**', '*_shared.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec  do |configuration|
+    # Using the expect syntax is preferable to the should syntax in some cases.
+    # The problem here is that the :should syntax that RSpec uses can fail in
+    # the case of proxy objects, and objects that include the delegate module.
+    # Essentially it requires that we define methods on every object in the
+    # system. Not owning every object means that we cannot ensure this works in
+    # a consistent manner. The expect syntax gets around this problem by not
+    # relying on RSpec specific methods being defined on every object in the
+    # system.
+    # configuration.syntax = [:expect, :should]
+    configuration.syntax = :expect
+  end
+
+  config.before(:example) do
+    RailFeeds::Logging.logger = Logger.new(IO::NULL)
+  end
+
+  config.after(:each) { Timecop.return }
+end
+
+require 'rail_feeds'