| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.apache.sling.maven.projectsupport; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.plugin.MojoExecutionException; |
| import org.apache.maven.plugin.logging.Log; |
| import org.apache.sling.launchpad.api.LaunchpadContentProvider; |
| import org.apache.sling.maven.projectsupport.bundlelist.v1_0_0.BundleList; |
| import org.apache.sling.maven.projectsupport.bundlelist.v1_0_0.StartLevel; |
| import org.apache.sling.maven.projectsupport.bundlelist.v1_0_0.io.xpp3.BundleListXpp3Reader; |
| import org.junit.Before; |
| import org.junit.BeforeClass; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.TemporaryFolder; |
| import org.mockito.Matchers; |
| import org.mockito.Mockito; |
| import org.mockito.invocation.InvocationOnMock; |
| import org.mockito.stubbing.Answer; |
| |
| /** Test the BundleListContentProvider */ |
| public class BundleListContentProviderTest { |
| private static BundleList bundleList; |
| |
| public static final String TEST_BUNDLE_LIST = "test-bundle-list.xml"; |
| public static final int BUNDLES_IN_TEST_BUNDLE_LIST = 13; |
| |
| private LaunchpadContentProvider provider; |
| private File resourceProviderRoot; |
| private File resourceProviderFile; |
| private File configDirectory; |
| private int logWarningsCount; |
| private String fakeBundlePath; |
| |
| @Rule |
| public TemporaryFolder tempFolder = new TemporaryFolder(); |
| |
| private static final String [] CONFIG_FILES = { |
| "file1.txt", |
| "file2.cfg", |
| "someFile.properties" |
| }; |
| |
| @BeforeClass |
| public static void parseBundleList() throws Exception { |
| final BundleListXpp3Reader reader = new BundleListXpp3Reader(); |
| final InputStream is = BundleListContentProviderTest.class.getClassLoader().getResourceAsStream(TEST_BUNDLE_LIST); |
| assertNotNull("Expecting " + TEST_BUNDLE_LIST + " to be found", is); |
| try { |
| bundleList = reader.read(is); |
| } finally { |
| is.close(); |
| } |
| } |
| |
| @Before |
| public void setupTemporaryFiles() throws IOException { |
| for(String filename: CONFIG_FILES) { |
| final File f = getConfigFile(filename); |
| f.createNewFile(); |
| assertTrue("Expecting temporary config file to have been created: " + f.getAbsolutePath(), f.exists()); |
| } |
| configDirectory = tempFolder.getRoot(); |
| |
| resourceProviderRoot = new File(tempFolder.getRoot(), "RESOURCE_PROVIDER_ROOT"); |
| resourceProviderRoot.mkdirs(); |
| resourceProviderFile = new File(resourceProviderRoot, "RP_FILE_" + System.currentTimeMillis()); |
| resourceProviderFile.createNewFile(); |
| fakeBundlePath = getFakeBundlePath(); |
| } |
| |
| private File getConfigFile(String name) { |
| return new File(tempFolder.getRoot(), name); |
| } |
| |
| private String getFakeBundlePath() { |
| try { |
| return new File("/FAKE_BUNDLE").toURI().toURL().toExternalForm(); |
| } catch (MalformedURLException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| @Before |
| public void setupProvider() { |
| final Log log = Mockito.mock(Log.class); |
| final Answer<Void> countWarningAnswers = new Answer<Void>() { |
| |
| public Void answer(InvocationOnMock invocation) throws Throwable { |
| logWarningsCount++; |
| return null; |
| } |
| |
| }; |
| Mockito.doAnswer(countWarningAnswers).when(log).warn(Matchers.any(String.class)); |
| Mockito.doAnswer(countWarningAnswers).when(log).warn(Matchers.any(Throwable.class)); |
| Mockito.doAnswer(countWarningAnswers).when(log).warn(Matchers.any(String.class), Matchers.any(Throwable.class)); |
| |
| provider = new BundleListContentProvider(resourceProviderRoot) { |
| |
| @Override |
| BundleList getInitializedBundleList() { |
| return bundleList; |
| } |
| |
| @Override |
| File getConfigDirectory() { |
| return configDirectory; |
| } |
| |
| @Override |
| Artifact getArtifact(ArtifactDefinition def) throws MojoExecutionException { |
| final Artifact a = Mockito.mock(Artifact.class); |
| final String fakeName = new StringBuilder() |
| .append("/FAKE_BUNDLE/") |
| .append(def.getArtifactId()) |
| .append("/") |
| .append(def.getStartLevel()) |
| .append("/") |
| .append(def.getRunModes()) |
| .toString(); |
| Mockito.when(a.getFile()).thenReturn(new File(fakeName)); |
| return a; |
| } |
| |
| @Override |
| Log getLog() { |
| return log; |
| } |
| }; |
| } |
| |
| private void assertChildren(String path, String ...expected) { |
| final List<String> kids = new ArrayList<String>(); |
| final Iterator<String> it = provider.getChildren(path); |
| if(expected.length == 0) { |
| assertTrue("Expecting no children for " + path, it == null || !it.hasNext()); |
| } else { |
| assertNotNull("Expecting non-null iterator for " + path, it); |
| while(it.hasNext()) { |
| kids.add(it.next()); |
| } |
| for(String exp : expected) { |
| assertTrue("Expecting " + exp + " in children of " + path + " (result=" + kids + ")", |
| kids.contains(exp)); |
| } |
| } |
| assertEquals("Expecting the correct number of children for " + path + " (result=" + kids + ")", |
| expected.length, kids.size()); |
| } |
| |
| @Test |
| public void testParsedBundlesCount() { |
| int counter = 0; |
| for(StartLevel level : bundleList.getStartLevels()) { |
| counter += level.getBundles().size(); |
| } |
| assertEquals(BUNDLES_IN_TEST_BUNDLE_LIST, counter); |
| } |
| |
| @Test |
| public void testRoot() { |
| assertChildren("resources", |
| "resources/bundles", |
| "resources/corebundles", |
| "resources/config", |
| "resources/install", |
| "resources/install.dev", |
| "resources/install.test", |
| "resources/install.oak", |
| "resources/install.jackrabbit"); |
| } |
| |
| @Test |
| public void testBundles() { |
| assertChildren("resources/bundles", |
| "resources/bundles/1/"); |
| } |
| |
| @Test |
| public void testInstall() { |
| assertChildren("resources/install", |
| "resources/install/0", |
| "resources/install/1", |
| "resources/install/5", |
| "resources/install/15"); |
| } |
| |
| @Test |
| public void testInstallDev() { |
| assertChildren("resources/install.dev", |
| "resources/install.dev/0", |
| "resources/install.dev/5"); |
| } |
| |
| @Test |
| public void testInstallTest() { |
| assertChildren("resources/install.test", |
| "resources/install.test/0", |
| "resources/install.test/5"); |
| } |
| |
| @Test |
| public void testInstallOak() { |
| assertChildren("resources/install.oak", |
| "resources/install.oak/15"); |
| } |
| |
| @Test |
| public void testInstallJackrabbit() { |
| assertChildren("resources/install.jackrabbit", |
| "resources/install.jackrabbit/15"); |
| } |
| |
| @Test |
| public void testCoreBundles() { |
| assertChildren("resources/corebundles"); |
| } |
| |
| @Test |
| public void testConfig() { |
| assertChildren("resources/config", |
| "resources/config/file1.txt", |
| "resources/config/file2.cfg", |
| "resources/config/someFile.properties"); |
| } |
| |
| @Test |
| public void testConfigFile() { |
| assertChildren("resources/config/file1.txt"); |
| assertEquals("Expecting no warnings", 0, logWarningsCount); |
| } |
| |
| @Test |
| public void testConfigSubpath() { |
| assertChildren("resources/config/someFolder/someSubFolder"); |
| assertEquals("Expecting a warning", 1, logWarningsCount); |
| } |
| |
| @Test |
| public void testNonExistentConfigDirectory() { |
| configDirectory = new File("/NON_EXISTENT_" + System.currentTimeMillis()); |
| assertChildren("resources/config"); |
| } |
| |
| @Test |
| public void testIgnoredNonBootstrapBundles() { |
| // All these start levels do not provide resources/bundles anymore - moved to resources/install |
| for(int i=0; i <= 30; i++) { |
| if(i == 1) { |
| continue; |
| } |
| final String path ="resources/bundles/" + i; |
| assertNull("Expecting no resources under " + path, provider.getChildren(path)); |
| } |
| } |
| |
| @Test |
| public void testInstall0() { |
| assertChildren("resources/install/0", |
| fakeBundlePath + "/commons-io/0/null", |
| fakeBundlePath + "/commons-fileupload/0/null", |
| fakeBundlePath + "/commons-collections/0/null"); |
| } |
| |
| @Test |
| public void testBootstrapBundles() { |
| assertChildren("resources/bundles/1", |
| fakeBundlePath + "/slf4j-api/-1/null", |
| fakeBundlePath + "/org.apache.sling.commons.log/-1/null"); |
| } |
| |
| @Test |
| public void testInstall5() { |
| assertChildren("resources/install/5", |
| fakeBundlePath + "/five.norunmode/5/null"); |
| } |
| |
| @Test |
| public void testInstall5Dev() { |
| assertChildren("resources/install.dev/5", |
| fakeBundlePath + "/org.apache.sling.extensions.webconsolebranding/5/dev"); |
| } |
| |
| @Test |
| public void testInstall5Test() { |
| assertChildren("resources/install.test/5", |
| fakeBundlePath + "/org.apache.sling.extensions.webconsolesecurityprovider/5/test"); |
| } |
| |
| @Test |
| public void testInstall15() { |
| assertChildren("resources/install/15", |
| fakeBundlePath + "/fifteen.norunmode/15/null"); |
| } |
| |
| @Test |
| public void testInstall15Oak() { |
| assertChildren("resources/install.oak/15", |
| fakeBundlePath + "/org.apache.sling.jcr.oak.server/15/oak", |
| fakeBundlePath + "/jsr305/15/oak,jackrabbit"); |
| } |
| |
| @Test |
| public void testInstall15Jackrabbit() { |
| assertChildren("resources/install.jackrabbit/15", |
| fakeBundlePath + "/guava/15/jackrabbit", |
| fakeBundlePath + "/jsr305/15/oak,jackrabbit"); |
| } |
| |
| @Test |
| public void testConfigResource() throws Exception { |
| final URL url = provider.getResource("resources/config/file1.txt"); |
| assertNotNull("Expecting config resource to be found", url); |
| assertEquals(getConfigFile("file1.txt").toURI().toURL().toExternalForm(), url.toExternalForm()); |
| } |
| |
| @Test |
| public void testResourceProviderResource() throws Exception { |
| final URL url = provider.getResource(resourceProviderFile.getName()); |
| assertNotNull("Expecting resource provider file to be found", url); |
| assertEquals(resourceProviderFile.toURI().toURL().toExternalForm(), url.toExternalForm()); |
| } |
| |
| @Test |
| public void testClasspathResource() throws Exception { |
| final URL url = provider.getResource(TEST_BUNDLE_LIST); |
| assertNotNull("Expecting classpath resource to be found", url); |
| assertTrue(url.toExternalForm().endsWith(TEST_BUNDLE_LIST)); |
| } |
| |
| @Test |
| public void testClasspathResourceAsStream() throws Exception { |
| final InputStream is = provider.getResourceAsStream(TEST_BUNDLE_LIST); |
| assertNotNull("Expecting classpath resource stream to be found", is); |
| is.close(); |
| } |
| |
| @Test |
| public void testNotFoundStream() throws Exception { |
| final InputStream is = provider.getResourceAsStream("resources/config/NOT_HERE.txt"); |
| assertNull("Expecting null stream for non-existent resource", is); |
| } |
| |
| @Test |
| public void testURLResource() throws Exception { |
| final String urlStr = "http://www.perdu.com"; |
| final URL url = provider.getResource(urlStr); |
| assertNotNull("Expecting URL resource to be found", url); |
| assertEquals(new URL(urlStr), url); |
| } |
| |
| @Test |
| public void testNullResult() { |
| assertNull(provider.getChildren("/FOO/bar")); |
| } |
| |
| @Test |
| public void testAllBundlesFound() { |
| final List<String> allResources = new LinkedList<String>(); |
| addRecursively(allResources, "resources"); |
| final List<String> bundles = new LinkedList<String>(); |
| for(String r : allResources) { |
| if(r.contains("FAKE_BUNDLE")) { |
| bundles.add(r); |
| } |
| } |
| |
| // Bundles that have two run modes appear in two folders, we have two of those |
| // with two run modes each |
| final int expected = BUNDLES_IN_TEST_BUNDLE_LIST + 2; |
| assertEquals("Expecting the exact number of test bundles to be found", expected, bundles.size()); |
| } |
| |
| @Test |
| public void testFile() { |
| assertChildren("file:/something"); |
| } |
| |
| private void addRecursively(List<String> resources, String path) { |
| if(path.endsWith("/")) { |
| path = path.substring(0, path.length() - 1); |
| } |
| resources.add(path); |
| final Iterator<String> it = provider.getChildren(path); |
| if(it != null) { |
| while(it.hasNext()) { |
| addRecursively(resources, it.next()); |
| } |
| } |
| } |
| |
| } |