@Test
public void given__discoverHeadMerge__when__appliedToContext__then__strategiesCorrect() throws Exception {
    GitHubSCMSourceContext ctx = new GitHubSCMSourceContext(null, SCMHeadObserver.none());
    assumeThat(ctx.wantBranches(), is(false));
    assumeThat(ctx.wantPRs(), is(false));
    assumeThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assumeThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assumeThat(ctx.authorities(), not(hasItem(
            instanceOf(OriginPullRequestDiscoveryTrait.OriginChangeRequestSCMHeadAuthority.class)
    )));
    OriginPullRequestDiscoveryTrait instance = new OriginPullRequestDiscoveryTrait(
            EnumSet.allOf(ChangeRequestCheckoutStrategy.class)
    );
    instance.decorateContext(ctx);
    assertThat(ctx.wantBranches(), is(false));
    assertThat(ctx.wantPRs(), is(true));
    assertThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assertThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assertThat(ctx.originPRStrategies(), Matchers.is(EnumSet.allOf(ChangeRequestCheckoutStrategy.class)));
    assertThat(ctx.authorities(), hasItem(
            instanceOf(OriginPullRequestDiscoveryTrait.OriginChangeRequestSCMHeadAuthority.class)
    ));
}
 

@Test
public void given__discoverMergeOnly__when__appliedToContext__then__strategiesCorrect() throws Exception {
    GitHubSCMSourceContext ctx = new GitHubSCMSourceContext(null, SCMHeadObserver.none());
    assumeThat(ctx.wantBranches(), is(false));
    assumeThat(ctx.wantPRs(), is(false));
    assumeThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assumeThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assumeThat(ctx.authorities(), not(hasItem(
            instanceOf(ForkPullRequestDiscoveryTrait.TrustContributors.class)
    )));
    ForkPullRequestDiscoveryTrait instance = new ForkPullRequestDiscoveryTrait(
            EnumSet.of(ChangeRequestCheckoutStrategy.MERGE),
            new ForkPullRequestDiscoveryTrait.TrustContributors()
    );
    instance.decorateContext(ctx);
    assertThat(ctx.wantBranches(), is(false));
    assertThat(ctx.wantPRs(), is(true));
    assertThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assertThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assertThat(ctx.forkPRStrategies(), Matchers.is(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE)));
    assertThat(ctx.authorities(), hasItem(
            instanceOf(ForkPullRequestDiscoveryTrait.TrustContributors.class)
    ));
}
 

@Test
public void given__nonDefaultTrust__when__appliedToContext__then__authoritiesCorrect() throws Exception {
    GitHubSCMSourceContext ctx = new GitHubSCMSourceContext(null, SCMHeadObserver.none());
    assumeThat(ctx.wantBranches(), is(false));
    assumeThat(ctx.wantPRs(), is(false));
    assumeThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assumeThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assumeThat(ctx.authorities(), not(hasItem(
            instanceOf(ForkPullRequestDiscoveryTrait.TrustContributors.class)
    )));
    ForkPullRequestDiscoveryTrait instance = new ForkPullRequestDiscoveryTrait(
            EnumSet.allOf(ChangeRequestCheckoutStrategy.class),
            new ForkPullRequestDiscoveryTrait.TrustEveryone()
    );
    instance.decorateContext(ctx);
    assertThat(ctx.wantBranches(), is(false));
    assertThat(ctx.wantPRs(), is(true));
    assertThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assertThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assertThat(ctx.forkPRStrategies(), Matchers.is(EnumSet.allOf(ChangeRequestCheckoutStrategy.class)));
    assertThat(ctx.authorities(), hasItem(
            instanceOf(ForkPullRequestDiscoveryTrait.TrustEveryone.class)
    ));
}
 

@Test
public void given__cr_head__when__isAutomaticBuild__then__returns_false() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new BranchBuildStrategyImpl().isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        null,
                        null,
                        null
                ),
                is(false)
        );
    }
}
 

@Test
public void given__cr_head_ignoring_untrusted_changes_when__trusted_revision__then__isAutomaticBuild_returns_true() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        c.createRepository("dummy", MockRepositoryFlags.TRUST_AWARE);
        Integer crNum = c.openChangeRequest("dummy", "master");

        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, crNum, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new ChangeRequestBuildStrategyImpl(false, true).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        null,
                        null,
                        null
                ),
                is(true)
        );
    }
}
 

@Test
public void given__cr_head_ignoring_target_changes__when__first_build__then__isAutomaticBuild_returns_true() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new ChangeRequestBuildStrategyImpl(true, false).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        null,
                        null,
                        null
                ),
                is(true)
        );
    }
}
 

@Test
public void given__cr_head_ignoring_target_changes__when__origin_change__then__isAutomaticBuild_returns_true() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new ChangeRequestBuildStrategyImpl(true, false).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "new-dummy"),
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy")
                ),
                is(true)
        );
    }
}
 

@Test
public void given__cr_head_ignoring_target_changes__when__both_change__then__isAutomaticBuild_returns_true() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new ChangeRequestBuildStrategyImpl(true, false).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "new-dummy"),
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "old-dummy"), "dummy"),
                        null,
                        null
                ),
                is(true)
        );
    }
}
 

@Test
public void given__cr_head_ignoring_target_changes__when__target_change__then__isAutomaticBuild_returns_false() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new ChangeRequestBuildStrategyImpl(true, false).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "old-dummy"), "dummy"),
                        null,
                        null
                ),
                is(false)
        );
    }
}
 

@Test
public void given__cr_head__when__isAutomaticBuild__then__returns_false() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, 1, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);
        assertThat(
                new TagBuildStrategyImpl(null, null).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        null,
                        null,
                        null
                ),
                is(false)
        );
    }
}
 

@Override
protected SCMSource createSource(@Nonnull MultiBranchProject project, @Nonnull BlueScmConfig scmConfig) {
    // Update endpoint only if its GitHub Enterprise
    if(scmConfig.getId().equals(GithubEnterpriseScm.ID)) {
        updateEndpoints(scmConfig.getUri());
    }

    Set<ChangeRequestCheckoutStrategy> strategies = new HashSet<>();
    strategies.add(ChangeRequestCheckoutStrategy.MERGE);

    return new GitHubSCMSourceBuilder(null, scmConfig.getUri(), computeCredentialId(scmConfig),
            (String)scmConfig.getConfig().get("repoOwner"),
            (String)scmConfig.getConfig().get("repository"))
            .withTrait(new BranchDiscoveryTrait(true, true)) //take all branches
            .withTrait(new ForkPullRequestDiscoveryTrait(strategies, new ForkPullRequestDiscoveryTrait.TrustPermission()))
            .withTrait(new OriginPullRequestDiscoveryTrait(strategies))
            .withTrait(new CleanBeforeCheckoutTrait())
            .withTrait(new CleanAfterCheckoutTrait())
            .withTrait(new LocalBranchTrait())
            .build();
}
 

@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildOriginPRMerge(boolean buildOriginPRMerge) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof OriginPullRequestDiscoveryTrait) {
            Set<ChangeRequestCheckoutStrategy> s = ((OriginPullRequestDiscoveryTrait) trait).getStrategies();
            if (buildOriginPRMerge) {
                s.add(ChangeRequestCheckoutStrategy.MERGE);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.MERGE);
            }
            traits.set(i, new OriginPullRequestDiscoveryTrait(s));
            return;
        }
    }
    if (buildOriginPRMerge) {
        traits.add(new OriginPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE)));
    }
}
 

@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildForkPRMerge(boolean buildForkPRMerge) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof ForkPullRequestDiscoveryTrait) {
            ForkPullRequestDiscoveryTrait forkTrait = (ForkPullRequestDiscoveryTrait) trait;
            Set<ChangeRequestCheckoutStrategy> s = forkTrait.getStrategies();
            if (buildForkPRMerge) {
                s.add(ChangeRequestCheckoutStrategy.MERGE);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.MERGE);
            }
            traits.set(i, new ForkPullRequestDiscoveryTrait(s, forkTrait.getTrust()));
            return;
        }
    }
    if (buildForkPRMerge) {
        traits.add(new ForkPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE),
                new ForkPullRequestDiscoveryTrait.TrustPermission()));
    }
}
 

@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildForkPRHead(boolean buildForkPRHead) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof ForkPullRequestDiscoveryTrait) {
            ForkPullRequestDiscoveryTrait forkTrait = (ForkPullRequestDiscoveryTrait) trait;
            Set<ChangeRequestCheckoutStrategy> s = forkTrait.getStrategies();
            if (buildForkPRHead) {
                s.add(ChangeRequestCheckoutStrategy.HEAD);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.HEAD);
            }
            traits.set(i, new ForkPullRequestDiscoveryTrait(s, forkTrait.getTrust()));
            return;
        }
    }
    if (buildForkPRHead) {
        traits.add(new ForkPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.HEAD),
                new ForkPullRequestDiscoveryTrait.TrustPermission()));
    }
}
 

@Test
public void given__discoverHeadOnly__when__appliedToContext__then__strategiesCorrect() throws Exception {
    GitHubSCMSourceContext ctx = new GitHubSCMSourceContext(null, SCMHeadObserver.none());
    assumeThat(ctx.wantBranches(), is(false));
    assumeThat(ctx.wantPRs(), is(false));
    assumeThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assumeThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assumeThat(ctx.authorities(), not(hasItem(
            instanceOf(OriginPullRequestDiscoveryTrait.OriginChangeRequestSCMHeadAuthority.class)
    )));
    OriginPullRequestDiscoveryTrait instance = new OriginPullRequestDiscoveryTrait(
            EnumSet.of(ChangeRequestCheckoutStrategy.HEAD)
    );
    instance.decorateContext(ctx);
    assertThat(ctx.wantBranches(), is(false));
    assertThat(ctx.wantPRs(), is(true));
    assertThat(ctx.prefilters(), is(Collections.<SCMHeadPrefilter>emptyList()));
    assertThat(ctx.filters(), is(Collections.<SCMHeadFilter>emptyList()));
    assertThat(ctx.originPRStrategies(), Matchers.is(EnumSet.of(ChangeRequestCheckoutStrategy.HEAD)));
    assertThat(ctx.authorities(), hasItem(
            instanceOf(OriginPullRequestDiscoveryTrait.OriginChangeRequestSCMHeadAuthority.class)
    ));
}
 

/**
 * Legacy setter.
 *
 * @param buildOriginPRMerge see {@link OriginPullRequestDiscoveryTrait#OriginPullRequestDiscoveryTrait(Set)}.
 * @deprecated use {@link OriginPullRequestDiscoveryTrait}
 */
@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildOriginPRMerge(boolean buildOriginPRMerge) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof OriginPullRequestDiscoveryTrait) {
            Set<ChangeRequestCheckoutStrategy> s = ((OriginPullRequestDiscoveryTrait) trait).getStrategies();
            if (buildOriginPRMerge) {
                s.add(ChangeRequestCheckoutStrategy.MERGE);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.MERGE);
            }
            traits.set(i, new OriginPullRequestDiscoveryTrait(s));
            return;
        }
    }
    if (buildOriginPRMerge) {
        traits.add(new OriginPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE)));
    }
}
 

/**
 * Legacy setter.
 *
 * @param buildOriginPRHead see {@link OriginPullRequestDiscoveryTrait#OriginPullRequestDiscoveryTrait(Set)}.
 * @deprecated use {@link OriginPullRequestDiscoveryTrait}
 */
@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildOriginPRHead(boolean buildOriginPRHead) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof OriginPullRequestDiscoveryTrait) {
            Set<ChangeRequestCheckoutStrategy> s = ((OriginPullRequestDiscoveryTrait) trait).getStrategies();
            if (buildOriginPRHead) {
                s.add(ChangeRequestCheckoutStrategy.HEAD);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.HEAD);
            }
            traits.set(i, new OriginPullRequestDiscoveryTrait(s));
            return;
        }
    }
    if (buildOriginPRHead) {
        traits.add(new OriginPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.HEAD)));
    }
}
 

/**
 * Legacy setter.
 *
 * @param buildForkPRMerge see {@link ForkPullRequestDiscoveryTrait#ForkPullRequestDiscoveryTrait(Set, SCMHeadAuthority)}.
 * @deprecated use {@link ForkPullRequestDiscoveryTrait}
 */
@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildForkPRMerge(boolean buildForkPRMerge) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof ForkPullRequestDiscoveryTrait) {
            ForkPullRequestDiscoveryTrait forkTrait = (ForkPullRequestDiscoveryTrait) trait;
            Set<ChangeRequestCheckoutStrategy> s = forkTrait.getStrategies();
            if (buildForkPRMerge) {
                s.add(ChangeRequestCheckoutStrategy.MERGE);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.MERGE);
            }
            traits.set(i, new ForkPullRequestDiscoveryTrait(s, forkTrait.getTrust()));
            return;
        }
    }
    if (buildForkPRMerge) {
        traits.add(new ForkPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE),
                new ForkPullRequestDiscoveryTrait.TrustPermission()));
    }
}
 

/**
 * Legacy setter.
 *
 * @param buildForkPRHead see
 * {@link ForkPullRequestDiscoveryTrait#ForkPullRequestDiscoveryTrait(Set, SCMHeadAuthority)}.
 * @deprecated use {@link ForkPullRequestDiscoveryTrait}
 */
@Deprecated
@Restricted(DoNotUse.class)
@RestrictedSince("2.2.0")
@DataBoundSetter
public void setBuildForkPRHead(boolean buildForkPRHead) {
    for (int i = 0; i < traits.size(); i++) {
        SCMTrait<?> trait = traits.get(i);
        if (trait instanceof ForkPullRequestDiscoveryTrait) {
            ForkPullRequestDiscoveryTrait forkTrait = (ForkPullRequestDiscoveryTrait) trait;
            Set<ChangeRequestCheckoutStrategy> s = forkTrait.getStrategies();
            if (buildForkPRHead) {
                s.add(ChangeRequestCheckoutStrategy.HEAD);
            } else {
                s.remove(ChangeRequestCheckoutStrategy.HEAD);
            }
            traits.set(i, new ForkPullRequestDiscoveryTrait(s, forkTrait.getTrust()));
            return;
        }
    }
    if (buildForkPRHead) {
        traits.add(new ForkPullRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.HEAD),
                new ForkPullRequestDiscoveryTrait.TrustPermission()));
    }
}
 

/**
 * Constructor.
 *
 * @param id the merge request id.
 * @param name the name of the head.
 * @param target the target of this merge request.
 * @param strategy the checkout strategy
 * @param origin the origin of the merge request
 * @param originOwner the name of the owner of the origin project
 * @param originProjectPath the name of the origin project path
 * @param originName the name of the branch in the origin project
 * @param title the title of the merge request
 */
public MergeRequestSCMHead(@NonNull String name, long id, BranchSCMHead target,
    ChangeRequestCheckoutStrategy strategy, SCMHeadOrigin origin, String originOwner,
    String originProjectPath, String originName, String title) {
    super(name);
    this.id = id;
    this.target = target;
    this.strategy = strategy;
    this.origin = origin;
    this.originOwner = originOwner;
    this.originProjectPath = originProjectPath;
    this.originName = originName;
    this.title = title;
}
 

/**
 * Constructor for programmatic instantiation.
 *
 * @param strategies the {@link ChangeRequestCheckoutStrategy} instances.
 * @param trust the authority.
 */
public ForkMergeRequestDiscoveryTrait(@NonNull Set<ChangeRequestCheckoutStrategy> strategies,
    @NonNull SCMHeadAuthority<? super GitLabSCMSourceRequest, ? extends
        ChangeRequestSCMHead2, ? extends SCMRevision> trust) {
    this((strategies.contains(ChangeRequestCheckoutStrategy.MERGE) ? 1 : 0)
        + (strategies.contains(ChangeRequestCheckoutStrategy.HEAD) ? 2 : 0), trust);
}
 

/**
 * Returns the strategies.
 *
 * @return the strategies.
 */
@NonNull
public Set<ChangeRequestCheckoutStrategy> getStrategies() {
    switch (strategyId) {
        case 1:
            return EnumSet.of(ChangeRequestCheckoutStrategy.MERGE);
        case 2:
            return EnumSet.of(ChangeRequestCheckoutStrategy.HEAD);
        case 3:
            return EnumSet
                .of(ChangeRequestCheckoutStrategy.HEAD, ChangeRequestCheckoutStrategy.MERGE);
        default:
            return EnumSet.noneOf(ChangeRequestCheckoutStrategy.class);
    }
}
 

/**
 * Constructor.
 *
 * @param source the source.
 * @param context the context.
 * @param listener the listener.
 */
GitLabSCMSourceRequest(SCMSource source, GitLabSCMSourceContext context,
    TaskListener listener) {
    super(source, context, listener);
    fetchBranches = context.wantBranches();
    fetchTags = context.wantTags();
    fetchOriginMRs = context.wantOriginMRs();
    fetchForkMRs = context.wantForkMRs();
    originMRStrategies = fetchOriginMRs && !context.originMRStrategies().isEmpty()
        ? Collections.unmodifiableSet(EnumSet.copyOf(context.originMRStrategies()))
        : Collections.<ChangeRequestCheckoutStrategy>emptySet();
    forkMRStrategies = fetchForkMRs && !context.forkMRStrategies().isEmpty()
        ? Collections.unmodifiableSet(EnumSet.copyOf(context.forkMRStrategies()))
        : Collections.<ChangeRequestCheckoutStrategy>emptySet();
    Set<SCMHead> includes = context.observer().getIncludes();
    if (includes != null) {
        Set<Long> mergeRequestNumbers = new HashSet<>(includes.size());
        Set<String> branchNames = new HashSet<>(includes.size());
        Set<String> tagNames = new HashSet<>(includes.size());
        for (SCMHead h : includes) {
            if (h instanceof BranchSCMHead) {
                branchNames.add(h.getName());
            } else if (h instanceof MergeRequestSCMHead) {
                mergeRequestNumbers.add(Long.parseLong(((MergeRequestSCMHead) h).getId()));
                if (SCMHeadOrigin.DEFAULT.equals(h.getOrigin())) {
                    branchNames.add(((MergeRequestSCMHead) h).getOriginName());
                }
            } else if (h instanceof GitLabTagSCMHead) {
                tagNames.add(h.getName());
            }
        }
        this.requestedMergeRequestNumbers = Collections.unmodifiableSet(mergeRequestNumbers);
        this.requestedOriginBranchNames = Collections.unmodifiableSet(branchNames);
        this.requestedTagNames = Collections.unmodifiableSet(tagNames);
    } else {
        requestedMergeRequestNumbers = null;
        requestedOriginBranchNames = null;
        requestedTagNames = null;
    }
}
 

/**
 * Returns the {@link ChangeRequestCheckoutStrategy} to create for merge requests of the
 * specified type.
 *
 * @param fork {@code true} to return strategies for the fork merge requests, {@code false} for
 * origin merge requests.
 * @return the {@link ChangeRequestCheckoutStrategy} to create for each merge request.
 */
@NonNull
public final Set<ChangeRequestCheckoutStrategy> getMRStrategies(boolean fork) {
    if (fork) {
        return fetchForkMRs ? getForkMRStrategies()
            : Collections.<ChangeRequestCheckoutStrategy>emptySet();
    }
    return fetchOriginMRs ? getOriginMRStrategies()
        : Collections.<ChangeRequestCheckoutStrategy>emptySet();
}
 

/**
 * Returns the {@link ChangeRequestCheckoutStrategy} to create for each merge request.
 *
 * @return a map of the {@link ChangeRequestCheckoutStrategy} to create for each merge request
 * keyed by whether the strategy applies to forks or not ({@link Boolean#FALSE} is the key for
 * origin merge requests)
 */
public final Map<Boolean, Set<ChangeRequestCheckoutStrategy>> getMRStrategies() {
    Map<Boolean, Set<ChangeRequestCheckoutStrategy>> result = new HashMap<>();
    for (Boolean fork : new Boolean[]{Boolean.TRUE, Boolean.FALSE}) {
        result.put(fork, getMRStrategies(fork));
    }
    return result;
}
 

@NonNull
public List<SCMSourceTrait> getTraitsDefaults() {
    return Arrays.<SCMSourceTrait>asList( // TODO finalize
            new BranchDiscoveryTrait(true, false),
            new OriginMergeRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE)),
            new ForkMergeRequestDiscoveryTrait(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE),
                    new ForkMergeRequestDiscoveryTrait.TrustPermission()));
}
 

@Test
public void given__cr_head_ignoring_untrusted_changes_when__trusted_unavailable__then__isAutomaticBuild_returns_false() throws Exception {
    try (MockSCMController c = MockSCMController.create()) {
        c.createRepository("dummy", MockRepositoryFlags.TRUST_AWARE);
        Integer crNum = c.openChangeRequest("dummy", "master");

        MockChangeRequestSCMHead head = new MockChangeRequestSCMHead(SCMHeadOrigin.DEFAULT, crNum, "master",
                ChangeRequestCheckoutStrategy.MERGE, true);

        c.addFault(new MockFailure() {
            @Override
            public void check(String repository, String branchOrCR, String revision, boolean actions)
                    throws IOException {
                throw new IOException("Fail");
            }
        });
        assertThat(
                new ChangeRequestBuildStrategyImpl(false, true).isAutomaticBuild(
                        new MockSCMSource(c, "dummy"),
                        head,
                        new MockChangeRequestSCMRevision(head,
                                new MockSCMRevision(new MockSCMHead("master"), "dummy"), "dummy"),
                        null,
                        null,
                        null
                ),
                is(false)
        );
    }
}
 

@Test
public void given__legacyCode__when__constructor_cloud__then__discoveryTraitDefaults() throws Exception {
    GitHubSCMSource instance = new GitHubSCMSource("preserve-id", null, "SAME",
            "e4d8c11a-0d24-472f-b86b-4b017c160e9a", "cloudbeers", "stunning-adventure");
    assertThat(instance.getId(), is("preserve-id"));
    assertThat(instance.getApiUri(), is(GitHubSCMSource.GITHUB_URL));
    assertThat(instance.getRepoOwner(), is("cloudbeers"));
    assertThat(instance.getRepository(), is("stunning-adventure"));
    assertThat(instance.getCredentialsId(), is("e4d8c11a-0d24-472f-b86b-4b017c160e9a"));
    assertThat(instance.getTraits(),
            containsInAnyOrder(
                    Matchers.allOf(
                            instanceOf(BranchDiscoveryTrait.class),
                            hasProperty("buildBranch", is(true)),
                            hasProperty("buildBranchesWithPR", is(true))
                    ),
                    Matchers.allOf(
                            instanceOf(ForkPullRequestDiscoveryTrait.class),
                            hasProperty("strategies", is(EnumSet.of(ChangeRequestCheckoutStrategy.MERGE))),
                            hasProperty("trust", instanceOf(ForkPullRequestDiscoveryTrait.TrustPermission.class))
                    )
            )
    );
    // Legacy API
    assertThat(instance.getCheckoutCredentialsId(), is(GitHubSCMSource.DescriptorImpl.SAME));
    assertThat(instance.getIncludes(), is("*"));
    assertThat(instance.getExcludes(), is(""));
    assertThat(instance.getBuildOriginBranch(), is(true));
    assertThat(instance.getBuildOriginBranchWithPR(), is(true));
    assertThat(instance.getBuildOriginPRHead(), is(false));
    assertThat(instance.getBuildOriginPRMerge(), is(false));
    assertThat(instance.getBuildForkPRHead(), is(false));
    assertThat(instance.getBuildForkPRMerge(), is(true));
}
 

@Test
public void testOpenSinglePRThrowsIOOnObserve() throws Exception {
    // Situation: Hitting the Github API for a PR and an IO exception during the getPullRequest
    githubApi.stubFor(
            get(urlEqualTo("/repos/cloudbeers/yolo/pulls/1"))
                    .willReturn(
                            aResponse()
                                    .withHeader("Content-Type", "application/json; charset=utf-8")
                                    .withBodyFile("../PRs/_files/body-yolo-pulls-open-pr.json")));
    SCMHeadObserver mockSCMHeadObserver = Mockito.mock(SCMHeadObserver.class);
    Mockito.when(mockSCMHeadObserver.getIncludes()).thenReturn(Collections
            .singleton(new PullRequestSCMHead("PR-1", "ataylor",
                    "http://localhost:" + githubApi.port(), "master", 1,
                    new BranchSCMHead("master"), SCMHeadOrigin.DEFAULT, ChangeRequestCheckoutStrategy.MERGE)));
    GitHubSCMSourceContext context = new GitHubSCMSourceContext(null, mockSCMHeadObserver);
    context.wantPRs();

    //Spy on repo
    GHRepository repoSpy = Mockito.spy(repo);
    GHPullRequest pullRequestSpy = Mockito.spy(repoSpy.getPullRequest(1));
    Mockito.when(repoSpy.getPullRequest(1)).thenReturn(pullRequestSpy);
    //then throw on the PR during observe
    Mockito.when(pullRequestSpy.getUser()).thenThrow(new IOException("Failed to get user"));
    GitHubSCMSourceRequest request = context.newRequest(new GitHubSCMSource("cloudbeers", "yolo", null, false), null);
    Iterator<GHPullRequest> pullRequestIterator = new GitHubSCMSource("cloudbeers", "yolo", null, false)
            .new LazyPullRequests(request, repoSpy).iterator();

    // Expected: In the iterator will have one item in it but when getting that item you receive an IO exception
    assertTrue(pullRequestIterator.hasNext());
    try{
        pullRequestIterator.next();
        fail();
    } catch (Exception e) {
        assertEquals("java.io.IOException: Failed to get user", e.getMessage());
    }
}
 

@Test
public void authority_with_repositoryUrl() throws Exception {
    try (GitHubSCMSourceRequest probe = new GitHubSCMSourceContext(null, SCMHeadObserver.collect()).newRequest(
            new GitHubSCMSource("", "", "https://github.com/example/does-not-exist", true), null)) {
        TagDiscoveryTrait.TagSCMHeadAuthority instance = new TagDiscoveryTrait.TagSCMHeadAuthority();
        assertThat(instance.isTrusted(probe, new SCMHead("v1.0.0")), is(false));
        assertThat(instance.isTrusted(probe, new PullRequestSCMHead("PR-1", "does-not-exists",
                "http://does-not-exist.test", "feature/1", 1, new BranchSCMHead("master"), SCMHeadOrigin.DEFAULT, ChangeRequestCheckoutStrategy.MERGE)), is(false));
        assertThat(instance.isTrusted(probe, new GitHubTagSCMHead("v1.0.0", 0L)), is(true));
    }
}