Add Skipped Tests to Coverage

I created say connect.go and connect_test.go. For some reason I need to skip some tests in connect_test.go (using t.Skip()), especially when it comes to contacting external APIs and may involve some payments.

However, those tests are decreasing my code coverage in the pipeline, although I am pretty sure that they're working for one simple reason: I already tested them, and didn't make any change thereafter.

I am using:

go test -v -coverprofile=profile.cov -covermode=count ./...

Is there any way to mark those tests as trusted or add them to the coverage by any means?

"Is there any way to mark those tests as trusted or add them to the coverage by any means?"

No.

Especially no as not the (skipped or executed) test determines line coverage percentage but "actual" code being exercised by these tests. So marking a test as "trusted" would have to remember which actual code lines would have been executed by this test.

No. Coverage is calculated during the execution of tests by adding telemetry to your (non-test) code that reports which code is executed.

If you skip a test then the code that would normally be executed by that test is NOT executed, and so will not contribute to coverage results.

The only way to "trust" a test and have it still contribute to coverage would be to contrive some mechanism for the test to still run but have all tests evaluate as "passed", irrespective of the actual outcome. i.e. run the test but ignore any errors.

Which completely defeats the purpose of those tests.

You could do this using the go test package by creating interposer test functions and using those instead of the testing.T functions directly, e.g.

var ignoreFailures bool

func TErrorf(t *testing T, s string, args ...any) {
  if ignoreFailures {
    return
  }
  t.Errorf(s, args...)
}

// then in a test...
func Test(t *testing.T) {
  ignoreFailures = true
  ...
  if wanted != got {
    TErrorf(t, "wanted: %s, got: %s", wanted, got)
  }

(repeated for all functions of testing.T)

But do NOT do this!

The whole point of a test is to make absolutely certain that nothing has changed to break your code so that you aren't relying on "it works on my machine" or "it worked before".

And you will need to do more work if you wish to preserve other aspects of testing.T function behaviours, such as T.Fatal() (to avoid panics in your tests that T.Fatal otherwise would prevent).

Alternative Approach

I suspect you are skipping the tests because they are difficult/costly to execute due to external dependencies.

Interposer functions won't solve that and will likely make things worse as you will still be trying to call the external apis and possibly encountering timeouts, making your tests run even slower as a result.

A better solution is to take the time to mock those dependencies so that you can perform your tests independently of them.

i.e. instead of testing your code by actually calling external apis, mock the apis and create tests that exercise your code for the possible scenarios.

Your tests will likely run more quickly as a result and can run whether or not those apis are physically accessible from the environment in which the tests are running.

If you need integration tests to perform against the real apis, these should be in a separate project that can be run only if/when/where needed.