/// <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)); }