testify | common assertions and mocks | Unit Testing library

It seems like .env file is not contained in your image.

Try to execute source .env after copying .env file into the image.

The FindAllStringIndex() function returns the position of bytes, not runes.

You need to import "unicode/utf8" and use utf8.RuneCountInString(text[:pos[0][0]]) and so on instead of pos[0][0] to make sure you count the Unicode code points and not just bytes:

At the most basic level it has to be said that a lack of volatile doesn't guarantee that it will fail. It just means that the JVM is allowed to do optimizations that could lead to failure. But whether those optimizations happen and whether they then lead to failure is influenced by many different factors. Therefore it's often very hard to actually detect these problems, until they become catastrophic.

For a starter, I'd like to summarize conditions that happen to frequently coincide when it does go wrong.

• the non-volatile variable is usually read in a tight loop
• the non-volatile variable is changed rarely, but when it changes it's "important" in some sense.
• the amount of code executed inside that loop is small (roughly small enough to be fully inlined by an aggressive compiler)
• the tight loop over-running has a very visible effect (for example it leads to an exception and not just silently doing unnecessary work).

Note that not all of those are necessary, but they tend to be true when I actually observe the issue.

My personal interpretation (plus some reading on the topic) lead me to these rules of thumb:

• if reading the wrong value won't be noticed, then you simply won't notice if the volatile is missing. If the only bad thing that happens is that you run through a loop a couple of times unnecessarily, then chances are you will never realize that it happens.
• when the reads of the volatile variable happen with enough "distance" between them (where distance is measured by other read access to other parts of memory) then it can often behave as if it was volatile, simply because it drops out of the cache
• any kind of synchronization on anything inside the loops tends to have the effect of invalidating some caches at least and thus causes the variable to act as if it was volatile.

These three alone make it rather hard to actually spot the problem except in very extreme cases (i.e. when executing once too many causes a big crash in your system).

In your specific example, I assume that the feature flag is not something that will be toggled multiple times per second. It's more likely that it's set once per process and then stays untouched.

For example, if you have multiple incoming requests in the same second and halfway through the second you toggle the feature flag it can happen that some of the requests that happen after the toggling will still use the old value, due to having it cached from earlier.

Will you notice? Unlikely. It'll be extremely hard to distinguish "this request came in just before the change" from "this request came in just after the change and wrongly used the old value". If 6 out of 10 requests use the old value instead of the correct 5 out of 10, there's a good chance no one will ever notice.

When you define a rule in a kv file using , that rule gets applied to every instance of that SomeClass that gets created after the kv file is loaded. If you have two different rules like , then the second set of properties from the second rule just get added to the first.

If you want different properties, you can create different classes and define different <> rules. Or, you can define a single rule that contains two instances of the original SomeClass.

In your case you can do something like:

I need to redeclare my testing logic over each function

Correct.

Your function runTestCase[T Item](tc testCase[T]) already provides a reasonable level of abstraction. As you did, you can put there some common logic about starting the test and verifying the expected outcome. However that's about it.

A generic type (or function) under test has to be instantiated with some concrete type sooner or later, and one single test table can only include either one of those types — or interface{}/any, which you can not use to satisfy a specific constraint like int | string.

However, you probably do not need to always test every possible type parameter. The purpose of generics is to write code that works with arbitrary types, and in particular the purpose of constraints is to write code with arbitrary types that support the same operations.

I'd advise to write unit tests for different types only if the code makes use of operators that have different meanings. For example:

• the + operator for numbers (sum) and strings (concatenation)
• the < and > for numbers (greater, lesser) and strings (lexicographically before or after)

See also this where the OP was attempting to do something similar

Solution to the first issue:
when using testify/suite, There are bunch of methods if created for the Suite struct, they will be automatically executed when running the test. That being said, These methods will pass through an interface filter. In the case of .SetupSuite, it has to have NO arguments and No return, in order to run.

Solution to the second issue: There is a way in go-sqlmock to match any kind of data by using sqlmock.AnyArg().

Fixed code:

First, you have a data race. Multiple goroutines write successful without synchronization: undefined behavior.

You may use the sync/atomic package for an easy and safe counting:

if you don't want to consider mockFirebaseAuthClient.On("CreateUser", user).Return("firebaseuniqueid", nil) and mockPostgresRepo.On("CreateUser", user).Return(nil) and just want to mock that calls, then you can use mock.Anything as the argument in both the calls instead of user like this mockFirebaseAuthClient.On("CreateUser", mock.Anything).Return("firebaseuniqueid", nil) . So the arguments will not be considerd and the mock calls will return required value.

I think you want