atdis 0.2 → 0.3

data/spec/atdis/models/authority_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe ATDIS::Models::Authority do
+  describe "validations" do
+    context "a valid ref" do
+      let(:a) { ATDIS::Models::Authority.new(ref: "http://www.council.nsw.gov.au/atdis/1.0", name: "Council")}
+      it {a.should be_valid}
+    end
+
+    context "a valid ref with https" do
+      let(:a) { ATDIS::Models::Authority.new(ref: "https://www.council.nsw.gov.au/atdis/1.0", name: "Council")}
+      it {a.should be_valid}
+    end
+
+    context "an invalid ref that isn't a url" do
+      let(:a) { ATDIS::Models::Authority.new(ref: "foobar", name: "Council")}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {ref: [
+          ATDIS::ErrorMessage.new("is not a valid URL", "4.3.1"),
+          ATDIS::ErrorMessage.new("is not a valid Unique Authority Identifier", "4.3.1")
+        ]}
+      }
+    end
+
+    context "an invalid ref because it doesn't end in atdis/1.0" do
+      let(:a) { ATDIS::Models::Authority.new(ref: "http://www.council.nsw.gov.au/foobar", name: "Council")}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {ref: [ATDIS::ErrorMessage.new("is not a valid Unique Authority Identifier", "4.3.1")]}
+      }
+    end
+  end
+end

data/spec/atdis/models/document_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe ATDIS::Models::Document do
+  it ".attribute_names" do
+    ATDIS::Models::Document.attribute_names.should == ["ref", "title", "document_url"]
+  end
+
+  it ".ref" do
+    ATDIS::Models::Document.interpret(ref: "27B/6").ref.should == "27B/6"
+  end
+
+  it ".title" do
+    ATDIS::Models::Document.interpret(title: "Authorisation for Repairs").title.should == "Authorisation for Repairs"
+  end
+
+  it ".document_url" do
+    ATDIS::Models::Document.interpret(document_url: "http://foo.com/bar").document_url.should == URI.parse("http://foo.com/bar")
+  end
+end

data/spec/atdis/models/event_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe ATDIS::Models::Event do
+  it ".attribute_names" do
+    ATDIS::Models::Event.attribute_names.should == ["id", "timestamp", "description", "event_type", "status"]
+  end
+
+  it ".id" do
+    ATDIS::Models::Event.interpret(id: "27B/6").id.should == "27B/6"
+  end
+
+  it ".date" do
+    ATDIS::Models::Event.interpret(timestamp: "2013-06-18").timestamp.should == DateTime.new(2013,6,18)
+  end
+
+  it ".description" do
+    ATDIS::Models::Event.interpret(description: "A very fine event").description.should == "A very fine event"
+  end
+
+  it ".event_type" do
+    # TODO Is event_type always a string? ATDIS-1.0.3 doesn't say
+    ATDIS::Models::Event.interpret(event_type: "approval").event_type.should == "approval"
+  end
+
+  it ".status" do
+    # TODO Is status always a string? ATDIS-1.0.3 doesn't say
+    ATDIS::Models::Event.interpret(status: "approved").status.should == "approved"
+  end
+end

data/spec/atdis/models/info_spec.rb

@@ -0,0 +1,303 @@
+require "spec_helper"
+
+describe ATDIS::Models::Info do
+  let(:a) { ATDIS::Models::Info.new(
+    dat_id: "DA2013-0381",
+    development_type: "residential",
+    application_type: "DA",
+    last_modified_date: DateTime.new(2013,4,20,2,1,7),
+    description: "New pool plus deck",
+    authority: {
+      ref:  "http://www.council.nsw.gov.au/atdis/1.0",
+      name: "Example Council Shire Council"
+    },
+    lodgement_date: DateTime.new(2013,4,20,2,1,7),
+    determination_date: DateTime.new(2013,6,20),
+    determination_type: "Pending",
+    status: "OPEN",
+  )}
+
+  describe "determination_type" do
+    context "is missing" do
+      before(:each) { a.determination_type = nil}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {determination_type: [ATDIS::ErrorMessage.new("does not have one of the allowed types", "4.3.1")]}
+      }
+    end
+
+    context "is valid and Pending" do
+      before(:each) { a.determination_type = "Pending" }
+      it { a.should be_valid }
+    end
+
+    context "is not valid because it's not one of the set of allowed ones" do
+      before(:each) { a.determination_type = "Something random" }
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {determination_type: [ATDIS::ErrorMessage.new("does not have one of the allowed types", "4.3.1")]}
+      }
+    end
+  end
+
+  describe "notification_date" do
+    it "both valid start and end dates" do
+      a.notification_start_date = DateTime.new(2013,4,20,2,1,7)
+      a.notification_end_date = DateTime.new(2013,5,20,0,0,0)
+      a.should be_valid
+    end
+
+    it "invalid start date" do
+      a.notification_start_date = "18 January 2013"
+      a.notification_end_date = DateTime.new(2013,2,1,0,0,0)
+      a.should_not be_valid
+      a.errors.messages.should == {notification_start_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+    end
+
+    it "invalid end date" do
+      a.notification_start_date = DateTime.new(2013,1,10,0,0,0)
+      a.notification_end_date = "18 January 2013"
+      a.should_not be_valid
+      a.errors.messages.should == {notification_end_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+    end
+
+    it "only start date set" do
+      a.notification_start_date = DateTime.new(2013,4,20,2,1,7)
+      a.should_not be_valid
+      a.errors.messages.should == {notification_end_date: [ATDIS::ErrorMessage["can not be blank if notification_start_date is set", "4.3.1"]]}
+    end
+
+    it "only end date set" do
+      a.notification_end_date = DateTime.new(2013,4,20,2,1,7)
+      a.should_not be_valid
+      a.errors.messages.should == {notification_start_date: [ATDIS::ErrorMessage["can not be blank if notification_end_date is set", "4.3.1"]]}
+    end
+
+    it "end date is before start date" do
+      a.notification_start_date = DateTime.new(2013,5,20,0,0,0)
+      a.notification_end_date = DateTime.new(2013,4,20,2,1,7)
+      a.should_not be_valid
+      a.errors.messages.should == {notification_end_date: [ATDIS::ErrorMessage["can not be earlier than notification_start_date", "4.3.1"]]}
+    end
+
+    it "both dates set to null" do
+      a.notification_start_date = nil
+      a.notification_end_date = nil
+      a.notification_start_date.should be_nil
+      a.notification_end_date.should be_nil
+      a.should be_valid
+    end
+
+    it "only start date set to null" do
+      a.notification_start_date = nil
+      a.notification_end_date = DateTime.new(2013,2,1,0,0,0)
+      a.should_not be_valid
+      a.errors.messages.should == {notification_start_date: [ATDIS::ErrorMessage["can not be blank if notification_end_date is set", "4.3.1"]]}
+    end
+
+    it "only end date set to null" do
+      a.notification_start_date = DateTime.new(2013,2,1,0,0,0)
+      a.notification_end_date = nil
+      a.should_not be_valid
+      a.errors.messages.should == {notification_end_date: [ATDIS::ErrorMessage["can not be blank if notification_start_date is set", "4.3.1"]]}
+    end
+  end
+
+  describe ".status" do
+    it do
+      a.status = nil
+      a.should_not be_valid
+      a.errors.messages.should == {status: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+  end
+
+  describe ".determination_date" do
+    it do
+      a.determination_date = nil
+      a.should be_valid
+    end
+    it do
+      a.determination_date = "18 January 2013"
+      a.should_not be_valid
+      a.errors.messages.should == {determination_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+    end
+    it "nil should be allowed if the application is not yet determined" do
+      a.determination_date = nil
+      a.determination_date.should be_nil
+      a.should be_valid
+    end
+  end
+
+  describe ".lodgement_date" do
+    it do
+      a.lodgement_date = nil
+      a.should_not be_valid
+      a.errors.messages.should == {lodgement_date: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+    it do
+      a.lodgement_date = "18 January 2013"
+      a.should_not be_valid
+      a.errors.messages.should == {lodgement_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+    end
+  end
+
+  describe ".authority" do
+    it do
+      a.authority = nil
+      a.should_not be_valid
+      a.errors.messages.should == {authority: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+  end
+
+  describe ".description" do
+    it do
+      a.description = ""
+      a.should_not be_valid
+      a.errors.messages.should == {description: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+  end
+
+  describe ".last_modified_date" do
+    it do
+      a.last_modified_date = nil
+      a.should_not be_valid
+      a.errors.messages.should == {last_modified_date: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+    it do
+      a.last_modified_date = "18 January 2013"
+      a.should_not be_valid
+      a.errors.messages.should == {last_modified_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+    end
+  end
+
+  describe ".dat_id" do
+    it ".dat_id" do
+      a.dat_id = nil
+      a.should_not be_valid
+      a.errors.messages.should == {dat_id: [ATDIS::ErrorMessage["can't be blank", "4.3.1"]]}
+    end
+
+    it "should be url encoded" do
+      a.dat_id = "foo bar"
+      a.should_not be_valid
+      a.errors.messages.should == {dat_id: [ATDIS::ErrorMessage["should be url encoded", "4.3.1"]]}
+    end
+  end
+
+  describe "#description=" do
+    let(:a) { ATDIS::Models::Info.new }
+    it "should do not type casting when it's already a String" do
+      a.description = "foo"
+      a.description.should == "foo"
+    end
+    context "not a string" do
+      before :each do
+        a.description = 123
+      end
+      it "should cast to a string when it's not a string" do
+        a.description.should == "123"
+      end
+      it "should keep the original value" do
+        a.description_before_type_cast.should == 123
+      end
+    end
+  end
+
+  describe "#lodgement_date=" do
+    let(:a) { ATDIS::Models::Info.new }
+    it "should do no type casting when it's already a date" do
+      a.lodgement_date = DateTime.new(2013,1,1)
+      a.lodgement_date.should == DateTime.new(2013,1,1)
+    end
+
+    it "should cast a string to a date when it's a valid date" do
+      a.lodgement_date = "2013-01-01"
+      a.lodgement_date.should == DateTime.new(2013,1,1)
+    end
+
+    context "not a valid date" do
+      before :each do
+        a.lodgement_date = "2013/01/01"
+      end
+      it "should be nil" do
+        a.lodgement_date.should be_nil
+      end
+      it "should keep the original string" do
+        a.lodgement_date_before_type_cast.should == "2013/01/01"
+      end
+    end
+  end
+
+  describe "#last_modified_date=" do
+    let(:a) { ATDIS::Models::Info.new }
+    it "should do no type casting when it's already a date" do
+      a.last_modified_date = DateTime.new(2013,1,1)
+      a.last_modified_date.should == DateTime.new(2013,1,1)
+    end
+
+    it "should cast a string to a date when it's a valid date" do
+      a.last_modified_date = "2013-01-01"
+      a.last_modified_date.should == DateTime.new(2013,1,1)
+    end
+
+    context "not a valid date" do
+      before :each do
+        a.last_modified_date = "2013/01/01"
+      end
+      it "should be nil" do
+        a.last_modified_date.should be_nil
+      end
+      it "should keep the original string" do
+        a.last_modified_date_before_type_cast.should == "2013/01/01"
+      end
+    end
+  end
+
+  describe "related_apps" do
+    context "is missing" do
+      before(:each) { a.related_apps = nil }
+      it { a.should be_valid }
+    end
+
+    context "is not an array" do
+      before(:each) { a.related_apps = "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json"}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {related_apps: [ATDIS::ErrorMessage.new("should be an array", "4.3.1")]}
+      }
+    end
+
+    context "are all valid URLs that uniquely identifies a DA" do
+      before(:each) { a.related_apps = [
+        "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json",
+        "http://www.council.nsw.gov.au/foo/bar/atdis/1.0/sdjfsd.json"
+      ]}
+      it { a.should be_valid }
+    end
+
+    context "are all valid URLs but one does not end in json" do
+      before(:each) { a.related_apps = [
+        "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json",
+        "http://www.council.nsw.gov.au/foo/bar/atdis/1.0/sdjfsd"
+      ]}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {related_apps: [ATDIS::ErrorMessage.new("contains url(s) not in the expected format", "4.3.1")]}
+      }
+    end
+
+    context "contains an invalid URL" do
+      before(:each) { a.related_apps = [
+        "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json",
+        "foobar"
+      ]}
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {related_apps: [
+          ATDIS::ErrorMessage.new("contains an invalid URL", "4.3.1"),
+          ATDIS::ErrorMessage.new("contains url(s) not in the expected format", "4.3.1")
+        ]}
+      }
+    end
+  end
+end

data/spec/atdis/models/land_title_ref_spec.rb

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

data/spec/atdis/models/location_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe ATDIS::Models::Location do
+  it ".attribute_names" do
+    ATDIS::Models::Location.attribute_names.should == [
+      "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]
+        }
+      )}
+
+      it { l.should 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"]]}
+      end
+
+      it "geometry" do
+        l.geometry = {type: "Point"}
+        l.geometry.should be_nil
+        l.should_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
+    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
+      l = ATDIS::Models::Location.interpret(
+        geometry: {
+          type: "Point",
+          coordinates: [100.0, 0.0]
+        }
+      )
+      # TODO Check that the returned geometry is a point
+      l.geometry.x.should == 100
+      l.geometry.y.should == 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
+      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] ]
+          ]
+        }
+      )
+      # 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
+    end
+  end
+end