SONAR-3736 Use Maven dependencies for I18n Harmcrest matchers

- Do not use URLs anymore, to make it easier to test (no need for an
  internet connection)

2 files changed, 30 insertions, 224 deletions

diff --git a/sonar-testing-harness/src/main/java/org/sonar/test/i18n/BundleSynchronizedMatcher.java b/sonar-testing-harness/src/main/java/org/sonar/test/i18n/BundleSynchronizedMatcher.java
index 4ae41847827..ca49bcec1de 100644
--- a/sonar-testing-harness/src/main/java/org/sonar/test/i18n/BundleSynchronizedMatcher.java
+++ b/sonar-testing-harness/src/main/java/org/sonar/test/i18n/BundleSynchronizedMatcher.java
@@ -20,25 +20,15 @@
 package org.sonar.test.i18n;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.apache.commons.io.IOUtils;
 import org.hamcrest.BaseMatcher;
 import org.hamcrest.Description;
-import org.sonar.test.TestUtils;
 
-import java.io.BufferedInputStream;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.MalformedURLException;
-import java.net.URI;
-import java.net.URL;
-import java.util.Collection;
 import java.util.Map;
 import java.util.Properties;
 import java.util.SortedMap;
@@ -51,63 +41,34 @@ import static org.junit.Assert.fail;
 public class BundleSynchronizedMatcher extends BaseMatcher<String> {
 
   public static final String L10N_PATH = "/org/sonar/l10n/";
-  private static final Collection<String> CORE_BUNDLES = Lists.newArrayList("checkstyle.properties", "core.properties",
-      "findbugs.properties", "gwt.properties", "pmd.properties", "squidjava.properties");
-  private static final String GITHUB_RAW_FILE_PATH = "https://raw.github.com/SonarSource/sonar/master/plugins/sonar-l10n-en-plugin/src/main/resources/org/sonar/l10n/";
 
-  private String sonarVersion;
-  private URI referenceEnglishBundleURI;
-  // we use this variable to be able to unit test this class without looking at the real Github core bundles that change all the time
-  private String remote_file_path;
   private String bundleName;
   private SortedMap<String, String> missingKeys;
   private SortedMap<String, String> additionalKeys;
 
-  public BundleSynchronizedMatcher() {
-    this(null, GITHUB_RAW_FILE_PATH);
-  }
-
-  public BundleSynchronizedMatcher(URI referenceEnglishBundleURI) {
-    this.referenceEnglishBundleURI = referenceEnglishBundleURI;
-  }
-
-  public BundleSynchronizedMatcher(String sonarVersion) {
-    this(sonarVersion, GITHUB_RAW_FILE_PATH);
-  }
-
-  @VisibleForTesting
-  BundleSynchronizedMatcher(String sonarVersion, String remote_file_path) {
-    this.sonarVersion = sonarVersion;
-    this.remote_file_path = remote_file_path;
-  }
-
   public boolean matches(Object arg0) {
     if (!(arg0 instanceof String)) {
       return false;
     }
     bundleName = (String) arg0;
 
-    File bundle = getBundleFileFromClasspath(bundleName);
+    // Find the bundle that needs to be verified
+    InputStream bundleInputStream = getBundleFileInputStream(bundleName);
 
-    // Find the default bundle name which should be compared to
-    String defaultBundleName = extractDefaultBundleName(bundleName);
-    File defaultBundle;
-    if (isCoreBundle(defaultBundleName)) {
-      defaultBundle = getBundleFileFromGithub(defaultBundleName);
-    } else if (referenceEnglishBundleURI != null) {
-      defaultBundle = getBundleFileFromProvidedURI(defaultBundleName);
-    } else {
-      defaultBundle = getBundleFileFromClasspath(defaultBundleName);
-    }
+    // Find the default bundle which the provided one should be compared to
+    InputStream defaultBundleInputStream = getDefaultBundleFileInputStream(bundleName);
 
-    // and now let's compare
+    // and now let's compare!
     try {
-      missingKeys = retrieveMissingTranslations(bundle, defaultBundle);
-      additionalKeys = retrieveMissingTranslations(defaultBundle, bundle);
+      missingKeys = retrieveMissingTranslations(bundleInputStream, defaultBundleInputStream);
+      additionalKeys = retrieveMissingTranslations(defaultBundleInputStream, bundleInputStream);
       return missingKeys.isEmpty();
     } catch (IOException e) {
       fail("An error occured while reading the bundles: " + e.getMessage());
       return false;
+    } finally {
+      IOUtils.closeQuietly(bundleInputStream);
+      IOUtils.closeQuietly(defaultBundleInputStream);
     }
   }
 
@@ -159,7 +120,8 @@ public class BundleSynchronizedMatcher extends BaseMatcher<String> {
     }
   }
 
-  protected SortedMap<String, String> retrieveMissingTranslations(File bundle, File referenceBundle) throws IOException {
+  @VisibleForTesting
+  protected static SortedMap<String, String> retrieveMissingTranslations(InputStream bundle, InputStream referenceBundle) throws IOException {
     SortedMap<String, String> missingKeys = Maps.newTreeMap();
 
     Properties bundleProps = loadProperties(bundle);
@@ -175,98 +137,34 @@ public class BundleSynchronizedMatcher extends BaseMatcher<String> {
     return missingKeys;
   }
 
-  private Properties loadProperties(File f) throws IOException {
+  @VisibleForTesting
+  protected static Properties loadProperties(InputStream inputStream) throws IOException {
     Properties props = new Properties();
-    FileInputStream input = new FileInputStream(f);
-    try {
-      props.load(input);
-      return props;
-
-    } finally {
-      IOUtils.closeQuietly(input);
-    }
-  }
-
-  protected File getBundleFileFromGithub(String defaultBundleName) {
-    String remoteFile = computeGitHubURL(defaultBundleName, sonarVersion);
-    URL remoteFileURL = null;
-    try {
-      remoteFileURL = new URL(remoteFile);
-    } catch (MalformedURLException e) {
-      fail("Could not download the original core bundle at: " + remote_file_path + defaultBundleName);
-    }
-    return downloadRemoteFile(defaultBundleName, remoteFileURL);
-  }
-
-  protected String computeGitHubURL(String defaultBundleName, String sonarVersion) {
-    String computedURL = remote_file_path + defaultBundleName;
-    if (sonarVersion != null && !sonarVersion.contains("-SNAPSHOT")) {
-      computedURL = computedURL.replace("/master/", "/" + sonarVersion + "/");
-    }
-    return computedURL;
+    props.load(inputStream);
+    return props;
   }
 
-  protected File getBundleFileFromClasspath(String bundleName) {
-    File bundle = TestUtils.getResource(L10N_PATH + bundleName);
+  @VisibleForTesting
+  protected static InputStream getBundleFileInputStream(String bundleName) {
+    InputStream bundle = BundleSynchronizedMatcher.class.getResourceAsStream(L10N_PATH + bundleName);
     assertThat("File '" + bundleName + "' does not exist in '/org/sonar/l10n/'.", bundle, notNullValue());
-    assertThat("File '" + bundleName + "' does not exist in '/org/sonar/l10n/'.", bundle.exists(), is(true));
     return bundle;
   }
 
-  private File getBundleFileFromProvidedURI(String defaultBundleName) {
-    URL remoteFileURL = null;
-    try {
-      remoteFileURL = referenceEnglishBundleURI.toURL();
-    } catch (MalformedURLException e) {
-      fail("Could not download the original bundle at: " + remote_file_path + defaultBundleName);
-    }
-    return downloadRemoteFile(defaultBundleName, remoteFileURL);
-  }
-
-  private File downloadRemoteFile(String defaultBundleName, URL remoteFileUrl) {
-    File localBundle = new File("target/l10n/download/" + defaultBundleName);
-    try {
-      saveUrlToLocalFile(remoteFileUrl, localBundle);
-    } catch (IOException e) {
-      fail("Could not download the original core bundle at: " + remoteFileUrl.toString() + defaultBundleName);
-    }
-    assertThat("File 'target/tmp/" + defaultBundleName + "' has been downloaded but does not exist.", localBundle, notNullValue());
-    assertThat("File 'target/tmp/" + defaultBundleName + "' has been downloaded but does not exist.", localBundle.exists(), is(true));
-    return localBundle;
-  }
-
-  private void saveUrlToLocalFile(URL url, File localFile) throws IOException {
-    if (localFile.exists()) {
-      localFile.delete();
-    }
-    localFile.getParentFile().mkdirs();
-
-    InputStream in = null;
-    OutputStream fout = null;
-    try {
-      in = new BufferedInputStream(url.openStream());
-      fout = new FileOutputStream(localFile);
-
-      byte data[] = new byte[1024];
-      int count;
-      while ((count = in.read(data, 0, 1024)) != -1) {
-        fout.write(data, 0, count);
-      }
-    } finally {
-      IOUtils.closeQuietly(in);
-      IOUtils.closeQuietly(fout);
-    }
+  @VisibleForTesting
+  protected static InputStream getDefaultBundleFileInputStream(String bundleName) {
+    String defaultBundleName = extractDefaultBundleName(bundleName);
+    InputStream bundle = BundleSynchronizedMatcher.class.getResourceAsStream(L10N_PATH + defaultBundleName);
+    assertThat("Default bundle '" + defaultBundleName + "' could not be found: add a dependency to the corresponding plugin in your POM.", bundle, notNullValue());
+    return bundle;
   }
 
-  public static String extractDefaultBundleName(String bundleName) {
+  @VisibleForTesting
+  protected static String extractDefaultBundleName(String bundleName) {
     int firstUnderScoreIndex = bundleName.indexOf('_');
     assertThat("The bundle '" + bundleName + "' is a default bundle (without locale), so it can't be compared.", firstUnderScoreIndex > 0,
         is(true));
     return bundleName.substring(0, firstUnderScoreIndex) + ".properties";
   }
 
-  public static boolean isCoreBundle(String defaultBundleName) {
-    return CORE_BUNDLES.contains(defaultBundleName);
-  }
-
 }
diff --git a/sonar-testing-harness/src/main/java/org/sonar/test/i18n/I18nMatchers.java b/sonar-testing-harness/src/main/java/org/sonar/test/i18n/I18nMatchers.java
index ea4ac5f5965..b0a492550cc 100644
--- a/sonar-testing-harness/src/main/java/org/sonar/test/i18n/I18nMatchers.java
+++ b/sonar-testing-harness/src/main/java/org/sonar/test/i18n/I18nMatchers.java
@@ -25,8 +25,6 @@ import org.apache.commons.lang.StringUtils;
 import org.sonar.test.TestUtils;
 
 import java.io.File;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.util.Collection;
 import java.util.Map;
 
@@ -39,42 +37,7 @@ public final class I18nMatchers {
   }
 
   /**
-   * <p>
-   * <b>Used by language packs that translate Core bundles.</b>
-   * </p>
-   * Returns a matcher which checks that a translation bundle is up to date with the corresponding English Core bundle.
-   * <ul>
-   * <li>If a version of Sonar is specified, then the check is done against this version of the bundle found on Sonar Github repository.</li>
-   * <li>If sonarVersion is set to NULL, the check is done against the latest version of this bundle found on Github (master branch).</li>
-   * </ul>
-   * 
-   * @param sonarVersion
-   *          the version of the bundle to check against, or NULL to check against the latest source on GitHub
-   * @return the matcher
-   */
-  public static BundleSynchronizedMatcher isBundleUpToDate(String sonarVersion) {
-    return new BundleSynchronizedMatcher(sonarVersion);
-  }
-
-  /**
-   * <p>
-   * <b>Used by language packs that translate third-party bundles.</b>
-   * </p>
-   * Returns a matcher which checks that a translation bundle is up to date with the given reference English bundle from a third-party plugin.
-   * 
-   * @param referenceEnglishBundleURI
-   *          the URI referencing the English bundle to check against
-   * @return the matcher
-   */
-  public static BundleSynchronizedMatcher isBundleUpToDate(URI referenceEnglishBundleURI) {
-    return new BundleSynchronizedMatcher(referenceEnglishBundleURI);
-  }
-
-  /**
-   * <p>
-   * <b>Used only by independent plugins that embeds their own bundles for every language.</b>
-   * </p>
-   * Returns a matcher which checks that a translation bundle is up to date with the corresponding default one found in the same folder.
+   * Returns a matcher which checks that a translation bundle is up to date with the corresponding default one found in the classpath.
    * 
    * @return the matcher
    */
@@ -83,53 +46,9 @@ public final class I18nMatchers {
   }
 
   /**
-   * <p>
-   * <b>Must be used only by independent plugins that embeds their own bundles for every language.</b>
-   * </p>
-   * Checks that all the translation bundles found on the classpath are up to date with the corresponding default one found in the same
-   * folder.
+   * Checks that all the translation bundles found on the classpath are up to date with the corresponding default ones found in the classpath.
    */
   public static void assertAllBundlesUpToDate() {
-    try {
-      assertAllBundlesUpToDate(null, null);
-    } catch (URISyntaxException e) {
-      // Ignore, this can't happen here
-    }
-  }
-
-  /**
-   * <p>
-   * <b>Must be used only by language packs.</b>
-   * </p>
-   * <p>
-   * Depending on the parameters, this method does the following:
-   * <ul>
-   * <li><b>sonarVersion</b>: checks that all the Core translation bundles found on the classpath are up to date with the corresponding English ones found on Sonar 
-   * GitHub repository for the given Sonar version.
-   * <ul><li><i>Note: if sonarVersion is set to NULL, the check is done against the latest version of this bundles found the master branch of the GitHub repository.</i></li></ul>
-   * </li>
-   * <li><b>pluginIdsToBundleUrlMap</b>: checks that other translation bundles found on the classpath are up to date with the reference English bundles of the corresponding
-   * plugins given by the "pluginIdsToBundleUrlMap" parameter.
-   * </li>
-   * </ul>
-   * </p>
-   * <p><br>
-   * The following example will check that the translation of the Core bundles are up to date with version 3.2 of Sonar English Language Pack, and it
-   * will also check that the translation of the bundle of the Web plugin is up to date with the reference English bundle of version 1.2 of the Web plugin:
-   * <pre>
-   * Map<String, String> pluginIdsToBundleUrlMap = Maps.newHashMap();
-   * pluginIdsToBundleUrlMap.put("web", "http://svn.codehaus.org/sonar-plugins/tags/sonar-web-plugin-1.2/src/main/resources/org/sonar/l10n/web.properties");
-   * assertAllBundlesUpToDate("3.2", pluginIdsToBundleUrlMap);
-   * </pre>
-   * </p>
-   * 
-   * @param sonarVersion
-   *          the version of the bundles to check against, or NULL to check against the latest source on GitHub
-   * @param pluginIdsToBundleUrlMap
-   *          a map that gives, for a given plugin, the URL of the English bundle that must be used to check the translation.
-   * @throws URISyntaxException if the provided URLs in the "pluginIdsToBundleUrlMap" parameter are not correct
-   */
-  public static void assertAllBundlesUpToDate(String sonarVersion, Map<String, String> pluginIdsToBundleUrlMap) throws URISyntaxException {
     File bundleFolder = TestUtils.getResource(BundleSynchronizedMatcher.L10N_PATH);
     if (bundleFolder == null || !bundleFolder.isDirectory()) {
       fail("No bundle found in '" + BundleSynchronizedMatcher.L10N_PATH + "'");
@@ -141,18 +60,7 @@ public final class I18nMatchers {
       String bundleName = bundle.getName();
       if (bundleName.indexOf('_') > 0) {
         try {
-          String baseBundleName = BundleSynchronizedMatcher.extractDefaultBundleName(bundleName);
-          String pluginId = StringUtils.substringBefore(baseBundleName, ".");
-          if (BundleSynchronizedMatcher.isCoreBundle(baseBundleName)) {
-            // this is a core bundle => must be checked againt the provided version of Sonar
-            assertThat(bundleName, isBundleUpToDate(sonarVersion));
-          } else if (pluginIdsToBundleUrlMap != null && pluginIdsToBundleUrlMap.get(pluginId) != null) {
-            // this is a third-party plugin translated by a language pack => must be checked against the provided URL
-            assertThat(bundleName, isBundleUpToDate(new URI(pluginIdsToBundleUrlMap.get(pluginId))));
-          } else {
-            // this is the case of a plugin that provides all the bundles for every language => check the bundles inside the plugin
-            assertThat(bundleName, isBundleUpToDate());
-          }
+          assertThat(bundleName, isBundleUpToDate());
         } catch (AssertionError e) {
           failedAssertionMessages.put(bundleName, e.getMessage());
         }