validates | useful custom validators for Rails applications

That's related to some unexpected issue related to the use of --nomultiline or IRB.conf[:USE_MULTILINE] = false inside .irbrc file.

Similar issue with the hack

To avoid that issue, you can just skip using --nomultiline option, when launching your rails console.

You can use ValidationError from Yup to achieve this goal. The constructor of ValidationError accepts array of other ValidationError instances. The individual ValidationError instances are capable of holding path and error message and the parent instance will combine them.

Here's the example test function:

If you want to test that a "thing" is deleted, make a fixture without teardown, delete it in the test, then assert if it is deleted.

Note: This was an edge case of the design we didn't consider. I've made the relevant devs teams aware and they'll consider fixing it in a future release.

In the short term, you could try grabbing the last non 0x0 double element of the cell array:

That s in %<...>s denotes "string". From the sprintf docs:

For more complex formatting, Ruby supports a reference by name. %s style uses format style, but %{name} style doesn't.

Example:

As Santiago Squarzon points out, you don't usually need to instantiate an IValidateSetValuesGenerator-implementing class yourself: PowerShell does it for you when you use such a class in a [ValidateSet()] attribute in order to decorate a parameter in a function's or script's parameter-declaration block (param(...)), so as to constrain the arguments passed to that parameter to the set of values returned from the specified class' .GetValidValues() instance method.

Note: The IValidateSetValuesGenerator interface requires PowerShell (Core) v6+; for solutions that also work in Windows PowerShell, see this blog post that Santiago found.

If you do need to instantiate such a class explicitly:

instead of the two-line

You can use a single(-line) expression:

The race you are suggesting is very surprising, because it is exactly what DynamoDB claims its conditional updates avoids. So either Amazon have a serious bug in their implementation (which would be surprising, but not impossible), or the race is actually different than what you described in your question.

In your timeline you didn't say how your code resets "StartedRefreshingAt" to nothing. Does the same UpdateTable operation which writes the results of the work back to the table also deletes the StartedRefreshingAt attribute? Because if it's a separate write, it's theoretically possible (even if not common) for the two writes to be reordered. If StartedRefreshingAt is deleted first, at that moment the second process can start its own work - before the first process's results were written - so the problem you described can happen.

Another thing you didn't say is how your processing reads the work from the item. If you accidentally used eventual consistency for the read, instead of strong consistency, it is possible that execution 2 actually did start after execution 1 was finished, but when it read the work it needs to do - it read again the old value and not what execution 1 wrote - so execution 2 ended up repeating 1's work instead of doing new work.

I don't know if either of these guesses makes sense because I don't know the details of your application, but I think the possibility that DynamoDB consistency simply doesn't work as promised is the last guess I would make.

This diagram is not bad. It is however somewhat confusing, because:

• Login is not really a use-case, even if it's a popular practice. This has however no impact on your SD diagram itself.
• Showing actors in a sequence diagram is not formally correct, even if it's a popular practice.
• Login Screen is in fact a part of System, which creates a kind of implicit redundancy.

Don't worry about too much about the two first points, if this is the kind of practices that your teacher showed you.

The last point could easily be addressed:

• The last lifeline could be more specific about the internals (example here), or,
• Keep only two lifelines, one for the actor and one for the system. THis is in my view the better alternative when you use actors in a SD.

Ad.1. You can go either way - store the current RT in the DB and check if it's there, or store all the used RTs and check that the current RT is not there. Either will work. With the latter option you get that additional benefit of being able to revoke all RTs if you see someone trying to reuse an RT. On the other hand, as you pointed out, it may mean that the database will get substantially large. That's the kind of decisions you have to make when designing your system: I want to provide better RT security but I will need to spend more money on a larger DB.

Of course you don't have to keep all the tokens indefinitely. There is no added value in checking that someone reused a token from two years ago.

Ad. 2. Different systems can have different ways of deciding what is a "refresh token family", but I would say these are tokens issued for the given user and client. Maybe in some cases you could limit that to a given audience. In some Identity Server you will have some sort of consent object saved and tokens related to this consent object. This can also be a good candidate for identifying all the tokens you need to revoke.

Ad. 3. Access and refresh tokens are not meant to be used as a mechanism for session. The token just expires, there is no concept of a user logging out. If you really want this sort of feature you will have to keep information about tokens in the database together with an information whether the user has actively logged out. If so, then you can decline those tokens. It is a bit of a workaround, though, and usually using sessions will just be more straightforward in this case.