async def METHOD_NAME(
    decoy: Decoy,
    hardware_api: HardwareControlAPI,
    magnetic_module: MagDeck,
    module_data_mapper: ModuleDataMapper,
    module_identifier: ModuleIdentifier,
) -> None:
    """It should map the module control data to response."""
    expected_response = MagneticModule(
        id="module-id",
        serialNumber="serial-number",
        firmwareVersion="1.2.3",
        hardwareRevision="hardware-revision",
        hasAvailableUpdate=True,
        moduleType=ModuleType.MAGNETIC,
        moduleModel=ModuleModel.MAGNETIC_MODULE_V1,
        usbPort=UsbPort(
            port=42,
            hub=False,
            portGroup=PortGroup.UNKNOWN,
            hubPort=None,
            path="/dev/null",
        ),
        moduleOffset=ModuleCalibrationData.construct(
            offset=Vec3f(x=0, y=0, z=0),
        ),
        data=MagneticModuleData(
            status=MagneticStatus.ENGAGED,
            engaged=True,
            height=101,
        ),
    )
    calibration_offset = module_calibration.ModuleCalibrationOffset(
        slot="D3",
        offset=Point(x=0, y=0, z=0),
        module=ModuleType.MAGNETIC,
        module_id="serial-number",
        source=SourceType.default,
        status=CalibrationStatus(),
    )
    decoy.when(hardware_api.attached_modules).then_return([magnetic_module])
    decoy.when(module_calibration.load_all_module_calibrations()).then_return(
        [
            calibration_offset,
        ]
    )
    decoy.when(magnetic_module.has_available_update()).then_return(True)
    decoy.when(magnetic_module.model()).then_return("magneticModuleV1")
    decoy.when(magnetic_module.device_info).then_return(
        {
            "serial": "serial-number",
            "version": "1.2.3",
        }
    )
    decoy.when(magnetic_module.live_data).then_return(
        {
            "status": "engaged",
            "data": {"engaged": True, "height": 42},
        }
    )
    decoy.when(magnetic_module.usb_port).then_return(
        HardwareUSBPort(
            name="abc",
            port_number=101,
            hub=False,
            port_group=PortGroup.UNKNOWN,
            hub_port=None,
        )
    )
    module_identity = ModuleIdentity(
        module_id="module-id",
        serial_number="serial-number",
        firmware_version="firmware-version",
        hardware_revision="hardware-revision",
    )
    decoy.when(
        module_identifier.identify({"serial": "serial-number", "version": "1.2.3"})
    ).then_return(module_identity)
    decoy.when(
        module_data_mapper.map_data(
            model="magneticModuleV1",
            module_identity=module_identity,
            has_available_update=True,
            live_data={"status": "engaged", "data": {"engaged": True, "height": 42}},
            usb_port=HardwareUSBPort(
                name="abc",
                port_number=101,
                hub=False,
                port_group=PortGroup.UNKNOWN,
                hub_port=None,
            ),
            module_offset=ModuleCalibrationData.construct(
                offset=Vec3f(
                    x=calibration_offset.offset.x,
                    y=calibration_offset.offset.y,
                    z=calibration_offset.offset.z,
                ),
                slot=calibration_offset.slot,
                source=None,
                last_modified=None,
            ),
        )
    ).then_return(expected_response)
    result = await get_attached_modules(
        requested_version=_HTTP_API_VERSION,
        hardware=hardware_api,
        module_data_mapper=module_data_mapper,
        module_identifier=module_identifier,
    )
    assert result.content.data == [expected_response]