public void AddItemsWhenOccurExceptionPasses()
{
var helper = new HashSetHelper <int>();
var recievedList = new List <int>();
var counter = 0;
helper.OnAdded.Add((v) => {
if (v % 2 == 0)
{
throw new System.Exception();
}
recievedList.Add(v); counter++;
});
var testData = Enumerable.Range(0, 10);
Assert.DoesNotThrow(() => {
helper.Add(testData);
});
Assert.AreEqual(testData.Count() / 2, counter);
AssertionUtils.AssertEnumerableByUnordered(
testData.Where(_v => _v % 2 != 0),
recievedList,
""
);
AssertionUtils.AssertEnumerableByUnordered(
testData,
helper.Items,
""
);
}
/// <summary>
/// Used to fill the cache with an array of
/// All keywords are stored lowercase
/// </summary>
/// <returns></returns>
public async Task <List <KeyValuePair <string, int> > > Inflate()
{
if (_cache.TryGetValue(nameof(SearchSuggestionsService), out _))
{
return(new Dictionary <string, int>().ToList());
}
var allFilesList = new List <KeyValuePair <string, int> >();
try
{
allFilesList = await _context.FileIndex.GroupBy(i => i.Tags)
// ReSharper disable once UseMethodAny.1
.Where(x => x.Count() >= 1) // .ANY is not supported by EF Core
.TagWith("Inflate SearchSuggestionsService")
.Select(val => new KeyValuePair <string, int>(val.Key, val.Count())).ToListAsync();
}
catch (Exception exception)
{
if (!exception.Message.Contains("Unknown column"))
{
_logger.LogError(exception, "mysql search suggest exception catch-ed");
}
return(allFilesList);
}
var suggestions = new Dictionary <string, int>(StringComparer.InvariantCultureIgnoreCase);
foreach (var tag in allFilesList)
{
if (string.IsNullOrEmpty(tag.Key))
{
continue;
}
var keywordsHashSet = HashSetHelper.StringToHashSet(tag.Key.Trim());
foreach (var keyword in keywordsHashSet)
{
if (suggestions.ContainsKey(keyword))
{
suggestions[keyword] += tag.Value;
}
else
{
suggestions.Add(keyword, tag.Value);
}
}
}
var suggestionsFiltered = suggestions
.Where(p => p.Value >= 10)
.OrderByDescending(p => p.Value)
.ToList();
_cache.Set(nameof(SearchSuggestionsService), suggestionsFiltered,
new TimeSpan(100, 0, 0));
return(suggestionsFiltered);
}
public void OnRemovedInRemovePasses()
{
var helper = new HashSetHelper <int>();
var counter = 0;
var recievedValue = 0;
helper.OnRemoved.Add((v) => { counter++; recievedValue = v; });
var testData = new int[] {
100, 200
};
foreach (var d in testData)
{
helper.Add(d);
}
Assert.AreEqual(0, counter);
helper.Remove(testData[0]);
Assert.AreEqual(1, counter);
Assert.AreEqual(testData[0], recievedValue);
counter = 0;
helper.Remove(testData[1]);
Assert.AreEqual(1, counter);
Assert.AreEqual(testData[1], recievedValue);
}
public void OnRemovedInRemoveItemsPasses()
{
var helper = new HashSetHelper <int>();
var recievedList = new List <int>();
var counter = 0;
helper.OnRemoved.Add((v) => { recievedList.Add(v); counter++; });
var testData = Enumerable.Range(0, 10);
helper.Add(testData);
helper.Remove(testData.Where(_v => _v % 2 == 0));
Assert.AreEqual(testData.Count() / 2, counter);
AssertionUtils.AssertEnumerableByUnordered(
testData.Where(_v => _v % 2 == 0),
recievedList,
""
);
AssertionUtils.AssertEnumerableByUnordered(
testData.Where(_v => _v % 2 != 0),
helper.Items,
""
);
}
public void RemovePasses()
{
var helper = new HashSetHelper <int>();
var testData = new int[] {
100, 200
};
foreach (var d in testData)
{
helper.Add(d);
}
helper.Remove(testData[0]);
AssertionUtils.AssertEnumerableByUnordered(
new int[] { testData[1] }
, helper.Items
, ""
);
helper.Remove(testData[1]);
AssertionUtils.AssertEnumerableByUnordered(
new int[] { }
, helper.Items
, ""
);
}
public void HashSetHelperTest_HashSetSingleComma()
{
// testing with double commas those are not supported by the c# exif read tool
var result = HashSetHelper.StringToHashSet("test,test1");
var expetedresult = HashSetHelper.HashSetToString(result);
Assert.AreEqual("test, test1", expetedresult);
}
public void ClearWhenEmptyPasses()
{
var helper = new HashSetHelper <int>();
Assert.DoesNotThrow(() => {
helper.Clear();
});
}
public void HashSetHelperTest_HashSetDuplicateContent()
{
// hashsets does not support duplicates, but test the comma implementation
var result = HashSetHelper.StringToHashSet("test, test");
var expetedresult = HashSetHelper.HashSetToString(result);
Assert.AreEqual("test", expetedresult);
}
public void AddWhenNullPasses()
{
var helper = new HashSetHelper <string>();
Assert.DoesNotThrow(() => {
helper.Add(default(string));
});
Assert.AreEqual(0, helper.Count);
}
public void OnClearedInClearWhenEmptyPasses()
{
var helper = new HashSetHelper <int>();
var counter = 0;
helper.OnCleared.Add(() => counter++);
helper.Clear();
Assert.AreEqual(0, counter);
}
public void OnRemovedInClearWhenEmptyPasses()
{
var helper = new HashSetHelper <int>();
var counter = 0;
var recievedValue = new List <int>();
helper.OnRemoved.Add((v) => { counter++; recievedValue.Add(v); });
Assert.AreEqual(0, counter);
Assert.IsFalse(recievedValue.Any());
}
public void HashSetHelperTest_DoubleSpaces()
{
var hashSetResult = HashSetHelper.StringToHashSet("test0, test1 , test2, test3");
Assert.AreEqual(4, hashSetResult.Count);
Assert.AreEqual("test0", hashSetResult.ToList()[0]);
Assert.AreEqual("test1", hashSetResult.ToList()[1]);
Assert.AreEqual("test2", hashSetResult.ToList()[2]);
Assert.AreEqual("test3", hashSetResult.ToList()[3]);
}
public void OnChangedCountInClearNotRemovePasses()
{
var helper = new HashSetHelper <int>();
var isCall = false;
helper.OnChangedCount.Add((_helper, _count) => {
isCall = true;
});
helper.Clear();
Assert.IsFalse(isCall);
}
public void AddWhenContainsPasses()
{
var helper = new HashSetHelper <int>();
var value = 100;
helper.Add(value);
Assert.DoesNotThrow(() => {
helper.Add(value);
});
Assert.IsTrue(helper.Contains(value));
Assert.AreEqual(1, helper.Count);
}
public void OnRemovedWhenNotContainsPasses()
{
var helper = new HashSetHelper <int>();
var counter = 0;
var recievedValue = 0;
helper.OnRemoved.Add((v) => { counter++; recievedValue = v; });
Assert.AreEqual(0, counter);
helper.Remove(123);
Assert.AreEqual(0, counter);
Assert.AreEqual(0, recievedValue);
}
public void OnAddedInAddWhenNotAddPasses()
{
var helper = new HashSetHelper <string>();
var counter = 0;
var recievedValue = "";
helper.OnAdded.Add((v) => { recievedValue = v; counter++; });
helper.Add(default(string));
Assert.AreEqual("", recievedValue);
Assert.AreEqual(0, counter);
}
public void GetEnumeratorPasses()
{
var helper = new HashSetHelper <int>();
var testData = new int[] { 10, 20, 40 };
helper.Add(testData);
AssertionUtils.AssertEnumerableByUnordered(
testData,
helper,
""
);
}
public void OnChangedCountInRemoveItemsNotRemovePasses()
{
var helper = new HashSetHelper <int>();
var isCall = false;
helper.OnChangedCount.Add((_helper, _count) => {
isCall = true;
});
var testData = new int[] { 1, 2, 3 };
helper.Remove(testData);
Assert.IsFalse(isCall);
}
public void RemoveItemsPasses()
{
var helper = new HashSetHelper <int>();
var testData = Enumerable.Range(0, 10);
helper.Add(testData);
helper.Remove(testData);
AssertionUtils.AssertEnumerableByUnordered(
new int[] { },
helper.Items,
""
);
}
public void OnRemovedInRemoveWhenOccurExceptionPasses()
{
var helper = new HashSetHelper <int>();
helper.OnRemoved.Add((v) => {
throw new System.Exception();
});
var value = 100;
helper.Add(value);
Assert.DoesNotThrow(() => {
helper.Remove(value);
});
}
public void OnAddedInAddWhenOccurExceptionPasses()
{
var helper = new HashSetHelper <int>();
helper.OnAdded.Add((v) => {
throw new System.Exception();
});
Assert.DoesNotThrow(() => {
int value = 100;
helper.Add(value);
Assert.IsTrue(helper.Contains(value));
Assert.AreEqual(1, helper.Count);
});
}
public void OnChangedCountInRemoveNotRemovePasses()
{
var helper = new HashSetHelper <int>();
helper.Add(1, 2, 4);
bool isCall = false;
helper.OnChangedCount.Add((_helper, _count) => {
isCall = true;
});
helper.Remove(1000);
Assert.IsFalse(isCall);
}
public void OnAddedInAddPasses()
{
var helper = new HashSetHelper <int>();
var counter = 0;
var recievedValue = 0;
helper.OnAdded.Add((v) => { recievedValue = v; counter++; });
var value = 100;
helper.Add(value);
Assert.AreEqual(value, recievedValue);
Assert.AreEqual(1, counter);
}
public void ContainsPasses()
{
var helper = new HashSetHelper <int>();
var value = 100;
helper.Add(value);
Assert.IsTrue(helper.Contains(value));
helper.Remove(value);
Assert.IsFalse(helper.Contains(value));
helper.Add(value);
Assert.IsTrue(helper.Contains(value));
}
public void OnChangedCountInAddNotAddPasses()
{
var helper = new HashSetHelper <int>();
var value = 1;
helper.Add(value);
var isCall = false;
helper.OnChangedCount.Add((_helper, _count) => {
isCall = true;
});
helper.Add(value);
Assert.IsFalse(isCall);
}
public void OnChangedCountInAddItemsPasses()
{
var helper = new HashSetHelper <int>();
var recievedData = (self : (IReadOnlyHashSetHelper <int>)null, count : (int)0);
helper.OnChangedCount.Add((_helper, _count) => {
recievedData.self = _helper;
recievedData.count = _count;
});
var testData = new int[] { 1, 2, 3 };
helper.Add(testData);
Assert.AreEqual(helper, recievedData.self);
Assert.AreEqual(helper.Count, recievedData.count);
}
public void AddPasses()
{
var helper = new HashSetHelper <int>();
var value = 100;
helper.Add(value);
Assert.IsTrue(helper.Contains(value));
Assert.AreEqual(1, helper.Count);
var value2 = 101;
helper.Add(value2);
Assert.IsTrue(helper.Contains(value2));
Assert.AreEqual(2, helper.Count);
}
public void ClearPasses()
{
var helper = new HashSetHelper <int>();
var testData = new int[] {
0, 1, 2, 3, 4
};
foreach (var d in testData)
{
helper.Add(d);
}
helper.Clear();
Assert.AreEqual(0, helper.Count);
}
public void OnChangedCountInAddPasses()
{
var helper = new HashSetHelper <int>();
var callCounter = 0;
var recievedData = (self : (IReadOnlyHashSetHelper <int>)null, count : (int)0);
helper.OnChangedCount.Add((_helper, _count) => {
callCounter++;
recievedData.self = _helper;
recievedData.count = _count;
});
helper.Add(1);
Assert.AreEqual(1, callCounter);
Assert.AreEqual(helper, recievedData.self);
Assert.AreEqual(helper.Count, recievedData.count);
}
public void OnChangedCountInClearWhenOccurExceptionPasses()
{
var helper = new HashSetHelper <int>();
helper.Add(1, 2, 3);
helper.OnChangedCount.Add((_helper, _count) => {
throw new System.NotImplementedException();
});
helper.Clear();
AssertionUtils.AssertEnumerableByUnordered(
new int[] { },
helper.Items,
""
);
}
public void CanSerializeAndDeserializeHashSet()
{
var obj = new HashSetHelper {Property = new HashSet<string> {"test1", "test2"}};
var bson = Serialize<HashSetHelper>(obj);
var prop = Deserialize<HashSetHelper>(bson);
Assert.IsNotNull(prop);
Assert.IsNotNull(prop.Property);
Assert.AreEqual(2, prop.Property.Count);
Assert.IsTrue(prop.Property.Contains("test1"));
Assert.IsTrue(prop.Property.Contains("test2"));
}
