test/unit/helpers.approver-group.js

import test from 'ava';
import nock from 'nock';
import {
  client,
  ApproverAssignment,
  ApproverGroup,
  ApproverGroupAssignment,
  ConsentApprover,
  ConsentFormVersion,
} from '../../src';

// See tests.js for testing client creation
test.before('start server', (t) => {
  client.apiBaseUrl = 'https://somesite.Clinical6.com';
  client.authToken = 'valid_token';

  t.context.getResponseAssignments = {
    data: [
      {
        id: '1',
        type: 'consent__approver_assignments',
        attributes: {
          created_at: '2018-04-30T08:58:08Z',
          updated_at: '2018-04-30T08:58:08Z'
        },
        relationships: {
          approver_group: {
            data: {
              id: '1',
              type: 'consent__approver_groups'
            }
          },
          approver: {
            data: {
              id: '1',
              type: 'consent__approvers'
            }
          }
        }
      },
      {
        id: '2',
        type: 'consent__approver_assignments',
        attributes: {
          created_at: '2018-04-30T08:58:27Z',
          updated_at: '2018-04-30T08:58:27Z'
        },
        relationships: {
          approver_group: {
            data: {
              id: '1',
              type: 'consent__approver_groups'
            }
          },
          approver: {
            data: {
              id: '2',
              type: 'consent__approvers'
            }
          }
        }
      },
      {
        id: '3',
        type: 'consent__approver_assignments',
        attributes: {
          created_at: '2018-04-30T08:58:48Z',
          updated_at: '2018-04-30T08:58:48Z'
        },
        relationships: {
          approver_group: {
            data: {
              id: '1',
              type: 'consent__approver_groups'
            }
          },
          approver: {
            data: {
              id: '3',
              type: 'consent__approvers'
            }
          }
        }
      }
    ],
    included: [
      {
        id: '1',
        type: 'consent__approver_groups',
        attributes: {
          name: 'Testing123'
        },
        relationships: {
          approver_assignments: {
            data: [
              {
                id: '1',
                type: 'consent__approver_assignments'
              },
              {
                id: '2',
                type: 'consent__approver_assignments'
              },
              {
                id: '3',
                type: 'consent__approver_assignments'
              }
            ]
          },
          approvers: {
            data: [
              {
                id: '1',
                type: 'consent__approvers'
              },
              {
                id: '2',
                type: 'consent__approvers'
              },
              {
                id: '3',
                type: 'consent__approvers'
              }
            ]
          }
        }
      }
    ]
  };
});

test.beforeEach((t) => {
  client.cache = 'never';
  client.authToken = 'valid_token';

  t.context.insertResponse = {
    data: {
      id: 3,
      type: 'consent__approver_groups',
      attributes: {
        name: 'A group name'
      },
      relationships: {
        approver_assignments: {
          data: []
        },
        approvers: {
          data: []
        }
      }
    }
  };

  t.context.updateResponse = {
    data: {
      id: 19,
      type: 'consent__approver_groups',
      attributes: {
        name: 'A group name',
        created_at: '2018-05-04T16:44:32Z',
        updated_at: '2018-05-04T16:44:32Z'
      },
      relationships: {
        approver_assignments: {
          data: []
        },
        group_assignments: {
          data: []
        },
        approvers: {
          data: []
        },
        form_versions: {
          data: []
        }
      }
    }
  };

  t.context.insertResponseAssignment = {
    data: {
      id: 3,
      type: 'consent__approver_group_assignments',
      relationships: {
        form_version: {
          data: {
            id: 6,
            type: 'consent__form_versions'
          }
        },
        approver_group: {
          data: {
            id: 3,
            type: 'consent__approver_groups'
          }
        }
      }
    },
    included: [
      {
        id: 6,
        type: 'consent__form_versions',
        attributes: {
          archived_at: '2018-03-09T16:44:08Z'
        },
        relationships: {
          site: {
            data: {
              id: 6,
              type: 'trials__sites'
            }
          },
          agreement_template: {
            data: {
              id: 6,
              type: 'agreement__templates'
            }
          },
          language: {
            data: {
              id: 7,
              type: 'languages'
            }
          },
          consent_form: {
            data: {
              id: 6,
              type: 'consent__forms'
            }
          },
          approver_groups: {
            data: [
              {
                id: 3,
                type: 'consent__approver_groups'
              }
            ]
          },
          approvers: {
            data: [
              {
                id: 5,
                type: 'consent__approvers'
              },
              {
                id: 6,
                type: 'consent__approvers'
              }
            ]
          }
        }
      },
      {
        id: 3,
        type: 'consent__approver_groups',
        attributes: {
          name: 'Approver Group 3'
        },
        relationships: {
          approver_assignments: {
            data: [
              {
                id: 5,
                type: 'consent__approver_assignments'
              },
              {
                id: 6,
                type: 'consent__approver_assignments'
              }
            ]
          },
          approvers: {
            data: [
              {
                id: 5,
                type: 'consent__approvers'
              },
              {
                id: 6,
                type: 'consent__approvers'
              }
            ]
          }
        }
      },
      {
        id: 5,
        type: 'consent__approver_assignments',
        relationships: {
          approver_group: {
            data: {
              id: 3,
              type: 'consent__approver_groups'
            }
          },
          approver: {
            data: {
              id: 5,
              type: 'consent__approvers'
            }
          }
        }
      },
      {
        id: 5,
        type: 'consent__approvers',
        attributes: {
          first_name: 'John',
          last_name: 'Doe',
          email: 'john@example.com',
          title: null
        },
        relationships: {
          approver_groups: {
            data: [
              {
                id: 3,
                type: 'consent__approver_groups'
              }
            ]
          },
          consent_form_versions: {
            data: [
              {
                id: 6,
                type: 'consent__form_versions'
              }
            ]
          }
        }
      },
      {
        id: 6,
        type: 'consent__approver_assignments',
        relationships: {
          approver_group: {
            data: {
              id: 3,
              type: 'consent__approver_groups'
            }
          },
          approver: {
            data: {
              id: 6,
              type: 'consent__approvers'
            }
          }
        }
      },
      {
        id: 6,
        type: 'consent__approvers',
        attributes: {
          first_name: 'John',
          last_name: 'Doe',
          email: 'john@example.com',
          title: null
        },
        relationships: {
          approver_groups: {
            data: [
              {
                id: 3,
                type: 'consent__approver_groups'
              }
            ]
          },
          consent_form_versions: {
            data: [
              {
                id: 6,
                type: 'consent__form_versions'
              }
            ]
          }
        }
      }
    ]
  };

  t.context.approverGroupJsonApi = {
    id: 1,
    type: 'consent__approver_groups',
    attributes: {
      name: 'A group name',
      created_at: undefined,
      updated_at: undefined
    },
    relationships: {
      approver_assignments: {
        data: []
      },
      approvers: {
        data: []
      },
      form_versions: {
        data: []
      }
    }
  };

  t.context.approverGroupJson = {
    id: 1,
    type: 'consent__approver_groups',
    name: 'A group name',
    created_at: undefined,
    updated_at: undefined,
  };

  t.context.approverGroupAssignmentJsonApi = {
    id: 6,
    type: 'consent__approver_group_assignments',
    attributes: {},
    relationships: {
      form_version: {
        data: {
          id: 6,
          type: 'consent__form_versions'
        }
      },
      approver_group: {
        data: {
          id: 3,
          type: 'consent__approver_groups'
        }
      }
    }
  };

  t.context.approverAssignmentJsonApi = {
    id: 1,
    type: 'consent__approver_assignments',
    attributes: {},
    relationships: {
      approver_group: {
        data: {
          id: 1,
          type: 'consent__approver_groups'
        }
      },
      approver: {
        data: {
          id: 1,
          type: 'consent__approvers'
        }
      }
    }
  };


  client.storageUtility.clear();
  t.context.storage = client.storageUtility;
  client.approverGroup = new ApproverGroup({});
  t.context.approverGroup = new ApproverGroup({ data: t.context.approverGroupJsonApi });
});

/**
 * @test {ApproverGroup}
 */
test('[unit] ApproverGroup should handle approverGroup data with a normal json format', (t) => {
  const { approverGroupJson } = t.context;
  const approverGroup = new ApproverGroup(approverGroupJson);
  t.is(approverGroup.type, 'consent__approver_groups');
  t.is(approverGroup.name, 'A group name');
  t.is(approverGroup.createdAt, undefined);
  t.is(approverGroup.updatedAt, undefined);
});

/**
 * @test {ApproverGroup}
 */
test('[unit] ApproverGroup should handle approverGroup data with json api format', (t) => {
  const { approverGroupJsonApi } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  t.is(approverGroup.type, 'consent__approver_groups');
  t.is(approverGroup.name, 'A group name');
  t.is(approverGroup.createdAt, undefined);
  t.is(approverGroup.updatedAt, undefined);
});

/**
 * @test {ApproverGroup}
 */
test('[unit] ApproverGroup should generate json api format when converted to string', (t) => {
  const { approverGroupJsonApi } = t.context;
  let approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  t.deepEqual(approverGroup.toJSON(), approverGroupJsonApi);

  approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  t.deepEqual(approverGroup.toJSON(), approverGroupJsonApi);
});


// ApproverGroup.save
/**
 * @test {ApproverGroup.save}
 */
test('[unit] ApproverGroup.save should successfully save a new approverGroup when id does not exist', async (t) => {
  const { approverGroupJsonApi, insertResponse } = t.context;
  const json = JSON.parse(JSON.stringify(approverGroupJsonApi));
  delete json.id;
  const approverGroup = new ApproverGroup({ data: json });
  let request = {};
  nock(client.apiBaseUrl).post(`/v3/consent/approver_groups`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [201, insertResponse];
  });

  const response = await approverGroup.save();

  t.is(request.path, `/v3/consent/approver_groups`);
  t.is(request.headers.accept, 'application/json');
  t.deepEqual(request.requestBody, { data: json });
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.is(response.id, 3);
  t.is(response.type, 'consent__approver_groups');
  t.is(response.name, 'A group name');
  t.is(response.approvers.length, 0);
  t.is(response.approverAssignments.length, 0);
});

/**
 * @test {ApproverGroup.save}
 */
test('[unit] ApproverGroup.save should successfully update an approverGroup with an approverGroup object when id exists', async (t) => {
  const { updateResponse } = t.context;
  const updateAproverGroupJsonApi = {
    id: 19,
    type: 'consent__approver_groups',
    attributes: {
      name: 'A group name',
      created_at: '2018-05-04T16:44:32Z',
      updated_at: '2018-05-04T16:44:32Z'
    },
    relationships: {
      approver_assignments: {
        data: []
      },
      approvers: {
        data: []
      },
      form_versions: {
        data: []
      }
    }
  };
  const approverGroup = new ApproverGroup({ data: updateAproverGroupJsonApi });
  let request = {};
  nock(client.apiBaseUrl).patch(`/v3/consent/approver_groups/${approverGroup.id}`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [200, updateResponse];
  });
  const response = await approverGroup.save();

  t.is(request.path, `/v3/consent/approver_groups/${approverGroup.id}`);
  t.is(request.headers.accept, 'application/json');
  t.deepEqual(request.requestBody, { data: updateAproverGroupJsonApi });
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.is(response.id, 19);
  t.is(response.type, 'consent__approver_groups');
  t.is(response.createdAt, '2018-05-04T16:44:32Z');
  t.is(response.updatedAt, '2018-05-04T16:44:32Z');
  t.is(response.name, 'A group name');
  t.is(response.approverAssignments.length, 0);
  t.is(response.approvers.length, 0);
  t.is(response.formVersions.length, 0);
});


// ApproverGroup.addApprover
/**
 * @test {ApproverGroup.addApprover}
 */
test('[unit] ApproverGroup.addApprover should successfully insert a approverAssignment with a user and approverGroup when approverAssignment.id does not exist', async (t) => {
  const { approverGroupJsonApi, approverAssignmentJsonApi, insertResponseAssignment } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  const approver = new ConsentApprover({ id: 1 });
  let request = {};
  nock(client.apiBaseUrl).post(`/v3/consent/approver_assignments`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [201, insertResponseAssignment];
  });
  const response = await approverGroup.addApprover(approver);

  t.is(request.path, `/v3/consent/approver_assignments`);
  t.is(request.headers.accept, 'application/json');
  const json = JSON.parse(JSON.stringify(approverAssignmentJsonApi));
  delete json.id;
  t.deepEqual(request.requestBody, { data: json });
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.is(response.id, 3);
  t.is(response.type, 'consent__approver_group_assignments');

  t.is(approverGroup.approverAssignments[0].id, 3);
  t.is(approverGroup.approverAssignments[0].type, 'consent__approver_group_assignments');

  t.is(approverGroup.approvers[0].id, 1);
  t.is(approverGroup.approvers[0].type, 'consent__approvers');
});


// ApproverGroup.addFormVersion
/**
 * @test {ApproverGroup.addFormVersion}
 */
test('[unit] ApproverGroup.addFormVersion should successfully insert an approverGroupAssignment with a consentFormVersion and approverGroup when approverGroupAssignment.id does not exist', async (t) => {
  const { approverGroupJsonApi, approverGroupAssignmentJsonApi, insertResponseAssignment } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  approverGroup.id = 3;
  const consentFormVersion = new ConsentFormVersion({ id: 6 });
  let request = {};
  nock(client.apiBaseUrl).post(`/v3/consent/approver_group_assignments`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [201, insertResponseAssignment];
  });
  const response = await approverGroup.addFormVersion(consentFormVersion);
  t.is(request.path, `/v3/consent/approver_group_assignments`);
  t.is(request.headers.accept, 'application/json');
  const json = JSON.parse(JSON.stringify(approverGroupAssignmentJsonApi));
  delete json.id;
  t.deepEqual(request.requestBody, { data: json });
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.is(response.id, 3);
  t.is(response.type, 'consent__approver_group_assignments');

  t.is(approverGroup.approverAssignments[0].id, 3);
  t.is(approverGroup.approverAssignments[0].type, 'consent__approver_group_assignments');
  t.is(approverGroup.approverAssignments[0].formVersion.id, 6);
  t.is(approverGroup.approverAssignments[0].formVersion.type, 'consent__form_versions');

  t.is(approverGroup.formVersions[0].id, 6);
  t.is(approverGroup.formVersions[0].type, 'consent__form_versions');
});


// ApproverGroup.getApproverAssignments method
/**
 * @test {ApproverGroup.getApproverAssignments}
 */
test.serial('[unit] ApproverGroup.getApproverAssignments should throw an error when there is no authToken or invalid params', async (t) => {
  const { approverGroupJsonApi } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });

  client.authToken = undefined;
  const title = `ApproverGroupService.getChildren error`;
  await t.throwsAsync(approverGroup.getApproverAssignments(approverGroup, { type: 'consent__approver_assignments' }), `${title}: requires authToken`);
});

/**
 * @test {ApproverGroup.getApproverAssignments}
 */
test(`[unit] ApproverGroup.getApproverAssignments should receive a valid request and response for a get request without an id`, async (t) => {
  const { approverGroupJsonApi, getResponseAssignments } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  let request = {};
  nock(client.apiBaseUrl).get(`/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [200, getResponseAssignments];
  });
  const response = await approverGroup.getApproverAssignments();
  t.is(request.path, `/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`);
  t.is(request.headers.accept, 'application/json');
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');

  t.truthy(response);
  t.is(Object.keys(response).length, 3);
  t.truthy(response[0] instanceof ApproverAssignment);
  t.is(response[0].id, 1);
  t.is(response[0].type, 'consent__approver_assignments');
  t.truthy(response[0].approver);
  t.is(response[0].approver.id, 1);
  t.truthy(response[1] instanceof ApproverAssignment);
  t.is(response[1].id, 2);
  t.is(response[1].type, 'consent__approver_assignments');
  t.truthy(response[2] instanceof ApproverAssignment);
  t.is(response[2].id, 3);
  t.is(response[2].type, 'consent__approver_assignments');

  t.is(approverGroup.approverAssignments[0].id, 1);
  t.is(approverGroup.approverAssignments[0].type, 'consent__approver_assignments');

  t.truthy(approverGroup.approvers[0]);
  t.is(approverGroup.approvers[0].id, 1);
});

// /**
//  * @test {ApproverGroup.getApproverAssignments}
//  */
// test('[unit] ApproverGroup.getApproverAssignments should receive a valid response for a get request with an id', async (t) => {
//   const { approverGroupJsonApi, getResponseAssignment20 } = t.context;
//   const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
//   const approverAssignment = new ApproverAssignment({ id: 20 });
//   let request = {};
//   nock(client.apiBaseUrl).get(`/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments/${approverAssignment.id}`).reply(function (uri, requestBody) {
//     request = this.req;
//     request.requestBody = requestBody;
//     return [200, getResponseAssignment20];
//   });
//   const response = await approverGroup.getApproverAssignments({ id: 20 });
//   t.is(request.path, `/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments/${approverAssignment.id}`);
//   t.is(request.headers.accept, 'application/json');
//   t.is(request.headers['content-type'], 'application/json');
//   t.is(request.headers.authorization, 'Token token=valid_token');

//   t.truthy(response);
//   t.truthy(response instanceof ApproverAssignment);
//   t.is(response.id, 20);
//   t.is(response.type, 'consent__approver_assignments');
//   t.is(response.createdAt, '2018-04-17T19:59:53Z');
//   t.is(response.updatedAt, '2018-04-17T19:59:53Z');
//   t.truthy(response.approver);
//   t.is(response.approver.id, 278);
//   t.is(response.approver.createdAt, '2018-04-17T19:59:54Z');
//   t.is(response.approver.email, 'user418@fake.com');
//   t.is(response.approver.updatedAt, '2018-04-17T19:59:54Z');
//   t.is(response.approver.uuid, '7731e5db-3c94-4596-8a52-cb753b9d23bd');
//   t.truthy(response.approverGroup);
//   t.is(response.approverGroup.id, 2);
//   t.is(response.approverGroup.type, 'approverGroups');
// });


// ApproverGroup.getApprovers method
/**
 * @test {ApproverGroup.getApprovers}
 */
test.serial('[unit] ApproverGroup.getApprovers should throw an error when there is no authToken or invalid params', async (t) => {
  const { approverGroupJsonApi } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });

  client.authToken = undefined;
  const title = `ApproverGroupService.getChildren error`;
  await t.throwsAsync(approverGroup.getApprovers(approverGroup, { type: 'consent__approver_assignments' }), `${title}: requires authToken`);
});

/**
 * @test {ApproverGroup.getApprovers}
 */
test(`[unit] ApproverGroup.getApprovers should receive a valid request and response for a get request without an id`, async (t) => {
  const { approverGroupJsonApi, getResponseAssignments } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  let request = {};
  nock(client.apiBaseUrl).get(`/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [200, getResponseAssignments];
  });
  const response = await approverGroup.getApprovers();
  t.is(request.path, `/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`);
  t.is(request.headers.accept, 'application/json');
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');

  t.truthy(response);
  t.is(Object.keys(response).length, 3);
  t.truthy(response[0] instanceof ConsentApprover);
  t.is(response[0].id, 1);
  t.is(response[0].type, 'consent__approvers');
  t.truthy(response[1] instanceof ConsentApprover);
  t.is(response[1].id, 2);
  t.is(response[1].type, 'consent__approvers');
  t.truthy(response[2] instanceof ConsentApprover);
  t.is(response[2].id, 3);
  t.is(response[2].type, 'consent__approvers');
});


// ApproverGroup.removeApprover
/**
 * @test {ApproverGroup.removeApprover}
 */
test('[unit] ApproverGroup.removeApprover should successfully remove a approverAssignment with a approver and approverGroup given a approver', async (t) => {
  const { approverGroupJsonApi, getResponseAssignments } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  approverGroup.id = 9;
  const approver = new ConsentApprover({ id: 1 });
  let request = {};
  nock(client.apiBaseUrl).get(`/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`).reply(200, getResponseAssignments);
  nock(client.apiBaseUrl).delete(`/v3/consent/approver_assignments/1`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [204, ''];
  });
  const response = await approverGroup.removeApprover(approver);

  t.is(request.path, `/v3/consent/approver_assignments/1`);
  t.is(request.headers.accept, 'application/json');
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.falsy(response);
});


// ApproverGroup.removeApprover
/**
 * @test {ApproverGroup.removeApprover}
 */
test('[unit] ApproverGroup.removeApprover should successfully remove a approverAssignment with a approver and approverGroup given an assignment', async (t) => {
  const { approverGroupJsonApi, getResponseAssignments } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  approverGroup.id = 9;
  const assignment = new ApproverAssignment({ id: 5 });
  let request = {};
  nock(client.apiBaseUrl).get(`/v3/consent/approver_groups/${approverGroup.id}/consent/approver_assignments`).reply(200, getResponseAssignments);
  nock(client.apiBaseUrl).delete(`/v3/consent/approver_assignments/5`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [204, ''];
  });
  const response = await approverGroup.removeApprover(assignment);

  t.is(request.path, `/v3/consent/approver_assignments/5`);
  t.is(request.headers.accept, 'application/json');
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.falsy(response);
});


// ApproverGroup.removeFormVersion
/**
 * @test {ApproverGroup.removeFormVersion}
 */
test('[unit] ApproverGroup.removeFormVersion should successfully remove an approverGroupAssignment with a consentFormVersion and approverGroup given an approverGroupAssignment', async (t) => {
  const { approverGroupJsonApi } = t.context;
  const approverGroup = new ApproverGroup({ data: approverGroupJsonApi });
  approverGroup.id = 1;
  const assignment = new ApproverGroupAssignment({ id: 5 });
  let request = {};
  nock(client.apiBaseUrl).delete(`/v3/consent/approver_group_assignments/5`).reply(function (uri, requestBody) {
    request = this.req;
    request.requestBody = requestBody;
    return [204, ''];
  });
  const response = await approverGroup.removeFormVersion(assignment);

  t.is(request.path, `/v3/consent/approver_group_assignments/5`);
  t.is(request.headers.accept, 'application/json');
  t.is(request.headers['content-type'], 'application/json');
  t.is(request.headers.authorization, 'Token token=valid_token');
  t.falsy(response);
});