govuk_content_models 6.0.2

data/test/models/fact_check_address_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+require "fact_check_address"
+
+class FactCheckAddressTest < ActiveSupport::TestCase
+
+  setup do
+    dummy_plek = mock do
+      stubs(:find).with("publisher").returns("publisher.wibble.alphagov.co.uk")
+    end
+    Plek.stubs(:current).returns(dummy_plek)
+  end
+
+  test "can tell if an address is valid" do
+    service = FactCheckAddress.new
+    address = service.for_edition(Edition.new)
+    assert service.valid_address?(address), "Address should be valid but isn't"
+  end
+
+  test "can tell if an address is invalid" do
+    service = FactCheckAddress.new
+    address = "factcheck+notwibble-abde@alphagov.co.uk"
+    refute service.valid_address?(address), "Address should be invalid but isn't"
+  end
+
+  test "can extract edition ID from an address" do
+    service = FactCheckAddress.new
+    address = "factcheck+wibble-abde@alphagov.co.uk"
+    assert_equal "abde", service.edition_id_from_address(address)
+  end
+
+  test "can generate an address from an edition" do
+    service = FactCheckAddress.new
+    e = Edition.new
+    assert_match /#{e.id}/, service.for_edition(e)
+  end
+end

data/test/models/help_page_edition_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class HelpPageEditionTest < ActiveSupport::TestCase
+  setup do
+    @artefact = FactoryGirl.create(:artefact, :kind => 'help_page', :slug => "help/foo")
+  end
+
+  should "have correct extra fields" do
+    h = FactoryGirl.build(:help_page_edition, :panopticon_id => @artefact.id)
+    h.body = "I'm a help page."
+    h.safely.save!
+
+    h = HelpPageEdition.first
+    assert_equal "I'm a help page.", h.body
+  end
+
+  should "give a friendly (legacy supporting) description of its format" do
+    help_page = HelpPageEdition.new
+    assert_equal "HelpPage", help_page.format
+  end
+
+  should "return the body as whole_body" do
+    h = FactoryGirl.build(:help_page_edition,
+                          :panopticon_id => @artefact.id,
+                          :body => "Something")
+    assert_equal h.body, h.whole_body
+  end
+
+  should "clone extra fields when cloning edition" do
+    help_page = FactoryGirl.create(:help_page_edition,
+                               :panopticon_id => @artefact.id,
+                               :state => "published",
+                               :body => "I'm very helpful")
+
+    new_help_page = help_page.build_clone
+    assert_equal help_page.body, new_help_page.body
+  end
+end

data/test/models/licence_edition_test.rb

@@ -0,0 +1,104 @@
+require_relative '../test_helper'
+
+class LicenceEditionTest < ActiveSupport::TestCase
+  def setup
+    @artefact = FactoryGirl.create(:artefact)
+  end
+
+  should "have correct extra fields" do
+    l = FactoryGirl.build(:licence_edition, panopticon_id: @artefact.id)
+    l.licence_identifier = "AB1234"
+    l.licence_short_description = "Short description of licence"
+    l.licence_overview = "Markdown overview of licence..."
+    l.will_continue_on = "The HMRC website"
+    l.continuation_link = "http://www.hmrc.gov.uk"
+    l.safely.save!
+
+    l = LicenceEdition.first
+    assert_equal "AB1234", l.licence_identifier
+    assert_equal "Short description of licence", l.licence_short_description
+    assert_equal "Markdown overview of licence...", l.licence_overview
+    assert_equal "The HMRC website", l.will_continue_on
+    assert_equal "http://www.hmrc.gov.uk", l.continuation_link
+  end
+
+  context "validations" do
+    setup do
+      @l = FactoryGirl.build(:licence_edition, panopticon_id: @artefact.id)
+    end
+
+    should "require a licence identifier" do
+      @l.licence_identifier = ''
+      assert_equal false, @l.valid?, "expected licence edition not to be valid"
+    end
+
+    context "licence identifier uniqueness" do
+      should "require a unique licence identifier" do
+        artefact2 = FactoryGirl.create(:artefact)
+        FactoryGirl.create(:licence_edition, :licence_identifier => "wibble", panopticon_id: artefact2.id)
+        @l.licence_identifier = "wibble"
+        assert ! @l.valid?, "expected licence edition not to be valid"
+      end
+
+      should "not consider archived editions when evaluating uniqueness" do
+        artefact2 = FactoryGirl.create(:artefact)
+        FactoryGirl.create(:licence_edition, :licence_identifier => "wibble", panopticon_id: artefact2.id, :state => "archived")
+        @l.licence_identifier = "wibble"
+        assert @l.valid?, "expected licence edition to be valid"
+      end
+    end
+
+    should "not require a unique licence identifier for different versions of the same licence edition" do
+      @l.state = 'published'
+      @l.licence_identifier = 'wibble'
+      @l.save!
+
+      new_version = @l.build_clone
+      assert_equal 'wibble', new_version.licence_identifier
+      assert new_version.valid?, "Expected clone to be valid"
+    end
+    
+    should "not validate the continuation link when blank" do
+      @l.continuation_link = ""
+      assert @l.valid?, "continuation link validation should not be triggered when the field is blank"
+    end
+    should "fail validation when the continuation link has an invalid url" do
+      @l.continuation_link = "not&a+valid_url"
+      assert !@l.valid?, "continuation link validation should fail with a invalid url"
+    end
+    should "pass validation with a valid continuation link url" do
+      @l.continuation_link = "http://www.hmrc.gov.uk"
+      assert @l.valid?, "continuation_link validation should pass with a valid url"
+    end
+  end
+
+  should "clone extra fields when cloning edition" do
+    licence = FactoryGirl.create(:licence_edition,
+                                 :panopticon_id => @artefact.id,
+                                 :state => "published",
+                                 :licence_identifier => "1234",
+                                 :licence_short_description => "Short description of licence",
+                                 :licence_overview => "Overview to be cloned",
+                                 :will_continue_on => "Continuation text to be cloned",
+                                 :continuation_link => "http://www.gov.uk")
+    new_licence = licence.build_clone
+
+    assert_equal licence.licence_identifier, new_licence.licence_identifier
+    assert_equal licence.licence_short_description, new_licence.licence_short_description
+    assert_equal licence.licence_overview, new_licence.licence_overview
+    assert_equal licence.will_continue_on, new_licence.will_continue_on
+    assert_equal licence.continuation_link, new_licence.continuation_link
+  end
+
+  context "indexable_content" do
+    should "include the licence_overview, removing markup" do
+      licence = FactoryGirl.create(:licence_edition, licence_overview: "## Overview")
+      assert_equal "Overview", licence.indexable_content
+    end
+
+    should "include the licence_short_description" do
+      licence = FactoryGirl.create(:licence_edition, licence_short_description: "Short desc")
+      assert_equal "Short desc", licence.indexable_content
+    end
+  end
+end

data/test/models/local_authority_test.rb

@@ -0,0 +1,113 @@
+require_relative "../test_helper"
+
+describe LocalAuthority do
+  before :each do
+    LocalAuthority.delete_all
+  end
+
+  it "should create an authority with correct field types" do
+    # Although it may seem overboard, this test is helpful to confirm
+    # the correct field types are being used on the model
+    LocalAuthority.create!(
+                  name: "Example",
+                  snac: "AA00",
+                  local_directgov_id: 1,
+                  tier: "county",
+                  contact_address: ["Line one", "line two", "line three"],
+                  contact_url: "http://example.gov/contact",
+                  contact_phone: "0000000000",
+                  contact_email: "contact@example.gov")
+    authority = LocalAuthority.first
+    assert_equal "Example", authority.name
+    assert_equal "AA00", authority.snac
+    assert_equal 1, authority.local_directgov_id
+    assert_equal "county", authority.tier
+    assert_equal ["Line one", "line two", "line three"], authority.contact_address
+    assert_equal "http://example.gov/contact", authority.contact_url
+    assert_equal "0000000000", authority.contact_phone
+    assert_equal "contact@example.gov", authority.contact_email
+  end
+
+  describe "validating local_interactions" do
+    before :each do
+      @authority = FactoryGirl.create(:local_authority)
+    end
+
+    it "should require a lgsl_code and lgil_code" do
+      li = @authority.local_interactions.build
+      refute li.valid?
+      assert_equal ["can't be blank"], li.errors[:lgsl_code]
+      assert_equal ["can't be blank"], li.errors[:lgil_code]
+    end
+
+    it "should not allow duplicate lgsl/lgil pairs" do
+      li1 = @authority.local_interactions.create!(:lgsl_code => 42, :lgil_code => 8, :url => "http://www.example.com/one")
+      li2 = @authority.local_interactions.build(:lgsl_code => 42, :lgil_code => 8, :url => "http://www.example.com/two")
+
+      refute li2.valid?
+      assert_equal ["is already taken"], li2.errors[:lgil_code]
+
+      li2.lgil_code = 3
+      assert li2.valid?
+    end
+
+    it "should only validate uniqueness within the authority" do
+      authority2 = FactoryGirl.create(:local_authority)
+      li1 = @authority.local_interactions.create!(:lgsl_code => 42, :lgil_code => 8, :url => "http://www.example.com/one")
+      li2 = authority2.local_interactions.build(:lgsl_code => 42, :lgil_code => 8, :url => "http://www.example.com/two")
+
+      assert li2.valid?
+    end
+  end
+
+  describe "preferred_interaction_for" do
+    before :each do
+      @authority = FactoryGirl.create(:local_authority)
+      @lgsl_code = "142"
+    end
+
+    describe "with no LIGL specified" do
+      it "should return the lowest LGIL that's not 8" do
+        @interaction1 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 12)
+        @interaction2 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION)
+        @interaction3 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 9)
+
+        assert_equal @interaction3, @authority.preferred_interaction_for(@lgsl_code)
+      end
+
+      it "should return LGIL 8 if there are no others" do
+        @interaction2 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION)
+
+        assert_equal @interaction2, @authority.preferred_interaction_for(@lgsl_code)
+      end
+    end
+
+    describe "with an LGIL specified" do
+      it "should return the interaction for the specified LGIL" do
+        @interaction1 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 12)
+        @interaction2 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION)
+        @interaction3 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 9)
+
+        assert_equal @interaction2, @authority.preferred_interaction_for(@lgsl_code, 8)
+      end
+
+      it "should return nil if there is no interaction with the specified LGIL" do
+        @interaction1 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 12)
+        @interaction2 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION)
+        @interaction3 = FactoryGirl.create(:local_interaction, :local_authority => @authority, :lgsl_code => @lgsl_code,
+                                           :lgil_code => 9)
+
+        assert_equal nil, @authority.preferred_interaction_for(@lgsl_code, 3)
+      end
+    end
+  end
+end

data/test/models/local_service_test.rb

@@ -0,0 +1,199 @@
+require "test_helper"
+require "govuk_content_models/test_helpers/local_services"
+
+class LocalServiceTest < ActiveSupport::TestCase
+  include LocalServicesHelper
+
+  def create_service_for_tiers(*tiers)
+    @service = LocalService.create!(
+      lgsl_code:      @lgsl_code,
+      providing_tier: tiers.map(&:to_s)
+    )
+  end
+
+  def setup
+    LocalAuthority.delete_all
+    @lgsl_code = 123
+    @snac_code = "AA00"
+    @county_council = FactoryGirl.create(
+      :local_authority,
+      tier: "county",
+      snac: "AA00"
+    )
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: @county_council,
+      lgsl_code:       @lgsl_code,
+      url:             "http://some.county.council.gov/do-123.html"
+    )
+    @district_council = FactoryGirl.create(
+      :local_authority,
+      tier: "district",
+      snac: "AA"
+    )
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: @district_council,
+      lgsl_code:       @lgsl_code,
+      url:             "http://some.district.council.gov/do-123.html"
+    )
+    @unitary_authority = FactoryGirl.create(
+      :local_authority,
+      tier: "unitary",
+      snac: "BB00"
+    )
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: @unitary_authority,
+      lgsl_code:       @lgsl_code,
+      url:             "http://some.unitary.council.gov/do-123.html"
+    )
+  end
+
+  test "should return county URL for county/UA service in county" do
+    service = create_service_for_tiers(:county, :unitary)
+    councils = [@county_council.snac, @district_council.snac]
+    assert_equal "http://some.county.council.gov/do-123.html",
+                 service.preferred_interaction(councils).url
+  end
+
+  test "should return UA URL for county/UA service in UA" do
+    service = create_service_for_tiers(:county, :unitary)
+    councils = [@unitary_authority.snac]
+    assert_equal "http://some.unitary.council.gov/do-123.html",
+                 service.preferred_interaction(councils).url
+  end
+
+  test "should return nil for county/UA service in district" do
+    service = create_service_for_tiers(:county, :unitary)
+    councils = [@district_council.snac]
+    assert_nil service.preferred_interaction(councils)
+  end
+
+  test "should allow overriding returned LGIL" do
+    FactoryGirl.create(:local_interaction,
+      local_authority: @county_council,
+      lgsl_code:       @lgsl_code,
+      lgil_code:       12,
+      url:             "http://some.county.council.gov/do-456.html"
+    )
+    service = create_service_for_tiers(:county, :unitary)
+    councils = [@county_council.snac, @district_council.snac]
+    assert_equal "http://some.county.council.gov/do-456.html",
+                 service.preferred_interaction(councils, 12).url
+  end
+
+  test "should not list a county (in a UA) as providing a service it does not provide" do
+    service = create_service_for_tiers(:county, :unitary)
+    other_service = service.lgsl_code.to_i + 1
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: @county_council,
+      lgsl_code:       other_service
+    )
+    authority = FactoryGirl.create(
+      :local_authority,
+      tier: "county",
+      snac: "CC00"
+    )
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: authority,
+      lgsl_code:       other_service
+    )
+
+    refute_includes service.provided_by.map(&:snac), "CC00"
+  end
+
+  test "should not list a UA as providing a service it does not provide" do
+    service = create_service_for_tiers(:county, :unitary)
+    other_service = service.lgsl_code.to_i + 1
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: @county_council,
+      lgsl_code:       other_service
+    )
+    authority = FactoryGirl.create(
+      :local_authority,
+      tier: "unitary",
+      snac: "CC01"
+    )
+    FactoryGirl.create(
+      :local_interaction,
+      local_authority: authority,
+      lgsl_code:       other_service
+    )
+
+    refute_includes service.provided_by.map(&:snac), "CC01"
+  end
+
+  test "should list a county (in a UA) that provides a service" do
+    service = create_service_for_tiers(:county, :unitary)
+    assert_includes service.provided_by.map(&:snac), @county_council.snac
+  end
+
+  test "should list a UA that provides a service" do
+    service = create_service_for_tiers(:county, :unitary)
+    assert_includes service.provided_by.map(&:snac), @unitary_authority.snac
+  end
+
+  test "should return district URL for district/UA service in county/district" do
+    service = create_service_for_tiers(:district, :unitary)
+    councils = [@county_council.snac, @district_council.snac]
+    assert_equal "http://some.district.council.gov/do-123.html",
+                 service.preferred_interaction(councils).url
+  end
+
+  test "should return UA URL for district/UA service in UA" do
+    service = create_service_for_tiers(:district, :unitary)
+    councils = [@unitary_authority.snac]
+    assert_match "http://some.unitary.council.gov/do-123.html",
+                 service.preferred_interaction(councils).url
+  end
+
+  test "should return nil for district/UA service in county" do
+    service = create_service_for_tiers(:district, :unitary)
+    councils = [@county_council.snac]
+    assert_nil service.preferred_interaction(councils)
+  end
+
+  test "should list only districts and UAs as providers" do
+    service = create_service_for_tiers(:district, :unitary)
+    providers = service.provided_by
+    assert_equal 2, providers.length
+    assert_includes providers.map(&:snac), @district_council.snac
+    assert_includes providers.map(&:snac), @unitary_authority.snac
+  end
+
+  test "should return district URL for both-tier service in county/district" do
+    service = create_service_for_tiers("district", "unitary", "county")
+    councils = [@county_council.snac, @district_council.snac]
+    url = service.preferred_interaction(councils).url
+    assert_equal "http://some.district.council.gov/do-123.html", url
+  end
+
+  test "should return UA URL for both-tier service in UA" do
+    service = create_service_for_tiers("district", "unitary", "county")
+    councils = [@unitary_authority.snac]
+    url = service.preferred_interaction(councils).url
+    assert_equal "http://some.unitary.council.gov/do-123.html", url
+  end
+
+  # This shouldn't really ever happen and suggests that the data
+  # is incorrect somehow, but we might as well fall back to county council
+  test "should return county URL for both-tier service in county" do
+    service = create_service_for_tiers("district", "unitary", "county")
+    councils = [@county_council.snac]
+    url = service.preferred_interaction(councils).url
+    assert_equal "http://some.county.council.gov/do-123.html", url
+  end
+
+  test "should list all authorities providing a both-tier service" do
+    service = create_service_for_tiers("district", "unitary", "county")
+    make_authority("county", snac: "CC00", lgsl: 124)
+    providers = service.provided_by
+    assert_includes providers.map(&:snac), @district_council.snac
+    assert_includes providers.map(&:snac), @unitary_authority.snac
+    assert_includes providers.map(&:snac), @county_council.snac
+  end
+end