1 /*
   2  * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.io.IOException;
  25 import java.nio.file.Files;
  26 import java.nio.file.Path;
  27 import java.util.List;
  28 import java.util.Arrays;
  29 import java.util.function.Function;
  30 import java.util.stream.Collectors;
  31 import jdk.jpackage.test.JPackageCommand;
  32 import jdk.jpackage.test.PackageType;
  33 import jdk.jpackage.test.PackageTest;
  34 import jdk.jpackage.test.LinuxHelper;
  35 import jdk.jpackage.test.Executor;
  36 import jdk.jpackage.test.Test;
  37 
  38 /**
  39  * Test --license-file parameter. Output of the test should be licensetest*.*
  40  * package bundle. The output package should provide the same functionality as
  41  * the default package and also incorporate license information from
  42  * test/jdk/tools/jpackage/resources/license.txt file from OpenJDK repo.
  43  *
  44  * deb:
  45  *
  46  * Package should install license file /usr/share/doc/licensetest/copyright
  47  * file.
  48  *
  49  * rpm:
  50  *
  51  * Package should install license file in
  52  * %{_defaultlicensedir}/licensetest-1.0/license.txt file.
  53  *
  54  * Mac:
  55  *
  56  * Windows
  57  *
  58  * Installer should display license text matching contents of the license file
  59  * during installation.
  60  */
  61 
  62 /*
  63  * @test
  64  * @summary jpackage with --license-file
  65  * @library ../helpers
  66  * @modules jdk.jpackage/jdk.jpackage.internal
  67  * @run main/othervm/timeout=360 -Xmx512m LicenseTest
  68  */
  69 public class LicenseTest {
  70     public static void main(String[] args) {
  71         Test.run(args, () -> {
  72             new PackageTest().configureHelloApp()
  73             .addInitializer(cmd -> {
  74                 cmd.addArguments("--license-file", LICENSE_FILE);
  75             })
  76             .forTypes(PackageType.LINUX_DEB)
  77             .addBundleVerifier(cmd -> {
  78                 verifyLicenseFileInLinuxPackage(cmd, debLicenseFile(cmd));
  79             })
  80             .addInstallVerifier(cmd -> {
  81                 verifyLicenseFileInstalledDebian(debLicenseFile(cmd));
  82             })
  83             .addUninstallVerifier(cmd -> {
  84                 verifyLicenseFileNotInstalledLinux(debLicenseFile(cmd));
  85             })
  86             .forTypes(PackageType.LINUX_RPM)
  87             .addBundleVerifier(cmd -> {
  88                 verifyLicenseFileInLinuxPackage(cmd,rpmLicenseFile(cmd));
  89             })
  90             .addInstallVerifier(cmd -> {
  91                 verifyLicenseFileInstalledRpm(rpmLicenseFile(cmd));
  92             })
  93             .addUninstallVerifier(cmd -> {
  94                 verifyLicenseFileNotInstalledLinux(rpmLicenseFile(cmd));
  95             })
  96             .run();
  97         });
  98      }
  99 
 100     private static Path rpmLicenseFile(JPackageCommand cmd) {
 101         final Path licenseRoot = Path.of(
 102                 new Executor()
 103                 .setExecutable("rpm")
 104                 .addArguments("--eval", "%{_defaultlicensedir}")
 105                 .executeAndGetFirstLineOfOutput());
 106         final Path licensePath = licenseRoot.resolve(String.format("%s-%s",
 107                 LinuxHelper.getPackageName(cmd), cmd.version())).resolve(
 108                 LICENSE_FILE.getFileName());
 109         return licensePath;
 110     }
 111 
 112     private static Path debLicenseFile(JPackageCommand cmd) {
 113         return cmd.appInstallationDirectory().resolve("share/doc/copyright");
 114     }
 115 
 116     private static void verifyLicenseFileInLinuxPackage(JPackageCommand cmd,
 117             Path expectedLicensePath) {
 118         Test.assertTrue(LinuxHelper.getPackageFiles(cmd).filter(path -> path.equals(
 119                 expectedLicensePath)).findFirst().orElse(null) != null,
 120                 String.format("Check license file [%s] is in %s package",
 121                         expectedLicensePath, LinuxHelper.getPackageName(cmd)));
 122     }
 123 
 124     private static void verifyLicenseFileInstalledRpm(Path licenseFile) {
 125         Test.assertTrue(Files.isReadable(licenseFile), String.format(
 126                 "Check license file [%s] is readable", licenseFile));
 127         try {
 128             Test.assertTrue(Files.readAllLines(licenseFile).equals(
 129                     Files.readAllLines(LICENSE_FILE)), String.format(
 130                     "Check contents of package license file [%s] are the same as contents of source license file [%s]",
 131                     licenseFile, LICENSE_FILE));
 132         } catch (IOException ex) {
 133             throw new RuntimeException(ex);
 134         }
 135     }
 136 
 137     private static void verifyLicenseFileInstalledDebian(Path licenseFile) {
 138         Test.assertTrue(Files.isReadable(licenseFile), String.format(
 139                 "Check license file [%s] is readable", licenseFile));
 140 
 141         Function<List<String>, List<String>> stripper = (lines) -> Arrays.asList(
 142                 String.join("\n", lines).stripTrailing().split("\n"));
 143 
 144         try {
 145             List<String> actualLines = Files.readAllLines(licenseFile).stream().dropWhile(
 146                     line -> !line.startsWith("License:")).collect(
 147                             Collectors.toList());
 148             // Remove leading `License:` followed by the whitespace from the first text line.
 149             actualLines.set(0, actualLines.get(0).split("\\s+", 2)[1]);
 150 
 151             actualLines = stripper.apply(actualLines);
 152 
 153             Test.assertNotEquals(0, String.join("\n", actualLines).length(),
 154                     "Check stripped license text is not empty");
 155 
 156             Test.assertTrue(actualLines.equals(
 157                     stripper.apply(Files.readAllLines(LICENSE_FILE))),
 158                     String.format(
 159                             "Check subset of package license file [%s] is a match of the source license file [%s]",
 160                             licenseFile, LICENSE_FILE));
 161         } catch (IOException ex) {
 162             throw new RuntimeException(ex);
 163         }
 164     }
 165 
 166     private static void verifyLicenseFileNotInstalledLinux(Path licenseFile) {
 167         Test.assertDirectoryExists(licenseFile.getParent(), false);
 168     }
 169 
 170     private static final Path LICENSE_FILE = Test.TEST_SRC_ROOT.resolve(
 171             Path.of("resources", "license.txt"));
 172 }