blob: f5829a2b15fadb60255f2ee35b4264c0c340de5a [file] [log] [blame]
// Copyright (C) 2019 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.findowners;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.flogger.FluentLogger;
import com.google.gerrit.acceptance.PushOneCommit;
import com.google.gerrit.acceptance.TestPlugin;
import com.google.gerrit.reviewdb.client.Project;
import org.junit.Rule;
import org.junit.Test;
/** Test find-owners plugin features related to include and file statements. */
@TestPlugin(name = "find-owners", sysModule = "com.googlesource.gerrit.plugins.findowners.Module")
public class IncludeIT extends FindOwners {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
@Rule public Watcher watcher = new Watcher(logger);
@Test
public void includeNotFoundTest() throws Exception {
// c2 and c1 are both submitted before existence of OWNERS.
PushOneCommit.Result c2 = addFile("1", "t.c", "##");
// Submitted c2 still finds no owners before c1 is submitted.
assertThat(getOwnersResponse(c2)).contains("owners:[], files:[ t.c ]");
PushOneCommit.Result c1 =
addFile("2", "OWNERS", "x@x\na@a\ninclude P1/P2 : f1\ninclude ./d1/d2/../../f2\n");
// Now c2 should find owners, but include directives find no repository or file.
String ownersAX = "owners:[ " + ownerJson("a@a") + ", " + ownerJson("x@x") + " ]";
String path2owners = "path2owners:{ ./:[ a@a, x@x ] }";
String owner2paths = "owner2paths:{ a@a:[ ./ ], x@x:[ ./ ] }";
String projectName = project.get();
String expectedInLog =
"project:"
+ projectName
+ ", "
+ "ownersFileName:OWNERS, "
+ "getBranchId:refs/heads/master(FOUND), "
+ "findOwnersFileFor:./t.c, "
+ "findOwnersFileIn:., "
+ "getFile:OWNERS:(...), "
+ "parseLine:include:P1/P2:f1, "
+ "getRepoFile:P1/P2:refs/heads/master:f1, "
+ "getRepoFileException:repositorynotfound:P1/P2, " // repository not found
+ "parseLine:include:(), " // missing file is treated as empty
+ "parseLine:include:"
+ projectName
+ ":./d1/d2/../../f2, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f2, "
+ "getFile:f2(NOTFOUND), " // same repository but f2 is missing
+ "parseLine:include:(), " // missing file is treated as empty
+ "countNumOwners, "
+ "findOwners, "
+ "checkFile:./t.c, "
+ "checkDir:., "
+ "addOwnerWeightsIn:./ "
+ "] ";
String c2Response = getOwnersDebugResponse(c2);
assertThat(c2Response).contains(path2owners);
assertThat(c2Response).contains(owner2paths);
assertThat(c2Response).contains("file2owners:{ ./t.c:[ a@a, x@x ] }");
assertThat(c2Response).contains(ownersAX);
assertThat(c2Response).contains(expectedInLog);
// A submitted change gets owners info from current repository.
String c1Response = getOwnersDebugResponse(c1);
assertThat(c1Response).contains(path2owners);
assertThat(c1Response).contains(owner2paths);
assertThat(c1Response).contains("file2owners:{ ./OWNERS:[ a@a, x@x ] }");
assertThat(c1Response).contains(ownersAX);
}
@Test
public void includeFoundTest() throws Exception {
// Compared with includeNotFoundTest, this one has file "f2" to include.
addFile("c0", "f2", "g1@g\ng2@g\n");
// c2 and c1 are both submitted before existence of OWNERS.
PushOneCommit.Result c2 = addFile("c2", "t.c", "##");
PushOneCommit.Result c1 =
addFile("c1", "OWNERS", "x@x\na@a\ninclude P1/P2 : f1\ninclude ./d1/d2/../../f2\n");
String ownerA = ownerJson("a@a");
String ownerX = ownerJson("x@x");
String ownerG1 = ownerJson("g1@g");
String ownerG2 = ownerJson("g2@g");
String ownersAG1G2X =
"owners:[ " + ownerA + ", " + ownerG1 + ", " + ownerG2 + ", " + ownerX + " ]";
String path2owners = "path2owners:{ ./:[ a@a, g1@g, g2@g, x@x ] }";
String owner2paths = "owner2paths:{ a@a:[ ./ ], g1@g:[ ./ ], g2@g:[ ./ ], x@x:[ ./ ] }";
String projectName = project.get();
String expectedInLog =
"project:"
+ projectName
+ ", "
+ "ownersFileName:OWNERS, "
+ "getBranchId:refs/heads/master(FOUND), "
+ "findOwnersFileFor:./t.c, "
+ "findOwnersFileIn:., "
+ "getFile:OWNERS:(...), "
+ "parseLine:include:P1/P2:f1, "
+ "getRepoFile:P1/P2:refs/heads/master:f1, "
+ "getRepoFileException:repositorynotfound:P1/P2, "
+ "parseLine:include:(), " // P1/P2 is still not found
+ "parseLine:include:"
+ projectName
+ ":./d1/d2/../../f2, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f2, "
+ "getFile:f2:(...), " // f2 is included
+ "countNumOwners, "
+ "findOwners, "
+ "checkFile:./t.c, "
+ "checkDir:., "
+ "addOwnerWeightsIn:./ "
+ "] ";
String c2Response = getOwnersDebugResponse(c2);
assertThat(c2Response).contains(path2owners);
assertThat(c2Response).contains(owner2paths);
assertThat(c2Response).contains("file2owners:{ ./t.c:[ a@a, g1@g, g2@g, x@x ] }");
assertThat(c2Response).contains(ownersAG1G2X);
assertThat(c2Response).contains(expectedInLog);
// A submitted change gets owners info from current repository.
String c1Response = getOwnersDebugResponse(c1);
assertThat(c1Response).contains(path2owners);
assertThat(c1Response).contains(owner2paths);
assertThat(c1Response).contains("file2owners:{ ./OWNERS:[ a@a, g1@g, g2@g, x@x ] }");
assertThat(c1Response).contains(ownersAG1G2X);
}
@Test
public void includeIndirectFileTest() throws Exception {
// Test indirectly included file and relative file path.
addFile("1", "d1/f2", "d1f2@g\n");
addFile("2", "d2/f2", "d2f2@g\n");
addFile("3", "d3/f2", "d3f2@g\n");
addFile("4", "d1/d2/owners", "d1d2@g\ninclude ../f2\n");
addFile("5", "d2/d2/owners", "d2d2@g\ninclude ../f2\n");
addFile("6", "d3/d2/owners", "d3d2@g\ninclude ../f2\n");
addFile("7", "d3/OWNERS", "d3@g\ninclude ../d2/d2/owners\n");
addFile("8", "OWNERS", "x@g\n");
PushOneCommit.Result c1 = createChange("c1", "d3/t.c", "Hello!");
// d3's owners are in d3/OWNERS, d2/d2/owners, d2/f2, OWNERS,
// If the include directories are based on original directory d3,
// then the included files will be d2/d2/owners and d3/f2.
String ownerD3 = ownerJson("d3@g");
String ownerD2 = ownerJson("d2d2@g");
String ownerF2 = ownerJson("d2f2@g");
String ownerX = ownerJson("x@g", 0, 1, 0);
assertThat(getOwnersResponse(c1))
.contains(
"owners:[ "
+ ownerD2
+ ", "
+ ownerF2
+ ", "
+ ownerD3
+ ", "
+ ownerX
+ " ], files:[ d3/t.c ]");
}
@Test
public void includeVsFileTest() throws Exception {
// Test difference between include and file statements.
// The file statement skips "set noparent" and "per-file" statements.
addFile("d1", "d1/OWNERS", "d1@g\n");
addFile("d1/d1", "d1/d1/OWNERS", "per-file *.c=d1d1p@g\nd1d1@g\nfile: d1/OWNERS\n");
addFile("d1/d1/d1", "d1/d1/d1/OWNERS", "set noparent\nper-file *.c=d1d1d1p@g\nd1d1d1@g\n");
addFile("d1/d2", "d1/d2/OWNERS", "per-file *.c=d1d2p@g\nd1d2@g\ninclude d1/OWNERS\n");
addFile("d1/d2/d1", "d1/d2/d1/OWNERS", "set noparent\nper-file *.c=d1d2d1p@g\nd1d2d1@g\n");
addFile("d2", "d2/OWNERS", "d2@g\n");
addFile("d2/d1", "d2/d1/OWNERS", "per-file *.c=d2d1p@g\nd2d1@g\nfile: ./d1/OWNERS\n");
addFile("d2/d1/d1", "d2/d1/d1/OWNERS", "set noparent\nper-file *.c=d2d1d1p@g\nd2d1d1@g\n");
addFile("d2/d2", "d2/d2/OWNERS", "per-file *.c=d2d2p@g\nd2d2@g\ninclude ./d1/OWNERS\n");
addFile("d2/d2/d1", "d2/d2/d1/OWNERS", "set noparent\nper-file *.c=d2d2d1p@g\nd2d2d1@g\n");
addFile("d3", "d3/OWNERS", "d3@g\n");
addFile("d3/d1/d1", "d3/d1/d1/OWNERS", "d3d1d1@g\nfile: ../../../d1/d1/OWNERS\n");
addFile("d3/d1/d2", "d3/d1/d2/OWNERS", "d3d1d2@g\nfile: //d1/d2/OWNERS\n");
addFile("d3/d2/d1", "d3/d2/d1/OWNERS", "d3d2d1@g\ninclude /d2/d1/OWNERS\n");
addFile("d3/d2/d2", "d3/d2/d2/OWNERS", "d3d2d2@g\ninclude //d2/d2/OWNERS\n");
PushOneCommit.Result c11 = createChange("c11", "d3/d1/d1/t.c", "test");
PushOneCommit.Result c12 = createChange("c12", "d3/d1/d2/t.c", "test");
PushOneCommit.Result c21 = createChange("c21", "d3/d2/d1/t.c", "test");
PushOneCommit.Result c22 = createChange("c22", "d3/d2/d2/t.c", "test");
// file and file
String owners11 = "file2owners:{ ./d3/d1/d1/t.c:" + "[ d1d1@g, d1d1d1@g, d3@g, d3d1d1@g ] }";
// file and include
String owners12 = "file2owners:{ ./d3/d1/d2/t.c:" + "[ d1d2@g, d1d2d1@g, d3@g, d3d1d2@g ] }";
// include and file
String owners21 =
"file2owners:{ ./d3/d2/d1/t.c:" + "[ d2d1@g, d2d1d1@g, d2d1p@g, d3@g, d3d2d1@g ] }";
// include and include
String owners22 =
"file2owners:{ ./d3/d2/d2/t.c:" + "[ d2d2@g, d2d2d1@g, d2d2d1p@g, d2d2p@g, d3d2d2@g ] }";
assertThat(getOwnersDebugResponse(c11)).contains(owners11);
assertThat(getOwnersDebugResponse(c12)).contains(owners12);
assertThat(getOwnersDebugResponse(c21)).contains(owners21);
assertThat(getOwnersDebugResponse(c22)).contains(owners22);
}
@Test
public void multipleIncludeTest() throws Exception {
// Now "include" and "file:" statements can share parsed results.
addFile("d1", "d1/OWNERS", "d1@g\n");
addFile("d2/d1", "d2/d1/OWNERS", "include /d1/OWNERS\nfile://d1/OWNERS\n");
addFile("d2/d2", "d2/d2/OWNERS", "file: //d1/OWNERS\ninclude /d1/OWNERS\n");
PushOneCommit.Result c1 = createChange("c1", "d2/d1/t.c", "test");
PushOneCommit.Result c2 = createChange("c2", "d2/d2/t.c", "test");
String projectName = project.get();
String log1 = "parseLine:useSaved:file:" + projectName + "://d1/OWNERS, ";
String log2 = "parseLine:useSaved:include:" + projectName + ":/d1/OWNERS, ";
String response1 = getOwnersDebugResponse(c1);
String response2 = getOwnersDebugResponse(c2);
assertThat(response1).contains(log1);
assertThat(response1).doesNotContain(log2);
assertThat(response2).doesNotContain(log1);
assertThat(response2).contains(log2);
}
@Test
public void includeCycleTest() throws Exception {
// f1 includes f2, f2 includes f3, f3 includes f4, f4 includes f2, OWNERS includes f1.
// All files are in the root directory, but could be referred with relative paths.
addFile("1", "f1", "f1@g\ninclude ./f2\n");
addFile("2", "f2", "f2@g\ninclude d1/../f3\n");
addFile("3", "f3", "f3@g\ninclude /f4\n");
addFile("4", "f4", "f4@g\ninclude d2/../f2\n");
addFile("5", "OWNERS", "x@g\ninclude ./d1/../f1\n");
PushOneCommit.Result c = createChange("6", "t.c", "#\n");
String response = getOwnersDebugResponse(c);
String projectName = project.get();
String expectedInLog =
"project:"
+ projectName
+ ", "
+ "ownersFileName:OWNERS, "
+ "getBranchId:refs/heads/master(FOUND), "
+ "findOwnersFileFor:./t.c, "
+ "findOwnersFileIn:., "
+ "getFile:OWNERS:(...), "
+ "parseLine:include:"
+ projectName
+ ":./d1/../f1, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f1, "
+ "getFile:f1:(...), "
+ "parseLine:include:"
+ projectName
+ ":./f2, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f2, "
+ "getFile:f2:(...), "
+ "parseLine:include:"
+ projectName
+ ":d1/../f3, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f3, "
+ "getFile:f3:(...), "
+ "parseLine:include:"
+ projectName
+ ":/f4, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:f4, "
+ "getFile:f4:(...), "
+ "parseLine:errorRecursion:include:"
+ projectName
+ ":d2/../f2, "
+ "countNumOwners, "
+ "findOwners, "
+ "checkFile:./t.c, "
+ "checkDir:., "
+ "addOwnerWeightsIn:./ "
+ "] ";
assertThat(response).contains("path2owners:{ ./:[ f1@g, f2@g, f3@g, f4@g, x@g ] }");
assertThat(response)
.contains("owner2paths:{ f1@g:[ ./ ], f2@g:[ ./ ], f3@g:[ ./ ], f4@g:[ ./ ], x@g:[ ./ ] }");
assertThat(response).contains(expectedInLog);
}
@Test
public void includeDuplicationTest() throws Exception {
// f0 is included into f1, f2, f3,
// f2 is included into f4 and f5; f4 is included into f5.
// f0, f1, f2, f3, f5 are included into d6/OWNERS.
addFile("0", "d0/f0", "f0@g\n");
addFile("1", "d1/d2/f1", "f1@g\ninclude ../../d0/f0\n");
addFile("2", "d2/f2", "f2@g\ninclude ../d0/f0\n");
addFile("3", "d2/d3/f3", "f3@g\ninclude /d0/f0\n");
addFile("4", "d4/f4", "f4@g\ninclude ../d2/f2\n");
addFile("5", "d4/d5/f5", "f5@g\ninclude /d2/f2\ninclude ../f4\n");
PushOneCommit.Result c =
addFile(
"6",
"d6/OWNERS",
"f6@g\ninclude /d0/f0\ninclude ../d1/d2/f1\n"
+ "include ../d2/f2\ninclude /d2/d3/f3\ninclude /d2/../d4/d5/f5\ninclude /d4/f4\n");
String result = getOwnersDebugResponse(c);
assertThat(result).contains("{ ./d6/OWNERS:[ f0@g, f1@g, f2@g, f3@g, f4@g, f5@g, f6@g ] }");
String projectName = project.get();
String skipLog = "parseLine:useSaved:include:" + projectName + ":";
for (String path : new String[] {"../../d0/f0", "../d0/f0", "../d2/f2", "/d2/f2", "/d4/f4"}) {
assertThat(result).contains(skipLog + path);
}
String expectedInLog =
"project:"
+ projectName
+ ", "
+ "ownersFileName:OWNERS, "
+ "getBranchId:refs/heads/master(FOUND), "
+ "findOwnersFileFor:./d6/OWNERS, "
+ "findOwnersFileIn:./d6, "
+ "getFile:d6/OWNERS:(...), "
+ "parseLine:include:"
+ projectName
+ ":/d0/f0, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d0/f0, "
+ "getFile:d0/f0:(...), "
+ "parseLine:include:"
+ projectName
+ ":../d1/d2/f1, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d1/d2/f1, "
+ "getFile:d1/d2/f1:(...), "
+ "parseLine:useSaved:include:"
+ projectName
+ ":../../d0/f0, "
+ "parseLine:include:"
+ projectName
+ ":../d2/f2, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d2/f2, "
+ "getFile:d2/f2:(...), "
+ "parseLine:useSaved:include:"
+ projectName
+ ":../d0/f0, "
+ "parseLine:include:"
+ projectName
+ ":/d2/d3/f3, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d2/d3/f3, "
+ "getFile:d2/d3/f3:(...), "
+ "parseLine:useSaved:include:"
+ projectName
+ ":/d0/f0, "
+ "parseLine:include:"
+ projectName
+ ":/d2/../d4/d5/f5, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d4/d5/f5, "
+ "getFile:d4/d5/f5:(...), "
+ "parseLine:useSaved:include:"
+ projectName
+ ":/d2/f2, "
+ "parseLine:include:"
+ projectName
+ ":../f4, "
+ "getRepoFile:"
+ projectName
+ ":refs/heads/master:d4/f4, "
+ "getFile:d4/f4:(...), "
+ "parseLine:useSaved:include:"
+ projectName
+ ":../d2/f2, "
+ "parseLine:useSaved:include:"
+ projectName
+ ":/d4/f4, "
+ "findOwnersFileIn:., "
+ "getFile:OWNERS(NOTFOUND), "
+ "countNumOwners, "
+ "findOwners, "
+ "checkFile:./d6/OWNERS, "
+ "checkDir:./d6, "
+ "checkDir:., "
+ "addOwnerWeightsIn:./d6/ "
+ "] ";
assertThat(result).contains(expectedInLog);
}
@Test
public void includeProjectOwnerTest() throws Exception {
// Test include directive with other project name.
Project.NameKey pA = newProject("PA");
Project.NameKey pB = newProject("PB");
String nameA = pA.get();
String nameB = pB.get();
switchProject(pA);
addFile("1", "f1", "pAf1@g\ninclude ./d1/f1\n");
addFile("2", "d1/f1", "pAd1f1@g\ninclude " + nameB + ":" + "/d2/f2\n");
addFile("3", "d2/OWNERS", "pAd2@g\n include " + nameA + " : " + "../f1\n");
addFile("4", "OWNERS", "pA@g\n");
switchProject(pB);
addFile("5", "f1", "pBf1@g\ninclude ./d1/f1\n");
addFile("6", "f2", "pBf2@g\n");
addFile("7", "d1/f1", "pBd1f1@g\n");
addFile("8", "d2/f2", "pBd2f2@g\ninclude ../f1\n");
switchProject(pA);
PushOneCommit.Result c1 = createChange("c1", "d2/t.c", "Hello!");
// included: pA:d2/OWNERS, pA:d2/../f1, pA:d1/f1, pB:d2/f2, pB:d2/../f1, pB:./d1/f1
// inherited: pA:OWNERS
String owners =
"owners:[ "
+ ownerJson("pAd1f1@g")
+ ", "
+ ownerJson("pAd2@g")
+ ", "
+ ownerJson("pAf1@g")
+ ", "
+ ownerJson("pBd1f1@g")
+ ", "
+ ownerJson("pBd2f2@g")
+ ", "
+ ownerJson("pBf1@g")
+ ", "
+ ownerJson("pA@g", 0, 1, 0)
+ " ]";
assertThat(getOwnersResponse(c1)).contains(owners);
}
}