ratis 3.3.6 → 3.3.7

data/spec/ratis/landmark_category_spec.rb

@@ -3,43 +3,51 @@ require 'spec_helper'
 describe Ratis::LandmarkCategory do
 
   before do
-    stub_atis_request.to_return( atis_response 'Getcategories', '1.1', '0', <<-BODY )
-    <Types>
-      <Typeinfo>
-        <Type>AIRPORT</Type>
-        <Description>AIRPT</Description>
-      </Typeinfo>
-      <Typeinfo>
-        <Type>CASINO</Type>
-        <Description>CAS</Description>
-      </Typeinfo>
-      <Typeinfo>
-        <Type>CEMETARIES</Type>
-        <Description>CEM</Description>
-      </Typeinfo>
-    </Types>
-    BODY
-
-    @landmark_categories = Ratis::LandmarkCategory.all
+    Ratis.reset
+    Ratis.configure do |config|
+      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-262/soap.cgi'
+      config.namespace  = 'PX_WEB'
+    end
   end
 
-  it 'only makes one request' do
-    an_atis_request.should have_been_made.times 1
+  describe '.all', vcr: {} do
+    it 'only makes one request' do
+      # false just to stop further processing of response
+      Ratis::Request.should_receive(:get).once.and_call_original
+      Ratis::LandmarkCategory.all
+    end
+
+    it 'requests the correct SOAP action with correct args' do
+      Ratis::Request.should_receive(:get) do |action, options|
+        action.should eq('Getcategories')
+
+      end.and_return(double('response', :success? => false))
+
+      Ratis::LandmarkCategory.all
+    end
+
+    it 'should return a collection of Ratis::LandmarkCategory(s)' do
+      categories = Ratis::LandmarkCategory.all
+      categories.each do |obj|
+        expect(obj).to be_a(Ratis::LandmarkCategory)
+      end
+    end
+
+    it 'should return all landmark categories' do
+      categories = Ratis::LandmarkCategory.all
+      categories.should have(76).items
+    end
   end
 
-  it 'requests the correct SOAP action' do
-    an_atis_request_for('Getcategories').should have_been_made
-  end
-
-  it 'should return all landmark categories' do
-    @landmark_categories.should have(3).items
+  describe '.web_categories', vcr: {} do
+    it "does something" do
+      web_categories = Ratis::LandmarkCategory.web_categories
+      expect(web_categories).to have(14).items
 
-    @landmark_categories[0].type.should eql 'AIRPORT'
-    @landmark_categories[0].description.should eql 'AIRPT'
-    @landmark_categories[1].type.should eql 'CASINO'
-    @landmark_categories[1].description.should eql 'CAS'
-    @landmark_categories[2].type.should eql 'CEMETARIES'
-    @landmark_categories[2].description.should eql 'CEM'
+      [["AIRPORT", "WEBAIR"], ["COLLEGES", "WEBCOL"], ["COMMUNITY RESOURCES", "WEBCMR"], ["FAMILY ATTRACTIONS", "WEBFAM"], ["GOVT LOCAL STATE FEDERAL", "WEBGOV"], ["HOSPITALS AND CLINICS", "WEBHOS"], ["LIBRARIES", "WEBLIB"], ["LIGHT RAIL STATIONS", "WEBSTN"], ["MUSEUMS", "WEBMUS"], ["PARK AND RIDE", "WEBPR"], ["PERFORMING ARTS", "WEBPER"], ["SHOPPING MALLS", "WEBSHP"], ["SPORTS VENUES", "WEBSPT"], ["TRANSIT CENTERS", "WEBTC"]].each do |pair|
+        expect(web_categories).to include(pair)
+      end
+    end
   end
 
 end

data/spec/ratis/landmark_spec.rb

@@ -3,49 +3,21 @@ require 'spec_helper'
 describe Ratis::Landmark do
 
   before do
-    stub_atis_request.to_return( atis_response 'Getlandmarks', '1.4', '0', <<-BODY )
-    <Landmarks>
-      <Landmark>
-        <Id>5007</Id>
-        <Verbose>FALCON FIELD AIRPORT</Verbose>
-        <Location>4800 E. FALCON DR.</Location>
-        <Area>ME</Area>
-        <Latitude>33.456119</Latitude>
-        <Longitude>-111.728010</Longitude>
-        <Locality>N</Locality>
-        <Type>AIRPT</Type>
-        <Map_level>3</Map_level>
-        <Notes> Hours of Operation: </Notes>
-        <Zipcode>85215</Zipcode>
-      </Landmark>
-      <Landmark>
-        <Id>5009</Id>
-        <Verbose>SKY HARBOR AIRPORT TERMINAL 4 WB</Verbose>
-        <Location>3700 E SKY HARBOR BLVD</Location>
-        <Area>PH</Area>
-        <Latitude>33.434520</Latitude>
-        <Longitude>-111.996145</Longitude>
-        <Locality>N</Locality>
-        <Type>AIRPT</Type>
-        <Map_level>3</Map_level>
-        <Notes> Hours of Operation: !!!!!!!!24 hours</Notes>
-        <Zipcode>99999</Zipcode>
-      </Landmark>
-    </Landmarks>
-    BODY
-
-    @landmarks = Ratis::Landmark.where :type => :all
+    # @landmarks = Ratis::Landmark.where :type => :all
   end
 
   it 'only makes one request' do
+    pending
     an_atis_request.should have_been_made.times 1
   end
 
   it 'requests the correct SOAP action' do
+    pending
     an_atis_request_for('Getlandmarks', 'Type' => 'ALL').should have_been_made
   end
 
   it 'should return all landmarks' do
+    pending
     @landmarks.should have(2).items
 
     @landmarks[0].type.should eql 'AIRPT'
@@ -60,4 +32,3 @@ describe Ratis::Landmark do
   end
 
 end
-

data/spec/ratis/location_spec.rb

@@ -1,207 +1,99 @@
 require 'spec_helper'
 
 describe Ratis::Location do
-
-  describe 'Intersection or Stop' do
-    pending 'needs implementation'
-  end
-
-  describe 'Landmark' do
-
-    before do
-      stub_atis_request.to_return( atis_response 'Locate', '1.12', 'ok', <<-BODY )
-      <Projection>SP</Projection>
-      <Locationtype>L</Locationtype>
-      <Location>
-              <Name>CENTRAL STATION</Name>
-              <Area>Phoenix</Area>
-              <Areacode>PH</Areacode>
-              <Region>1</Region>
-              <Zipname></Zipname>
-              <Latitude>33.452082</Latitude>
-              <Longitude>-112.074374</Longitude>
-              <Landmarkid>7234</Landmarkid>
-              <Islocality>N</Islocality>
-      </Location>
-      BODY
-
-      @locations = Ratis::Location.where :location => "Central Station", :media => 'a', :max_answers => 3
-      @first_location = @locations.first
+  before do
+    Ratis.reset
+    Ratis.configure do |config|
+      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-262/soap.cgi'
+      config.namespace  = 'PX_WEB'
     end
-
-    describe '#where' do
-
-      it 'only makes one request' do
-        an_atis_request.should have_been_made.times 1
-      end
-
-      it 'requests the correct SOAP action' do
-        an_atis_request_for('Locate', 'Location' => 'Central Station', 'Media' => 'A', 'Maxanswers' => '3').should have_been_made
-      end
-
-      it 'returns the single locations' do
-        @locations.should have(1).item
-      end
-
-      it 'parses out fields correctly' do
-        @first_location.name.should eql 'CENTRAL STATION'
-        @first_location.area.should eql 'Phoenix'
-        @first_location.response.should eql 'ok'
-        @first_location.areacode.should eql 'PH'
-        @first_location.latitude.should eql '33.452082'
-        @first_location.longitude.should eql '-112.074374'
-        @first_location.landmark_id.should eql '7234'
-        @first_location.address.should eql ''
-        @first_location.startaddr.should eql ''
-        @first_location.endaddr.should eql ''
-        @first_location.address_string.should eql 'CENTRAL STATION (in Phoenix)'
-      end
-
-    end
-
-  end
-
-  describe 'Address with house number match' do
-    pending 'needs implementation'
   end
 
-  describe 'Address without house number match' do
-
+  describe '#where', vcr: {} do
     before do
-      stub_atis_request.to_return( atis_response 'Locate', '1.12', 'ambig', <<-BODY )
-      <Locationtype>A</Locationtype>
-      <Projection>SP</Projection>
-      <Location>
-        <Name>W PENNSYLVANIA AVE</Name>
-        <Area>Youngtown</Area>
-        <Areacode>YG</Areacode>
-        <Region>1</Region>
-        <Zipname>85363 - Youngtown</Zipname>
-        <Latitude>33.5811205</Latitude>
-        <Longitude>-112.2989325</Longitude>
-        <Landmarkid>0</Landmarkid>
-        <Startaddr>11105</Startaddr>
-        <Endaddr>11111</Endaddr>
-        <Startlatitude>33.581130</Startlatitude>
-        <Startlongitude>-112.298791</Startlongitude>
-        <Endlatitude>33.581111</Endlatitude>
-        <Endlongitude>-112.299074</Endlongitude>
-      </Location>
-      <Location>
-        <Name>W PENNSYLVANIA AVE</Name>
-        <Area>Youngtown</Area>
-        <Areacode>YG</Areacode>
-        <Region>1</Region>
-        <Zipname>85363 - Youngtown</Zipname>
-        <Latitude>33.581082</Latitude>
-        <Longitude>-112.2991235</Longitude>
-        <Landmarkid>0</Landmarkid>
-        <Startaddr>11109</Startaddr>
-        <Endaddr>11113</Endaddr>
-        <Startlatitude>33.581111</Startlatitude>
-        <Startlongitude>-112.299074</Startlongitude>
-        <Endlatitude>33.581053</Endlatitude>
-        <Endlongitude>-112.299173</Endlongitude>
-      </Location>
-      BODY
-
-      @locations = Ratis::Location.where :location => '1600 Pennsylvania Ave', :media => 'W', :max_answers => 1000
-      @first_location = @locations.first
+      @conditions = {:location => '1315 W. Straford Dr.',
+                     :media    => 'W' }
     end
 
-    describe '#where' do
-
-      it 'only makes one request' do
-        an_atis_request.should have_been_made.times 1
-      end
-
-      it 'requests the correct SOAP action' do
-        an_atis_request_for('Locate', 'Location' => '1600 Pennsylvania Ave', 'Media' => 'W', 'Maxanswers' => '1000').should have_been_made
-      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::Location.where(@conditions.dup)
+    end
 
-      it 'returns multiple locations' do
-        @locations.should have(2).items
-      end
+    it 'requests the correct SOAP action with correct args' do
+      Ratis::Request.should_receive(:get) do |action, options|
+        action.should eq('Locate')
+        options["Location"].should eq('1315 W. Straford Dr.')
+        options["Maxanswers"].should eq(20)
+        options["Media"].should eq('W')
 
-      it 'parses out fields correctly' do
-        @first_location.name.should eql 'W PENNSYLVANIA AVE'
-        @first_location.area.should eql 'Youngtown'
-        @first_location.response.should eql 'ambig'
-        @first_location.areacode.should eql 'YG'
-        @first_location.latitude.should eql '33.5811205'
-        @first_location.longitude.should eql '-112.2989325'
-        @first_location.landmark_id.should eql '0'
-        @first_location.address.should eql ''
-        @first_location.startaddr.should eql '11105'
-        @first_location.endaddr.should eql '11111'
-        @first_location.address_string.should eql '11105 - 11111 W PENNSYLVANIA AVE (in Youngtown)'
-      end
+      end.and_return(double('response', :success? => false))
 
+      Ratis::Location.where(@conditions.dup)
     end
 
-    describe '#to_a' do
-      it 'returns lat, lon, name and landmark_id' do
-        @first_location.to_a.should eql ['33.5811205', '-112.2989325', 'W PENNSYLVANIA AVE', '0']
+    it 'should return a collection of Ratis::Location(s)' do
+      locations = Ratis::Location.where(@conditions.dup)
+      locations.each do |obj|
+        expect(obj).to be_a(Ratis::Location)
       end
     end
 
-    describe '#to_hash' do
-      it 'returns a subset of Location params' do
-        hash = {
-          :latitude   => '33.5811205',
-          :longitude  => '-112.2989325',
-          :name       => 'W PENNSYLVANIA AVE',
-          :area       => 'Youngtown',
-          :address    => '',
-          :startaddr  => '11105',
-          :endaddr    => '11111',
-          :address_string => '11105 - 11111 W PENNSYLVANIA AVE (in Youngtown)',
-          :landmark_id => '0' }
-
-        HashDiff.diff(@first_location.to_hash, hash).should eql []
-      end
-
+    it 'parses out fields correctly' do
+      locations = Ratis::Location.where(@conditions.dup)
+      first_location = locations.first
+
+      expect(first_location.name).to eql 'W STRAFORD DR'
+      expect(first_location.area).to eql 'Chandler'
+      expect(first_location.responsecode).to eql 'ok'
+      expect(first_location.areacode).to eql 'CH'
+      expect(first_location.latitude).to eql '33.353202'
+      expect(first_location.longitude).to eql '-111.864902'
+      expect(first_location.landmark_id).to eql '0'
+      expect(first_location.address).to eql '1315'
+      expect(first_location.startaddr).to be_nil
+      expect(first_location.endaddr).to be_nil
+      expect(first_location.address_string).to eql '1315 W STRAFORD DR (in Chandler)'
     end
 
   end
 
-  describe '#where' do
-
-    it 'defaults media to W' do
-      stub_atis_request.to_return( atis_response 'Locate', '1.12', 'ok', <<-BODY )
-      <Location>
-        <Name>Some place</Name>
-      </Location>
-      BODY
-
-      Ratis::Location.where :location => 'Some place', :max_answers => 1000
-      an_atis_request_for('Locate', 'Location' => 'Some place', 'Media' => 'W', 'Maxanswers' => '1000').should have_been_made
+  describe '#to_a' do
+    it 'returns lat, lon, name and landmark_id' do
+      pending
+      @first_location.to_a.should eql ['33.5811205', '-112.2989325', 'W PENNSYLVANIA AVE', '0']
     end
+  end
 
-    it 'requires a valid media' do
-      expect do
-        Ratis::Location.where :location => 'Some place', :media => 'XYZZY'
-      end.to raise_error ArgumentError, 'You must provide media of A|W|I'
+  describe '#to_hash' do
+    it 'returns a subset of Location params' do
+      pending
+      hash = {
+        :latitude   => '33.5811205',
+        :longitude  => '-112.2989325',
+        :name       => 'W PENNSYLVANIA AVE',
+        :area       => 'Youngtown',
+        :address    => '',
+        :startaddr  => '11105',
+        :endaddr    => '11111',
+        :address_string => '11105 - 11111 W PENNSYLVANIA AVE (in Youngtown)',
+        :landmark_id => '0' }
+
+      HashDiff.diff(@first_location.to_hash, hash).should eql []
     end
 
-    it 'defaults max_answers to 20' do
-      stub_atis_request.to_return( atis_response 'Locate', '1.12', 'ok', <<-BODY )
-      <Location>
-        <Name>Some place</Name>
-      </Location>
-      BODY
+  end
 
-      Ratis::Location.where :location => 'Some place', :media => 'W'
-      an_atis_request_for('Locate', 'Location' => 'Some place', 'Media' => 'W', 'Maxanswers' => '20').should have_been_made
+  describe '#address_string' do
+    it "does something" do
+      pending
     end
+  end
 
-    it 'requires a numeric max_answers' do
-      expect do
-        Ratis::Location.where :location => 'Some place', :max_answers => 'not a number'
-      end.to raise_error ArgumentError, 'You must provide a numeric max_answers'
+  describe '#full_address' do
+    it "does something" do
+      pending
     end
-
   end
-
-end
-
+end

data/spec/ratis/next_bus2_spec.rb

@@ -11,7 +11,7 @@ describe Ratis::NextBus2 do
 
   let(:empty_body){ {:nextbus_response => {:atstop => {:service => []}}} }
 
-  describe '#where' do
+  describe '#where', vcr: {} do
     before do
       # appid
       # a short string that can be used to separate requests from different applications or different modules with
@@ -61,16 +61,16 @@ describe Ratis::NextBus2 do
         response = Ratis::NextBus2.where(@conditions.dup)
         late_run = response.runs.first
         expect(late_run[:realtime][:valid]).to eq("Y")
-        expect(late_run[:realtime][:estimatedtime]).to_not eq(late_run[:triptime])
+        # expect(late_run[:realtime][:estimatedtime]).to_not eq(late_run[:triptime])
         expect(late_run[:realtime][:reliable]).to eq("Y")
-        expect(late_run[:realtime][:estimatedtime]).to eq("02:52 PM")
+        expect(late_run[:realtime][:estimatedtime]).to eq("01:08 PM")
         expect(late_run[:realtime][:estimatedminutes]).to eq("16")
 
         # :realtime=>{:valid=>"Y", :estimatedtime=>"02:52 PM", :reliable=>"Y", :stopped=>"N", :estimatedminutes=>"16", :lat=>"33.451187", :polltime=>"02:35 PM", :long=>"-111.982079", :adherence=>"0", :trend=>"D", :speed=>"0.00", :vehicleid=>"6050"},
       end
 
       it 'requests the correct SOAP action' do
-        response = Ratis::NextBus2.where(@conditions.dup.merge(:stop_id => id))
+        response = Ratis::NextBus2.where(@conditions.dup.merge(:stop_id => @stop_id))
           expect(response.stops).to_not be_empty
           expect(response.runs).to_not be_empty
         end
@@ -92,15 +92,15 @@ describe Ratis::NextBus2 do
           expect(response.stops).to be_a(Array)
 
           expect(stop[:area]).to eq("Phoenix")
-          expect(stop[:atisstopid]).to eq("3317")
-          expect(stop[:stopposition]).to eq("O")
-          expect(stop[:description]).to eq("CENTRAL AVE & DOBBINS RD")
+          expect(stop[:atisstopid]).to eq("6124")
+          expect(stop[:stopposition]).to eq("Y")
+          expect(stop[:description]).to eq("VAN BUREN ST & 16TH ST")
           expect(stop[:stopstatustype]).to eq("N")
-          expect(stop[:lat]).to eq("33.363692")
-          expect(stop[:long]).to eq("-112.073191")
+          expect(stop[:lat]).to eq("33.451493")
+          expect(stop[:long]).to eq("-112.048207")
           expect(stop[:side]).to eq("Far")
-          expect(stop[:stopid]).to eq("10050")
-          expect(stop[:heading]).to eq("NB")
+          expect(stop[:stopid]).to eq("10040")
+          expect(stop[:heading]).to eq("WB")
         end
 
         it "should return an empty array if the api request isn't successful" do
@@ -125,25 +125,25 @@ describe Ratis::NextBus2 do
           expect(response).to be_a(Ratis::NextBus2)
           expect(response.runs).to be_a(Array)
 
-          expect(run[:operator]).to eq "AP"
-          expect(run[:status]).to eq "N"
-          expect(run[:sign]).to eq "0 CENTRAL North to Dunlap/3rd St."
+          expect(run[:operator]).to eq "FT"
+          expect(run[:status]).to eq "D"
+          expect(run[:sign]).to eq "3 Van Buren To 75th Avenue"
           expect(run[:triptime]).to_not be_nil #eq "12:29 PM"
           expect(run[:triptime]).to_not be_empty
           # expect(run.realtime=>{:valid=>nil, :estimatedminutes=>nil, :polltime=>nil, :lat=>nil, :trend=>nil, :vehicleid=>nil, :speed=>nil, :adherence=>nil, :long=>nil, :reliable=>nil, :estimatedtime=>"12:09 PM", :stopped=>nil}
-          expect(run[:exception]).to be_nil
-          expect(run[:tripid]).to eq "10709-11"
+          expect(run[:exception]).to eq("N")
+          expect(run[:tripid]).to eq "11221-5"
           expect(run[:routetype]).to eq "B"
           expect(run[:skedtripid]).to be_nil
-          expect(run[:stopid]).to eq "10050"
+          expect(run[:stopid]).to eq "10040"
           expect(run[:servicetype]).to eq "W"
-          expect(run[:adherence]).to be_nil
-          expect(run[:atisstopid]).to eq "3317"
+          expect(run[:adherence]).to eq('16')
+          expect(run[:atisstopid]).to eq "6124"
           # expect(run[:block]).to eq "5"
-          expect(run[:route]).to eq "ZERO"
+          expect(run[:route]).to eq "3"
           expect(run[:estimatedtime]).to_not be_nil
           expect(run[:estimatedtime]).to_not be_empty
-          expect(run[:direction]).to eq "N"
+          expect(run[:direction]).to eq "W"
         end
       end