private Collection<Node> collectSubArchives(final Archive<?> archive) { return archive.getContent(Filters.include(WAR_AND_JAR)).values(); } }
public Map<ArchivePath, Node> getSignatureFiles(Archive<?> archive) { return archive.getContent(// // This is adapted from Jacoco SignatureRemover Filters.include("/META-INF/[^/]*\\.SF|" // + "/META-INF/[^/]*\\.DSA|" // + "/META-INF/[^/]*\\.RSA|" // + "/META-INF/SIG-[^/]*")); }
private Collection<Node> collectSubArchives(final Archive<?> archive) { return archive.getContent(Filters.include(WAR_AND_JAR)).values(); } }
public Map<ArchivePath, Node> getManifestFiles(Archive<?> archive) { return archive.getContent(Filters.include("/META-INF/MANIFEST\\.MF")); } }
private Collection<Node> getPersistenceDescriptors(final Archive<?> archive) { return archive.getContent(Filters.include(".*persistence.xml")).values(); }
public Map<ArchivePath, Node> getSignatureFiles(Archive<?> archive) { return archive.getContent(// // This is adapted from Jacoco SignatureRemover Filters.include("/META-INF/[^/]*\\.SF|" // + "/META-INF/[^/]*\\.DSA|" // + "/META-INF/[^/]*\\.RSA|" // + "/META-INF/SIG-[^/]*")); }
private Collection<Node> getPersistenceDescriptors(final Archive<?> archive) { return archive.getContent(Filters.include(".*persistence.xml")).values(); }
private Collection<Node> collectSubArchives(final Archive<?> archive) { return archive.getContent(Filters.include(WAR_AND_JAR)).values(); } }
public Map<ArchivePath, Node> getManifestFiles(Archive<?> archive) { return archive.getContent(Filters.include("/META-INF/MANIFEST\\.MF")); } }
public void process(Archive<?> archive, TestClass testClass) { if (archive instanceof EnterpriseArchive) { final EnterpriseArchive ear = (EnterpriseArchive) archive; Map<ArchivePath, Node> wars = ear.getContent(Filters.include(".*\\.war")); for (Map.Entry<ArchivePath, Node> war : wars.entrySet()) { handleWebArchive(ear.getAsType(WebArchive.class, war.getKey())); } } else if (archive instanceof WebArchive) { handleWebArchive((WebArchive) archive); } else { throw new IllegalArgumentException("Can only handle .ear or .war deployments: " + archive); } }
private void enrichWithCDI(Archive<?> applicationArchive) { Map<ArchivePath, Node> contentMap = applicationArchive.getContent(Filters.include(".*/cukespace-core.jar")); for (Node node : contentMap.values()) { if (node.getAsset() instanceof ArchiveAsset) { JavaArchive archive = (JavaArchive) ((ArchiveAsset) node.getAsset()).getArchive(); archive.addClass(CukeSpaceCDIObjectFactory.class); archive.addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml"); } } } }
private void scanJarArchive(Archive<?> archive) { URL beansXmlUrl = getBeanXmlUrl(archive, "META-INF/beans.xml"); if (beansXmlUrl == null) { // that means we switch to 'Implicit BDA' mode beansXmlUrl = getBeanXmlUrl(archive, "/"); } // otherwise we store it for later use beansXmls.add(beansXmlUrl); // and now scan all classes those classes acording to their BDA info Map<ArchivePath, Node> classes = archive.getContent(Filters.include(".*\\.class")); scanClasses(beanArchiveService.getBeanArchiveInformation(beansXmlUrl), classes, null); }
@Test public void shouldBeAbleToImportADirectoryWithIncludeFilter() throws Exception { String fileName = SecurityActions.getThreadContextClassLoader().getResource(EXISTING_DIRECTORY_RESOURCE).toURI().getPath(); Archive<?> archive = ShrinkWrap .create(ExplodedImporter.class, "test.jar") .importDirectory(fileName, Filters.include(".*META-INF.*")) .as(JavaArchive.class); Logger.getLogger(ExplodedImporterTestCase.class.getName()).info(archive.toString(true)); Assert.assertEquals("Archive should contains only 2 paths", 2, archive.getContent().size()); Assert.assertTrue("Nested files should be imported", archive.contains(new BasicPath("/META-INF/MANIFEST.FM"))); }
@Test public void shouldIncludePathRegExp() throws Exception { List<ArchivePath> paths = Arrays.asList(ArchivePaths.create("/META-INF/"), ArchivePaths.create("/WEB-INF/")); List<ArchivePath> filteredPaths = executeFilter(ArchivePath.class, paths, Filters.include(".*META-INF.*")); Assert.assertEquals("Should only contain one", 1, filteredPaths.size()); Assert.assertEquals("Should only contain metainf", ArchivePaths.create("/META-INF/"), filteredPaths.get(0)); }
@Test public void testFilter() throws Exception { String resourcePath = "/test/cl-test.jar"; GenericArchive archive = ShrinkWrap.create(ZipImporter.class).importFrom( TestIOUtil.createFileFromResourceName("cl-test.jar")).as(GenericArchive.class); GenericArchive filtered = archive.filter(Filters.include(".*MANIFEST\\.MF")); // Check that only META-INF/MANIFEST.MF exist in Archive Assert.assertEquals(2, filtered.getContent().size()); Assert.assertTrue(filtered.contains(ArchivePaths.create("META-INF/MANIFEST.MF"))); }
@Test @ArchiveType(ClassContainer.class) public void testDeletePackagesFilteredWithoutSubpackages() { addExemplaryClasses(); Filter<ArchivePath> filter = Filters.include(DummyClassForTest.class); getClassContainer().deletePackages(false, filter, DummyClassForTest.class.getPackage().getName()); assertNotContainsClass(getArchivePathFromClass(DummyClassForTest.class)); // Sub packages, if not listed, must NOT be removed assertContainsClass(getArchivePathFromClass(EmptyClassForFiltersTest1.class)); // Classes from the same package not included in the filter must NOT be removed assertContainsClass(getArchivePathFromClass(DummyInterfaceForTest.class)); }
@Test @ArchiveType(ClassContainer.class) public void testDeletePackagesAsStringsFilteredWithoutSubpackages() { addExemplaryClasses(); Filter<ArchivePath> filter = Filters.include(DummyClassForTest.class); getClassContainer().deletePackages(false, filter, DummyClassForTest.class.getPackage().getName()); assertNotContainsClass(getArchivePathFromClass(DummyClassForTest.class)); // Sub packages, if not listed, must NOT be removed assertContainsClass(getArchivePathFromClass(EmptyClassForFiltersTest1.class)); // Classes from the same package not included in the filter must NOT be removed assertContainsClass(getArchivePathFromClass(DummyInterfaceForTest.class)); }
@Test @ArchiveType(ClassContainer.class) public void testDeletePackagesAsStringsFilteredWithSubpackages() { addExemplaryClasses(); Filter<ArchivePath> filter = Filters.include(DummyClassForTest.class); getClassContainer().deletePackages(true, filter, DummyClassForTest.class.getPackage().getName()); assertNotContainsClass(getArchivePathFromClass(DummyClassForTest.class)); // Classes from the same (or sub-) package not included in the filter must NOT be removed assertContainsClass(getArchivePathFromClass(EmptyClassForFiltersTest1.class)); assertContainsClass(getArchivePathFromClass(DummyInterfaceForTest.class)); }
@Test @ArchiveType(ClassContainer.class) public void testDeletePackagesFilteredWithSubpackages() { addExemplaryClasses(); Filter<ArchivePath> filter = Filters.include(DummyClassForTest.class); getClassContainer().deletePackages(true, filter, DummyClassForTest.class.getPackage().getName()); assertNotContainsClass(getArchivePathFromClass(DummyClassForTest.class)); // Classes from the same (or sub-) package not included in the filter must NOT be removed assertContainsClass(getArchivePathFromClass(EmptyClassForFiltersTest1.class)); assertContainsClass(getArchivePathFromClass(DummyInterfaceForTest.class)); }
@Test @ArchiveType(ClassContainer.class) public void shouldIncludeOnlySelectedClasses() throws Exception { getClassContainer().addPackages(true, Filters.include(DynamicContainerTestBase.class, ArchiveType.class), DynamicContainerTestBase.class.getPackage().getName()); ArchivePath expectedPath = new BasicPath(getClassPath(), AssetUtil.getFullPathForClassResource(DynamicContainerTestBase.class)); ArchivePath expectedPath2 = new BasicPath(getClassPath(), AssetUtil.getFullPathForClassResource(ArchiveType.class)); Assert.assertEquals("Should only include selected classes", 2, numAssets(getArchive())); assertContainsClass(expectedPath); assertContainsClass(expectedPath2); }