atdis 0.3.11 → 0.5.0

data/spec/atdis/feed_spec.rb

@@ -1,110 +1,204 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe ATDIS::Feed do
-  let(:feed) { ATDIS::Feed.new("http://www.council.nsw.gov.au/atdis/1.0") }
+  let(:feed) { ATDIS::Feed.new("http://www.council.nsw.gov.au/atdis/1.0", "UTC") }
   let(:page) { double }
 
   it "should return all the applications" do
-  expect(ATDIS::Models::Page).to receive(:read_url).with("http://www.council.nsw.gov.au/atdis/1.0/applications.json").and_return(page)
-    feed.applications.should == page
+    expect(ATDIS::Models::Page).to receive(:read_url).with(
+      "http://www.council.nsw.gov.au/atdis/1.0/applications.json",
+      "UTC",
+      false
+    ).and_return(page)
+    expect(feed.applications).to eq page
   end
 
   it "should return all the applications" do
-    feed.applications_url.should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json"
+    expect(feed.applications_url).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json"
   end
 
   describe "should restrict search by postcode" do
     it "single postcode" do
-      feed.applications_url(postcode: 2000).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000"
+      expect(feed.applications_url(postcode: 2000)).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000"
     end
 
     it "multiple postcodes in an array" do
-      feed.applications_url(postcode: [2000,2001]).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001"
+      expect(feed.applications_url(postcode: [2000, 2001])).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001"
     end
 
     it "multiple postcodes as a string" do
-      feed.applications_url(postcode: "2000,2001").should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001"
+      expect(feed.applications_url(postcode: "2000,2001")).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001"
     end
   end
 
   describe "search by lodgement date" do
     it "just a lodgement start date as a date" do
-      feed.applications_url(lodgement_date_start: Date.new(2001,2,1)).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_start=2001-02-01"
+      expect(feed.applications_url(lodgement_date_start: Date.new(2001, 2, 1))).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_start=2001-02-01"
     end
 
     it "just a lodgement start date as a string" do
-      feed.applications_url(lodgement_date_start: "2011-02-04").should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_start=2011-02-04"
+      expect(feed.applications_url(lodgement_date_start: "2011-02-04")).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_start=2011-02-04"
     end
 
     it "a lodgement start date and end date" do
-      feed.applications_url(lodgement_date_start: Date.new(2001,2,1), lodgement_date_end: Date.new(2001,3,1)).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_end=2001-03-01&lodgement_date_start=2001-02-01"
+      expect(
+        feed.applications_url(
+          lodgement_date_start: Date.new(2001, 2, 1),
+          lodgement_date_end: Date.new(2001, 3, 1)
+        )
+      ).to eq(
+        "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_end=2001-03-01&lodgement_date_start=2001-02-01"
+      )
     end
   end
 
   describe "search by last modified date" do
     it "just a last modified start date" do
-      feed.applications_url(last_modified_date_start: Date.new(2001,2,1)).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_start=2001-02-01"
+      expect(feed.applications_url(last_modified_date_start: Date.new(2001, 2, 1))).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_start=2001-02-01"
     end
 
     it "a last modified start date and end date" do
-      feed.applications_url(last_modified_date_start: Date.new(2001,2,1), last_modified_date_end: Date.new(2001,3,1)).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_end=2001-03-01&last_modified_date_start=2001-02-01"
+      expect(
+        feed.applications_url(
+          last_modified_date_start: Date.new(2001, 2, 1),
+          last_modified_date_end: Date.new(2001, 3, 1)
+        )
+      ).to eq(
+        "http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_end=2001-03-01&last_modified_date_start=2001-02-01"
+      )
     end
   end
 
   describe "search by suburb" do
     it do
-      feed.applications_url(suburb: ["willow tree", "foo", "bar"]).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=willow+tree,foo,bar"
+      expect(feed.applications_url(suburb: ["willow tree", "foo", "bar"])).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=willow+tree,foo,bar"
     end
   end
 
   it "jump straight to the second page" do
-    feed.applications_url(page: 2).should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2"
+    expect(feed.applications_url(page: 2)).to eq "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2"
   end
 
   it "passing an invalid option" do
-    expect {feed.applications_url(foo: 1)}.to raise_error "Unexpected options used: foo"
+    expect { feed.applications_url(foo: 1) }.to raise_error "Unexpected options used: foo"
   end
 
   describe ".base_url_from_url" do
-    it { ATDIS::Feed.base_url_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000").should == "http://www.council.nsw.gov.au/atdis/1.0" }
-    it { ATDIS::Feed.base_url_from_url("http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000#bar").should == "http://www.foo.nsw.gov.au/prefix/atdis/1.0" }
+    it do
+      expect(
+        ATDIS::Feed.base_url_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000"
+        )
+      ).to eq "http://www.council.nsw.gov.au/atdis/1.0"
+    end
+    it do
+      expect(
+        ATDIS::Feed.base_url_from_url(
+          "http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000#bar"
+        )
+      ).to eq "http://www.foo.nsw.gov.au/prefix/atdis/1.0"
+    end
     it "should assume that any query parameters that are not recognised are part of the base_url" do
-      ATDIS::Feed.base_url_from_url("http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000&foo=bar").should == "http://www.foo.nsw.gov.au/prefix/atdis/1.0?foo=bar"
+      expect(
+        ATDIS::Feed.base_url_from_url(
+          "http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000&foo=bar"
+        )
+      ).to eq "http://www.foo.nsw.gov.au/prefix/atdis/1.0?foo=bar"
     end
   end
 
   describe ".options_from_url" do
-    it { ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json").should == {} }
-    it { ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2").should == {page: 2} }
-    it { ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001").should == {postcode: "2000,2001"} }
-    it { ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_end=2001-03-01&lodgement_date_start=2001-02-01").should ==
-      {lodgement_date_start: Date.new(2001,2,1), lodgement_date_end: Date.new(2001,3,1)} }
-    it { ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_end=2001-03-01&last_modified_date_start=2001-02-01").should ==
-      {last_modified_date_start: Date.new(2001,2,1), last_modified_date_end: Date.new(2001,3,1)} }
+    it do
+      expect(
+        ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json")
+      ).to eq({})
+    end
+    it do
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2"
+        )
+      ).to eq(page: 2)
+    end
+    it do
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?postcode=2000,2001"
+        )
+      ).to eq(postcode: "2000,2001")
+    end
+    it do
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?lodgement_date_end=2001-03-01&lodgement_date_start=2001-02-01"
+        )
+      ).to eq(
+        lodgement_date_start: Date.new(2001, 2, 1), lodgement_date_end: Date.new(2001, 3, 1)
+      )
+    end
+    it do
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?last_modified_date_end=2001-03-01&last_modified_date_start=2001-02-01"
+        )
+      ).to eq(
+        last_modified_date_start: Date.new(2001, 2, 1), last_modified_date_end: Date.new(2001, 3, 1)
+      )
+    end
     it "should assume that any query parameters that are not recognised are part of the base_url" do
-      ATDIS::Feed.options_from_url("http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000&foo=bar").should == {postcode: "2000"}
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.foo.nsw.gov.au/prefix/atdis/1.0/applications.json?postcode=2000&foo=bar"
+        )
+      ).to eq(postcode: "2000")
     end
 
     it do
-        ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=willow+tree,foo,bar").should == {suburb: "willow tree,foo,bar"}
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=willow+tree,foo,bar"
+        )
+      ).to eq(suburb: "willow tree,foo,bar")
     end
 
     it do
-      ATDIS::Feed.options_from_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=&postcode=2000").should == {postcode: "2000", suburb: nil}
+      expect(
+        ATDIS::Feed.options_from_url(
+          "http://www.council.nsw.gov.au/atdis/1.0/applications.json?suburb=&postcode=2000"
+        )
+      ).to eq(postcode: "2000", suburb: nil)
     end
   end
 
   describe "#application_url" do
-    it { feed.application_url("27B6").should == "http://www.council.nsw.gov.au/atdis/1.0/27B6.json" }
-    it { feed.application_url("27B stroke 6").should == "http://www.council.nsw.gov.au/atdis/1.0/27B+stroke+6.json" }
-    it { feed.application_url("27B/6").should == "http://www.council.nsw.gov.au/atdis/1.0/27B%2F6.json" }
+    it do
+      expect(feed.application_url("27B6")).to eq(
+        "http://www.council.nsw.gov.au/atdis/1.0/27B6.json"
+      )
+    end
+    it do
+      expect(feed.application_url("27B stroke 6")).to eq(
+        "http://www.council.nsw.gov.au/atdis/1.0/27B+stroke+6.json"
+      )
+    end
+    it do
+      expect(feed.application_url("27B/6")).to eq(
+        "http://www.council.nsw.gov.au/atdis/1.0/27B%2F6.json"
+      )
+    end
   end
 
   describe "#application" do
     it {
       application = double
-      expect(ATDIS::Models::Application).to receive(:read_url).with("http://www.council.nsw.gov.au/atdis/1.0/27B%2F6.json").and_return(application)
-      feed.application("27B/6").should == application
+      expect(ATDIS::Models::Application).to receive(:read_url).with(
+        "http://www.council.nsw.gov.au/atdis/1.0/27B%2F6.json",
+        "UTC",
+        false
+      ).and_return(application)
+      expect(feed.application("27B/6")).to eq application
     }
   end
 end

data/spec/atdis/model_spec.rb

@@ -1,119 +1,192 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 class ModelB < ATDIS::Model
-  set_field_mappings ({
+  field_mappings(
     bar: [String]
-  })
+  )
 end
 
 class ModelA < ATDIS::Model
-  set_field_mappings ({
-    bar:   [String],
+  field_mappings(
+    bar: [String],
     hello: [ModelB]
-  })
+  )
 end
 
 describe ATDIS::Model do
   describe ".attributes" do
     it do
-      a = ModelA.new(bar: "foo")
-      a.attributes.should == {"bar" => "foo"}
+      a = ModelA.new({ bar: "foo" }, "UTC")
+      expect(a.attributes).to eq("bar" => "foo")
     end
   end
 
   describe "#json_errors" do
     it "should return the json attribute with the errors" do
-      a = ModelA.interpret(bar: "Hello")
+      a = ModelA.interpret({ bar: "Hello" }, "UTC")
       a.errors.add(:bar, ATDIS::ErrorMessage["can not be so friendly", "4.5"])
       a.errors.add(:bar, ATDIS::ErrorMessage["and something else", "4.6"])
-      a.json_errors.should == [[{bar: "Hello"}, [
-        ATDIS::ErrorMessage["bar can not be so friendly", "4.5"],
-        ATDIS::ErrorMessage["bar and something else", "4.6"]]]]
+      expect(a.json_errors).to eq(
+        [[
+          { bar: "Hello" },
+          [
+            ATDIS::ErrorMessage["bar can not be so friendly", "4.5"],
+            ATDIS::ErrorMessage["bar and something else", "4.6"]
+          ]
+        ]]
+      )
     end
 
     it "should include the errors from child objects" do
-      a = ModelA.interpret(hello: {bar: "Kat"})
+      a = ModelA.interpret({ hello: { bar: "Kat" } }, "UTC")
       a.hello.errors.add(:bar, ATDIS::ErrorMessage["can't be a name", "2.3"])
-      a.hello.json_errors.should == [[{bar: "Kat"}, [ATDIS::ErrorMessage["bar can't be a name", "2.3"]]]]
-      a.json_errors.should == [[{hello: {bar: "Kat"}}, [ATDIS::ErrorMessage["bar can't be a name", "2.3"]]]]
+      expect(a.hello.json_errors).to eq(
+        [[{ bar: "Kat" }, [ATDIS::ErrorMessage["bar can't be a name", "2.3"]]]]
+      )
+      expect(a.json_errors).to eq(
+        [[{ hello: { bar: "Kat" } }, [ATDIS::ErrorMessage["bar can't be a name", "2.3"]]]]
+      )
     end
 
     it "should include the errors from only the first child object in an array" do
-      a = ModelA.interpret(hello: [{bar: "Kat"}, {bar: "Mat"}])
-      a.hello[0].bar.should == "Kat"
-      a.hello[1].bar.should == "Mat"
-      a.json_errors.should == []
+      a = ModelA.interpret({ hello: [{ bar: "Kat" }, { bar: "Mat" }] }, "UTC")
+      expect(a.hello[0].bar).to eq "Kat"
+      expect(a.hello[1].bar).to eq "Mat"
+      expect(a.json_errors).to eq []
       a.hello[0].errors.add(:bar, ATDIS::ErrorMessage["can't be a name", "1.2"])
       a.hello[1].errors.add(:bar, ATDIS::ErrorMessage["can't be a name", "1.2"])
-      a.json_errors.should == [[{hello: [{bar: "Kat"}]}, [ATDIS::ErrorMessage["bar can't be a name", "1.2"]]]]
+      expect(a.json_errors).to eq(
+        [[{ hello: [{ bar: "Kat" }] }, [ATDIS::ErrorMessage["bar can't be a name", "1.2"]]]]
+      )
     end
 
     it "should show json parsing errors" do
-      a = ModelA.interpret(invalid: {parameter: "foo"})
-      a.should_not be_valid
-      a.json_errors.should == [[nil, [ATDIS::ErrorMessage['Unexpected parameters in json data: {"invalid":{"parameter":"foo"}}', "4"]]]]
+      a = ModelA.interpret({ invalid: { parameter: "foo" } }, "UTC")
+      expect(a).to_not be_valid
+      expect(a.json_errors).to eq(
+        [[
+          nil,
+          [
+            ATDIS::ErrorMessage[
+              'Unexpected parameters in json data: {"invalid":{"parameter":"foo"}}',
+              "4"
+            ]
+          ]
+        ]]
+      )
     end
 
     it "should json errors even if value is nil" do
-      b = ModelB.new
+      b = ModelB.new({}, "UTC")
       b.errors.add(:bar, ATDIS::ErrorMessage.new("can't be nil", "1.2"))
-      b.json_errors.should == [[{bar: nil}, [ATDIS::ErrorMessage.new("bar can't be nil", "1.2")]]]
+      expect(b.json_errors).to eq(
+        [[{ bar: nil }, [ATDIS::ErrorMessage.new("bar can't be nil", "1.2")]]]
+      )
     end
   end
 
   describe ".cast" do
-    it {ATDIS::Model.cast("2013-04-20T02:01:07Z", DateTime).should == DateTime.new(2013,4,20,2,1,7)}
-    it {ATDIS::Model.cast("2013-04-20", DateTime).should == DateTime.new(2013,4,20)}
-    it {ATDIS::Model.cast("2013-04-20T02:01:07+05:00", DateTime).should == DateTime.new(2013,4,20,2,1,7,"+5")}
-    it {ATDIS::Model.cast("2013-04-20T02:01:07-05:00", DateTime).should == DateTime.new(2013,4,20,2,1,7,"-5")}
-    it {ATDIS::Model.cast("2013-04", DateTime).should be_nil}
-    it {ATDIS::Model.cast("18 September 2013", DateTime).should be_nil}
-    it {ATDIS::Model.cast(DateTime.new(2013,4,20,2,1,7), DateTime).should == DateTime.new(2013,4,20,2,1,7)}
+    describe "DateTime" do
+      describe "timezone given in string" do
+        context "in default timezone" do
+          let(:value) { ATDIS::Model.cast("2013-04-20T02:01:07Z", DateTime, "UTC") }
+          it { expect(value).to eq(DateTime.new(2013, 4, 20, 2, 1, 7, 0)) }
+          it { expect(value.zone).to eq "+00:00" }
+        end
+
+        context "in Sydney timezone" do
+          let(:value) { ATDIS::Model.cast("2013-04-20T02:01:07Z", DateTime, "Sydney") }
+          it { expect(value).to eq(DateTime.new(2013, 4, 20, 2, 1, 7, 0)) }
+          it { expect(value.zone).to eq "+10:00" }
+        end
+
+        it do
+          expect(
+            ATDIS::Model.cast("2013-04-20T02:01:07+05:00", DateTime, "UTC")
+          ).to eq(DateTime.new(2013, 4, 20, 2, 1, 7, "+5"))
+        end
+
+        it do
+          expect(
+            ATDIS::Model.cast("2013-04-20T02:01:07-05:00", DateTime, "UTC")
+          ).to eq(DateTime.new(2013, 4, 20, 2, 1, 7, "-5"))
+        end
+      end
+
+      describe "timezone not given in string" do
+        context "in default timezone" do
+          let(:value) { ATDIS::Model.cast("2013-04-20", DateTime, "UTC") }
+          it { expect(value).to eq(DateTime.new(2013, 4, 20, 0, 0, 0, 0)) }
+          it { expect(value.zone).to eq "+00:00" }
+        end
+
+        context "in Sydney timezone" do
+          let(:value) { ATDIS::Model.cast("2013-04-20", DateTime, "Sydney") }
+          it { expect(value).to eq(DateTime.new(2013, 4, 20, 0, 0, 0, "+10")) }
+          it { expect(value.zone).to eq "+10:00" }
+        end
+      end
+
+      it do
+        expect(ATDIS::Model.cast("2013-04", DateTime, "UTC")).to be_nil
+      end
+
+      it do
+        expect(ATDIS::Model.cast("18 September 2013", DateTime, "UTC")).to be_nil
+      end
+
+      it do
+        expect(
+          ATDIS::Model.cast(DateTime.new(2013, 4, 20, 2, 1, 7, 0), DateTime, "UTC")
+        ).to eq(DateTime.new(2013, 4, 20, 2, 1, 7, 0))
+      end
+    end
 
     it "should cast arrays by casting each member" do
-      ATDIS::Model.cast([1, 2, 3], String).should == ["1", "2", "3"]
+      expect(ATDIS::Model.cast([1, 2, 3], String, "UTC")).to eq %w[1 2 3]
     end
 
     # This casting allows nil values
-    describe "casting Fixnum" do
-      it { ATDIS::Model.cast("3", Fixnum).should == 3}
-      it { ATDIS::Model.cast("4.0", Fixnum).should == 4}
-      it { ATDIS::Model.cast(5, Fixnum).should == 5}
-      it { ATDIS::Model.cast(0, Fixnum).should == 0}
-      it { ATDIS::Model.cast(nil, Fixnum).should be_nil}
+    describe "casting Integer" do
+      it { expect(ATDIS::Model.cast("3", Integer, "UTC")).to eq 3 }
+      it { expect(ATDIS::Model.cast("4.0", Integer, "UTC")).to eq 4 }
+      it { expect(ATDIS::Model.cast(5, Integer, "UTC")).to eq 5 }
+      it { expect(ATDIS::Model.cast(0, Integer, "UTC")).to eq 0 }
+      it { expect(ATDIS::Model.cast(nil, Integer, "UTC")).to be_nil }
     end
   end
 
   describe ".attribute_keys" do
     it do
-      ATDIS::Model.attribute_types = {foo: String, a: Fixnum, info: String}
-      ATDIS::Model.attribute_keys.should == [:foo, :a, :info]
+      ATDIS::Model.attribute_types = { foo: String, a: Integer, info: String }
+      expect(ATDIS::Model.attribute_keys).to eq %i[foo a info]
     end
   end
 
   describe ".partition_by_used" do
     it do
-      ATDIS::Model.stub(:attribute_keys).and_return([:foo])
-      ATDIS::Model.partition_by_used({foo: 2}).should == [
-        {foo: 2}, {}
+      allow(ATDIS::Model).to receive(:attribute_keys).and_return([:foo])
+      expect(ATDIS::Model.partition_by_used(foo: 2)).to eq [
+        { foo: 2 }, {}
       ]
     end
 
     it do
-      ATDIS::Model.stub(:attribute_keys).and_return([:foo, :a])
-      ATDIS::Model.partition_by_used({foo: 2, a: 3, d: 4}).should == [
-        {foo: 2, a: 3},
-        {d: 4}
+      allow(ATDIS::Model).to receive(:attribute_keys).and_return(%i[foo a])
+      expect(ATDIS::Model.partition_by_used(foo: 2, a: 3, d: 4)).to eq [
+        { foo: 2, a: 3 },
+        { d: 4 }
       ]
     end
 
     it "something that isn't a hash will never get used" do
-      ATDIS::Model.stub(:attribute_keys).and_return([:foo, :a])
-      ATDIS::Model.partition_by_used("hello").should == [
+      allow(ATDIS::Model).to receive(:attribute_keys).and_return(%i[foo a])
+      expect(ATDIS::Model.partition_by_used("hello")).to eq [
         {},
         "hello"
       ]
-
     end
   end
 end