public void MultipleQueries_QueriedFieldsAreIdentical_ReturnsOnlyOneRecordToken()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
PalasoTestItem itemCreatedAfterCache = dataMapper.CreateItem();
itemCreatedAfterCache.StoredString = "Item 6";
itemCreatedAfterCache.Child.StoredString = "Item 6";
dataMapper.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(7, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
}
public void UpdateItemInCache_ItemDoesNotExistInCacheButDoesInRepository_ItemIsAddedToResultSetAndSortedCorrectly()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
PalasoTestItem itemCreatedAfterCache = dataMapper.CreateItem();
itemCreatedAfterCache.StoredString = "Item 6";
dataMapper.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
public void UpdateItemInCache_ItemHasNotChanged_ResultSetIsNotChanged()
{
PalasoTestItem unmodifiedItem = dataMapper.CreateItem();
unmodifiedItem.StoredString = "Item 6";
dataMapper.SaveItem(unmodifiedItem);
//_results = dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.UpdateItemInCache(unmodifiedItem);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
public void DeleteAllItemsFromCache_AllItemsAreDeleted()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteAllItemsFromCache();
Assert.AreEqual(0, resultSetCacheUnderTest.GetResultSet().Count);
}
public void DeleteItemFromCacheById_Id_ItemIsNoLongerInResultSet()
{
PalasoTestItem itemToDelete = dataMapper.CreateItem();
itemToDelete.StoredString = "Item 6";
dataMapper.SaveItem(itemToDelete);
//_results = dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.DeleteItemFromCache(itemToDelete);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(6, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
}
public void DeleteItemFromCacheById_Null_Throws()
{
_results = dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
Assert.Throws <ArgumentNullException>(() => resultSetCacheUnderTest.DeleteItemFromCache((PalasoTestItem)null));
}
public void UpdateItemInCache_ItemDoesNotExistInRepository_Throws()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
PalasoTestItem itemNotInRepository = new PalasoTestItem();
Assert.Throws <ArgumentOutOfRangeException>(() => resultSetCacheUnderTest.UpdateItemInCache(itemNotInRepository));
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
PalasoTestItem itemToModify = dataMapper.CreateItem();
itemToModify.StoredString = "Item 6";
dataMapper.SaveItem(itemToModify);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
itemToModify.StoredString = "Item 7";
dataMapper.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 7", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
private ResultSet <LexEntry> GetAllEntriesWithMeaningsSortedByLexicalForm(IWritingSystemDefinition lexicalUnitWritingSystem, bool glossMeaningField)
{
if (lexicalUnitWritingSystem == null)
{
throw new ArgumentNullException("lexicalUnitWritingSystem");
}
string cachename = String.Format("MeaningsSortedByLexicalForm_{0}", lexicalUnitWritingSystem);
if (_caches[cachename] == null)
{
DelegateQuery <LexEntry> MatchingMeaningQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entry)
{
List <IDictionary <string, object> > fieldsandValuesForRecordTokens = new List <IDictionary <string, object> >();
int senseNumber = 0;
foreach (LexSense sense in entry.Senses)
{
foreach (LanguageForm form in glossMeaningField ? sense.Gloss.Forms : sense.Definition.Forms)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string lexicalForm = entry.LexicalForm[lexicalUnitWritingSystem.Id];
if (String.IsNullOrEmpty(lexicalForm))
{
lexicalForm = null;
}
tokenFieldsAndValues.Add("Form", lexicalForm);
string meaning = form.Form;
if (String.IsNullOrEmpty(meaning))
{
meaning = null;
}
tokenFieldsAndValues.Add("Meaning", meaning);
string meaningWritingSystem = form.WritingSystemId;
if (String.IsNullOrEmpty(meaningWritingSystem))
{
meaningWritingSystem = null;
}
tokenFieldsAndValues.Add("MeaningWritingSystem", meaningWritingSystem);
tokenFieldsAndValues.Add("SenseNumber", senseNumber);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
senseNumber++;
}
return(fieldsandValuesForRecordTokens);
}
);
ResultSet <LexEntry> itemsMatchingQuery = GetItemsMatching(MatchingMeaningQuery);
SortDefinition[] sortDefinition = new SortDefinition[4];
sortDefinition[0] = new SortDefinition("Form", lexicalUnitWritingSystem.Collator);
sortDefinition[1] = new SortDefinition("Meaning", StringComparer.InvariantCulture);
sortDefinition[2] = new SortDefinition("MeaningWritingSystem", StringComparer.InvariantCulture);
sortDefinition[3] = new SortDefinition("SenseNumber", Comparer <int> .Default);
ResultSetCache <LexEntry> cache =
new ResultSetCache <LexEntry>(this, sortDefinition, itemsMatchingQuery, MatchingMeaningQuery);
_caches.Add(cachename, cache);
}
return(_caches[cachename].GetResultSet());
}
public void Constructor_IsPassedUnsortedResultSet_GetResultSetReturnsSorted()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
Assert.AreEqual(3, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
}
public void Constructor_IsPassedUnsortedResultSet_GetResultSetReturnsSorted()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
Assert.AreEqual(3, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
}
public void Constructor_SortDefinitionNull_SortedByRepositoryId()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, null, _results, _queryToCache);
ResultSet<TestItem> resultSet = resultSetCacheUnderTest.GetResultSet();
Assert.AreEqual(3, resultSet.Count);
for (int recordTokenNum = 0; recordTokenNum < (resultSet.Count - 1); recordTokenNum++)
{
Assert.IsTrue(resultSet[recordTokenNum].Id.CompareTo(resultSet[recordTokenNum + 1].Id) < 0);
}
}
public void Add_QueryNull_Throws()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
Assert.Throws <ArgumentNullException>(() => resultSetCacheUnderTest.Add(results, null));
}
/// <summary>
/// Gets a ResultSet containing entries that contain a semantic domain assigned to them
/// sorted by semantic domain.
/// Use "SemanticDomain" to access the semantic domain in a RecordToken.
/// </summary>
/// <param name="fieldName"></param>
/// <returns></returns>
public ResultSet <LexEntry> GetEntriesWithSemanticDomainSortedBySemanticDomain(
string fieldName)
{
if (fieldName == null)
{
throw new ArgumentNullException("fieldName");
}
string cachename = String.Format("Semanticdomains_{0}", fieldName);
if (_caches[cachename] == null)
{
var semanticDomainsQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entry)
{
var fieldsandValuesForRecordTokens = new List <IDictionary <string, object> >();
foreach (LexSense sense in entry.Senses)
{
foreach (KeyValuePair <string, IPalasoDataObjectProperty> pair in sense.Properties)
{
if (pair.Key == fieldName)
{
var semanticDomains = (OptionRefCollection)pair.Value;
foreach (string semanticDomain in semanticDomains.Keys)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string domain = semanticDomain;
if (String.IsNullOrEmpty(semanticDomain))
{
domain = null;
}
if (CheckIfTokenHasAlreadyBeenReturnedForThisSemanticDomain(fieldsandValuesForRecordTokens, domain))
{
continue; //This is to avoid duplicates
}
tokenFieldsAndValues.Add("SemanticDomain", domain);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
}
}
}
return(fieldsandValuesForRecordTokens);
}
);
ResultSet <LexEntry> itemsMatchingQuery = GetItemsMatching(semanticDomainsQuery);
var sortDefinition = new SortDefinition[2];
sortDefinition[0] = new SortDefinition("SemanticDomain", StringComparer.InvariantCulture);
sortDefinition[1] = new SortDefinition("Sense", Comparer <int> .Default);
var cache =
new ResultSetCache <LexEntry>(this, sortDefinition, itemsMatchingQuery, semanticDomainsQuery);
_caches.Add(cachename, cache);
}
return(_caches[cachename].GetResultSet());
}
public void Constructor_SortDefinitionNull_SortedByRepositoryId()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, null, _results, _queryToCache);
ResultSet <PalasoTestItem> resultSet = resultSetCacheUnderTest.GetResultSet();
Assert.AreEqual(3, resultSet.Count);
for (int recordTokenNum = 0; recordTokenNum < (resultSet.Count - 1); recordTokenNum++)
{
Assert.IsTrue(resultSet[recordTokenNum].Id.CompareTo(resultSet[recordTokenNum + 1].Id) < 0);
}
}
public void DeleteAllItemsFromCache_AllItemsAreDeleted()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
QueryAdapter <PalasoTestItem> secondQueryToCache = new QueryAdapter <PalasoTestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet <PalasoTestItem> results = dataMapper.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.DeleteAllItemsFromCache();
Assert.AreEqual(0, resultSetCacheUnderTest.GetResultSet().Count);
}
public void UpdateItemInCache_ItemDoesNotExistInCacheButDoesInRepository_ItemIsAddedToResultSetAndSortedCorrectly()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
PalasoTestItem itemCreatedAfterCache = _dataMapper.CreateItem();
itemCreatedAfterCache.StoredString = "Item 1";
_dataMapper.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
}
public void ResultSetContainsIdenticalRecordTokens_Throws()
{
PalasoTestItem itemFromWhichToCreateIdenticalRecordTokens = dataMapper.CreateItem();
itemFromWhichToCreateIdenticalRecordTokens.StoredString = "Get me twice!";
QueryAdapter <PalasoTestItem> query1 = new QueryAdapter <PalasoTestItem>();
query1.Show("StoredString");
QueryAdapter <PalasoTestItem> query2 = new QueryAdapter <PalasoTestItem>();
query2.Show("StoredString");
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions);
resultSetCacheUnderTest.Add(dataMapper.GetItemsMatching(query1), query1);
Assert.Throws <ArgumentException>(() => resultSetCacheUnderTest.Add(dataMapper.GetItemsMatching(query2), query2));
}
public void DeleteItemFromCacheById_Id_ItemIsNoLongerInResultSet()
{
PalasoTestItem itemToDelete = _dataMapper.CreateItem();
itemToDelete.StoredString = "Item 1";
_dataMapper.SaveItem(itemToDelete);
_results = _dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteItemFromCache(itemToDelete);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(3, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
PalasoTestItem itemToModify = _dataMapper.CreateItem();
itemToModify.StoredString = "Item 5";
_dataMapper.SaveItem(itemToModify);
_results = _dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
itemToModify.StoredString = "Item 1";
_dataMapper.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
}
public void UpdateItemInCache_ItemHasNotChanged_ResultSetIsNotChanged()
{
PalasoTestItem unmodifiedItem = _dataMapper.CreateItem();
unmodifiedItem.StoredString = "Item 1";
_dataMapper.SaveItem(unmodifiedItem);
_results = _dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.UpdateItemInCache(unmodifiedItem);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
PalasoTestItem itemToModify = dataMapper.CreateItem();
itemToModify.StoredList = PopulateListWith("Change Me!", "Me 2!");
dataMapper.SaveItem(itemToModify);
_results = dataMapper.GetItemsMatching(_queryToCache);
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
itemToModify.StoredList = PopulateListWith("Item 5", "Item 4");
dataMapper.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(6, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredList"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredList"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredList"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredList"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredList"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredList"]);
}
public void UpdateItemInCache_ItemDoesNotExistInRepository_Throws()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
TestItem itemNotInRepository = new TestItem();
resultSetCacheUnderTest.UpdateItemInCache(itemNotInRepository);
}
public void ResultSetContainsIdenticalRecordTokens_Throws()
{
TestItem itemFromWhichToCreateIdenticalRecordTokens = _repository.CreateItem();
itemFromWhichToCreateIdenticalRecordTokens.StoredString = "Get me twice!";
QueryAdapter<TestItem> query1 = new QueryAdapter<TestItem>();
query1.Show("StoredString");
QueryAdapter<TestItem> query2 = new QueryAdapter<TestItem>();
query2.Show("StoredString");
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions);
resultSetCacheUnderTest.Add(_repository.GetItemsMatching(query1), query1);
resultSetCacheUnderTest.Add(_repository.GetItemsMatching(query2), query2);
}
public void DeleteItemFromCacheById_Id_ItemIsNoLongerInResultSet()
{
TestItem itemToDelete = _repository.CreateItem();
itemToDelete.StoredString = "Item 6";
_repository.SaveItem(itemToDelete);
//_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.DeleteItemFromCache(itemToDelete);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(6, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
}
public void UpdateItemInCache_ItemHasNotChanged_ResultSetIsNotChanged()
{
TestItem unmodifiedItem = _repository.CreateItem();
unmodifiedItem.StoredString = "Item 6";
_repository.SaveItem(unmodifiedItem);
//_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.UpdateItemInCache(unmodifiedItem);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
public void Constructor_RepositoryNull_Throws()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(null, _sortDefinitions, _results, _queryToCache);
}
public void MultipleQueries_QueriedFieldsAreIdentical_ReturnsOnlyOneRecordToken()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
TestItem itemCreatedAfterCache = _repository.CreateItem();
itemCreatedAfterCache.StoredString = "Item 6";
itemCreatedAfterCache.Child.StoredString = "Item 6";
_repository.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(7, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
}
public void UpdateItemInCache_Null_Throws()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(_dataMapper, _sortDefinitions, _results, _queryToCache);
Assert.Throws <ArgumentNullException>(() => resultSetCacheUnderTest.UpdateItemInCache(null));
}
public void Add_QueryNull_Throws()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, null);
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
TestItem itemToModify = _repository.CreateItem();
itemToModify.StoredString = "Item 5";
_repository.SaveItem(itemToModify);
_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
itemToModify.StoredString = "Item 1";
_repository.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
}
public void UpdateItemInCache_ItemDoesNotExistInCacheButDoesInRepository_ItemIsAddedToResultSetAndSortedCorrectly()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
TestItem itemCreatedAfterCache = _repository.CreateItem();
itemCreatedAfterCache.StoredString = "Item 6";
_repository.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 6", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
TestItem itemToModify = _repository.CreateItem();
itemToModify.StoredList = PopulateListWith("Change Me!", "Me 2!");
_repository.SaveItem(itemToModify);
_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
itemToModify.StoredList = PopulateListWith("Item 5", "Item 4");
_repository.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(6, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredList"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredList"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredList"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredList"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredList"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredList"]);
}
public void UpdateItemInCache_ItemExists_ResultSetIsUpdatedAndSorted()
{
TestItem itemToModify = _repository.CreateItem();
itemToModify.StoredString = "Item 6";
_repository.SaveItem(itemToModify);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
itemToModify.StoredString = "Item 7";
_repository.SaveItem(itemToModify);
resultSetCacheUnderTest.UpdateItemInCache(itemToModify);
Assert.AreEqual(8, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual(null, resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[4]["StoredString"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[5]["StoredString"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[6]["StoredString"]);
Assert.AreEqual("Item 7", resultSetCacheUnderTest.GetResultSet()[7]["StoredString"]);
}
public void UpdateItemInCache_ItemHasNotChanged_ResultSetIsNotChanged()
{
TestItem unmodifiedItem = _repository.CreateItem();
unmodifiedItem.StoredList = PopulateListWith("Item 5", "Item 4");
_repository.SaveItem(unmodifiedItem);
_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.UpdateItemInCache(unmodifiedItem);
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(6, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredList"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredList"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredList"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredList"]);
Assert.AreEqual("Item 4", resultSetCacheUnderTest.GetResultSet()[4]["StoredList"]);
Assert.AreEqual("Item 5", resultSetCacheUnderTest.GetResultSet()[5]["StoredList"]);
}
public void DeleteItemFromCacheById_Item_ItemIsNoLongerInResultSet()
{
TestItem itemToDelete = _repository.CreateItem();
itemToDelete.StoredList = PopulateListWith("Item 5", "Item 4");
_repository.SaveItem(itemToDelete);
_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteItemFromCache(_repository.GetId(itemToDelete));
//Would be a better test but ResultSets don't support equality checks
//Assert.AreEqual(resultsBeforeUpdate, resultsAfterUpdate);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredList"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredList"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredList"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredList"]);
}
public void DeleteItemFromCacheById_Null_Throws()
{
_results = _repository.GetItemsMatching(_queryToCache);
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteItemFromCache((TestItem)null);
}
public void DeleteAllItemsFromCache_AllItemsAreDeleted()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
QueryAdapter<TestItem> secondQueryToCache = new QueryAdapter<TestItem>();
secondQueryToCache.In("Child").Show("StoredString");
ResultSet<TestItem> results = _repository.GetItemsMatching(secondQueryToCache);
resultSetCacheUnderTest.Add(results, secondQueryToCache);
resultSetCacheUnderTest.DeleteAllItemsFromCache();
Assert.AreEqual(0, resultSetCacheUnderTest.GetResultSet().Count);
}
public void DeleteItemFromCacheById_ItemNotInRepository_Throws()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteItemFromCache(RepositoryId.Empty);
}
public void UpdateItemInCache_Null_Throws()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.UpdateItemInCache(null);
}
public void DeleteAllItemsFromCache_AllItemsAreDeleted()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
resultSetCacheUnderTest.DeleteAllItemsFromCache();
Assert.AreEqual(0, resultSetCacheUnderTest.GetResultSet().Count);
}
public void UpdateItemInCache_ItemDoesNotExistInCacheButDoesInRepository_ItemIsAddedToResultSetAndSortedCorrectly()
{
ResultSetCache<TestItem> resultSetCacheUnderTest = new ResultSetCache<TestItem>(_repository, _sortDefinitions, _results, _queryToCache);
TestItem itemCreatedAfterCache = _repository.CreateItem();
itemCreatedAfterCache.StoredString = "Item 1";
_repository.SaveItem(itemCreatedAfterCache);
resultSetCacheUnderTest.UpdateItemInCache(itemCreatedAfterCache);
Assert.AreEqual(4, resultSetCacheUnderTest.GetResultSet().Count);
Assert.AreEqual("Item 0", resultSetCacheUnderTest.GetResultSet()[0]["StoredString"]);
Assert.AreEqual("Item 1", resultSetCacheUnderTest.GetResultSet()[1]["StoredString"]);
Assert.AreEqual("Item 2", resultSetCacheUnderTest.GetResultSet()[2]["StoredString"]);
Assert.AreEqual("Item 3", resultSetCacheUnderTest.GetResultSet()[3]["StoredString"]);
}
public void DeleteItemFromCacheById_ItemNotInRepository_Throws()
{
ResultSetCache <PalasoTestItem> resultSetCacheUnderTest = new ResultSetCache <PalasoTestItem>(dataMapper, _sortDefinitions, _results, _queryToCache);
Assert.Throws <ArgumentOutOfRangeException>(() => resultSetCacheUnderTest.DeleteItemFromCache(RepositoryId.Empty));
}
