datahike-browser-tests 1.0.0

package/java/src/datahike/java/DatahikeTest.java

@@ -0,0 +1,370 @@
+package datahike.java;
+
+import clojure.java.api.Clojure;
+import clojure.lang.PersistentHashSet;
+import clojure.lang.APersistentMap;
+import clojure.lang.APersistentVector;
+import clojure.lang.PersistentVector;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+import static datahike.java.Datahike.deref;
+import static datahike.java.Util.*;
+import static org.junit.Assert.*;
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+
+
+public class DatahikeTest {
+
+    private Object schema = Clojure.read(" [{:db/ident :name\n" +
+            "                 :db/valueType :db.type/string\n" +
+            "                 :db/unique :db.unique/identity\n" +
+            "                 :db/index true\n" +
+            "                 :db/cardinality :db.cardinality/one}\n" +
+            "                {:db/ident :age\n" +
+            "                 :db/valueType :db.type/long\n" +
+            "                 :db/cardinality :db.cardinality/one}]");
+
+    private APersistentMap config() {
+        UUID connId = UUID.randomUUID();
+        return map(kwd(":store"), map(kwd(":backend"), kwd(":memory"),
+                                      kwd(":id"), connId),
+                   kwd(":initial-tx"), this.schema);
+    }
+
+    private Date firstDate;
+    private String query;
+
+    private Object transactOnce() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+
+        Object conn = Datahike.connect(config);
+        query = "[:find ?n ?a :where [?e :name ?n] [?e :age ?a]]";
+
+        Datahike.transact(conn, vec(
+                map(kwd(":name"), "Alice", kwd(":age"), 25L),
+                map(kwd(":name"), "Bob", kwd(":age"), 30L)));
+        return conn;
+    }
+
+    @org.junit.Test
+    public void databaseExists() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        assertTrue(Datahike.databaseExists(config));
+        APersistentMap configNotExisting = (APersistentMap)ednFromString("{:store {:backend :memory :id #uuid \"00000000-0000-0000-0000-000000000000\"}}");
+        assertFalse(Datahike.databaseExists(configNotExisting));
+    }
+
+    @org.junit.Test
+    public void queryWithDBAndInput() {
+        Object conn = transactOnce();
+        query = "[:find ?n ?a :in $ [?n] :where [?e :name ?n] [?e :age ?a]]";
+        Set<APersistentVector> res = (Set<APersistentVector>)Datahike.q(query, deref(conn), Clojure.read("[\"Alice\"]"));
+        Object[] names = res.stream().map(vec -> vec.get(0)).toArray();
+        assertTrue(names[0].equals("Alice"));
+    }
+
+    @org.junit.Test
+    public void queryWithJavaArrayInput() {
+        Object conn = transactOnce();
+        query = "[:find ?n ?a :in $ [?n] :where [?e :name ?n] [?e :age ?a]]";
+        Set<APersistentVector> res = (Set<APersistentVector>)Datahike.q(query, deref(conn), new String[] {"Alice"});
+        Object[] names = res.stream().map(vec -> vec.get(0)).toArray();
+        assertTrue(names[0].equals("Alice"));
+    }
+
+    @org.junit.Test
+    public void queryWithLocalInputDB() {
+        Object input = Clojure.read("[[1 :name 'Ivan'] [1 :age  19] [1 :aka  \"dragon_killer_94\"] [1 :aka  '-=autobot=-']]");
+        Set res = (Set)Datahike.q("[:find  ?n ?a :where [?e :aka \"dragon_killer_94\"] [?e :name ?n] [?e :age  ?a]]", input);
+        assertTrue(res.size() == 1);
+    }
+
+    @org.junit.Test
+    public void queryWithDB() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+
+        // Transacting new schema
+        Datahike.transact(conn, vec(map(kwd(":db/ident"), kwd(":name"),
+                kwd(":db/valueType"), kwd(":db.type/string"),
+                kwd(":db/cardinality"), kwd(":db.cardinality/one"))));
+
+        // Transacting with schema presence
+        Datahike.transact(conn, vec(map(kwd(":name"), "Alice")));
+
+        Object deref = Datahike.deref(conn);
+
+        Set res = (Set<APersistentVector>)Datahike.q("[:find ?e :where [?e :name]]", deref);
+        assertTrue(res.size() == 1);
+
+        res = (Set<APersistentVector>)Datahike.q("[:find ?v :where [_ :name ?v]]", deref);
+        assertEquals(PersistentHashSet.create(Arrays.asList(PersistentVector.create("Alice"))), res);
+    }
+
+    @org.junit.Test
+    public void history() {
+        Object conn = transactOnce();
+
+        Set<APersistentVector> res = (Set<APersistentVector>)Datahike.q((String) query, Datahike.history(deref(conn)));
+        Object[] names = res.stream().map(pv -> pv.get(0)).toArray();
+        assertArrayEquals(new String[] {"Alice", "Bob"}, names);
+    }
+
+    @Test
+    public void asOfAndSince() {
+        Object conn = transactOnce();
+
+        // Make sure transaction has older timestamp than firstDate
+        try {
+            Thread.sleep(10);
+        } catch (InterruptedException e) {
+        }
+
+        firstDate = new Date();
+        Datahike.transact(conn, vec(map(
+                kwd(":db/id"), vec(kwd(":name"), "Alice"),
+                kwd(":age"), 30L)));
+
+        Set res = (Set<APersistentVector>)Datahike.q(query, Datahike.asOf(deref(conn), firstDate));
+        assertEquals(2, res.size());
+
+        res = (Set<APersistentVector>)Datahike.q(query, Datahike.since(deref(conn), firstDate));
+        // 0, because :name was transacted before the first date
+        assertEquals(0, res.size());
+    }
+
+    @Test
+    public void pullAndPullMany() {
+        Object conn = transactOnce();
+
+        Datahike.transact(conn, vec(map(kwd(":db/id"), 10,
+                                        kwd(":name"), "Joe",
+                                        kwd(":age"), 50L)));
+        Map res = Datahike.pull(deref(conn), "[*]", 10);
+        assertEquals("Joe", res.get(kwd(":name")));
+
+        Datahike.transact(conn, vec(map(kwd(":db/id"), 20,
+                kwd(":name"), "Jane",
+                kwd(":age"), 25L)));
+        List list = Datahike.pullMany(deref(conn), "[*]", vec(10, 20));
+        assertEquals(2, list.size());
+    }
+
+    @Test
+    public void release() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+        Datahike.release(conn);
+    }
+
+    @Test
+    public void seekDatoms() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+
+        Datahike.transact(conn, (APersistentVector)Clojure.read("[{:db/id 10 :name \"Petr\" :age 44} {:db/id 20 :name \"Ivan\" :age 25} {:db/id 30 :name \"Sergey\" :age 11}]"));
+
+        // Test seekdatoms convenience method (component-based)
+        Object db = deref(conn);
+        Iterable<?> datomsResult = Datahike.seekdatoms(db, kwd(":eavt"), 10);
+        assertNotNull(datomsResult);
+
+        // Just verify the API works - detailed datom testing is covered elsewhere
+        boolean foundDatoms = false;
+        for (Object item : datomsResult) {
+            foundDatoms = true;
+            break; // At least one datom found
+        }
+        assertTrue(foundDatoms);
+    }
+
+    @Test
+    public void tempId() {
+        Object id = Datahike.tempid(kwd(":db.part/user"));
+        assertTrue(((Number)id).longValue() < 0);
+        id = Datahike.tempid(kwd(":db.part/user"), -10000);
+        assertEquals(-10000L, ((Number)id).longValue());
+    }
+
+    @Test
+    public void entity() {
+        Object conn = transactOnce();
+        Datahike.transact(conn, vec(map(kwd(":db/id"), 10,
+                kwd(":name"), "Joe",
+                kwd(":age"), 50L)));
+
+        IEntity entity = (IEntity) Datahike.entity(deref(conn), 10);
+        Object res = entity.valAt(kwd(":name"));
+        assertEquals("Joe", res);
+    }
+
+    @Test
+    public void entityDb() {
+        Object conn = transactOnce();
+        Datahike.transact(conn, vec(map(kwd(":db/id"), 10,
+                kwd(":name"), "Joe",
+                kwd(":age"), 50L)));
+        IEntity entity = (IEntity) Datahike.entity(deref(conn), 10);
+
+        Object db = Datahike.entityDb(entity);
+        assertNotNull(db);
+    }
+
+    @Test
+    public void filterAndIsFiltered() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+        assertFalse(Datahike.isFiltered(deref(conn)));
+
+        Datahike.transact(conn, (APersistentVector)Clojure.read("[{:db/id 10 :name \"Petr\" :age 44} {:db/id 20 :name \"Ivan\" :age 25} {:db/id 30 :name \"Sergey\" :age 11}]"));
+        Object filteredDB = Datahike.filter(deref(conn), Clojure.read("(fn [_ datom] (not= :age (:a datom)))"));
+        assertTrue(Datahike.isFiltered(filteredDB));
+    }
+
+    @Test
+    public void dbWith() {
+        APersistentMap config = config();
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+        APersistentVector txData = (APersistentVector)Clojure.read("[{:db/id 10 :name \"Petr\" :age 44} {:db/id 20 :name \"Ivan\" :age 25} {:db/id 30 :name \"Sergey\" :age 11}]");
+        Object dbAfter = Datahike.dbWith(deref(conn), txData);
+        query = "[:find ?a :in $ :where [?e :age ?a]]";
+        Set res = (Set)Datahike.q(query, dbAfter);
+        assertTrue(res.size() == 3);
+    }
+
+    /* TODO: This requires a durable backend */
+    // @Test
+    // public void gcStorage() {
+    //     APersistentMap config = config();
+    //     Datahike.createDatabase(config);
+    //     Object conn = Datahike.connect(config);
+    //     Set<UUID> res = (Set<UUID>)deref(Datahike.gcStorage(conn));
+    //     assertTrue(res.size() == 0);
+    // }
+
+    @Test
+    public void databaseBuilderMemoryWithUUID() {
+        UUID id = UUID.randomUUID();
+        Map<String, Object> config = Database.memory(id)
+            .keepHistory(true)
+            .build();
+
+        assertNotNull(config);
+        assertTrue(config.containsKey("store"));
+
+        @SuppressWarnings("unchecked")
+        Map<String, Object> store = (Map<String, Object>) config.get("store");
+        assertEquals(":memory", store.get("backend"));
+        assertEquals(id, store.get("id"));
+        assertEquals(true, config.get("keep-history?"));
+    }
+
+    @Test
+    public void databaseBuilderMemoryWithString() {
+        UUID id = UUID.randomUUID();
+        String idString = id.toString();
+
+        Map<String, Object> config = Database.memory(idString)
+            .schemaFlexibility(SchemaFlexibility.READ)
+            .build();
+
+        @SuppressWarnings("unchecked")
+        Map<String, Object> store = (Map<String, Object>) config.get("store");
+        assertEquals(id, store.get("id"));
+        assertEquals(":read", config.get("schema-flexibility"));
+    }
+
+    @Test
+    public void databaseBuilderFile() {
+        Map<String, Object> config = Database.file("/tmp/test-db")
+            .keepHistory(false)
+            .name("test-database")
+            .build();
+
+        @SuppressWarnings("unchecked")
+        Map<String, Object> store = (Map<String, Object>) config.get("store");
+        assertEquals(":file", store.get("backend"));
+        assertEquals("/tmp/test-db", store.get("path"));
+        assertEquals(false, config.get("keep-history?"));
+        assertEquals("test-database", config.get("name"));
+    }
+
+    @Test
+    public void databaseBuilderWithInitialTx() {
+        Object schema = vec(
+            map(kwd(":db/ident"), kwd(":test/attr"),
+                kwd(":db/valueType"), kwd(":db.type/string"),
+                kwd(":db/cardinality"), kwd(":db.cardinality/one"))
+        );
+
+        Map<String, Object> config = Database.memory(UUID.randomUUID())
+            .initialTx(schema)
+            .build();
+
+        assertNotNull(config.get("initial-tx"));
+    }
+
+    @Test
+    public void databaseBuilderCustomOption() {
+        Map<String, Object> config = Database.memory(UUID.randomUUID())
+            .option("temporal-index", true)
+            .option("attribute-refs?", false)
+            .build();
+
+        assertEquals(true, config.get("temporal-index"));
+        assertEquals(false, config.get("attribute-refs?"));
+    }
+
+    @Test
+    public void databaseBuilderIntegration() {
+        // Test that the builder output works with actual Datahike API
+        Map<String, Object> config = Database.memory(UUID.randomUUID())
+            .schemaFlexibility(SchemaFlexibility.READ)
+            .keepHistory(true)
+            .build();
+
+        Datahike.createDatabase(config);
+        assertTrue(Datahike.databaseExists(config));
+
+        Object conn = Datahike.connect(config);
+        assertNotNull(conn);
+
+        // Transact and query to verify the database works
+        Datahike.transact(conn, vec(map(kwd(":name"), "Test")));
+        Object result = Datahike.q("[:find ?n :where [?e :name ?n]]", deref(conn));
+        assertNotNull(result);
+
+        Datahike.deleteDatabase(config);
+        assertFalse(Datahike.databaseExists(config));
+    }
+
+    /**
+     * Called by Datahike's Clojure tests and runs the above Junit tests.
+     */
+    public static boolean run() {
+        Result result = JUnitCore.runClasses(DatahikeTest.class);
+
+        System.out.println("\n");
+        List<Failure> failures = result.getFailures();
+        for (Failure failure : failures) {
+            System.out.println("Junit Failure: " + failure.toString());
+        }
+        System.out.println("Java Bindings test failure count: " + failures.size());
+
+        return result.wasSuccessful();
+    }
+}

package/java/src/datahike/java/EDN.java

@@ -0,0 +1,170 @@
+package datahike.java;
+
+import clojure.lang.Keyword;
+import clojure.lang.Symbol;
+import clojure.java.api.Clojure;
+import clojure.lang.IFn;
+
+/**
+ * EDN type helpers for explicit type construction.
+ *
+ * <p>This class provides static methods for creating EDN types when you need
+ * fine-grained control over conversion, or want to force a value to be treated
+ * as a specific EDN type regardless of automatic conversion rules.</p>
+ *
+ * <p>Example:</p>
+ * <pre>{@code
+ * import static datahike.java.EDN.*;
+ *
+ * Map<String, Object> schema = Map.of(
+ *     "db/ident", keyword("person", "name"),
+ *     "db/valueType", keyword("db.type", "string"),
+ *     "db/cardinality", keyword("db.cardinality", "one"),
+ *     "db/doc", forceString(":literal-colon-in-doc")
+ * );
+ * }</pre>
+ */
+public class EDN {
+
+    private static final IFn readStringFn = Clojure.var("clojure.edn", "read-string");
+
+    /**
+     * Forbids instance creation.
+     */
+    private EDN() {}
+
+    /**
+     * Creates an EDN keyword from a name.
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * keyword("name")  // → :name
+     * }</pre>
+     *
+     * @param name keyword name
+     * @return Clojure keyword
+     */
+    public static Keyword keyword(String name) {
+        return Keyword.intern(name);
+    }
+
+    /**
+     * Creates a namespaced EDN keyword.
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * keyword("person", "name")  // → :person/name
+     * }</pre>
+     *
+     * @param namespace keyword namespace
+     * @param name keyword name
+     * @return Clojure keyword
+     */
+    public static Keyword keyword(String namespace, String name) {
+        return Keyword.intern(namespace, name);
+    }
+
+    /**
+     * Creates an EDN symbol from a name.
+     *
+     * <p>Symbols are used for function names and special forms in Clojure.
+     * Rarely needed in data transactions.</p>
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * symbol("my-fn")  // → my-fn
+     * }</pre>
+     *
+     * @param name symbol name
+     * @return Clojure symbol
+     */
+    public static Symbol symbol(String name) {
+        return Symbol.intern(name);
+    }
+
+    /**
+     * Creates a namespaced EDN symbol.
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * symbol("clojure.core", "assoc")  // → clojure.core/assoc
+     * }</pre>
+     *
+     * @param namespace symbol namespace
+     * @param name symbol name
+     * @return Clojure symbol
+     */
+    public static Symbol symbol(String namespace, String name) {
+        return Symbol.intern(namespace, name);
+    }
+
+    /**
+     * Creates an EDN UUID tagged literal.
+     *
+     * <p>Returns a string that will be parsed as #uuid when converted to EDN.</p>
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * uuid("550e8400-e29b-41d4-a716-446655440000")
+     * // → #uuid "550e8400-e29b-41d4-a716-446655440000"
+     * }</pre>
+     *
+     * @param uuidString UUID string (with or without #uuid prefix)
+     * @return UUID tagged literal
+     */
+    public static Object uuid(String uuidString) {
+        // Strip #uuid prefix if present
+        String cleaned = uuidString.trim();
+        if (cleaned.startsWith("#uuid")) {
+            cleaned = cleaned.substring(5).trim().replaceAll("\"", "");
+        }
+        return readStringFn.invoke("#uuid \"" + cleaned + "\"");
+    }
+
+    /**
+     * Creates an EDN instant (timestamp) tagged literal.
+     *
+     * <p>Returns a string that will be parsed as #inst when converted to EDN.</p>
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * inst("2024-01-01T00:00:00Z")
+     * // → #inst "2024-01-01T00:00:00Z"
+     * }</pre>
+     *
+     * @param isoTimestamp ISO 8601 timestamp string
+     * @return instant tagged literal
+     */
+    public static Object inst(String isoTimestamp) {
+        // Strip #inst prefix if present
+        String cleaned = isoTimestamp.trim();
+        if (cleaned.startsWith("#inst")) {
+            cleaned = cleaned.substring(5).trim().replaceAll("\"", "");
+        }
+        return readStringFn.invoke("#inst \"" + cleaned + "\"");
+    }
+
+    /**
+     * Forces a value to be treated as a string, even if it starts with ':'.
+     *
+     * <p>Use this to create strings that start with ':' without them becoming keywords.</p>
+     *
+     * <p>Example:</p>
+     * <pre>{@code
+     * forceString(":literal-colon")
+     * // → ":literal-colon" (string, not :literal-colon keyword)
+     * }</pre>
+     *
+     * <p>Note: This is equivalent to using backslash escaping: "\\:literal-colon"</p>
+     *
+     * @param value string value (can start with :)
+     * @return the string as-is (will not be converted to keyword)
+     */
+    public static String forceString(String value) {
+        // If value starts with ':', we need to escape it to prevent keyword conversion
+        if (value.startsWith(":")) {
+            return "\\" + value;  // Add backslash escape
+        }
+        return value;
+    }
+}

package/java/src/datahike/java/IEntity.java

@@ -0,0 +1,11 @@
+package datahike.java;
+
+public interface IEntity {
+    /**
+     * Returns the value associated with keyword 'k' in this Entity.
+     *
+     * @param k a keyword
+     * @return the value associated with keyword 'k' in this Entity.
+     */
+    public Object valAt(Object k);
+}