ratis 3.1.0 → 3.1.1

data/spec/ratis/next_bus_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Ratis::NextBus do
+  before do
+    Ratis.reset
+    Ratis.configure do |config|
+      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-252/soap.cgi'
+      config.namespace  = 'PX_WEB'
+    end
+
+    @stop_id = 10050
+    @time    = Chronic.parse('tomorrow at 6am')
+  end
+
+  describe '#where' do
+    before do
+      # appid
+      # a short string that can be used to separate requests from different applications or different modules with
+      # Optional (highly recommended)
+      @conditions = {:stop_id      => @stop_id,
+                     :app_id       => 'ratis-specs',
+                     :type         => 'N',
+                     :datetime     => @time }
+    end
+
+    it 'returns the next 4 bus times' do
+      # raises exception when no runs available:
+      # Ratis::Errors::SoapError:
+      # SOAP - no runs available
+      response = Ratis::NextBus.where(@conditions.dup)
+      expect(response.runs).to have(4).items
+    end
+
+    it 'only makes one request' do
+      # false just to stop further processing of response
+      Ratis::Request.should_receive(:get).once.and_call_original
+      Ratis::NextBus.where(@conditions.dup)
+    end
+
+    it 'requests the correct SOAP action' do
+      Ratis::Request.should_receive(:get) do |action, options|
+                       action.should eq('Nextbus')
+                       options["Stopid"].should eq(@stop_id)
+                       options["Appid"].should eq('ratis-specs')
+                       options["Date"].should eq(@time.strftime("%m/%d/%Y"))
+                       options["Time"].should eq(@time.strftime("%I%M"))
+                       options["Type"].should eq('N')
+
+                     end.and_return(double('response', :success? => false)) # false only to stop further running
+
+      Ratis::NextBus.where(@conditions.dup)
+    end
+
+    it "should set all the service values to instance vars" do
+      response = Ratis::NextBus.where(@conditions.dup)
+      expect(response).to be_a(Ratis::NextBus)
+      expect(response.status).to eq('N')
+      expect(response.sign).to eq('0 CENTRAL North to Dunlap/3rd St.')
+      expect(response.routetype).to eq('B')
+      expect(response.times).to eq("05:49 AM, 06:09 AM, 06:29 AM, 06:49 AM")
+      expect(response.direction).to eq('N')
+    end
+
+    it "should raise error if datetime condition is not a DateTime or Time" do
+      lambda {
+        Ratis::NextBus.where(@conditions.dup.merge(:datetime => '01/01/2013'))
+      }.should raise_error(ArgumentError, 'If datetime supplied it should be a Time or DateTime instance, otherwise it defaults to Time.now')
+
+      lambda {
+        Ratis::NextBus.where(@conditions.dup.merge(:datetime => Time.now))
+      }.should_not raise_error(ArgumentError)
+
+      lambda {
+        Ratis::NextBus.where(@conditions.dup.merge(:datetime => DateTime.today))
+      }.should_not raise_error(ArgumentError)
+    end
+
+    it "should raise error if stop id is not provided" do
+      lambda {
+        Ratis::NextBus.where(@conditions.dup.merge(:stop_id => nil))
+      }.should raise_error(ArgumentError, 'You must provide a stop ID')
+    end
+
+    it "should return an empty array if the api request isn't successful" do
+      Ratis::Request.should_receive('get').
+                     with('Nextbus', {"Time"=>@time.strftime("%I%M"), "Type"=>"N", "Stopid"=>10050, "Date"=>@time.strftime("%m/%d/%Y"), "Appid"=>"ratis-specs"}).
+                     and_return(double('response', :success? => false))
+      expect(Ratis::NextBus.where(@conditions.dup)).to be_empty
+    end
+  end
+
+end
+
+# EXAMPLE RESPONSE
+# {:envelope => {
+#   :"@xmlns:xsd"               =>"http://www.w3.org/1999/XMLSchema",
+#   :"@xmlns:xsi"               =>"http://www.w3.org/1999/XMLSchema-instance",
+#   :"@xmlns:soap_env"          =>"http://schemas.xmlsoap.org/soap/envelope/",
+#   :"@xmlns:soap_enc"          =>"http://schemas.xmlsoap.org/soap/encoding/",
+#   :"@soap_env:encoding_style" =>"http://schemas.xmlsoap.org/soap/encoding/",
+#   :body => {
+#     :nextbus_response => {
+#       :atstop => {
+#         :side => "Far",
+#         :stopid => "10050",
+#         :heading => "NB",
+#         :lat => "33.363692",
+#         :area => "Phoenix",
+#         :service => {
+#           :status => "N",
+#           :sign => "0 CENTRAL North to Dunlap/3rd St.",
+#           :routetype => "B",
+#           :times => "10:29 AM, 10:49 AM, 11:09 AM, 11:29 AM",
+#           :direction => "N",
+#           :tripinfo => [
+#              {:tripid => "8374-8",
+#               :exception => "N",
+#               :skedtripid => nil,
+#               :estimatedtime => "10:29 AM",
+#               :triptime => "10:29 AM",
+#               :adherence => nil,
+#               :realtime => {
+#                 :valid => nil,
+#                 :reliable => nil,
+#                 :estimatedtime => "10:29 AM",
+#                 :stopped => nil,
+#                 :lat => nil,
+#                 :estimatedminutes => nil,
+#                 :vehicleid => nil,
+#                 :polltime => nil,
+#                 :long => nil,
+#                 :adherence => nil,
+#                 :trend => nil,
+#                 :speed => nil},
+#               :block => "3"
+#              },
+#              {:tripid => "8374-8",
+#               :exception => "N",
+#               :skedtripid => nil,
+#               :estimatedtime => "10:49 AM",
+#               :triptime => "10:49 AM",
+#               :adherence => nil,
+#               :realtime => {
+#                 :valid => nil,
+#                 :reliable => nil,
+#                 :estimatedtime => "10:49 AM",
+#                 :stopped => nil,
+#                 :lat => nil,
+#                 :estimatedminutes => nil,
+#                 :vehicleid => nil,
+#                 :polltime => nil,
+#                 :long => nil,
+#                 :adherence => nil,
+#                 :trend => nil,
+#                 :speed => nil
+#                },
+#                :block => "5"
+#              },
+#              {:tripid => "8374-9",
+#               :exception => "N",
+#               :skedtripid => nil,
+#               :estimatedtime => "11:09 AM",
+#               :triptime => "11:09 AM",
+#               :adherence => nil,
+#               :realtime => {
+#                 :valid => nil,
+#                 :reliable => nil,
+#                 :estimatedtime => "11:09 AM",
+#                 :stopped => nil,
+#                 :lat => nil,
+#                 :estimatedminutes => nil,
+#                 :vehicleid => nil,
+#                 :polltime => nil,
+#                 :long => nil,
+#                 :adherence => nil,
+#                 :trend => nil,
+#                 :speed => nil
+#               },
+#               :block => "8"},
+#              {:tripid => "8374-9",
+#               :exception => "N",
+#               :skedtripid => nil,
+#               :estimatedtime => "11:29 AM",
+#               :triptime => "11:29 AM",
+#               :adherence => nil,
+#               :realtime => {
+#                 :valid => nil,
+#                 :reliable => nil,
+#                 :estimatedtime => "11:29 AM",
+#                 :stopped => nil,
+#                 :lat => nil,
+#                 :estimatedminutes => nil,
+#                 :vehicleid => nil,
+#                 :polltime => nil,
+#                 :long => nil,
+#                 :adherence => nil,
+#                 :trend => nil,
+#                 :speed => nil
+#               },
+#               :block => "11"}
+#           ],
+#         :servicetype => "W",
+#         :route => "0",
+#         :operator => "AP"
+#       },
+#       :description => "CENTRAL AVE & DOBBINS RD",
+#       :atisstopid => "3317",
+#       :stopposition => "O",
+#       :long => "-112.073191",
+#       :stopstatustype => "N",
+#       :walkdist => "0.00"
+#     },
+#     :version => "1.26",
+#     :responsecode => "0",
+#     :input => {
+#       :time => "10:40 AM",
+#       :stopid => "10050",
+#       :date => "06/05/2013",
+#       :locationlat => nil,
+#       :landmarkid => nil,
+#       :locationlong => nil,
+#       :atisstopid => "0",
+#       :locationtext => "Location",
+#       :route => nil
+#     },
+#     :host => "s-rpta-soap",
+#     :"@xmlns:namesp1" => "PX_WEB",
+#     :copyright => "XML schema Copyright (c) 2003-2012 Trapeze Software, Inc., all rights reserved.",
+#     :soapversion => "2.5.2 - 06/07/12"}}}}
+

data/spec/ratis/pattern_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Ratis::Pattern do
+  before do
+    Ratis.reset
+    Ratis.configure do |config|
+      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-252/soap.cgi'
+      config.namespace  = 'PX_WEB'
+    end
+  end
+
+  describe '#all' do
+
+    before do
+      @today      = Chronic.parse('tomorrow at 8am') # Time.now.strftime("%m/%d/%Y")
+      @conditions = {:route_short_name => '0',
+                     :direction        => 'N',
+                     :date             => @today,
+                     :service_type     => 'W',
+                     :longest          => 'N'}
+    end
+
+    it 'only makes one request' do
+      # false just to stop further processing of response
+      Ratis::Request.should_receive(:get).once.and_call_original
+      Ratis::Pattern.all(@conditions.dup)
+    end
+
+    it 'should return no data error when date is in the past' do
+      old_date_conditions = @conditions.merge(:date => '01/28/2013')
+      expect do
+        Ratis::Pattern.all(old_date_conditions)
+      end.to raise_error(Ratis::Errors::SoapError, "error #1007--Record not found or no more data")
+    end
+
+    it 'requests the correct SOAP action with correct args' do
+      Ratis::Request.should_receive(:get) do |action, options|
+        action.should eq('Getpatterns')
+        options["Route"].should eq('0')
+        options["Direction"].should eq('N')
+        options["Date"].should eq(@today)
+        options["Servicetype"].should eq('W')
+        options["Longest"].should eq('N')
+
+      end.and_return(double('response', :success? => false))
+
+      Ratis::Pattern.all(@conditions.dup)
+    end
+
+    it 'should return a collection Pattern::RouteInfo(s)' do
+
+      pattern = Ratis::Pattern.all(@conditions.dup)
+      pattern.routeinfos.each do |obj|
+        expect(obj).to be_a(Ratis::Pattern::RouteInfo)
+      end
+
+    end
+
+    it "should parse the route info fields" do
+      pattern   = Ratis::Pattern.all(@conditions.dup)
+      routeinfo = pattern.routeinfos.first
+
+      expect(routeinfo.operate).to eq('AP')
+      expect(routeinfo.routetype).to eq('B')
+      expect(routeinfo.headsign).to eq("0 CENTRAL North to Dunlap/3rd St.")
+      expect(routeinfo.routeid).to eq('83720')
+      expect(routeinfo.route).to eq('0')
+      expect(routeinfo.school).to be_nil
+      expect(routeinfo.effective).to eq('05/20/13')
+      expect(routeinfo.tripcount).to eq('51')
+
+    end
+
+    it "should raise error for missing arg route_short_name" do
+      conditions = @conditions.dup
+      conditions.delete(:route_short_name)
+
+      expect do
+        Ratis::Pattern.all(conditions)
+      end.to raise_error(ArgumentError, 'You must provide a route_short_name')
+    end
+
+    it "should raise error for missing arg direction" do
+      conditions = @conditions.dup
+      conditions.delete(:direction)
+
+      expect do
+        Ratis::Pattern.all(conditions)
+      end.to raise_error(ArgumentError, 'You must provide a direction')
+    end
+
+    it "should raise error for missing arg date" do
+      conditions = @conditions.dup
+      conditions.delete(:date)
+
+      expect do
+        Ratis::Pattern.all(conditions)
+      end.to raise_error(ArgumentError, 'You must provide a date')
+    end
+
+    it "should raise error for missing arg service_type" do
+      conditions = @conditions.dup
+      conditions.delete(:service_type)
+
+      expect do
+        Ratis::Pattern.all(conditions)
+      end.to raise_error(ArgumentError, 'You must provide a service_type')
+    end
+
+    it "should raise error for missing arg longest" do
+      conditions = @conditions.dup
+      conditions.delete(:longest)
+
+      expect do
+        Ratis::Pattern.all(conditions)
+      end.to raise_error(ArgumentError, 'You must provide a longest')
+    end
+
+  end
+
+end
+

data/spec/ratis/point_2_point_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe Ratis::Point2Point do
+  before do
+    Ratis.reset
+    Ratis.configure do |config|
+      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-252/soap.cgi'
+      config.namespace  = 'PX_WEB'
+    end
+  end
+
+  describe 'Routesonly => Y' do
+    describe '#where' do
+      describe 'services from origin to destination', {:vcr => {:cassette_name => "Point2Point"}} do
+        before do
+          @today      = Time.now.strftime("%m/%d/%Y")
+          @conditions = {:routes_only      => true,
+                         :origin_lat       => 33.446931,
+                         :origin_long      => -112.097903,
+                         :destination_lat  => 33.447098,
+                         :destination_long => -112.077213,
+                         :date             => @today,
+                         :start_time       => '1700',
+                         :end_time         => '1800'}
+
+        end
+
+        it 'returns all matching services that fit the origin/destination for a given time frame' do
+          services = Ratis::Point2Point.where(@conditions.dup)
+          services.should have(20).items
+        end
+
+        it 'only makes one request' do
+          # false just to stop further processing of response
+          Ratis::Request.should_receive(:get).once.and_call_original
+          Ratis::Point2Point.where(@conditions.dup)
+        end
+
+        it 'requests the correct SOAP action' do
+          Ratis::Request.should_receive(:get) do |action, options|
+                           action.should eq('Point2point')
+                           options["Date"].should eq(@today)
+                           options["Destinationlong"].should eq(-112.077213)
+                           options["Starttime"].should eq("1700")
+                           options["Endtime"].should eq("1800")
+                           options["Destinationlat"].should eq(33.447098)
+                           options["Routesonly"].should eq("Y")
+                           options["Originlong"].should eq(-112.097903)
+                           options["Originlat"].should eq(33.446931)
+
+                         end.and_return(double('response', :success? => false)) # false only to stop further running
+
+          Ratis::Point2Point.where(@conditions.dup)
+        end
+
+        it 'returns a routes only response for each matched service' do
+          services = Ratis::Point2Point.where(@conditions.dup)
+          services.should be_a( Array )
+          services.each{|response| response.should be_a( Ratis::Point2Point::RoutesOnlyResponse ) }
+        end
+
+        it 'parses out service fields' do
+          services = Ratis::Point2Point.where(@conditions.dup)
+          service  = services.first
+
+          service.route.should eql '562'
+          service.direction.should eql 'O'
+          service.service_type.should eql 'W'
+          service.signage.should eql "562 Goodyear To Goodyear"
+          service.route_type.should eql 'X'
+        end
+
+        it "should NOT filter by passed in routes" do
+          # According to Marc Ferguson of Trapeze group, route filter only works when Routesonly = 'N'
+          services = Ratis::Point2Point.where(@conditions.dup.merge(:routes => ['1']))
+          services.should have(20).items
+        end
+      end
+    end
+  end
+
+  describe 'Routesonly => N' do
+
+    describe '#where' do
+
+      before do
+        @today      = Time.now.strftime("%m/%d/%Y")
+        @conditions = {:routes_only      => false,
+                       :origin_lat       => 33.446931,
+                       :origin_long      => -112.097903,
+                       :destination_lat  => 33.447098,
+                       :destination_long => -112.077213,
+                       :date             => @today,
+                       :start_time       => '1700',
+                       :end_time         => '1800'}
+
+      end
+
+      it 'only makes one request' do
+        Ratis::Request.should_receive(:get).once.and_call_original
+        Ratis::Point2Point.where(@conditions.dup)
+      end
+
+      it 'requests the correct SOAP action with correct args' do
+        Ratis::Request.should_receive(:get) do |action, options|
+          action.should eq('Point2point')
+          options["Date"].should eq(@today)
+          options["Destinationlong"].should eq(-112.077213)
+          options["Starttime"].should eq("1700")
+          options["Endtime"].should eq("1800")
+          options["Destinationlat"].should eq(33.447098)
+          options["Routesonly"].should eq("N")
+          options["Originlong"].should eq(-112.097903)
+          options["Originlat"].should eq(33.446931)
+
+        end.and_return(double('response', :success? => false)) # false only to stop further running
+
+        Ratis::Point2Point.where(@conditions.dup)
+      end
+
+      it 'gets the groups' do
+        schedule = Ratis::Point2Point.where(@conditions.dup)
+        schedule.should have(3).groups
+        schedule.groups.each{|group| group.should be_a(Ratis::Point2Point::Group) }
+      end
+
+      it 'gets the trips within each group' do
+        schedule = Ratis::Point2Point.where(@conditions.dup)
+        schedule.groups[0].should have(18).trips
+        schedule.groups[1].should have(16).trips
+        schedule.groups[2].should have(4).trips
+      end
+
+      it 'parses out the on stop fields' do
+        schedule = Ratis::Point2Point.where(@conditions.dup)
+        group    = schedule.groups.first
+        on_stop  = group.on_stop
+
+        on_stop.should be_a(Ratis::Point2Point::Stop)
+
+        on_stop.description.should eql('JEFFERSON ST & 18TH AVE')
+        on_stop.latitude.should eql(33.446931)
+        on_stop.longitude.should eql(-112.097903)
+        on_stop.atis_stop_id.should eql(9469)
+        on_stop.walk_dist.should eql(0.01)
+        on_stop.walk_dir.should eql('E')
+        on_stop.walk_hint.should eql('N')
+      end
+
+      it 'parses out the off stop fields' do
+        schedule  = Ratis::Point2Point.where(@conditions.dup)
+        group     = schedule.groups.first
+        off_stop  = group.off_stop
+
+        off_stop.should be_a(Ratis::Point2Point::Stop)
+
+        off_stop.description.should eql('JEFFERSON ST & 3RD AVE')
+        off_stop.latitude.should eql(33.447098)
+        off_stop.longitude.should eql(-112.077213)
+        off_stop.atis_stop_id.should eql(1463)
+        off_stop.walk_dist.should eql(0.007)
+        off_stop.walk_dir.should eql('E')
+        off_stop.walk_hint.should eql('N')
+      end
+
+      it 'parses out the trip' do
+        schedule = Ratis::Point2Point.where(@conditions.dup)
+        group    = schedule.groups.first
+        trip     = group.trips.first
+
+        trip.should be_a(Ratis::Point2Point::Trip)
+
+        trip.on_time.should eql('05:00 PM')
+        trip.off_time.should eql('05:06 PM')
+      end
+
+      it 'parses out the service' do
+        schedule = Ratis::Point2Point.where(@conditions.dup)
+        group    = schedule.groups.first
+        service  = group.trips.first.service
+
+        service.should be_a(Ratis::Point2Point::Service)
+
+        service.route.should eql('451')
+        service.direction.should eql('S')
+        service.service_type.should eql('W')
+        service.signage.should eql('CSM RAPID To 27th Av/Bsln PNR')
+        service.route_type.should eql('X')
+        service.exception.should eql('N')
+      end
+
+      it "should only return result groups for filtered route" do
+        schedule = Ratis::Point2Point.where(@conditions.dup.merge(:routes => ['451']))
+        schedule.groups.size.should eq(1)
+      end
+
+      it "should only return result groups for filtered routes" do
+        schedule = Ratis::Point2Point.where(@conditions.dup.merge(:routes => ['1', '451']))
+        schedule.groups.size.should eq(2)
+      end
+
+      it "should raise error if the trip is NOT possible for a route being attempted to filter on" do
+        # According to Marc Ferguson of Trapeze group, route filter only works when Routesonly = 'N'
+        lambda {
+          Ratis::Point2Point.where(@conditions.dup.merge(:routes => ['GAL']))
+        }.should raise_error(Ratis::Errors::SoapError)
+      end
+
+      it "should raise error if the trip is NOT possible for a route being attempted to filter on" do
+        # According to Marc Ferguson of Trapeze group, route filter only works when Routesonly = 'N'
+        begin
+          Ratis::Point2Point.where(@conditions.dup.merge(:routes => ['GAL']))
+        rescue Exception => e
+          e.message.should eq('Trip not possible')
+        end
+      end
+
+
+    end
+  end
+
+end
+