src/test/java/com/googlesource/gerrit/plugins/zuul/util/DependsOnFetcherTest.java - plugins/zuul - Git at Google

 // Copyright (C) 2020 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 package com.googlesource.gerrit.plugins.zuul.util;

 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

 import com.google.gerrit.entities.BranchNameKey;
 import com.google.gerrit.entities.Change;
 import com.google.gerrit.entities.PatchSet;
 import com.google.gerrit.entities.Project;
 import com.google.gerrit.extensions.common.ChangeInfo;
 import com.google.gerrit.extensions.restapi.AuthException;
 import com.google.gerrit.extensions.restapi.BadRequestException;
 import com.google.gerrit.extensions.restapi.Response;
 import com.google.gerrit.extensions.restapi.TopLevelResource;
 import com.google.gerrit.server.change.RevisionResource;
 import com.google.gerrit.server.permissions.PermissionBackendException;
 import com.google.gerrit.server.restapi.change.ChangesCollection;
 import com.google.gerrit.server.restapi.change.QueryChanges;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.commons.lang3.tuple.Pair;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.lib.ObjectId;
 import org.junit.Test;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;

 public class DependsOnFetcherTest {
   private ChangesCollection changes;
   private CommitMessageFetcher commitMessageFetcher;
   private DependsOnExtractor dependsOnExtractor;
   private RevisionResource rsrc;
   private Map<Integer, ChangeInfo> changeInfos = new HashMap<>();

   @Test
   public void testExtractNoDependencies() throws Exception {
     configureMocks(new ArrayList<>(), new ArrayList<>());

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft()).isEmpty();
     assertThat(dependsOn.getRight()).isEmpty();
   }

   @Test
   public void testExtractSingleFoundDependency() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));

     List<ChangeInfo> searchResult = new ArrayList<>();
     searchResult.add(getChangeInfo(1));
     configureMocks(extracted, searchResult);

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft()).containsExactly(getChangeInfo(1));
     assertThat(dependsOn.getRight()).isEmpty();
   }

   @Test
   public void testExtractMultipleFoundDependencies() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));
     extracted.add(getChangeKey(2));
     extracted.add(getChangeKey(3));
     List<ChangeInfo> searchResult = new ArrayList<>();
     searchResult.add(getChangeInfo(1));
     searchResult.add(getChangeInfo(2));
     searchResult.add(getChangeInfo(3));
     configureMocks(extracted, searchResult);

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft())
         .containsExactly(getChangeInfo(1), getChangeInfo(2), getChangeInfo(3));
     assertThat(dependsOn.getRight()).isEmpty();
   }

   @Test
   public void testExtractSingleMissingDependency() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));

     configureMocks(extracted, new ArrayList<>());

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft()).isEmpty();
     assertThat(dependsOn.getRight()).containsExactly(getChangeKey(1));
   }

   @Test
   public void testExtractMultipleMissingDependencies() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));
     extracted.add(getChangeKey(2));
     extracted.add(getChangeKey(3));
     configureMocks(extracted, new ArrayList<>());

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft()).isEmpty();
     assertThat(dependsOn.getRight())
         .containsExactly(getChangeKey(1), getChangeKey(2), getChangeKey(3));
   }

   @Test
   public void testExtractMultipleDependenciesMultipleResultsForChangeId() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));
     extracted.add(getChangeKey(2));
     extracted.add(getChangeKey(3));

     List<ChangeInfo> searchResult = new ArrayList<>();
     searchResult.add(getChangeInfo(1));
     searchResult.add(getChangeInfo(2));
     searchResult.add(getChangeInfo(3));

     ChangeInfo changeInfo = getChangeInfo(102);
     changeInfo.changeId = getChangeInfo(2).changeId;
     searchResult.add(changeInfo);

     configureMocks(extracted, searchResult);

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft())
         .containsExactly(getChangeInfo(1), getChangeInfo(2), getChangeInfo(3), getChangeInfo(102));
     assertThat(dependsOn.getRight()).isEmpty();
   }

   @Test
   public void testExtractMixed() throws Exception {
     List<String> extracted = new ArrayList<>();
     extracted.add(getChangeKey(1));
     extracted.add(getChangeKey(2));
     extracted.add(getChangeKey(3));
     extracted.add(getChangeKey(4));

     List<ChangeInfo> searchResult = new ArrayList<>();
     searchResult.add(getChangeInfo(2));
     searchResult.add(getChangeInfo(3));

     ChangeInfo changeInfo = getChangeInfo(102);
     changeInfo.changeId = getChangeInfo(2).changeId;
     searchResult.add(changeInfo);

     configureMocks(extracted, searchResult);

     DependsOnFetcher fetcher = createFetcher();
     Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

     assertThat(dependsOn.getLeft())
         .containsExactly(getChangeInfo(2), getChangeInfo(102), getChangeInfo(3));
     assertThat(dependsOn.getRight()).containsExactly(getChangeKey(1), getChangeKey(4));
   }

   private void configureMocks(
       List<String> extractedDependsOn, List<ChangeInfo> searchResultDependsOn)
       throws RepositoryNotFoundException, IOException, BadRequestException, AuthException,
           PermissionBackendException {
     String commitId = "0123456789012345678901234567890123456789";

     Project.NameKey projectNameKey = Project.nameKey("projectFoo");

     PatchSet patchSet = mock(PatchSet.class);
     when(patchSet.commitId()).thenReturn(ObjectId.fromString(commitId));

     BranchNameKey branchNameKey = BranchNameKey.create(projectNameKey, "branchBar");

     Change.Key changeKey = Change.key("I0123456789");
     Change change = new Change(changeKey, null, null, branchNameKey, null);

     rsrc = mock(RevisionResource.class);
     when(rsrc.getChange()).thenReturn(change);
     when(rsrc.getPatchSet()).thenReturn(patchSet);

     commitMessageFetcher = mock(CommitMessageFetcher.class);
     when(commitMessageFetcher.fetch(projectNameKey, commitId)).thenReturn("commitMsgFoo");

     dependsOnExtractor = mock(DependsOnExtractor.class);
     when(dependsOnExtractor.extract("commitMsgFoo")).thenReturn(extractedDependsOn);

     QueryChanges queryChanges = mock(QueryChanges.class);
     final AtomicBoolean addedQuery = new AtomicBoolean(false);

     if (!extractedDependsOn.isEmpty()) {
       doAnswer(
               new Answer<Void>() {
                 @Override
                 public Void answer(InvocationOnMock invocation) throws Throwable {
                   if (addedQuery.getAndSet(true)) {
                     fail("flag has already been set");
                   }
                   return null;
                 }
               })
           .when(queryChanges)
           .addQuery("change:" + String.join(" OR change:", extractedDependsOn));

       when(queryChanges.apply(TopLevelResource.INSTANCE))
           .thenAnswer(
               new Answer<Response<List<ChangeInfo>>>() {

                 @Override
                 public Response<List<ChangeInfo>> answer(InvocationOnMock invocation)
                     throws Throwable {
                   if (!addedQuery.get()) {
                     fail("executed query before all options were set");
                   }
                   return Response.ok(searchResultDependsOn);
                 }
               });
     }

     changes = mock(ChangesCollection.class);
     when(changes.list()).thenReturn(queryChanges);
   }

   private String getChangeKey(int keyEnding) {
     return "I0123456789abcdef0000000000000000000" + (10000 + keyEnding);
   }

   private ChangeInfo getChangeInfo(int keyEnding) {
     return changeInfos.computeIfAbsent(
         keyEnding,
         neededKeyEnding -> {
           ChangeInfo changeInfo = new ChangeInfo();
           changeInfo.changeId = getChangeKey(neededKeyEnding);
           changeInfo._number = neededKeyEnding;
           return changeInfo;
         });
   }

   private DependsOnFetcher createFetcher() {
     return new DependsOnFetcher(changes, commitMessageFetcher, dependsOnExtractor);
   }
 }
	// Copyright (C) 2020 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	package com.googlesource.gerrit.plugins.zuul.util;

	import static com.google.common.truth.Truth.assertThat;
	import static org.junit.Assert.fail;
	import static org.mockito.Mockito.doAnswer;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.when;

	import com.google.gerrit.entities.BranchNameKey;
	import com.google.gerrit.entities.Change;
	import com.google.gerrit.entities.PatchSet;
	import com.google.gerrit.entities.Project;
	import com.google.gerrit.extensions.common.ChangeInfo;
	import com.google.gerrit.extensions.restapi.AuthException;
	import com.google.gerrit.extensions.restapi.BadRequestException;
	import com.google.gerrit.extensions.restapi.Response;
	import com.google.gerrit.extensions.restapi.TopLevelResource;
	import com.google.gerrit.server.change.RevisionResource;
	import com.google.gerrit.server.permissions.PermissionBackendException;
	import com.google.gerrit.server.restapi.change.ChangesCollection;
	import com.google.gerrit.server.restapi.change.QueryChanges;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.concurrent.atomic.AtomicBoolean;
	import org.apache.commons.lang3.tuple.Pair;
	import org.eclipse.jgit.errors.RepositoryNotFoundException;
	import org.eclipse.jgit.lib.ObjectId;
	import org.junit.Test;
	import org.mockito.invocation.InvocationOnMock;
	import org.mockito.stubbing.Answer;

	public class DependsOnFetcherTest {
	private ChangesCollection changes;
	private CommitMessageFetcher commitMessageFetcher;
	private DependsOnExtractor dependsOnExtractor;
	private RevisionResource rsrc;
	private Map<Integer, ChangeInfo> changeInfos = new HashMap<>();

	@Test
	public void testExtractNoDependencies() throws Exception {
	configureMocks(new ArrayList<>(), new ArrayList<>());

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft()).isEmpty();
	assertThat(dependsOn.getRight()).isEmpty();
	}

	@Test
	public void testExtractSingleFoundDependency() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));

	List<ChangeInfo> searchResult = new ArrayList<>();
	searchResult.add(getChangeInfo(1));
	configureMocks(extracted, searchResult);

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft()).containsExactly(getChangeInfo(1));
	assertThat(dependsOn.getRight()).isEmpty();
	}

	@Test
	public void testExtractMultipleFoundDependencies() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));
	extracted.add(getChangeKey(2));
	extracted.add(getChangeKey(3));
	List<ChangeInfo> searchResult = new ArrayList<>();
	searchResult.add(getChangeInfo(1));
	searchResult.add(getChangeInfo(2));
	searchResult.add(getChangeInfo(3));
	configureMocks(extracted, searchResult);

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft())
	.containsExactly(getChangeInfo(1), getChangeInfo(2), getChangeInfo(3));
	assertThat(dependsOn.getRight()).isEmpty();
	}

	@Test
	public void testExtractSingleMissingDependency() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));

	configureMocks(extracted, new ArrayList<>());

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft()).isEmpty();
	assertThat(dependsOn.getRight()).containsExactly(getChangeKey(1));
	}

	@Test
	public void testExtractMultipleMissingDependencies() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));
	extracted.add(getChangeKey(2));
	extracted.add(getChangeKey(3));
	configureMocks(extracted, new ArrayList<>());

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft()).isEmpty();
	assertThat(dependsOn.getRight())
	.containsExactly(getChangeKey(1), getChangeKey(2), getChangeKey(3));
	}

	@Test
	public void testExtractMultipleDependenciesMultipleResultsForChangeId() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));
	extracted.add(getChangeKey(2));
	extracted.add(getChangeKey(3));

	List<ChangeInfo> searchResult = new ArrayList<>();
	searchResult.add(getChangeInfo(1));
	searchResult.add(getChangeInfo(2));
	searchResult.add(getChangeInfo(3));

	ChangeInfo changeInfo = getChangeInfo(102);
	changeInfo.changeId = getChangeInfo(2).changeId;
	searchResult.add(changeInfo);

	configureMocks(extracted, searchResult);

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft())
	.containsExactly(getChangeInfo(1), getChangeInfo(2), getChangeInfo(3), getChangeInfo(102));
	assertThat(dependsOn.getRight()).isEmpty();
	}

	@Test
	public void testExtractMixed() throws Exception {
	List<String> extracted = new ArrayList<>();
	extracted.add(getChangeKey(1));
	extracted.add(getChangeKey(2));
	extracted.add(getChangeKey(3));
	extracted.add(getChangeKey(4));

	List<ChangeInfo> searchResult = new ArrayList<>();
	searchResult.add(getChangeInfo(2));
	searchResult.add(getChangeInfo(3));

	ChangeInfo changeInfo = getChangeInfo(102);
	changeInfo.changeId = getChangeInfo(2).changeId;
	searchResult.add(changeInfo);

	configureMocks(extracted, searchResult);

	DependsOnFetcher fetcher = createFetcher();
	Pair<List<ChangeInfo>, List<String>> dependsOn = fetcher.fetchForRevision(rsrc);

	assertThat(dependsOn.getLeft())
	.containsExactly(getChangeInfo(2), getChangeInfo(102), getChangeInfo(3));
	assertThat(dependsOn.getRight()).containsExactly(getChangeKey(1), getChangeKey(4));
	}

	private void configureMocks(
	List<String> extractedDependsOn, List<ChangeInfo> searchResultDependsOn)
	throws RepositoryNotFoundException, IOException, BadRequestException, AuthException,
	PermissionBackendException {
	String commitId = "0123456789012345678901234567890123456789";

	Project.NameKey projectNameKey = Project.nameKey("projectFoo");

	PatchSet patchSet = mock(PatchSet.class);
	when(patchSet.commitId()).thenReturn(ObjectId.fromString(commitId));

	BranchNameKey branchNameKey = BranchNameKey.create(projectNameKey, "branchBar");

	Change.Key changeKey = Change.key("I0123456789");
	Change change = new Change(changeKey, null, null, branchNameKey, null);

	rsrc = mock(RevisionResource.class);
	when(rsrc.getChange()).thenReturn(change);
	when(rsrc.getPatchSet()).thenReturn(patchSet);

	commitMessageFetcher = mock(CommitMessageFetcher.class);
	when(commitMessageFetcher.fetch(projectNameKey, commitId)).thenReturn("commitMsgFoo");

	dependsOnExtractor = mock(DependsOnExtractor.class);
	when(dependsOnExtractor.extract("commitMsgFoo")).thenReturn(extractedDependsOn);

	QueryChanges queryChanges = mock(QueryChanges.class);
	final AtomicBoolean addedQuery = new AtomicBoolean(false);

	if (!extractedDependsOn.isEmpty()) {
	doAnswer(
	new Answer<Void>() {
	@Override
	public Void answer(InvocationOnMock invocation) throws Throwable {
	if (addedQuery.getAndSet(true)) {
	fail("flag has already been set");
	}
	return null;
	}
	})
	.when(queryChanges)
	.addQuery("change:" + String.join(" OR change:", extractedDependsOn));

	when(queryChanges.apply(TopLevelResource.INSTANCE))
	.thenAnswer(
	new Answer<Response<List<ChangeInfo>>>() {

	@Override
	public Response<List<ChangeInfo>> answer(InvocationOnMock invocation)
	throws Throwable {
	if (!addedQuery.get()) {
	fail("executed query before all options were set");
	}
	return Response.ok(searchResultDependsOn);
	}
	});
	}

	changes = mock(ChangesCollection.class);
	when(changes.list()).thenReturn(queryChanges);
	}

	private String getChangeKey(int keyEnding) {
	return "I0123456789abcdef0000000000000000000" + (10000 + keyEnding);
	}

	private ChangeInfo getChangeInfo(int keyEnding) {
	return changeInfos.computeIfAbsent(
	keyEnding,
	neededKeyEnding -> {
	ChangeInfo changeInfo = new ChangeInfo();
	changeInfo.changeId = getChangeKey(neededKeyEnding);
	changeInfo._number = neededKeyEnding;
	return changeInfo;
	});
	}

	private DependsOnFetcher createFetcher() {
	return new DependsOnFetcher(changes, commitMessageFetcher, dependsOnExtractor);
	}
	}