XPath for testing XML responses

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <ListCountriesResponse xmlns="http://example.com/countries">
      <Countries>
        <Country><Code>US</Code><Name>United States</Name></Country>
        <Country><Code>GB</Code><Name>United Kingdom</Name></Country>
        <Country><Code>IN</Code><Name>India</Name></Country>
        <Country><Code>DE</Code><Name>Germany</Name></Country>
        <Country><Code>FR</Code><Name>France</Name></Country>
        <Country><Code>JP</Code><Name>Japan</Name></Country>
        <Country><Code>BR</Code><Name>Brazil</Name></Country>
        <Country><Code>CA</Code><Name>Canada</Name></Country>
        <Country><Code>AU</Code><Name>Australia</Name></Country>
        <Country><Code>ZA</Code><Name>South Africa</Name></Country>
      </Countries>
    </ListCountriesResponse>
  </soap:Body>
</soap:Envelope>

/users/user[@id='2']/name

/            start at the top of the document
users        go to the child element called users (the root)
/user        then to its children called user
[@id='2']    keep only the ones whose id attribute is '2'
/name        then go to their name child

@Test
@DisplayName("paths: step from element to element")
void paths() {
    assertEquals("US", c.string(countries, "//c:Countries/c:Country/c:Code")); // string() gives the first match
    assertEquals(10, c.strings(countries, "//c:Country/c:Code").size());
}

@Test
@DisplayName("predicates: filter with conditions in square brackets")
void predicates() {
    assertEquals("Japan", c.string(countries, "//c:Country[c:Code='JP']/c:Name"));
    assertEquals("South Africa", c.string(countries, "//c:Country[last()]/c:Name"));
    assertEquals("India", c.string(countries, "//c:Country[3]/c:Name"));
    assertEquals(List.of("US", "GB"), c.strings(countries, "//c:Country[starts-with(c:Name, 'United')]/c:Code"));
}

@Test
@DisplayName("functions: count, sum, string length and more")
void functions() {
    assertEquals(10, c.number(countries, "count(//c:Country)"));
    assertEquals(3, plain.number(users, "count(//role)"));
    assertTrue(c.bool(countries, "//c:Country/c:Code = 'BR'")); // true if any Code equals BR
    assertEquals(2, c.number(countries, "string-length(//c:Country[c:Name='Canada']/c:Code)"));
}

@Test
@DisplayName("attributes are selected with @")
void attributes() {
    assertEquals("Bob Smith", plain.string(users, "/users/user[@id='2']/name"));
    assertEquals(List.of("1", "2"), plain.strings(users, "//user/@id"));
}

@Test
@DisplayName("conditions on children: users who have the admin role")
void childConditions() {
    assertEquals(List.of("Alice Johnson"), plain.strings(users, "//user[roles/role='admin']/name"));
    assertEquals(List.of("Bob Smith"), plain.strings(users, "//user[active='false']/name"));
}

package com.testingapis.soap;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * XPath with the prefixes you choose. The prefixes in your queries don't have to match the ones in the
 * document: what matters is the namespace URI each prefix stands for (lesson 2).
 *
 *   XmlQuery q = new XmlQuery(Map.of("c", "http://example.com/countries"));
 *   q.string(doc, "//c:Country[c:Code='IN']/c:Capital")   // "New Delhi"
 */
public final class XmlQuery {

    private final XPath xpath = XPathFactory.newInstance().newXPath();

    public XmlQuery(Map<String, String> prefixes) {
        xpath.setNamespaceContext(new NamespaceContext() {
            @Override
            public String getNamespaceURI(String prefix) {
                return prefixes.getOrDefault(prefix, "");
            }

            @Override
            public String getPrefix(String uri) {
                return null;
            }

            @Override
            public Iterator<String> getPrefixes(String uri) {
                return null;
            }
        });
    }

    /** No prefixes: for documents without namespaces. */
    public XmlQuery() {
        this(Map.of());
    }

    public String string(Node node, String expression) {
        return (String) evaluate(node, expression, XPathConstants.STRING);
    }

    public double number(Node node, String expression) {
        return (Double) evaluate(node, expression, XPathConstants.NUMBER);
    }

    public boolean bool(Node node, String expression) {
        return (Boolean) evaluate(node, expression, XPathConstants.BOOLEAN);
    }

    /** The text of every node the expression selects, in document order. */
    public List<String> strings(Node node, String expression) {
        NodeList nodes = (NodeList) evaluate(node, expression, XPathConstants.NODESET);
        List<String> values = new ArrayList<>();
        for (int i = 0; i < nodes.getLength(); i++) values.add(nodes.item(i).getTextContent());
        return values;
    }

    private Object evaluate(Node node, String expression, QName type) {
        try {
            return xpath.evaluate(expression, node, type);
        } catch (XPathExpressionException e) {
            throw new IllegalArgumentException("Bad XPath '" + expression + "': " + e.getMessage(), e);
        }
    }
}