testResultsInvalidation: function() {
var realm = new Realm({schema: [schemas.TestObject]});
realm.write(function() {
for (var i = 10; i > 0; i--) {
realm.create('TestObject', [i]);
}
});
var resultsVariants = [
realm.objects('TestObject'),
realm.objects('TestObject').filtered('doubleCol > 1'),
realm.objects('TestObject').filtered('doubleCol > 1').sorted('doubleCol'),
realm.objects('TestObject').filtered('doubleCol > 1').snapshot()
];
// test isValid
resultsVariants.forEach(function(objects) {
TestCase.assertEqual(objects.isValid(), true);
});
// close and test invalidated accessors
realm.close();
realm = new Realm({
schemaVersion: 1,
schema: [schemas.TestObject, schemas.BasicTypes]
});
resultsVariants.forEach(function(objects) {
TestCase.assertEqual(objects.isValid(), false);
TestCase.assertThrows(function() { objects[0]; });
TestCase.assertThrows(function() { objects.filtered('doubleCol < 42'); });
TestCase.assertThrows(function() { objects.sorted('doubleCol', true); });
TestCase.assertThrows(function() { objects.snapshot(); });
});
},
testRealmConstructorSchemaVersion: function() {
var defaultRealm = new Realm({schema: []});
TestCase.assertEqual(defaultRealm.schemaVersion, 0);
TestCase.assertThrows(function() {
new Realm({schemaVersion: 1});
}, "Realm already opened at a different schema version");
TestCase.assertEqual(new Realm().schemaVersion, 0);
TestCase.assertEqual(new Realm({schemaVersion: 0}).schemaVersion, 0);
var realm = new Realm({path: 'test1.realm', schema: [], schemaVersion: 1});
TestCase.assertEqual(realm.schemaVersion, 1);
// FIXME - enable once Realm exposes a schema object
//TestCase.assertEqual(realm.schema.length, 0);
realm.close();
// FIXME - enable once realm initialization supports schema comparison
// TestCase.assertThrows(function() {
// realm = new Realm({path: testPath, schema: [schemas.TestObject], schemaVersion: 1});
// }, "schema changes require updating the schema version");
realm = new Realm({path: 'test1.realm', schema: [schemas.TestObject], schemaVersion: 2});
realm.write(function() {
realm.create('TestObject', {doubleCol: 1});
});
TestCase.assertEqual(realm.objects('TestObject')[0].doubleCol, 1)
},
Realm.Sync.User.login('http://localhost:9080', username, 'password', (error, user) => {
failOnError(error);
assertIsUser(user);
// Can we open a realm with the logged-in user?
var realm = new Realm({ sync: { user: user, url: 'realm://localhost:9080/~/test' } });
TestCase.assertInstanceOf(realm, Realm);
realm.close();
});
testMigrationFunction: function() {
var count = 0;
function migrationFunction(oldRealm, newRealm) {
TestCase.assertEqual(oldRealm.schemaVersion, 0);
TestCase.assertEqual(newRealm.schemaVersion, 1);
count++;
}
// no migration should be run
var realm = new Realm({schema: [], migration: migrationFunction});
TestCase.assertEqual(0, count);
realm.close();
// migration should be run
realm = new Realm({schema: [Schemas.TestObject], migration: migrationFunction, schemaVersion: 1});
TestCase.assertEqual(1, count);
realm.close();
// invalid migration function
TestCase.assertThrows(function() {
new Realm({schema: [], schemaVersion: 2, migration: 'invalid'});
});
// migration function exceptions should propogate
var exception = new Error('expected exception');
realm = undefined;
TestCase.assertThrowsException(function() {
realm = new Realm({schema: [], schemaVersion: 3, migration: function() {
throw exception;
}});
}, exception);
TestCase.assertEqual(realm, undefined);
TestCase.assertEqual(Realm.schemaVersion(Realm.defaultPath), 1);
// migration function shouldn't run if nothing changes
realm = new Realm({schema: [Schemas.TestObject], migration: migrationFunction, schemaVersion: 1});
TestCase.assertEqual(1, count);
realm.close();
// migration function should run if only schemaVersion changes
realm = new Realm({schema: [Schemas.TestObject], migration: function() { count++; }, schemaVersion: 2});
TestCase.assertEqual(2, count);
realm.close();
},
testDataMigration: function() {
var realm = new Realm({schema: [{
name: 'TestObject',
properties: {
prop0: 'string',
prop1: 'int',
}
}]});
realm.write(function() {
realm.create('TestObject', ['stringValue', 1]);
});
realm.close();
realm = new Realm({
schema: [{
name: 'TestObject',
properties: {
renamed: 'string',
prop1: 'int',
}
}],
schemaVersion: 1,
migration: function(oldRealm, newRealm) {
var oldObjects = oldRealm.objects('TestObject');
var newObjects = newRealm.objects('TestObject');
TestCase.assertEqual(oldObjects.length, 1);
TestCase.assertEqual(newObjects.length, 1);
TestCase.assertEqual(oldObjects[0].prop0, 'stringValue');
TestCase.assertEqual(oldObjects[0].prop1, 1);
TestCase.assertEqual(oldObjects[0].renamed, undefined);
TestCase.assertEqual(newObjects[0].prop0, undefined);
TestCase.assertEqual(newObjects[0].renamed, '');
TestCase.assertEqual(newObjects[0].prop1, 1);
newObjects[0].renamed = oldObjects[0].prop0;
TestCase.assertThrows(function() {
oldObjects[0].prop0 = 'throws';
});
}
});
var objects = realm.objects('TestObject');
TestCase.assertEqual(objects.length, 1);
TestCase.assertEqual(objects[0].renamed, 'stringValue');
TestCase.assertEqual(objects[0].prop1, 1);
TestCase.assertEqual(objects[0].prop0, undefined);
},
testMigrationSchema: function() {
var realm = new Realm({schema: [{
name: 'TestObject',
properties: {
prop0: 'string',
prop1: 'int',
}
}]});
realm.close();
realm = new Realm({
schema: [{
name: 'TestObject',
properties: {
renamed: 'string',
prop1: 'int',
}
}],
schemaVersion: 1,
migration: function(oldRealm, newRealm) {
var oldSchema = oldRealm.schema;
var newSchema = newRealm.schema;
TestCase.assertEqual(oldSchema.length, 1);
TestCase.assertEqual(newSchema.length, 1);
TestCase.assertEqual(oldSchema[0].name, 'TestObject');
TestCase.assertEqual(newSchema[0].name, 'TestObject');
TestCase.assertEqual(oldSchema[0].properties.prop0.type, 'string');
TestCase.assertEqual(newSchema[0].properties.prop0, undefined);
TestCase.assertEqual(oldSchema[0].properties.prop1.type, 'int');
TestCase.assertEqual(newSchema[0].properties.prop1.type, 'int');
TestCase.assertEqual(oldSchema[0].properties.renamed, undefined);
TestCase.assertEqual(newSchema[0].properties.renamed.type, 'string');
}
});
},
testEncryptionValidKey: function() {
var key = new Int8Array(64);
key[0] = 1;
var realm = new Realm({schema: [Schemas.TestObject], encryptionKey: key});
realm.write(function() {
realm.create('TestObject', {doubleCol: 1});
TestCase.assertEqual(realm.objects('TestObject').length, 1);
});
// test failure with different or missing
realm.close();
TestCase.assertThrows(function() {
new Realm({schema: [Schemas.TestObject], encryptionKey: new Int8Array(64)});
});
TestCase.assertThrows(function() {
new Realm({schema: [Schemas.TestObject]});
});
// test can reopen with original key
var realm = new Realm({schema: [Schemas.TestObject], encryptionKey: key});
TestCase.assertEqual(realm.objects('TestObject').length, 1);
},
import Realm from 'realm';
import schemas from './migrations';
let nextSchemaIndex = Realm.schemaVersion(Realm.defaultPath);
while (nextSchemaIndex < schemas.length) {
const migratedRealm = new Realm({ ...schemas[nextSchemaIndex++] });
migratedRealm.close();
}
export default new Realm(schemas[schemas.length - 1]);