ns-api 0.0.2

data/spec/ns/api/request/base_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Ns::Api::Request::Base do
+
+  class Dummy < Ns::Api::Request::Base; end
+  class DummyResponse; end
+
+  subject { Ns::Api::Request::Base.new }
+
+  let(:xml)      { File.read(File.join($ROOT, 'spec/fixtures/ns_travel_advice_response.xml')) }
+  let(:response) { HTTPI::Response.new(200, [], xml) }
+
+  it 'should disable HTTPI logging' do
+    HTTPI.should_receive(:log=).with(false)
+    Dummy.new
+  end
+
+  it 'should not implement base_uri' do
+    lambda { subject.class.send(:base_uri) }.should raise_error
+  end
+
+  it 'should not implement query' do
+    lambda { subject.send(:query) }.should raise_error
+  end
+
+  it 'should not implement response_class' do
+    lambda { subject.class.send(:response_class) }.should raise_error
+  end
+
+  it 'should have an http request' do
+    HTTPI::Request.should_receive(:new)
+    subject.class.stub!(:base_uri).and_return('http://foo.com')
+    subject.send(:http_request)
+  end
+
+  it 'should set the query and credentials' do
+    request = HTTPI::Request.new('http://foo.com')
+
+    request.should_receive(:query=).with(an_instance_of(Hash))
+    Ns.configuration.should_receive(:username)
+    Ns.configuration.should_receive(:password)
+
+    HTTPI::Request.stub!(:new).and_return(request)
+    subject.stub!(:query).and_return({foo: 'bar'})
+    subject.class.stub!(:base_uri).and_return('http://foo.com')
+
+    subject.send(:http_request_with_query_and_authentication)
+  end
+
+  it 'should return the url for the request' do
+    request = HTTPI::Request.new('http://foo.com')
+    subject.stub!(:http_request).and_return(request)
+    subject.stub!(:query).and_return({foo: 'bar'})
+
+    subject.send(:url_for_request).should be_an_instance_of(HTTPI::Request)
+  end
+
+  it 'should fetch the plain text response body' do
+    subject.class.stub!(:base_uri).and_return('http://foo.com')
+    subject.stub!(:query).and_return({})
+    HTTPI.should_receive(:get).and_return(response)
+    response.should_receive(:body)
+
+    subject.send(:response_body)
+  end
+
+end

data/spec/ns/api/request/disruption_collection_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Ns::Api::Request::DisruptionCollection do
+
+  let(:disruption_collection) { Ns::DisruptionCollection.new(station: 'asd') }
+  subject { Ns::Api::Request::DisruptionCollection.new(disruption_collection: disruption_collection) }
+
+  it 'has a base_uri' do
+    subject.class.base_uri.should == 'http://webservices.ns.nl/ns-api-storingen'
+  end
+
+  it 'has a response_class' do
+    subject.class.response_class.should == Ns::Api::Response::DisruptionCollection
+  end
+
+  describe 'query' do
+
+    let(:query) { subject.send(:query) }
+
+    it 'should have a station' do
+      query[:station].should == disruption_collection.station
+    end
+
+    it 'should have an actual' do
+      query[:actual].should == disruption_collection.actual
+    end
+
+    it 'should have an include_planned' do
+      query[:unplanned].should == disruption_collection.include_planned
+    end
+
+  end
+
+end

data/spec/ns/api/request/travel_advice_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Ns::Api::Request::TravelAdvice do
+
+  let(:trip)     { Ns::Trip.new(from: 'edc', to: 'asd', departure: Time.now) }
+  let(:xml)      { File.read(File.join($ROOT, 'spec/fixtures/ns_travel_advice_response.xml')) }
+  let(:response) { HTTPI::Response.new(200, [], xml) }
+  subject        { Ns::Api::Request::TravelAdvice.new(trip: trip) }
+
+  it 'has a base uri' do
+    subject.class.base_uri.should == 'http://webservices.ns.nl/ns-api-treinplanner'
+  end
+
+  it 'has a trip' do
+    subject.trip.should == trip
+  end
+
+  it 'forwards the response to the correct response class' do
+    subject.stub!(:response_body).and_return(xml)
+    subject.response
+  end
+
+  describe 'query' do
+
+    let(:query) { subject.send(:query) }
+
+    it 'should have a fromStation' do
+      query[:fromStation].should == trip.from.name
+    end
+
+    it 'should have a toStation' do
+      query[:toStation].should == trip.to.name
+    end
+
+    it 'should have a dateTime' do
+      query[:dateTime].should == trip.formatted_time
+    end
+
+    it 'should have a departure' do
+      query[:departure].should == trip.departure?
+    end
+
+    it 'should have a hslAllowed' do
+      query[:hslAllowed].should == trip.allow_hsl
+    end
+
+    it 'should have a yearCard' do
+      query[:yearCard].should == trip.year_card
+    end
+
+  end
+
+end

data/spec/ns/api/response/disruption_collection_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Ns::Api::Response::DisruptionCollection do
+
+  let(:parsed_response)       { double(:parsed_response) }
+  let(:disruption_collection) { double(:disruption_collection) }
+  let(:raw_disruption)        { double(:raw_disruption) }
+  let(:planned_disruptions)   { [ [ 'Storing', raw_disruption ] ] }
+  let(:unplanned_disruptions) { [ [ 'Storing', raw_disruption ] ] }
+  subject { Ns::Api::Response::DisruptionCollection.new(parsed_response: parsed_response) }
+
+  before do
+    parsed_response.stub!(:[]).with('Storingen').and_return(disruption_collection)
+    disruption_collection.stub!(:[]).with('Gepland').and_return(planned_disruptions)
+    disruption_collection.stub!(:[]).with('Ongepland').and_return(unplanned_disruptions)
+  end
+
+  it 'should not error if parsed response is empty' do
+    empty = Ns::Api::Response::DisruptionCollection.new(parsed_response: {})
+
+    empty.planned_disruptions.should == []
+    empty.unplanned_disruptions.should == []
+  end
+
+  it 'should fetch planned disruptions' do
+    parsed_response.should_receive(:has_key?).with('Storingen').and_return(true)
+    disruption_collection.should_receive(:has_key?).and_return(true)
+    raw_disruption.should_receive(:[]).any_number_of_times.and_return('')
+    Ns::Disruption.should_receive(:new)
+
+    subject.planned_disruptions
+  end
+
+  it 'should fetch unplanned disruptions' do
+    parsed_response.should_receive(:has_key?).with('Storingen').and_return(true)
+    disruption_collection.should_receive(:has_key?).and_return(true)
+    raw_disruption.should_receive(:[]).any_number_of_times.and_return('')
+    Ns::Disruption.should_receive(:new)
+
+    subject.unplanned_disruptions
+  end
+
+end

data/spec/ns/api/response/parser_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Ns::Api::Response::Parser do
+
+  let(:xml) { File.read(File.join($ROOT, 'spec/fixtures/ns_travel_advice_response.xml')) }
+  subject   { Ns::Api::Response::Parser.new(response_text: xml) }
+
+  it 'should have a parser' do
+    Nori.should_receive(:new)
+    subject.send(:parser)
+  end
+
+  it 'should parse a response' do
+    subject.parsed_response.class.should == Hash
+  end
+
+end

data/spec/ns/api/response/travel_advice_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Ns::Api::Response::TravelAdvice do
+
+  let(:parsed_response) { double(:parsed_response) }
+  let(:travel_options)  { double(:travel_options) }
+  let(:travel_option)   { double(:travel_option) }
+  subject { Ns::Api::Response::TravelAdvice.new(parsed_response: parsed_response) }
+
+  before do
+    parsed_response.stub!(:[]).and_return(travel_options)
+    travel_options.stub!(:[]).and_return(travel_option)
+  end
+
+  it 'should initialize with a parsed response' do
+    subject.parsed_response.should == parsed_response
+  end
+
+  it 'should check for the presence of keys' do
+    parsed_response.should_receive(:has_key?).with('ReisMogelijkheden').and_return(true)
+    parsed_response['ReisMogelijkheden'].should_receive(:has_key?).with('ReisMogelijkheid').and_return(true)
+
+    subject.send(:raw_travel_options)
+  end
+
+  it 'should map travel options to Ns::TravelOption objects' do
+    subject.stub!(:raw_travel_options).and_return([travel_option])
+    Ns::TravelOption.should_receive(:new)
+
+    travel_option.should_receive(:[]).with('GeplandeVertrekTijd')
+    travel_option.should_receive(:[]).with('ActueleVertrekTijd')
+    travel_option.should_receive(:[]).with('GeplandeAankomstTijd')
+    travel_option.should_receive(:[]).with('ActueleAankomstTijd')
+    travel_option.should_receive(:[]).with('AantalOverstappen')
+    travel_option.should_receive(:[]).with('Optimaal')
+    travel_option.should_receive(:[]).with('ReisDeel').and_return([{'ReisStop' => [{ 'Spoor' => '9a' }]}])
+
+    subject.travel_options
+  end
+
+  it 'should map travel options to Ns::TravelOption objects if only one travel option is present' do
+    subject.stub!(:raw_travel_options).and_return([travel_option])
+    Ns::TravelOption.should_receive(:new)
+
+    travel_option.should_receive(:[]).with('GeplandeVertrekTijd')
+    travel_option.should_receive(:[]).with('ActueleVertrekTijd')
+    travel_option.should_receive(:[]).with('GeplandeAankomstTijd')
+    travel_option.should_receive(:[]).with('ActueleAankomstTijd')
+    travel_option.should_receive(:[]).with('AantalOverstappen')
+    travel_option.should_receive(:[]).with('Optimaal')
+    travel_option.should_receive(:[]).with('ReisDeel').and_return({'ReisStop' => [{ 'Spoor' => '9a' }]})
+
+    subject.travel_options
+  end
+
+  it 'should not error if parsed response is empty' do
+    empty = Ns::Api::Response::TravelAdvice.new(parsed_response: {})
+    empty.travel_options.should == []
+  end
+
+end

data/spec/ns/disruption_collection_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Ns::DisruptionCollection do
+
+  subject { Ns::DisruptionCollection.new(station: 'asd') }
+
+  let(:xml_with_disruptions)  { File.read(File.join($ROOT, 'spec/fixtures/ns_disruptions_with_results.xml')) }
+  let(:xml_no_disruptions)    { File.read(File.join($ROOT, 'spec/fixtures/ns_disruptions_no_results.xml')) }
+  let(:response)              { double('response') }
+  let(:disruption_collection) { double('disruption_collection') }
+
+  before do
+    response.stub!(:planned_disruptions)
+    response.stub!(:unplanned_disruptions)
+    disruption_collection.stub!(:response).and_return(response)
+    subject.stub!(:disruption_collection).and_return(disruption_collection)
+  end
+
+  it 'should fetch a list of planned disruptions around a station' do
+    subject.planned_disruptions
+  end
+
+  it 'should fetch a list of unplanned disruptions around a station' do
+    subject.unplanned_disruptions
+  end
+
+  it 'has a disruption_collection' do
+    object = Ns::DisruptionCollection.new(station: 'asd')
+    lambda { object.send(:disruption_collection) }.should_not raise_error
+  end
+
+end

data/spec/ns/disruption_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Ns::Disruption do
+
+  let(:route)   { 'Amsterdam Centraal - Ede Centrum' }
+  let(:reason)  { '       Op last van         de politie' }
+  let(:message) { 'Bericht         met           spaties     ' }
+  let(:advice)  { 'Maak gebruik van overige           treinen of       bussen' }
+  let(:period)  { 'Zaterdag 18 en zondag 19 december' }
+
+  subject {
+    Ns::Disruption.new(
+      route:   route,
+      reason:  reason,
+      message: message,
+      advice:  advice,
+      period:  period
+    )
+  }
+
+  it 'initializes properly' do
+    %w(route period).each do |var|
+      subject.send(var).should == send(var)
+    end
+  end
+
+  it 'strips and cleans strings of excess spaces' do
+    subject.reason.should  == 'Op last van de politie'
+    subject.message.should == 'Bericht met spaties'
+    subject.advice.should  == 'Maak gebruik van overige treinen of bussen'
+  end
+
+end

data/spec/ns/station_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ns::Station do
+
+  subject { Ns::Station.new(name: 'edc') }
+
+  it 'should have a name' do
+    subject.name.should == 'edc'
+  end
+
+end

data/spec/ns/travel_option_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Ns::TravelOption do
+
+  let(:planned_departure) { DateTime.now }
+  let(:actual_departure)  { DateTime.now + (80.0 / 60 / 60 / 24) }
+  let(:planned_arrival)   { planned_departure + (3600.0 / 60 / 60 / 24) }
+  let(:actual_arrival)    { actual_departure + (3600.0 / 60 / 60 / 24) }
+  let(:changes)           { 2 }
+  let(:platform)          { '9a' }
+
+  subject {
+    Ns::TravelOption.new(
+      planned_departure: planned_departure,
+      actual_departure:  actual_departure,
+      planned_arrival:   planned_arrival,
+      actual_arrival:    actual_arrival,
+      changes:           changes,
+      platform:          platform
+    )
+  }
+
+  it 'should initialize properly' do
+    %w(planned_departure actual_departure planned_arrival actual_arrival changes platform).each do |var|
+      subject.send(var).should == send(var)
+    end
+  end
+
+  it 'should calculate the planned duration' do
+    subject.planned_duration.should == 3600
+  end
+
+  it 'should calculate the actual duration' do
+    subject.actual_duration.should == 3600
+  end
+
+  it 'should calculate the delay' do
+    subject.delay.should == 80
+  end
+
+end

data/spec/ns/trip_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Ns::Trip do
+
+  subject { Ns::Trip.new(from: 'edc', to: 'asd', departure: (Time.now + 3600)) }
+
+  let(:time1) { Time.now + 3600 }
+  let(:time2) { Time.now + 8600 }
+  let(:xml)   { File.read(File.join($ROOT, 'spec/fixtures/ns_travel_advice_response.xml')) }
+  let(:departure_trip)    { Ns::Trip.new(from: 'edc', to: 'asd', departure: time1) }
+  let(:arrival_trip)      { Ns::Trip.new(from: 'edc', to: 'asd', arrival: time2) }
+  let(:trip_without_time) { Ns::Trip.new(from: 'edc', to: 'asd') }
+
+  it 'should map origin and destination to station classes' do
+    subject.from.class.should == Ns::Station
+    subject.to.class.should == Ns::Station
+  end
+
+  it 'has a time' do
+    departure_trip.time.should == time1
+    arrival_trip.time.should == time2
+  end
+
+  it 'has a default time' do
+    Time.should_receive(:now)
+    trip_without_time.time
+  end
+
+  it 'defaults to arrival if no time given' do
+    trip_without_time.departure?.should == false
+  end
+
+  it 'has a formatted time' do
+    departure_trip.formatted_time.should == time1.iso8601
+    arrival_trip.formatted_time.should == time2.iso8601
+  end
+
+  it 'tells wether it is a departure or arrival time' do
+    departure_trip.departure?.should == true
+    arrival_trip.departure?.should == false
+  end
+
+  it 'has travel options' do
+    response = double('travel_advice_response')
+    response.stub!(:travel_options)
+    travel_advice = double('travel_advice')
+    travel_advice.stub!(:response).and_return(response)
+    Ns::Api::Request::TravelAdvice.stub!(:new).and_return(travel_advice)
+
+    travel_options = subject.travel_options
+  end
+
+  it 'has a default allow_hsl' do
+    subject.allow_hsl.should == false
+  end
+
+  it 'has a default year_card' do
+    subject.year_card.should == false
+  end
+
+  describe 'validations' do
+
+    let(:trip1) { Ns::Trip.new(from: 'edc', to: 'asd') }
+    let(:trip2) { Ns::Trip.new(from: 'edc', to: 'asd', departure: '') }
+    let(:trip3) { Ns::Trip.new(from: 'edc', to: 'asd', arrival: '') }
+    let(:trip4) { Ns::Trip.new(from: 'edc', to: 'asd', departure: Time.now) }
+    let(:trip5) { Ns::Trip.new(from: 'edc', to: 'asd', arrival: Time.now) }
+    let(:trip6) { Ns::Trip.new(from: 'edc', to: 'asd', arrival: Date.today) }
+    let(:trip7) { Ns::Trip.new(arrival: Date.today) }
+    let(:trip8) { Ns::Trip.new(from: 'edc', arrival: Date.today) }
+
+    it 'should validate departure/arrival times' do
+      trip1.valid?.should == false
+      trip2.valid?.should == false
+      trip3.valid?.should == false
+      trip4.valid?.should == true
+      trip5.valid?.should == true
+      trip6.valid?.should == false
+      trip7.valid?.should == false
+      trip8.valid?.should == false
+    end
+
+  end
+
+end