Adding test cases which bring the link controller coverage to 100%.

packages/server/src/db/linkedRows/LinkController.js

@@ -136,7 +136,14 @@ class LinkController {
    * Returns whether the two link schemas are equal (in the important parts, not a pure equality check)
    */
   areLinkSchemasEqual(linkSchema1, linkSchema2) {
-    const compareFields = ["name", "type", "tableId", "fieldName", "autocolumn"]
+    const compareFields = [
+      "name",
+      "type",
+      "tableId",
+      "fieldName",
+      "autocolumn",
+      "relationshipType",
+    ]
     for (let field of compareFields) {
       if (linkSchema1[field] !== linkSchema2[field]) {
         return false
@@ -336,6 +343,7 @@ class LinkController {
         try {
           linkedTable = await this._db.get(field.tableId)
         } catch (err) {
+          /* istanbul ignore next */
           continue
         }
         const fields = this.handleRelationshipType(field, {
@@ -416,6 +424,7 @@ class LinkController {
           await this._db.put(linkedTable)
         }
       } catch (err) {
+        /* istanbul ignore next */
         Sentry.captureException(err)
       }
     }

packages/server/src/db/tests/linkController.spec.js

@@ -1,7 +1,8 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
-const { basicTable } = require("../../tests/utilities/structures")
+const { basicRow, basicLinkedRow, basicTable } = require("../../tests/utilities/structures")
 const LinkController = require("../linkedRows/LinkController")
 const { RelationshipTypes } = require("../../constants")
+const { cloneDeep } = require("lodash/fp")
 
 describe("test the link controller", () => {
   let config = new TestConfig(false)
@@ -10,7 +11,7 @@ describe("test the link controller", () => {
   beforeEach(async () => {
     await config.init()
     const { _id } = await config.createTable()
-    table2 = await config.createLinkedTable()
+    table2 = await config.createLinkedTable(RelationshipTypes.MANY_TO_MANY, ["link", "link2"])
     // update table after creating link
     table1 = await config.getTable(_id)
   })
@@ -32,6 +33,12 @@ describe("test the link controller", () => {
     return new LinkController(linkConfig)
   }
 
+  async function createLinkedRow(linkField = "link", t1 = table1, t2 = table2) {
+    const row = await config.createRow(basicRow(t2._id))
+    const { _id } = await config.createRow(basicLinkedRow(t1._id, row._id, linkField))
+    return config.getRow(t1._id, _id)
+  }
+
   it("should be able to confirm if two table schemas are equal", () => {
     const controller = createLinkController(table1)
     let equal = controller.areLinkSchemasEqual(table2.schema.link, table2.schema.link)
@@ -56,4 +63,156 @@ describe("test the link controller", () => {
     expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_ONE)
     expect(output.linkerField.relationshipType).toEqual(RelationshipTypes.ONE_TO_MANY)
   })
+
+  it("should be able to delete a row", async () => {
+    const row = await createLinkedRow()
+    const controller = createLinkController(table1, row)
+    // get initial count
+    const beforeLinks = await controller.getRowLinkDocs(row._id)
+    await controller.rowDeleted()
+    let afterLinks = await controller.getRowLinkDocs(row._id)
+    expect(beforeLinks.length).toEqual(1)
+    expect(afterLinks.length).toEqual(0)
+  })
+
+  it("shouldn't throw an error when deleting a row with no links", async () => {
+    const row = await config.createRow(basicRow(table1._id))
+    const controller = createLinkController(table1, row)
+    let error
+    try {
+      await controller.rowDeleted()
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeUndefined()
+  })
+
+  it("should throw an error when validating a table which is invalid", () => {
+    const controller = createLinkController(table1)
+    const copyTable = {
+      ...table1
+    }
+    copyTable.schema.otherTableLink = {
+      type: "link",
+      fieldName: "link",
+      tableId: table2._id,
+    }
+    let error
+    try {
+      controller.validateTable(copyTable)
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+    expect(error.message).toEqual("Cannot re-use the linked column name for a linked table.")
+  })
+
+  it("should be able to remove a link when saving/updating the row", async () => {
+    const row = await createLinkedRow()
+    // remove the link from the row
+    row.link = []
+    const controller = createLinkController(table1, row)
+    await controller.rowSaved()
+    let links = await controller.getRowLinkDocs(row._id)
+    expect(links.length).toEqual(0)
+  })
+
+  it("should be able to delete a table and have links deleted", async () => {
+    await createLinkedRow()
+    const controller = createLinkController(table1)
+    let before = await controller.getTableLinkDocs()
+    await controller.tableDeleted()
+    let after = await controller.getTableLinkDocs()
+    expect(before.length).toEqual(1)
+    expect(after.length).toEqual(0)
+  })
+
+  it("should be able to remove a linked field from a table", async () => {
+    await createLinkedRow()
+    await createLinkedRow("link2")
+    const controller = createLinkController(table1, null, table1)
+    let before = await controller.getTableLinkDocs()
+    await controller.removeFieldFromTable("link")
+    let after = await controller.getTableLinkDocs()
+    expect(before.length).toEqual(2)
+    // shouldn't delete the other field
+    expect(after.length).toEqual(1)
+  })
+
+  it("should throw an error when overwriting a link column", async () => {
+    const update = cloneDeep(table1)
+    update.schema.link.relationshipType = RelationshipTypes.MANY_TO_ONE
+    let error
+    try {
+      const controller = createLinkController(update)
+      await controller.tableSaved()
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+  })
+
+  it("should be able to remove a field view table update", async () => {
+    await createLinkedRow()
+    await createLinkedRow()
+    const newTable = cloneDeep(table1)
+    delete newTable.schema.link
+    const controller = createLinkController(newTable, null, table1)
+    await controller.tableUpdated()
+    const links = await controller.getTableLinkDocs()
+    expect(links.length).toEqual(0)
+  })
+
+  it("shouldn't allow one to many having many relationships against it", async () => {
+    const firstTable = await config.createTable()
+    const { _id } = await config.createLinkedTable(RelationshipTypes.MANY_TO_ONE, ["link"])
+    const linkTable = await config.getTable(_id)
+    // an initial row to link around
+    const row = await createLinkedRow("link", linkTable, firstTable)
+    let error
+    try {
+      // create another row to initiate the error
+      await config.createRow(basicLinkedRow(row.tableId, row.link[0]))
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+  })
+
+  it("should not error if a link being created doesn't exist", async () => {
+    let error
+    try {
+      await config.createRow(basicLinkedRow(table1._id, "invalid"))
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeUndefined()
+  })
+
+  it("make sure auto column goes onto other row too", async () => {
+    const table = await config.createTable()
+    const tableCfg = basicTable()
+    tableCfg.schema.link = {
+      type: "link",
+      fieldName: "link",
+      tableId: table._id,
+      name: "link",
+      autocolumn: true,
+    }
+    await config.createTable(tableCfg)
+    const afterTable = await config.getTable(table._id)
+    expect(afterTable.schema.link.autocolumn).toBe(true)
+  })
+
+  it("should be able to link to self", async () => {
+    const table = await config.createTable()
+    table.schema.link = {
+      type: "link",
+      fieldName: "link",
+      tableId: table._id,
+      name: "link",
+      autocolumn: true,
+    }
+    await config.updateTable(table)
+  })
 })

packages/server/src/tests/utilities/TestConfiguration.js

@@ -135,16 +135,22 @@ class TestConfiguration {
     return this._req(null, { id: tableId }, controllers.table.find)
   }
 
-  async createLinkedTable() {
+  async createLinkedTable(relationshipType, links = ["link"]) {
     if (!this.table) {
       throw "Must have created a table first."
     }
     const tableConfig = basicTable()
     tableConfig.primaryDisplay = "name"
-    tableConfig.schema.link = {
-      type: "link",
-      fieldName: "link",
-      tableId: this.table._id,
+    for (let link of links) {
+      tableConfig.schema[link] = {
+        type: "link",
+        fieldName: link,
+        tableId: this.table._id,
+        name: link,
+      }
+      if (relationshipType) {
+        tableConfig.schema[link].relationshipType = relationshipType
+      }
     }
     const linkedTable = await this.createTable(tableConfig)
     this.linkedTable = linkedTable
@@ -163,8 +169,9 @@ class TestConfiguration {
     if (!this.table) {
       throw "Test requires table to be configured."
     }
-    config = config || basicRow(this.table._id)
-    return this._req(config, { tableId: this.table._id }, controllers.row.save)
+    const tableId = (config && config.tableId) || this.table._id
+    config = config || basicRow(tableId)
+    return this._req(config, { tableId }, controllers.row.save)
   }
 
   async getRow(tableId, rowId) {

packages/server/src/tests/utilities/structures.js

@@ -53,6 +53,14 @@ exports.basicRow = tableId => {
   }
 }
 
+exports.basicLinkedRow = (tableId, linkedRowId, linkField = "link") => {
+  // this is based on the basic linked tables you get from the test configuration
+  return {
+    ...exports.basicRow(tableId),
+    [linkField]: [linkedRowId],
+  }
+}
+
 exports.basicRole = () => {
   return {
     name: "NewRole",