public void CanOverrideConfigurationFilename()
{
// Arrange
var config = new RealmConfiguration();
var config2 = config.ConfigWithPath("fred.realm");
// Assert
Assert.That(config2.DatabasePath, Is.StringEnding("fred.realm"));
}
public void TriggerMigrationBySchemaVersion()
{
// Arrange
var config1 = new RealmConfiguration("ChangingVersion.realm");
Realm.DeleteRealm(config1); // ensure start clean
var realm1 = Realm.GetInstance(config1);
// new database doesn't push back a version number
Assert.That(config1.SchemaVersion, Is.EqualTo(0));
realm1.Dispose();
// Act
var config2 = config1.ConfigWithPath("ChangingVersion.realm");
config2.SchemaVersion = 99;
Realm realm2 = null; // should be updated by DoesNotThrow
// Assert
Assert.DoesNotThrow(() => realm2 = Realm.GetInstance(config2)); // same path, different version, should auto-migrate quietly
Assert.That(realm2.Config.SchemaVersion, Is.EqualTo(99));
realm2.Dispose();
}
private static bool MigrationCallback(IntPtr oldRealmPtr, IntPtr newRealmPtr, Native.Schema oldSchema, ulong schemaVersion, IntPtr managedMigrationHandle)
{
var migrationHandle = GCHandle.FromIntPtr(managedMigrationHandle);
var migration = (Migration)migrationHandle.Target;
var oldRealmHandle = new UnownedRealmHandle(oldRealmPtr);
var oldConfiguration = new RealmConfiguration(migration._configuration.DatabasePath)
{
SchemaVersion = schemaVersion, IsReadOnly = true
};
var oldRealm = new Realm(oldRealmHandle, oldConfiguration, RealmSchema.CreateFromObjectStoreSchema(oldSchema));
var newRealmHandle = new UnownedRealmHandle(newRealmPtr);
var newRealm = new Realm(newRealmHandle, migration._configuration, migration._schema);
var result = migration.Execute(oldRealm, newRealm);
migrationHandle.Free();
return(result);
}
internal static Realm GetInstance(RealmConfiguration config, RealmSchema schema)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (schema == null)
{
if (config.ObjectClasses != null)
{
schema = RealmSchema.CreateSchemaForClasses(config.ObjectClasses);
}
else
{
schema = RealmSchema.Default;
}
}
return(config.CreateRealm(schema));
}
public void TriggerMigrationBySchemaEditing()
{
// NOTE to regnerate the bundled database go edit the schema in Person.cs and comment/uncomment ExtraToTriggerMigration
// running in between and saving a copy with the added field
// this should never be needed as this test just needs the Realm to need migrating
TestHelpers.CopyBundledDatabaseToDocuments(
"ForMigrationsToCopyAndMigrate.realm", "NeedsMigrating.realm");
var triggersSchemaFieldValue = string.Empty;
var configuration = new RealmConfiguration("NeedsMigrating.realm");
configuration.SchemaVersion = 100;
configuration.MigrationCallback = (migration, oldSchemaVersion) =>
{
Assert.That(oldSchemaVersion, Is.EqualTo(99));
var oldPeople = migration.OldRealm.All("Person");
var newPeople = migration.NewRealm.All<Person>();
Assert.That(newPeople.Count(), Is.EqualTo(oldPeople.Count()));
for (var i = 0; i < newPeople.Count(); i++)
{
var oldPerson = oldPeople.ElementAt(i);
var newPerson = newPeople.ElementAt(i);
Assert.That(newPerson.LastName, Is.Not.EqualTo(oldPerson.TriggersSchema));
newPerson.LastName = triggersSchemaFieldValue = oldPerson.TriggersSchema;
}
};
using (var realm = Realm.GetInstance(configuration))
{
var person = realm.All<Person>().Single();
Assert.That(person.LastName, Is.EqualTo(triggersSchemaFieldValue));
}
}
public override void SetUp()
{
_configuration = new RealmConfiguration { ObjectClasses = new[] { typeof(DynamicOwner), typeof(DynamicDog) } };
if (_mode == DynamicTestObjectType.DynamicRealmObject)
{
_configuration.Dynamic = true;
}
base.SetUp();
using (var trans = _realm.BeginWrite())
{
var o1 = _realm.CreateObject("DynamicOwner");
o1.Name = "Tim";
var d1 = _realm.CreateObject("DynamicDog");
d1.Name = "Bilbo Fleabaggins";
d1.Color = "Black";
o1.TopDog = d1; // set a one-one relationship
o1.Dogs.Add(d1);
var d2 = _realm.CreateObject("DynamicDog");
d2.Name = "Earl Yippington III";
d2.Color = "White";
o1.Dogs.Add(d2);
// lonely people and dogs
var o2 = _realm.CreateObject("DynamicOwner");
o2.Name = "Dani"; // the dog-less
var d3 = _realm.CreateObject("DynamicDog"); // will remain unassigned
d3.Name = "Maggie Mongrel";
d3.Color = "Grey";
trans.Commit();
}
}
/// <summary>
/// Clone method allowing you to override or customise the current path.
/// </summary>
/// <returns>An object with a fully-specified, canonical path.</returns>
/// <param name="newConfigPath">Path to the realm, must be a valid full path for the current platform, relative subdir, or just filename.</param>
public RealmConfiguration ConfigWithPath(string newConfigPath)
{
RealmConfiguration ret = (RealmConfiguration)MemberwiseClone();
string candidatePath; // may need canonicalising
if (!string.IsNullOrEmpty(newConfigPath))
{
if (Path.IsPathRooted(newConfigPath))
{
candidatePath = newConfigPath;
}
else // append a relative path, maybe just a relative subdir needing filename
{
var usWithoutFile = Path.GetDirectoryName(DatabasePath);
if (newConfigPath[newConfigPath.Length - 1] == Path.DirectorySeparatorChar) // ends with separator
{
newConfigPath = Path.Combine(newConfigPath, DefaultRealmName); // add filename to relative subdir
}
candidatePath = Path.Combine(usWithoutFile, newConfigPath);
}
ret.DatabasePath = Path.GetFullPath(candidatePath); // canonical version, removing embedded ../ and other relative artifacts
}
return(ret);
}
public void AbleToReopenEncryptedWithSameKey()
{
ReliesOnEncryption();
// Arrange
var config = new RealmConfiguration("AbleToReopenEncryptedWithSameKey.realm");
Realm.DeleteRealm(config); // ensure guarded from prev tests
var answerKey = new byte[64];
answerKey[0] = 42;
config.EncryptionKey = answerKey;
var openedWithKey = Realm.GetInstance(config);
openedWithKey.Dispose();
var config2 = new RealmConfiguration("AbleToReopenEncryptedWithSameKey.realm");
var answerKey2 = new byte[64];
answerKey2[0] = 42;
config2.EncryptionKey = answerKey2;
// Assert
Assert.DoesNotThrow(() =>
{
using (Realm.GetInstance(config2))
{
}
});
}
public void ValidEncryptionKeyAccepted()
{
ReliesOnEncryption();
// Arrange
var config = new RealmConfiguration("ValidEncryptionKeyAcceoted.realm");
var goldilocksKey = new byte[64];
// Assert
Assert.DoesNotThrow(() => config.EncryptionKey = goldilocksKey);
Assert.DoesNotThrow(() => config.EncryptionKey = null);
}
private static bool MigrationCallback(IntPtr oldRealmPtr, IntPtr newRealmPtr, Native.Schema oldSchema, ulong schemaVersion, IntPtr managedMigrationHandle)
{
var migrationHandle = GCHandle.FromIntPtr(managedMigrationHandle);
var migration = (Migration)migrationHandle.Target;
// the realms here are owned by Object Store so we should do nothing to clean them up
var oldRealmHandle = new UnownedRealmHandle();
var newRealmHandle = new UnownedRealmHandle();
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
oldRealmHandle.SetHandle(oldRealmPtr);
newRealmHandle.SetHandle(newRealmPtr);
}
var oldConfiguration = new RealmConfiguration(migration._configuration.DatabasePath) { SchemaVersion = schemaVersion, IsReadOnly = true };
var oldRealm = new Realm(oldRealmHandle, oldConfiguration, RealmSchema.CreateFromObjectStoreSchema(oldSchema));
var newRealm = new Realm(newRealmHandle, migration._configuration, migration._schema);
var result = migration.Execute(oldRealm, newRealm);
migrationHandle.Free();
return result;
}
public void ReadOnlyRealmsWillNotAutoMigrate()
{
// Arrange
var config = new RealmConfiguration("WillBeReadonly.realm");
Realm.DeleteRealm(config); // ensure start clean
config.IsReadOnly = true;
config.SchemaVersion = 42;
TestHelpers.CopyBundledDatabaseToDocuments(
"ForMigrationsToCopyAndMigrate.realm", "WillBeReadonly.realm");
// Assert
Assert.Throws<RealmMigrationNeededException>(() =>
{
Realm.GetInstance(config);
});
}
public void TearDown()
{
Realm.DeleteRealm(RealmConfiguration.DefaultConfiguration);
var uniqueConfig = new RealmConfiguration(SpecialRealmName); // for when need 2 realms or want to not use default
Realm.DeleteRealm(uniqueConfig);
}
public static Realm GetInstance(RealmConfiguration config = null)
{
config = config ?? RealmConfiguration.DefaultConfiguration;
// TODO cache these initializers but note complications with ObjectClasses
var schemaInitializer = new SchemaInitializerHandle();
if (config.ObjectClasses == null)
{
foreach (var realmObjectClass in RealmObjectClasses)
{
var objectSchemaHandle = GenerateObjectSchema(realmObjectClass);
NativeSchema.initializer_add_object_schema(schemaInitializer, objectSchemaHandle);
}
}
else
{
foreach (var selectedRealmObjectClass in config.ObjectClasses)
{
if (selectedRealmObjectClass.BaseType != typeof(RealmObject))
{
throw new ArgumentException($"The class {selectedRealmObjectClass.FullName} must descend directly from RealmObject");
}
Debug.Assert(RealmObjectClasses.Contains(selectedRealmObjectClass)); // user-specified class must have been picked up by our static ctor
var objectSchemaHandle = GenerateObjectSchema(selectedRealmObjectClass);
NativeSchema.initializer_add_object_schema(schemaInitializer, objectSchemaHandle);
}
}
var schemaHandle = new SchemaHandle(schemaInitializer);
var srHandle = new SharedRealmHandle();
var readOnly = MarshalHelpers.BoolToIntPtr(config.ReadOnly);
var durability = MarshalHelpers.BoolToIntPtr(false);
var databasePath = config.DatabasePath;
IntPtr srPtr = IntPtr.Zero;
try {
srPtr = NativeSharedRealm.open(schemaHandle,
databasePath, (IntPtr)databasePath.Length,
readOnly, durability,
config.EncryptionKey,
config.SchemaVersion);
} catch (RealmMigrationNeededException) {
if (config.ShouldDeleteIfMigrationNeeded)
{
DeleteRealm(config);
}
else
{
throw; // rethrow te exception
//TODO when have Migration but also consider programmer control over auto migration
//MigrateRealm(configuration);
}
// create after deleting old reopen after migrating
srPtr = NativeSharedRealm.open(schemaHandle,
databasePath, (IntPtr)databasePath.Length,
readOnly, durability,
config.EncryptionKey,
config.SchemaVersion);
}
RuntimeHelpers.PrepareConstrainedRegions();
try { /* Retain handle in a constrained execution region */ }
finally
{
srHandle.SetHandle(srPtr);
}
return(new Realm(srHandle, config));
}
/// <summary>
/// Determines whether the specified RealmConfiguration is equal to the current RealmConfiguration.
/// </summary>
/// <param name="rhs">The <see cref="System.Object"/> to compare with the current RealmConfiguration.</param>
/// <returns><c>true</c> if the specified <see cref="System.Object"/> is equal to the current
/// <see cref="Realms.RealmConfiguration"/>; otherwise, <c>false</c>.</returns>
public bool Equals(RealmConfiguration rhs)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
return(false);
}
public void ReadOnlyFilesMustExist()
{
// Arrange
var config = new RealmConfiguration("FileNotThere.realm");
config.IsReadOnly = true;
// Assert
Assert.Throws<RealmFileNotFoundException>(() =>
{
Realm.GetInstance(config);
});
}
/// <summary>
/// Deletes all the files associated with a realm. Hides knowledge of the auxiliary filenames from the programmer.
/// </summary>
/// <param name="configuration">A configuration which supplies the realm path.</param>
public static void DeleteRealm(RealmConfiguration configuration)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
}
public void MigrationTriggersDelete()
{
// Arrange
var config = new RealmConfiguration("MigrateWWillRecreate.realm")
{
ShouldDeleteIfMigrationNeeded = true
};
Realm.DeleteRealm(config);
Assert.False(File.Exists(config.DatabasePath));
TestHelpers.CopyBundledDatabaseToDocuments(
"ForMigrationsToCopyAndMigrate.realm", "MigrateWWillRecreate.realm");
// Act - should cope by deleting and silently recreating
var realm = Realm.GetInstance(config);
// Assert
Assert.That(File.Exists(config.DatabasePath));
}
public void EncryptionKeyMustBe64Bytes()
{
ReliesOnEncryption();
// Arrange
var config = new RealmConfiguration("EncryptionKeyMustBe64Bytes.realm");
var smallKey = new byte[] { 1, 2, 3 };
var bigKey = new byte[656];
// Assert
Assert.Throws<FormatException>(() => config.EncryptionKey = smallKey);
Assert.Throws<FormatException>(() => config.EncryptionKey = bigKey);
}
public void CanSetDefaultConfiguration()
{
// Arrange
var config = new RealmConfiguration();
RealmConfiguration.DefaultConfiguration = config.ConfigWithPath("fred.realm");
// Assert
Assert.That(RealmConfiguration.DefaultConfiguration.DatabasePath, Is.StringEnding("fred.realm"));
}
/// <summary>
/// Factory for a Realm instance for this thread.
/// </summary>
/// <param name="config">Optional configuration.</param>
/// <returns>A realm instance.</returns>
/// <exception cref="RealmFileAccessErrorException">Throws error if the file system returns an error, preventing file creation.</exception>
public static Realm GetInstance(RealmConfiguration config = null)
{
return(GetInstance(config ?? RealmConfiguration.DefaultConfiguration, null));
}
public void RealmWithOneClassWritesDesiredClass()
{
// Arrange
var config = new RealmConfiguration("RealmWithOneClass.realm");
Realm.DeleteRealm(config);
config.ObjectClasses = new Type[] { typeof(LoneClass) };
// Act
using (var lonelyRealm = Realm.GetInstance(config))
{
lonelyRealm.Write(() =>
{
lonelyRealm.Add(new LoneClass
{
Name = "The Singular"
});
});
// Assert
Assert.That(lonelyRealm.All<LoneClass>().Count(), Is.EqualTo(1));
}
}
public void UnableToOpenWithDifferentKey()
{
ReliesOnEncryption();
// Arrange
var config = new RealmConfiguration("UnableToOpenWithDifferentKey.realm");
Realm.DeleteRealm(config); // ensure guarded from prev tests
var emptyKey = new byte[64];
config.EncryptionKey = emptyKey;
var openedWithKey = Realm.GetInstance(config);
openedWithKey.Dispose();
config.EncryptionKey[0] = 42;
// Assert
Assert.Throws<RealmFileAccessErrorException>(() =>
{
using (Realm.GetInstance(config))
{
}
});
}
public void RealmObjectClassesOnlyAllowRealmObjects()
{
// Arrange
var config = new RealmConfiguration("RealmWithOneClass.realm");
Realm.DeleteRealm(config);
config.ObjectClasses = new Type[] { typeof(LoneClass), typeof(object) };
// Act and assert
// Can't have classes in the list which are not RealmObjects
Assert.That(() => Realm.GetInstance(config), Throws.TypeOf<ArgumentException>());
}
/// <summary>
/// Factory for a Realm instance for this thread.
/// </summary>
/// <param name="config">Optional configuration.</param>
/// <returns>A realm instance.</returns>
/// <exception cref="RealmFileAccessErrorException">Throws error if the filesystem has an error preventing file creation.</exception>
public static Realm GetInstance(RealmConfiguration config = null)
{
return(GetInstance(config, null));
}
public void ReadOnlyRealmsArentWritable()
{
// Arrange
var config = new RealmConfiguration("WillBeReadonly.realm");
Realm.DeleteRealm(config); // ensure start clean
config.SchemaVersion = 0; // must set version before file can be opened readOnly
using (var openToCreate = Realm.GetInstance(config))
{
openToCreate.Write(() =>
{
openToCreate.Add(new Person());
});
}
config.IsReadOnly = true;
using (var openedReadonly = Realm.GetInstance(config))
{
// Assert
Assert.Throws<RealmInvalidTransactionException>(() =>
{
openedReadonly.Write(() =>
{
openedReadonly.Add(new Person());
});
});
}
}
/// <summary>
/// Factory for a Realm instance for this thread.
/// </summary>
/// <param name="config">Optional configuration.</param>
/// <returns>A realm instance.</returns>
/// <exception cref="RealmFileAccessErrorException">Throws error if the file system returns an error, preventing file creation.</exception>
//// [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static Realm GetInstance(RealmConfiguration config = null)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
return(null);
} // GetInstance
public void ExceptionInMigrationCallback()
{
TestHelpers.CopyBundledDatabaseToDocuments(
"ForMigrationsToCopyAndMigrate.realm", "NeedsMigrating.realm");
var dummyException = new Exception();
var configuration = new RealmConfiguration("NeedsMigrating.realm") { SchemaVersion = 100 };
configuration.MigrationCallback = (migration, oldSchemaVersion) =>
{
throw dummyException;
};
var ex = Assert.Throws<AggregateException>(() => Realm.GetInstance(configuration).Dispose());
Assert.That(ex.Flatten().InnerException, Is.SameAs(dummyException));
}
public void DeleteRealmFailsIfOpenSameThread()
{
// Arrange
var config = new RealmConfiguration();
var openRealm = Realm.GetInstance(config);
// Assert
Assert.Throws<RealmPermissionDeniedException>(() => Realm.DeleteRealm(config));
}
public void AddAnObjectFromAnotherRealmShouldFail()
{
Person p = null;
_realm.Write(() => p = _realm.Add(new Person()));
var secondaryConfig = new RealmConfiguration("AddAnObjectFromAnotherRealmShouldFail");
Realm.DeleteRealm(secondaryConfig);
using (var otherRealm = Realm.GetInstance(secondaryConfig))
{
Assert.That(() => otherRealm.Add(p), Throws.TypeOf<RealmObjectManagedByAnotherRealmException>());
}
}
public void RealmWithOneClassThrowsIfUseOther()
{
// Arrange
var config = new RealmConfiguration("RealmWithOneClass.realm");
Realm.DeleteRealm(config);
config.ObjectClasses = new Type[] { typeof(LoneClass) };
// Act and assert
using (var lonelyRealm = Realm.GetInstance(config))
{
// Can't create an object with a class not included in this Realm
lonelyRealm.Write(() =>
{
Assert.That(() => lonelyRealm.Add(new Person()), Throws.TypeOf<ArgumentException>());
});
}
}
public void IndexedDateTimeOffsetTest()
{
// Arrange
var config = new RealmConfiguration
{
ObjectClasses = new[] { typeof(IndexedDateTimeOffsetObject) }
};
// Act and "assert" that no exception is thrown here
using (Realm.GetInstance(config))
{
}
}
public void Compact_ShouldReduceSize(bool encrypt, bool populate)
{
var config = new RealmConfiguration($"compactrealm_{encrypt}_{populate}.realm");
if (encrypt)
{
config.EncryptionKey = new byte[64];
config.EncryptionKey[0] = 5;
}
Realm.DeleteRealm(config);
using (var realm = Realm.GetInstance(config))
{
if (populate)
{
AddDummyData(realm);
}
}
var initialSize = new FileInfo(config.DatabasePath).Length;
Assert.That(Realm.Compact(config));
var finalSize = new FileInfo(config.DatabasePath).Length;
Assert.That(initialSize >= finalSize);
using (var realm = Realm.GetInstance(config))
{
Assert.That(realm.All<IntPrimaryKeyWithValueObject>().Count(), Is.EqualTo(populate ? 500 : 0));
}
}
internal Migration(RealmConfiguration configuration, RealmSchema schema)
{
Configuration = configuration;
Schema = schema;
_handle = GCHandle.Alloc(this);
}
internal Migration(RealmConfiguration configuration, RealmSchema schema)
{
Configuration = configuration;
Schema = schema;
}
internal Migration(RealmConfiguration configuration, RealmSchema schema)
{
_configuration = configuration;
_schema = schema;
}