VertexiumAssert.java

package org.vertexium.test.util;

import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import org.vertexium.*;
import org.vertexium.event.GraphEvent;
import org.vertexium.query.IterableWithTotalHits;
import org.vertexium.query.QueryResultsIterable;

import java.util.*;
import java.util.stream.Collectors;

import static junit.framework.TestCase.fail;
import static org.junit.Assert.assertEquals;
import static org.vertexium.util.IterableUtils.count;
import static org.vertexium.util.IterableUtils.toList;
import static org.vertexium.util.StreamUtils.stream;

public class VertexiumAssert {
    protected final static List<GraphEvent> graphEvents = new ArrayList<>();

    public static void assertIdsAnyOrder(Iterable<String> ids, String... expectedIds) {
        List<String> sortedIds = stream(ids).sorted().collect(Collectors.toList());
        Arrays.sort(expectedIds);

        String idsString = idsToString(sortedIds.toArray(new String[sortedIds.size()]));
        String expectedIdsString = idsToString(expectedIds);
        assertEquals("ids length mismatch found:[" + idsString + "] expected:[" + expectedIdsString + "]", expectedIds.length, sortedIds.size());
        for (int i = 0; i < expectedIds.length; i++) {
            assertEquals("at offset: " + i + " found:[" + idsString + "] expected:[" + expectedIdsString + "]", expectedIds[i], sortedIds.get(i));
        }
    }

    public static void assertVertexIdsAnyOrder(Iterable<Vertex> vertices, String... expectedIds) {
        List<Vertex> sortedVertices = stream(vertices)
                .sorted(Comparator.comparing(Element::getId))
                .collect(Collectors.toList());
        Arrays.sort(expectedIds);
        assertVertexIds(sortedVertices, expectedIds);
    }

    public static void assertVertexIds(Iterable<Vertex> vertices, String... expectedIds) {
        String verticesIdsString = vertexIdsToString(vertices);
        String expectedIdsString = idsToString(expectedIds);
        List<Vertex> verticesList = toList(vertices);
        assertEquals("ids length mismatch found:[" + verticesIdsString + "] expected:[" + expectedIdsString + "]", expectedIds.length, verticesList.size());
        for (int i = 0; i < expectedIds.length; i++) {
            assertEquals("at offset: " + i + " found:[" + verticesIdsString + "] expected:[" + expectedIdsString + "]", expectedIds[i], verticesList.get(i).getId());
        }
    }

    public static String vertexIdsToString(Iterable<Vertex> vertices) {
        List<String> idsList = stream(vertices)
                .map(Element::getId)
                .collect(Collectors.toList());
        String[] idsArray = idsList.toArray(new String[idsList.size()]);
        return idsToString(idsArray);
    }

    public static String idsToString(String[] ids) {
        return Joiner.on(", ").join(ids);
    }

    public static String idsToStringSorted(Iterable<String> ids) {
        ArrayList<String> idsList = Lists.newArrayList(ids);
        Collections.sort(idsList);
        return Joiner.on(", ").join(idsList);
    }

    public static void assertEvents(GraphEvent... expectedEvents) {
        assertEquals("Different number of events occurred than were asserted", expectedEvents.length, graphEvents.size());

        for (int i = 0; i < expectedEvents.length; i++) {
            assertEquals(expectedEvents[i], graphEvents.get(i));
        }
    }

    public static void assertEdgeIdsAnyOrder(Iterable<Edge> edges, String... expectedIds) {
        List<Edge> sortedEdges = stream(edges)
                .sorted(Comparator.comparing(Element::getId))
                .collect(Collectors.toList());
        Arrays.sort(expectedIds);
        assertEdgeIds(sortedEdges, expectedIds);
    }

    public static void assertEdgeIds(Iterable<Edge> edges, String... ids) {
        List<Edge> edgesList = toList(edges);
        assertEquals("ids length mismatch", ids.length, edgesList.size());
        for (int i = 0; i < ids.length; i++) {
            assertEquals("at offset: " + i, ids[i], edgesList.get(i).getId());
        }
    }

    public static void assertResultsCount(int expectedCountAndTotalHits, QueryResultsIterable<? extends Element> results) {
        assertEquals(expectedCountAndTotalHits, results.getTotalHits());
        assertEquals(expectedCountAndTotalHits, count(results));
    }

    public static void assertResultsCount(
            int expectedCount,
            int expectedTotalHits,
            IterableWithTotalHits<?> results
    ) {
        assertEquals(expectedTotalHits, results.getTotalHits());
        assertEquals(expectedCount, count(results));
    }

    public static void addGraphEvent(GraphEvent graphEvent) {
        graphEvents.add(graphEvent);
    }

    public static void clearGraphEvents() {
        graphEvents.clear();
    }

    public static void assertRowIdsAnyOrder(Iterable<String> expectedRowIds, Iterable<? extends VertexiumObject> searchResults) {
        List<String> foundRowIds = getRowIds(searchResults);
        assertEquals(idsToStringSorted(expectedRowIds), idsToStringSorted(foundRowIds));
    }

    private static List<String> getRowIds(Iterable<? extends VertexiumObject> searchResults) {
        return stream(searchResults)
                .filter((sr) -> sr instanceof ExtendedDataRow)
                .map((sr) -> ((ExtendedDataRow) sr).getId().getRowId())
                .collect(Collectors.toList());
    }

    public static void assertThrowsException(Runnable fn) {
        try {
            fn.run();
        } catch (Throwable ex) {
            return;
        }
        fail("Should have thrown an exception");
    }
}