icontract | Design-by-contract in Python3 with informative violation messages and inheritance

I asked this question in the dotnet project

All credit go to @vitek-karas.

The detailed answer is:

Currently this is by design. LoadFromAssemblyPath as well as any other LoadAssembly-like methods only ever load that assembly, they don't try to load a "plugin". For this case to work you would need the AssemblyDependencyResolver and hook it up to the Default ALC (probably via the Resolving event), and hope that there are no collisions between the host app and the plugin (since they will share all dependencies) and so on. Generally this is why it's better to load plugins into their own ALCs as that creates the necessary isolation and also makes it easy to hook up AssemblyDependencyResolver.

Higher-level answer - in 3.0 we didn't try to provide a "plugin load" API as there were too many open questions in how it should behave (the exact isolation behavior is very tricky to get right so that it would work for most use cases). Instead we provided the necessary building blocks (ALC, ADR, diag improvements, ...) and rely on users to write the cca 20 lines of code to implement the custom ALC. In 5.0 we are improving diagnostics by adding detailed tracing around the entire assembly binding process, that should help debugging issues when loading assemblies in general, but specifically when implementing custom ALCs.

Changed direction a little and now have a workable solution.

You can do something like this:

The problem was in the conversion of decimal in json. Json converts automatically decimal numbers into strings, but it was expecting a decimal number, which provoked somehow the exception

It turned out, there was an additional CustomVertxGenerator.java class which extends ClassicAsyncVertxGenerator for vert.x-jooq with a method to handle additional types from/into a String during JSON-conversion. And this was new to me.

When the conversion for numeric types from the postgresql db was fixed in the method of the class, the problem was resolved.

You can remove the AddressOf operator. It is not required in C#:

Should be pretty straight forward, as you directly provide the object on which error() is called to the method under test.

Thus: simply mock that object, for example using Mockito.

And then you use the verify functionality of Mockito to ensure that you see that call to log.error() with the expected string value.

You can find many examples how to do that; for example here.

Given your specific example, you could even write your own stub implementation of that logging interface; and have that code simply remember any strings given to it. So that you can afterwards simply ask the stub to return that string passed into it.

It's a tradeoff. The goal is to fit the type expected by the client. The tradeoff is between 1) having an additional class and 2) forcing an existing type to change.

The pro of 1) is that an existing type remains intact (assuming it does presently make the most sense as the type it is, returning a single IContract); the con of 1) is that it requires more code and more dependencies.

The pro of 2) is that code size and number of dependencies remain lower; the con of 2) is that you subvert the project's types design by changing a type to return a list that will always contain a single element, purely for the sake of the client's expectations.

In strongly typed languages, the types system is intended to be there as an aid to the programmer. The greater verbosity buys the benefits of the type system, and subverting that system doesn't help very much with reducing the verbosity, yet loses the benefits of that type system. As such, I would resolve this in strongly-typed languages with an adapter, not by changing the interface.

In other words, resolve the situation with the principle of least surprise ( https://en.wikipedia.org/wiki/Principle_of_least_astonishment ). If another programmer on the project (or you, yourself, in some months' time) would ordinarily expect an instance of EscalationMapper to return a sole IContract, and so would be surprised to see it return an IEnumerable, then use an adapter ( https://en.wikipedia.org/wiki/Adapter_pattern ). If, conversely, they'd be surprised to see it return a single item, then change the interface.

To get a Contracts collection inside this object you need to change your JSON to this one