spark_api 1.4.28 → 1.5.0

data/spec/unit/spark_api/models/search_template/quick_search_spec.rb

@@ -10,9 +10,9 @@ describe QuickSearch do
     it "gets a current user's quick searches" do
       s = stub_api_get("/searchtemplates/quicksearches", "search_templates/quick_searches/get.json")
       quicksearches = QuickSearch.get
-      quicksearches.should be_an(Array)
-      quicksearches.size.should eq(2)
-      s.should have_been_requested
+      expect(quicksearches).to be_an(Array)
+      expect(quicksearches.size).to eq(2)
+      expect(s).to have_been_requested
     end
   end
 
@@ -21,8 +21,8 @@ describe QuickSearch do
     it "gets an individual quick search" do
       s = stub_api_get("/searchtemplates/quicksearches/#{id}", "search_templates/quick_searches/get.json")
       quicksearch = QuickSearch.find(id)
-      quicksearch.should be_an(QuickSearch)
-      s.should have_been_requested
+      expect(quicksearch).to be_an(QuickSearch)
+      expect(s).to have_been_requested
     end
   end
 

data/spec/unit/spark_api/models/shared_listing_spec.rb

@@ -7,7 +7,7 @@ describe SharedListing do
   end
 
   it "should respond to the finders" do
-    SharedListing.should respond_to(:find)
+    expect(SharedListing).to respond_to(:find)
   end
 
   context "/sharedlistings", :support do
@@ -15,11 +15,11 @@ describe SharedListing do
       stub_api_post("/#{subject.class.element_name}", 'listings/shared_listing_new.json', 'listings/shared_listing_post.json')
       subject.ListingIds = ["20110224152431857619000000","20110125122333785431000000"]
       subject.ViewId = "20080125122333787615000000"
-      subject.save.should be(true)
-      subject.Id.should eq("15Ar")
-      subject.Mode.should eq("Public")
-      subject.ResourceUri.should eq("/v1/sharedlistings/15Ar")
-      subject.SharedUri.should eq("http://www.flexmls.com/share/15Ar/3544-N-Olsen-Avenue-Tucson-AZ-85719")
+      expect(subject.save).to be(true)
+      expect(subject.Id).to eq("15Ar")
+      expect(subject.Mode).to eq("Public")
+      expect(subject.ResourceUri).to eq("/v1/sharedlistings/15Ar")
+      expect(subject.SharedUri).to eq("http://www.flexmls.com/share/15Ar/3544-N-Olsen-Avenue-Tucson-AZ-85719")
     end
 
     on_post_it "should fail creating" do
@@ -27,8 +27,8 @@ describe SharedListing do
         request.to_return(:status => 400, :body => fixture('errors/failure.json'))
       end
       subject
-      subject.save.should be(false)
-      expect{ subject.save! }.to raise_error(SparkApi::ClientError){ |e| e.status.should == 400 }
+      expect(subject.save).to be(false)
+      expect{ subject.save! }.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to eq(400) }
     end
   end
 
@@ -39,10 +39,10 @@ describe SharedListing do
                    'listings/shared_listing_get.json')
 
       shared = SharedListing.find(shared_id)
-      shared.should respond_to('SharedUri')
-      shared.should respond_to('Mode')
-      shared.Mode.should eq('Public')
-      shared.ListingIds.should be_an(Array)
+      expect(shared).to respond_to('SharedUri')
+      expect(shared).to respond_to('Mode')
+      expect(shared.Mode).to eq('Public')
+      expect(shared.ListingIds).to be_an(Array)
     end
   end
 

data/spec/unit/spark_api/models/sort_spec.rb

@@ -6,14 +6,14 @@ describe Sort do
   end
 
   it "should include the finders module" do
-    Sort.should respond_to(:find)
+    expect(Sort).to respond_to(:find)
   end
 
   it "should return sorts" do
     stub_api_get("/searchtemplates/sorts", 'sorts/get.json')
     sorts = Sort.find(:all)
-    sorts.should be_an(Array)
-    sorts.length.should eq(1)
+    expect(sorts).to be_an(Array)
+    expect(sorts.length).to eq(1)
   end
 
 end

data/spec/unit/spark_api/models/standard_fields_spec.rb

@@ -7,11 +7,11 @@ describe StandardFields do
   end
 
   it "should respond to get" do
-    StandardFields.should respond_to(:get)
+    expect(StandardFields).to respond_to(:get)
   end
 
   it "should find and expand all" do
-    StandardFields.should respond_to(:find_and_expand_all)
+    expect(StandardFields).to respond_to(:find_and_expand_all)
 
     # stub request to standardFields
     stub_api_get('/standardfields','standardfields/standardfields.json')
@@ -26,19 +26,19 @@ describe StandardFields do
     fields = StandardFields.find_and_expand_all(["City","StateOrProvince"])
 
     # keys are present
-    fields.should have_key("City")
-    fields.should have_key("StateOrProvince")
-    fields.should_not have_key("SubdivisionName")
+    expect(fields).to have_key("City")
+    expect(fields).to have_key("StateOrProvince")
+    expect(fields).not_to have_key("SubdivisionName")
 
     # FieldList
-    fields["City"]["FieldList"].length.should eq(235)
-    fields["StateOrProvince"]["FieldList"].length.should eq(5)
+    expect(fields["City"]["FieldList"].length).to eq(235)
+    expect(fields["StateOrProvince"]["FieldList"].length).to eq(5)
 
   end
 
   context "/standardfields/nearby/<property_type>", :support do
     on_get_it "should find nearby fields" do
-      StandardFields.should respond_to(:find_nearby)
+      expect(StandardFields).to respond_to(:find_nearby)
 
       # stub request
       stub_api_get('/standardfields/nearby/A','standardfields/nearby.json',
@@ -50,10 +50,10 @@ describe StandardFields do
       fields = StandardFields.find_nearby(["A"], {:Lat => 50, :Lon => -92})
 
       # validate response
-      fields["D"]["Success"].should eq(true)
-      fields["D"]["Results"].first.should have_key("City")
-      fields["D"]["Results"].first.should have_key("PostalCode")
-      fields["D"]["Results"].first.should have_key("StateOrProvince")
+      expect(fields["D"]["Success"]).to eq(true)
+      expect(fields["D"]["Results"].first).to have_key("City")
+      expect(fields["D"]["Results"].first).to have_key("PostalCode")
+      expect(fields["D"]["Results"].first).to have_key("StateOrProvince")
     end
   end
 

data/spec/unit/spark_api/models/subresource_spec.rb

@@ -17,14 +17,14 @@ describe Subresource do
 
     dummy_class.parse_date_start_and_end_times(times)
 
-    times['Date'].should eq(date)
+    expect(times['Date']).to eq(date)
 
     if RUBY_VERSION < '1.9'
-      times['StartTime'].should eq(Time.parse(start_time.to_s))
-      times['EndTime'].should eq(Time.parse(end_time.to_s))
+      expect(times['StartTime']).to eq(Time.parse(start_time.to_s))
+      expect(times['EndTime']).to eq(Time.parse(end_time.to_s))
     else
-      times['StartTime'].should eq(start_time.to_time)
-      times['EndTime'].should eq(end_time.to_time)
+      expect(times['StartTime']).to eq(start_time.to_time)
+      expect(times['EndTime']).to eq(end_time.to_time)
     end
   end
 
@@ -36,14 +36,14 @@ describe Subresource do
 
     dummy_class.parse_date_start_and_end_times(times)
 
-    times['Date'].should eq(date)
+    expect(times['Date']).to eq(date)
 
     if RUBY_VERSION < '1.9'
-      times['StartTime'].should eq(Time.parse(start_time.to_s))
-      times['EndTime'].should eq(Time.parse(end_time.to_s))
+      expect(times['StartTime']).to eq(Time.parse(start_time.to_s))
+      expect(times['EndTime']).to eq(Time.parse(end_time.to_s))
     else
-      times['StartTime'].should eq(start_time.to_time)
-      times['EndTime'].should eq(end_time.to_time)
+      expect(times['StartTime']).to eq(start_time.to_time)
+      expect(times['EndTime']).to eq(end_time.to_time)
     end
   end
 
@@ -55,14 +55,14 @@ describe Subresource do
 
     dummy_class.parse_date_start_and_end_times(times)
 
-    times['Date'].should eq(date)
+    expect(times['Date']).to eq(date)
 
     if RUBY_VERSION < '1.9'
-      times['StartTime'].should eq(Time.parse(start_time.to_s))
-      times['EndTime'].should eq(Time.parse(end_time.to_s))
+      expect(times['StartTime']).to eq(Time.parse(start_time.to_s))
+      expect(times['EndTime']).to eq(Time.parse(end_time.to_s))
     else
-      times['StartTime'].should eq(start_time.to_time)
-      times['EndTime'].should eq(end_time.to_time)
+      expect(times['StartTime']).to eq(start_time.to_time)
+      expect(times['EndTime']).to eq(end_time.to_time)
     end
   end
 
@@ -71,4 +71,22 @@ describe Subresource do
 
     expect {dummy_class.parse_date_start_and_end_times(times)}.to raise_error(ArgumentError)
   end
+
+  it "should ignore an empty Date" do
+    times = {'Date' => '', 'StartTime' => '09:12:34-0700', 'EndTime' => '12:43:21-0700'}
+    dummy_class.parse_date_start_and_end_times(times)
+    expect(times['Date']).to eq('')
+  end
+
+  it "should ignore an empty StartTime" do
+    times = {'Date' => '10/01/2012', 'StartTime' => '', 'EndTime' => '12:43:21-0700'}
+    dummy_class.parse_date_start_and_end_times(times)
+    expect(times['StartTime']).to eq('')
+  end
+
+  it "should ignore an empty EndTime" do
+    times = {'Date' => '10/01/2012', 'StartTime' => '09:12:34-0700', 'EndTime' => ''}
+    dummy_class.parse_date_start_and_end_times(times)
+    expect(times['EndTime']).to eq('')
+  end
 end

data/spec/unit/spark_api/models/system_info_spec.rb

@@ -16,22 +16,22 @@ describe SystemInfo do
   end
 
   it "should respond to get" do
-    SystemInfo.should respond_to(:get)
+    expect(SystemInfo).to respond_to(:get)
   end
   
   it "should have a primary_logo instance method" do
-    @sysinfo.should respond_to(:primary_logo)
+    expect(@sysinfo).to respond_to(:primary_logo)
   end
 
   it "should respond to attributes" do
     ['Name','OfficeId','Id','MlsId','Office','Mls'].each do |k|
-      (@sysinfo.send k.to_sym).should be_a(String)
+      expect(@sysinfo.send k.to_sym).to be_a(String)
     end
-    @sysinfo.Configuration.should be_a(Array)
+    expect(@sysinfo.Configuration).to be_a(Array)
   end
 
   it "should have an array of config items" do
-    @sysinfo.Configuration.should be_a(Array)
+    expect(@sysinfo.Configuration).to be_a(Array)
   end
 
   describe "#primary_logo" do
@@ -56,11 +56,11 @@ describe SystemInfo do
     end 
 
     it "should return nil when no logo is present" do
-      @sysinfo.primary_logo.should == nil
+      expect(@sysinfo.primary_logo).to eq(nil)
     end
 
     it "should return the first logo when several are present" do
-      @sysinfo_with_logos.primary_logo.should be_a(Hash)
+      expect(@sysinfo_with_logos.primary_logo).to be_a(Hash)
     end 
   end
 

data/spec/unit/spark_api/models/tour_of_home_spec.rb

@@ -16,7 +16,7 @@ describe TourOfHome do
   end
 
   it "should respond to a few methods" do
-    subject.class.should respond_to(:find_by_listing_key)
+    expect(subject.class).to respond_to(:find_by_listing_key)
   end
 
   context "/listings/<listing_id>/tourofhomes", :support do
@@ -24,8 +24,8 @@ describe TourOfHome do
       stub_auth_request
       stub_api_get('/listings/20060725224713296297000000/tourofhomes','listings/tour_of_homes.json')
       v = subject.class.find_by_listing_key('20060725224713296297000000')
-      v.should be_an(Array)
-      v.length.should == 2
+      expect(v).to be_an(Array)
+      expect(v.length).to eq(2)
     end
   end
 

data/spec/unit/spark_api/models/video_spec.rb

@@ -3,16 +3,16 @@ require './spec/spec_helper'
 describe Video do
 
   it "responds to" do
-    Video.should respond_to(:find_by_listing_key)
-    Video.new.should respond_to(:branded?)
-    Video.new.should respond_to(:unbranded?)
+    expect(Video).to respond_to(:find_by_listing_key)
+    expect(Video.new).to respond_to(:branded?)
+    expect(Video.new).to respond_to(:unbranded?)
   end
 
   it "has a type" do
-    Video.new(:Type => "branded").branded?.should == true
-    Video.new(:Type => "unbranded").branded?.should == false
-    Video.new(:Type => "unbranded").unbranded?.should == true
-    Video.new(:Type => "branded").unbranded?.should == false
+    expect(Video.new(:Type => "branded").branded?).to eq(true)
+    expect(Video.new(:Type => "unbranded").branded?).to eq(false)
+    expect(Video.new(:Type => "unbranded").unbranded?).to eq(true)
+    expect(Video.new(:Type => "branded").unbranded?).to eq(false)
   end
 
   describe "/listings/<listing_id>/videos", :support do
@@ -23,8 +23,8 @@ describe Video do
 
     on_get_it "should get an array of videos" do
       p = Video.find_by_listing_key('1234')
-      p.should be_an(Array)
-      p.length.should == 2
+      expect(p).to be_an(Array)
+      expect(p.length).to eq(2)
     end
 
   end

data/spec/unit/spark_api/models/virtual_tour_spec.rb

@@ -12,14 +12,14 @@ describe VirtualTour do
   end
 
   it "should respond to a few methods" do
-    VirtualTour.should respond_to(:find_by_listing_key)
-    @virtualtour.should respond_to(:branded?)
-    @virtualtour.should respond_to(:unbranded?)
+    expect(VirtualTour).to respond_to(:find_by_listing_key)
+    expect(@virtualtour).to respond_to(:branded?)
+    expect(@virtualtour).to respond_to(:unbranded?)
   end
 
   it "should know if it's branded" do
-    @virtualtour.branded?.should == true
-    @virtualtour.unbranded?.should == false
+    expect(@virtualtour.branded?).to eq(true)
+    expect(@virtualtour.unbranded?).to eq(false)
   end
 
   context "/listings/<listing_id>/virtualtours", :support do
@@ -28,8 +28,8 @@ describe VirtualTour do
       stub_api_get('/listings/1234/virtualtours','listings/virtual_tours_index.json')
 
       v = VirtualTour.find_by_listing_key('1234')
-      v.should be_an(Array)
-      v.length.should == 5
+      expect(v).to be_an(Array)
+      expect(v.length).to eq(5)
     end
   end
 

data/spec/unit/spark_api/models/vow_account_spec.rb

@@ -20,7 +20,7 @@ describe VowAccount do
       })
       vow.parent = Contact.new(:Id => "20090928182824338901000000")
       vow.save
-      s.should have_been_requested
+      expect(s).to have_been_requested
     end
 
     on_post_it "should create an empty consumer account" do
@@ -28,7 +28,7 @@ describe VowAccount do
       vow = VowAccount.new
       vow.parent = Contact.new(:Id => "20090928182824338901000000")
       vow.save
-      s.should have_been_requested
+      expect(s).to have_been_requested
     end
 
     on_put_it "should update a consumer account details" do
@@ -36,27 +36,27 @@ describe VowAccount do
       @vow_account.LoginName = "Johnny Newman"
       s = stub_api_put("/contacts/20090928182824338901000000/portal", "contacts/vow_accounts/edit.json", "contacts/vow_accounts/post.json")
       @vow_account.save
-      s.should have_been_requested
+      expect(s).to have_been_requested
     end
 
     it "should enable the current account" do
       s = stub_api_put("/contacts/20090928182824338901000000/portal", {"Settings" => {"Enabled" => "true"}}, "contacts/vow_accounts/post.json")
       @vow_account.enable
-      @vow_account.enabled?.should be_true
-      s.should have_been_requested
+      expect(@vow_account.enabled?).to be true
+      expect(s).to have_been_requested
     end
 
     it "should disable the current account" do
       s = stub_api_put("/contacts/20090928182824338901000000/portal", {"Settings" => {"Enabled" => "false"}}, "contacts/vow_accounts/post.json")
       @vow_account.disable
-      @vow_account.enabled?.should be_false
-      s.should have_been_requested
+      expect(@vow_account.enabled?).to be false
+      expect(s).to have_been_requested
     end
 
     it "should change the password" do
       s = stub_api_put("/contacts/20090928182824338901000000/portal", {"Password" => "NewPassw0rd123"}, "contacts/vow_accounts/post.json")
       @vow_account.change_password("NewPassw0rd123")
-      s.should have_been_requested
+      expect(s).to have_been_requested
     end
 
   end

data/spec/unit/spark_api/multi_client_spec.rb

@@ -20,13 +20,13 @@ describe SparkApi::MultiClient do
 
   it "should activate a client implemenation when activate()" do
     SparkApi.activate(:test_client_a)
-    SparkApi.client.api_key.should eq('a')
+    expect(SparkApi.client.api_key).to eq('a')
     SparkApi.activate(:test_client_b)
-    SparkApi.client.api_key.should eq('b')
+    expect(SparkApi.client.api_key).to eq('b')
     SparkApi.activate(:test_client_c)
-    SparkApi.client.api_key.should eq('c')
+    expect(SparkApi.client.api_key).to eq('c')
     SparkApi.activate(:test_client_a)
-    SparkApi.client.api_key.should eq('a')
+    expect(SparkApi.client.api_key).to eq('a')
   end
   it "should fail to activate symbols that do not have implementations" do
     expect { SparkApi.activate(:test_client_d) }.to raise_error(ArgumentError)
@@ -34,35 +34,35 @@ describe SparkApi::MultiClient do
   
   it "should temporarily activate a client implemenation when activate() block" do
     SparkApi.activate(:test_client_a)
-    SparkApi.client.api_key.should eq('a')
+    expect(SparkApi.client.api_key).to eq('a')
     SparkApi.activate(:test_client_b) do
-      SparkApi.client.api_key.should eq('b')
+      expect(SparkApi.client.api_key).to eq('b')
     end
-    SparkApi.client.api_key.should eq('a')
+    expect(SparkApi.client.api_key).to eq('a')
     expect do
       SparkApi.activate(:test_client_c) do
-        SparkApi.client.api_key.should eq('c')
+        expect(SparkApi.client.api_key).to eq('c')
         raise "OH MY GOODNESS I BLEW UP!!!"
       end
     end.to raise_error
-    SparkApi.client.api_key.should eq('a')
+    expect(SparkApi.client.api_key).to eq('a')
   end
 
   context "yaml" do
     before :each do
-      SparkApi::Configuration::YamlConfig.stub(:config_path) { "spec/config/spark_api" }
+      allow(SparkApi::Configuration::YamlConfig).to receive(:config_path) { "spec/config/spark_api" }
     end
 
     it "should activate a client implemenation when activate()" do
       SparkApi.activate(:test_key)
-      SparkApi.client.api_key.should eq('demo_key')
+      expect(SparkApi.client.api_key).to eq('demo_key')
     end
 
     it "should activate a single session key" do
-      SparkApi::Configuration::YamlConfig.stub(:config_path) { "spec/config/spark_api" }
+      allow(SparkApi::Configuration::YamlConfig).to receive(:config_path) { "spec/config/spark_api" }
       SparkApi.activate(:test_single_session_oauth)
-      SparkApi.client.session.should respond_to(:access_token)
-      SparkApi.client.session.access_token.should eq("yay success!")
+      expect(SparkApi.client.session).to respond_to(:access_token)
+      expect(SparkApi.client.session.access_token).to eq("yay success!")
     end
   end