realm-js/tests/js/realm-tests.js

////////////////////////////////////////////////////////////////////////////
//
// Copyright 2016 Realm Inc.
//
// 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.
//
////////////////////////////////////////////////////////////////////////////

'use strict';

const require_method = require;

// Prevent React Native packager from seeing modules required with this
function nodeRequire(module) {
    return require_method(module);
}

function uuid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
}

function closeAfterUpload(realm) {
    return new Promise((resolve, reject) => {
        realm.syncSession.addProgressNotification('upload', 'forCurrentlyOutstandingWork', (transferred, transferable) => {
            if (transferred >= transferable) {
                realm.close();
                resolve();
            }
        });
    });
}

const Realm = require('realm');
const TestCase = require('./asserts');
const schemas = require('./schemas');

let pathSeparator = '/';
const isNodeProcess = typeof process === 'object' && process + '' === '[object process]';
if (isNodeProcess && process.platform === 'win32') {
    pathSeparator = '\\';
}

const fs = isNodeProcess ? nodeRequire('fs-extra') : require('react-native-fs');

module.exports = {
    testRealmConstructor: function() {
        const realm = new Realm({schema: []});
        TestCase.assertTrue(realm instanceof Realm);

        TestCase.assertEqual(typeof Realm, 'function');
        TestCase.assertTrue(Realm instanceof Function);
    },

    testRealmConstructorPath: function() {
        TestCase.assertThrows(() => new Realm('')); // the message for this error is platform-specific
        TestCase.assertThrowsContaining(() => new Realm('test1.realm', 'invalidArgument'),
                                        "Invalid arguments when constructing 'Realm'");

        const defaultRealm = new Realm({schema: []});
        TestCase.assertEqual(defaultRealm.path, Realm.defaultPath);

        const defaultRealm2 = new Realm();
        TestCase.assertEqual(defaultRealm2.path, Realm.defaultPath);

        const defaultDir = Realm.defaultPath.substring(0, Realm.defaultPath.lastIndexOf(pathSeparator) + 1);
        const testPath = 'test1.realm';
        const realm = new Realm({schema: [], path: testPath});
        TestCase.assertEqual(realm.path, defaultDir + testPath);

        const testPath2 = 'test2.realm';
        const realm2 = new Realm({schema: [], path: testPath2});
        TestCase.assertEqual(realm2.path, defaultDir + testPath2);
    },

    testRealmIsClosed: function() {
        const realm = new Realm({schema: []});
        TestCase.assertFalse(realm.isClosed);
        realm.close();
        TestCase.assertTrue(realm.isClosed);
    },

    testRealmConstructorSchemaVersion: function() {
        const defaultRealm = new Realm({schema: []});
        TestCase.assertEqual(defaultRealm.schemaVersion, 0);

        TestCase.assertThrowsContaining(() => new Realm({schemaVersion: 1, schema: []}),
                                        "already opened with different schema version.");

        TestCase.assertEqual(new Realm().schemaVersion, 0);
        TestCase.assertEqual(new Realm({schemaVersion: 0}).schemaVersion, 0);

        let realm = new Realm({path: 'test1.realm', schema: [], schemaVersion: 1});
        TestCase.assertEqual(realm.schemaVersion, 1);
        TestCase.assertEqual(realm.schema.length, 0);
        realm.close();

        realm = new Realm({path: 'test1.realm', schema: [schemas.TestObject], schemaVersion: 2});
        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
        });
        TestCase.assertEqual(realm.objects('TestObject')[0].doubleCol, 1);
        TestCase.assertEqual(realm.schemaVersion, 2);
        TestCase.assertEqual(realm.schema.length, 1);
    },

    testRealmConstructorDynamicSchema: function() {
        let realm = new Realm({schema: [schemas.TestObject]});
        realm.write(() => {
            realm.create('TestObject', [1])
        });
        realm.close();

        realm = new Realm();
        const objects = realm.objects('TestObject');
        TestCase.assertEqual(objects.length, 1);
        TestCase.assertEqual(objects[0].doubleCol, 1.0);
    },

    testRealmConstructorSchemaValidation: function() {
        TestCase.assertThrowsContaining(() => new Realm({schema: schemas.AllTypes}),
                                        "schema must be of type 'array', got");
        TestCase.assertThrowsContaining(() => new Realm({schema: ['SomeType']}),
                                        "Failed to read ObjectSchema: JS value must be of type 'object', got (SomeType)");
        TestCase.assertThrowsContaining(() => new Realm({schema: [{}]}),
                                        "Failed to read ObjectSchema: name must be of type 'string', got (undefined)");
        TestCase.assertThrowsContaining(() => new Realm({schema: [{name: 'SomeObject'}]}),
                                        "Failed to read ObjectSchema: properties must be of type 'object', got (undefined)");
        TestCase.assertThrowsContaining(() => new Realm({schema: [{properties: {intCol: 'int'}}]}),
                                        "Failed to read ObjectSchema: name must be of type 'string', got (undefined)");

        function assertPropertyInvalid(prop, message) {
            TestCase.assertThrowsContaining(() => {
                new Realm({schema: [{name: 'InvalidObject', properties: { int: 'int', bad: prop }}]});
            }, message, 1);
        }

        assertPropertyInvalid({type:'list[]', objectType: 'InvalidObject'},
                              "List property 'InvalidObject.bad' must have a non-list value type");
        assertPropertyInvalid({type:'list?', objectType: 'InvalidObject'},
                              "List property 'InvalidObject.bad' cannot be optional");
        assertPropertyInvalid('', "Property 'InvalidObject.bad' must have a non-empty type");
        assertPropertyInvalid({type:'linkingObjects', objectType: 'InvalidObject', property: 'nosuchproperty'},
                              "Property 'InvalidObject.nosuchproperty' declared as origin of linking objects property 'InvalidObject.bad' does not exist");
        assertPropertyInvalid({type:'linkingObjects', objectType: 'InvalidObject', property: 'int'},
                              "Property 'InvalidObject.int' declared as origin of linking objects property 'InvalidObject.bad' is not a link");

        // linkingObjects property where the source property links elsewhere
        TestCase.assertThrowsContaining(() => {
            new Realm({schema: [{
                name: 'InvalidObject',
                properties: {
                    link: 'IntObject',
                    linkingObjects: {type:'linkingObjects', objectType: 'InvalidObject', property: 'link'}
                }
            }, {
                name: 'IntObject',
                properties: {
                    integer: 'int'
                }
            }]});
        }, "Property 'InvalidObject.link' declared as origin of linking objects property 'InvalidObject.linkingObjects' links to type 'IntObject'")

        {
            new Realm({schema: [{
                name: 'Object',
                properties: {
                    // weird but valid
                    objectList: {type:'object[]', objectType: 'Object'}
                }
            }]});
        }
    },

    testRealmConstructorInMemory: function() {
        // open in-memory realm instance
        const realm1 = new Realm({inMemory: true, schema: [schemas.TestObject]});
        realm1.write(() => {
            realm1.create('TestObject', [1])
        });
        TestCase.assertEqual(realm1.inMemory, true);

        // open a second instance of the same realm and check that they share data
        const realm2 = new Realm({inMemory: true});
        const objects = realm2.objects('TestObject');
        TestCase.assertEqual(objects.length, 1);
        TestCase.assertEqual(objects[0].doubleCol, 1.0);
        TestCase.assertEqual(realm2.inMemory, true);

        // Close both realms (this should delete the realm since there are no more
        // references to it.
        realm1.close();
        realm2.close();

        // Open the same in-memory realm again and verify that it is now empty
        const realm3 = new Realm({inMemory: true});
        TestCase.assertEqual(realm3.schema.length, 0);

        // try to open the same realm in persistent mode (should fail as you cannot mix modes)
        TestCase.assertThrowsContaining(() => new Realm({}), 'already opened with different inMemory settings.');
    },

    testRealmConstructorReadOnly: function() {
        let realm = new Realm({schema: [schemas.TestObject]});
        realm.write(() => {
            realm.create('TestObject', [1])
        });
        TestCase.assertEqual(realm.readOnly, false);
        realm.close();

        realm = new Realm({readOnly: true, schema: [schemas.TestObject]});
        const objects = realm.objects('TestObject');
        TestCase.assertEqual(objects.length, 1);
        TestCase.assertEqual(objects[0].doubleCol, 1.0);
        TestCase.assertEqual(realm.readOnly, true);

        TestCase.assertThrowsContaining(() => realm.write(() => {}),
                                        "Can't perform transactions on read-only Realms.");
        realm.close();

        realm = new Realm({readOnly: true});
        TestCase.assertEqual(realm.schema.length, 1);
        TestCase.assertEqual(realm.readOnly, true);
    },

    testRealmOpen: function() {
        let realm = new Realm({schema: [schemas.TestObject], schemaVersion: 1});
        realm.write(() => {
            realm.create('TestObject', [1])
        });
        realm.close();

        return Realm.open({schema: [schemas.TestObject], schemaVersion: 2}).then(realm => {
            const objects = realm.objects('TestObject');
            TestCase.assertEqual(objects.length, 1);
            TestCase.assertEqual(objects[0].doubleCol, 1.0);
            realm.close();
        });
    },

    testRealmOpenNoConfig: function() {
        let realm = new Realm({schema: [schemas.TestObject], schemaVersion: 1});
        realm.write(() => {
            realm.create('TestObject', [1])
        });
        realm.close();

        return Realm.open().then(realm => {
            const objects = realm.objects('TestObject');
            TestCase.assertEqual(objects.length, 1);
            TestCase.assertEqual(objects[0].doubleCol, 1.0);
            realm.close();
        });
    },

    testDefaultPath: function() {
        const defaultPath = Realm.defaultPath;
        let defaultRealm = new Realm({schema: []});
        TestCase.assertEqual(defaultRealm.path, Realm.defaultPath);

        try {
            const newPath = `${Realm.defaultPath.substring(0, defaultPath.lastIndexOf(pathSeparator) + 1)}default2.realm`;
            Realm.defaultPath = newPath;
            defaultRealm = new Realm({schema: []});
            TestCase.assertEqual(defaultRealm.path, newPath, "should use updated default realm path");
            TestCase.assertEqual(Realm.defaultPath, newPath, "defaultPath should have been updated");
        } finally {
            Realm.defaultPath = defaultPath;
        }
    },

    testRealmSchemaVersion: function() {
        TestCase.assertEqual(Realm.schemaVersion(Realm.defaultPath), -1);

        let realm = new Realm({schema: []});
        TestCase.assertEqual(realm.schemaVersion, 0);
        TestCase.assertEqual(Realm.schemaVersion(Realm.defaultPath), 0);

        realm = new Realm({schema: [], schemaVersion: 2, path: 'another.realm'});
        TestCase.assertEqual(realm.schemaVersion, 2);
        TestCase.assertEqual(Realm.schemaVersion('another.realm'), 2);
    },

    testRealmWrite: function() {
        const realm = new Realm({schema: [schemas.IntPrimary, schemas.AllTypes, schemas.TestObject, schemas.LinkToAllTypes]});

        // exceptions should be propogated
        TestCase.assertThrowsContaining(() => realm.write(() => { throw new Error('Inner exception message'); }),
                                        'Inner exception message');

        // writes should be possible after caught exception
        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
        });
        TestCase.assertEqual(1, realm.objects('TestObject').length);

        realm.write(() => {
            // nested transactions not supported
            TestCase.assertThrowsContaining(() => realm.write(() => {}),
                                            'The Realm is already in a write transaction');
        });
    },

    testRealmCreate: function() {
        const realm = new Realm({schema: [schemas.TestObject]});

        TestCase.assertThrowsContaining(() => realm.create('TestObject', {doubleCol: 1}),
                                        "Cannot modify managed objects outside of a write transaction.");

        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
            realm.create('TestObject', {doubleCol: 2});
        });

        const objects = realm.objects('TestObject');
        TestCase.assertEqual(objects.length, 2, 'wrong object count');
        TestCase.assertEqual(objects[0].doubleCol, 1, 'wrong object property value');
        TestCase.assertEqual(objects[1].doubleCol, 2, 'wrong object property value');
    },

    testRealmCreatePrimaryKey: function() {
        const realm = new Realm({schema: [schemas.IntPrimary]});

        realm.write(() => {
            const obj0 = realm.create('IntPrimaryObject', {
                primaryCol: 0,
                valueCol: 'val0',
            });

            TestCase.assertThrowsContaining(() => {
                realm.create('IntPrimaryObject', {
                    primaryCol: 0,
                    valueCol: 'val0',
                });
            }, "Attempting to create an object of type 'IntPrimaryObject' with an existing primary key value '0'.");

            realm.create('IntPrimaryObject', {
                primaryCol: 1,
                valueCol: 'val1',
            }, true);

            const objects = realm.objects('IntPrimaryObject');
            TestCase.assertEqual(objects.length, 2);

            realm.create('IntPrimaryObject', {
                primaryCol: 0,
                valueCol: 'newVal0',
            }, true);

            TestCase.assertEqual(obj0.valueCol, 'newVal0');
            TestCase.assertEqual(objects.length, 2);

            realm.create('IntPrimaryObject', {primaryCol: 0}, true);
            TestCase.assertEqual(obj0.valueCol, 'newVal0');
        });
    },

    testRealmCreateUpsert: function() {
        const realm = new Realm({schema: [schemas.AllPrimaryTypes, schemas.TestObject,
                                          schemas.StringPrimary]});
        realm.write(function() {
            const values = {
                primaryCol: '0',
                boolCol:    true,
                intCol:     1,
                floatCol:   1.1,
                doubleCol:  1.11,
                stringCol:  '1',
                dateCol:    new Date(1),
                dataCol:    new ArrayBuffer(1),
                objectCol:  {doubleCol: 1},
                arrayCol:   [],
            };

            const obj0 = realm.create('AllPrimaryTypesObject', values);

            TestCase.assertThrowsContaining(() => realm.create('AllPrimaryTypesObject', values),
                                            "Attempting to create an object of type 'AllPrimaryTypesObject' with an existing primary key value ''0''.");

            const obj1 = realm.create('AllPrimaryTypesObject', {
                primaryCol: '1',
                boolCol:    false,
                intCol:     2,
                floatCol:   2.2,
                doubleCol:  2.22,
                stringCol:  '2',
                dateCol:    new Date(2),
                dataCol:    new ArrayBuffer(2),
                objectCol:  {doubleCol: 0},
                arrayCol:   [{doubleCol: 2}],
            }, true);

            const objects = realm.objects('AllPrimaryTypesObject');
            TestCase.assertEqual(objects.length, 2);

            realm.create('AllPrimaryTypesObject', {
                primaryCol: '0',
                boolCol:    false,
                intCol:     2,
                floatCol:   2.2,
                doubleCol:  2.22,
                stringCol:  '2',
                dateCol:    new Date(2),
                dataCol:    new ArrayBuffer(2),
                objectCol:  null,
                arrayCol:   [{doubleCol: 2}],
            }, true);

            TestCase.assertEqual(objects.length, 2);
            TestCase.assertEqual(obj0.stringCol, '2');
            TestCase.assertEqual(obj0.boolCol, false);
            TestCase.assertEqual(obj0.intCol, 2);
            TestCase.assertEqualWithTolerance(obj0.floatCol, 2.2, 0.000001);
            TestCase.assertEqualWithTolerance(obj0.doubleCol, 2.22, 0.000001);
            TestCase.assertEqual(obj0.dateCol.getTime(), 2);
            TestCase.assertEqual(obj0.dataCol.byteLength, 2);
            TestCase.assertEqual(obj0.objectCol, null);
            TestCase.assertEqual(obj0.arrayCol.length, 1);

            realm.create('AllPrimaryTypesObject', {primaryCol: '0'}, true);
            realm.create('AllPrimaryTypesObject', {primaryCol: '1'}, true);
            TestCase.assertEqual(obj0.stringCol, '2');
            TestCase.assertEqual(obj0.objectCol, null);
            TestCase.assertEqual(obj1.objectCol.doubleCol, 0);

            realm.create('AllPrimaryTypesObject', {
                primaryCol: '0',
                stringCol:  '3',
                objectCol:  {doubleCol: 0},
            }, true);

            TestCase.assertEqual(obj0.stringCol, '3');
            TestCase.assertEqual(obj0.boolCol, false);
            TestCase.assertEqual(obj0.intCol, 2);
            TestCase.assertEqualWithTolerance(obj0.floatCol, 2.2, 0.000001);
            TestCase.assertEqualWithTolerance(obj0.doubleCol, 2.22, 0.000001);
            TestCase.assertEqual(obj0.dateCol.getTime(), 2);
            TestCase.assertEqual(obj0.dataCol.byteLength, 2);
            TestCase.assertEqual(obj0.objectCol.doubleCol, 0);
            TestCase.assertEqual(obj0.arrayCol.length, 1);

            realm.create('AllPrimaryTypesObject', {primaryCol: '0', objectCol: undefined}, true);
            realm.create('AllPrimaryTypesObject', {primaryCol: '1', objectCol: null}, true);
            TestCase.assertEqual(obj0.objectCol.doubleCol, 0);
            TestCase.assertEqual(obj1.objectCol, null);

            // test with string primaries
            const obj = realm.create('StringPrimaryObject', {
                primaryCol: '0',
                valueCol: 0
            });
            TestCase.assertEqual(obj.valueCol, 0);

            realm.create('StringPrimaryObject', {
                primaryCol: '0',
                valueCol: 1
            }, true);
            TestCase.assertEqual(obj.valueCol, 1);
        });
    },

    testRealmWithIndexedProperties: function() {
        const realm = new Realm({schema: [schemas.IndexedTypes]});
        realm.write(() => {
            realm.create('IndexedTypesObject', {boolCol: true, intCol: 1, stringCol: '1', dateCol: new Date(1)});
        });

        const NotIndexed = {
            name: 'NotIndexedObject',
            properties: {
                floatCol: {type: 'float', indexed: false}
            }
        };

        new Realm({schema: [NotIndexed], path: '1.realm'});

        const IndexedSchema = {
            name: 'IndexedSchema',
        };
        TestCase.assertThrowsContaining(() => {
            IndexedSchema.properties = { floatCol: {type: 'float', indexed: true} };
            new Realm({schema: [IndexedSchema], path: '2.realm'});
        }, "Property 'IndexedSchema.floatCol' of type 'float' cannot be indexed.");

        TestCase.assertThrowsContaining(() => {
            IndexedSchema.properties = { doubleCol: {type: 'double', indexed: true} }
            new Realm({schema: [IndexedSchema], path: '3.realm'});
        }, "Property 'IndexedSchema.doubleCol' of type 'double' cannot be indexed.");

        TestCase.assertThrowsContaining(() => {
            IndexedSchema.properties = { dataCol: {type: 'data', indexed: true} }
            new Realm({schema: [IndexedSchema], path: '4.realm'});
        }, "Property 'IndexedSchema.dataCol' of type 'data' cannot be indexed.");

        // primary key
        IndexedSchema.properties = { intCol: {type: 'int', indexed: true} };
        IndexedSchema.primaryKey = 'intCol';

        // Test this doesn't throw
        new Realm({schema: [IndexedSchema], path: '5.realm'});
    },

    testRealmCreateWithDefaults: function() {
        let realm = new Realm({schema: [schemas.DefaultValues, schemas.TestObject]});

        const createAndTestObject = () => {
            const obj = realm.create('DefaultValuesObject', {});
            const properties = schemas.DefaultValues.properties;

            TestCase.assertEqual(obj.boolCol, properties.boolCol.default);
            TestCase.assertEqual(obj.intCol, properties.intCol.default);
            TestCase.assertEqualWithTolerance(obj.floatCol, properties.floatCol.default, 0.000001);
            TestCase.assertEqualWithTolerance(obj.doubleCol, properties.doubleCol.default, 0.000001);
            TestCase.assertEqual(obj.stringCol, properties.stringCol.default);
            TestCase.assertEqual(obj.dateCol.getTime(), properties.dateCol.default.getTime());
            TestCase.assertEqual(obj.dataCol.byteLength, properties.dataCol.default.byteLength);
            TestCase.assertEqual(obj.objectCol.doubleCol, properties.objectCol.default.doubleCol);
            TestCase.assertEqual(obj.nullObjectCol, null);
            TestCase.assertEqual(obj.arrayCol.length, properties.arrayCol.default.length);
            TestCase.assertEqual(obj.arrayCol[0].doubleCol, properties.arrayCol.default[0].doubleCol);
        };

        realm.write(createAndTestObject);

        // Defaults should still work when creating another Realm instance.
        realm = new Realm();
        realm.write(createAndTestObject);
    },

    testRealmCreateWithChangingDefaults: function() {
        const objectSchema = {
            name: 'IntObject',
            properties: {
                intCol: {type: 'int', default: 1},
            }
        };

        let realm = new Realm({schema: [objectSchema]});

        const createAndTestObject = () => {
            const object = realm.create('IntObject', {});
            TestCase.assertEqual(object.intCol, objectSchema.properties.intCol.default);
        };

        realm.write(createAndTestObject);

        objectSchema.properties.intCol.default++;

        realm = new Realm({schema: [objectSchema]});
        realm.write(createAndTestObject);
    },

    testRealmCreateWithConstructor: function() {
        let customCreated = 0;

        function CustomObject() {
            customCreated++;
        }
        CustomObject.schema = {
            name: 'CustomObject',
            properties: {
                intCol: 'int'
            }
        }

        function InvalidObject() {
            return {};
        }
        TestCase.assertThrowsContaining(() => new Realm({schema: [InvalidObject]}),
                                        "Realm object constructor must have a 'schema' property.");

        InvalidObject.schema = {
            name: 'InvalidObject',
            properties: {
                intCol: 'int'
            }
        };

        let realm = new Realm({schema: [CustomObject, InvalidObject]});

        realm.write(() => {
            let object = realm.create('CustomObject', {intCol: 1});
            TestCase.assertTrue(object instanceof CustomObject);
            TestCase.assertTrue(Object.getPrototypeOf(object) == CustomObject.prototype);
            TestCase.assertEqual(customCreated, 1);

            // Should be able to create object by passing in constructor.
            object = realm.create(CustomObject, {intCol: 2});
            TestCase.assertTrue(object instanceof CustomObject);
            TestCase.assertTrue(Object.getPrototypeOf(object) == CustomObject.prototype);
            TestCase.assertEqual(customCreated, 2);
        });

        TestCase.assertThrowsContaining(() => {
            realm.write(() => {
                realm.create('InvalidObject', {intCol: 1});
            });
        }, 'Realm object constructor must not return another value');

        // Only the original constructor should be valid.
        function InvalidCustomObject() {}
        InvalidCustomObject.schema = CustomObject.schema;

        TestCase.assertThrowsContaining(() => {
            realm.write(() => {
                realm.create(InvalidCustomObject, {intCol: 1});
            });
        }, 'Constructor was not registered in the schema for this Realm');

        // The constructor should still work when creating another Realm instance.
        realm = new Realm();
        TestCase.assertTrue(realm.objects('CustomObject')[0] instanceof CustomObject);
        TestCase.assertTrue(realm.objects(CustomObject).length > 0);
    },

    testRealmCreateWithChangingConstructor: function() {
        function CustomObject() {}
        CustomObject.schema = {
            name: 'CustomObject',
            properties: {
                intCol: 'int'
            }
        };

        let realm = new Realm({schema: [CustomObject]});
        realm.write(() => {
            const object = realm.create('CustomObject', {intCol: 1});
            TestCase.assertTrue(object instanceof CustomObject);
        });

        function NewCustomObject() {}
        NewCustomObject.schema = CustomObject.schema;

        realm = new Realm({schema: [NewCustomObject]});
        realm.write(() => {
            const object = realm.create('CustomObject', {intCol: 1});
            TestCase.assertTrue(object instanceof NewCustomObject);
        });
    },

    testRealmDelete: function() {
        const realm = new Realm({schema: [schemas.TestObject]});

        realm.write(() => {
            for (let i = 0; i < 10; i++) {
                realm.create('TestObject', {doubleCol: i});
            }
        });

        const objects = realm.objects('TestObject');
        TestCase.assertThrowsContaining(() => realm.delete(objects[0]),
                                        "Can only delete objects within a transaction.");

        realm.write(() => {
            TestCase.assertThrowsContaining(() => realm.delete(),
                                            "object must be of type 'object', got (undefined)");

            realm.delete(objects[0]);
            TestCase.assertEqual(objects.length, 9, 'wrong object count');
            TestCase.assertEqual(objects[0].doubleCol, 9, "wrong property value");
            TestCase.assertEqual(objects[1].doubleCol, 1, "wrong property value");

            realm.delete([objects[0], objects[1]]);
            TestCase.assertEqual(objects.length, 7, 'wrong object count');
            TestCase.assertEqual(objects[0].doubleCol, 7, "wrong property value");
            TestCase.assertEqual(objects[1].doubleCol, 8, "wrong property value");

            const threeObjects = realm.objects('TestObject').filtered("doubleCol < 5");
            TestCase.assertEqual(threeObjects.length, 3, "wrong results count");
            realm.delete(threeObjects);
            TestCase.assertEqual(objects.length, 4, 'wrong object count');
            TestCase.assertEqual(threeObjects.length, 0, 'threeObject should have been deleted');

            const o = objects[0];
            realm.delete(o);
            TestCase.assertThrowsContaining(() => realm.delete(o),
                                            'Object is invalid. Either it has been previously deleted or the Realm it belongs to has been closed.');
        });
    },

    testDeleteAll: function() {
        const realm = new Realm({schema: [schemas.TestObject, schemas.IntPrimary]});

        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
            realm.create('TestObject', {doubleCol: 2});
            realm.create('IntPrimaryObject', {primaryCol: 2, valueCol: 'value'});
        });

        TestCase.assertEqual(realm.objects('TestObject').length, 2);
        TestCase.assertEqual(realm.objects('IntPrimaryObject').length, 1);

        TestCase.assertThrowsContaining(() => realm.deleteAll(),
                                        "Can only delete objects within a transaction.");

        realm.write(() => {
            realm.deleteAll();
        });

        TestCase.assertEqual(realm.objects('TestObject').length, 0);
        TestCase.assertEqual(realm.objects('IntPrimaryObject').length, 0);
    },

    testRealmObjects: function() {
        const realm = new Realm({schema: [schemas.PersonObject, schemas.DefaultValues, schemas.TestObject]});

        realm.write(() => {
            realm.create('PersonObject', {name: 'Ari', age: 10});
            realm.create('PersonObject', {name: 'Tim', age: 11});
            realm.create('PersonObject', {name: 'Bjarne', age: 12});
            realm.create('PersonObject', {name: 'Alex', age: 12, married: true});
        });

        // Should be able to pass constructor for getting objects.
        const objects = realm.objects(schemas.PersonObject);
        TestCase.assertTrue(objects[0] instanceof schemas.PersonObject);

        function InvalidPerson() {}
        InvalidPerson.schema = schemas.PersonObject.schema;

        TestCase.assertThrowsContaining(() => realm.objects(), "objectType must be of type 'string', got (undefined)");
        TestCase.assertThrowsContaining(() => realm.objects([]), "objectType must be of type 'string', got ()");
        TestCase.assertThrowsContaining(() => realm.objects('InvalidClass'), "Object type 'InvalidClass' not found in schema.");
        TestCase.assertThrowsContaining(() => realm.objects('PersonObject', 'truepredicate'),
                                        "Invalid arguments: at most 1 expected, but 2 supplied.");
        TestCase.assertThrowsContaining(() => realm.objects(InvalidPerson),
                                        'Constructor was not registered in the schema for this Realm');

        const person = realm.objects('PersonObject')[0];
        const listenerCallback = () => {};
        realm.addListener('change', listenerCallback);

        // The tests below assert that everthing throws when
        // operating on a closed realm
        realm.close();

        TestCase.assertThrowsContaining(() => console.log("Name: ", person.name),
                                        'Accessing object of type PersonObject which has been invalidated or deleted');

        TestCase.assertThrowsContaining(() => realm.objects('PersonObject'), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.addListener('change', () => {}), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.create('PersonObject', {name: 'Ari', age: 10}), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.delete(person), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.deleteAll(), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.write(() => {}), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.removeListener('change', listenerCallback), 'Cannot access realm that has been closed');
        TestCase.assertThrowsContaining(() => realm.removeAllListeners(), 'Cannot access realm that has been closed');
    },

    testRealmObjectForPrimaryKey: function() {
        const realm = new Realm({schema: [schemas.IntPrimary, schemas.StringPrimary, schemas.TestObject]});

        realm.write(() => {
            realm.create('IntPrimaryObject', {primaryCol: 0, valueCol: 'val0'});
            realm.create('IntPrimaryObject', {primaryCol: 1, valueCol: 'val1'});

            realm.create('StringPrimaryObject', {primaryCol: '', valueCol: -1});
            realm.create('StringPrimaryObject', {primaryCol: 'val0', valueCol: 0});
            realm.create('StringPrimaryObject', {primaryCol: 'val1', valueCol: 1});

            realm.create('TestObject', {doubleCol: 0});
        });

        TestCase.assertEqual(realm.objectForPrimaryKey('IntPrimaryObject', -1), undefined);
        TestCase.assertEqual(realm.objectForPrimaryKey('IntPrimaryObject', 0).valueCol, 'val0');
        TestCase.assertEqual(realm.objectForPrimaryKey('IntPrimaryObject', 1).valueCol, 'val1');

        TestCase.assertEqual(realm.objectForPrimaryKey('StringPrimaryObject', 'invalid'), undefined);
        TestCase.assertEqual(realm.objectForPrimaryKey('StringPrimaryObject', '').valueCol, -1);
        TestCase.assertEqual(realm.objectForPrimaryKey('StringPrimaryObject', 'val0').valueCol, 0);
        TestCase.assertEqual(realm.objectForPrimaryKey('StringPrimaryObject', 'val1').valueCol, 1);

        TestCase.assertThrowsContaining(() => realm.objectForPrimaryKey('TestObject', 0),
                                        "'TestObject' does not have a primary key defined");
        TestCase.assertThrowsContaining(() => realm.objectForPrimaryKey(),
                                        "objectType must be of type 'string', got (undefined)");
        TestCase.assertThrowsContaining(() => realm.objectForPrimaryKey('IntPrimaryObject'),
                                        "Invalid null value for non-nullable primary key.");
        TestCase.assertThrowsContaining(() => realm.objectForPrimaryKey('InvalidClass', 0),
                                        "Object type 'InvalidClass' not found in schema.");
    },

    testNotifications: function() {
        const realm = new Realm({schema: []});
        let notificationCount = 0;
        let notificationName;

        realm.addListener('change', (realm, name) => {
            notificationCount++;
            notificationName = name;
        });

        TestCase.assertEqual(notificationCount, 0);
        realm.write(() => {});
        TestCase.assertEqual(notificationCount, 1);
        TestCase.assertEqual(notificationName, 'change');

        let secondNotificationCount = 0;
        function secondNotification() {
            secondNotificationCount++;
        }

        // The listener should only be added once.
        realm.addListener('change', secondNotification);
        realm.addListener('change', secondNotification);

        realm.write(() => {});
        TestCase.assertEqual(notificationCount, 2);
        TestCase.assertEqual(secondNotificationCount, 1);

        realm.removeListener('change', secondNotification);
        realm.write(() => {});
        TestCase.assertEqual(notificationCount, 3);
        TestCase.assertEqual(secondNotificationCount, 1);

        realm.removeAllListeners();
        realm.write(() => {});
        TestCase.assertEqual(notificationCount, 3);
        TestCase.assertEqual(secondNotificationCount, 1);

        TestCase.assertThrowsContaining(() => realm.addListener('invalid', () => {}),
                                        "Only the 'change' and 'schema' notification names are supported.");

        realm.addListener('change', () => {
            throw new Error('expected error message');
        });

        TestCase.assertThrowsContaining(() => realm.write(() => {}),
                                        'expected error message');
    },

    testSchema: function() {
        const originalSchema = [schemas.TestObject, schemas.AllTypes, schemas.LinkToAllTypes,
                                schemas.IndexedTypes, schemas.IntPrimary, schemas.PersonObject,
                                schemas.LinkTypes, schemas.LinkingObjectsObject];

        const schemaMap = {};
        originalSchema.forEach(objectSchema => {
            if (objectSchema.schema) { // for PersonObject
                schemaMap[objectSchema.schema.name] = objectSchema;
            } else {
                schemaMap[objectSchema.name] = objectSchema;
            }
        });

        const realm = new Realm({schema: originalSchema});

        const schema = realm.schema;
        TestCase.assertEqual(schema.length, originalSchema.length);

        const normalizeProperty = (val) => {
            let prop;
            if (typeof val !== 'string' && !(val instanceof String)) {
                prop = val;
                prop.optional = val.optional || false;
                prop.indexed = val.indexed || false;
            }
            else {
                prop = {type: val, indexed: false, optional: false};
            }
            if (prop.type.includes('?')) {
                prop.optional = true;
                prop.type = prop.type.replace('?', '');
            }
            if (prop.type.includes('[]')) {
                prop.objectType = prop.type.replace('[]', '');
                prop.type = 'list';
            }
            return prop;
        };

        for (const objectSchema of schema) {
            let original = schemaMap[objectSchema.name];
            if (original.schema) {
                original = original.schema;
            }

            TestCase.assertEqual(objectSchema.primaryKey, original.primaryKey);
            for (const propName in objectSchema.properties) {
                TestCase.assertDefined(original.properties[propName], `schema has unexpected property ${propName}`);

                const actual = objectSchema.properties[propName];
                const expected = normalizeProperty(original.properties[propName]);
                TestCase.assertEqual(actual.name, propName);
                TestCase.assertEqual(actual.indexed, expected.indexed);

                if (actual.type == 'object') {
                    TestCase.assertEqual(actual.objectType, expected.type === 'object' ? expected.objectType : expected.type);
                    TestCase.assertEqual(actual.optional, true);
                    TestCase.assertUndefined(actual.property);
                }
                else if (actual.type == 'list') {
                    TestCase.assertEqual(actual.type, expected.type);
                    TestCase.assertEqual(actual.objectType, expected.objectType);
                    TestCase.assertEqual(actual.optional, expected.optional);
                    TestCase.assertUndefined(actual.property);
                }
                else if (actual.type == 'linkingObjects') {
                    TestCase.assertEqual(actual.type, expected.type);
                    TestCase.assertEqual(actual.objectType, expected.objectType);
                    TestCase.assertEqual(actual.property, expected.property);
                    TestCase.assertEqual(actual.optional, false);
                }
                else {
                    TestCase.assertEqual(actual.type, expected.type);
                    TestCase.assertEqual(actual.optional, expected.optional);
                    TestCase.assertUndefined(actual.property);
                    TestCase.assertUndefined(actual.objectType);
                }
            }
        }
    },

    testCopyBundledRealmFiles: function() {
        Realm.copyBundledRealmFiles();

        let realm = new Realm({path: 'dates-v5.realm', schema: [schemas.DateObject]});
        TestCase.assertEqual(realm.objects('Date').length, 2);
        TestCase.assertEqual(realm.objects('Date')[0].currentDate.getTime(), 1462500087955);

        const newDate = new Date(1);
        realm.write(() => {
            realm.objects('Date')[0].currentDate = newDate;
        });
        realm.close();

        // copy should not overwrite existing files
        Realm.copyBundledRealmFiles();
        realm = new Realm({path: 'dates-v5.realm', schema: [schemas.DateObject]});
        TestCase.assertEqual(realm.objects('Date')[0].currentDate.getTime(), 1);
    },

    testErrorMessageFromInvalidWrite: function() {
        const realm = new Realm({schema: [schemas.PersonObject]});

        TestCase.assertThrowsException(() => {
            realm.write(() => {
                const p1 = realm.create('PersonObject', { name: 'Ari', age: 10 });
                p1.age = "Ten";
            });
        }, new Error("PersonObject.age must be of type 'number', got 'string' ('Ten')"));
    },

    testErrorMessageFromInvalidCreate: function() {
        const realm = new Realm({schema: [schemas.PersonObject]});

        TestCase.assertThrowsException(() => {
            realm.write(() => {
                const p1 = realm.create('PersonObject', { name: 'Ari', age: 'Ten' });
            });
        }, new Error("PersonObject.age must be of type 'number', got 'string' ('Ten')"));
    },

    testValidTypesForListProperties: function() {
        const realm = new Realm({schema: [schemas.PersonObject]});
        realm.write(() => {
            const p1 = realm.create('PersonObject', { name: 'Ari', age: 10 });
            const p2 = realm.create('PersonObject', { name: 'Harold', age: 55, children: realm.objects('PersonObject').filtered('age < 15') });
            TestCase.assertEqual(p2.children.length, 1);
            const p3 = realm.create('PersonObject', { name: 'Wendy', age: 52, children: p2.children });
            TestCase.assertEqual(p3.children.length, 1);
        });
    },

    testEmpty: function() {
        const realm = new Realm({schema: [schemas.PersonObject]});
        TestCase.assertTrue(realm.empty);

        realm.write(() => realm.create('PersonObject', { name: 'Ari', age: 10 }));
        TestCase.assertTrue(!realm.empty);

        realm.write(() => realm.delete(realm.objects('PersonObject')));
        TestCase.assertTrue(realm.empty);
    },

    testManualTransaction: function() {
        const realm = new Realm({schema: [schemas.TestObject]});
        TestCase.assertTrue(realm.empty);

        realm.beginTransaction();
        realm.create('TestObject', {doubleCol: 3.1415});
        realm.commitTransaction();

        TestCase.assertEqual(realm.objects('TestObject').length, 1);
    },

    testCancelTransaction: function() {
        const realm = new Realm({schema: [schemas.TestObject]});
        TestCase.assertTrue(realm.empty);

        realm.beginTransaction();
        realm.create('TestObject', {doubleCol: 3.1415});
        realm.cancelTransaction();

        TestCase.assertTrue(realm.empty);
    },

    testIsInTransaction: function() {
        const realm = new Realm({schema: [schemas.TestObject]});
        TestCase.assertTrue(!realm.isInTransaction);
        realm.beginTransaction();
        TestCase.assertTrue(realm.isInTransaction);
        realm.cancelTransaction();
        TestCase.assertTrue(!realm.isInTransaction);
    },

    testCompact: function() {
        let wasCalled = false;
        const count = 1000;
        // create compactable Realm
        const realm1 = new Realm({schema: [schemas.StringOnly]});
        realm1.write(() => {
            realm1.create('StringOnlyObject', { stringCol: 'A' });
            for (let i = 0; i < count; i++) {
                realm1.create('StringOnlyObject', { stringCol: 'ABCDEFG' });
            }
            realm1.create('StringOnlyObject', { stringCol: 'B' });
        });
        realm1.close();

        // open Realm and see if it is compacted
        const shouldCompact = (totalBytes, usedBytes) => {
            wasCalled = true;
            const fiveHundredKB = 500*1024;
            return (totalBytes > fiveHundredKB) && (usedBytes / totalBytes) < 0.2;
        };
        const realm2 = new Realm({schema: [schemas.StringOnly], shouldCompactOnLaunch: shouldCompact});
        TestCase.assertTrue(wasCalled);
        TestCase.assertEqual(realm2.objects('StringOnlyObject').length, count + 2);
        // we don't check if the file is smaller as we assume that Object Store does it
        realm2.close();
    },

    testManualCompact: function() {
        const realm1 = new Realm({schema: [schemas.StringOnly]});
        realm1.write(() => {
            realm1.create('StringOnlyObject', { stringCol: 'A' });
        });
        TestCase.assertTrue(realm1.compact());
        realm1.close();

        const realm2 = new Realm({schema: [schemas.StringOnly]});
        TestCase.assertEqual(realm2.objects('StringOnlyObject').length, 1);
        realm2.close();
    },

    testManualCompactInWrite: function() {
        const realm = new Realm({schema: [schemas.StringOnly]});
        realm.write(() => {
            TestCase.assertThrowsContaining(() => {
                realm.compact();
            }, 'Cannot compact a Realm within a transaction.');
        });
        TestCase.assertTrue(realm.empty);
    },

    testManualCompactMultipleInstances: function() {
        const realm1 = new Realm({schema: [schemas.StringOnly]});
        const realm2 = new Realm({schema: [schemas.StringOnly]});
        TestCase.assertTrue(realm1.compact());
    },

    testRealmDeleteFileDefaultConfigPath: function() {
        const config = {schema: [schemas.TestObject]};
        const realm = new Realm(config);

        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
        });

        TestCase.assertEqual(realm.objects('TestObject').length, 1);
        realm.close();

        Realm.deleteFile(config);

        const realm2 = new Realm(config);
        TestCase.assertEqual(realm2.objects('TestObject').length, 0);
        realm.close();
    },

    testRealmDeleteFileCustomConfigPath: function() {
        const config = {schema: [schemas.TestObject], path: 'test-realm-delete-file.realm'};
        const realm = new Realm(config);

        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
        });

        TestCase.assertEqual(realm.objects('TestObject').length, 1);
        realm.close();

        Realm.deleteFile(config);

        const realm2 = new Realm(config);
        TestCase.assertEqual(realm2.objects('TestObject').length, 0);
        realm.close();
    },

    testRealmDeleteFileSyncConfig: function() {
        if (!global.enableSyncTests) {
            return;
        }

        return Realm.Sync.User
            .login('http://localhost:9080', Realm.Sync.Credentials.anonymous())
            .then(user => {
                const config = {
                    schema: [schemas.TestObject],
                    sync: {user, url: 'realm://localhost:9080/~/test', fullSynchronization: true },
                };

                const realm = new Realm(config);
                const path = realm.path;
                realm.close();

                return fs.exists(path)
                    .then(pathExistBeforeDelete => {
                        TestCase.assertTrue(pathExistBeforeDelete);
                        Realm.deleteFile(config);

                        return fs.exists(path)
                    })
                    .then(pathExistAfterDelete => {
                        TestCase.assertFalse(pathExistAfterDelete);
                    });
            });
    },

    testRealmDeleteRealmIfMigrationNeededVersionChanged: function() {
        const schema = [{
            name: 'TestObject',
            properties: {
                prop0: 'string',
                prop1: 'int',
            }
        }];

        var realm = new Realm({schema: schema});

        realm.write(function() {
            realm.create('TestObject', ['stringValue', 1]);
        });

        realm.close();


        realm = new Realm({schema: schema, deleteRealmIfMigrationNeeded: true, schemaVersion: 1, migration: undefined });

        // object should be gone as Realm should get deleted
        TestCase.assertEqual(realm.objects('TestObject').length, 0);

        // create a new object
        realm.write(function() {
            realm.create('TestObject', ['stringValue', 1]);
        });

        realm.close();

        var migrationWasCalled = false;
        realm = new Realm({schema: schema, deleteRealmIfMigrationNeeded: false, schemaVersion: 2, migration: function(oldRealm, newRealm) {
            migrationWasCalled = true;
        }});

        // migration function should get called as deleteRealmIfMigrationNeeded is false
        TestCase.assertEqual(migrationWasCalled, true);

        // object should be there because Realm shouldn't get deleted
        TestCase.assertEqual(realm.objects('TestObject').length, 1);
        realm.close();
    },

    testRealmDeleteRealmIfMigrationNeededSchemaChanged: function() {
        const schema = [{
            name: 'TestObject',
            properties: {
                prop0: 'string',
                prop1: 'int',
            }
        }];

        const schema1 = [{
            name: 'TestObject',
            properties: {
                prop0: 'string',
                prop1: 'int',
                prop2: 'float',
            }
        }];

        const schema2 = [{
            name: 'TestObject',
            properties: {
                prop0: 'string',
                prop1: 'int',
                prop2: 'float',
                prop3: 'double'
            }
        }];

        var realm = new Realm({schema: schema});

        realm.write(function() {
            realm.create('TestObject', {prop0: 'stringValue', prop1: 1});
        });

        realm.close();


        // change schema
        realm = new Realm({schema: schema1, deleteRealmIfMigrationNeeded: true, migration: undefined});

        // object should be gone as Realm should get deleted
        TestCase.assertEqual(realm.objects('TestObject').length, 0);

        // create a new object
        realm.write(function() {
            realm.create('TestObject', {prop0: 'stringValue', prop1: 1, prop2: 1.0});
        });

        realm.close();


        TestCase.assertThrows(function(e) {
            // updating schema without changing schemaVersion OR setting deleteRealmIfMigrationNeeded = true should raise an error
            new Realm({schema: schema2, deleteRealmIfMigrationNeeded: false, migration: function(oldRealm, newRealm) {}});
        });

        var migrationWasCalled = false;

        // change schema again, but increment schemaVersion
        realm = new Realm({schema: schema2, deleteRealmIfMigrationNeeded: false, schemaVersion: 1, migration: function(oldRealm, newRealm) {
            migrationWasCalled = true;
        }});

        // migration function should get called as deleteRealmIfMigrationNeeded is false
        TestCase.assertEqual(migrationWasCalled, true);

        // object should be there because Realm shouldn't get deleted
        TestCase.assertEqual(realm.objects('TestObject').length, 1);
        realm.close();
    },

    testRealmDeleteRealmIfMigrationNeededIncompatibleConfig: function() {
        const schema = [{
            name: 'TestObject',
            properties: {
                prop0: 'string',
                prop1: 'int',
            }
        }];

        TestCase.assertThrows(function() {
            new Realm({schema: schema, deleteRealmIfMigrationNeeded: true, readOnly: true});
        }, "Cannot set 'deleteRealmIfMigrationNeeded' when 'readOnly' is set.")

        TestCase.assertThrows(function() {
            new Realm({schema: schema, deleteRealmIfMigrationNeeded: true, migration: function(oldRealm, newRealm) {}});
        }, "Cannot include 'migration' when 'deleteRealmIfMigrationNeeded' is set.")
    },

    testDisableFileFormatUpgrade: function() {
        Realm.copyBundledRealmFiles();

        TestCase.assertThrowsContaining(() => {
            new Realm({ path: 'dates-v3.realm', disableFormatUpgrade: true } );
        }, 'The Realm file format must be allowed to be upgraded in order to proceed.');
    },


    // FIXME: We need to test adding a property also calls the listener
    testSchemaUpdatesNewClass: function() {
        return new Promise((resolve, reject) => {
            let called = false;
            let realm1 = new Realm({ _cache: false });
            TestCase.assertTrue(realm1.empty);
            TestCase.assertEqual(realm1.schema.length, 0);  // empty schema
            realm1.addListener('schema', (realm, event, schema) => {
                TestCase.assertEqual(event, 'schema');
                TestCase.assertEqual(schema.length, 1);
                TestCase.assertEqual(realm.schema.length, 1);
                TestCase.assertEqual(schema[0].name, 'TestObject');
                TestCase.assertEqual(realm1.schema.length, 1);
                TestCase.assertEqual(realm.schema[0].name, 'TestObject');
                called = true;
            });

            const schema = [{
                name: 'TestObject',
                properties: {
                    prop0: 'string',
                }
            }];

            let realm2 = new Realm({ schema: schema, _cache: false });
            TestCase.assertEqual(realm1.schema.length, 0); // not yet updated
            TestCase.assertEqual(realm2.schema.length, 1);

            // give some time to let advance_read to complete
            // in real world, a Realm will not be closed just after its
            // schema has been updated
            setTimeout(() => {
                if (called) {
                    resolve();
                } else {
                    reject();
                }
            }, 1000);
        });
    },

    testSchemaUpdatesPartialRealm: function() {
        if (!global.enableSyncTests) {
            return;
        }

        const realmId = uuid();
        // We need an admin user to create the reference Realm
        return Realm.Sync.User.login('http://localhost:9080', Realm.Sync.Credentials.nickname("admin", true))
            .then(user1 => {
                const config = {
                    schema: [schemas.TestObject],
                    sync: {
                        user: user1,
                        url: `realm://localhost:9080/${realmId}`,
                        fullSynchronization: false,
                    },
                };

                const realm = new Realm(config);
                TestCase.assertEqual(realm.schema.length, 7); // 5 permissions, 1 results set, 1 test object
                return closeAfterUpload(realm)
                    .then(() => {
                        return Realm.Sync.User.login('http://localhost:9080', Realm.Sync.Credentials.anonymous());
                    }).then((user2) => {
                        const dynamicConfig = {
                            sync: { user: user2, url: `realm://localhost:9080/${realmId}`, fullSynchronization: false },
                        };

                        return Realm.open(dynamicConfig);
                    }).then((realm2) => {
                        TestCase.assertEqual(realm2.schema.length, 7); // 5 permissions, 1 results set, 1 test object
                        let called = false;
                        realm2.addListener('schema', (realm, event, schema) => {
                            TestCase.assertEqual(realm2.schema.length, 8); // 5 permissions, 1 results set, 1 test object, 1 foo object
                            called = true;
                        });

                        config.schema.push({
                            name: 'Foo',
                            properties: {
                                doubleCol: 'double',
                            }
                        });

                        return Realm.open(config)
                            .then((realm) => {
                                return closeAfterUpload(realm);
                            })
                            .then(() => {
                                return new Promise((resolve, reject) => {
                                    setTimeout(() => {
                                        realm2.close();
                                        if (called) {
                                            resolve();
                                        } else {
                                            reject();
                                        }
                                    }, 1000);
                                });;
                            });
                    });
            });
    },

    testCreateTemplateObject: function() {
        var realm = new Realm({schema: [
            schemas.AllTypes,
            schemas.DefaultValues,
            schemas.TestObject,
            schemas.LinkToAllTypes
        ]});
        realm.beginTransaction();

        // Test all simple data types
        let template = Realm.createTemplateObject(schemas.AllTypes);
        TestCase.assertEqual(Object.keys(template).length, 7);
        let unmanagedObj = Object.assign(template, { boolCol: true });
        let managedObj = realm.create(schemas.AllTypes.name, unmanagedObj) ;
        TestCase.assertEqual(managedObj.boolCol, true);

        // Default values
        unmanagedObj = Realm.createTemplateObject(schemas.DefaultValues);
        TestCase.assertEqual(Object.keys(unmanagedObj).length, 10);
        managedObj = realm.create(schemas.DefaultValues.name, unmanagedObj);
        TestCase.assertEqual(managedObj.boolCol, true);
        TestCase.assertEqual(managedObj.intCol, -1);
        TestCase.assertEqualWithTolerance(managedObj.floatCol, -1.1, 0.000001);
        TestCase.assertEqualWithTolerance(managedObj.doubleCol, -1.11, 0.000001);
        TestCase.assertEqual(managedObj.stringCol, 'defaultString');
        TestCase.assertEqual(managedObj.dateCol.getTime(), 1);
        TestCase.assertEqual(managedObj.dataCol.byteLength, 1);
        TestCase.assertEqual(managedObj.objectCol.doubleCol, 1);
        TestCase.assertEqual(managedObj.nullObjectCol, null);
        TestCase.assertEqual(managedObj.arrayCol[0].doubleCol, 2);
    },


    testWriteCopyTo: function() {
        const realm = new Realm({schema: [schemas.IntPrimary, schemas.AllTypes, schemas.TestObject, schemas.LinkToAllTypes]});

        realm.write(() => {
            realm.create('TestObject', {doubleCol: 1});
        });
        TestCase.assertEqual(1, realm.objects('TestObject').length);

        TestCase.assertThrowsContaining(() => {
            realm.writeCopyTo();
        }, "At least path has to be provided for 'writeCopyTo'");

        TestCase.assertThrowsContaining(() => {
            realm.writeCopyTo(34);
        }, "Argument to 'writeCopyTo' must be a String.");

        // make sure that copies are in the same directory as the original file
        // that is important for running tests on mobile devices,
        // so we don't have issues with permissisons
        const copyName = realm.path + ".copy.realm";

        realm.writeCopyTo(copyName);

        const copyConfig = { path: copyName };
        const realmCopy = new Realm(copyConfig);
        TestCase.assertEqual(1, realmCopy.objects('TestObject').length);
        realmCopy.close();

        TestCase.assertThrowsContaining(() => {
            realm.writeCopyTo(realm.path + ".copy-invalid-key.realm", "hello");
        }, "Encryption key for 'writeCopyTo' must be a Binary.");

        const encryptedCopyName = realm.path + ".copy-encrypted.realm";

        var encryptionKey = new Int8Array(64);
        for(let i=0; i < 64; i++) {
            encryptionKey[i] = 1;
        }
        realm.writeCopyTo(encryptedCopyName, encryptionKey);

        const encryptedCopyConfig = { path: encryptedCopyName, encryptionKey: encryptionKey };
        const encryptedRealmCopy = new Realm(encryptedCopyConfig);
        TestCase.assertEqual(1, encryptedRealmCopy.objects('TestObject').length);
        encryptedRealmCopy.close();

        realm.close();
    },


    testQueryBasedOnlyMethods: function() {
        if (!global.enableSyncTests) {
            return;
        }

        const realm = new Realm({sync: true});
        TestCase.assertThrowsContaining(() =>  {
            realm.privileges();
        }, 'Wrong Realm type');
        TestCase.assertThrowsContaining(() =>  {
            realm.privileges('__Role');
        }, 'Wrong Realm type');
        TestCase.assertThrowsContaining(() =>  {
            realm.permissions();
        }, 'Wrong Realm type');
        TestCase.assertThrowsContaining(() =>  {
            realm.permissions('__Class');
        }, 'Wrong Realm type');
        TestCase.assertThrowsContaining(() =>  {
            realm.subscriptions();
        }, 'Wrong Realm type');
        TestCase.assertThrowsContaining(() =>  {
            realm.unsubscribe('foo');
        }, 'Wrong Realm type');
    } ,

};