Merge pull request #528 from alphagov/cm-854-simplify-use-of-schema-in-tests

CM-854: Simplify use of schema in tests

Author: edavey

app/models/edition.rb

@@ -16,6 +16,8 @@ class Edition < ApplicationRecord
   has_one :fact_check_outcome, dependent: :destroy
   has_many :domain_events
 
+  delegate :schema, to: :document
+
   scope :current_versions, lambda {
     published
   }

app/models/edition/validates_details.rb

@@ -6,10 +6,6 @@ module Edition::ValidatesDetails
   included do
     validates_with DetailsValidator
 
-    # Only used in tests, so we can easily add a schema to an edition, without
-    # having to resort to mocks, which are difficult to setup/clean between tests
-    attr_writer :schema
-
     def self.human_attribute_name(attr, options = {})
       if attr.starts_with?(DETAILS_PREFIX)
         key = attr.to_s.delete_prefix(DETAILS_PREFIX)
@@ -20,10 +16,6 @@ def self.human_attribute_name(attr, options = {})
     end
   end
 
-  def schema
-    @schema ||= Schema.find_by_block_type(block_type)
-  end
-
   # When an error is raised about a field within the details hash
   # we have to prefix it. This overrides the default `read_attribute_for_validation`
   # method, and reads it from the details hash if the attribute name

app/validators/details_validator.rb

@@ -5,6 +5,9 @@ class DetailsValidator < ActiveModel::Validator
 
   def validate(edition)
     @edition = edition
+
+    return false if block_type_blank?
+
     errors = validate_with_schema(edition)
     errors.each do |e|
       if e["type"] == "required"
@@ -103,6 +106,10 @@ def translate_error(type, attribute, **args)
 
 private
 
+  def block_type_blank?
+    @edition.errors.attribute_names.include?(:"document.block_type")
+  end
+
   def generate_prefix(error)
     keys = error["data_pointer"].split("/")[1..]
     if error_is_for_embedded_object?(error)

engines/fact_check/spec/components/embedded_block_diff_component_spec.rb

@@ -10,10 +10,14 @@
 
   let(:schema) { double(:schema) }
 
-  let(:document) { build(:document, schema:) }
+  let(:document) { build(:document) }
 
   let(:items) { CombinedEditionDetails.new(published_details: items_published, new_details: items_new).content }
 
+  before do
+    allow(document).to receive(:schema).and_return(schema)
+  end
+
   describe "when there is no data to render" do
     before do
       render_inline(described_class.new(items:, object_type:, object_title:, document:))

engines/fact_check/spec/components/nested_blocks_with_summary_diff_component_spec.rb

@@ -27,13 +27,14 @@
   let(:object_title) { "address-1" }
 
   let(:schema) { build(:schema, body: SchemaHelpers::MINIMAL_CONTACT_SCHEMA_BODY) }
-  let(:document) { create(:document, :contact, schema:) }
+  let(:document) { create(:document, :contact) }
   let(:pub_edition) { build(:edition, :contact, :published, document:, details: published_details) }
   let(:edition) { build(:edition, :contact, :awaiting_factcheck, document:, details: new_details) }
   let(:block) { build(:content_block, edition:) }
   let(:component) { described_class.new(items:, object_type:, object_title:, block:) }
 
   before do
+    allow(document).to receive(:schema).and_return(schema)
     allow(document).to receive(:latest_published_edition).and_return(pub_edition)
     render_inline(component)
   end

engines/fact_check/spec/components/ungrouped_subschema_diff_component_spec.rb

@@ -8,7 +8,7 @@
                            } })
   end
   let(:schema) { build(:schema) }
-  let(:document) { build(:document, schema:) }
+  let(:document) { build(:document) }
   let(:display_fields) { %w[amount] }
   let(:edition) do
     build(:edition,
@@ -30,6 +30,7 @@
   let(:component) { described_class.new(block:, subschema:) }
 
   before do
+    allow(document).to receive(:schema).and_return(schema)
     allow(schema).to receive(:subschema).with("content_block_block_type").and_return(subschema)
     allow(subschema).to receive(:block_display_fields).and_return(display_fields)
   end

engines/fact_check/spec/factories/content_block.rb

@@ -4,7 +4,7 @@
 
     transient do
       schema { build(:schema) }
-      document { build(:document, schema:) }
+      document { build(:document) }
       id { "123" }
     end
 

features/step_definitions/block_creation_steps.rb

@@ -134,7 +134,7 @@ def create_published_tax_edition
     :edition,
     :tax,
     document: tax_document,
-    details: { description: "Some text" },
+    details: { tax_type: "Tax", description: "Some text" },
     creator: @user,
     lead_organisation_id: organisation_id,
     title: "My tax",

spec/components/edition/show/embedded_object/subschema_item_component_spec.rb

@@ -1,7 +1,4 @@
 RSpec.describe Edition::Show::EmbeddedObject::SubschemaItemComponent, type: :component do
-  let(:schema) { double("schema: time period") }
-  let(:subschema) { double("subschema: date_range") }
-
   let(:details) do
     {
       "date_range" => {
@@ -13,40 +10,32 @@
     }
   end
 
-  let(:edition) { build(:edition, :pension, details: details) }
-  let(:object_type) { "date_range" }
-  let(:schema_name) { "date_range" }
+  let(:edition_with_sole_date_range_object) { build(:edition, :time_period, details: details) }
 
   let(:component) do
     described_class.new(
-      edition:,
-      object_type:,
-      schema_name:,
+      edition: edition_with_sole_date_range_object,
+      object_type: "date_range",
+      schema_name: "date_range",
     )
   end
 
   let(:metadata_response) { "METADATA" }
   let(:block_response) { "BLOCKS" }
 
   before do
-    allow(edition.document).to receive(:schema).and_return(schema)
-    allow(schema).to receive(:subschema).with(object_type).and_return(subschema)
-    allow(subschema).to receive(:id).and_return(object_type)
-    allow(subschema).to receive(:block_display_fields).and_return(%w[start end])
-    allow(subschema).to receive(:field_ordering_rule).with("start").and_return(1)
-    allow(subschema).to receive(:field_ordering_rule).with("end").and_return(2)
-    allow(subschema).to receive(:field_ordering_rule).with("title").and_return(3)
-
     expect(component).to receive(:render).with(metadata_response).and_return(metadata_response)
     allow(component).to receive(:render).with(block_response).and_return(block_response)
   end
 
   it "renders non-blank fields apart from 'block_display_fields' with the MetadataComponent" do
+    expected_subschema = edition_with_sole_date_range_object.schema.subschema("date_range")
+
     allow(Edition::Show::EmbeddedObjects::BlocksComponent).to receive(:new).and_return(block_response)
 
     expect(Edition::Show::EmbeddedObjects::MetadataComponent).to receive(:new).with(
       items: { "other_field" => "Other value" },
-      schema: subschema,
+      schema: expected_subschema,
     ).and_return(metadata_response)
 
     render_inline component
@@ -63,7 +52,7 @@
       object_type: "date_range",
       object_title: nil,
       schema_name: "date_range",
-      edition: edition,
+      edition: edition_with_sole_date_range_object,
     ).and_return(block_response)
 
     render_inline component

spec/components/shared/embedded_object/summary_card_component_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Shared::EmbeddedObject::SummaryCardComponent, type: :component do
   include Rails.application.routes.url_helpers
 
-  context "when the embedded object has nested fields" do
+  context "when the embedded object has nested fields, as within TimePeriod#date_range" do
     let(:details) do
       {
         "date_range" => {
@@ -11,42 +11,12 @@
       }
     end
 
-    let(:subschema_id) { "date_range" }
-    let(:parent_schema) { double("parent_schema", id: "content_block_time_period", block_type: "time_period") }
-    let(:body) do
-      {
-        "type" => "object",
-        "properties" => {
-          "start" => {
-            "type" => "object",
-            "properties" => {
-              "date" => { "type" => "string" },
-              "time" => { "type" => "string" },
-            },
-          },
-          "end" => {
-            "type" => "object",
-            "properties" => {
-              "date" => { "type" => "string" },
-              "time" => { "type" => "string" },
-            },
-          },
-        },
-      }
-    end
-
-    let(:subschema) { Schema::EmbeddedSchema.new(subschema_id, body, parent_schema) }
-    let(:schema) { double(:schema, block_type: "schema") }
-
-    let(:document) { build(:document, :pension, schema:) }
-    let(:edition) { build_stubbed(:edition, :pension, details:, document:) }
+    let(:document) { build(:document, :time_period) }
+    let(:edition) { build_stubbed(:edition, :time_period, details:, document:) }
 
     let(:component) { described_class.new(edition:, object_type: "date_range") }
 
     before do
-      allow(subschema).to receive(:block_display_fields).and_return(%w[start end])
-      allow(schema).to receive(:subschema).and_return(subschema)
-
       %w[
         date_range/start/date
         date_range/start/time