atdis 0.3.13 → 0.4.0

data/spec/atdis/models/authority_spec.rb

@@ -1,33 +1,63 @@
+# frozen_string_literal: true
+
 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}
+      let(:a) do
+        ATDIS::Models::Authority.new(
+          {
+            ref: "http://www.council.nsw.gov.au/atdis/1.0",
+            name: "Council"
+          },
+          "UTC"
+        )
+      end
+      it { expect(a).to 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}
+      let(:a) do
+        ATDIS::Models::Authority.new(
+          {
+            ref: "https://www.council.nsw.gov.au/atdis/1.0",
+            name: "Council"
+          },
+          "UTC"
+        )
+      end
+      it { expect(a).to 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")
-        ]}
-      }
+      let(:a) { ATDIS::Models::Authority.new({ ref: "foobar", name: "Council" }, "UTC") }
+      it do
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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
     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")}
+      let(:a) do
+        ATDIS::Models::Authority.new(
+          {
+            ref: "http://www.council.nsw.gov.au/foobar",
+            name: "Council"
+          },
+          "UTC"
+        )
+      end
       it {
-        a.should_not be_valid
-        a.errors.messages.should == {ref: [ATDIS::ErrorMessage.new("is not a valid Unique Authority Identifier", "4.3.1")]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          ref: [ATDIS::ErrorMessage.new("is not a valid Unique Authority Identifier", "4.3.1")]
+        )
       }
     end
   end

data/spec/atdis/models/document_spec.rb

@@ -1,19 +1,25 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe ATDIS::Models::Document do
   it ".attribute_names" do
-    ATDIS::Models::Document.attribute_names.should == ["ref", "title", "document_url"]
+    expect(ATDIS::Models::Document.attribute_names).to eq %w[ref title document_url]
   end
 
   it ".ref" do
-    ATDIS::Models::Document.interpret(ref: "27B/6").ref.should == "27B/6"
+    expect(ATDIS::Models::Document.interpret({ ref: "27B/6" }, "UTC").ref).to eq "27B/6"
   end
 
   it ".title" do
-    ATDIS::Models::Document.interpret(title: "Authorisation for Repairs").title.should == "Authorisation for Repairs"
+    expect(
+      ATDIS::Models::Document.interpret({ title: "Authorisation for Repairs" }, "UTC").title
+    ).to eq "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")
+    expect(
+      ATDIS::Models::Document.interpret({ document_url: "http://foo.com/bar" }, "UTC").document_url
+    ).to eq URI.parse("http://foo.com/bar")
   end
 end

data/spec/atdis/models/event_spec.rb

@@ -1,38 +1,50 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe ATDIS::Models::Event do
   it ".attribute_names" do
-    ATDIS::Models::Event.attribute_names.should == ["id", "timestamp", "description", "event_type", "status"]
+    expect(ATDIS::Models::Event.attribute_names).to eq(
+      %w[id timestamp description event_type status]
+    )
   end
 
   it ".id" do
-    ATDIS::Models::Event.interpret(id: "27B/6").id.should == "27B/6"
+    expect(ATDIS::Models::Event.interpret({ id: "27B/6" }, "UTC").id).to eq "27B/6"
   end
 
   describe ".date" do
     it do
-      ATDIS::Models::Event.interpret(timestamp: "2013-06-18").timestamp.should == DateTime.new(2013,6,18)
+      expect(ATDIS::Models::Event.interpret({ timestamp: "2013-06-18" }, "UTC").timestamp).to eq(
+        DateTime.new(2013, 6, 18)
+      )
     end
 
     it do
-      e = ATDIS::Models::Event.new(description: "Something", id: "27B/6")
+      e = ATDIS::Models::Event.new({ description: "Something", id: "27B/6" }, "UTC")
       e.timestamp = "18 January 2013"
-      e.should_not be_valid
-      e.errors.messages.should == {timestamp: [ATDIS::ErrorMessage["is not a valid date", "4.3.8"]]}
+      expect(e).to_not be_valid
+      expect(e.errors.messages).to eq(
+        timestamp: [ATDIS::ErrorMessage["is not a valid date", "4.3.8"]]
+      )
     end
   end
 
   it ".description" do
-    ATDIS::Models::Event.interpret(description: "A very fine event").description.should == "A very fine event"
+    expect(
+      ATDIS::Models::Event.interpret({ description: "A very fine event" }, "UTC").description
+    ).to eq "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"
+    # TODO: Is event_type always a string? ATDIS-1.0.3 doesn't say
+    expect(
+      ATDIS::Models::Event.interpret({ event_type: "approval" }, "UTC").event_type
+    ).to eq "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"
+    # TODO: Is status always a string? ATDIS-1.0.3 doesn't say
+    expect(ATDIS::Models::Event.interpret({ status: "approved" }, "UTC").status).to eq "approved"
   end
 end

data/spec/atdis/models/info_spec.rb

@@ -1,232 +1,291 @@
+# frozen_string_literal: true
+
 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",
-  )}
+  let(:a) do
+    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"
+      },
+      "UTC"
+    )
+  end
 
   describe "determination_type" do
     context "is missing" do
-      before(:each) { a.determination_type = nil}
+      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")]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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 }
+      it { expect(a).to 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")]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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
+      a.notification_start_date = DateTime.new(2013, 4, 20, 2, 1, 7)
+      a.notification_end_date = DateTime.new(2013, 5, 20, 0, 0, 0)
+      expect(a).to 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"]]}
+      a.notification_end_date = DateTime.new(2013, 2, 1, 0, 0, 0)
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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_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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      a.notification_start_date = DateTime.new(2013, 4, 20, 2, 1, 7)
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      a.notification_end_date = DateTime.new(2013, 4, 20, 2, 1, 7)
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      a.notification_start_date = DateTime.new(2013, 5, 20, 0, 0, 0)
+      a.notification_end_date = DateTime.new(2013, 4, 20, 2, 1, 7)
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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
+      expect(a.notification_start_date).to be_nil
+      expect(a.notification_end_date).to be_nil
+      expect(a).to 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"]]}
+      a.notification_end_date = DateTime.new(2013, 2, 1, 0, 0, 0)
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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_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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(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
+      expect(a).to be_valid
     end
     it do
       a.determination_date = "2013-01-18"
-      a.should be_valid
+      expect(a).to be_valid
     end
     it do
       a.determination_date = "2013-18-01"
-      a.should_not be_valid
-      a.errors.messages.should == {determination_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        determination_date: [ATDIS::ErrorMessage["is not a valid date", "4.3.1"]]
+      )
     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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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
+      expect(a.determination_date).to be_nil
+      expect(a).to 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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        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"]]}
+      expect(a).to_not be_valid
+      expect(a.errors.messages).to eq(
+        dat_id: [ATDIS::ErrorMessage["should be url encoded", "4.3.1"]]
+      )
     end
 
     it "should be valid if url encoded" do
       a.dat_id = "010%2F2014%2F00000031%2F001"
-      a.should be_valid
+      expect(a).to be_valid
     end
   end
 
   describe "#description=" do
-    let(:a) { ATDIS::Models::Info.new }
+    let(:a) { ATDIS::Models::Info.new({}, "UTC") }
     it "should do not type casting when it's already a String" do
       a.description = "foo"
-      a.description.should == "foo"
+      expect(a.description).to eq "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"
+        expect(a.description).to eq "123"
       end
       it "should keep the original value" do
-        a.description_before_type_cast.should == 123
+        expect(a.description_before_type_cast).to eq 123
       end
     end
   end
 
   describe "#lodgement_date=" do
-    let(:a) { ATDIS::Models::Info.new }
+    let(:a) { ATDIS::Models::Info.new({}, "UTC") }
     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)
+      a.lodgement_date = DateTime.new(2013, 1, 1)
+      expect(a.lodgement_date).to eq 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)
+      expect(a.lodgement_date).to eq DateTime.new(2013, 1, 1)
     end
 
     context "not a valid date" do
@@ -234,24 +293,24 @@ describe ATDIS::Models::Info do
         a.lodgement_date = "2013/01/01"
       end
       it "should be nil" do
-        a.lodgement_date.should be_nil
+        expect(a.lodgement_date).to be_nil
       end
       it "should keep the original string" do
-        a.lodgement_date_before_type_cast.should == "2013/01/01"
+        expect(a.lodgement_date_before_type_cast).to eq "2013/01/01"
       end
     end
   end
 
   describe "#last_modified_date=" do
-    let(:a) { ATDIS::Models::Info.new }
+    let(:a) { ATDIS::Models::Info.new({}, "UTC") }
     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)
+      a.last_modified_date = DateTime.new(2013, 1, 1)
+      expect(a.last_modified_date).to eq 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)
+      expect(a.last_modified_date).to eq DateTime.new(2013, 1, 1)
     end
 
     context "not a valid date" do
@@ -259,10 +318,10 @@ describe ATDIS::Models::Info do
         a.last_modified_date = "2013/01/01"
       end
       it "should be nil" do
-        a.last_modified_date.should be_nil
+        expect(a.last_modified_date).to be_nil
       end
       it "should keep the original string" do
-        a.last_modified_date_before_type_cast.should == "2013/01/01"
+        expect(a.last_modified_date_before_type_cast).to eq "2013/01/01"
       end
     end
   end
@@ -270,47 +329,63 @@ describe ATDIS::Models::Info do
   describe "related_apps" do
     context "is missing" do
       before(:each) { a.related_apps = nil }
-      it { a.should be_valid }
+      it { expect(a).to 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"}
+      before(:each) do
+        a.related_apps = "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json"
+      end
       it {
-        a.should_not be_valid
-        a.errors.messages.should == {related_apps: [ATDIS::ErrorMessage.new("should be an array", "4.3.1")]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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 }
+      before(:each) do
+        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"
+        ]
+      end
+      it { expect(a).to 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"
-      ]}
+      before(:each) do
+        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"
+        ]
+      end
       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")]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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"
-      ]}
+      before(:each) do
+        a.related_apps = [
+          "http://www.council.nsw.gov.au/atdis/1.0/2014_20-022DA.json",
+          "foobar"
+        ]
+      end
       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")
-        ]}
+        expect(a).to_not be_valid
+        expect(a.errors.messages).to eq(
+          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