Okay thanks to the hint in this answer by @Xitrum "deregister method" I found a solution:

collectors = list(REGISTRY._collector_to_names.keys())
for collector in collectors:
    REGISTRY.unregister(collector)

Now all tests can start with their own registry:

def test_metrics_endpoint_availability():
    app = create_app()
    FlaskInstrumentator(app).instrument()
    client = app.test_client()

    response = client.get("/")
    response = client.get("/metrics")
    
    # Test stuff
    

def test_grouped_status_codes():
    app = create_app()
    FlaskInstrumentator(app).instrument()
    client = app.test_client()

    client.get("/does_not_exist")  # Should be ignored.
    client.get("/does_not_exist")  # Should be ignored.
    client.post("/")
    client.post("/")
    
    # Test stuff

Edit 2023

Here is a helper function I use for unit tests atm:

from prometheus_client import REGISTRY

def reset_prom_collectors() -> None:
    """Resets collectors in the default Prometheus registry.

    Modifies the `REGISTRY` registry. Supposed to be called at the beginning
    of individual test functions. Else registry is reused across test functions
    and so we can run into errors like duplicate metrics or unexpected values
    for metrics.
    """

    # Unregister all collectors.
    collectors = list(REGISTRY._collector_to_names.keys())
    print(f"before unregister collectors={collectors}")
    for collector in collectors:
        REGISTRY.unregister(collector)
    print(f"after unregister collectors={list(REGISTRY._collector_to_names.keys())}")

    # Import default collectors.
    from prometheus_client import gc_collector, platform_collector, process_collector

    # Re-register default collectors.
    process_collector.ProcessCollector()
    platform_collector.PlatformCollector()
    gc_collector.GCCollector()

    print(f"after re-register collectors={list(REGISTRY._collector_to_names.keys())}")

The same problem I had

In my personal project, I have the same problem and I adopted this solution.

In CollectorRegistry, the class where you store your metrics, there's no method to get Collector object (Collector is the parent class of any metric like Counter, Gauge, Histogram, etc.).

The restricted_registry method creates a subset (a restricted registry) where you have the Metrics that have that name and labels. But "it's experimental", so be careful. It doesn't solve my (our) problem. Because if a metric has a label, you also have to specify its value, and sometimes you can't know it (for example, if you're counting how many https requests you've made):

def restricted_registry(self, names: Iterable[str]) -> "RestrictedRegistry":
    """Returns object that only collects some metrics.

    Returns an object which upon collect() will return
    only samples with the given names.

    Intended usage is:
        generate_latest(REGISTRY.restricted_registry(['a_timeseries']))

    Experimental."""
    names = set(names)
    return RestrictedRegistry(names, self)

So if you're coding a project, and not its tests, don't use it.

My solutions adopted

First solution (fast implementation)

The first is to store all your metrics inside a custom class (eg PrometheusMetrics) where you have a dictionary with all Metrics object, for example (return objects are custom for my case, if you want to use a parent class, writes Collector):

def register_new_metrics(self, metrics: list[Counter | Gauge | Histogram | Summary | Enum]):
    for metric in metrics:
        for metric_obj in metric.describe():
            # Register the new metric inside the registry
            self.get_registry().register(metric)
            # Add it to the dict
            self._metric[metric_obj.name] = metric

And you can invoke it in this way:

self.register_new_metrics([
            Counter(f'name', "documentation", ['label1','label2']),
            Histogram(f'name2', "documentation", ['label1', 'label2', 'label3'])
])

This way you can have a simple get('metric_name') method that returns a requested metric object. This solution doesn't cause any problems if you only create metrics once at the same time as you create a CollectorRegistry (e.g.).

But if you want to create metrics at runtime, don't use this solution. Because Prometheus uses a threading.Lock (doc) inside the CollectorRegistry class and uses it for a lot of operations.

Second solution (more logical than the first)

The second, in my opinion, is another more logical solution. You can create a subclass of CollectorRegistry and create your own method where you get metrics using the protected field self._names_to_collectors and lock the thread with self._lock. After that you can register your own subclass using "Custom Collectors" way (doc):

from prometheus_client import REGISTRY

REGISTRY.register(CustomRegistry())

class CustomRegistry(CollectorRegistry):
    # ...
    def get_metric(metric: str) -> Collector:
        with self._lock:
            self._names_to_collectors.get(metric)
    # ...

If anyone has a better solution, please write! I am also interested in this topic.