public void RepoShouldBeQueryable()
{
DaoRepository repo = GetTestDaoRepository();
repo.EnsureDaoAssemblyAndSchema();
House one = new House {
Name = "Get This One"
};
House two = new House {
Name = "Get This Too"
};
House three = new House {
Name = "Not this one"
};
repo.Save(one);
repo.Save(three);
repo.Save(two);
House[] houses = repo.Query <House>(Query.Where("Name").StartsWith("Get")).ToArray();
Expect.AreEqual(2, houses.Length);
houses.Each(house =>
{
repo.Delete(house);
});
repo.Delete(three);
}
public virtual ExternalEventSubscriptionDescriptor SubscribeExternal(ExternalEventSubscriptionDescriptor subscriptionInfo)
{
if (string.IsNullOrWhiteSpace(subscriptionInfo.CreatedBy))
{
subscriptionInfo.CreatedBy = CurrentUser.UserName;
}
string clientNameProp = nameof(ExternalEventSubscriptionDescriptor.ClientName);
string eventNameProp = nameof(ExternalEventSubscriptionDescriptor.EventName);
Args.ThrowIfNullOrEmpty(subscriptionInfo.ClientName, clientNameProp);
Args.ThrowIfNullOrEmpty(subscriptionInfo.EventName, eventNameProp);
ExternalEventSubscriptionDescriptor lookedUp = DaoRepository.Query <ExternalEventSubscriptionDescriptor>
(
Query.Where(clientNameProp) == subscriptionInfo.ClientName &&
Query.Where(eventNameProp) == subscriptionInfo.EventName &&
Query.Where(nameof(ExternalEventSubscriptionDescriptor.CreatedBy)) == subscriptionInfo.CreatedBy
)
.FirstOrDefault();
if (lookedUp != null)
{
return(lookedUp);
}
return(DaoRepository.Save(subscriptionInfo));
}
public void Synchronize()
{
foreach (Type type in StorableTypes)
{
FileInfo[] files = YamlDataDirectory.GetYamlFiles(type);
foreach (FileInfo file in files)
{
YamlData data = YamlData.Load(type, file, Logger);
object dao = DaoRepository.Query("Name", data.Name).FirstOrDefault();
if (dao == null)
{
DaoRepository.Save(data.Data);
}
else
{
data.FileWins += (o, a) =>
{
YamlData.YamlDataEventArgs d = (YamlData.YamlDataEventArgs)a;
DaoRepository.Save(d.Type, d.Data);
FireEvent(FileWins, d);
};
data.DataWins += (o, a) =>
{
YamlData.YamlDataEventArgs d = (YamlData.YamlDataEventArgs)a;
YamlDataDirectory.Save(file, d.Type, d.Data);
FireEvent(DataWins, d);
};
data.Data = dao;
data.Synchronize(type, file);
}
}
}
}
public void TestDaoRepoHbGen()
{
Database db = DataProvider.Current.GetAppDatabaseFor(ProcessApplicationNameProvider.Current, this);
DaoRepository repo = new DaoRepository(db)
{
BaseNamespace = typeof(ShellDescriptor).Namespace, RequireCuid = true
};
repo.AddType <ShellDescriptor>();
ShellDescriptor d = new ShellDescriptor()
{
AssemblyName = "Ass", NameSpace = "Ns"
};
d = repo.Save(d);
ShellDescriptor queried = repo.Query <ShellDescriptor>(c => c.Id == d.Id).FirstOrDefault();
Expect.IsNotNull(queried);
Expect.AreEqual(d, queried);
ShellDescriptor retrieved = repo.Retrieve <ShellDescriptor>(d.Id);
Expect.IsNotNull(retrieved);
Expect.AreEqual(d, retrieved);
Pass("yay");
}
public void CanSaveAndRetrieveAllCurrentAppDomainDescriptorsTest()
{
DaoRepository daoRepo = GetAssemblyManagementRepository(GetConsoleLogger());
AssemblyDescriptor[] descriptors = AssemblyDescriptor.GetCurrentAppDomainDescriptors().ToArray();
foreach (AssemblyDescriptor descriptor in descriptors)
{
OutLine("Before save");
OutputInfo(descriptor);
AssemblyDescriptor saved = daoRepo.Save(descriptor);
OutLine("Original after save", ConsoleColor.Yellow);
OutputInfo(descriptor);
OutLine("Result after save", ConsoleColor.DarkYellow);
OutputInfo(saved);
Expect.AreEqual(descriptor.AssemblyFullName, saved.AssemblyFullName, "AssemlbyFullName didn't match");
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "AssemblyReferenceDescriptors count didn't match");
AssemblyDescriptor retrieved = daoRepo.Retrieve <AssemblyDescriptor>(saved.Uuid);
OutLine("Retrieved after save", ConsoleColor.DarkGreen);
OutputInfo(saved);
Expect.AreEqual(descriptor.AssemblyFullName, retrieved.AssemblyFullName, "AssemlbyFullName didn't match");
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, retrieved.AssemblyReferenceDescriptors?.Count, "AssemblyReferenceDescriptors count didn't match");
}
}
public virtual ReplicationOperation Replicate(ReplicationOperation operation)
{
ReplicationOperation result = DaoRepository.Save(operation);
Task.Run(() => (ReplicationOperation)operation.Execute(this));
return(result);
}
public void CanSaveToRepo()
{
DataPoint point = new DataPoint();
point.Description = "Description_".RandomLetters(5);
DaoRepository repo = new DaoRepository();
repo.Database = new SQLiteDatabase(".\\", nameof(CanSaveToRepo));
repo.AddType <DataPoint>();
repo.AddType <DataRelationship>();
string prop1 = "Hello_".RandomLetters(8);
string prop2 = "banana".RandomLetters(4);
bool gender = false;
point.Property("Name", prop1);
point.Property("LastName", prop2);
point.Property("Gender", gender);
point = repo.Save(point);
Expect.IsTrue(point.Cuid.Length > 0);
OutLine(point.Cuid);
DataPoint retrieved = repo.Query <DataPoint>(dp => dp.Cuid == point.Cuid).FirstOrDefault();
Expect.AreEqual(point.Description, retrieved.Description);
Expect.AreEqual(prop1, retrieved.Property("Name").Value);
Expect.AreEqual(prop2, retrieved.Property("LastName").Value);
Expect.AreEqual(false, retrieved.Property("Gender").Value);
Expect.AreEqual(prop1, retrieved.Property <string>("Name"));
Expect.AreEqual(prop2, retrieved.Property <string>("LastName"));
Expect.AreEqual(gender, retrieved.Property <bool>("Gender"));
}
public virtual Task Trigger(string eventName, object sender, EventSourceServiceArgs args)
{
if (args.EventMessage != null)
{
DaoRepository.Save(args.EventMessage);
}
return(FireListenersAsync(eventName, sender, args));
}
private static TestClass GetTestClassInstance(string methodName, DaoRepository repo)
{
TestClass objectInstance = new TestClass();
objectInstance.StringProperty = string.Format("{0}:: a value ".RandomLetters(8), methodName);
repo.Save(objectInstance);
Expect.IsGreaterThan(objectInstance.Id.Value, 0);
return(objectInstance);
}
private void GetTestObjects(string methodName, out DaoRepository repo, out TestRestResponder responder, out TestClass objectInstance)
{
Database database;
GetTestRepoAndResponder(methodName, out repo, out responder, out database);
objectInstance = new TestClass();
objectInstance.StringProperty = "{0}:: a value ({1})"._Format(methodName, 8.RandomLetters());
objectInstance = repo.Save(objectInstance);
Expect.IsGreaterThan(objectInstance.Id.Value, 0);
}
public HostEntry AddHostEntry()
{
Machine current = Machine.Current;
List <HostAddress> hostAddresses = current.HostAddresses;
HostEntry entry = new HostEntry
{
HostName = current.DnsName,
IpAddress = hostAddresses.FirstOrDefault(ha => ha.AddressFamily.Equals(AddressFamily.InterNetwork.ToString()))?.ToString(),
IpAddressV6 = hostAddresses.FirstOrDefault(ha => ha.AddressFamily.Equals(AddressFamily.InterNetworkV6.ToString()))?.ToString()
};
return(DaoRepository.Save(entry));
}
public void CanSaveAndRetrieveAssemblyDescriptorTest()
{
DaoRepository daoRepo = GetAssemblyManagementRepository(GetConsoleLogger());
AssemblyDescriptor descriptor = new AssemblyDescriptor(Assembly.GetExecutingAssembly());
Expect.IsTrue(descriptor.AssemblyReferenceDescriptors.Count > 0, "No references found");
AssemblyDescriptor saved = daoRepo.Save(descriptor);
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "Saved references didn't match");
AssemblyDescriptor retrieved = daoRepo.Retrieve <AssemblyDescriptor>(descriptor.Uuid);
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "Retrieved references didn't match");
}
public void SetsModified()
{
string schemaName = "TheSchemaName_".RandomLetters(5);
DaoRepository repo = new DaoRepository(new SQLiteDatabase(".", MethodBase.GetCurrentMethod().Name), Log.Default, schemaName);
repo.WarningsAsErrors = false;
repo.AddType <TestRepoData>();
TestRepoData data = new TestRepoData();
Expect.IsNull(data.Modified);
data = repo.Save(data);
Expect.IsNotNull(data.Modified);
Expect.IsFalse(data.Modified == default(DateTime));
}
public void ParentSaveShouldSaveChildren()
{
DaoRepository repo = GetTestDaoRepository();
repo.EnsureDaoAssemblyAndSchema();
Parent parent = new Parent();
parent.Name = "Parent Name";
Son sonOne = new Son();
Son sonTwo = new Son();
parent.Sons = new List <Son>(new Son[] { sonOne, sonTwo });
parent = repo.Save(parent);
Parent retrieved = repo.Retrieve <Parent>(parent.Id);
Expect.AreEqual(2, retrieved.Sons.Count);
}
public void RetrieveShouldSetParentOnChildren()
{
DaoRepository repo = GetTestDaoRepository();
repo.EnsureDaoAssemblyAndSchema();
Parent parent = new Parent();
parent.Name = "Test parent";
Son one = new Son();
one.Name = "Son";
parent.Sons = new List <Son>(new Son[] { one });
parent = repo.Save(parent);
Son checkSon = repo.Retrieve <Son>(parent.Sons[0].Id);
Expect.AreEqual(one.Name, checkSon.Name);
Expect.AreEqual(parent.Id, checkSon.Parent.Id);
Expect.AreEqual(parent.Name, checkSon.Parent.Name);
}
public void SavingParentShouldSaveChildLists()
{
DaoRepository repo = GetTestDaoRepository();
repo.EnsureDaoAssemblyAndSchema();
House house = new House {
Name = "TestHouse", Parents = new List <Parent> {
new Parent {
Name = "TestParent"
}
}
};
repo.Save(house);
House retrieved = repo.Retrieve <House>(house.Id);
Expect.AreEqual(1, retrieved.Parents.Count);
}
public void SavingParentXrefShouldSetChildXref()
{
DaoRepository repo = GetTestDaoRepository();
repo.EnsureDaoAssemblyAndSchema();
House house = new House {
Name = "TestHouse", Parents = new List <Parent> {
new Parent {
Name = "TestParent"
}
}
};
repo.Save(house);
House retrieved = repo.Retrieve <House>(house.Id);
Parent parent = repo.Retrieve <Parent>(retrieved.Parents[0].Id);
Expect.AreEqual(1, parent.Houses.Length);
}
public HostEntry AddHostEntry(string hostName, string ipaddress, string mac)
{
return(DaoRepository.Save <HostEntry>(new HostEntry {
HostName = hostName, IpAddress = ipaddress, MacAddress = mac
}));
}
