/// <summary>
/// Initializes a new instance of the <see cref="T:SushiHangover.RealmThread"/> class.
/// </summary>
/// <param name="realmConfig">RealmConfigurationBase</param>
/// <param name="autoCommmit">If set to <c>true</c> auto commmit open transaction on Dispose</param>
public RealmThread(RealmConfigurationBase realmConfig, bool autoCommmit)
{
autoCommmitOnDispose = autoCommmit;
workQueue = new BlockingCollection <RealmWork>();
realmThread = new InternalThread(workQueue);
realmThread.Start(realmConfig);
}
protected Realm GetRealm(RealmConfigurationBase config = null)
{
var result = Realm.GetInstance(config ?? RealmConfiguration.DefaultConfiguration);
CleanupOnTearDown(result);
return(result);
}
public void Bar()
{
var path = RealmConfigurationBase.GetPathToRealm();
var realm = Realm.GetInstance();
// Use LINQ to query
var puppies = realm.All <Dog>().Where(d => d.Age < 2);
puppies.Count(); // => 0 because no dogs have been added yet
// Update and persist objects with a thread-safe transaction
realm.Write(() =>
{
realm.Add(new Dog {
Name = "Rex", Age = 1
});
});
// Queries are updated in realtime
puppies.Count(); // => 1
// LINQ query syntax works as well
var oldDogs = from d in realm.All <Dog>() where d.Age > 8 select d;
// Query and update from any thread
new Thread(() =>
{
var realm2 = Realm.GetInstance();
var theDog = realm2.All <Dog>().Where(d => d.Age == 1).First();
realm2.Write(() => theDog.Age = 3);
}).Start();
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Forms.Init(this, savedInstanceState);
var nunit = new App();
var options = new TestOptions
{
LogToOutput = true,
};
if (Intent.GetBooleanExtra("headless", false))
{
TestHelpers.CopyBundledDatabaseToDocuments("nunit3-junit.xslt", "nunit3-junit.xslt");
var transformPath = RealmConfigurationBase.GetPathToRealm("nunit3-junit.xslt");
options.XmlTransformFile = transformPath;
options.AutoRun = true;
options.CreateXmlResultFile = true;
options.OnCompletedCallback = () =>
{
Console.WriteLine("Activity finished...");
OnFinished(Result.Ok);
Finish();
};
options.ResultFilePath = Intent.GetStringExtra("resultPath");
}
nunit.Options = options;
LoadApplication(nunit);
}
public static string CopyBundledDatabaseToDocuments(string realmName, string destPath = null, bool overwrite = true)
{
destPath = RealmConfigurationBase.GetPathToRealm(destPath); // any relative subdir or filename works
#if __ANDROID__
using (var asset = Application.Context.Assets.Open(realmName))
using (var destination = File.OpenWrite(destPath))
{
asset.CopyTo(destination);
}
#else
#if __IOS__
var sourceDir = Foundation.NSBundle.MainBundle.BundlePath;
#elif WINDOWS_UWP
var sourceDir = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
#elif __MACOS__
var sourceDir = Foundation.NSBundle.MainBundle.ResourcePath;
#else
var sourceDir = NUnit.Framework.TestContext.CurrentContext.TestDirectory;
#endif
File.Copy(Path.Combine(sourceDir, realmName), destPath, overwrite);
#endif
return(destPath);
}
protected async Task <Realm> GetRealmAsync(RealmConfigurationBase config, CancellationToken cancellationToken = default)
{
var result = await Realm.GetInstanceAsync(config, cancellationToken);
CleanupOnTearDown(result);
return(result);
}
protected Realm GetRealm(RealmConfigurationBase config)
{
var result = Realm.GetInstance(config);
CleanupOnTearDown(result);
return(result);
}
protected async Task <Realm> GetRealmAsync(RealmConfigurationBase config)
{
var result = await Realm.GetInstanceAsync(config);
CleanupOnTearDown(result);
return(result);
}
private static string GetPath(RealmConfigurationBase config)
{
var realmFolder = Path.GetDirectoryName(config.DatabasePath);
var folderPath = Path.Combine(realmFolder, ".lfs");
Directory.CreateDirectory(folderPath);
return(folderPath);
}
public static void TransformTestResults(string resultPath)
{
CopyBundledFileToDocuments("nunit3-junit.xslt", "nunit3-junit.xslt");
var transformFile = RealmConfigurationBase.GetPathToRealm("nunit3-junit.xslt");
var xpathDocument = new XPathDocument(resultPath);
var transform = new XslCompiledTransform();
transform.Load(transformFile);
using var writer = new XmlTextWriter(resultPath, null);
transform.Transform(xpathDocument, null, writer);
}
public RealmDatabase(string databaseName, bool persist = true)
{
string folder = Path.Combine(Directory.GetCurrentDirectory(), "Databases");
string path = Path.Combine(folder, databaseName);
Directory.CreateDirectory(folder);
_configuration = persist ? new RealmConfiguration(path) : new InMemoryConfiguration(databaseName);
if (!isCompactado && persist)
{
isCompactado = Realm.Compact(_configuration);
}
}
public static void Delete(RealmConfigurationBase config = null)
{
if (config != null)
{
Realms.Realm.DeleteRealm(config);
}
else
{
var realmInstance = Realms.Realm.GetInstance();
Realms.Realm.DeleteRealm(realmInstance.Config);
}
}
public override void Initialize()
{
CreatableTypes()
.EndingWith("Service")
.AsInterfaces()
.RegisterAsLazySingleton();
Mvx.IoCProvider.RegisterType <INewsRepositoryService, NewsRepository>();
Mvx.IoCProvider.RegisterType <IStorageService, Storage>();
Mvx.IoCProvider.RegisterType <IRestClient, RestClient>();
RealmConfigurationBase config = RealmConfiguration.DefaultConfiguration;
config.SchemaVersion = 1;
RegisterAppStart <MainViewModel>();
}
private static RemoteFileManager GetManager(RealmConfigurationBase config)
{
return(_remoteManagers.GetOrAdd(config.DatabasePath, (key) =>
{
var result = _remoteManagerFactory();
result.Start(config);
result.OnFileUploaded += (s, e) =>
{
OnFileUploaded?.Invoke(s, e);
};
// TODO: trigger cleanup event with a list of files that can be deleted.
return result;
}));
}
protected async Task <Realm> GetRealmAsync(RealmConfigurationBase config, bool openAsync = true, CancellationToken cancellationToken = default(CancellationToken))
{
Realm result;
if (openAsync)
{
result = await Realm.GetInstanceAsync(config, cancellationToken);
}
else
{
result = Realm.GetInstance(config);
await SyncTestHelpers.WaitForDownloadAsync(result);
}
CleanupOnTearDown(result);
return(result);
}
public static Realms.Realm GetInstance(RealmConfigurationBase config)
{
var context = SynchronizationContext.Current;
SynchronizationContext.SetSynchronizationContext(null);
Realms.Realm realm = null;
try
{
realm = Realms.Realm.GetInstance(config);
}
finally
{
SynchronizationContext.SetSynchronizationContext(context);
}
return(realm);
}
internal void Start(RealmConfigurationBase config)
{
_config = config;
string realmPath;
if (_config is SyncConfigurationBase syncConfig)
{
realmPath = syncConfig.ServerUri.PathAndQuery.Replace("~", syncConfig.User.Identity);
}
else
{
realmPath = Path.GetFileNameWithoutExtension(_config.DatabasePath);
}
_realmPathHash = HashHelper.MD5(realmPath);
_runner = new BackgroundRunner(_config);
EnqueueExisting();
}
public static string CopyBundledFileToDocuments(string realmName, string destPath = null)
{
destPath = RealmConfigurationBase.GetPathToRealm(destPath); // any relative subdir or filename works
var assembly = typeof(TestHelpers).Assembly;
var resourceName = assembly.GetManifestResourceNames().SingleOrDefault(s => s.EndsWith(realmName));
if (resourceName == null)
{
throw new Exception($"Couldn't find embedded resource '{realmName}' in the RealmTests assembly");
}
using var stream = assembly.GetManifestResourceStream(resourceName);
using var destination = new FileStream(destPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
stream.CopyTo(destination);
return(destPath);
}
public static void CopyBundledDatabaseToDocuments(string realmName, string destPath = null, bool overwrite = true)
{
destPath = RealmConfigurationBase.GetPathToRealm(destPath); // any relative subdir or filename works
#if __ANDROID__
using (var asset = Android.App.Application.Context.Assets.Open(realmName))
using (var destination = File.OpenWrite(destPath))
{
asset.CopyTo(destination);
}
return;
#endif
#if __IOS__
var sourceDir = Foundation.NSBundle.MainBundle.BundlePath;
#else
var sourceDir = NUnit.Framework.TestContext.CurrentContext.TestDirectory;
#endif
File.Copy(Path.Combine(sourceDir, realmName), destPath, overwrite);
}
public void Migrate()
{
var uri = RealmConfigurationBase.GetPathToRealm(DATABASE_PATH);
bool databaseExist = File.Exists(uri);
var configuration = new RealmConfiguration(DATABASE_PATH)
{
SchemaVersion = DATABASE_SCHEMA_VERSION,
MigrationCallback = (migration, oldSchemaVersion) => OnMigration(migration, oldSchemaVersion, migration.NewRealm.Config.SchemaVersion)
};
Realm database = Realm.GetInstance(configuration);
if (!databaseExist)
{
var transaction = database.BeginWrite();
this.OnDataBaseCreated(database);
transaction.Commit();
}
database.Dispose();
}
public static Task WaitForUploads(RealmConfigurationBase config)
{
return(GetManager(config).WaitForUploads());
}
internal static string GetFilePath(RealmConfigurationBase config, string id)
{
return(Path.Combine(GetPath(config), id));
}
public ComicDatabase(RealmConfigurationBase realmConfig)
{
RealmConfiguration = realmConfig;
Open();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SushiHangover.RealmThread"/> class.
/// </summary>
/// <param name="realmConfig">RealmConfigurationBase</param>
public RealmThread(RealmConfigurationBase realmConfig) : this(realmConfig, false)
{
}
protected RealmServiceBase(RealmConfigurationBase config = null)
{
RealmInstance = Realms.Realm.GetInstance(config);
InitializeInternal();
}
/// <summary>
/// Factory for obtaining a <see cref="T:Realms.Realm" /> instance for this thread.
/// </summary>
/// <param name="realmConfiguration">The realm configuration.</param>
/// <returns>
/// A <see cref="T:Realms.Realm" /> instance.
/// </returns>
/// <exception cref="T:Realms.Exceptions.RealmFileAccessErrorException">Thrown if the file system returns an error preventing file creation.</exception>
public static KeyValueRealm GetInstance(RealmConfigurationBase realmConfiguration)
{
return(new KeyValueRealm(realmConfiguration));
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyValueRealm"/> class.
/// </summary>
/// <param name="realmConfiguration">The realm configuration.</param>
public KeyValueRealm(RealmConfigurationBase realmConfiguration)
{
_realm = Realm.GetInstance(realmConfiguration);
}
public static Task <Realms.Realm> GetInstanceAsync(RealmConfigurationBase config) => Realms.Realm.GetInstanceAsync(config);
public static Realms.Realm GetInstance(RealmConfigurationBase config) => Realms.Realm.GetInstance(config);
public static bool Compact(RealmConfigurationBase config = null)
{
return(Realms.Realm.Compact(config));
}
