public void StringKeywordSuggestion_SetRelevanceMoreThan100_ExpectException()
{
var sut = new StringKeywordSuggestion("some_word", Guid.NewGuid());
sut.Relevance = 100;
Assert.That(sut.Relevance, Is.EqualTo(100));
sut.Relevance = 100.01;
}
public void StringKeywordSuggestion_loadFromSource_ValidSourceName()
{
var guidValue = Guid.NewGuid();
var sourceName = "TestSourceName";
var sut = new StringKeywordSuggestion("someKWValue", guidValue, sourceName);
var sut1 = new StringKeywordSuggestion("someKWValue", guidValue);
Assert.That(sut.SourceGuid, Is.EqualTo(guidValue));
Assert.That(sut.SourceName, Is.EqualTo(sourceName));
Assert.That(sut1.SourceGuid, Is.EqualTo(guidValue));
Assert.That(sut1.SourceName, Is.EqualTo(guidValue.ToString()));
}
/// <summary>
/// Returns suggestions implementing
/// </summary>
/// <param name="keys">Keyword value </param>
/// <returns>LIst of suggestions of <see cref="ISuggestionSource"/> type</returns>
public ISuggestionInstance[] GetSuggestions(params ISemanticObject[] keys)
{
Dictionary<string, StringKeywordSuggestion> WrappedSuggestions = new Dictionary<string, StringKeywordSuggestion>();
foreach (var nextKey in keys)
{
foreach (var nextSynonym in this.storage.GetSynonyms(nextKey.GetLiteralValue()))
{
if (WrappedSuggestions.ContainsKey(nextSynonym.Keyword))
{
var oldValue = WrappedSuggestions[nextSynonym.Keyword];
oldValue.Rank = oldValue.Rank + nextSynonym.Rating;
}
else
{
var newSynonym = new StringKeywordSuggestion(nextSynonym.Keyword, this.id, this.name);
newSynonym.Rank = nextSynonym.Rating;
WrappedSuggestions.Add(nextSynonym.Keyword, newSynonym);
}
}
}
var readyArray = WrappedSuggestions.Values.ToArray<ISuggestionInstance>().CalculateRelevanceBasedOnRank();
return readyArray.ToArray();
}
/// <summary>
/// Return suggestions based on one string value keyword
/// </summary>
/// <param name="keys">Keyword(s) to find recommendations to</param>
/// <returns>
/// Array of found suggestions based on one keyword
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
public ISuggestionInstance[] GetSuggestions(params ISemanticObject[] keys)
{
var keyValues = keys.Select(k => k.GetLiteralValue());
ISuggestionInstance[] Suggestions;
try
{
this.ctx.Database.Connection.Open();
// Had to go to RAW since Compact sql does not offer stored procedures
// AND can't throws not supported operation on count and grouping works way to slow.
// With normal (not compact) sql versions should be possible to go with normal queries like
// var contentThatHasOurKeywords = this.ctx.ContentData.Where(c => keyValues.Intersect(c.Keywords.Select(k => k.Name)).Count() > 0).Take(this.datasetLimit);
// var AllKeywordsFromContent = contentThatHasOurKeywords.SelectMany(c => c.Keywords).GroupBy(c => c.Name);
// var AllKeywordsWithRaitings = AllKeywordsFromContent.Select(k => new
// {
// Keyword = k.Name,
// Rating = AllKeywordsFromContent.Where(kk => kk.Name.Equals(k.Name)).Count()
// }).OrderByDescending(r => r.Raiting);
//
// Original Sql query:
// select top 150 kw.name, count(kw.ID) as relevance
// from dbo.Keywords as kw
// join dbo.[ContentDataKeywords] as t on kw.ID = t.[KeywordsID]
// where (t.[ContentDataID] in (
// select top 5000 tIN.ContentDataID
// from dbo.Keywords as kwIN
// join dbo.[ContentDataKeywords] as tIN on kwIN.ID=tIN.[KeywordsID]
// where kwIN.name='girl' or kwIN.name='park'
// ) and kw.name != 'girl' and kw.name != 'park')
// group by kw.name
// order by count(kw.ID) DESC
var manualQuery = string.Format(@"select top {1} kw.name, count(kw.ID) as Relevance
from Keywords as kw
join [ContentDataKeywords] as t on kw.ID = t.[KeywordsID]
where (t.[ContentDataID] in (
select top {0} tIN.ContentDataID
from Keywords as kwIN
join[ContentDataKeywords] as tIN on kwIN.ID = tIN.[KeywordsID]
where kwIN.name = {2}
) and kw.name != {3})
group by kw.name
order by relevance DESC", this.datasetLimit, KeywordsCount,
string.Join(" or kwIN.name= ", keys.Select(k => string.Format("'{0}'", k.GetLiteralValue()))),
string.Join(" and kw.name != ", keys.Select(k => string.Format("'{0}'", k.GetLiteralValue())))
);
var solutions = this.ctx.Database.SqlQuery<DbResultKwNameWithRelevance>(manualQuery).ToList();
Suggestions = new ISuggestionInstance[solutions.Count];
for (var i = 0; i < solutions.Count; i++)
{
Suggestions[i] = new StringKeywordSuggestion(solutions[i].Name.ToString(), this.Guid, this.name);
Suggestions[i].Rank = solutions[i].Relevance;
}
}
catch (Exception ex)
{
throw new Exception("Database error", ex);
}
finally
{
if (this.ctx != null && this.ctx.Database != null & this.ctx.Database.Connection != null)
{
this.ctx.Database.Connection.Close();
}
}
return Suggestions;
}
public void StringKeywordSuggestion_trytosetrelevanceTooBig_expectExceptions()
{
var sut = new StringKeywordSuggestion("some value", Guid.NewGuid());
sut.Relevance = 100.00001;
}
public void StringKeywordSuggestion_SetRaitingLessThanZero_ExpectException()
{
var sut = new StringKeywordSuggestion("some_word", Guid.NewGuid());
sut.Rank = -0.01;
}
public void StringKeywordSuggestion_SetNoName_ValidateThatNameTakenFromGuid()
{
var sut = new StringKeywordSuggestion("some_word", Guid.NewGuid());
Assert.That(sut.SourceGuid.ToString(), Is.EqualTo(sut.SourceName));
}
public void StringKeywordSuggestion_SetName_CheckThatNameTakenIsNameAndDiffirent()
{
var sut = new StringKeywordSuggestion("some_word", Guid.NewGuid(), "sourcename");
Assert.That(sut.SourceName.ToString(), Is.EqualTo("sourcename"));
Assert.That(sut.SourceGuid.ToString(), Is.Not.EqualTo(sut.SourceName));
}
public void StringKeywordSuggestion_ConstructorWithEmptyStringValue_ExpectException()
{
var sut = new StringKeywordSuggestion(string.Empty, Guid.NewGuid());
}
