org.apache.neethi.PolicyReference Java Examples

void addAssertions(PolicyComponent pc, boolean includeOptional,
                   Collection<Assertion> assertions) {

    if (Constants.TYPE_ASSERTION == pc.getType()) {
        Assertion a = (Assertion)pc;
        if (includeOptional || !a.isOptional()) {
            assertions.add((Assertion)pc);
        }
        return;
    }

    if (Constants.TYPE_POLICY_REF == pc.getType()) {
        PolicyReference pr = (PolicyReference)pc;
        pc = pr.normalize(registry, false);
    }

    PolicyOperator po = (PolicyOperator)pc;

    List<PolicyComponent> pcs = CastUtils.cast(po.getPolicyComponents(), PolicyComponent.class);
    for (PolicyComponent child : pcs) {
        addAssertions(child, includeOptional, assertions);
    }
}
 

Policy resolveLocal(PolicyReference ref, DescriptionInfo di) {
    String uri = ref.getURI().substring(1);
    String absoluteURI = di.getBaseURI();
    if (absoluteURI == null) {
        absoluteURI = Integer.toString(di.hashCode()) + ref.getURI();
    } else {
        absoluteURI = absoluteURI + ref.getURI();
    }
    Policy resolved = registry.lookup(absoluteURI);
    if (null != resolved) {
        return resolved;
    }

    ReferenceResolver resolver = new LocalServiceModelReferenceResolver(di, builder);
    resolved = resolver.resolveReference(uri);
    if (null != resolved) {
        ref.setURI(absoluteURI);
        registry.register(absoluteURI, resolved);
    }
    return resolved;
}
 

Policy resolveReference(PolicyReference ref, DescriptionInfo di) {
    Policy p = null;
    if (isExternal(ref)) {
        String uri = di.getBaseURI();
        if (uri == null) {
            uri = Integer.toString(di.hashCode());
        }
        p = resolveExternal(ref, uri);
    } else {
        p = resolveLocal(ref, di);
    }
    checkResolved(ref, p);
    return p;
}
 

Policy resolveReference(PolicyReference ref, Document doc) {
    Policy p = null;
    if (isExternal(ref)) {
        p = resolveExternal(ref, doc.getBaseURI());
    } else {
        p = resolveLocal(ref, doc);
    }
    checkResolved(ref, p);
    return p;
}
 

Policy resolveLocal(PolicyReference ref, Document doc) {
    String relativeURI = ref.getURI().substring(1);
    String absoluteURI = doc.getBaseURI() + ref.getURI();
    Policy resolved = registry.lookup(absoluteURI);
    if (null != resolved) {
        return resolved;
    }
    ReferenceResolver resolver = new LocalDocumentReferenceResolver(doc, builder);
    resolved = resolver.resolveReference(relativeURI);
    if (null != resolved) {
        ref.setURI(absoluteURI);
        registry.register(absoluteURI, resolved);
    }
    return resolved;
}
 

protected Policy resolveExternal(PolicyReference ref,  String baseURI) {
    Policy resolved = registry.lookup(ref.getURI());
    if (null != resolved) {
        return resolved;
    }
    ReferenceResolver resolver = new RemoteReferenceResolver(baseURI, builder);
    return resolver.resolveReference(ref.getURI());
}
 

Policy resolveReference(PolicyReference ref, PolicyBuilder builder, Bus bus, DescriptionInfo i) {
    Policy p = null;
    if (!ref.getURI().startsWith("#")) {
        String base = i == null ? null : i.getBaseURI();
        p = resolveExternal(ref, base, bus);
    } else {
        p = resolveLocal(ref, bus, i);
    }
    if (null == p) {
        throw new PolicyException(new Message("UNRESOLVED_POLICY_REFERENCE_EXC", BUNDLE, ref.getURI()));
    }

    return p;
}
 

protected Policy resolveExternal(PolicyReference ref,  String baseURI, Bus bus) {
    PolicyBuilder builder = bus.getExtension(PolicyBuilder.class);
    ReferenceResolver resolver = new RemoteReferenceResolver(baseURI, builder);
    PolicyRegistry registry = bus.getExtension(PolicyEngine.class).getRegistry();
    Policy resolved = registry.lookup(ref.getURI());
    if (null != resolved) {
        return resolved;
    }
    return resolver.resolveReference(ref.getURI());
}
 

@Test
public void testGetPolicyReference() throws Exception {
    String name = "/samples/test26.xml";
    InputStream is = PolicyBuilderTest.class.getResourceAsStream(name);

    PolicyReference pr = builder.getPolicyReference(is);
    assertEquals("#PolicyA", pr.getURI());

    name = "/samples/test27.xml";
    is = PolicyBuilderTest.class.getResourceAsStream(name);

    pr = builder.getPolicyReference(is);
    assertEquals("http://sample.org/test.wsdl#PolicyA", pr.getURI());
}
 

@Test
public void testAddAssertions() {
    engine = new PolicyEngineImpl();
    Collection<Assertion> assertions = new ArrayList<>();

    Assertion a = control.createMock(Assertion.class);
    EasyMock.expect(a.getType()).andReturn(Constants.TYPE_ASSERTION);
    EasyMock.expect(a.isOptional()).andReturn(true);

    control.replay();
    engine.addAssertions(a, false, assertions);
    assertTrue(assertions.isEmpty());
    control.verify();

    control.reset();
    EasyMock.expect(a.getType()).andReturn(Constants.TYPE_ASSERTION);
    control.replay();
    engine.addAssertions(a, true, assertions);
    assertEquals(1, assertions.size());
    assertSame(a, assertions.iterator().next());
    control.verify();

    assertions.clear();
    Policy p = new Policy();
    a = new PrimitiveAssertion(new QName("http://x.y.z", "a"));
    p.addAssertion(a);

    // id has no #
    engine.getRegistry().register("ab", p);

    // local reference is an id + #
    PolicyReference pr = new PolicyReference();
    pr.setURI("#ab");

    engine.addAssertions(pr, false, assertions);
    assertEquals(1, assertions.size());
    assertSame(a, assertions.iterator().next());
}
 

protected boolean isExternal(PolicyReference ref) {
    return !ref.getURI().startsWith("#");
}
 

protected void checkResolved(PolicyReference ref, Policy p) {
    if (null == p) {
        throw new PolicyException(new Message("UNRESOLVED_POLICY_REFERENCE_EXC", BUNDLE, ref.getURI()));
    }
}
 

/**
 * Creates a PolicyReference object from a DOM element.
 *
 * @param element the element
 * @return the PolicyReference object constructed from the element
 */
PolicyReference getPolicyReference(Object element);