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

@Test
public void testListOrganization() {
    OrganisationEntry[] orgs = resolver.listOrganisations();
    assertEquals(2, orgs.length);
    assertTrue((orgs[0].getOrganisation().equals(BundleInfo.BUNDLE_TYPE) && orgs[1]
            .getOrganisation().equals(BundleInfo.PACKAGE_TYPE))
            || (orgs[0].getOrganisation().equals(BundleInfo.PACKAGE_TYPE) && orgs[1]
                    .getOrganisation().equals(BundleInfo.BUNDLE_TYPE)));
}
 

@Override
public OrganisationEntry[] listOrganisations() {
    Collection<String> names = findNames(Collections.<String, String> emptyMap(),
        IvyPatternHelper.ORGANISATION_KEY);
    List<OrganisationEntry> ret = new ArrayList<>(names.size());
    for (String org : names) {
        ret.add(new OrganisationEntry(this, org));
    }
    return ret.toArray(new OrganisationEntry[names.size()]);
}
 

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

@Override
public ModuleEntry[] listModules(OrganisationEntry org) {
    ensureIvyConfigured(getSettings());
    Map<String, String> tokenValues = new HashMap<>();
    tokenValues.put(IvyPatternHelper.ORGANISATION_KEY, org.getOrganisation());
    Collection<String> names = findIvyNames(tokenValues, IvyPatternHelper.MODULE_KEY);
    List<ModuleEntry> ret = new ArrayList<>(names.size());
    for (String name : names) {
        ret.add(new ModuleEntry(org, name));
    }
    return ret.toArray(new ModuleEntry[names.size()]);
}
 

public OrganisationEntry[] listOrganisationEntries() {
    pushContext();
    try {
        return searchEngine.listOrganisationEntries();
    } finally {
        popContext();
    }
}
 

public ModuleEntry[] listModuleEntries(OrganisationEntry org) {
    pushContext();
    try {
        return searchEngine.listModuleEntries(org);
    } finally {
        popContext();
    }
}
 

@Override
public ModuleEntry[] listModules(OrganisationEntry org) {
    if (isM2compatible()) {
        ensureConfigured(getSettings());
        return super.listModules(org);
    }
    return new ModuleEntry[0];
}
 

@Test
public void testListModules() {
    ModuleEntry[] modules = resolver.listModules(new OrganisationEntry(resolver,
            BundleInfo.BUNDLE_TYPE));
    assertEquals(3, modules.length);
    modules = resolver.listModules(new OrganisationEntry(resolver, BundleInfo.PACKAGE_TYPE));
    assertEquals(64, modules.length);
}
 

static void assertOrganisationEntries(DependencyResolver resolver, String[] orgNames,
        OrganisationEntry[] orgs) {
    assertNotNull(orgs);
    assertEquals(
        "invalid organisation entries: unmatched number: expected: " + Arrays.asList(orgNames)
                + " but was " + Arrays.asList(orgs), orgNames.length, orgs.length);
    assertOrganisationEntriesContains(resolver, orgNames, orgs);
}
 

static void assertOrganisationEntriesContains(DependencyResolver resolver, String[] orgNames,
        OrganisationEntry[] orgs) {
    assertNotNull(orgs);
    for (String orgName : orgNames) {
        boolean found = false;
        for (OrganisationEntry org : orgs) {
            if (orgName.equals(org.getOrganisation())) {
                found = true;
                assertEquals(resolver, org.getResolver());
            }
        }
        assertTrue("organisation not found: " + orgName, found);
    }
}
 

static void assertModuleEntries(DependencyResolver resolver, OrganisationEntry org,
        String[] names, ModuleEntry[] mods) {
    assertNotNull(mods);
    assertEquals(
        "invalid module entries: unmatched number: expected: " + Arrays.asList(names)
                + " but was " + Arrays.asList(mods), names.length, mods.length);
    assertModuleEntriesContains(resolver, org, names, mods);
}
 

private static void assertModuleEntriesContains(DependencyResolver resolver, OrganisationEntry org,
                                                String[] names, ModuleEntry[] mods) {
    assertNotNull(mods);
    for (String name : names) {
        boolean found = false;
        for (ModuleEntry mod : mods) {
            if (name.equals(mod.getModule())) {
                found = true;
                assertEquals(resolver, mod.getResolver());
                assertEquals(org, mod.getOrganisationEntry());
            }
        }
        assertTrue("module not found: " + name, found);
    }
}
 

static OrganisationEntry getEntry(OrganisationEntry[] orgs, String name) {
    for (OrganisationEntry org : orgs) {
        if (name.equals(org.getOrganisation())) {
            return org;
        }
    }
    return null; // for compilation only
}
 

@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);
}
 

@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]);
}
 

@Override
public ModuleEntry[] listModules(OrganisationEntry org) {
    ensureConfigured();
    return super.listModules(org);
}
 

@Override
public OrganisationEntry[] listOrganisations() {
    return new OrganisationEntry[0];
}
 

public ModuleEntry[] listModules(OrganisationEntry org) {
    return new ModuleEntry[0];
}
 

public OrganisationEntry[] listOrganisations() {
    return new OrganisationEntry[0];
}
 

public ModuleEntry[] listModules(OrganisationEntry org) {
    throw new UnsupportedOperationException();
}
 

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

public OrganisationEntry[] listOrganisations() {
    throw new UnsupportedOperationException();
}
 

public ModuleEntry[] listModules(OrganisationEntry org) {
    throw new UnsupportedOperationException();
}
 

public OrganisationEntry[] listOrganisations() {
    // This is never used
    throw new UnsupportedOperationException();
}
 

public ModuleEntry[] listModules(OrganisationEntry org) {
    // This is never used
    throw new UnsupportedOperationException();
}
 

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

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

public OrganisationEntry[] listOrganisations() {
    throw new UnsupportedOperationException();
}
 

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

public OrganisationEntry[] listOrganisations() {
    // This is never used
    throw new UnsupportedOperationException();
}