plugin.setVersion("0.1");
        PluginDescriptor pluginDescriptor = pluginManager.loadPlugin(
                plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());
        assertNotNull(pluginDescriptor);
    }

    @Test
    void testMojoDescriptorRetrieval() throws Exception {
        MavenSession session = createMavenSession(null);
        String goal = "it";

        List<MetadataResult> results = repositorySystem.resolveMetadata(request.getRepositorySession(), requests);

        Versions versions = new Versions();

        for (MetadataResult res : results) {
            ArtifactRepository repository = res.getRequest().getRepository();
            if (repository == null) {
                repository = request.getRepositorySession().getLocalRepository();
            }

        MavenSession mavenSession = createMavenSession(pomFile);
        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
        configuration.setRepositorySession(mavenSession.getRepositorySession());
        ModelSource modelSource = new FileModelSource(pomFile);
        ProjectBuildingResult result = getContainer()
                .lookup(org.apache.maven.project.ProjectBuilder.class)

        // second try, refetch all (possibly outdated) metadata that wasn't updated in the first attempt

        if (!request.getRepositorySession().isOffline() && !requests.isEmpty()) {
            DefaultRepositorySystemSession session = new DefaultRepositorySystemSession(request.getRepositorySession());
            session.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);

            results = repositorySystem.resolveMetadata(session, requests);

        String pluginKey = pluginKey(mojoDescriptor);
        if (validationPluginExcludes(mavenSession.getRepositorySession()).contains(pluginKey)) {
            return;
        }
        PluginValidationIssues pluginIssues = pluginIssues(mavenSession.getRepositorySession())
                .computeIfAbsent(pluginKey, k -> new PluginValidationIssues());

        }

        repositorySystem.injectMirror(request.getRepositorySession(), internalRepositories);

        repositorySystem.injectProxy(request.getRepositorySession(), internalRepositories);

        repositorySystem.injectAuthentication(request.getRepositorySession(), internalRepositories);

        List<ArtifactRepository> dominantRepositories;

                    plugin, session.getRepositorySession(), project.getRemotePluginRepositories());
            plugin.setVersion(pluginVersionResolver.resolve(versionRequest).getVersion());
        }

        try {
            return pluginManager.getPluginDescriptor(
                    plugin, project.getRemotePluginRepositories(), session.getRepositorySession());
        } catch (PluginResolutionException e) {

            resolvePluginVersion(plugin, session, project);
        }

        return pluginManager.getMojoDescriptor(
                plugin, goal, project.getRemotePluginRepositories(), session.getRepositorySession());
    }

    // TODO take repo mans into account as one may be aggregating prefixes of many
    // TODO collect at the root of the repository, read the one at the root, and fetch remote if something is missing

                        repositorySystem.injectMirror(request.getRepositorySession(), Arrays.asList(repo));
                        repositorySystem.injectProxy(request.getRepositorySession(), Arrays.asList(repo));
                        repositorySystem.injectAuthentication(request.getRepositorySession(), Arrays.asList(repo));
                        repos.add(repo);

                    execution.getPlugin(),
                    execution.getGoal(),
                    project.getRemotePluginRepositories(),
                    session.getRepositorySession());

            execution.setMojoDescriptor(mojoDescriptor);
        }

        return mojoDescriptor;
    }

    @Override
    public void setupMojoExecution(