public void Setup()
{
_testRep = new TestRepository();
_rep = new CachingRepository(_testRep, new TestEventStore());
_aggregate = _testRep.Get<TestAggregate>(Guid.NewGuid());
_rep.Save(_aggregate,-1);
}
public void Stores_and_deletes()
{
bool deleted = false;
bool inserted = false;
var key = Guid.NewGuid().ToString("N");
using (var session = new CachingRepository <string, Document>(_repo,
_ => deleted = true,
_ => inserted = true))
{
session.Run(key, d => { d.Name = "test"; d.Value = "test123"; });
session.Commit();
}
deleted.ShouldBeFalse();
inserted.ShouldBeTrue();
_repo.Get(key).ShouldNotBeNull();
inserted = false;
using (var session = new CachingRepository <string, Document>(_repo,
_ => deleted = true,
_ => inserted = true))
{
session.Delete(key);
session.IsDeleted(key).ShouldBeTrue();
session.Commit();
}
deleted.ShouldBeTrue();
inserted.ShouldBeFalse();
_repo.Get(key).ShouldBeNull();
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new ConsoleLoggerFactory();
using (CachingRepository <MessageTemplate> repository
= new CachingRepository <MessageTemplate>(
new Repository <MessageTemplate>(new MessageTemplatesContext())))
{
ITransmissionStrategy transmissionStrategy =
new SmsTransmissionStrategy(loggerFactory);
Messenger messenger = new Messenger(
loggerFactory,
repository,
transmissionStrategy);
IUser user = new User("Gen-Eric", "*****@*****.**", "+4522123631");
messenger.Send(new Message
{
Recipient = user,
MessageTemplateId = 1,
Parameters = new List <object> {
"Jesper", DateTime.Now
}
});
Console.ReadLine();
}
}
private static void ComposeObjects()
{
var wrappedRepository = new ServiceRepository();
IPersonRepository repository = new CachingRepository(wrappedRepository);
var viewModel = new PeopleViewerViewModel(repository);
Application.Current.MainWindow = new PeopleViewerWindow(viewModel);
}
public when_using_caching_repository()
{
var mockStore = new MockStreamStoreConnection("testRepo");
mockStore.Connect();
_repo = new StreamStoreRepository(new PrefixedCamelCaseStreamNameBuilder(), mockStore, new JsonMessageSerializer());
_cachingRepo = new CachingRepository(_repo);
}
private static void CompositionObjects()
{
//ISuperheroRepository repository = new CSVRepository();
var decoratedRepository = new SuperheroRepository();
var repository = new CachingRepository(decoratedRepository);
SuperheroViewModel viewModel = new SuperheroViewModel(repository);
Application.Current.MainWindow = new SuperheroesViewerWindow(viewModel);
}
private void GetRepos(string dbName, out DaoRepository daoRepo, out CachingRepository cachingRepo)
{
SQLiteDatabase db = new SQLiteDatabase(dbName);
daoRepo = new DaoRepository(db);
daoRepo.DaoNamespace = $"{typeof(TestMonkey).Namespace}.Dao";
daoRepo.WarningsAsErrors = false;
daoRepo.AddType <TestMonkey>();
cachingRepo = new CachingRepository(daoRepo);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var wrappedRepository = new ServiceRepository();
var repository = new CachingRepository(wrappedRepository);
var viewModel = new MainWindowViewModel(repository);
Application.Current.MainWindow = new MainWindow(viewModel);
Application.Current.MainWindow.Show();
}
public void Cannot_commitsession_twice()
{
var key = Guid.NewGuid().ToString("N");
using (var session = new CachingRepository <string, Document>(_repo))
{
session.Run(key, d => { d.Name = "test"; d.Value = "test123"; });
session.Commit();
Should.Throw <ObjectDisposedException>(() => session.Commit());
}
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
ServiceRepository wrappedRepository = new ServiceRepository();
CachingRepository serviceRepository = new CachingRepository(wrappedRepository);
PeopleViewModel peopleViewModel = new PeopleViewModel(serviceRepository);
Application.Current.MainWindow = new MainWindow(peopleViewModel);
Application.Current.MainWindow.Show();
}
public CompositeRepository(DaoRepository sourceRepository, DataProvider dataProvider = null)
{
DataDirectoryProvider = dataProvider ?? DataProvider.Current;
SourceRepository = sourceRepository;
ReadRepository = new CachingRepository(sourceRepository);
WriteRepositories = new HashSet <IRepository>();
WorkspacePath = DataDirectoryProvider.GetWorkspaceDirectory(this.GetType()).FullName;
BackupRepository = ServiceRegistry.Default.Get <IRepository>();
TypeSchemaTempPathProvider = (sd, ts) => Path.Combine(WorkspacePath, sd.Name, ts.Hash);
WireBackup();
sourceRepository.StorableTypes.Each(type => AddType(type));
}
public CompositeRepository(DaoRepository sourceRepository, DataSettings dataSettings = null)
{
DataSettings = dataSettings ?? DataSettings.Current;
SourceRepository = sourceRepository;
ReadRepository = new CachingRepository(sourceRepository);
WriteRepositories = new HashSet <IRepository>();
WorkspacePath = DataSettings.GetWorkspaceDirectory(this.GetType()).FullName;
BackupRepository = new ObjectRepository(DataSettings.GetSysDataDirectory("BackupObjectRepo").FullName);
TypeSchemaTempPathProvider = (sd, ts) => Path.Combine(WorkspacePath, sd.Name, ts.Hash);
WireBackup();
sourceRepository.StorableTypes.Each(type => AddType(type));
}
public CompositeRepository(DaoRepository sourceRepository, string workspacePath)
{
SourceRepository = sourceRepository;
ReadRepository = new CachingRepository(sourceRepository);
WriteRepositories = new HashSet <IRepository>();
WorkspacePath = workspacePath;
BackupRepository = new ObjectRepository(Path.Combine(WorkspacePath, "BackupObjectRepo"));
TypeSchemaTempPathProvider = (sd, ts) =>
{
return(Path.Combine(WorkspacePath, sd.Name, ts.Hash));
};
WireBackup();
sourceRepository.StorableTypes.Each(type => AddType(type));
}
public void Does_not_store_anything_if_not_committed()
{
bool triggered = false;
var key = Guid.NewGuid().ToString("N");
using (var session = new CachingRepository <string, Document>(_repo,
_ => triggered = true,
_ => triggered = true))
{
session.Run(key, d => { d.Name = "test"; d.Value = "test123"; });
session[key].Name.ShouldBe("test");
session[key].Value.ShouldBe("test123");
}
triggered.ShouldBeFalse();
_repo.Get(key).ShouldBeNull();
}
private IEnumerable <Repository> GetTestRepositories()
{
ConsoleLogger logger = new ConsoleLogger {
AddDetails = false, UseColors = true
};
logger.StartLoggingThread();
string schemaName = "TheSchemaName_".RandomLetters(5);
DaoRepository daoRepo = new DaoRepository(new SQLiteDatabase(".", nameof(RepoQueryTest)), logger, schemaName);
daoRepo.WarningsAsErrors = false;
daoRepo.AddType(typeof(KeyHashRepoTestData));
yield return(daoRepo);
CachingRepository cachingRepo = new CachingRepository(daoRepo, logger);
yield return(cachingRepo);
}
public void ShouldQueryCacheTest()
{
ConsoleLogger logger = new ConsoleLogger {
AddDetails = false, UseColors = true
};
logger.StartLoggingThread();
string schemaName = "TheSchemaName_".RandomLetters(5);
DaoRepository repo = new DaoRepository(new SQLiteDatabase(".", nameof(ShouldQueryCacheTest)), logger, schemaName);
repo.AddType(typeof(TestData));
CachingRepository cachingRepo = new CachingRepository(repo, logger);
TestData data = new TestData {
Name = "Bryan", SerialNumber = "12345A", OtherInformation = "is having an existential crisis"
};
data.Save <TestData>(cachingRepo);
bool?queriedSource = false;
bool?queriedCache = false;
cachingRepo.SubscribeOnce(nameof(CachingRepository.QueriedSource), (o, a) =>
{
OutLineFormat("Queried source: {0}", ConsoleColor.Yellow, a.PropertiesToLine());
queriedSource = true;
});
cachingRepo.SubscribeOnce(nameof(CachingRepository.QueriedCache), (o, a) =>
{
OutLineFormat("Queried cache: {0}", ConsoleColor.Green, a.PropertiesToLine());
queriedCache = true;
});
IEnumerable <TestData> result = cachingRepo.Query <TestData>(td => td.SerialNumber.Equals(data.SerialNumber));
Expect.AreEqual(1, result.Count());
result = cachingRepo.Query <TestData>(td => td.SerialNumber.Equals(data.SerialNumber));
Expect.AreEqual(1, result.Count());
Expect.IsTrue(queriedSource.Value, "didn't query source");
Expect.IsTrue(queriedCache.Value, "didn't query cache");
}
public void SavingKeyHashRepoDataShouldntDuplicate()
{
ConsoleLogger logger = new ConsoleLogger {
AddDetails = false, UseColors = true
};
logger.StartLoggingThread();
string schemaName = "TheSchemaName_".RandomLetters(5);
DaoRepository repo = new DaoRepository(new SQLiteDatabase(".", nameof(SavingKeyHashRepoDataShouldntDuplicate)), logger, schemaName);
repo.WarningsAsErrors = false;
repo.AddType(typeof(KeyHashRepoTestData));
CachingRepository cachingRepo = new CachingRepository(repo, logger);
string nameOne = 32.RandomLetters();
string valueOne = 16.RandomLetters();
KeyHashRepoTestData one = new KeyHashRepoTestData {
Name = nameOne, SomeOtherUniqueProperty = valueOne
};
KeyHashRepoTestData two = new KeyHashRepoTestData {
Name = nameOne, SomeOtherUniqueProperty = valueOne
};
Expect.AreEqual(one, two);
one.Save <KeyHashRepoTestData>(cachingRepo);
var queryParams = new { Name = nameOne };
cachingRepo.Cache <KeyHashRepoTestData>(queryParams);
List <KeyHashRepoTestData> retrieved = cachingRepo.Query <KeyHashRepoTestData>(queryParams).ToList();
Expect.AreEqual(1, retrieved.Count);
two.Save <KeyHashRepoTestData>(cachingRepo);
retrieved = cachingRepo.Query <KeyHashRepoTestData>(queryParams).ToList();
Expect.AreEqual(1, retrieved.Count);
}
public void Should_get_same_aggregate_from_different_cache_repository()
{
var rep = new CachingRepository(new TestRepository(), new TestEventStore());
var aggregate = rep.Get<TestAggregate>(_aggregate.Id);
Assert.That(aggregate, Is.EqualTo(_aggregate));
}
public void Setup()
{
_rep = new CachingRepository(new TestRepository(), new TestEventStore());
_aggregate = _rep.Get<TestAggregate>(Guid.NewGuid());
}
public CachingRepositoryTests(ITestOutputHelper output) : base(output)
{
_cachingRepository = (CachingRepository)ServiceProvider.GetService <ICachingRepository>();
}
private void GetRepos(string dbName, out MongoRepository mongoRepo, out CachingRepository cachingRepo)
{
mongoRepo = new MongoRepository(databaseName: dbName);
mongoRepo.AddType <TestMonkey>();
cachingRepo = new CachingRepository(mongoRepo);
}
