atdis 0.2 → 0.3

data/lib/atdis/version.rb

@@ -1,3 +1,3 @@
 module Atdis
-  VERSION = "0.2"
+  VERSION = "0.3"
 end

data/spec/atdis/feed_spec.rb

@@ -1,40 +1,96 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe ATDIS::Feed do
-  let (:base_url_string) { "http://www.council.nsw.gov.au" }
-  let (:base_url) { URI.parse(base_url_string) }
+  let(:feed) { ATDIS::Feed.new("http://www.council.nsw.gov.au/atdis/1.0") }
+  let(:page) { double }
 
-  context "base_url passed as string" do
-    let(:feed) { ATDIS::Feed.new(base_url_string) }
+  it "should return all the applications" do
+    ATDIS::Models::Page.should_receive(:read_url).with("http://www.council.nsw.gov.au/atdis/1.0/applications.json").and_return(page)
+    feed.applications.should == page
+  end
+
+  it "should return all the applications" do
+    feed.applications_url.should == "http://www.council.nsw.gov.au/atdis/1.0/applications.json"
+  end
 
-    describe "#base_url" do
-      it { feed.base_url.should == base_url }
+  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"
     end
 
-    describe "#applications" do
-      it do
-        applications_results = double
-        ATDIS::Page.should_receive(:read_url).with(URI.parse("http://www.council.nsw.gov.au/atdis/1.0/applications.json")).and_return(applications_results)
-        feed.applications.should == applications_results
-      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"
+    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"
     end
   end
 
-  context "base_url passed as url" do
-    let(:feed) { ATDIS::Feed.new(base_url) }
+  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"
+    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"
+    end
 
-    describe "#base_url" do
-      it { feed.base_url.should == base_url }
+    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"
     end
   end
 
-  context "request for page 2" do
-    let(:feed) { ATDIS::Feed.new(base_url_string)}
+  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"
+    end
 
-    it "#applications" do
-        applications_results = double
-        ATDIS::Page.should_receive(:read_url).with(URI.parse("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2")).and_return(applications_results)
-        feed.applications(2).should == applications_results
+    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"
     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"
+  end
+
+  it "passing an invalid option" do
+    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 "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"
+    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 "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"}
+    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" }
+  end
+
+  describe "#application" do
+    it {
+      application = double
+      ATDIS::Models::Application.should_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
+    }
+  end
 end

data/spec/atdis/model_spec.rb

@@ -1,7 +1,67 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
+class ModelB < ATDIS::Model
+  set_field_mappings ({
+    bar: [String]
+  })
+end
+
+class ModelA < ATDIS::Model
+  set_field_mappings ({
+    bar:   [String],
+    hello: [ModelB]
+  })
+end
+
 describe ATDIS::Model do
-  describe ".cast" do 
+  describe ".attributes" do
+    it do
+      a = ModelA.new(bar: "foo")
+      a.attributes.should == {"bar" => "foo"}
+    end
+  end
+
+  describe "#json_errors" do
+    it "should return the json attribute with the errors" do
+      a = ModelA.interpret(bar: "Hello")
+      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"]]]]
+    end
+
+    it "should include the errors from child objects" do
+      a = ModelA.interpret(hello: {bar: "Kat"})
+      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"]]]]
+    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.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"]]]]
+    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"]]]]
+    end
+
+    it "should json errors even if value is nil" do
+      b = ModelB.new
+      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")]]]
+    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")}
@@ -24,147 +84,36 @@ describe ATDIS::Model do
     end
   end
 
-  describe ".map_field" do
-    let(:mappings) { { :foo => :bar, :a => :b, :info => { :foo => :bar2, :a => :b2, :c => :c2 } } }
-
-    context "one version of data" do
-      let(:data) { { :foo => 2, :a => 3, :d => 4, :info => { :foo => 2, :a => 3, :d => 4 } } }
-
-      it { ATDIS::Model.map_field(:bar, data, mappings).should == 2 }
-      it { ATDIS::Model.map_field(:b, data, mappings).should == 3 }
-      it { ATDIS::Model.map_field(:bar2, data, mappings).should == 2 }
-      it { ATDIS::Model.map_field(:b2, data, mappings).should == 3 }
-      it { ATDIS::Model.map_field(:c2, data, mappings).should be_nil }
-    end
-
-    context "another version of data" do
-      let(:data) { { :foo => 2, :a => 3, :d => 4 } }
-
-      it { ATDIS::Model.map_field(:bar, data, mappings).should == 2 }
-      it { ATDIS::Model.map_field(:b, data, mappings).should == 3 }
-      it { ATDIS::Model.map_field(:bar2, data, mappings).should be_nil }
-      it { ATDIS::Model.map_field(:b2, data, mappings).should be_nil }
-      it { ATDIS::Model.map_field(:c2, data, mappings).should be_nil }
-    end
-  end
-
-  describe ".unused_data" do
-    it do
-      ATDIS::Model.unused_data(
-      {
-        :foo => 2,
-        :a => 3,
-        :d => 4
-      },
-      {
-        :foo => :bar,
-        :a => :b
-      }).should ==
-      {
-        :d => 4
-      }
-    end
-
+  describe ".attribute_keys" do
     it do
-      ATDIS::Model.unused_data(
-      {
-        :foo => 2,
-        :a => 3,
-        :d => 4,
-        :info => {
-          :foo => 2,
-          :a => 3,
-          :d => 4
-        }
-      },
-      {
-        :foo => :bar,
-        :a => :b,
-        :info => {
-          :foo => :bar2,
-          :a => :b2
-        }
-      }).should ==
-      {
-        :d => 4,
-        :info => {
-          :d => 4
-        }
-      }
+      ATDIS::Model.attribute_types = {foo: String, a: Fixnum, info: String}
+      ATDIS::Model.attribute_keys.should == [:foo, :a, :info]
     end
   end
 
-  describe ".attribute_names_from_mappings" do
+  describe ".partition_by_used" do
     it do
-      # Doing this nastiness to support Ruby 1.8
-      h = ActiveSupport::OrderedHash.new
-      h[:foo] = :bar
-      h[:a] = :b
-      h2 = ActiveSupport::OrderedHash.new
-      h2[:foo] = :bar2
-      h2[:a] = :b2
-      h[:info] = h2
-      ATDIS::Model.attribute_names_from_mappings(h).should == [:bar, :b, :bar2, :b2]
+      ATDIS::Model.stub(:attribute_keys).and_return([:foo])
+      ATDIS::Model.partition_by_used({foo: 2}).should == [
+        {foo: 2}, {}
+      ]
     end
-  end
 
-  describe ".map_fields" do
     it do
-      ATDIS::Model.map_fields(
-      {
-        :foo => 2,
-        :a => 3,
-        :d => 4
-      },
-      {
-        :foo => :bar,
-        :a => :b
-      }).should ==
-      {
-        :bar => 2,
-        :b => 3,
-      }
+      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}
+      ]
     end
 
-    it do
-      ATDIS::Model.map_fields(
-      {
-        :foo => 2,
-        :a => 3,
-        :d => 4,
-        :info => {
-          :foo => 2,
-          :a => 3,
-          :d => 4
-        }
-      },
-      {
-        :foo => :bar,
-        :a => :b,
-        :info => {
-          :foo => :bar2,
-          :a => :b2
-        }
-      }).should ==
-      {
-        :bar => 2,
-        :b => 3,
-        :bar2 => 2,
-        :b2 => 3
-      }
-    end
-  end
-
-  describe "#json_attribute" do
-    let(:model) { ATDIS::Model.new }
-    let(:mapping) { {:previous => :previous_page_no, :next => :next_page_no, :foo => {:bar => :apple, :foo => :orange}} }
-
-    it "simple case" do
-      model.json_attribute(:previous_page_no, 12, mapping).should == {:previous => 12}
-    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 == [
+        {},
+        "hello"
+      ]
 
-    it "with recursion" do
-      model.json_attribute(:apple, 12, mapping).should == {:foo => {:bar => 12}}
     end
   end
 end

data/spec/atdis/models/address_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe ATDIS::Models::Address do
+  context "valid address" do
+    let(:a) { ATDIS::Models::Address.new(
+      street: "123 Fourfivesix Street",
+      suburb: "Neutral Bay",
+      postcode: "2780",
+      state: "NSW"
+    )}
+
+    it { a.should be_valid }
+
+    context "postcode that is too short" do
+      before(:each) { a.postcode = "278" }
+      it {
+        a.should_not be_valid
+        a.errors.messages.should == {postcode: [ATDIS::ErrorMessage.new("is not a valid postcode", "4.3.3")]}
+      }
+    end
+  end
+end

data/spec/atdis/models/application_spec.rb

@@ -0,0 +1,246 @@
+require "spec_helper"
+
+describe ATDIS::Models::Application do
+  context "extra parameter in json" do
+    it "should not be valid" do
+      ATDIS::Models::Location.should_receive(:interpret).with("location").and_return(double(valid?: true))
+      ATDIS::Models::Document.should_receive(:interpret).with("document").and_return(double(valid?: true))
+      ATDIS::Models::Event.should_receive(:interpret).with("event").and_return(double(valid?: true))
+
+      a = ATDIS::Models::Application.interpret(
+        info: {
+          dat_id: "DA2013-0381",
+          development_type: "residential",
+          application_type: "DA",
+          last_modified_date: "2013-04-20T02:01:07Z",
+          description: "New pool plus deck",
+          authority: {
+            ref:  "http://www.council.nsw.gov.au/atdis/1.0",
+            name: "Example Council Shire Council"
+          },
+          lodgement_date: "2013-04-20T02:01:07Z",
+          determination_date: "2013-06-20",
+          determination_type: "Pending",
+          status: "OPEN"
+        },
+        reference: {
+          more_info_url: "http://foo.com/bar"
+        },
+        # This is the extra parameter that shouldn't be here
+        foo: "bar",
+        locations: ["location"],
+        events: ["event"],
+        documents: ["document"]
+      )
+      a.should_not be_valid
+      a.errors.messages.should == {json: [ATDIS::ErrorMessage['Unexpected parameters in json data: {"foo":"bar"}', "4"]]}
+    end
+  end
+
+  describe ".interpret" do
+    it "should parse the json and create an application object" do
+      application = double
+
+      ATDIS::Models::Application.should_receive(:new).with(
+        info: {
+          dat_id: "DA2013-0381",
+          development_type: "residential",
+          last_modified_date: "2013-04-20T02:01:07Z",
+          description: "New pool plus deck",
+          authority: "Example Council Shire Council",
+          lodgement_date: "2013-04-20T02:01:07Z",
+          determination_date: "2013-06-20",
+          notification_start_date: "2013-04-20T02:01:07Z",
+          notification_end_date: "2013-05-20T02:01:07Z",
+          officer: "Ms Smith",
+          estimated_cost: "50,000",
+          status: "OPEN",
+        },
+        reference: {
+          more_info_url: "http://foo.com/bar",
+          comments_url: "http://foo.com/comment",
+        },
+        locations: [{ address: "123 Fourfivesix Street" }],
+        events: [ { id: "event1" }, { id: "event2" } ],
+        documents: [ { ref: "27B/6/a" }, { ref: "27B/6/b" } ],
+        people: [ { name: "Tuttle" }, { name: "Buttle" } ],
+        extended: {another_parameter: "with some value", anything: "can go here"},
+        json_left_overs: {}
+      ).and_return(application)
+
+      ATDIS::Models::Application.interpret(
+        info: {
+          dat_id: "DA2013-0381",
+          development_type: "residential",
+          last_modified_date: "2013-04-20T02:01:07Z",
+          description: "New pool plus deck",
+          authority: "Example Council Shire Council",
+          lodgement_date: "2013-04-20T02:01:07Z",
+          determination_date: "2013-06-20",
+          notification_start_date: "2013-04-20T02:01:07Z",
+          notification_end_date: "2013-05-20T02:01:07Z",
+          officer: "Ms Smith",
+          # TODO: In ATDIS-1.0.3 it does not specify whether this is a float or a string
+          # and whether to include (or not) AUD or dollar sign. For the time being we'll
+          # just assume it's a free-form string
+          estimated_cost: "50,000",
+          status: "OPEN"
+        },
+        reference: {
+          more_info_url: "http://foo.com/bar",
+          comments_url: "http://foo.com/comment"
+        },
+        locations: [{ address: "123 Fourfivesix Street" }],
+        events: [ { id: "event1" }, { id: "event2" } ],
+        documents: [ { ref: "27B/6/a" }, { ref: "27B/6/b" } ],
+        people: [ { name: "Tuttle" }, { name: "Buttle" } ],
+        extended: {another_parameter: "with some value", anything: "can go here"}
+      ).should == application
+    end
+
+    it "should create a nil valued application when there is no information in the json" do
+      application = double
+      ATDIS::Models::Application.should_receive(:new).with({json_left_overs:{}, info: {},
+        reference: {}}).and_return(application)
+
+      ATDIS::Models::Application.interpret(info: {}, reference: {}).should == application
+    end
+  end
+
+  describe "#extended" do
+    it "should do no typecasting" do
+      a = ATDIS::Models::Application.new(extended: {another_parameter: "with some value", anything: "can go here"})
+      a.extended.should == {another_parameter: "with some value", anything: "can go here"}
+    end
+  end
+
+  describe "#location=" do
+    let(:a) { ATDIS::Models::Application.new }
+    it "should type cast to a location" do
+      location = double
+      ATDIS::Models::Location.should_receive(:interpret).with(address: "123 Fourfivesix Street").and_return(location)
+      a.locations = [{ address: "123 Fourfivesix Street" }]
+      a.locations.should == [location]
+    end
+
+    it "should not cast when it's already a location" do
+      l = ATDIS::Models::Location.new
+      a.locations = [l]
+      a.locations.should == [l]
+    end
+  end
+
+  describe "#events" do
+    let(:a) { ATDIS::Models::Application.new }
+    it "should type cast to several events" do
+      event1, event2 = double, double
+      ATDIS::Models::Event.should_receive(:interpret).with(id: "event1").and_return(event1)
+      ATDIS::Models::Event.should_receive(:interpret).with(id: "event2").and_return(event2)
+      a.events = [ { id: "event1" }, { id: "event2" } ]
+      a.events.should == [event1, event2]
+    end
+  end
+
+  describe "#documents" do
+    let(:a) { ATDIS::Models::Application.new }
+    it "should type cast to several documents" do
+      document1, document2 = double, double
+      ATDIS::Models::Document.should_receive(:interpret).with(ref: "27B/6/a").and_return(document1)
+      ATDIS::Models::Document.should_receive(:interpret).with(ref: "27B/6/b").and_return(document2)
+      a.documents = [ { ref: "27B/6/a" }, { ref: "27B/6/b" } ]
+      a.documents.should == [document1, document2]
+    end
+  end
+
+  describe "#people" do
+    let(:a) { ATDIS::Models::Application.new }
+    it "should type cast to several people" do
+      tuttle, buttle = double, double
+      ATDIS::Models::Person.should_receive(:interpret).with(name: "Tuttle").and_return(tuttle)
+      ATDIS::Models::Person.should_receive(:interpret).with(name: "Buttle").and_return(buttle)
+      a.people = [ { name: "Tuttle" }, { name: "Buttle" } ]
+      a.people.should == [tuttle, buttle]
+    end
+  end
+
+  # TODO This should really be a test on the Model base class
+  describe "#attribute_names" do
+    it do
+      # These are also ordered in a way that corresponds to the specification. Makes for easy reading by humans.
+      ATDIS::Models::Application.attribute_names.should == [
+        "info",
+        "reference",
+        "locations",
+        "events",
+        "documents",
+        "people",
+        "extended"
+      ]
+    end
+  end
+
+  describe "validations" do
+    before :each do
+      ATDIS::Models::Location.should_receive(:interpret).with("address").and_return(double(valid?: true))
+      ATDIS::Models::Document.should_receive(:interpret).with("document").and_return(double(valid?: true))
+      ATDIS::Models::Event.should_receive(:interpret).with("event").and_return(double(valid?: true))
+    end
+
+    let(:a) { ATDIS::Models::Application.new(
+      info: 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",
+      ),
+      reference: ATDIS::Models::Reference.new(
+        more_info_url: URI.parse("http://foo.com/bar"),
+      ),
+      locations: ["address"],
+      events: ["event"],
+      documents: ["document"]
+  ) }
+
+    it { a.should be_valid }
+
+    describe ".location" do
+      it "should not be valid if the location is not valid" do
+        l = double(valid?: false)
+        ATDIS::Models::Location.should_receive(:interpret).with(foo: "some location data").and_return(l)
+        a.locations = [{foo: "some location data"}]
+        a.should_not be_valid
+      end
+    end
+
+    describe "events" do
+      it "has to be an array" do
+        ATDIS::Models::Event.should_receive(:interpret).with(foo: "bar").and_return(double(valid?: true))
+        a.events = {foo: "bar"}
+        #a.events.should be_nil
+        a.should_not be_valid
+        a.errors.messages.should == {events: [ATDIS::ErrorMessage["should be an array", "4.3"]]}
+      end
+
+      it "can not be an empty array" do
+        a.events = []
+        a.should_not be_valid
+        a.errors.messages.should == {events: [ATDIS::ErrorMessage.new("should not be an empty array", "4.3")]}
+      end
+
+      it "can not be empty" do
+        a.events = nil
+        a.should_not be_valid
+        a.errors.messages.should == {events: [ATDIS::ErrorMessage["can't be blank", "4.3"]]}
+      end
+    end
+  end
+end