expecter | Expecter Gadget : better expectations

If I follow you correctly, you want to bring the start_datetime of the "end turn" row for the same id_object and name. In MySQL 8.0, you can use window functions for this:

This is a limitation of virtual time and the way the clock is manipulated in StepVerifier. The thenAwait methods are not synchronized with the underlying scheduling (that happens for example as part of the retryBackoff operation). This means that the operator submits retry tasks at a point where the clock has already been advanced by one day. So the second retry is scheduled for + 1 day and 10 seconds, since the clock is at +1 day. After that, the clock is never advanced so the additional request is never made to MockWebServer.

Your case is made even more complicated in the sense that there is an additional component involved, the MockWebServer, that still works "in real time". Though advancing the virtual clock is a very quick operation, the response from the MockWebServer still goes through a socket and thus has some amount of latency to the retry scheduling, which makes things more complicated from the test writing perspective.

One possible solution to explore would be to externalize the creation of the VirtualTimeScheduler and tie advanceTimeBy calls to the mockServer.takeRequest(), in a parallel thread.

I think that the issue you have is caused by SomeUtil.user() not emitting a value.

Why do I think it's the case: I have tried out a simple example to reproduce your issue:

Your problem is not whether Sinon supports this or that, but rather a missing understanding of how "classes" work in Ecmascript, as shown by the attempt at stubbing constructor property in the test code. That will never work, as that property has nothing to do with how any resulting objects turn out. It is simply a reference to the function that was used to create the object. I have covered a very similar topic on the Sinon tracker that you might have interest in reading to gain some core JS foo :-) Basically, it is not possible to stub a constructor, but you can probably coerce your code to use another constructor function in its place through either DI or link seams.

As a matter of fact, a few answers down in the same thread, you will see me covering an example of how I myself designed a Redis using class to be easily testable by supporting dependency injection. You might want to check it out, as it is more or less directly applicable to your example module above.

Another technique, which you already has tried getting to work, is using link seams (using rewire). The Sinon homepage has a nice article on doing this. Both rewire and proxyquire will do the job just fine here: I think you have just complicated the matter a bit by wrapping the require statement with a mock.

Even though I am on the Sinon maintainer team, I never use the mock functionality, so I cannot tell you how to use that, as I think it obscures the testing, but to get the basic link seams working using rewire I would basically remove all the Sinon code first and get the basic case going (removing redis for a stubbed module you have created).

Only then, add Sinon code as required.

I think you need to run the sub tests in parallel.

Can you call t.Parallel() inside the subtests and check ?

We should take different approaches depending on the problem. For example, if we know that we're comparing numbers with any, we can use typeof().

If we're comparing interfaces, for example, we can use this approach:

Using the stringr package:

The fundamentals of Angular - HttpClient - retry() states:

The RxJS library offers several retry operators that are worth exploring. The simplest is called retry() and it automatically re-subscribes to a failed Observable a specified number of times. Re-subscribing to the result of an HttpClient method call has the effect of reissuing the HTTP request.

So every time you call flush it leaves behind an open request. You just need to repeat the request handling and flushing as many times as the service retries the request.

Short Answer

The short answer is that, for at least some complex propTypes like for myProp2, you can only include a single non-null test prop type of any type. This is an inherent limitation to this approach, and comes from a built-in characteristic of React/Jest that causes multiple error conditions that might otherwise have produced identical error messages to be reported only once. In fact, even for simple propTypes like for myProp1, a related but slightly more hidden limitation also exists: you can include any number of different unacceptable non-null test prop values, but never more than one of the same type. e.g. ['', {}, []] will work but ['', 'x', {}, []] will not (note that there are two strings).

This limitation is important as there doesn't currently seem to be a better way of testing propTypes in React. However, the constraints this places on this approach seem manageable, allowing propTypes to still be reasonably tested.

Details

There are currently some significant limitations on how you can use this approach (i.e. mocking console.error) which, if over-stepped, could be the source of some hard-to-trace testing bugs.

The source of these limitations is a behaviour of React (or perhaps Jest in response to React?) that is built-in to its error reporting mechanism. It currently only seems to produce multiple console.error messages, at least for propTypes issues, when those messages are distinct from each other. Presumably the rationale behind this is that repeated identical messages provide no new information and so such a message should only be shown the first time, which seems reasonable. The implication of this, though, is that two distinct error conditions which, when they occur separately, produce identical error messages only result in a single error message when they occur within the same test run. All subsequent identical messages are suppressed. This has several further implications for strategies such as this one that necessarily expect the output from console.error to exactly correlate with test-failing conditions, as follows.

Currently, for simple propTypes (like that for myProp1 in the example code), distinct error messages seem to appear for all unacceptable prop values of different data types, e.g.