org.apache.ivy.core.search.RevisionEntry Java Examples

@SuppressWarnings({"rawtypes", "unchecked"})
@Test
public void testMaven2Listing() {
    IBiblioResolver resolver = new IBiblioResolver();
    resolver.setName("test");
    resolver.setSettings(settings);
    resolver.setM2compatible(true);
    assertEquals("test", resolver.getName());

    ModuleEntry[] modules = resolver
            .listModules(new OrganisationEntry(resolver, "commons-lang"));
    assertNotNull(modules);
    assertEquals(1, modules.length);
    assertEquals("commons-lang", modules[0].getModule());

    RevisionEntry[] revisions = resolver.listRevisions(modules[0]);
    assertTrue(revisions.length > 0);

    Map otherTokenValues = new HashMap();
    otherTokenValues.put(IvyPatternHelper.ORGANISATION_KEY, "commons-lang");
    String[] values = resolver.listTokenValues(IvyPatternHelper.MODULE_KEY, otherTokenValues);
    assertNotNull(values);
    assertEquals(1, values.length);
    assertEquals("commons-lang", values[0]);

    Map[] valuesMaps = resolver.listTokenValues(new String[] {IvyPatternHelper.MODULE_KEY},
        otherTokenValues);
    Set vals = new HashSet();
    for (Map valuesMap : valuesMaps) {
        vals.add(valuesMap.get(IvyPatternHelper.MODULE_KEY));
    }
    values = (String[]) vals.toArray(new String[vals.size()]);
    assertEquals(1, values.length);
    assertEquals("commons-lang", values[0]);
}
 

@Test
public void testListing() {
    FileSystemResolver resolver = new FileSystemResolver();
    resolver.setName("test");
    resolver.setSettings(settings);
    assertEquals("test", resolver.getName());

    resolver.addIvyPattern(IVY_PATTERN);
    resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/"
            + "[organisation]/[module]/[type]s/[artifact]-[revision].[ext]");

    OrganisationEntry[] orgs = resolver.listOrganisations();
    ResolverTestHelper.assertOrganisationEntriesContains(resolver, new String[] {"org1",
            "org2", "org6", "org9", "orgfailure", "yourorg", "IVY-644"}, orgs);

    OrganisationEntry org = ResolverTestHelper.getEntry(orgs, "org1");
    assertNotNull("organisation not found: org1", org);
    ModuleEntry[] mods = resolver.listModules(org);
    ResolverTestHelper.assertModuleEntries(resolver, org, new String[] {"mod1.1", "mod1.2",
            "mod1.3", "mod1.4", "mod1.5", "mod1.6", "mod1.7"}, mods);

    ModuleEntry mod = ResolverTestHelper.getEntry(mods, "mod1.1");
    assertNotNull("module not found: mod1.1", mod);
    RevisionEntry[] revs = resolver.listRevisions(mod);
    ResolverTestHelper.assertRevisionEntries(resolver, mod, new String[] {"1.0", "1.0.1",
            "1.1", "2.0"}, revs);

    mod = ResolverTestHelper.getEntry(mods, "mod1.2");
    assertNotNull("module not found: mod1.2", mod);
    revs = resolver.listRevisions(mod);
    ResolverTestHelper.assertRevisionEntries(resolver, mod, new String[] {"0.9", "1.0", "1.1",
            "2.0", "2.1", "2.2"}, revs);
}
 

private static void assertRevisionEntriesContains(DependencyResolver resolver, ModuleEntry mod,
                                                  String[] names, RevisionEntry[] revs) {
    assertNotNull(revs);
    for (String name : names) {
        boolean found = false;
        for (RevisionEntry rev : revs) {
            if (name.equals(rev.getRevision())) {
                found = true;
                assertEquals(resolver, rev.getResolver());
                assertEquals(mod, rev.getModuleEntry());
            }
        }
        assertTrue("revision not found: " + name, found);
    }
}
 

static void assertRevisionEntries(DependencyResolver resolver, ModuleEntry mod, String[] names,
        RevisionEntry[] revs) {
    assertNotNull(revs);
    assertEquals(
        "invalid revision entries: unmatched number: expected: " + Arrays.asList(names)
                + " but was " + Arrays.asList(revs), names.length, revs.length);
    assertRevisionEntriesContains(resolver, mod, names, revs);
}
 

public RevisionEntry[] listRevisionEntries(ModuleEntry module) {
    pushContext();
    try {
        return searchEngine.listRevisionEntries(module);
    } finally {
        popContext();
    }
}
 

@Override
public RevisionEntry[] listRevisions(ModuleEntry mod) {
    Map<String, String> tokenValues = new HashMap<>();
    tokenValues.put(IvyPatternHelper.ORGANISATION_KEY, mod.getOrganisation());
    tokenValues.put(IvyPatternHelper.MODULE_KEY, mod.getModule());
    Collection<String> names = findNames(tokenValues, IvyPatternHelper.REVISION_KEY);
    List<RevisionEntry> ret = new ArrayList<>(names.size());
    for (String name : names) {
        ret.add(new RevisionEntry(mod, name));
    }
    return ret.toArray(new RevisionEntry[names.size()]);
}
 

@Override
public RevisionEntry[] listRevisions(ModuleEntry module) {
    ensureConfigured();
    return super.listRevisions(module);
}
 

@Override
public RevisionEntry[] listRevisions(ModuleEntry mod) {
    ensureConfigured(getSettings());
    return super.listRevisions(mod);
}
 

public RevisionEntry[] listRevisions(ModuleEntry module) {
    return new RevisionEntry[0];
}
 

public RevisionEntry[] listRevisions(ModuleEntry module) {
    throw new UnsupportedOperationException("A Maven deployer cannot be used to resolve dependencies. It can only be used to publish artifacts.");
}
 

@Override
public RevisionEntry[] listRevisions(ModuleEntry mod) {
    ensureIvyConfigured(getSettings());
    ensureArtifactConfigured(getSettings());
    return super.listRevisions(mod);
}
 

public RevisionEntry[] listRevisionEntries(ModuleEntry module) {
    return ivy.listRevisionEntries(module);
}
 

public RevisionEntry[] listRevisions(ModuleEntry mod) {
    // This is never used
    throw new UnsupportedOperationException();
}
 

public RevisionEntry[] listRevisions(ModuleEntry module) {
    throw new UnsupportedOperationException();
}
 

public RevisionEntry[] listRevisions(ModuleEntry module) {
    throw new UnsupportedOperationException("A Maven deployer cannot be used to resolve dependencies. It can only be used to publish artifacts.");
}
 

public RevisionEntry[] listRevisions(ModuleEntry mod) {
    // This is never used
    throw new UnsupportedOperationException();
}
 

public RevisionEntry[] listRevisions(ModuleEntry module) {
    throw new UnsupportedOperationException();
}
 

RevisionEntry[] listRevisions(ModuleEntry module);