public void AddEntityAndRetrieveFromDisk()
        {
            // Create test entity and write it to the mock filesystem
            IJsonEntity <EntityTest> entity;
            IJsonEntity <EntityTest> entityFromRepo;

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entity          = testRepository.Create();
                entity.Contents = new EntityTest {
                    Name = "foo", Number = 1
                };
                testRepository.Add(entity);
                testRepository.Save();
            }

            // Now re-create the repo, which should read the persisted value for the new entity from "disk"
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
            }

            Assert.IsNotNull(entityFromRepo);
            Assert.AreEqual(entity.Id, entityFromRepo.Id);
            Assert.AreEqual(entity.Contents.Name, entityFromRepo.Contents.Name);
            Assert.AreEqual(entity.Contents.Number, entityFromRepo.Contents.Number);
        }
        public void AddEntityThenDeleteFromDisk()
        {
            // Create test entity
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                entity.Contents = new EntityTest {
                    Name = "foo", Number = 1
                };
                testRepository.Add(entity);
                testRepository.Save();
            }

            // Read the new entity from disk, then delete it and save
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNotNull(entityFromRepo);
                testRepository.Delete(entityFromRepo);
                testRepository.Save();
            }

            // After re-initializing the repo, the deleted item should be gone, but everything else should still be present
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNull(entityFromRepo);
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
 public void CreateNewResource()
 {
     var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
     var entity = testRepository.Create();
     Assert.IsNotNull(entity);
     Assert.IsNull(entity.JsonData);
     Assert.AreEqual(MockDataPath, testRepository.Path);
 }
        /// <summary>
        /// Creates a concrete Config Provider instance
        /// </summary>
        /// <param name="componentName">The name of the component that this Provider will manage</param>
        /// <param name="validationHandlers">A collection of functions that will validate config data for use with the specified Component</param>
        /// <returns>A new instance of the Config Provider</returns>
        public IConfigProvider Create(string componentName, Dictionary<string, Func<string, bool>> validationHandlers)
        {
            string repositoryDataDirectory = Path.Combine(_fileSystem.GetTempDirectoryPath(), _applicationAssemblyName);

            var configServiceProvider = new ConfigServiceProvider(componentName, _configServiceHttpClient);
            var cacheProvider = new DurableMemoryRepository<ConfigRoot>(repositoryDataDirectory, _fileSystem);
            var configProvider = new ConfigProvider(componentName, validationHandlers, configServiceProvider, cacheProvider);
            return configProvider;
        }
        public void CreateNewResource()
        {
            var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
            var entity         = testRepository.Create();

            Assert.IsNotNull(entity);
            Assert.IsNull(entity.JsonData);
            Assert.AreEqual(MockDataPath, testRepository.Path);
        }
        /// <summary>
        /// Creates a concrete Config Provider instance
        /// </summary>
        /// <param name="componentName">The name of the component that this Provider will manage</param>
        /// <param name="validationHandlers">A collection of functions that will validate config data for use with the specified Component</param>
        /// <returns>A new instance of the Config Provider</returns>
        public IConfigProvider Create(string componentName, Dictionary <string, Func <string, bool> > validationHandlers)
        {
            string repositoryDataDirectory = Path.Combine(_fileSystem.GetTempDirectoryPath(), _applicationAssemblyName);

            var configServiceProvider = new ConfigServiceProvider(componentName, _configServiceHttpClient);
            var cacheProvider         = new DurableMemoryRepository <ConfigRoot>(repositoryDataDirectory, _fileSystem);
            var configProvider        = new ConfigProvider(componentName, validationHandlers, configServiceProvider, cacheProvider);

            return(configProvider);
        }
        public void RespositoryCreationWithExtraneousFilesInStorageLocation()
        {
            // Instead of using the default mock files, create a bunch of mock files to simulate a case where the data storage location has other things in it
            _mockProvider.Reset();
            CreateMockDataFilesWithExtraStuff();

            var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
            var entity = testRepository.Create();
            Assert.IsNotNull(entity);
            Assert.AreEqual(5, entity.Id);
            Assert.AreEqual(MockDataPath, testRepository.Path);
        }
        public void CallSaveWithNoPendingChanges()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                testRepository.Save();
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void RespositoryCreationWithExtraneousFilesInStorageLocation()
        {
            // Instead of using the default mock files, create a bunch of mock files to simulate a case where the data storage location has other things in it
            _mockProvider.Reset();
            CreateMockDataFilesWithExtraStuff();

            var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
            var entity         = testRepository.Create();

            Assert.IsNotNull(entity);
            Assert.AreEqual(5, entity.Id);
            Assert.AreEqual(MockDataPath, testRepository.Path);
        }
        public void CreateTwoNewResourcesWithUniqueIDs()
        {
            var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
            var firstEntity = testRepository.Create();
            Assert.IsNotNull(firstEntity);
            Assert.AreEqual(5, firstEntity.Id);

            var secondEntity = testRepository.Create();
            Assert.IsNotNull(secondEntity);
            Assert.AreEqual(6, secondEntity.Id);

            Assert.AreEqual(MockDataPath, testRepository.Path);
        }
        public void DeleteItemThatDoesNotExist()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                testRepository.Delete(entity);
                testRepository.Save();
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void CreateTwoNewResourcesWithUniqueIDs()
        {
            var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
            var firstEntity    = testRepository.Create();

            Assert.IsNotNull(firstEntity);
            Assert.AreEqual(5, firstEntity.Id);

            var secondEntity = testRepository.Create();

            Assert.IsNotNull(secondEntity);
            Assert.AreEqual(6, secondEntity.Id);

            Assert.AreEqual(MockDataPath, testRepository.Path);
        }
        public void AddSameItemMoreThanOnce()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                testRepository.Add(entity);
                testRepository.Add(entity);
                testRepository.Save();
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4, 5 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4, 5 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void AddEntityThenDeleteFromMemory()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                IJsonEntity <EntityTest> entity = testRepository.Create();
                entity.Contents = new EntityTest {
                    Name = "foo", Number = 1
                };
                testRepository.Add(entity);

                IJsonEntity <EntityTest> entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNotNull(entityFromRepo);

                testRepository.Delete(entity);

                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNull(entityFromRepo);
            }
        }
        public void AddEntityAndRetrieveFromMemory()
        {
            IJsonEntity <EntityTest> entity;
            IJsonEntity <EntityTest> entityFromRepo;

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entity          = testRepository.Create();
                entity.Contents = new EntityTest {
                    Name = "foo", Number = 1
                };
                testRepository.Add(entity);
                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
            }

            Assert.IsNotNull(entityFromRepo);
            Assert.AreEqual(entity.Id, entityFromRepo.Id);
            Assert.AreEqual(entity.Contents.Name, entityFromRepo.Contents.Name);
            Assert.AreEqual(entity.Contents.Number, entityFromRepo.Contents.Number);
        }
        public void DataReadFromRepoIsDisconnectedFromSession()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var collection1 = testRepository.Entities.Where(x => new[] { 1, 2 }.Contains(x.Id)).ToArray();
                testRepository.Delete(collection1[0]);
                testRepository.Delete(collection1[1]);
                var collection2 = testRepository.Entities.Where(x => new[] { 1, 2 }.Contains(x.Id)).ToArray();
                CollectionAssert.AreEquivalent(new[] { 1, 2 }, collection1.Select(x => x.Id).ToArray());
                CollectionAssert.AreEquivalent(new int[] {}, collection2.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var collection1 = testRepository.Entities.ToArray();
                var entity1     = testRepository.Create();
                var entity2     = testRepository.Create();
                testRepository.Add(entity1);
                testRepository.Add(entity2);
                var collection2 = testRepository.Entities.ToArray();

                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, collection1.Select(x => x.Id).ToArray());
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4, 5, 6 }, collection2.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var    collection1    = testRepository.Entities.ToArray();
                var    entity         = collection1[0];
                string originalName   = entity.Contents.Name;
                int    originalNumber = entity.Contents.Number;
                entity.Contents.Name   = "foo";
                entity.Contents.Number = -1;
                testRepository.Update(entity);
                var collection2 = testRepository.Entities.ToArray();

                Assert.AreNotEqual(originalName, collection2[0].Contents.Name);
                Assert.AreNotEqual(originalNumber, collection2[0].Contents.Number);
            }
        }
        public void UpdateTheSameItemMultipleTimes()
        {
            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Entities.First(x => x.Id == 1);
                entity.Contents.Name   = "newname1";
                entity.Contents.Number = -1;
                testRepository.Update(entity);
                entity.Contents.Name   = "newname2";
                entity.Contents.Number = -2;
                testRepository.Update(entity);
                testRepository.Save();
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
                var entity = testRepository.Entities.First(x => x.Id == 1);
                Assert.AreEqual("newname2", entity.Contents.Name);
                Assert.AreEqual(-2, entity.Contents.Number);
            }
        }
Ejemplo n.º 18
0
 protected override void ProcessRecord()
 {
     DurableMemoryRepository<string> r = new DurableMemoryRepository<string>("foobar", new FileSystemFacade());
     WriteObject("Value is baz");
 }
        public void AddEntityThenDeleteFromMemory()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                IJsonEntity<EntityTest> entity = testRepository.Create();
                entity.Contents = new EntityTest { Name = "foo", Number = 1 };
                testRepository.Add(entity);

                IJsonEntity<EntityTest> entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNotNull(entityFromRepo);

                testRepository.Delete(entity);

                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNull(entityFromRepo);
            }
        }
        public void CallSaveWithNoPendingChanges()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                testRepository.Save();
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void AddEntityThenDeleteFromDisk()
        {
            // Create test entity
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                entity.Contents = new EntityTest { Name = "foo", Number = 1 };
                testRepository.Add(entity);
                testRepository.Save();
            }
            
            // Read the new entity from disk, then delete it and save
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNotNull(entityFromRepo);
                testRepository.Delete(entityFromRepo);
                testRepository.Save();
            }

            // After re-initializing the repo, the deleted item should be gone, but everything else should still be present
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
                Assert.IsNull(entityFromRepo);
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void AddAndDeleteTheSameItemMultipleTimesInASession()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                testRepository.Add(entity);
                testRepository.Delete(entity);
                testRepository.Add(entity);
                testRepository.Delete(entity);
                testRepository.Add(entity);
                testRepository.Delete(entity);
                testRepository.Add(entity);
                testRepository.Add(entity);
                testRepository.Delete(entity);
                testRepository.Delete(entity);
                testRepository.Save();
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
Ejemplo n.º 23
0
 /// <summary>
 /// Do some *real* work
 /// </summary>
 /// <returns>A bit of data to export to the console</returns>
 public string DoWork()
 {
     DurableMemoryRepository<string> r = new DurableMemoryRepository<string>("foobar", new FileSystemFacade());
     string path = r.Path;
     return path;
 }
        public void DeleteItemThatDoesNotExist()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Create();
                testRepository.Delete(entity);
                testRepository.Save();
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }
        }
        public void UpdateTheSameItemMultipleTimes()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var entity = testRepository.Entities.First(x => x.Id == 1);
                entity.Contents.Name = "newname1";
                entity.Contents.Number = -1;
                testRepository.Update(entity);
                entity.Contents.Name = "newname2";
                entity.Contents.Number = -2;
                testRepository.Update(entity);
                testRepository.Save();
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, testRepository.Entities.Select(x => x.Id).ToArray());
                var entity = testRepository.Entities.First(x => x.Id == 1);
                Assert.AreEqual("newname2", entity.Contents.Name);
                Assert.AreEqual(-2, entity.Contents.Number);
            }
        }
        public void UpdateNullEntity()
        {
            var testRepository = new DurableMemoryRepository <EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);

            testRepository.Update(null);
        }
        public void AddEntityAndRetrieveFromDisk()
        {
            // Create test entity and write it to the mock filesystem
            IJsonEntity<EntityTest> entity;
            IJsonEntity<EntityTest> entityFromRepo;
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entity = testRepository.Create();
                entity.Contents = new EntityTest {Name = "foo", Number = 1};
                testRepository.Add(entity);
                testRepository.Save();
            }

            // Now re-create the repo, which should read the persisted value for the new entity from "disk"
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
            }

            Assert.IsNotNull(entityFromRepo);
            Assert.AreEqual(entity.Id, entityFromRepo.Id);
            Assert.AreEqual(entity.Contents.Name, entityFromRepo.Contents.Name);
            Assert.AreEqual(entity.Contents.Number, entityFromRepo.Contents.Number);
        }
        public void DataReadFromRepoIsDisconnectedFromSession()
        {
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var collection1 = testRepository.Entities.Where(x => new[]{1, 2}.Contains(x.Id)).ToArray();
                testRepository.Delete(collection1[0]);
                testRepository.Delete(collection1[1]);
                var collection2 = testRepository.Entities.Where(x => new[] { 1, 2 }.Contains(x.Id)).ToArray();
                CollectionAssert.AreEquivalent(new[] { 1, 2 }, collection1.Select(x => x.Id).ToArray());
                CollectionAssert.AreEquivalent(new int[] {}, collection2.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var collection1 = testRepository.Entities.ToArray();
                var entity1 = testRepository.Create();
                var entity2 = testRepository.Create();
                testRepository.Add(entity1);
                testRepository.Add(entity2);
                var collection2 = testRepository.Entities.ToArray();
                
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4 }, collection1.Select(x => x.Id).ToArray());
                CollectionAssert.AreEquivalent(new[] { 1, 2, 4, 5, 6 }, collection2.Select(x => x.Id).ToArray());
            }

            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                var collection1 = testRepository.Entities.ToArray();
                var entity = collection1[0];
                string originalName = entity.Contents.Name;
                int originalNumber = entity.Contents.Number;
                entity.Contents.Name = "foo";
                entity.Contents.Number = -1;
                testRepository.Update(entity);
                var collection2 = testRepository.Entities.ToArray();

                Assert.AreNotEqual(originalName, collection2[0].Contents.Name);
                Assert.AreNotEqual(originalNumber, collection2[0].Contents.Number);
            }
        }
 public void AddNullEntity()
 {
     var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object);
     testRepository.Add(null);
 }
        public void AddEntityAndRetrieveFromMemory()
        {
            IJsonEntity<EntityTest> entity;
            IJsonEntity<EntityTest> entityFromRepo;
            using (var testRepository = new DurableMemoryRepository<EntityTest>(MockDataPath, _mockProvider.MockFileSystem.Object))
            {
                entity = testRepository.Create();
                entity.Contents = new EntityTest {Name = "foo", Number = 1};
                testRepository.Add(entity);
                entityFromRepo = testRepository.Entities.FirstOrDefault(x => x.Contents.Name == "foo");
            }

            Assert.IsNotNull(entityFromRepo);
            Assert.AreEqual(entity.Id, entityFromRepo.Id);
            Assert.AreEqual(entity.Contents.Name, entityFromRepo.Contents.Name);
            Assert.AreEqual(entity.Contents.Number, entityFromRepo.Contents.Number);
        }
Ejemplo n.º 31
0
 protected override void ProcessRecord()
 {
     DurableMemoryRepository<string> r = new DurableMemoryRepository<string>("foobar", new FileSystemFacade());
     string path = r.Path;
     WriteObject(string.Format("Value is {0}", path));
 }
Ejemplo n.º 32
0
 /// <summary>
 /// Do some *real* work
 /// </summary>
 /// <returns>A bit of data to export to the console</returns>
 public string DoWork()
 {
     DurableMemoryRepository<string> r = new DurableMemoryRepository<string>("foobar", new FileSystemFacade());
     var e = r.Entities;
     return "baz";
 }