atdis 0.3.11 → 0.5.0

data/spec/atdis/models/land_title_ref_spec.rb

@@ -1,39 +1,55 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe ATDIS::Models::LandTitleRef do
   context "torrens" do
-    before(:each) {
+    before(:each) do
       m = double
-      expect(ATDIS::Models::TorrensTitle).to receive(:interpret).with({lot: "10"}).and_return(m)
+      expect(ATDIS::Models::TorrensTitle).to receive(:interpret).with(
+        { lot: "10" },
+        "UTC"
+      ).and_return(m)
       expect(m).to receive(:valid?).and_return(true)
-    }
-    let(:l) { ATDIS::Models::LandTitleRef.new(torrens: {lot: "10"}) }
-    it { l.should be_valid }
+    end
+    let(:l) { ATDIS::Models::LandTitleRef.new({ torrens: { lot: "10" } }, "UTC") }
+    it { expect(l).to be_valid }
   end
 
   context "other" do
-    let(:l) { ATDIS::Models::LandTitleRef.new(other: {some: "foo", random: "stuff"})}
-    it { l.should be_valid }
+    let(:l) { ATDIS::Models::LandTitleRef.new({ other: { some: "foo", random: "stuff" } }, "UTC") }
+    it { expect(l).to be_valid }
   end
 
   context "no torrens or other" do
-    let(:l) { ATDIS::Models::LandTitleRef.new }
+    let(:l) { ATDIS::Models::LandTitleRef.new({}, "UTC") }
     it {
-      l.should_not be_valid
-      l.errors.messages.should == {torrens: [ATDIS::ErrorMessage.new("or other needs be present", "4.3.3")]}
+      expect(l).to_not be_valid
+      expect(l.errors.messages).to eq(
+        torrens: [ATDIS::ErrorMessage.new("or other needs be present", "4.3.3")]
+      )
     }
   end
 
   context "both torrens and other" do
-    before(:each) {
+    before(:each) do
       m = double
-      expect(ATDIS::Models::TorrensTitle).to receive(:interpret).with({lot: "10"}).and_return(m)
+      expect(ATDIS::Models::TorrensTitle).to(
+        receive(:interpret).with({ lot: "10" }, "UTC").and_return(m)
+      )
       expect(m).to receive(:valid?).and_return(true)
-    }
-    let(:l) { ATDIS::Models::LandTitleRef.new(torrens: {lot: "10"}, other: {some: "foo", random: "stuff"})}
+    end
+    let(:l) do
+      ATDIS::Models::LandTitleRef.new(
+        { torrens: { lot: "10" }, other: { some: "foo", random: "stuff" } },
+        "UTC"
+      )
+    end
     it {
-      l.should_not be_valid
-      l.errors.messages.should == {torrens: [ATDIS::ErrorMessage.new("and other can't both be present", "4.3.3")]}
+      expect(l).to_not be_valid
+      expect(l.errors.messages).to eq(
+        torrens: [ATDIS::ErrorMessage.new("and other can't both be present", "4.3.3")]
+      )
     }
   end
 end

data/spec/atdis/models/location_spec.rb

@@ -1,95 +1,110 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe ATDIS::Models::Location do
   it ".attribute_names" do
-    ATDIS::Models::Location.attribute_names.should == [
-      "address",
-      "land_title_ref",
-      "geometry"
+    expect(ATDIS::Models::Location.attribute_names).to eq %w[
+      address
+      land_title_ref
+      geometry
     ]
   end
 
   describe "validation" do
     context "valid location" do
-      let(:l) { ATDIS::Models::Location.new(
-        address: {
-          street: "123 Fourfivesix Street",
-          suburb: "Neutral Bay",
-          postcode: "2089",
-          state: "NSW"
-        },
-        land_title_ref: {
-          torrens: {
-            lot: "10",
-            section: "ABC",
-            dpsp_id: "DP2013-0381",
-          }
-        },
-        geometry: {
-          type: "Point",
-          coordinates: [100.0, 0.0]
-        }
-      )}
+      let(:l) do
+        ATDIS::Models::Location.new(
+          {
+            address: {
+              street: "123 Fourfivesix Street",
+              suburb: "Neutral Bay",
+              postcode: "2089",
+              state: "NSW"
+            },
+            land_title_ref: {
+              torrens: {
+                lot: "10",
+                section: "ABC",
+                dpsp_id: "DP2013-0381"
+              }
+            },
+            geometry: {
+              type: "Point",
+              coordinates: [100.0, 0.0]
+            }
+          },
+          "UTC"
+        )
+      end
 
-      it { l.should be_valid }
+      it { expect(l).to be_valid }
 
       it "address" do
         l.address = nil
-        l.should_not be_valid
-        l.errors.messages.should == {address: [ATDIS::ErrorMessage["can't be blank", "4.3.3"]]}
+        expect(l).to_not be_valid
+        expect(l.errors.messages).to eq(address: [ATDIS::ErrorMessage["can't be blank", "4.3.3"]])
       end
 
       it "geometry" do
-        l.geometry = {type: "Point"}
-        l.geometry.should be_nil
-        l.should_not be_valid
+        l.geometry = { type: "Point" }
+        expect(l.geometry).to be_nil
+        expect(l).to_not be_valid
       end
     end
   end
 
   describe ".interpret" do
     it "should gracefully handle the land_title_ref block being missing" do
-      l = ATDIS::Models::Location.interpret(address: {street: "123 Fourfivesix Street", suburb: "Neutral Bay", postcode: "2089"})
-      l.land_title_ref.should be_nil
+      l = ATDIS::Models::Location.interpret(
+        { address: { street: "123 Fourfivesix Street", suburb: "Neutral Bay", postcode: "2089" } },
+        "UTC"
+      )
+      expect(l.land_title_ref).to be_nil
     end
 
     it "should pass on the responsibility for parsing the geometry section" do
-      # TODO Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
+      # TODO: Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
       l = ATDIS::Models::Location.interpret(
-        geometry: {
-          type: "Point",
-          coordinates: [100.0, 0.0]
-        }
+        {
+          geometry: {
+            type: "Point",
+            coordinates: [100.0, 0.0]
+          }
+        },
+        "UTC"
       )
-      # TODO Check that the returned geometry is a point
-      l.geometry.x.should == 100
-      l.geometry.y.should == 0
+      # TODO: Check that the returned geometry is a point
+      expect(l.geometry.x).to eq 100
+      expect(l.geometry.y).to eq 0
     end
 
     it "should interpret a polygon in the geometry section" do
-      # TODO Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
+      # TODO: Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
       l = ATDIS::Models::Location.interpret(
-        geometry: {
-          type: "Polygon",
-          coordinates: [
-            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
-              [100.0, 1.0], [100.0, 0.0] ]
-          ]
-        }
+        {
+          geometry: {
+            type: "Polygon",
+            coordinates: [
+              [[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]
+            ]
+          }
+        },
+        "UTC"
       )
-      # TODO Check that the returned geometry is a polygon
-      l.geometry.interior_rings.should be_empty
-      l.geometry.exterior_ring.points.count.should == 5
-      l.geometry.exterior_ring.points[0].x.should == 100
-      l.geometry.exterior_ring.points[0].y.should == 0
-      l.geometry.exterior_ring.points[1].x.should == 101
-      l.geometry.exterior_ring.points[1].y.should == 0
-      l.geometry.exterior_ring.points[2].x.should == 101
-      l.geometry.exterior_ring.points[2].y.should == 1
-      l.geometry.exterior_ring.points[3].x.should == 100
-      l.geometry.exterior_ring.points[3].y.should == 1
-      l.geometry.exterior_ring.points[4].x.should == 100
-      l.geometry.exterior_ring.points[4].y.should == 0
+      # TODO: Check that the returned geometry is a polygon
+      expect(l.geometry.interior_rings).to be_empty
+      expect(l.geometry.exterior_ring.points.count).to eq 5
+      expect(l.geometry.exterior_ring.points[0].x).to eq 100
+      expect(l.geometry.exterior_ring.points[0].y).to eq 0
+      expect(l.geometry.exterior_ring.points[1].x).to eq 101
+      expect(l.geometry.exterior_ring.points[1].y).to eq 0
+      expect(l.geometry.exterior_ring.points[2].x).to eq 101
+      expect(l.geometry.exterior_ring.points[2].y).to eq 1
+      expect(l.geometry.exterior_ring.points[3].x).to eq 100
+      expect(l.geometry.exterior_ring.points[3].y).to eq 1
+      expect(l.geometry.exterior_ring.points[4].x).to eq 100
+      expect(l.geometry.exterior_ring.points[4].y).to eq 0
     end
   end
 end

data/spec/atdis/models/page_spec.rb

@@ -1,37 +1,58 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe ATDIS::Models::Page do
   it ".attribute_names" do
-    ATDIS::Models::Page.attribute_names.should == ["response", "count", "pagination"]
+    expect(ATDIS::Models::Page.attribute_names).to eq %w[response count pagination]
   end
 
   it "should error if response is null" do
-    page = ATDIS::Models::Page.new(response: nil, count: 0, pagination: {pages: 1, per_page: 20, count: 0, current: 1})
-    page.should_not be_valid
-    page.errors.messages.should == {:response => [ATDIS::ErrorMessage["can't be blank", "4.3"]]}
+    page = ATDIS::Models::Page.new(
+      { response: nil, count: 0, pagination: { pages: 1, per_page: 20, count: 0, current: 1 } },
+      "UTC"
+    )
+    expect(page).to_not be_valid
+    expect(page.errors.messages).to eq(response: [ATDIS::ErrorMessage["can't be blank", "4.3"]])
   end
 
   describe "validations" do
     context "results block that is a hash" do
       before :each do
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application1").and_return(double(valid?: true))
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application1" },
+          "UTC"
+        ).and_return(double(valid?: true))
       end
-      let(:page) { ATDIS::Models::Page.new(response: {description: "application1"}) }
+      let(:page) { ATDIS::Models::Page.new({ response: { description: "application1" } }, "UTC") }
 
       it do
-        page.should_not be_valid
-        page.errors.messages.should == {response: [ATDIS::ErrorMessage["should be an array", "6.4"]]}
+        expect(page).to_not be_valid
+        expect(page.errors.messages).to eq(
+          response: [ATDIS::ErrorMessage["should be an array", "6.4"]]
+        )
       end
     end
 
     context "two valid applications no paging" do
       before :each do
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application1").and_return(double(valid?: true))
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application2").and_return(double(valid?: true))
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application1" },
+          "UTC"
+        ).and_return(double(valid?: true))
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application2" },
+          "UTC"
+        ).and_return(double(valid?: true))
+      end
+      let(:page) do
+        ATDIS::Models::Page.new(
+          { response: [{ description: "application1" }, { description: "application2" }] },
+          "UTC"
+        )
       end
-      let(:page) { ATDIS::Models::Page.new(response: [{description: "application1"}, {description: "application2"}]) }
 
-      it {page.should be_valid}
+      it { expect(page).to be_valid }
 
       # It's not super clear in the spec whether this should be allowed but it seems sensible to
       # allow it.
@@ -39,23 +60,30 @@ describe ATDIS::Models::Page do
         before :each do
           page.count = 2
         end
-        it { page.should be_valid }
+        it { expect(page).to be_valid }
       end
 
       context "with pagination" do
         before :each do
           page.count = 2
-          page.pagination = ATDIS::Models::Pagination.new(per_page: 25, current: 1, count: 2, pages: 1)
+          page.pagination = ATDIS::Models::Pagination.new(
+            { per_page: 25, current: 1, count: 2, pages: 1 },
+            "UTC"
+          )
         end
-        it { page.should be_valid }
+        it { expect(page).to be_valid }
 
         context "count is not consistent" do
           before :each do
             page.count = 1
           end
           it do
-            page.should_not be_valid
-            page.errors.messages.should == {count: [ATDIS::ErrorMessage["is not the same as the number of applications returned", "6.4"]]}
+            expect(page).to_not be_valid
+            expect(page.errors.messages).to eq(
+              count: [
+                ATDIS::ErrorMessage["is not the same as the number of applications returned", "6.4"]
+              ]
+            )
           end
         end
 
@@ -65,8 +93,15 @@ describe ATDIS::Models::Page do
             page.pagination.count = 1
           end
           it do
-            page.should_not be_valid
-            page.errors.messages.should == {count: [ATDIS::ErrorMessage["should not be larger than the number of results per page", "6.4"]]}
+            expect(page).to_not be_valid
+            expect(page.errors.messages).to eq(
+              count: [
+                ATDIS::ErrorMessage[
+                  "should not be larger than the number of results per page",
+                  "6.4"
+                ]
+              ]
+            )
           end
         end
 
@@ -76,19 +111,25 @@ describe ATDIS::Models::Page do
           end
 
           it do
-            page.should_not be_valid
-            page.errors.messages.should == {count: [ATDIS::ErrorMessage["should be present if pagination is being used", "6.4"]]}
+            expect(page).to_not be_valid
+            expect(page.errors.messages).to eq(
+              count: [ATDIS::ErrorMessage["should be present if pagination is being used", "6.4"]]
+            )
           end
         end
 
         context "pagination not valid" do
           before :each do
-            page.pagination.should_receive(:valid?).and_return(false)
+            expect(page.pagination).to receive(:valid?).and_return(false)
           end
 
           it do
-            page.should_not be_valid
-            page.errors.messages.should == {pagination: [ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]]}
+            expect(page).to_not be_valid
+            expect(page.errors.messages).to eq(
+              pagination: [
+                ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]
+              ]
+            )
           end
         end
       end
@@ -96,101 +137,144 @@ describe ATDIS::Models::Page do
 
     context "one valid application out of two no paging" do
       before :each do
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application1").and_return(double(valid?: true))
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application2").and_return(double(valid?: false))
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application1" },
+          "UTC"
+        ).and_return(double(valid?: true))
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application2" },
+          "UTC"
+        ).and_return(double(valid?: false))
+      end
+      let(:page) do
+        ATDIS::Models::Page.new(
+          { response: [{ description: "application1" }, { description: "application2" }] },
+          "UTC"
+        )
       end
-      let(:page) { ATDIS::Models::Page.new(response: [{description: "application1"}, {description: "application2"}]) }
 
       it do
-        page.should_not be_valid
-        page.errors.messages.should == {response: [ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]]}
+        expect(page).to_not be_valid
+        expect(page.errors.messages).to eq(
+          response: [ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]]
+        )
       end
     end
 
     context "two invalid applications no paging" do
-      let(:a1) { double(valid?: false, json_errors: [[{dat_id: "null"}, ["can not be empty"]]]) }
+      let(:a1) { double(valid?: false, json_errors: [[{ dat_id: "null" }, ["can not be empty"]]]) }
       let(:a2) { double(valid?: false) }
       before :each do
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application1").and_return(a1)
-        ATDIS::Models::Response.should_receive(:interpret).with(description: "application2").and_return(a2)
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application1" },
+          "UTC"
+        ).and_return(a1)
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { description: "application2" },
+          "UTC"
+        ).and_return(a2)
+      end
+      let(:page) do
+        ATDIS::Models::Page.new(
+          { response: [{ description: "application1" }, { description: "application2" }] },
+          "UTC"
+        )
       end
-      let(:page) { ATDIS::Models::Page.new(response: [{description: "application1"}, {description: "application2"}]) }
 
       it do
-        page.should_not be_valid
-        page.errors.messages.should == {response: [ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]]}
+        expect(page).to_not be_valid
+        expect(page.errors.messages).to eq(
+          response: [ATDIS::ErrorMessage["is not valid (see further errors for details)", nil]]
+        )
       end
 
       it "the errors from the first errored application should be here" do
-        page.should_not be_valid
-        page.json_errors.should == [[{response: [{description: "application1"}, {description: "application2"}]}, [ATDIS::ErrorMessage["response is not valid (see further errors for details)"]]], [{response: [{dat_id: "null"}]} , ["can not be empty"]]]
+        expect(page).to_not be_valid
+        expect(page.json_errors).to eq(
+          [
+            [
+              { response: [{ description: "application1" }, { description: "application2" }] },
+              [ATDIS::ErrorMessage["response is not valid (see further errors for details)"]]
+            ],
+            [
+              { response: [{ dat_id: "null" }] },
+              ["can not be empty"]
+            ]
+          ]
+        )
       end
-
     end
   end
 
   context "paging supported by vendor" do
     context "read a from an invalid json string" do
-      let(:page) { ATDIS::Models::Page.read_json(<<-EOF
-{
-  "response": [
-    {
-      "application": {
-        "description": "application2"
-      }
-    }
-  ],
-}
-       EOF
-        )}
+      let(:page) do
+        json = <<~JSON
+          {
+            "response": [
+              {
+                "application": {
+                  "description": "application2"
+                }
+              }
+            ],
+          }
+        JSON
+        ATDIS::Models::Page.read_json(json, "UTC")
+      end
 
       it do
-        page.should_not be_valid
-        page.errors.messages.has_key?(:json).should be_truthy
-        page.errors.messages.count.should == 1
-        # The error messages returned by the library are different for different Ruby versions
-        ruby19_message = ATDIS::ErrorMessage["Invalid JSON: 784: unexpected token at '{\n  \"response\": [\n    {\n      \"application\": {\n        \"description\": \"application2\"\n      }\n    }\n  ],\n}\n'", nil]
-        ruby20_message = ATDIS::ErrorMessage["Invalid JSON: 795: unexpected token at '{\n  \"response\": [\n    {\n      \"application\": {\n        \"description\": \"application2\"\n      }\n    }\n  ],\n}\n'", nil]
-        page.errors.messages[:json].count.should == 1
+        expect(page).to_not be_valid
+        expect(page.errors.messages.key?(:json)).to be_truthy
+        expect(page.errors.messages.count).to eq 1
+        expect(page.errors.messages[:json].count).to eq 1
         message = page.errors.messages[:json].first
-        (message == ruby19_message || message == ruby20_message).should be_truthy
+        expect(message.message).to match(/Invalid JSON: .*: unexpected token at '{/)
       end
     end
 
     context "read from a json string" do
-      let(:page) { ATDIS::Models::Page.read_json(<<-EOF
-{
-  "response": [
-    {
-      "application": {
-        "description": "application1"
-      }
-    },
-    {
-      "application": {
-        "description": "application2"
-      }
-    }
-  ],
-  "count": 2,
-  "pagination": {
-    "previous": 1,
-    "next": 3,
-    "current": 2,
-    "per_page": 2,
-    "count": 50,
-    "pages": 25
-  }
-}
-       EOF
-        )}
+      let(:page) do
+        json = <<~JSON
+          {
+            "response": [
+              {
+                "application": {
+                  "description": "application1"
+                }
+              },
+              {
+                "application": {
+                  "description": "application2"
+                }
+              }
+            ],
+            "count": 2,
+            "pagination": {
+              "previous": 1,
+              "next": 3,
+              "current": 2,
+              "per_page": 2,
+              "count": 50,
+              "pages": 25
+            }
+          }
+        JSON
+        ATDIS::Models::Page.read_json(json, "UTC")
+      end
       it ".results" do
         application1 = double("Application")
         application2 = double("Application")
-        ATDIS::Models::Response.should_receive(:interpret).with(application: {description: "application1"}).and_return(application1)
-        ATDIS::Models::Response.should_receive(:interpret).with(application: {description: "application2"}).and_return(application2)
-
-        page.response.should == [application1, application2]
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { application: { description: "application1" } },
+          "UTC"
+        ).and_return(application1)
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { application: { description: "application2" } },
+          "UTC"
+        ).and_return(application2)
+
+        expect(page.response).to eq [application1, application2]
       end
 
       it ".next_page" do
@@ -201,7 +285,7 @@ describe ATDIS::Models::Page do
     context "read from a url" do
       before :each do
         # Mock network response
-        RestClient.should_receive(:get).with("http://www.council.nsw.gov.au/atdis/1.0/applications.json").and_return(double(to_str: <<-EOF
+        json = <<-JSON
   {
     "response": [
       {
@@ -216,96 +300,121 @@ describe ATDIS::Models::Page do
       }
     ]
   }
-        EOF
-        ))
+        JSON
+        expect(ATDIS::Model).to receive(:read_url_raw).with(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json",
+          false
+        ).and_return(json)
       end
 
-      let(:applications_results) { ATDIS::Models::Page.read_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json") }
+      let(:applications_results) do
+        ATDIS::Models::Page.read_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json",
+          "UTC"
+        )
+      end
 
       it ".response" do
         application1 = double("Application")
         application2 = double("Application")
-        ATDIS::Models::Response.should_receive(:interpret).with(application: {description: "application1"}).and_return(application1)
-        ATDIS::Models::Response.should_receive(:interpret).with(application: {description: "application2"}).and_return(application2)
-
-        applications_results.response.should == [application1, application2]
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { application: { description: "application1" } },
+          "UTC"
+        ).and_return(application1)
+        expect(ATDIS::Models::Response).to receive(:interpret).with(
+          { application: { description: "application2" } },
+          "UTC"
+        ).and_return(application2)
+
+        expect(applications_results.response).to eq [application1, application2]
       end
 
       it ".next_page" do
-        applications_results.next_page.should be_nil
+        expect(applications_results.next_page).to be_nil
       end
 
       it ".pagination" do
-        applications_results.pagination.should be_nil
-      end
+        expect(applications_results.pagination).to be_nil
       end
+    end
   end
 
   context "paging supported by vendor" do
     before :each do
-      RestClient.should_receive(:get).with("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2").and_return(double(to_str: <<-EOF
-{
-  "response": [
-    {
-      "application": {
-        "description": "application1"
-      }
-    },
-    {
-      "application": {
-        "description": "application2"
-      }
-    }
-  ],
-  "count": 2,
-  "pagination": {
-    "previous": 1,
-    "next": 3,
-    "current": 2,
-    "per_page": 2,
-    "count": 50,
-    "pages": 25
-  }
-}
-      EOF
-      ))
+      json = <<~JSON
+        {
+          "response": [
+            {
+              "application": {
+                "description": "application1"
+              }
+            },
+            {
+              "application": {
+                "description": "application2"
+              }
+            }
+          ],
+          "count": 2,
+          "pagination": {
+            "previous": 1,
+            "next": 3,
+            "current": 2,
+            "per_page": 2,
+            "count": 50,
+            "pages": 25
+          }
+        }
+      JSON
+      expect(ATDIS::Model).to receive(:read_url_raw).with(
+        "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2",
+        false
+      ).and_return(json)
     end
 
-    let(:applications_results) { ATDIS::Models::Page.read_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2") }
+    let(:applications_results) do
+      ATDIS::Models::Page.read_url(
+        "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2",
+        "UTC"
+      )
+    end
 
     it ".previous" do
-      applications_results.pagination.previous.should == 1
+      expect(applications_results.pagination.previous).to eq 1
     end
 
     it ".next" do
-      applications_results.pagination.next.should == 3
+      expect(applications_results.pagination.next).to eq 3
     end
 
     it ".current" do
-      applications_results.pagination.current.should == 2
+      expect(applications_results.pagination.current).to eq 2
     end
 
     it ".per_page" do
-      applications_results.pagination.per_page.should == 2
+      expect(applications_results.pagination.per_page).to eq 2
     end
 
     it ".count" do
-      applications_results.pagination.count.should == 50
+      expect(applications_results.pagination.count).to eq 50
     end
 
     it ".pages" do
-      applications_results.pagination.pages.should == 25
+      expect(applications_results.pagination.pages).to eq 25
     end
 
     it ".next_url" do
-      applications_results.next_url.should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=3"
+      expect(applications_results.next_url).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=3"
     end
 
     it ".next_page" do
       n = double("Page")
       applications_results
-      ATDIS::Models::Page.should_receive(:read_url).with("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=3").and_return(n)
-      applications_results.next_page.should == n
+      expect(ATDIS::Models::Page).to receive(:read_url).with(
+        "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=3",
+        "UTC"
+      ).and_return(n)
+      expect(applications_results.next_page).to eq n
     end
   end
 end