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)); }