atdis 0.2 → 0.3

data/spec/atdis/document_spec.rb

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

data/spec/atdis/event_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ATDIS::Event do
-  it ".attribute_names" do
-    ATDIS::Event.attribute_names.should == ["id", "date", "description", "event_type", "status"]
-  end
-
-  it ".id" do
-    ATDIS::Event.interpret(:id => "27B/6").id.should == "27B/6"
-  end
-
-  it ".date" do
-    ATDIS::Event.interpret(:date => "2013-06-18").date.should == DateTime.new(2013,6,18)
-  end
-
-  it ".description" do
-    ATDIS::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::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::Event.interpret(:status => "approved").status.should == "approved"
-  end
-end

data/spec/atdis/location_spec.rb

@@ -1,148 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ATDIS::Location do
-  it ".attribute_names" do
-    ATDIS::Location.attribute_names.should == [
-      "address",
-      "lot",
-      "section",
-      "dpsp_id",
-      "geometry"
-    ]
-  end
-
-  describe "validation" do
-    context "valid location" do
-      let(:l) { ATDIS::Location.new(
-        :address => "123 Fourfivesix Street Neutral Bay NSW 2089",
-        :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 = ""
-        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
-
-      describe "lot" do
-        it "can not be blank" do
-          l.lot = ""
-          l.should_not be_valid
-          l.errors.messages.should == {:lot => [ATDIS::ErrorMessage["can't be blank", "4.3.3"]]}
-        end
-
-        it "can be none but is not interpreted in any special way" do
-          l.lot = "none"
-          l.lot.should == "none"
-          l.should be_valid
-        end
-      end
-
-      describe "section" do
-        it "can not be blank" do
-          l.section = ""
-          l.should_not be_valid
-          l.errors.messages.should == {:section => [ATDIS::ErrorMessage["can't be blank", "4.3.3"]]}
-        end
-
-        it "can be none" do
-          l.section = "none"
-          l.section.should be_nil
-          l.should be_valid
-        end
-      end
-
-      describe "dpsp_id" do
-        it "can not be blank" do
-          l.dpsp_id = ""
-          l.should_not be_valid
-          l.errors.messages.should == {:dpsp_id => [ATDIS::ErrorMessage["can't be blank", "4.3.3"]]}
-        end
-
-        it "can be none but is not interpreted in any special way" do
-          l.dpsp_id = "none"
-          l.dpsp_id.should == "none"
-          l.should be_valid
-        end
-      end
-    end
-  end
-
-  describe ".interpret" do
-    it "should interpret a parsed json block of location data" do
-      l = ATDIS::Location.interpret(
-        :address => "123 Fourfivesix Street Neutral Bay NSW 2089",
-        :land_title_ref => {
-          :lot => "10",
-          :section => "ABC",
-          :dpsp_id => "DP2013-0381"
-        })
-      
-      l.address.should == "123 Fourfivesix Street Neutral Bay NSW 2089"
-      l.lot.should == "10"
-      l.section.should == "ABC"
-      l.dpsp_id.should == "DP2013-0381"
-    end
-
-    it "should gracefully handle the land_title_ref block being missing" do
-      l = ATDIS::Location.interpret(:address => "123 Fourfivesix Street Neutral Bay NSW 2089")
-      l.address.should == "123 Fourfivesix Street Neutral Bay NSW 2089"
-      l.lot.should == ""
-      l.section.should == ""
-      l.dpsp_id.should == ""
-    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::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::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

data/spec/atdis/page_spec.rb

@@ -1,492 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ATDIS::Page do
-  it ".attribute_names" do
-    ATDIS::Page.attribute_names.should == ["results", "count", "previous_page_no", "next_page_no", "current_page_no",
-      "no_results_per_page", "total_no_results", "total_no_pages"]
-  end
-
-  describe "validations" do
-    context "two valid applications no paging" do
-      before :each do
-        ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(double(:valid? => true))
-        ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(double(:valid? => true))
-      end
-      let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-      it {page.should be_valid}
-
-      context "with pagination" do
-        before :each do
-          page.count = 2
-          page.no_results_per_page = 25
-          page.current_page_no = 1
-          page.total_no_results = 2
-          page.total_no_pages = 1
-        end
-        it { page.should 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.5"]]}
-          end
-        end
-
-        context "count is larger than number of results per page" do
-          before :each do
-            page.no_results_per_page = 1
-            page.total_no_results = 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.5"]]}
-          end
-        end
-
-        context "count is absent" do
-          before :each do
-            page.count = nil
-          end
-
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:count => [ATDIS::ErrorMessage["should be present if pagination is being used", "6.5"]]}
-          end
-        end
-
-        context "previous page number is pointing to a weird page number" do
-          before :each do
-            page.previous_page_no = 5
-            page.current_page_no = 2
-            page.total_no_results = 50
-            page.total_no_pages = 2
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:previous_page_no => [ATDIS::ErrorMessage["should be one less than current page number or null if first page", "6.5"]]}
-            page.json_errors.should == [[{:pagination => {:previous => 5}}, [ATDIS::ErrorMessage["should be one less than current page number or null if first page", "6.5"]]]]
-          end
-        end
-
-        context "previous page number if nil but not on first page" do
-          before :each do
-            page.current_page_no = 4
-            page.next_page_no = 5
-            page.previous_page_no = nil
-            page.total_no_results = 240
-            page.total_no_pages = 10
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:previous_page_no => [ATDIS::ErrorMessage["can't be null if not on the first page", "6.5"]]}
-          end
-        end
-
-        context "previous page number not nil but on first page" do
-          before :each do
-            page.current_page_no = 1
-            page.next_page_no = 2
-            page.previous_page_no = 0
-            page.total_no_results = 240
-            page.total_no_pages = 10
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:previous_page_no => [ATDIS::ErrorMessage["should be null if on the first page", "6.5"]]}
-          end
-        end
-
-        context "next page number is pointing to a weird page number" do
-          before :each do
-            page.next_page_no = 5
-            page.total_no_results = 50
-            page.total_no_pages = 2
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:next_page_no => [ATDIS::ErrorMessage["should be one greater than current page number or null if last page", "6.5"]]}
-          end          
-        end
-
-        context "next page number is nil but not on last page" do
-          before :each do
-            page.current_page_no = 4
-            page.previous_page_no = 3
-            page.next_page_no = nil
-            page.total_no_results = 140
-            page.total_no_pages = 6
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:next_page_no => [ATDIS::ErrorMessage["can't be null if not on the last page", "6.5"]]}
-          end
-        end
-
-        context "next page number is not nil but on last page" do
-          before :each do
-            page.previous_page_no = 3
-            page.current_page_no = 4
-            page.next_page_no = 5
-            page.total_no_results = 100
-            page.total_no_pages = 4
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:next_page_no => [ATDIS::ErrorMessage["should be null if on the last page", "6.5"]]}
-          end
-        end
-
-        context "current page is larger than the number of pages" do
-          before :each do
-            page.current_page_no = 2
-            page.previous_page_no = 1
-            page.next_page_no = 3
-            page.total_no_pages = 1
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:current_page_no => [ATDIS::ErrorMessage["is larger than the number of pages", "6.5"]]}
-          end
-        end
-
-        context "current page is zero" do
-          before :each do
-            page.current_page_no = 0
-            page.next_page_no = 1
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:current_page_no => [ATDIS::ErrorMessage["can not be less than 1", "6.5"]]}
-          end          
-        end
-
-        context "total_no_results is larger than would be expected" do
-          before :each do
-            page.current_page_no = 1
-            page.next_page_no = 2
-            page.no_results_per_page = 25
-            page.total_no_pages = 4
-            page.total_no_results = 101
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:total_no_results => [ATDIS::ErrorMessage["is larger than can be retrieved through paging", "6.5"]]}
-          end          
-        end
-
-        context "total no_results is less than would be expected" do
-          before :each do
-            page.current_page_no = 1
-            page.next_page_no = 2
-            page.no_results_per_page = 25
-            page.total_no_pages = 4
-            page.total_no_results = 75
-          end
-          it do
-            page.should_not be_valid
-            page.errors.messages.should == {:total_no_results => [ATDIS::ErrorMessage["could fit into a smaller number of pages", "6.5"]]}
-          end          
-        end
-      end
-    end
-
-    context "one valid application out of two no paging" do
-      before :each do
-        ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(double(:valid? => true))
-        ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(double(:valid? => false))
-      end
-      let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-      it do
-        page.should_not be_valid
-        page.errors.messages.should == {:results => [ATDIS::ErrorMessage["is not valid", 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(:a2) { double(:valid? => false) }
-      before :each do
-        ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(a1)
-        ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(a2)
-      end
-      let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-      it do
-        page.should_not be_valid
-        page.errors.messages.should == {:results => [ATDIS::ErrorMessage["is not valid", nil]]}
-      end
-
-      it "the errors from the first errored application should be here" do
-        page.should_not be_valid
-        page.json_errors.should == [[{:response => {:dat_id => "null"}} , ["can not be empty"]]]
-      end
-
-    end
-  end
-
-  describe ".level_used?" do
-    describe "level 1" do
-      context "two applications" do
-        before :each do
-          ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(double)
-          ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(double)
-        end
-        let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-        it { page.level_used?(1).should be_true }
-      end
-
-      context "no L1 features used" do
-        let(:page) { ATDIS::Page.new }
-        it { page.level_used?(1).should be_false }
-      end
-    end
-
-    describe "level 2" do
-      context "two applications with only L1 features" do
-        let(:a1) { double }
-        let(:a2) { double }
-        before :each do
-          ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(a1)
-          ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(a2)
-        end
-        let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-        it do
-          a1.should_receive(:level_used?).with(2).and_return(false)
-          a2.should_receive(:level_used?).with(2).and_return(false)
-          page.level_used?(2).should be_false
-        end
-
-        context "L2 feature used on Page" do
-          before :each do
-            page.count = 2
-          end
-
-          it { page.level_used?(2).should be_true }
-        end
-      end
-
-      context "two applications with L2 features" do
-        let(:a1) { double }
-        let(:a2) { double }
-        before :each do
-          ATDIS::Application.should_receive(:interpret).with(:description => "application1").and_return(a1)
-          ATDIS::Application.should_receive(:interpret).with(:description => "application2").and_return(a2)
-        end
-        let(:page) { ATDIS::Page.new(:results => [{:description => "application1"}, {:description => "application2"}]) }
-
-        it "should ask the applications whether they have L2 features" do
-          a1.should_receive(:level_used?).with(2).and_return(true)
-          page.level_used?(2).should be_true
-        end
-      end
-    end
-  end
-
-  context "paging supported by vendor" do
-    context "read a from an invalid json string" do
-      let(:page) { ATDIS::Page.read_json(<<-EOF
-{
-  "response": [
-    {
-      "application": {
-        "description": "application2"
-      }      
-    }
-  ],
-}        
-       EOF
-        )}
-
-      it do
-        page.should_not be_valid
-        page.errors.messages.has_key?(:json).should be_true
-        page.errors.messages.count.should == 1
-        # The error messages returned by the library are different for different Ruby versions
-        ruby18_message = ATDIS::ErrorMessage['Invalid JSON: unexpected "}"', nil]
-        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
-        message = page.errors.messages[:json].first
-        (message == ruby18_message || message == ruby19_message || message == ruby20_message).should be_true
-      end
-    end
-
-    context "read from a json string" do
-      let(:page) { ATDIS::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
-        )}
-      it ".results" do
-        application1 = double("Application")
-        application2 = double("Application")
-        ATDIS::Application.should_receive(:interpret).with(:application => {:description => "application1"}).and_return(application1)
-        ATDIS::Application.should_receive(:interpret).with(:application => {:description => "application2"}).and_return(application2)
-
-        page.results.should == [application1, application2]
-      end
-
-      it ".next" do
-        expect { page.next }.to raise_error "Can't use next_url when loaded with read_json"
-      end
-    end
-
-    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
-  {
-    "response": [
-      {
-        "application": {
-          "description": "application1"
-        }     
-      },
-      {
-        "application": {
-          "description": "application2"
-        }      
-      }
-    ]
-  }
-        EOF
-        ))
-      end
-
-      let(:applications_results) { ATDIS::Page.read_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json") }
-
-      it ".results" do
-        application1 = double("Application")
-        application2 = double("Application")
-        ATDIS::Application.should_receive(:interpret).with(:application => {:description => "application1"}).and_return(application1)
-        ATDIS::Application.should_receive(:interpret).with(:application => {:description => "application2"}).and_return(application2)
-
-        applications_results.results.should == [application1, application2]
-      end
-
-      it ".next" do
-        applications_results.next.should be_nil
-      end
-
-      it ".previous_page_no" do
-        applications_results.previous_page_no.should be_nil
-      end
-
-      it ".next_page_no" do
-        applications_results.next_page_no.should be_nil
-      end
-
-      it ".current_page_no" do
-        applications_results.current_page_no.should be_nil
-      end
-
-      it ".no_results_per_page" do
-        applications_results.no_results_per_page.should be_nil
-      end
-
-      it ".total_no_results" do
-        applications_results.total_no_results.should be_nil
-      end
-
-      it ".total_no_pages" do
-        applications_results.total_no_pages.should 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
-      ))
-    end
-
-    let(:applications_results) { ATDIS::Page.read_url("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2") }
-
-    it ".previous_page_no" do
-      applications_results.previous_page_no.should == 1
-    end
-
-    it ".next_page_no" do
-      applications_results.next_page_no.should == 3
-    end
-
-    it ".current_page_no" do
-      applications_results.current_page_no.should == 2
-    end
-
-    it ".no_results_per_page" do
-      applications_results.no_results_per_page.should == 2
-    end
-
-    it ".total_no_results" do
-      applications_results.total_no_results.should == 50
-    end
-
-    it ".total_no_pages" do
-      applications_results.total_no_pages.should == 25
-    end
-
-    it ".next_url" do
-      applications_results.next_url.should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=3"
-    end
-
-    it ".next" do
-      n = double("Page")
-      applications_results
-      ATDIS::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.should == n
-    end
-  end
-end