// Copyright 2016 Mozilla
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#[cfg(feature = "syncable")]
// Run with 'cargo test tolstoy_tests' from top-level.
#[cfg(feature = "syncable")]
mod tolstoy_tests {
    use std::borrow::Borrow;
    use std::collections::BTreeMap;
    use std::collections::HashMap;

    use std::collections::hash_map::Entry;

    use uuid::Uuid;

    use mentat::{conn::Conn, new_connection};

    use mentat_db::{assert_matches, TX0};

    use mentat_tolstoy::{
        debug::parts_to_datoms, GlobalTransactionLog, SyncFollowup, SyncReport, Syncer, Tx, TxPart,
    };

    use mentat_tolstoy::debug::txs_after;

    use core_traits::{Entid, TypedValue, ValueType};
    use mentat_tolstoy::tx_processor::{Processor, TxReceiver};
    use public_traits::errors::{MentatError, Result};
    use tolstoy_traits::errors::TolstoyError;

    struct TxCountingReceiver {
        tx_count: usize,
    }

    impl TxCountingReceiver {
        fn new() -> TxCountingReceiver {
            TxCountingReceiver { tx_count: 0 }
        }
    }

    impl TxReceiver<usize> for TxCountingReceiver {
        fn tx<T>(&mut self, _tx_id: Entid, _d: &mut T) -> Result<()>
        where
            T: Iterator<Item = TxPart>,
        {
            self.tx_count += 1;
            Ok(())
        }

        fn done(self) -> usize {
            self.tx_count
        }
    }

    #[derive(Debug)]
    struct TestingReceiver {
        txes: BTreeMap<Entid, Vec<TxPart>>,
    }

    impl TestingReceiver {
        fn new() -> TestingReceiver {
            TestingReceiver {
                txes: BTreeMap::new(),
            }
        }
    }

    impl TxReceiver<BTreeMap<Entid, Vec<TxPart>>> for TestingReceiver {
        fn tx<T>(&mut self, tx_id: Entid, d: &mut T) -> Result<()>
        where
            T: Iterator<Item = TxPart>,
        {
            let datoms = self.txes.entry(tx_id).or_default();
            datoms.extend(d);
            Ok(())
        }

        fn done(self) -> BTreeMap<Entid, Vec<TxPart>> {
            self.txes
        }
    }

    fn assert_tx_datoms_count(
        txes: &BTreeMap<Entid, Vec<TxPart>>,
        tx_num: usize,
        expected_datoms: usize,
    ) {
        let tx = txes.keys().nth(tx_num).expect("first tx");
        let datoms = txes.get(tx).expect("datoms");
        assert_eq!(expected_datoms, datoms.len());
    }

    #[derive(Debug)]
    struct TestRemoteClient {
        pub head: Uuid,
        pub chunks: HashMap<Uuid, TxPart>,
        pub transactions: HashMap<Uuid, Vec<TxPart>>,
        // Keep transactions in order:
        pub tx_rowid: HashMap<Uuid, usize>,
        pub rowid_tx: Vec<Uuid>,
    }

    impl TestRemoteClient {
        fn new() -> TestRemoteClient {
            TestRemoteClient {
                head: Uuid::nil(),
                chunks: HashMap::default(),
                transactions: HashMap::default(),
                tx_rowid: HashMap::default(),
                rowid_tx: vec![],
            }
        }
    }

    impl GlobalTransactionLog for TestRemoteClient {
        fn head(&self) -> Result<Uuid> {
            Ok(self.head)
        }

        fn transactions_after(&self, tx: &Uuid) -> Result<Vec<Tx>> {
            let rowid_range;
            if tx == &Uuid::nil() {
                rowid_range = 0..;
            } else {
                rowid_range = self.tx_rowid[tx] + 1..;
            }

            let mut txs = vec![];
            for tx_uuid in &self.rowid_tx[rowid_range] {
                txs.push(Tx {
                    tx: *tx_uuid,
                    parts: self.transactions.get(tx_uuid).unwrap().clone(),
                });
            }
            Ok(txs)
        }

        fn set_head(&mut self, tx: &Uuid) -> Result<()> {
            self.head = *tx;
            Ok(())
        }

        fn put_chunk(&mut self, tx: &Uuid, payload: &TxPart) -> Result<()> {
            match self.chunks.entry(*tx) {
                Entry::Occupied(_) => panic!("trying to overwrite chunk"),
                Entry::Vacant(entry) => {
                    entry.insert(payload.clone());
                }
            }
            Ok(())
        }

        fn put_transaction(
            &mut self,
            tx: &Uuid,
            _parent_tx: &Uuid,
            chunk_txs: &[Uuid],
        ) -> Result<()> {
            let mut parts = vec![];
            for chunk_tx in chunk_txs {
                parts.push(self.chunks.get(chunk_tx).unwrap().clone());
            }
            self.transactions.insert(*tx, parts);
            self.rowid_tx.push(*tx);
            self.tx_rowid.insert(*tx, self.rowid_tx.len() - 1);
            Ok(())
        }
    }

    macro_rules! assert_sync {
        ( $report: pat, $conn: expr, $sqlite: expr, $remote: expr ) => {{
            let mut ip = $conn
                .begin_transaction(&mut $sqlite)
                .expect("begun successfully");
            match Syncer::sync(&mut ip, &mut $remote).expect("sync report") {
                $report => (),
                wr => panic!("Wrong sync report: {:?}", wr),
            }
            ip.commit().expect("committed");
        }};
        ( error => $error: pat, $conn: expr, $sqlite: expr, $remote: expr ) => {{
            let mut ip = $conn
                .begin_transaction(&mut $sqlite)
                .expect("begun successfully");
            match Syncer::sync(&mut ip, &mut $remote)
                .expect_err("expected sync to fail, but did not")
            {
                $error => (),
                we => panic!("Failed with wrong error: {:?}", we),
            }
        }};
    }

    macro_rules! assert_transactions {
        ($sqlite:expr, $conn:expr, $($tx:expr),+) => {
            let txs = txs_after(&$sqlite, &$conn.current_schema(), TX0);

            let mut index = 1;
            $(
                assert_matches!(parts_to_datoms(&$conn.current_schema(), &txs[index].parts), $tx);
                index += 1;
            )*

            assert_eq!(index, txs.len());
        };

        ($sqlite:expr, $conn:expr, schema => $schema:expr, $($tx:expr),*) => {
            let txs = txs_after(&$sqlite, &$conn.current_schema(), TX0);

            // Schema assumed to be first transaction.
            assert_matches!(parts_to_datoms(&$conn.current_schema(), &txs[0].parts), $schema);

            let index = 1;
            $(
                assert_matches!(parts_to_datoms(&$conn.current_schema(), &txs[index].parts), $tx);
                let index = index + 1;
            )*

            assert_eq!(index, txs.len());
        };
    }

    #[test]
    fn test_reader() {
        let mut c = new_connection("").expect("Couldn't open conn.");
        let mut conn = Conn::connect(&mut c).expect("Couldn't open DB.");
        {
            let db_tx = c.transaction().expect("db tx");
            // Ensure that we see a bootstrap transaction.
            assert_eq!(
                1,
                Processor::process(&db_tx, None, TxCountingReceiver::new()).expect("processor")
            );
        }

        let ids = conn
            .transact(
                &mut c,
                r#"[
            [:db/add "s" :db/ident :foo/numba]
            [:db/add "s" :db/valueType :db.type/long]
            [:db/add "s" :db/cardinality :db.cardinality/one]
        ]"#,
            )
            .expect("successful transaction")
            .tempids;
        let numba_entity_id = ids.get("s").unwrap();

        let ids = conn
            .transact(
                &mut c,
                r#"[
            [:db/add "b" :foo/numba 123]
        ]"#,
            )
            .expect("successful transaction")
            .tempids;
        let _asserted_e = ids.get("b").unwrap();

        let first_tx;
        {
            let db_tx = c.transaction().expect("db tx");
            // Expect to see one more transaction of four parts (one for tx datom itself).
            let receiver = TestingReceiver::new();
            let txes = Processor::process(&db_tx, None, receiver).expect("processor");

            println!("{:#?}", txes);

            // Three transactions: bootstrap, vocab, assertion.
            assert_eq!(3, txes.keys().count());
            assert_tx_datoms_count(&txes, 2, 2);

            first_tx = *txes.keys().nth(1).expect("first non-bootstrap tx");
        }

        let ids = conn
            .transact(
                &mut c,
                r#"[
            [:db/add "b" :foo/numba 123]
        ]"#,
            )
            .expect("successful transaction")
            .tempids;
        let asserted_e = ids.get("b").unwrap();

        {
            let db_tx = c.transaction().expect("db tx");

            // Expect to see a single two part transaction
            let receiver = TestingReceiver::new();

            // Note that we're asking for the first transacted tx to be skipped by the processor.
            let txes = Processor::process(&db_tx, Some(first_tx), receiver).expect("processor");

            // Vocab, assertion.
            assert_eq!(2, txes.keys().count());
            // Assertion datoms.
            assert_tx_datoms_count(&txes, 1, 2);

            // Inspect the assertion.
            let tx_id = txes.keys().nth(1).expect("tx");
            let datoms = txes.get(tx_id).expect("datoms");
            let part = datoms
                .iter()
                .find(|&part| &part.e == asserted_e)
                .expect("to find asserted datom");

            assert_eq!(numba_entity_id, &part.a);
            assert!(part.v.matches_type(ValueType::Long));
            assert_eq!(TypedValue::Long(123), part.v);
            assert_eq!(true, part.added);
        }
    }

    #[test]
    fn test_bootstrap_upload() {
        let mut sqlite = new_connection("").unwrap();
        let mut conn = Conn::connect(&mut sqlite).unwrap();
        let mut remote_client = TestRemoteClient::new();

        // Fast forward empty remote with a bootstrap transaction.
        assert_sync!(SyncReport::RemoteFastForward, conn, sqlite, remote_client);

        let bootstrap_tx_parts = remote_client
            .transactions
            .get(&remote_client.rowid_tx[0])
            .unwrap();

        assert_matches!(
            parts_to_datoms(&conn.current_schema(), &bootstrap_tx_parts),
            "[
            [:db.schema/core :db.schema/attribute 1 ?tx true]
            [:db.schema/core :db.schema/attribute 3 ?tx true]
            [:db.schema/core :db.schema/attribute 4 ?tx true]
            [:db.schema/core :db.schema/attribute 5 ?tx true]
            [:db.schema/core :db.schema/attribute 6 ?tx true]
            [:db.schema/core :db.schema/attribute 7 ?tx true]
            [:db.schema/core :db.schema/attribute 8 ?tx true]
            [:db.schema/core :db.schema/attribute 9 ?tx true]
            [:db.schema/core :db.schema/attribute 10 ?tx true]
            [:db.schema/core :db.schema/attribute 11 ?tx true]
            [:db.schema/core :db.schema/attribute 12 ?tx true]
            [:db.schema/core :db.schema/attribute 13 ?tx true]
            [:db.schema/core :db.schema/attribute 22 ?tx true]
            [:db.schema/core :db.schema/attribute 37 ?tx true]
            [:db.schema/core :db.schema/attribute 38 ?tx true]
            [:db.schema/core :db.schema/attribute 39 ?tx true]
            [:db/ident :db/ident :db/ident ?tx true]
            [:db.part/db :db/ident :db.part/db ?tx true]
            [:db/txInstant :db/ident :db/txInstant ?tx true]
            [:db.install/partition :db/ident :db.install/partition ?tx true]
            [:db.install/valueType :db/ident :db.install/valueType ?tx true]
            [:db.install/attribute :db/ident :db.install/attribute ?tx true]
            [:db/valueType :db/ident :db/valueType ?tx true]
            [:db/cardinality :db/ident :db/cardinality ?tx true]
            [:db/unique :db/ident :db/unique ?tx true]
            [:db/isComponent :db/ident :db/isComponent ?tx true]
            [:db/index :db/ident :db/index ?tx true]
            [:db/fulltext :db/ident :db/fulltext ?tx true]
            [:db/noHistory :db/ident :db/noHistory ?tx true]
            [:db/add :db/ident :db/add ?tx true]
            [:db/retract :db/ident :db/retract ?tx true]
            [:db.part/user :db/ident :db.part/user ?tx true]
            [:db.part/tx :db/ident :db.part/tx ?tx true]
            [:db/excise :db/ident :db/excise ?tx true]
            [:db.excise/attrs :db/ident :db.excise/attrs ?tx true]
            [:db.excise/beforeT :db/ident :db.excise/beforeT ?tx true]
            [:db.excise/before :db/ident :db.excise/before ?tx true]
            [:db.alter/attribute :db/ident :db.alter/attribute ?tx true]
            [:db.type/ref :db/ident :db.type/ref ?tx true]
            [:db.type/keyword :db/ident :db.type/keyword ?tx true]
            [:db.type/long :db/ident :db.type/long ?tx true]
            [:db.type/double :db/ident :db.type/double ?tx true]
            [:db.type/string :db/ident :db.type/string ?tx true]
            [:db.type/uuid :db/ident :db.type/uuid ?tx true]
            [:db.type/uri :db/ident :db.type/uri ?tx true]
            [:db.type/boolean :db/ident :db.type/boolean ?tx true]
            [:db.type/instant :db/ident :db.type/instant ?tx true]
            [:db.type/bytes :db/ident :db.type/bytes ?tx true]
            [:db.cardinality/one :db/ident :db.cardinality/one ?tx true]
            [:db.cardinality/many :db/ident :db.cardinality/many ?tx true]
            [:db.unique/value :db/ident :db.unique/value ?tx true]
            [:db.unique/identity :db/ident :db.unique/identity ?tx true]
            [:db/doc :db/ident :db/doc ?tx true]
            [:db.schema/version :db/ident :db.schema/version ?tx true]
            [:db.schema/attribute :db/ident :db.schema/attribute ?tx true]
            [:db.schema/core :db/ident :db.schema/core ?tx true]
            [?tx :db/txInstant ?ms ?tx true]
            [:db/ident :db/valueType 24 ?tx true]
            [:db/txInstant :db/valueType 31 ?tx true]
            [:db.install/partition :db/valueType 23 ?tx true]
            [:db.install/valueType :db/valueType 23 ?tx true]
            [:db.install/attribute :db/valueType 23 ?tx true]
            [:db/valueType :db/valueType 23 ?tx true]
            [:db/cardinality :db/valueType 23 ?tx true]
            [:db/unique :db/valueType 23 ?tx true]
            [:db/isComponent :db/valueType 30 ?tx true]
            [:db/index :db/valueType 30 ?tx true]
            [:db/fulltext :db/valueType 30 ?tx true]
            [:db/noHistory :db/valueType 30 ?tx true]
            [:db.alter/attribute :db/valueType 23 ?tx true]
            [:db/doc :db/valueType 27 ?tx true]
            [:db.schema/version :db/valueType 25 ?tx true]
            [:db.schema/attribute :db/valueType 23 ?tx true]
            [:db/ident :db/cardinality 33 ?tx true]
            [:db/txInstant :db/cardinality 33 ?tx true]
            [:db.install/partition :db/cardinality 34 ?tx true]
            [:db.install/valueType :db/cardinality 34 ?tx true]
            [:db.install/attribute :db/cardinality 34 ?tx true]
            [:db/valueType :db/cardinality 33 ?tx true]
            [:db/cardinality :db/cardinality 33 ?tx true]
            [:db/unique :db/cardinality 33 ?tx true]
            [:db/isComponent :db/cardinality 33 ?tx true]
            [:db/index :db/cardinality 33 ?tx true]
            [:db/fulltext :db/cardinality 33 ?tx true]
            [:db/noHistory :db/cardinality 33 ?tx true]
            [:db.alter/attribute :db/cardinality 34 ?tx true]
            [:db/doc :db/cardinality 33 ?tx true]
            [:db.schema/version :db/cardinality 33 ?tx true]
            [:db.schema/attribute :db/cardinality 34 ?tx true]
            [:db/ident :db/unique 36 ?tx true]
            [:db.schema/attribute :db/unique 35 ?tx true]
            [:db/ident :db/index true ?tx true]
            [:db/txInstant :db/index true ?tx true]
            [:db.schema/attribute :db/index true ?tx true]
            [:db.schema/core :db.schema/version 1 ?tx true]]"
        );
    }

    #[test]
    fn test_against_bootstrap() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Fast forward empty remote with a bootstrap transaction from 1.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge 1 and 2 bootstrap transactions.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that nothing besides a bootstrap transaction is present after a sync on 2.
        let synced_txs_2 = txs_after(&sqlite_2, &conn_2.current_schema(), TX0);
        assert_eq!(0, synced_txs_2.len());

        // Assert that 1's sync didn't affect remote.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);

        // Assert that nothing besides a bootstrap transaction is present after a sync on 1.
        let synced_txs_1 = txs_after(&sqlite_1, &conn_1.current_schema(), TX0);
        assert_eq!(0, synced_txs_1.len());
    }

    #[test]
    fn test_empty_merge() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions from 1.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that we end up with the same schema on 2 as we had on 1.
        assert_transactions!(sqlite_2, conn_2,
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",
        );

        // Assert that 2's sync didn't affect remote state.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);
    }

    #[test]
    fn test_non_conflicting_merge_exact() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both 1 and 2 define the same schema.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that 2's schema didn't change after sync.
        assert_transactions!(sqlite_2, conn_2,
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",
        );

        // Assert that 2's sync didn't change remote state.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);
    }

    #[test]
    fn test_non_conflicting_merge_subset() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both 1 and 2 define the same schema.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // But 1 also has an assertion against its schema.
        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        assert_transactions!(sqlite_2, conn_2,
            // Assert that 2's schema is the same as before the sync.
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            // Assert that 2 has an additional transaction from 1 (name=Ivan).
            r#"[[?e :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms1 ?tx true]]"#
        );

        // Assert that 2's sync didn't change remote state.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);
    }

    #[test]
    fn test_schema_merge() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // 1 defines a richer schema than 2.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/age
              :db/valueType :db.type/long
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that 2's schema has been augmented with 1's.
        assert_transactions!(sqlite_2, conn_2,
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",
        );

        // Assert that 2's sync didn't change remote state.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);
    }

    #[test]
    fn test_entity_merge_unique_identity() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both have the same schema with a unique/identity attribute.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        // Both have the same assertion against the schema.
        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        assert_transactions!(sqlite_2, conn_2,
            // Assert that 2's schema is unchanged.
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/name :db/unique :db.unique/identity ?tx true]
            [:person/name :db/index true ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            // Assert that 2's unique entity got smushed with 1's.
            r#"[[?e :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );

        // Assert that 2's sync didn't change remote state.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);
    }

    #[test]
    fn test_entity_merge_unique_identity_conflict() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both start off with the same schema (a single unique/identity attribute) and an assertion.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // First removes the entity.
        conn_1
            .transact(
                &mut sqlite_1,
                r#"[
            [:db/retract (lookup-ref :person/name "Ivan") :person/name "Ivan"]]"#,
            )
            .expect("transacted");

        // Second changes the entitiy.
        conn_2
            .transact(
                &mut sqlite_2,
                r#"[
            {:db/id (lookup-ref :person/name "Ivan") :person/name "Vanya"}
        ]"#,
            )
            .expect("transacted");

        // First syncs first.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // And now, merge!
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );

        // We currently have a primitive conflict resolution strategy,
        // ending up with a new "Vanya" entity.
        assert_transactions!(
            sqlite_2,
            conn_2,
            // These hard-coded entids are brittle but deterministic.
            // They signify that we end up with a new entity Vanya, separate from the one
            // that was renamed.
            r#"[[65537 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65537 :person/name "Ivan" ?tx false]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65538 :person/name "Vanya" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_entity_merge_unique_identity_conflict_reversed() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both start off with the same schema (a single unique/identity attribute) and an assertion.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // First removes the entity.
        conn_1
            .transact(
                &mut sqlite_1,
                r#"[
            [:db/retract (lookup-ref :person/name "Ivan") :person/name "Ivan"]]"#,
            )
            .expect("transacted");

        // Second changes the entitiy.
        conn_2
            .transact(
                &mut sqlite_2,
                r#"[
            [:db/add (lookup-ref :person/name "Ivan") :person/name "Vanya"]
        ]"#,
            )
            .expect("transacted");

        // Second syncs first.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // And now, merge!
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_1,
            sqlite_1,
            remote_client
        );

        // Deletion of "Ivan" will be dropped on the floor, since there's no such
        // entity anymore (it's "Vanya").
        assert_transactions!(
            sqlite_1,
            conn_1,
            // These hard-coded entids are brittle but deterministic.
            r#"[[65537 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65537 :person/name "Ivan" ?tx false]
            [65537 :person/name "Vanya" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_entity_merge_unique_identity_conflict_simple() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both start off with the same schema (a single unique/identity attribute) and an assertion.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one
              :db/unique :db.unique/identity
              :db/index true}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_2,
            sqlite_2,
            remote_client
        );

        // First renames the entity.
        conn_1
            .transact(
                &mut sqlite_1,
                r#"[
            [:db/add (lookup-ref :person/name "Ivan") :person/name "Vanechka"]]"#,
            )
            .expect("transacted");

        // Second also renames the entitiy.
        conn_2
            .transact(
                &mut sqlite_2,
                r#"[
            [:db/add (lookup-ref :person/name "Ivan") :person/name "Vanya"]
        ]"#,
            )
            .expect("transacted");

        // Second syncs first.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // And now, merge!
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_1,
            sqlite_1,
            remote_client
        );

        // These hard-coded entids are brittle but deterministic.
        // They signify that we end up with a new entity Vanechka, separate from the one
        // that was renamed.
        assert_transactions!(
            sqlite_1,
            conn_1,
            r#"[[65537 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65537 :person/name "Ivan" ?tx false]
            [65537 :person/name "Vanya" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            // A new entity is created for the second rename.
            r#"[[65538 :person/name "Vanechka" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_conflicting_schema() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/many}]",
            )
            .expect("transacted");

        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );
        assert_sync!(
            error => MentatError::TolstoyError(TolstoyError::NotYetImplemented(_)),
            conn_2, sqlite_2, remote_client);
    }

    #[test]
    fn test_schema_with_non_matching_entids() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // :person/name will be e=65536.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // This entity will be e=65537.
        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // :person/name will be e=65536, :person/age will be e=65537 (NB conflict w/ above entity).
        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/age
              :db/valueType :db.type/long
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        assert_transactions!(sqlite_1, conn_1,
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            // Assert that 2's unique entity got smushed with 1's.
            r#"[[?e :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,

            // Assert that 2's extra vocabulary is present.
            "[[:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"
        );
    }

    #[test]
    fn test_entity_merge_non_unique_entity_conflict() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both start off with the same schema (a single unique/identity attribute) and an assertion.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        // Will result in two Ivans.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );
        // Upload the second Ivan.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // Get the second Ivan.
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // These entids are determenistic. We can't use lookup-refs because :person/name is
        // a non-unique attribute.
        // First removes an Ivan.
        conn_1
            .transact(
                &mut sqlite_1,
                r#"[
            [:db/retract 65537 :person/name "Ivan"]]"#,
            )
            .expect("transacted");

        // Second renames an Ivan.
        conn_2
            .transact(
                &mut sqlite_2,
                r#"[
            {:db/id 65537 :person/name "Vanya"}]"#,
            )
            .expect("transacted");

        // First syncs first.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // And now, merge!
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );

        // We currently have a primitive conflict resolution strategy,
        // ending up with a new "Vanya" entity.

        // These hard-coded entids are brittle but deterministic.
        // They signify that we end up with a new entity Vanya, separate from the one
        // that was renamed.
        assert_transactions!(
            sqlite_2,
            conn_2,
            r#"[[65537 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65538 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65537 :person/name "Ivan" ?tx false]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65538 :person/name "Ivan" ?tx false]
            [65538 :person/name "Vanya" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_entity_merge_non_unique_entity_conflict_reversed() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // Both start off with the same schema (a single unique/identity attribute) and an assertion.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        // Merge will result in two Ivans.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );
        // Upload the second Ivan.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // Get the second Ivan.
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // These entids are determenistic. We can't use lookup-refs because :person/name is
        // a non-unique attribute.
        // First removes an Ivan.
        conn_1
            .transact(
                &mut sqlite_1,
                r#"[
            [:db/retract 65537 :person/name "Ivan"]]"#,
            )
            .expect("transacted");

        // Second renames an Ivan.
        conn_2
            .transact(
                &mut sqlite_2,
                r#"[
            [:db/add 65537 :person/name "Vanya"]]"#,
            )
            .expect("transacted");

        // Second wins the sync race.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // First merges its changes with second's.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::None),
            conn_1,
            sqlite_1,
            remote_client
        );

        // We currently have a primitive conflict resolution strategy,
        // ending up dropping first's removal of "Ivan".
        // Internally that happens because :person/name is not :db/unique.

        // These hard-coded entids are brittle but deterministic.
        // They signify that we end up with a new entity Vanya, separate from the one
        // that was renamed.
        assert_transactions!(
            sqlite_1,
            conn_1,
            r#"[[65537 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            r#"[[65538 :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,
            // Just the rename left, removal is dropped on the floor.
            r#"[[65537 :person/name "Ivan" ?tx false]
            [65537 :person/name "Vanya" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_entity_merge_non_unique() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // 1 defines the same schema as 2.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :world/city
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Vancouver, BC
        conn_1
            .transact(&mut sqlite_1, r#"[{:world/city "Vancouver"}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :world/city
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Vancouver, WA
        conn_2
            .transact(&mut sqlite_2, r#"[{:world/city "Vancouver"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Since :world/city is not unique, we elect not to smush these entities.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );

        assert_transactions!(sqlite_2, conn_2,
            schema =>
            "[[?e :db/ident :world/city ?tx true]
            [?e :db/valueType :db.type/string ?tx true]
            [?e :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            // Assert that we didn't try smushing non-unique entities.
            r#"[[?e :world/city "Vancouver" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,

            r#"[[?e :world/city "Vancouver" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );

        // Since follow-up must be manually triggered, 1 shouldn't observe any changes yet.
        assert_sync!(SyncReport::NoChanges, conn_1, sqlite_1, remote_client);

        // Follow-up sync.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // 2 should now observe merge results from 1.
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        assert_transactions!(sqlite_1, conn_1,
            // Assert that 1's schema is unchanged.
            schema =>
            "[[?e :db/ident :world/city ?tx true]
            [?e :db/valueType :db.type/string ?tx true]
            [?e :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            // Assert that we didn't try smushing non-unique entities.
            r#"[[?e :world/city "Vancouver" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,

            r#"[[?e :world/city "Vancouver" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_schema_with_assertions_merge() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // 1 defines a richer schema than 2.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/age
              :db/valueType :db.type/long
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_1
            .transact(&mut sqlite_1, r#"[{:person/name "Ivan" :person/age 28}]"#)
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(&mut sqlite_2, r#"[{:person/name "Ivan"}]"#)
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );

        assert_transactions!(sqlite_2, conn_2,
            // Assert that 2's schema has been augmented with 1's.
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            r#"[[?e :person/name "Ivan" ?tx true]
            [?e :person/age 28 ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,

            r#"[[?e :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );

        // Follow-up sync after merge.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that 2's sync fast-forwarded remote.
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        assert_transactions!(sqlite_1, conn_1,
            // Assert that 1's schema remains the same, and it sees the extra Ivan.
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            r#"[[?e :person/name "Ivan" ?tx true]
            [?e :person/age 28 ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#,

            r#"[[?e :person/name "Ivan" ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"#
        );
    }

    #[test]
    fn test_non_subset_merge() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // 1 and 2 define different schemas.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/age
              :db/valueType :db.type/long
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/sin
              :db/valueType :db.type/long
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            SyncReport::Merge(SyncFollowup::FullSync),
            conn_2,
            sqlite_2,
            remote_client
        );

        assert_transactions!(sqlite_2, conn_2,
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            "[[:person/sin :db/ident :person/sin ?tx true]
            [:person/sin :db/valueType :db.type/long ?tx true]
            [:person/sin :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"
        );

        // Follow-up sync after merge.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_2,
            sqlite_2,
            remote_client
        );

        // Assert that 2's sync moved forward the remote state.
        assert_sync!(
            SyncReport::LocalFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        assert_transactions!(sqlite_1, conn_1,
            // Assert that 1's schema is intact, and has been augmented with 2's.
            schema =>
            "[[:person/name :db/ident :person/name ?tx true]
            [:person/name :db/valueType :db.type/string ?tx true]
            [:person/name :db/cardinality :db.cardinality/one ?tx true]
            [:person/age :db/ident :person/age ?tx true]
            [:person/age :db/valueType :db.type/long ?tx true]
            [:person/age :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]",

            "[[:person/sin :db/ident :person/sin ?tx true]
            [:person/sin :db/valueType :db.type/long ?tx true]
            [:person/sin :db/cardinality :db.cardinality/one ?tx true]
            [?tx :db/txInstant ?ms ?tx true]]"
        );
    }

    #[test]
    fn test_merge_schema_with_different_attribute_definitions() {
        let mut sqlite_1 = new_connection("").unwrap();
        let mut sqlite_2 = new_connection("").unwrap();

        let mut conn_1 = Conn::connect(&mut sqlite_1).unwrap();
        let mut conn_2 = Conn::connect(&mut sqlite_2).unwrap();

        let mut remote_client = TestRemoteClient::new();

        // 1 and 2 define same idents but with different cardinality.
        conn_1
            .transact(
                &mut sqlite_1,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/bff
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}]",
            )
            .expect("transacted");

        conn_2
            .transact(
                &mut sqlite_2,
                "[
            {:db/ident :person/name
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/one}
            {:db/ident :person/bff
              :db/valueType :db.type/string
              :db/cardinality :db.cardinality/many}]",
            )
            .expect("transacted");

        // Fast forward empty remote with a bootstrap and schema transactions.
        assert_sync!(
            SyncReport::RemoteFastForward,
            conn_1,
            sqlite_1,
            remote_client
        );

        // Merge bootstrap+schema transactions from 1 into 2.
        assert_sync!(
            error => MentatError::TolstoyError(TolstoyError::NotYetImplemented(_)),
            conn_2, sqlite_2, remote_client
        );
    }
}