ratis 3.4.3 → 3.5.0

data/spec/ratis/closest_stop_spec.rb

@@ -1,15 +1,6 @@
 require 'spec_helper'
 
 describe Ratis::ClosestStop do
-
-  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
-  end
-
   describe '#where', vcr: {} do
     before do
       @today      = Time.now.strftime("%m/%d/%Y")
@@ -32,7 +23,6 @@ describe Ratis::ClosestStop do
         options["Locationlong"].should eq(@conditions[:longitude])
         options["Locationtext"].should eq(@conditions[:location_text])
         options["Numstops"].should eq(@conditions[:num_stops])
-
       end.and_return(double('response', :success? => false))
 
       Ratis::ClosestStop.where(@conditions.dup)
@@ -92,8 +82,4 @@ describe Ratis::ClosestStop do
       end.to raise_error(ArgumentError, 'You must provide a longitude')
     end
   end
-
-
-
 end
-

data/spec/ratis/config_spec.rb

@@ -1,44 +1,35 @@
 require 'spec_helper'
 
 describe Ratis::Config do
+  it 'is valid' do
+    expect(Ratis.config).to be_valid
+  end
 
-  context 'with an endpoint and namespace set' do
-
-    describe '#valid?' do
-
-      it 'is valid' do
-        Ratis.config.valid?.should be_true
-      end
-
+  context 'nil endpoint' do
+    it 'is not valid' do
+      expect(Ratis.config).to receive(:endpoint).at_least(:once).and_return(nil)
+      expect(Ratis.config).to_not be_valid
     end
-
   end
 
-  context 'without an endpoint or namespace set' do
-
-    before do
-      # Override Ratis.configure made in spec_helper.rb
-      # Ratis.config = Ratis::Config.new
+  context 'empty endpoint' do
+    it 'is not valid' do
+      expect(Ratis.config).to receive(:endpoint).at_least(:once).and_return('')
+      expect(Ratis.config).to_not be_valid
     end
+  end
 
-    describe '#valid?' do
-
-      it 'is not valid' do
-        pending('Need way in specs to set new config after one is set.')
-        Ratis.config.valid?.should be_false
-      end
-
+  context 'nil namespace' do
+    it 'is not valid' do
+      expect(Ratis.config).to receive(:namespace).at_least(:once).and_return(nil)
+      expect(Ratis.config).to_not be_valid
     end
+  end
 
-    after do
-      # Reset Ratis.configure made in spec_helper.rb
-      Ratis.configure do |config|
-        config.endpoint = 'http://example.com/soap.cgi'
-        config.namespace = 'TEST_NS'
-      end
+  context 'empty namespace' do
+    it 'is not valid' do
+      expect(Ratis.config).to receive(:namespace).at_least(:once).and_return('')
+      expect(Ratis.config).to_not be_valid
     end
-
   end
-
 end
-

data/spec/ratis/core_ext_spec.rb

@@ -1,11 +1,8 @@
 require 'spec_helper'
 
 describe Hash do
-
   describe 'which is one level deep' do
-
     describe '#to_array' do
-
       it 'returns [] if key is not present in Hash' do
         {}.to_array(:a).should eql []
       end
@@ -21,15 +18,11 @@ describe Hash do
       it 'returns Array if value is an Array' do
         { :a => [1,2,3] }.to_array(:a).should eql [1,2,3]
       end
-
     end
-
   end
 
   describe 'which is two levels deep' do
-
     describe '#to_array' do
-
       it 'returns [] if key is not present in Hash' do
         { :a => {} }.to_array(:a, :b).should eql []
       end
@@ -45,10 +38,6 @@ describe Hash do
       it 'returns Array if value is an Array' do
         { :a => { :b => [1,2,3] } }.to_array(:a, :b).should eql [1,2,3]
       end
-
     end
-
   end
-
 end
-

data/spec/ratis/fleet_location_spec.rb

@@ -1,56 +1,41 @@
 require 'spec_helper'
 
 describe Ratis::FleetLocation do
-
-  before do
-    Ratis.reset
-    Ratis.configure do |config|
-      config.endpoint   = 'http://soap.valleymetro.org/cgi-bin-soap-web-271/soap.cgi'
-      config.namespace  = 'PX_WEB'
-    end
-  end
-
   describe "#current" do
-    before do
-      @conditions = {:app_id => 'WEB'}
-    end
-
     it 'only makes one request', vcr: {} do
       # false just to stop further processing of response
       Ratis::Request.should_receive(:get).once.and_call_original
-      Ratis::FleetLocation.current(@conditions.dup)
+      Ratis::FleetLocation.current
     end
 
     it 'requests the correct SOAP action' do
       Ratis::Request.should_receive(:get) do |action, options|
         action.should eq('Fleetlocation')
-        options["Appid"].should eq(@conditions[:app_id])
-
       end.and_return(double('response', :success? => false))
 
-      Ratis::FleetLocation.current(@conditions.dup)
+      Ratis::FleetLocation.current
     end
 
     it "should return a collection of Ratis::Vehicle(s)", vcr: {} do
-      stops = Ratis::FleetLocation.current(@conditions.dup)
+      stops = Ratis::FleetLocation.current
       stops.each do |obj|
         expect(obj).to be_a(Ratis::Vehicle)
       end
     end
 
     it 'returns multiple vehicles', vcr: {} do
-      stops = Ratis::FleetLocation.current(@conditions.dup)
-      stops.should have(403).items
+      stops = Ratis::FleetLocation.current
+      stops.should have(469).items
     end
 
     it 'parses out the vehicle fields correctly', vcr: {} do
-      vehicles = Ratis::FleetLocation.current(@conditions.dup)
+      vehicles = Ratis::FleetLocation.current
       vehicle  = vehicles.first
 
       expect(vehicle.route).to eq('1')
       expect(vehicle.direction).to eq('E')
-      expect(vehicle.updatetime).to eq('02:08 PM')
-      expect(vehicle.adherance).to eq('0')
+      expect(vehicle.updatetime).to eq('05:38 PM')
+      expect(vehicle.adherance).to eq('-1')
       expect(vehicle.adhchange).to eq('S')
       expect(vehicle.vehicle_id).to be_nil
       expect(vehicle.offroute).to eq('N')
@@ -58,7 +43,5 @@ describe Ratis::FleetLocation do
       expect(vehicle.reliable).to eq('Y')
       expect(vehicle.inservice).to eq('Y')
     end
-
   end
-
 end

data/spec/ratis/itinerary_spec.rb

@@ -1,19 +1,9 @@
 require 'spec_helper'
 
 describe Ratis::Itinerary do
-  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
-  end
-
   describe '#initialize' do
     it "does something" do
       pending
     end
   end
-
 end
-

data/spec/ratis/landmark_category_spec.rb

@@ -1,16 +1,7 @@
 require 'spec_helper'
 
 describe Ratis::LandmarkCategory do
-
-  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
-  end
-
-  describe '.all', vcr: {} do
+  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
@@ -49,6 +40,4 @@ describe Ratis::LandmarkCategory do
       end
     end
   end
-
 end
-

data/spec/ratis/landmark_spec.rb

@@ -1,52 +1,39 @@
 require 'spec_helper'
 
 describe Ratis::Landmark do
-
-  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
-  end
-
   describe "#where" do
-    before do
-      @conditions = {:type => '*',
-                     :zipcode => '85224'}
-    end
+    let(:conditions) { { :type => '*', :zipcode => '85224' } }
 
     it 'only makes one request', vcr: {} do
       # false just to stop further processing of response
       Ratis::Request.should_receive(:get).once.and_call_original
-      Ratis::Landmark.where(@conditions.dup)
+      Ratis::Landmark.where(conditions.dup)
     end
 
     it 'requests the correct SOAP action' do
       Ratis::Request.should_receive(:get) do |action, options|
         action.should eq('Getlandmarks')
-        options["Type"].should eq(@conditions[:type])
-        options["Zipcode"].should eq(@conditions[:zipcode])
-
+        options["Type"].should eq(conditions[:type])
+        options["Zipcode"].should eq(conditions[:zipcode])
       end.and_return(double('response', :success? => false))
 
-      Ratis::Landmark.where(@conditions.dup)
+      Ratis::Landmark.where(conditions.dup)
     end
 
     it "should return a collection of Ratis::Landmark(s)", vcr: {} do
-      stops = Ratis::Landmark.where(@conditions.dup)
+      stops = Ratis::Landmark.where(conditions.dup)
       stops.each do |obj|
         expect(obj).to be_a(Ratis::Landmark)
       end
     end
 
     it 'returns multiple landmarks', vcr: {} do
-      stops = Ratis::Landmark.where(@conditions.dup)
-      stops.should have(1514).items
+      stops = Ratis::Landmark.where(conditions.dup)
+      stops.should have(1034).items
     end
 
     it 'parses out the landmark fields correctly', vcr: {} do
-      landmarks = Ratis::Landmark.where(@conditions.dup)
+      landmarks = Ratis::Landmark.where(conditions.dup)
       landmark  = landmarks.first
 
       expect(landmark.type).to eq('LRT')
@@ -56,11 +43,11 @@ describe Ratis::Landmark do
     end
 
     it "should raise error for missing arg type" do
-      conditions = @conditions.dup
-      conditions.delete(:type)
+      conds = conditions.dup
+      conds.delete(:type)
 
       expect do
-        Ratis::Landmark.where(conditions)
+        Ratis::Landmark.where(conds)
       end.to raise_error(ArgumentError, 'You must provide a type')
     end
   end

data/spec/ratis/location_spec.rb

@@ -1,24 +1,13 @@
 require 'spec_helper'
 
 describe Ratis::Location do
-  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
-  end
-
   describe '#where', vcr: {} do
-    before do
-      @conditions = {:location => '1315 W. Straford Dr.',
-                     :media    => 'W' }
-    end
+    let(:conditions) { { :location => '1315 W. Straford Dr.', :media => 'W' } }
 
     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)
+      Ratis::Location.where(conditions.dup)
     end
 
     it 'requests the correct SOAP action with correct args' do
@@ -30,18 +19,18 @@ describe Ratis::Location do
 
       end.and_return(double('response', :success? => false))
 
-      Ratis::Location.where(@conditions.dup)
+      Ratis::Location.where(conditions.dup)
     end
 
     it 'should return a collection of Ratis::Location(s)' do
-      locations = Ratis::Location.where(@conditions.dup)
+      locations = Ratis::Location.where(conditions.dup)
       locations.each do |obj|
         expect(obj).to be_a(Ratis::Location)
       end
     end
 
     it 'parses out fields correctly' do
-      locations = Ratis::Location.where(@conditions.dup)
+      locations = Ratis::Location.where(conditions.dup)
       first_location = locations.first
 
       expect(first_location.name).to eql 'W STRAFORD DR'

data/spec/ratis/location_type_ahead_item_spec.rb

@@ -1,21 +1,23 @@
 require 'spec_helper'
 
 describe Ratis::LocationTypeAheadItem do
-  let(:item){ Ratis::LocationTypeAheadItem.new(name: '1315 W STRAFORD DR',
-                                               area: 'Chandler',
-                                               areacode: 'CH',
-                                               postcode: '85224',
-                                               type: 'N') }
+  let(:item) {
+    Ratis::LocationTypeAheadItem.new({
+      name: '1315 W STRAFORD DR',
+      area: 'Chandler',
+      areacode: 'CH',
+      postcode: '85224',
+      type: 'N'
+    })
+  }
 
   describe '#initialize' do
-    it "should correct assign instance variables" do
+    it "should correctly assign instance variables" do
       expect(item.name).to eq('1315 W STRAFORD DR')
       expect(item.area).to eq('Chandler')
       expect(item.areacode).to eq('CH')
       expect(item.postcode).to eq('85224')
       expect(item.type).to eq('N')
     end
-
   end
-
-end
+end

data/spec/ratis/location_type_ahead_spec.rb

@@ -1,54 +1,40 @@
 require 'spec_helper'
 
 describe Ratis::LocationTypeAhead do
-  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
-  end
-
   describe '#where', vcr: {} do
-    before do
-      @conditions = {:search => '1315 w straford dr'}
-    end
+    let(:conditions) { { :search => '1315 w straford dr' } }
 
     it 'only makes one request' do
       # false just to stop further processing of response
       Ratis::Request.should_receive(:get).once.and_call_original
-      Ratis::LocationTypeAhead.where(@conditions.dup)
+      Ratis::LocationTypeAhead.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('Locationtypeahead')
         options["Search"].should eq('1315 w straford dr')
-        options["Appid"].should eq('WEB') # default
-
       end.and_return(double('response', :success? => false))
 
-      Ratis::LocationTypeAhead.where(@conditions.dup)
+      Ratis::LocationTypeAhead.where(conditions.dup)
     end
 
     it 'should return a collection of Ratis::LocationTypeAheadItem(s)' do
-      locations = Ratis::LocationTypeAhead.where(@conditions.dup)
+      locations = Ratis::LocationTypeAhead.where(conditions.dup)
       locations.each do |obj|
         expect(obj).to be_a(Ratis::LocationTypeAheadItem)
       end
     end
 
     it 'parses out fields correctly' do
-      locations = Ratis::LocationTypeAhead.where(@conditions.dup)
+      locations = Ratis::LocationTypeAhead.where(conditions.dup)
       location = locations.first
 
       expect(location.name).to eql '1315 W STRAFORD DR'
       expect(location.area).to eql 'Chandler'
       expect(location.areacode).to eql 'CH'
-      expect(location.postcode).to eql '85224'
+      expect(location.postcode).to be_nil # Applies only to landmarks
       expect(location.type).to eql 'N'
     end
-
   end
-
-end
+end