@pdtf/schemas 2.3.0 → 3.0.0-2

package/src/tests/v2/transactionSchema.test.js

@@ -17,7 +17,7 @@ const schemaId =
 const v2TransactionSchema = getTransactionSchema(schemaId);
 
 test("exports a property pack schema, v2 with baspi overlay by default", () => {
-  const testSchema = getTransactionSchema();
+  const testSchema = getTransactionSchema(schemaId);
   expect(testSchema.$id).toEqual(
     "https://trust.propdata.org.uk/schemas/v2/pdtf-transaction.json"
   );
@@ -27,10 +27,11 @@ test("exports a property pack schema, v2 with baspi overlay by default", () => {
 });
 
 test("sample is valid BASPI", () => {
-  const testSchema = getTransactionSchema();
+  const testSchema = getTransactionSchema(schemaId);
   expect(
-    testSchema.properties.propertyPack.properties.materialFacts.baspiRef
-  ).toEqual("A");
+    testSchema.properties.propertyPack.properties.materialFacts.properties
+      .centralHeating.title
+  ).toEqual("Central Heating");
   const validator = getValidator(schemaId);
   const isValid = validator(exampleTransaction);
   if (!isValid) console.log(validator.errors);
@@ -59,17 +60,17 @@ test("sample with missing dependent required fields is invalid", () => {
 });
 
 test("correctly gets a top level subschema", () => {
-  const subschema = getSubschema("/propertyPack");
+  const subschema = getSubschema("/propertyPack", schemaId);
   expect(subschema.title).toBe("Property Pack");
 });
 
 test("correctly identifies a valid path", () => {
-  const isValid = isPathValid("/propertyPack/materialFacts");
+  const isValid = isPathValid("/propertyPack/materialFacts", schemaId);
   expect(isValid).toBe(true);
 });
 
 test("correctly identifies an undefined invalid path", () => {
-  const isValid = isPathValid("/propertyPack/materialItems");
+  const isValid = isPathValid("/propertyPack/materialItems", schemaId);
   expect(isValid).toBe(false);
 });
 
@@ -82,7 +83,7 @@ test("correctly identifies an error generating invalid path", () => {
 });
 
 test("correctly identifies an array invalid path", () => {
-  const isValid = isPathValid("/propertyPack/materialFacts/1/item");
+  const isValid = isPathValid("/propertyPack/materialFacts/1/item", schemaId);
   expect(isValid).toBe(false);
 });
 
@@ -125,14 +126,16 @@ test("correctly gets another subschema through a dependency", () => {
 
 test("correctly gets yet another subschema through a dependency", () => {
   const subschema = getSubschema(
-    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/groundRent/rentSubjectToIncrease/rentIncreaseCalculated"
+    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/groundRent/rentSubjectToIncrease/rentIncreaseCalculated",
+    schemaId
   );
   expect(subschema.title).toBe("How is the increase calculated?");
 });
 
 test("correctly gets yet, yet another subschema through a dependency", () => {
   const subschema = getSubschema(
-    "/propertyPack/materialFacts/listingAndConservation/isConservationArea/yesNo"
+    "/propertyPack/materialFacts/listingAndConservation/isConservationArea/yesNo",
+    schemaId
   );
   expect(subschema.type).toBe("string");
   expect(subschema.enum).toStrictEqual(["Yes", "No", "Not known"]);
@@ -140,7 +143,8 @@ test("correctly gets yet, yet another subschema through a dependency", () => {
 
 test("correctly gets yet, yet, yet another subschema through a dependency", () => {
   const subschema = getSubschema(
-    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding/other/yesNo"
+    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding/other/yesNo",
+    schemaId
   );
   expect(subschema.type).toBe("string");
   expect(subschema.enum).toStrictEqual(["Yes", "No"]);
@@ -148,21 +152,24 @@ test("correctly gets yet, yet, yet another subschema through a dependency", () =
 
 test("correctly gets yet, yet, yet another subschema through a second item dependency", () => {
   const subschema = getSubschema(
-    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding"
+    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding",
+    schemaId
   );
   expect(subschema.type).toBe("object");
 });
 
 test("correctly gets yes another subschema but through a non-baspi oneOf structure", () => {
   const subschema = getSubschema(
-    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/ChargeRestriction/EntryDetails/EntryText"
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/ChargeRestriction/EntryDetails/EntryText",
+    schemaId
   );
   expect(subschema).toEqual({ type: "string" });
 });
 
 test("correctly gets yes another subschema but through a non-baspi oneOf structure with array option", () => {
   const subschema = getSubschema(
-    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/0/ChargeRestriction/EntryDetails/EntryText"
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/0/ChargeRestriction/EntryDetails/EntryText",
+    schemaId
   );
   expect(subschema).toEqual({ type: "string" });
 });
@@ -179,11 +186,13 @@ test("correctly gets a subschema with multiple overlays", () => {
 
 test("correctly gets a subschema validator which is already cached", () => {
   const validator = getSubschemaValidator(
-    "/propertyPack/materialFacts/energyEfficiency/certificate"
+    "/propertyPack/materialFacts/energyEfficiency/certificate",
+    schemaId
   );
   expect(validator).not.toBeNull();
   const anotherValidator = getSubschemaValidator(
-    "/propertyPack/materialFacts/energyEfficiency/certificate"
+    "/propertyPack/materialFacts/energyEfficiency/certificate",
+    schemaId
   );
   expect(anotherValidator).not.toBeNull();
 });
@@ -238,6 +247,7 @@ test("correctly gets a subschema validator for a TA6 overlay which validates wit
     "ta6ed4",
   ]);
   let isValid = validator(data);
+  // console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 

package/src/tests/v3/transactionSchema.test.js

@@ -0,0 +1,350 @@
+const jp = require("jsonpointer");
+const fs = require("fs");
+
+const {
+  getTransactionSchema,
+  getSubschema,
+  isPathValid,
+  getValidator,
+  getSubschemaValidator,
+  getTitleAtPath,
+} = require("../../../index.js");
+
+const exampleTransaction = require("../../examples/v3/exampleTransaction.json");
+const schemaId =
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
+// const validator = getValidator(schemaId);
+const v3TransactionSchema = getTransactionSchema(schemaId);
+
+test("exports a property pack schema, v3 with baspi overlay by default", () => {
+  const testSchema = getTransactionSchema();
+  expect(testSchema.$id).toEqual(
+    "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json"
+  );
+  expect(
+    testSchema.properties.propertyPack.properties.materialFacts.baspiRef
+  ).toEqual("A");
+});
+
+test("sample is valid BASPI", () => {
+  const testSchema = getTransactionSchema();
+  expect(
+    testSchema.properties.propertyPack.properties.materialFacts.baspiRef
+  ).toEqual("A");
+  const validator = getValidator(schemaId);
+  const isValid = validator(exampleTransaction);
+  if (!isValid) console.log(validator.errors);
+  expect(isValid).toBe(true);
+});
+
+test("sample is valid NTS", () => {
+  const validator = getValidator(schemaId, ["nts2023"]);
+  const isValid = validator(exampleTransaction);
+  if (!isValid) console.log(validator.errors);
+  expect(isValid).toBe(true);
+});
+
+test("invalid sample is invalid", () => {
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  delete clonedExampleTransaction.propertyPack.materialFacts.notices;
+  const validator = getValidator(schemaId);
+  const isValid = validator(clonedExampleTransaction);
+  expect(isValid).toBe(false);
+});
+
+test("sample with missing dependent required fields is invalid", () => {
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  clonedExampleTransaction.propertyPack.materialFacts.ownership.ownershipsToBeTransferred[0].ownershipType =
+    "leasehold";
+  const validator = getValidator(schemaId);
+  const isValid = validator(clonedExampleTransaction);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a top level subschema", () => {
+  const subschema = getSubschema("/propertyPack");
+  expect(subschema.title).toBe("Property Pack");
+});
+
+test("correctly identifies a valid path", () => {
+  const isValid = isPathValid("/propertyPack/materialFacts");
+  expect(isValid).toBe(true);
+});
+
+test("correctly identifies an undefined invalid path", () => {
+  const isValid = isPathValid("/propertyPack/materialItems");
+  expect(isValid).toBe(false);
+});
+
+test("correctly identifies an error generating invalid path", () => {
+  const isValid = isPathValid(
+    "/propertyPack/materialItems/someProperty/item",
+    schemaId
+  );
+  expect(isValid).toBe(false);
+});
+
+test("correctly identifies an array invalid path", () => {
+  const isValid = isPathValid("/propertyPack/materialFacts/1/item");
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a subschema", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/notices",
+    schemaId
+  );
+  expect(subschema.title).toBe("Notices which Affect the Property");
+});
+
+test("correctly gets a subschema through an arrays element", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract",
+    schemaId
+  );
+  expect(Object.keys(subschema.properties)).toEqual([
+    "OCSummaryData",
+    "OCRegisterData",
+  ]);
+});
+
+test("correctly gets a subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/delayFactors/hasDelayFactors/details",
+    schemaId
+  );
+  expect(subschema.title).toBe(
+    "Provide details and likely timescale for delay"
+  );
+});
+
+test("correctly gets another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/leaseTerm/lengthOfLeaseInYears",
+    schemaId
+  );
+  expect(subschema.title).toBe("Length of lease (years)");
+});
+
+test("correctly gets yet another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/groundRent/rentSubjectToIncrease/rentIncreaseCalculated"
+  );
+  expect(subschema.title).toBe("How is the increase calculated?");
+});
+
+test("correctly gets yet, yet another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/listingAndConservation/isConservationArea/yesNo"
+  );
+  expect(subschema.type).toBe("string");
+  expect(subschema.enum).toStrictEqual(["Yes", "No", "Not known"]);
+});
+
+test("correctly gets yet, yet, yet another subschema through a second item dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding"
+  );
+  expect(subschema.type).toBe("array");
+});
+
+test("correctly gets yes another subschema but through a non-baspi oneOf structure", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/ChargeRestriction/EntryDetails/EntryText"
+  );
+  expect(subschema).toEqual({ type: "string" });
+});
+
+test("correctly gets yes another subschema but through a non-baspi oneOf structure with array option", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/0/ChargeRestriction/EntryDetails/EntryText"
+  );
+  expect(subschema).toEqual({ type: "string" });
+});
+
+test("correctly gets a subschema with multiple overlays", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/parking/parkingArrangements",
+    schemaId,
+    ["baspiV4", "ta6ed4"]
+  );
+  expect(subschema.baspiRef).toBe("A1.6.0");
+  expect(subschema.ta6Ref).toBe("9.1");
+});
+
+test("correctly gets a subschema validator which is already cached", () => {
+  const validator = getSubschemaValidator(
+    "/propertyPack/materialFacts/energyEfficiency/certificate"
+  );
+  expect(validator).not.toBeNull();
+  const anotherValidator = getSubschemaValidator(
+    "/propertyPack/materialFacts/energyEfficiency/certificate"
+  );
+  expect(anotherValidator).not.toBeNull();
+});
+
+test("correctly gets a subschema validator for a TA6 overlay", () => {
+  const path = "/propertyPack";
+  const data = jp.get(exampleTransaction, path);
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "ta6ed4",
+  ]);
+  let isValid = validator(data);
+  // console.log(validator.errors);
+  expect(isValid).toBe(true);
+});
+
+test("correctly gets a subschema validator for a TA6 overlay which validates", () => {
+  const path =
+    "/propertyPack/additionalLegalInfo/guaranteesWarrantiesAndIndemnityInsurances/subsidenceWork";
+  const data = { yesNo: "Yes" };
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "ta6ed4",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(false);
+  expect(validator.errors[0].message).toBe(
+    "must have required property 'attachments'"
+  );
+});
+
+test("correctly gets a subschema validator for a TA6 overlay which validates with non-TA6 field missing", () => {
+  const path = "/propertyPack";
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  const data = jp.get(exampleTransaction, path);
+  data.materialFacts.uprn = undefined;
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "ta6ed4",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(true);
+});
+
+test("correctly gets a subschema validator for a TA6 overlay which validates with non-TA6 section missing", () => {
+  const path = "/propertyPack";
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  const data = jp.get(clonedExampleTransaction, path);
+  data.additionalLegalInfo.smartHomeSystems = undefined;
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "ta6ed4",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(true);
+});
+
+test("correctly gets a subschema validator for a TA6 overlay which fails to validate with BASPI/TA6 section missing", () => {
+  const path = "/propertyPack";
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  const data = jp.get(clonedExampleTransaction, path);
+  data.materialFacts.waterAndDrainage = {};
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "ta6ed4",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a subschema validator for an NTS overlay", () => {
+  const path = "/propertyPack";
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  const data = jp.get(clonedExampleTransaction, path);
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "nts2023",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(true);
+});
+
+test("correctly gets a subschema validator for an LPE1 overlay", () => {
+  const path = "/propertyPack";
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  const data = jp.get(clonedExampleTransaction, path);
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
+    "lpe1ed4",
+  ]);
+  let isValid = validator(data);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a subschema validator which validates", () => {
+  const path = "/propertyPack/materialFacts/notices";
+  const validator = getSubschemaValidator(path);
+  const data = jp.get(exampleTransaction, path);
+  expect(data.neighbourDevelopment.yesNo).toBe("No");
+  let isValid = validator(data);
+  expect(isValid).toBe(true);
+  data.neighbourDevelopment.yesNo = "Invalid string";
+  isValid = validator(data);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets titles across schemas, arrays and non-existient title properties", () => {
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/ownershipType"
+    )
+  ).toBe("What type of ownership is the property?");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/leaseTerm/lengthOfLeaseInYears"
+    )
+  ).toBe("Length of lease (years)");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/serviceCharge/annualServiceCharge"
+    )
+  ).toBe("Amount of current annual service charge (£)");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/materialFacts/invalidPath"
+    )
+  ).toBe(undefined);
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract"
+    )
+  ).toBe("HMLR Official Copy Register Extract");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/PropertyAddress"
+    )
+  ).toBe("Property address");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/InvalidProp"
+    )
+  ).toBe(undefined);
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/materialFacts/energyEfficiency/certificate/currentEnergyRating"
+    )
+  ).toBe("Current energy efficiency rating");
+  expect(
+    getTitleAtPath(
+      v3TransactionSchema,
+      "/propertyPack/additionalLegalInfo/occupiers/othersAged17OrOver/aged17OrOverNames"
+    )
+  ).toBe("Please provide their full names and ages.");
+});

package/src/tests/v3/verifiedClaimsValidator.test.js

@@ -0,0 +1,128 @@
+const { validateVerifiedClaims } = require("../../../index.js");
+
+const exampleVouch = require("../../examples/v1/exampleVouch.json");
+const exampleDocumentedVouch = require("../../examples/v1/exampleDocumentedVouch.json");
+const v3SchemaId =
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
+
+test("returns an empty array for a valid claim", () => {
+  expect(validateVerifiedClaims([exampleVouch])).toEqual([]);
+});
+
+test("returns an empty array for a valid array of claims", () => {
+  const claimsArray = [exampleVouch, exampleDocumentedVouch];
+  expect(validateVerifiedClaims(claimsArray)).toEqual([]);
+});
+
+test("returns an array with an error stating if path is incorrect", () => {
+  const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
+  const originalPath = Object.keys(clonedVouch.claims)[0];
+  const data = clonedVouch.claims[originalPath];
+  clonedVouch.claims = {
+    "/propertyPack/INVALID/materialFacts/councilTax": data,
+  };
+  // v3 schema, no overlay
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([
+    "Path /propertyPack/INVALID/materialFacts/councilTax is not a valid PDTF schema path",
+  ]);
+});
+
+test("returns errors if BASPI requirements are not met and BASPI overlay is specified (default)", () => {
+  const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
+  clonedVouch.claims = {
+    "/propertyPack/materialFacts/delayFactors": {
+      hasDelayFactors: { yesNo: "Yes" },
+    },
+  };
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId);
+  expect(errors).toEqual([
+    {
+      instancePath: "/hasDelayFactors",
+      schemaPath: "#/properties/hasDelayFactors/oneOf/1/required",
+      keyword: "required",
+      params: { missingProperty: "details" },
+      message: "must have required property 'details'",
+    },
+    {
+      instancePath: "/hasDelayFactors",
+      schemaPath: "#/properties/hasDelayFactors/oneOf/1/required",
+      keyword: "required",
+      params: { missingProperty: "attachments" },
+      message: "must have required property 'attachments'",
+    },
+  ]);
+});
+
+test("returns no errors if BASPI requirements are not met and null overlay is specified", () => {
+  const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
+  clonedVouch.claims = {
+    "/propertyPack/materialFacts/delayFactors": {
+      hasDelayFactors: { yesNo: "Yes" },
+    },
+  };
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId, null);
+  expect(errors).toEqual([]);
+});
+
+test("returns errors for invalid fields even if null overlay is specified", () => {
+  const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
+  clonedVouch.claims = {
+    "/propertyPack/materialFacts/delayFactors": {
+      hasDelayFactors: { yesNo: "Maybe" },
+    },
+  };
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId, null);
+  expect(errors).toHaveLength(4);
+});
+
+test("returns an array of errors for verified claim with multiple paths", () => {
+  const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
+  clonedVouch.claims = {
+    "/propertyPack/materialFacts/cousncilTaxBad": {
+      councilTaxBand: "D",
+      councilTaxAffectingAlterations: {
+        yesNo: "Yes",
+        details:
+          "Extension added in 2005 to add bedroom with ensuite shower room. Certificate of Compliance issued 17th Feb 2006 and council tax updated",
+      },
+    },
+    "/propertyPack/materialFacts/councilTaxBadTwo": {
+      councilTaxBand: "D",
+      councilTaxAffectingAlterations: {
+        yesNo: "Yes",
+        details:
+          "Extension added in 2005 to add bedroom with ensuite shower room. Certificate of Compliance issued 17th Feb 2006 and council tax updated",
+      },
+    },
+  };
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([
+    "Path /propertyPack/materialFacts/cousncilTaxBad is not a valid PDTF schema path",
+    "Path /propertyPack/materialFacts/councilTaxBadTwo is not a valid PDTF schema path",
+  ]);
+});
+
+test("returns an empty array of errors for verified claim with multiple valid paths", () => {
+  const clonedVouch = JSON.parse(
+    JSON.stringify(exampleVouch),
+    v3SchemaId,
+    null
+  );
+  clonedVouch.claims = {
+    "/propertyPack/materialFacts/councilTax": {
+      councilTaxBand: "D",
+      councilTaxAffectingAlterations: {
+        yesNo: "Yes",
+        details:
+          "Extension added in 2005 to add bedroom with ensuite shower room. Certificate of Compliance issued 17th Feb 2006 and council tax updated",
+      },
+    },
+    "/propertyPack/materialFacts/address": {
+      line1: "property.line1",
+      line2: "property.line2",
+      town: "property.city",
+      county: "property.province",
+      postcode: "property.postcode",
+    },
+  };
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([]);
+});

package/src/utils/extractOverlay.js

@@ -4,7 +4,7 @@ const jp = require("jsonpointer");
 const fs = require("fs");
 const merge = require("deepmerge");
 
-const combinedSchema = require("../schemas/v2/combined.json");
+const combinedSchema = require("../schemas/v3/combined.json");
 
 const extractFields = [
   "baspi",
@@ -74,7 +74,7 @@ const extractOverlay = (sourceSchema, ref) => {
   const refName = `${ref}Ref`;
   const returnSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
-    $id: `https://trust.propdata.org.uk/schemas/v2/overlays/${ref}.json`,
+    $id: `https://trust.propdata.org.uk/schemas/v3/overlays/${ref}.json`,
   };
   traverse(sourceSchema).forEach(function (element) {
     let path = "/" + this.path.join("/");
@@ -160,7 +160,7 @@ extractFields.forEach((key) => {
     "discriminator",
   ]);
   overlays[key] = overlay;
-  const fileName = `../schemas/v2/overlays/${key}.json`;
+  const fileName = `../schemas/v3/overlays/${key}.json`;
   fs.writeFileSync(fileName, JSON.stringify(overlay, null, 2));
   console.log(`Overlay ${key} written to ${fileName}`);
 });
@@ -174,10 +174,10 @@ const coreSchema = deleteProperties(combinedSchema, [
 ]);
 
 fs.writeFileSync(
-  "../schemas/v2/pdtf-transaction.json",
+  "../schemas/v3/pdtf-transaction.json",
   JSON.stringify(coreSchema, null, 2)
 );
-console.log("Core schema written to ../schemas/v2/pdtf-transaction.json");
+console.log("Core schema written to ../schemas/v3/pdtf-transaction.json");
 
 const skeletonSchema = deleteProperties(coreSchema, [
   "$schema",
@@ -196,7 +196,7 @@ const skeletonSchema = deleteProperties(coreSchema, [
 const skeletonSchemaFlattened = flattenSkeleton(skeletonSchema);
 
 fs.writeFileSync(
-  "../schemas/v2/skeleton.json",
+  "../schemas/v3/skeleton.json",
   JSON.stringify(skeletonSchemaFlattened, null, 2)
 );
-console.log("Flat Skeleton schema written to ../schemas/v2/skeleton.json");
+console.log("Flat Skeleton schema written to ../schemas/v3/skeleton.json");