govuk_content_models 6.0.2

data/test/models/local_transaction_edition_test.rb

@@ -0,0 +1,78 @@
+require "test_helper"
+require "govuk_content_models/test_helpers/local_services"
+
+class LocalTransactionEditionTest < ActiveSupport::TestCase
+  include LocalServicesHelper
+  def setup
+    @artefact = FactoryGirl.create(:artefact)
+  end
+
+  test "should report that an authority provides a service" do
+    bins_transaction = LocalTransactionEdition.new(
+      lgsl_code:     "bins",
+      title:         "Transaction",
+      slug:          "slug",
+      panopticon_id: @artefact.id
+    )
+    county_council = make_authority_providing("bins")
+    assert bins_transaction.service_provided_by?(county_council.snac)
+  end
+
+  test "should report that an authority does not provide a service" do
+    bins_transaction = LocalTransactionEdition.new(
+      lgsl_code:     "bins",
+      title:         "Transaction",
+      slug:          "slug",
+      panopticon_id: @artefact.id
+    )
+    county_council = make_authority_providing("housing-benefit")
+    refute bins_transaction.service_provided_by?(county_council.snac)
+  end
+
+  test "should be a transaction search format" do
+    bins_transaction = LocalTransactionEdition.new(
+      lgsl_code:     "bins",
+      title:         "Transaction",
+      slug:          "slug",
+      panopticon_id: @artefact.id
+    )
+    assert_equal "transaction", bins_transaction.search_format
+  end
+
+
+  test "should validate on save that a LocalService exists for that lgsl_code" do
+    s = LocalService.create!(lgsl_code: "bins", providing_tier: %w{county unitary})
+
+    lt = LocalTransactionEdition.new(lgsl_code: "nonexistent", title: "Foo", slug: "foo", panopticon_id: @artefact.id)
+    lt.save
+    assert !lt.valid?
+
+    lt = LocalTransactionEdition.new(lgsl_code: s.lgsl_code, title: "Bar", slug: "bar", panopticon_id: @artefact.id)
+    lt.save
+    assert lt.valid?
+    assert lt.persisted?
+  end
+
+  test "should create a diff between the versions when publishing a new version" do
+    make_service(149, %w{county unitary})
+    edition_one = LocalTransactionEdition.new(title: "Transaction", slug: "transaction", lgsl_code: "149", panopticon_id: @artefact.id)
+    user = User.create name: "Thomas"
+
+    edition_one.introduction = "Test"
+    edition_one.state = :ready
+    edition_one.save!
+
+    user.publish edition_one, comment: "First edition"
+
+    edition_two = edition_one.build_clone
+    edition_two.introduction = "Testing"
+    edition_two.state = :ready
+    edition_two.save!
+
+    user.publish edition_two, comment: "Second edition"
+
+    publish_action = edition_two.actions.where(request_type: "publish").last
+
+    assert_equal "{\"Test\" >> \"Testing\"}", publish_action.diff
+  end
+end

data/test/models/overview_dashboard_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class OverviewDashboardTest < ActiveSupport::TestCase
+
+  test "Can create and retrieve dashboard overview objects" do
+    overview = create_test_overview
+
+    assert_equal overview.dashboard_type, "Format"
+    assert_equal overview.result_group, "Guide"
+    check_status_equal overview, row_status
+  end
+
+private
+  def create_test_overview
+    overview = OverviewDashboard.create dashboard_type: "Format", result_group: "Guide"
+
+    row_status.each do |k, v|
+      overview[k] = v
+    end
+
+    overview.save
+
+    found_overviews = OverviewDashboard.where(dashboard_type:  "Format")
+    assert_equal found_overviews.size, 1
+    found_overviews.first
+  end
+
+  def row_status
+    {
+      lined_up: 1,
+      draft: 1,
+      ammends_needed: 1,
+      in_review: 1,
+      ready: 1,
+      fact_check_recieved: 1,
+      fact_check: 1,
+      published: 1,
+      archived: 1
+    }
+  end
+
+  def check_status_equal(actual_object, expected_hash)
+    expected_hash.each do |k, v|
+      assert_equal actual_object[k], expected_hash[k]
+    end
+  end
+end

data/test/models/simple_smart_answer_edition_test.rb

@@ -0,0 +1,169 @@
+require "test_helper"
+
+class SimpleSmartAnswerEditionTest < ActiveSupport::TestCase
+  setup do
+    @artefact = FactoryGirl.create(:artefact)
+  end
+
+  should "be created with valid nodes" do
+    edition = FactoryGirl.build(:simple_smart_answer_edition, panopticon_id: @artefact.id)
+    edition.body = "This is a simple smart answer."
+
+    edition.nodes.build(:slug => "question1", :title => "You approach two locked doors. Which do you choose?", :kind => "question", :order => 1)
+    edition.nodes.build(:slug => "left", :title => "As you open the door, a lion bursts out and mauls you to death.", :order => 2, :kind => "outcome")
+    edition.nodes.build(:slug => "right", :title => "As you open the door, a tiger bursts out and mauls you to death.", :order => 3, :kind => "outcome")
+    edition.save!
+
+    edition = SimpleSmartAnswerEdition.first
+
+    assert_equal "This is a simple smart answer.", edition.body
+    assert_equal 3, edition.nodes.count
+    assert_equal ["question1", "left", "right"], edition.nodes.all.map(&:slug)
+  end
+
+  should "copy the body and nodes when cloning an edition" do
+    edition = FactoryGirl.create(:simple_smart_answer_edition,
+      panopticon_id: @artefact.id,
+      body: "This smart answer is somewhat unique and calls for a different kind of introduction",
+      state: "published"
+    )
+    edition.nodes.build(:slug => "question1", :title => "You approach two open doors. Which do you choose?", :kind => "question", :order => 1)
+    edition.nodes.build(:slug => "left", :title => "As you wander through the door, it slams shut behind you, as a lion starts pacing towards you...", :order => 2, :kind => "outcome")
+    edition.nodes.build(:slug => "right", :title => "As you wander through the door, it slams shut behind you, as a tiger starts pacing towards you...", :order => 3, :kind => "outcome")
+    edition.save!
+
+    cloned_edition = edition.build_clone
+    cloned_edition.save!
+
+    old_edition = SimpleSmartAnswerEdition.find(edition.id)
+    assert_equal ["question", "outcome", "outcome"], old_edition.nodes.all.map(&:kind)
+    assert_equal ["question1", "left", "right"], old_edition.nodes.all.map(&:slug)
+
+    new_edition = SimpleSmartAnswerEdition.find(cloned_edition.id)
+    assert_equal edition.body, new_edition.body
+    assert_equal ["question", "outcome", "outcome"], new_edition.nodes.all.map(&:kind)
+    assert_equal ["question1", "left", "right"], new_edition.nodes.all.map(&:slug)
+  end
+
+  should "not copy nodes when new edition is not a smart answer" do
+    edition = FactoryGirl.create(:simple_smart_answer_edition,
+      panopticon_id: @artefact.id,
+      body: "This smart answer is somewhat unique and calls for a different kind of introduction",
+      state: "published"
+    )
+    edition.nodes.build(:slug => "question1", :title => "You approach two open doors. Which do you choose?", :kind => "question", :order => 1)
+    edition.save!
+
+    new_edition = edition.build_clone(AnswerEdition)
+
+    assert_equal edition.body, new_edition.body
+
+    assert new_edition.is_a?(AnswerEdition)
+    assert ! new_edition.respond_to?(:nodes)
+  end
+
+  should "select the first node as the starting node" do
+    edition = FactoryGirl.create(:simple_smart_answer_edition)
+    edition.nodes.build(:slug => "question1", :title => "Question 1", :kind => "question", :order => 1)
+    edition.nodes.build(:slug => "question2", :title => "Question 2", :kind => "question", :order => 2)
+    edition.nodes.build(:slug => "foo", :title => "Outcome 1.", :order => 3, :kind => "outcome")
+    edition.nodes.build(:slug => "bar", :title => "Outcome 2", :order => 4, :kind => "outcome")
+
+    assert_equal "question1", edition.initial_node.slug
+  end
+
+  should "create nodes with nested attributes" do
+    edition = FactoryGirl.create(:simple_smart_answer_edition, :nodes_attributes => [
+      { slug: "question1", title: "Question 1", kind: "question", order: 1},
+      { slug: "foo", title: "Outcome 1", kind: "outcome", order: 2 },
+    ])
+
+    assert_equal 2, edition.nodes.size
+    assert_equal ["question1", "foo"], edition.nodes.all.map(&:slug)
+  end
+
+  should "destroy nodes using nested attributes" do
+    edition = FactoryGirl.create(:simple_smart_answer_edition)
+    edition.nodes.build(:slug => "question1", :title => "Question 1", :kind => "question", :order => 1)
+    edition.nodes.build(:slug => "question2", :title => "Question 2", :kind => "question", :order => 1)
+    edition.save!
+
+    assert_equal 2, edition.nodes.size
+
+    edition.update_attributes({
+      :nodes_attributes => {
+        "1" => { "id" => edition.nodes.first.id, "_destroy" => "1" }
+      }
+    })
+    edition.reload
+
+    assert_equal 1, edition.nodes.size
+  end
+
+  context "update_attributes method" do
+    setup do
+      @edition = FactoryGirl.create(:simple_smart_answer_edition)
+      @edition.nodes.build(:slug => "question1", :title => "Question 1", :kind => "question", :order => 1)
+      @edition.nodes.build(:slug => "question2", :title => "Question 2", :kind => "question", :order => 1)
+      @edition.nodes.first.options.build(
+        :label => "Option 1", :next_node => "question2", :order => 1)
+      @edition.save!
+    end
+
+    should "update edition and nested node and option attributes" do
+      @edition.update_attributes(:title => "Smarter than the average answer",
+        :body => "No developers were involved in the changing of this copy",
+        :nodes_attributes => {
+          "0" => { "id" => @edition.nodes.first.id, "title" => "Question the first", "options_attributes" => {
+            "0" => { "id" => @edition.nodes.first.options.first.id, "label" => "Option the first" }
+          }
+        }
+      })
+      
+      @edition.reload
+
+      assert_equal "Smarter than the average answer", @edition.title
+      assert_equal "No developers were involved in the changing of this copy", @edition.body
+      assert_equal "Question the first", @edition.nodes.first.title
+      assert_equal "Option the first", @edition.nodes.first.options.first.label
+    end
+
+    should "create and destroy nodes and options using nested attributes" do
+      @edition.update_attributes({
+        :nodes_attributes => {
+          "0" => { "id" => @edition.nodes.first.id, "options_attributes" => {
+              "0" => { "id" => @edition.nodes.first.options.first.id, "_destroy" => "1" }
+            }
+          },
+          "1" => { "id" => @edition.nodes.second.id, "_destroy" => "1" },
+          "2" => { "kind" => "question", "title" => "Question 3", "slug" => "question3", "options_attributes" => {
+            "0" => { "label" => "Goes to outcome 1", "next_node" => "outcome1" }
+          } },
+          "3" => { "kind" => "outcome", "title" => "Outcome 1", "slug" => "outcome1" }
+        }
+      })
+
+      @edition.reload
+
+      assert_equal 3, @edition.nodes.size
+      assert_equal 0, @edition.nodes.first.options.size
+      assert_equal "Question 3", @edition.nodes.second.title
+      assert_equal 1, @edition.nodes.second.options.size
+      assert_equal "outcome1", @edition.nodes.second.options.first.next_node
+      assert_equal "Outcome 1", @edition.nodes.third.title
+    end
+    
+    should "ignore new nodes if they are to be destroyed" do
+      @edition.update_attributes({
+        :nodes_attributes => {
+          "0" => { "id" => @edition.nodes.first.id, "title" => "Question the first" }, 
+          "1" => { "title" => "", "slug" => "", "kind" => "outcome", "_destroy" => "1" }
+        }
+      })
+      @edition.reload
+
+      assert_equal "Question the first", @edition.nodes.first.title
+      assert_equal 2, @edition.nodes.size
+    end
+  end
+end

data/test/models/simple_smart_answer_node_test.rb

@@ -0,0 +1,134 @@
+require "test_helper"
+
+class SimpleSmartAnswerNodeTest < ActiveSupport::TestCase
+
+  context "given a smart answer exists" do
+    setup do
+      @edition = FactoryGirl.create(:simple_smart_answer_edition)
+
+      @atts = {
+        title: "How much wood could a woodchuck chuck if a woodchuck could chuck wood?",
+        slug: "how-much-wood-could-a-woodchuck-chuck-if-a-woodchuck-could-chuck-wood",
+        body: "This is a serious question.",
+        kind: "question"
+      }
+    end
+
+    should "be able to create a valid node" do
+      @node = @edition.nodes.build(@atts)
+
+      assert @node.save!
+
+      @edition.reload
+
+      assert_equal "how-much-wood-could-a-woodchuck-chuck-if-a-woodchuck-could-chuck-wood", @edition.nodes.first.slug
+      assert_equal "How much wood could a woodchuck chuck if a woodchuck could chuck wood?", @edition.nodes.first.title
+      assert_equal "This is a serious question.", @edition.nodes.first.body
+    end
+
+    should "not be valid without a slug" do
+      @node = @edition.nodes.build( @atts.merge(slug: "") )
+
+      assert ! @node.valid?
+      assert_equal [:slug], @node.errors.keys
+    end
+
+    should "not be valid with an invalid slug" do
+      @node = @edition.nodes.build(@atts)
+
+      [
+        'under_score',
+        'space space',
+        'punct.u&ation',
+      ].each do |slug|
+        @node.slug = slug
+        refute @node.valid?
+      end
+    end
+
+    should "not be valid without a title" do
+      @node = @edition.nodes.build( @atts.merge(title: "") )
+
+      assert ! @node.valid?
+      assert_equal [:title], @node.errors.keys
+    end
+
+    should "not be valid without a kind" do
+      @node = @edition.nodes.build(@atts.merge(:kind => nil))
+      assert ! @node.valid?
+
+      assert_equal [:kind], @node.errors.keys
+    end
+
+    should "not be valid with a kind other than 'question' or 'outcome'" do
+      @node = @edition.nodes.build(@atts.merge(:kind => 'blah'))
+      assert ! @node.valid?
+
+      assert_equal [:kind], @node.errors.keys
+    end
+
+    should "create options using nested attributes" do
+      @node = @edition.nodes.create!(@atts.merge(:options_attributes => [
+        { :label => "Yes", :next_node => "yes" },
+        { :label => "No", :next_node => "no" }
+      ]))
+
+      @node.reload
+      assert_equal 2, @node.options.count
+      assert_equal ["Yes", "No"], @node.options.all.map(&:label)
+      assert_equal ["yes", "no"], @node.options.all.map(&:next_node)
+    end
+
+    should "destroy options using nested attributes" do
+      @node = @edition.nodes.create!(@atts.merge(:options_attributes => [
+        { :label => "Yes", :next_node => "yes" },
+        { :label => "No", :next_node => "no" }
+      ]))
+      assert_equal 2, @node.options.count
+
+      @node.update_attributes!(:options_attributes => {
+        "1" => { "id" => @node.options.first.id, "_destroy" => "1" }
+      })
+      @node.reload
+
+      assert_equal 1, @node.options.count
+      assert_equal ["No"], @node.options.all.map(&:label)
+      assert_equal ["no"], @node.options.all.map(&:next_node)
+    end
+
+    should "not be valid if an outcome has options" do
+      @node = @edition.nodes.build(@atts.merge(:kind => 'outcome', options_attributes: [
+        { :label => "Yes", :next_node => "yes" },
+        { :label => "No", :next_node => "no" }
+      ]))
+      assert ! @node.valid?
+
+      assert_equal [:options], @node.errors.keys
+    end
+
+    should "be able to create an outcome without options" do
+      @node = @edition.nodes.build(@atts.merge(:kind => 'outcome', :options_attributes => [] ))
+
+      assert @node.valid?
+      assert @node.save!
+    end
+
+    should "be returned in order" do
+      @nodes = [
+        @edition.nodes.create(@atts.merge(:title => "Third", :order => 3)),
+        @edition.nodes.create(@atts.merge(:title => "First", :order => 1)),
+        @edition.nodes.create(@atts.merge(:title => "Second", :order => 2)),
+      ]
+
+      assert_equal ["First","Second","Third"], @edition.nodes.all.map(&:title)
+    end
+
+    should "expose the simple smart answer edition" do
+      @node = @edition.nodes.build(@atts)
+
+      assert_equal @node.edition, @edition
+    end
+
+  end
+
+end

data/test/models/simple_smart_answer_option_test.rb

@@ -0,0 +1,90 @@
+require "test_helper"
+
+class SimpleSmartAnswerOptionTest < ActiveSupport::TestCase
+
+  context "given a smart answer exists with a node" do
+    setup do
+      @node = SimpleSmartAnswerEdition::Node.new(:slug => "question1", :title => "Question One?", :kind => "question")
+      @edition = FactoryGirl.create(:simple_smart_answer_edition, :nodes => [
+        @node,
+        SimpleSmartAnswerEdition::Node.new(:slug => "outcome1", :title => "Outcome One", :kind => "outcome")
+      ])
+
+      @atts = {
+        label: "Yes",
+        next_node: "yes"
+      }
+    end
+
+    should "be able to create a valid option" do
+      @option = @node.options.build(@atts)
+
+      assert @option.save!
+      @node.reload
+
+      assert_equal "Yes", @node.options.first.label
+      assert_equal "yes", @node.options.first.next_node
+    end
+
+    should "not be valid without a label" do
+      @option = @node.options.build(@atts.merge(label: nil))
+
+      assert !@option.valid?
+      assert @option.errors.keys.include?(:label)
+    end
+
+    should "not be valid without the next node" do
+      @option = @node.options.build(@atts.merge(next_node: nil))
+
+      assert !@option.valid?
+      assert @option.errors.keys.include?(:next_node)
+    end
+
+    should "expose the node" do
+      @option = @node.options.create(@atts)
+      @option.reload
+
+      assert_equal @node, @option.node
+    end
+
+    should "return in order" do
+      @options = [
+        @node.options.create(@atts.merge(:label => "Third", :next_node => "baz", :order => 3)),
+        @node.options.create(@atts.merge(:label => "First", :next_node => "foo", :order => 1)),
+        @node.options.create(@atts.merge(:label => "Second", :next_node => "bar", :order => 2)),
+      ]
+
+      assert_equal ["First","Second","Third"], @node.options.all.map(&:label)
+      assert_equal ["foo","bar","baz"], @node.options.all.map(&:next_node)
+    end
+
+    context "slug" do
+      should "generate a slug from the label if blank" do
+        @option = @node.options.build(@atts)
+
+        assert @option.valid?
+        assert_equal "yes", @option.slug
+      end
+
+      should "not overwrite a given slug" do
+        @option = @node.options.build(@atts.merge(:slug => "fooey"))
+
+        assert @option.valid?
+        assert_equal "fooey", @option.slug
+      end
+
+      should "not be valid with an invalid slug" do
+        @option = @node.options.build(@atts)
+
+        [
+          'under_score',
+          'space space',
+          'punct.u&ation',
+        ].each do |slug|
+          @option.slug = slug
+          refute @option.valid?
+        end
+      end
+    end
+  end
+end