WAL 202 did exceptions

[SuperBatata]

Description

Provide a clear and concise description of the changes made in this pull request:
Enhance did exceptions with custom exceptions with meaningful error messages

Type of Change

• bug fix - change which fixes an issue
• new feature - change which adds functionality

Checklist

• code cleanup and self-review
• unit + e2e test coverage
• documentation updated accordingly

Breaking

• -

[sonarcloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarCloud

[mikeplotean]

require already throws an IllegalArgumentException and within that lambda function you provide the message which the exception should be constructed with

so, what happens when you throw within the lambda lazyMessage function itself is:

1. require calls lazyMessage() to retrieve the message / object to get passed along with the exception
2. during that call it fails
3. and throws the exception that was constructed within the lazyMessage function (hence never finishing the assignment to message and not proceeding with the rest of the flow)

an option would be to create a custom require method, e.g.:

private fun require(condition: Boolean, type: KType, callback: () -> String) {
    if (!condition) {
        throw createException(type, callback())
    }
}

private fun createException(type: KType, message: String) = when (type) {
    typeOf<InvalidServiceIdException>() -> InvalidServiceIdException(message)
    typeOf<InvalidServiceTypeException>() -> InvalidServiceTypeException(message)
    typeOf<EmptyServiceEndpointException>() -> EmptyServiceEndpointException(message)
    else -> IllegalArgumentException(message)
}

then call it, e.g.:

init {
    require(id.isNotBlank(), typeOf<InvalidServiceIdException>()) { "Service property id cannot be blank" }
    type.forEach {
        require(it.isNotBlank(), typeOf<InvalidServiceTypeException>()) { "Service type strings cannot be blank" }
    }
    require(
        serviceEndpoint.isNotEmpty(), typeOf<EmptyServiceEndpointException>()
    ) { "Service endpoint set cannot be empty" }
    customProperties?.forEach {
        require(!reservedKeys.contains(it.key), typeOf<ReservedKeyOverrideException>()) {
            "Invalid attempt to override reserved Service property with key ${it.key} via customProperties map"
        }
    }
}

in pure jvm, require could use more reflection, e.g.:

private fun require(condition: Boolean, clazz: KClass<Throwable>, callback: () -> String) {
    if (!condition) {
        val constructor = clazz::class.primaryConstructor
        throw constructor!!.call(callback()).objectInstance!!
    }
}

but I'm not sure smth. similar is available in multiplatform
however, neither one is an elegant solution