public void Submit_CanUpdateOneCase()
{
const int expectedOperationResultsCount = 1;
//Arrange
var case1 = EphorteContext.Query <Case>().Where(c => c.Id > 1).First();
var caseId = case1.Id;
var newTitle = "new title" + DateTime.Now.ToShortTimeString();
SetTitle(case1, newTitle);
//Act
var changeEntries = new List <ChangeSetEntry>
{
new ChangeSetEntry {
Operation = EntryOperation.Update, Entity = case1
}
};
var result = Submit(new ChangeSet {
ChangeSetEntries = changeEntries
});
//Assert
AssertOperationResultCountIs(expectedOperationResultsCount, result);
var case1Updated = result.OperationResults.First().Entities.First() as Case;
Assert.IsNotNull(case1Updated);
Assert.AreEqual(newTitle, case1Updated.Title, "case1Updated.Title");
//Fetch the case again and verify title
Assert.AreEqual(newTitle, EphorteContext.Query <Case>().Where(x => x.Id == caseId).First().Title, "_ephorte.Query<Case>().Where(x => x.Id == caseId).First().Title");
}
private RegistryEntry GetRegistryEntry(RegistryEntry registryEntry)
{
var query = from o in EphorteContext.Query <RegistryEntry>()
where o.Id == registryEntry.Id
select o;
return(query.FirstOrDefault());
}
public void CreateRegistryEntryWithDocument(bool addAttachment, string fileformatId)
{
var mainCase = GetMainCase();
const string registryEntryTypeId = "U"; //Currently hardcoded
//Add registry-entry to case
var registryEntry = _ephorte.AddRegistryEntryToCase(mainCase, registryEntryTypeId, "One document - " + (addAttachment ? "ONE" : "NO") + " attachment (" + fileformatId + ")");
if (registryEntryTypeId == "U")
{
//If type is U, then there MUST be an at least one external recipient
_ephorte.AddRecipient(registryEntry, "FirstName1", "LastName1");
}
DocumentDescription documentDescription1;
DocumentObject documentObject1;
AddMainDocument(registryEntry, out documentDescription1, out documentObject1);
//Save changes (and attach uploaded document)
EphorteContext.SaveChanges();
LogEphorteWebLink(registryEntry);
//The checksum is now updated:
Assert.IsNotNull(documentObject1.Checksum, "documentObject1.Checksum");
//---------------------------------------------------
//Add a new version of the main document
//---------------------------------------------------
var documentObject2 = AddNewVersionOfDocument(documentDescription1, fileformatId);
//Fetch the updated document-object to verify that the checsum is set.
var documentObject2Reloaded = GetDocumentObject(documentObject2);
Assert.IsNotNull(documentObject2Reloaded, "documentObject2Reloaded");
Assert.IsNotNull(documentObject2Reloaded.Checksum, "documentObject2Reloaded.Checksum");
//NOTE:
//At this point we have a case, a registry-entry with ONE external recipient and ONE main-document. The main-document has two versions.
Assert.AreEqual(0, GetRegistryEntry(registryEntry).NumberOfSubDocuments, "NumberOfSubDocuments");
if (!addAttachment)
{
return;
}
//---------------------------------------------------
//Add attachment
var documentDescription2 = AddAttachment(registryEntry);
EphorteContext.SaveChanges();
//Verify that the FileFormatId has been resolved correctly: (.PDF -> RA-PDF)
Assert.AreEqual(FileFormatId.RaPdf, GetDocumentObject(documentDescription2.Id, VariantFormatId.Production, 1).FileformatId, "FileformatId documentDescription2");
//After the attachment is added, NumberOfSubDocuments should be 1:
Assert.AreEqual(1, GetRegistryEntry(registryEntry).NumberOfSubDocuments, "NumberOfSubDocuments");
}
public void Ctor_WithoutObjectModelAdapterProvided_AnyStateManagementShouldThrow()
{
var functionsAdapterStub = MockRepository.GenerateStub <IFunctionsAdapter>();
var ctx = new EphorteContext(functionsAdapter: functionsAdapterStub);
Action act = () => ctx.Attach(new object());
act.ShouldThrow <NotSupportedException>();
}
private DocumentObject GetDocumentObject(int documentDescriptionId, string variantFormatId, int versionNumber)
{
var query = from o in EphorteContext.Query <DocumentObject>()
where o.DocumentDescriptionId == documentDescriptionId &&
o.VariantFormatId == variantFormatId &&
o.VersionNumber == versionNumber
select o;
return(query.FirstOrDefault());
}
private void DeleteAllRemarksOnCase(int caseId)
{
var remarks = EphorteContext.Query <Remarks>().Where(r => r.CaseId == caseId);
Submit(new ChangeSet
{
ChangeSetEntries = new List <ChangeSetEntry>(remarks.Select(r => new ChangeSetEntry {
Operation = EntryOperation.Delete, Entity = r
}))
});
}
public void Submit_CanUpdateOneCaseAndInsertRemark()
{
var newCaseTitle = "new title" + DateTime.Now.ToShortTimeString();
var newRemarkText = "Some remarks regarding case " + newCaseTitle;
const int expectedOperationResultsCount = 2;
//Arrange
var case1 = EphorteContext.Query <Case>().Where(c => c.Id > 1).First();
var caseId = case1.Id;
SetTitle(case1, newCaseTitle);
var remark = new Remarks {
CaseId = case1.Id, Text = newRemarkText
};
//Act
var changeEntries = new List <ChangeSetEntry>
{
new ChangeSetEntry {
Operation = EntryOperation.Update, Entity = case1
},
new ChangeSetEntry {
Operation = EntryOperation.Insert, Entity = remark
}
};
var result = Submit(new ChangeSet {
ChangeSetEntries = changeEntries
});
//Assert
AssertOperationResultCountIs(expectedOperationResultsCount, result);
var case1Updated = result.OperationResults.First().Entities.First() as Case;
Assert.IsNotNull(case1Updated);
Assert.AreEqual(newCaseTitle, case1Updated.Title, "case1Updated.Title");
//Fetch the last inserted remark on the case
var q = from r in EphorteContext.Query <Remarks>()
.Include(x => x.Case)
where r.CaseId == caseId orderby r.CreatedDate descending
select r;
var lastRemark = q.FirstOrDefault();
Assert.IsNotNull(lastRemark, "lastRemark");
Assert.AreEqual(newRemarkText, lastRemark.Text, "lastRemark.Text");
Assert.IsNotNull(lastRemark.Case, "lastRemark.Case");
Assert.AreEqual(newCaseTitle, lastRemark.Case.Title, "lastRemark.Text");
}
public void CreateTwoRegistryEntriesOfType(string registryEntryTypeId)
{
var mainCase = GetMainCase();
const string moreThanOneRecipientExpectedPostfix = " m.fl.";
var registryEntry1 = _ephorte.AddRegistryEntryToCase(mainCase, registryEntryTypeId, registryEntryTypeId + " - With one recipient ");
var registryEntry2 = _ephorte.AddRegistryEntryToCase(mainCase, registryEntryTypeId, registryEntryTypeId + " - With two recipients ");
if (registryEntryTypeId == "I")
{
_ephorte.AddSenderRecipient(registryEntry1, "SenderFN", "LN");
_ephorte.AddSenderRecipient(registryEntry2, "SenderFN1", "LN1");
_ephorte.AddSenderRecipient(registryEntry2, "SenderFN2", "LN2");
}
if (registryEntryTypeId == "U")
{
_ephorte.AddRecipient(registryEntry1, "RecipientFN", "LN");
_ephorte.AddRecipient(registryEntry2, "RecipientFN1", "LN1");
_ephorte.AddRecipient(registryEntry2, "RecipientFN2", "LN2");
}
if (registryEntryTypeId == "X")
{
var r1 = _ephorte.AddSenderRecipient(registryEntry1, "InternalFN", "LN");
var r2 = _ephorte.AddSenderRecipient(registryEntry2, "InternalFN1", "LN1");
var r3 = _ephorte.AddSenderRecipient(registryEntry2, "InternalFN2", "LN2");
foreach (var recipient in new[] { r1, r2, r3 })
{
//TODO: Fix hardcoded values
recipient.AdministrativeUnitId = Configuration.RecipientXAdministrativeUnitId;
recipient.RegistryManagementUnitId = Configuration.RecipientXRegistryManagementUnitId;
}
}
EphorteContext.SaveChanges();
//First registry-entry has ONE recipient, so registryEntry.SenderRecipient must NOT end with " m.fl."
string registryEntry1SenderRecipient = GetRegistryEntry(registryEntry1).SenderRecipient;
Console.WriteLine("SenderRecipient: " + registryEntry1SenderRecipient);
Assert.IsNotNull(registryEntry1SenderRecipient, "SenderRecipient must not be null");
Assert.IsFalse(registryEntry1SenderRecipient.EndsWith(moreThanOneRecipientExpectedPostfix), "registryEntry.SenderRecipient (one recipient)");
//Second registry-entry has two recipients, and registryEntry.SenderRecipient DOES end with " m.fl."
Assert.IsTrue(GetRegistryEntry(registryEntry2).SenderRecipient.EndsWith(moreThanOneRecipientExpectedPostfix), "registryEntry.SenderRecipient (multiple)");
}
public void QueryForClassificationThatIsInUse_DoesNotReturnsZeroRecords()
{
var firstClassification = EphorteContext.Query <Classification>().First(c => c.Description != null);
Console.WriteLine(firstClassification.ClassId);
var query1 = EphorteContext.Query <Classification>().Where(x => x.ClassId == firstClassification.ClassId);
Assert.AreNotEqual(0, query1.Count(), "Query 1");
//WILL Currently fail:
//var query2 = EphorteContext.Query<Classification>().Where(x => x.Class.Id == firstClassification.ClassId);
//Assert.AreNotEqual(0, query2.Count(), "Query 2");
}
public void QueryForClassThatDoesNotExist_ReturnsZeroRecords()
{
//Norwegian
//var query = context.Query<Klassering>().Where(x => x.Ordningsverdi.Tittel == "12345678910").Count();
//var query = EphorteContext.Query<Classification>().Where(x => x.Class.Id == "DoesNotExist");
//This query would give same result:
var query = EphorteContext.Query <Classification>().Where(x => x.ClassId == "DoesNotExist");
var count = query.Count();
Assert.AreEqual(0, count);
}
private DocumentObject AddNewVersionOfDocument(DocumentDescription documentDescription1, string fileformatId)
{
var documentObject = _ephorte.AddDocumentObject(documentDescription1.Id, 2, VariantFormatId.Production, MainFileName, fileformatId);
EphorteContext.SaveChanges();
Assert.AreEqual(fileformatId, GetDocumentObject(documentDescription1.Id, VariantFormatId.Production, 2).FileformatId, "FileformatId documentDescription1");
//This time we add a text-document to an existing document-description
_ephorte.CheckinTextDocument(documentDescription1.Id, documentObject.VariantFormatId, documentObject.VersionNumber, TextFileContent + " - v2");
//Note that the checksum is not yet calculated "locally".
Assert.IsNull(documentObject.Checksum);
return(GetDocumentObject(documentObject)); //Re-fetch document-object
}
public void Submit_CanInsertRemark()
{
var newRemarkText = "Some remarks regarding case. Current time: " + DateTime.Now;
const int expectedOperationResultsCount = 1;
//Arrange
var case1 = EphorteContext.Query <Case>().Where(c => c.Id > 1).First();
var caseId = case1.Id;
var remarks = new Remarks {
CaseId = caseId, Text = newRemarkText
};
//Act
var changeEntries = new List <ChangeSetEntry>
{
new ChangeSetEntry {
Operation = EntryOperation.Insert, Entity = remarks
}
};
var result = Submit(new ChangeSet {
ChangeSetEntries = changeEntries
});
//Assert
AssertOperationResultCountIs(expectedOperationResultsCount, result);
var remarkUpdated = result.OperationResults.First().Entities.First() as Remarks;
Assert.IsNotNull(remarkUpdated);
Assert.AreEqual(newRemarkText, remarkUpdated.Text, "remarkUpdated.Text");
//Fetch the last inserted remark on the case
var q = from r in EphorteContext.Query <Remarks>()
//.Include(x => x.Case)
where r.CaseId == caseId
orderby r.CreatedDate descending
select r;
var lastRemark = q.FirstOrDefault();
Assert.IsNotNull(lastRemark, "lastRemark");
Assert.AreEqual(newRemarkText, lastRemark.Text, "lastRemark.Text");
}
public void PredefinedSearchQuery()
{
var result = EphorteContext.Query <Query>().FirstOrDefault(q => q.Id == PredefinedQueryId);
if (result != null)
{
var predefQueryResult = (from c in EphorteContext.Query <Case>()
where QueryContext.Current.StoredQuery(c, PredefinedQueryId)
select c as DataObject).Any();
var regularQueryResult = (from c in EphorteContext.Query <Case>()
where c.CaseDate < DateTime.Now
select c).Any();
Assert.AreEqual(predefQueryResult, regularQueryResult, "Expected predefined query {0} will return some Cases.", PredefinedQueryId);
}
else
{
Assert.Fail("Could not find predefined query for id={0}.", PredefinedQueryId);
}
}
private Case GetMainCase()
{
try
{
if (_mainCase != null)
{
return(_mainCase);
}
_mainCase = _ephorte.AddCase("TestCase " + DateTime.Now);
EphorteContext.SaveChanges();
return(_mainCase);
}
finally
{
if (_mainCase != null)
{
LogEphorteWebLink(_mainCase);
}
}
}
public void Submit_DeleteUpdateAndAddRemarks()
{
var newRemarkText = "Some remarks regarding case. Current time: " + DateTime.Now;
const int expectedOperationResultsCount = 3;
//Arrange
var case1 = EphorteContext.Query <Case>().Where(c => c.Id > 1).First();
var caseId = case1.Id;
//first delete all remarks on case
DeleteAllRemarksOnCase(caseId.Value);
//Add two remarks which can be changed and deleted
var remark1 = new Remarks {
CaseId = caseId, Text = newRemarkText + " 1"
};
var remark2 = new Remarks {
CaseId = caseId, Text = newRemarkText + " 2"
};
var result = Submit(new ChangeSet {
ChangeSetEntries
= new List <ChangeSetEntry>
{
new ChangeSetEntry {
Operation = EntryOperation.Insert, Entity = remark1
},
new ChangeSetEntry {
Operation = EntryOperation.Insert, Entity = remark2
}
}
});
var inserted = result.OperationResults.SelectMany(entryResult => entryResult.Entities).ToList();
//Act
var changedRemarkText = "Changed remark " + DateTime.Now;
var insertRemarkText = "Inserted remark" + DateTime.Now;
var deleteRemark = (Remarks)inserted[0];
var changeRemark = (Remarks)inserted[1]; changeRemark.Text = changedRemarkText;
var insertRemark = new Remarks {
CaseId = caseId, Text = insertRemarkText
};
result = Submit(new ChangeSet
{
ChangeSetEntries
= new List <ChangeSetEntry>
{
new ChangeSetEntry {
Operation = EntryOperation.Delete, Entity = deleteRemark
},
new ChangeSetEntry {
Operation = EntryOperation.Update, Entity = changeRemark
},
new ChangeSetEntry {
Operation = EntryOperation.Insert, Entity = insertRemark
},
}
});
//inserted = result.OperationResults.SelectMany(entryResult => entryResult.Entities).ToList();
//Assert
AssertOperationResultCountIs(expectedOperationResultsCount, result);
//Fetch the remarks on the case
var remarks = (from r in EphorteContext.Query <Remarks>()
where r.CaseId == caseId
orderby r.CreatedDate descending
select r).ToList();
Assert.AreEqual(2, remarks.Count, "remarks.Count");
Assert.AreEqual(1, remarks.Where(x => x.Text == changedRemarkText).Count());
Assert.AreEqual(1, remarks.Where(x => x.Text == insertRemarkText).Count());
}
