spark_api 1.4.29 → 1.5.1

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

@@ -14,13 +14,13 @@ describe Finders, "Finders model" do
   it "should get first result" do
     stub_api_get("/my_resource", 'finders.json')
     resource = MyResource.first
-    resource.Id.should eq(1)
+    expect(resource.Id).to eq(1)
   end
 
   it "should get last result" do
     stub_api_get("/my_resource", 'finders.json')
     resource = MyResource.last
-    resource.Id.should eq(2)
+    expect(resource.Id).to eq(2)
   end
 
   it "should find one result" do
@@ -29,23 +29,23 @@ describe Finders, "Finders model" do
       :_filter => "Something Eq 'dude'"
     })
     resource = MyResource.find_one(:_filter => "Something Eq 'dude'")
-    resource.Id.should eq(1)
+    expect(resource.Id).to eq(1)
   end
 
   describe "find" do
 
     it "should throw an error if no argument is passed" do
       stub_api_get("/my_resource/", 'finders.json')
-      lambda {
+      expect {
         MyResource.find()
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it "should throw an error when the first argument is nil" do
       stub_api_get("/my_resource/", 'finders.json', {:_limit => 1})
-      lambda {
+      expect {
         MyResource.find(nil, {:_limit => 1})
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
   end

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

@@ -0,0 +1,24 @@
+require './spec/spec_helper'
+
+describe FloPlan do
+
+  it "responds to" do
+    expect(FloPlan).to respond_to(:find_by_listing_key)
+  end
+
+  describe "/listings/<listing_id>/videos", :support do
+    before do
+      stub_auth_request
+      stub_api_get('/listings/1234/floplans','listings/floplans_index.json')
+    end
+
+    on_get_it "should correctly split images and thumbnails" do
+      p = FloPlan.find_by_listing_key('1234').first
+      expect(p.attributes['Images'].length).to eq(2)
+      expect(p.images.length).to eq(1)
+      expect(p.thumbnails.length).to eq(1)
+    end
+
+  end
+
+end

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

@@ -9,9 +9,9 @@ describe ListingCart do
     on_get_it "should get all listing carts" do
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resources = subject.class.get
-      resources.should be_an(Array)
-      resources.length.should eq(2)
-      resources.first.Id.should eq("20100912153422758914000000")
+      expect(resources).to be_an(Array)
+      expect(resources.length).to eq(2)
+      expect(resources.first.Id).to eq("20100912153422758914000000")
     end
 
     on_post_it "should save a new listing cart" do
@@ -20,8 +20,8 @@ describe ListingCart do
                             '20110302120238448431000000',
                             '20110510011212354751000000']
       subject.Name = "My Cart's Name"
-      subject.save.should be(true)
-      subject.ResourceUri.should eq("/v1/listingcarts/20100912153422758914000000")
+      expect(subject.save).to be(true)
+      expect(subject.ResourceUri).to eq("/v1/listingcarts/20100912153422758914000000")
     end
 
     on_post_it "should fail saving" do
@@ -29,8 +29,8 @@ describe ListingCart 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
 
@@ -38,9 +38,9 @@ describe ListingCart do
     on_get_it "should get a listing cart" do
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resource = subject.class.get.first
-      resource.Id.should eq("20100912153422758914000000")
-      resource.Name.should eq("My Listing Cart")
-      resource.ListingCount.should eq(10)
+      expect(resource.Id).to eq("20100912153422758914000000")
+      expect(resource.Name).to eq("My Listing Cart")
+      expect(resource.ListingCount).to eq(10)
     end
 
     on_put_it "should save a listing cart Name" do
@@ -48,9 +48,9 @@ describe ListingCart do
       resource = subject.class.get.first
       stub_api_put("/#{subject.class.element_name}/#{resource.Id}", 'listing_carts/put_name.json', 'success.json')
       resource.Name = "My Cart's Name"
-      resource.changed?.should be(true)
-      resource.save.should be(true)
-      resource.ResourceUri.should eq("/v1/listingcarts/20100912153422758914000000")
+      expect(resource.changed?).to be(true)
+      expect(resource.save).to be(true)
+      expect(resource.ResourceUri).to eq("/v1/listingcarts/20100912153422758914000000")
     end
 
     on_put_it "should save a listing cart ListingIds" do
@@ -60,41 +60,41 @@ describe ListingCart do
       resource.ListingIds = ['20110112234857732941000000',
                              '20110302120238448431000000',
                              '20110510011212354751000000']
-      resource.changed?.should be(true)
-      resource.save.should be(true)
-      resource.ResourceUri.should eq("/v1/listingcarts/20100912153422758914000000")
+      expect(resource.changed?).to be(true)
+      expect(resource.save).to be(true)
+      expect(resource.ResourceUri).to eq("/v1/listingcarts/20100912153422758914000000")
     end
 
     on_post_it "should add a listing to a cart" do
       list_id = "20110621133454434543000000"
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resource = subject.class.get.first
-      resource.Id.should eq("20100912153422758914000000")
+      expect(resource.Id).to eq("20100912153422758914000000")
       stub_api_post("/#{subject.class.element_name}/#{resource.Id}",'listing_carts/add_listing_post.json', 'listing_carts/add_listing.json')
-      resource.ListingCount.should eq(10)
+      expect(resource.ListingCount).to eq(10)
       resource.add_listing(list_id)
-      resource.ListingCount.should eq(11)
+      expect(resource.ListingCount).to eq(11)
     end
 
     on_post_it "should add multiple listings to a cart" do
       listing_ids = ["20110621133454434543000000", "20110621133454434543000001"]
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resource = subject.class.get.first
-      resource.Id.should eq("20100912153422758914000000")
+      expect(resource.Id).to eq("20100912153422758914000000")
       stub_api_post("/#{subject.class.element_name}/#{resource.Id}",'listing_carts/add_listings_post.json', 'listing_carts/add_listings.json')
-      resource.ListingCount.should eq(10)
+      expect(resource.ListingCount).to eq(10)
       resource.add_listings(listing_ids)
-      resource.ListingCount.should eq(12)
+      expect(resource.ListingCount).to eq(12)
     end
 
     on_delete_it "should delete a listing cart" do
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resource = subject.class.get.first
-      resource.Id.should eq("20100912153422758914000000")
-      resource.Name.should eq("My Listing Cart")
-      resource.ListingCount.should eq(10)
+      expect(resource.Id).to eq("20100912153422758914000000")
+      expect(resource.Name).to eq("My Listing Cart")
+      expect(resource.ListingCount).to eq(10)
       stub_api_delete("/#{subject.class.element_name}/#{resource.Id}", 'success.json')
-      resource.delete.should be(true)
+      expect(resource.delete).to be(true)
     end
   end
 
@@ -103,11 +103,11 @@ describe ListingCart do
       list_id = "20110621133454434543000000"
       stub_api_get("/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resource = subject.class.get.first
-      resource.Id.should eq("20100912153422758914000000")
+      expect(resource.Id).to eq("20100912153422758914000000")
       stub_api_delete("/#{subject.class.element_name}/#{resource.Id}/listings/#{list_id}", 'listing_carts/remove_listing.json')
-      resource.ListingCount.should eq(10)
+      expect(resource.ListingCount).to eq(10)
       resource.remove_listing(list_id)
-      resource.ListingCount.should eq(9)
+      expect(resource.ListingCount).to eq(9)
     end
   end
 
@@ -117,9 +117,9 @@ describe ListingCart do
       stub_api_get("/#{subject.class.element_name}/for/#{listing.Id}", 'listing_carts/listing_cart.json')
       [listing, listing.Id ].each do |l|
         resources = subject.class.for(l)
-        resources.should be_an(Array)
-        resources.length.should eq(2)
-        resources.first.Id.should eq("20100912153422758914000000")
+        expect(resources).to be_an(Array)
+        expect(resources.length).to eq(2)
+        expect(resources.first.Id).to eq("20100912153422758914000000")
       end
     end
   end
@@ -128,9 +128,9 @@ describe ListingCart do
     on_get_it "should get the carts for a user" do
       stub_api_get("/my/#{subject.class.element_name}", 'listing_carts/listing_cart.json')
       resources = subject.class.my
-      resources.should be_an(Array)
-      resources.length.should eq(2)
-      resources.first.Id.should eq("20100912153422758914000000")
+      expect(resources).to be_an(Array)
+      expect(resources.length).to eq(2)
+      expect(resources.first.Id).to eq("20100912153422758914000000")
     end
   end
 
@@ -138,9 +138,9 @@ describe ListingCart do
     on_get_it "should get the carts specific to a portal user" do
       stub_api_get("/#{subject.class.element_name}/portal", 'listing_carts/listing_cart.json')
       resources = subject.class.portal
-      resources.should be_an(Array)
-      resources.length.should eq(2)
-      resources.first.Id.should eq("20100912153422758914000000")
+      expect(resources).to be_an(Array)
+      expect(resources.length).to eq(2)
+      expect(resources.first.Id).to eq("20100912153422758914000000")
     end
   end
 
@@ -148,38 +148,38 @@ describe ListingCart do
     it "should return the listings in the cart" do 
       resource = subject.class.new Id: 5, ListingIds: ["1234"]
       stub_api_get("/#{subject.class.element_name}/#{resource.Id}/listings", 'listings/multiple.json')
-      resource.listings.should be_a(Array)
-      resource.listings.first.should be_a(Listing)
+      expect(resource.listings).to be_a(Array)
+      expect(resource.listings.first).to be_a(Listing)
     end
 
     it "should return an empty array if there aren't any listings" do 
       resource = subject.class.new Id: 5
-      resource.listings.should be_a(Array)
-      resource.listings.count.should === 0
+      expect(resource.listings).to be_a(Array)
+      expect(resource.listings.count).to be === 0
     end
   end
 
   describe "filter" do
     it "should return a filter string for the cart" do
       resource = subject.class.new Id: 5
-      resource.filter.should eq("ListingCart Eq '5'")
+      expect(resource.filter).to eq("ListingCart Eq '5'")
     end
   end
 
   describe "#deletable?" do
     it "should return true for private custom carts" do
       resource = subject.class.new
-      expect(resource.deletable?).to be_true
+      expect(resource.deletable?).to be true
     end
     
     it "should return true for custom vow carts" do
       resource = subject.class.new PortalCartType: "Custom"
-      expect(resource.deletable?).to be_true
+      expect(resource.deletable?).to be true
     end
 
     it "should return false for vow carts" do
       resource = subject.class.new PortalCartType: "Favorites"
-      expect(resource.deletable?).to be_false
+      expect(resource.deletable?).to be false
     end
   end
 

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

@@ -12,18 +12,18 @@ describe ListingMetaTranslations do
       stub_api_get("/flexmls/propertytypes/A/translations", 'listing_meta_translations/get.json')
       
       translations = ListingMetaTranslations.for_property_type('A')
-      translations.should be_an(ListingMetaTranslations)
-      translations.StandardFields.should be_an(Hash)
-      translations.CustomFields.should be_an(Hash)
+      expect(translations).to be_an(ListingMetaTranslations)
+      expect(translations.StandardFields).to be_an(Hash)
+      expect(translations.CustomFields).to be_an(Hash)
     end
     
     on_get_it "doesn't explode if there are no results" do
       stub_api_get("/flexmls/propertytypes/A/translations", 'no_results.json')
       
       translations = ListingMetaTranslations.for_property_type('A')
-      translations.should be_an(ListingMetaTranslations)
-      translations.StandardFields.should be_an(Hash)
-      translations.CustomFields.should be_an(Hash)
+      expect(translations).to be_an(ListingMetaTranslations)
+      expect(translations.StandardFields).to be_an(Hash)
+      expect(translations.CustomFields).to be_an(Hash)
     end
   end
 

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

@@ -74,91 +74,91 @@ describe Listing do
 
   describe "attributes" do
     it "should allow access to fields" do
-      @listing.StandardFields.should be_a(Hash)
-      @listing.StandardFields['ListingId'].should be_a(String)
-      @listing.StandardFields['ListPrice'].should match(@listing.ListPrice)
-      @listing.photos.should be_a(Array)
+      expect(@listing.StandardFields).to be_a(Hash)
+      expect(@listing.StandardFields['ListingId']).to be_a(String)
+      expect(@listing.StandardFields['ListPrice']).to match(@listing.ListPrice)
+      expect(@listing.photos).to be_a(Array)
     end
 
     it "should not respond to removed attributes" do
-      @listing.should_not respond_to(:Photos)
-      @listing.should_not respond_to(:Documents)
-      @listing.should_not respond_to(:VirtualTours)
-      @listing.should_not respond_to(:Videos)
+      expect(@listing).not_to respond_to(:Photos)
+      expect(@listing).not_to respond_to(:Documents)
+      expect(@listing).not_to respond_to(:VirtualTours)
+      expect(@listing).not_to respond_to(:Videos)
     end
 
     describe '.street_address' do
       it 'should return the street address' do
-        @listing.street_address.should eq("100 Someone's St")
+        expect(@listing.street_address).to eq("100 Someone's St")
       end
 
       it 'should remove data masks' do
         @listing.StandardFields["UnparsedFirstLineAddress"] = "********"
-        @listing.street_address.should eq("")
+        expect(@listing.street_address).to eq("")
       end
 
       it 'should handle a missing unparsed first line address' do
         [nil, '', ' '].each do |current|
           @listing.StandardFields['UnparsedFirstLineAddress'] = current
-          @listing.street_address.should eq('')
+          expect(@listing.street_address).to eq('')
         end
       end
     end
 
     it "should return the regional address" do
-      @listing.region_address.should eq("Fargo, ND 55320")
+      expect(@listing.region_address).to eq("Fargo, ND 55320")
     end
 
     it "should return full address" do
-      @listing.full_address.should eq("100 Someone's St, Fargo, ND 55320")
+      expect(@listing.full_address).to eq("100 Someone's St, Fargo, ND 55320")
     end
 
     it "should provide shortcut methods to standard fields" do
-      @listing.StreetName.should eq("Someone's")
-      @listing.YearBuilt.should eq(nil)
-      @listing.BuildingAreaTotal.should eq("1321.0")
-      @listing.PublicRemarks.should eq(nil)
-      @listing.PostalCode.should eq("55320")
-      @listing.ListPrice.should eq("100000.0")
+      expect(@listing.StreetName).to eq("Someone's")
+      expect(@listing.YearBuilt).to eq(nil)
+      expect(@listing.BuildingAreaTotal).to eq("1321.0")
+      expect(@listing.PublicRemarks).to eq(nil)
+      expect(@listing.PostalCode).to eq("55320")
+      expect(@listing.ListPrice).to eq("100000.0")
     end
 
     it "should report that it responds to shortcut methods to standard fields" do
-      @listing.should respond_to(:StreetName)
-      @listing.should respond_to(:YearBuilt)
-      @listing.should respond_to(:BuildingAreaTotal)
-      @listing.should respond_to(:PublicRemarks)
-      @listing.should respond_to(:PostalCode)
-      @listing.should respond_to(:ListPrice)
-
-      @listing.should_not respond_to(:BogusField)
+      expect(@listing).to respond_to(:StreetName)
+      expect(@listing).to respond_to(:YearBuilt)
+      expect(@listing).to respond_to(:BuildingAreaTotal)
+      expect(@listing).to respond_to(:PublicRemarks)
+      expect(@listing).to respond_to(:PostalCode)
+      expect(@listing).to respond_to(:ListPrice)
+
+      expect(@listing).not_to respond_to(:BogusField)
       @listing.StandardFields['BogusField'] = 'bogus'
-      @listing.should respond_to(:BogusField)
+      expect(@listing).to respond_to(:BogusField)
     end
   end
 
   describe "class methods" do
     it "should respond to find" do
-      Listing.should respond_to(:find)
+      expect(Listing).to respond_to(:find)
     end
 
     it "should respond to first" do
-      Listing.should respond_to(:first)
+      expect(Listing).to respond_to(:first)
     end
 
     it "should respond to last" do
-      Listing.should respond_to(:last)
+      expect(Listing).to respond_to(:last)
     end
 
     it "should respond to my" do
-      Listing.should respond_to(:my)
+      expect(Listing).to respond_to(:my)
     end
 
     it "should respond to find_by_cart_id" do
-      Listing.should respond_to(:find_by_cart_id)
+      expect(Listing).to respond_to(:find_by_cart_id)
     end
 
     it "should respond to count" do
-      Listing.should respond_to(:count)
+      expect(Listing).to respond_to(:count)
     end
   end
 
@@ -172,14 +172,14 @@ describe Listing do
         stub_api_get('/listings', 'listings/multiple.json', {:_filter => "PostalCode Eq '83805'"})
 
         listings = Listing.find(:all, :_filter => "PostalCode Eq '83805'")
-        listings.should be_an(Array)
-        listings.count.should eq(2)
+        expect(listings).to be_an(Array)
+        expect(listings.count).to eq(2)
       end
 
       on_get_it "should return the count" do
         stub_api_get("/listings", 'count.json', { :_pagination => "count"})
         count = Listing.count()
-        count.should == 2001
+        expect(count).to eq(2001)
       end
     end
 
@@ -188,10 +188,10 @@ describe Listing do
         stub_api_get("/listings/20060725224713296297000000", 'listings/no_subresources.json')
 
         l = Listing.find('20060725224713296297000000')
-        l.videos.length.should == 0
-        l.photos.length.should == 0
-        l.documents.length.should == 0
-        l.Id.should eq('20060725224713296297000000')
+        expect(l.videos.length).to eq(0)
+        expect(l.photos.length).to eq(0)
+        expect(l.documents.length).to eq(0)
+        expect(l.Id).to eq('20060725224713296297000000')
       end
 
       on_put_it "should save a listing that has modified ListPrice" do
@@ -200,7 +200,7 @@ describe Listing do
         stub_api_put("/flexmls/listings/#{list_id}", 'listings/put.json', 'success.json')
         l = Listing.find(list_id)
         l.ListPrice = 10000.0
-        l.save.should be(true)
+        expect(l.save).to be(true)
       end
 
       on_put_it "should save a listing that has modified ExpirationDate" do
@@ -209,7 +209,7 @@ describe Listing do
         stub_api_put("/flexmls/listings/#{list_id}", 'listings/put_expiration_date.json', 'success.json')
         l = Listing.find(list_id)
         l.ExpirationDate = "2011-10-04"
-        l.save.should be(true)
+        expect(l.save).to be(true)
       end
 
       it "should not save a listing that does not exist", :method => 'PUT' do
@@ -221,8 +221,8 @@ describe Listing do
         l = Listing.find(list_id)
         l.Id = "lolwut"
         l.ListPrice = 10000.0
-        l.save.should be(false)
-        expect{ l.save! }.to raise_error(SparkApi::ClientError){ |e| e.status.should == 400 }
+        expect(l.save).to be(false)
+        expect{ l.save! }.to raise_error(SparkApi::ClientError){ |e| expect(e.status).to eq(400) }
       end
 
       on_put_it "should save a listing with constraints" do
@@ -231,9 +231,9 @@ describe Listing do
         stub_api_put("/flexmls/listings/#{list_id}", 'listings/put.json', 'listings/constraints.json')
         l = Listing.find(list_id)
         l.ListPrice = 10000.0
-        l.save.should be(true)
-        l.constraints.size.should eq(1)
-        l.constraints.first.RuleName.should eq("MaxValue")
+        expect(l.save).to be(true)
+        expect(l.constraints.size).to eq(1)
+        expect(l.constraints.first.RuleName).to eq("MaxValue")
       end
 
       on_put_it "should fail saving a listing with constraints and provide the constraints" do
@@ -245,10 +245,10 @@ describe Listing do
 
         l = Listing.find(list_id)
         l.ListPrice = 10000.0
-        l.save.should be_false
-        l.constraints.size.should eq(1)
-        l.constraints.first.RuleName.should eq("MaxIncreasePercent")
-        l.errors.size.should eq(1)
+        expect(l.save).to be false
+        expect(l.constraints.size).to eq(1)
+        expect(l.constraints.first.RuleName).to eq("MaxIncreasePercent")
+        expect(l.errors.size).to eq(1)
       end
 
       on_put_it "should reorder a photo" do
@@ -257,7 +257,7 @@ describe Listing do
         stub_api_put("/listings/#{list_id}/photos/20110826220032167405000000", 'listings/put_reorder_photo.json', 'listings/reorder_photo.json')
         l = Listing.find(list_id)
         l.reorder_photo("20110826220032167405000000", "2")
-        l.photos.size.should eq(5)
+        expect(l.photos.size).to eq(5)
       end
 
       on_put_it "should raise an exception when an index is not an Integer" do
@@ -277,9 +277,9 @@ describe Listing do
           stub_api_put("/flexmls/listings/#{list_id}", 'listings/put.json', 'listings/constraints_with_pagination.json', :_pagination => '1')
           l = Listing.find(list_id)
           l.ListPrice = 10000.0
-          l.save(:_pagination => '1').should be(true)
-          l.constraints.size.should eq(1)
-          l.constraints.first.RuleName.should eq("MaxValue")
+          expect(l.save(:_pagination => '1')).to be(true)
+          expect(l.constraints.size).to eq(1)
+          expect(l.constraints.first.RuleName).to eq("MaxValue")
         end
       end
 
@@ -288,47 +288,47 @@ describe Listing do
           stub_api_get("/listings/1234", 'listings/with_photos.json', { :_expand => "Photos" })
 
           l = Listing.find('1234', :_expand => "Photos")
-          l.photos.length.should == 5
-          l.documents.length.should == 0
-          l.videos.length.should == 0
-          l.virtual_tours.length.should == 0
+          expect(l.photos.length).to eq(5)
+          expect(l.documents.length).to eq(0)
+          expect(l.videos.length).to eq(0)
+          expect(l.virtual_tours.length).to eq(0)
         end
 
         on_get_it "should return an array of documents" do
           stub_api_get("/listings/1234", 'listings/with_documents.json', { :_expand => "Documents" })
 
           l = Listing.find('1234', :_expand => "Documents")
-          l.photos.length.should == 0
-          l.documents.length.should == 2
-          l.videos.length.should == 0
-          l.virtual_tours.length.should == 0
+          expect(l.photos.length).to eq(0)
+          expect(l.documents.length).to eq(2)
+          expect(l.videos.length).to eq(0)
+          expect(l.virtual_tours.length).to eq(0)
         end
 
         on_get_it "should return an array of virtual tours" do
           stub_api_get("/listings/1234", 'listings/with_vtour.json', { :_expand => "VirtualTours" })
 
           l = Listing.find('1234', :_expand => "VirtualTours")
-          l.virtual_tours.length.should == 1
-          l.photos.length.should == 0
-          l.documents.length.should == 0
-          l.videos.length.should == 0
+          expect(l.virtual_tours.length).to eq(1)
+          expect(l.photos.length).to eq(0)
+          expect(l.documents.length).to eq(0)
+          expect(l.videos.length).to eq(0)
         end
 
         on_get_it "should return an array of videos" do
           stub_api_get("/listings/1234", 'listings/with_videos.json', { :_expand => "Videos" })
 
           l = Listing.find('1234', :_expand => "Videos")
-          l.videos.length.should == 2
-          l.virtual_tours.length.should == 0
-          l.photos.length.should == 0
-          l.documents.length.should == 0
+          expect(l.videos.length).to eq(2)
+          expect(l.virtual_tours.length).to eq(0)
+          expect(l.photos.length).to eq(0)
+          expect(l.documents.length).to eq(0)
         end
 
         on_get_it "should return an array of rental calendars" do
           stub_api_get("/listings/1234", 'listings/with_rental_calendar.json', { :_expand => "RentalCalendar" })
 
           l = Listing.find('1234', :_expand => "RentalCalendar")
-          l.rental_calendars.length.should == 2
+          expect(l.rental_calendars.length).to eq(2)
         end
         
         ## TourOfHomes: Not implemented yet ##
@@ -337,19 +337,19 @@ describe Listing do
           #stub_api_get("/listings/20060725224713296297000000/tourofhomes", 'listings/tour_of_homes.json')
 
           #l = Listing.find('20060725224713296297000000')
-          #l.tour_of_homes().length.should == 2
-          #l.videos.length.should == 0
-          #l.photos.length.should == 0
-          #l.documents.length.should == 0
+          #expect(l.tour_of_homes().length).to eq 2
+          #expect(l.videos.length).to eq 0
+          #expect(l.photos.length).to eq 0
+          #expect(l.documents.length).to eq 0
         #end
 
         on_get_it "should return permissions" do
           stub_api_get("/listings/20060725224713296297000000", 'listings/with_permissions.json', { :_expand => "Permissions" })
           l = Listing.find('20060725224713296297000000', :_expand => "Permissions")
-          l.Permissions["Editable"].should eq(true)
-          l.editable?().should eq(true)
-          l.editable?(:PriceChange).should eq(true)
-          l.editable?(:Photos).should eq(false)
+          expect(l.Permissions["Editable"]).to eq(true)
+          expect(l.editable?()).to eq(true)
+          expect(l.editable?(:PriceChange)).to eq(true)
+          expect(l.editable?(:Photos)).to eq(false)
         end
 
         on_delete_it "should bulk delete listing photos" do
@@ -359,7 +359,7 @@ describe Listing do
           photo_id1 = l.photos[0].Id
           photo_id2 = l.photos[1].Id
           stub_api_delete("/listings/#{list_id}/photos/#{photo_id1},#{photo_id2}", 'listings/photos/index.json')
-          l.delete_photos(photo_id1 + "," + photo_id2).should_not be_empty
+          expect(l.delete_photos(photo_id1 + "," + photo_id2)).not_to be_empty
         end
       end
     end
@@ -369,8 +369,8 @@ describe Listing do
         stub_api_get('/my/listings', 'listings/multiple.json')
 
         listings = Listing.my
-        listings.should be_an(Array)
-        listings.count.should eq(2)
+        expect(listings).to be_an(Array)
+        expect(listings.count).to eq(2)
       end
     end
 
@@ -379,8 +379,8 @@ describe Listing do
         stub_api_get('/office/listings', 'listings/multiple.json')
 
         listings = Listing.office
-        listings.should be_an(Array)
-        listings.count.should eq(2)
+        expect(listings).to be_an(Array)
+        expect(listings.count).to eq(2)
       end
     end
 
@@ -389,8 +389,8 @@ describe Listing do
         stub_api_get('/company/listings', 'listings/multiple.json')
 
         listings = Listing.company
-        listings.should be_an(Array)
-        listings.count.should eq(2)
+        expect(listings).to be_an(Array)
+        expect(listings.count).to eq(2)
       end
     end
 
@@ -399,7 +399,7 @@ describe Listing do
         stub_api_get("/listings/nearby",
                      'listings/no_subresources.json', {:_lat => "45.45", :_lon => "-93.98"})
         l = Listing.nearby(45.45, -93.98)
-        l.length.should == 1
+        expect(l.length).to eq(1)
       end
     end
 
@@ -409,8 +409,8 @@ describe Listing do
 
         listings = Listing.tour_of_homes
         
-        listings.should be_an(Array)
-        listings.count.should eq(2)
+        expect(listings).to be_an(Array)
+        expect(listings.count).to eq(2)
 
       end
     end