public void SerializeRequestTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
var accessor = GetCommandAccessor(target);
ArrayList values = new ArrayList();
IBinaryWriter writer = new ArrayListWriterMock(values);
accessor.SerializeRequest(writer);
Assert.AreEqual(values.Count, 15);
Assert.AreEqual(values[0], BuildExcerptsCommand_Accessor.MODE);
Assert.AreEqual(values[1], (int)target.Options);
Assert.AreEqual(values[2], target.Index);
// Keywords skipped, will be tested in unit-test for StringList class
Assert.AreEqual(values[4], target.BeforeMatch);
Assert.AreEqual(values[5], target.AfterMatch);
Assert.AreEqual(values[6], target.SnippetsDelimiter);
Assert.AreEqual(values[7], target.SnippetSizeLimit);
Assert.AreEqual(values[8], target.WordsAroundKeyword);
Assert.AreEqual(values[9], target.SnippetsCountLimit);
Assert.AreEqual(values[10], target.WordsCountLimit);
Assert.AreEqual(values[11], target.StartPassageId);
Assert.AreEqual(values[12], target.HtmlStripMode.ToString().ToLowerInvariant());
Assert.AreEqual(values[13], target.PassageBoundary.ToString().ToLowerInvariant());
// Documents skipped, for same reason
}
}
protected BuildExcerptsCommand_Accessor GetCommandAccessor(BuildExcerptsCommand command)
{
PrivateObject po = new PrivateObject(command);
BuildExcerptsCommand_Accessor accessor = new BuildExcerptsCommand_Accessor(po);
return(accessor);
}
public void DocumentsTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
Assert.IsNotNull(target.Documents);
Assert.IsInstanceOfType(target.Documents, typeof(IList <string>));
}
}
public void CommandInfoTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
BuildExcerptsCommand_Accessor accessor = GetCommandAccessor(target);
Assert.IsNotNull(accessor.CommandInfo);
Assert.AreEqual(accessor.CommandInfo.Id, ServerCommand.Excerpt);
Assert.AreEqual(accessor.CommandInfo.Version, BuildExcerptsCommand_Accessor.COMMAND_VERSION);
}
}
public void OptionsTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.Options, BuildExcerptsCommand_Accessor.DEFAULT_OPTIONS);
// valid value
BuildExcerptsOptions expected = BuildExcerptsOptions.OrderByWeight;
target.Options = expected;
Assert.AreEqual(expected, target.Options);
}
}
public void PassageBoundaryTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.PassageBoundary, BuildExcerptsCommand_Accessor.DEFAULT_PASSAGE_BOUNDARY);
// valid value
PassageBoundary expected = PassageBoundary.Paragraph;
target.PassageBoundary = expected;
Assert.AreEqual(expected, target.PassageBoundary);
}
}
public void HtmlStripModeTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.HtmlStripMode, BuildExcerptsCommand_Accessor.DEFAULT_HTML_STRIP_MODE);
// valid value
HtmlStripMode expected = HtmlStripMode.Retain;
target.HtmlStripMode = expected;
Assert.AreEqual(expected, target.HtmlStripMode);
}
}
public void Constructor_PassValidArguments_CopyValues()
{
using (ConnectionBase connection = new ConnectionMock())
{
string[] documents = new string[] { "doc 1", "doc 2", "doc 3" };
string[] keywords = new string[] { "keyword1", "keyword2" };
string index = "test";
BuildExcerptsCommand target = new BuildExcerptsCommand(connection, documents, keywords, index);
target.Documents.Should().Have.SameValuesAs(documents);
target.Keywords.Should().Have.SameValuesAs(keywords);
target.Index.Should().Be.EqualTo(index);
}
}
public void WordsAroundKeywordTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.WordsAroundKeyword, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_AROUND_KEYWORD);
// valid value
int expected = 0;
target.WordsAroundKeyword = expected;
Assert.AreEqual(expected, target.WordsAroundKeyword);
// invalid value
target.WordsAroundKeyword = -1;
}
}
public void IndexTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.Index, null);
// valid value
string expected = "test";
target.Index = expected;
Assert.AreEqual(expected, target.Index);
// invalid value
target.Index = null;
}
}
public void StartPassageIdTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.StartPassageId, BuildExcerptsCommand_Accessor.DEFAULT_START_PASSAGE_ID);
// valid value
int expected = 1;
target.StartPassageId = expected;
Assert.AreEqual(expected, target.StartPassageId);
// valid value
target.StartPassageId = -1;
}
}
public void WordsCountLimitTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.WordsCountLimit, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_COUNT_LIMIT);
// valid value
int expected = 1;
target.WordsCountLimit = expected;
Assert.AreEqual(expected, target.WordsCountLimit);
// invalid value
target.WordsCountLimit = -1;
}
}
public void SnippetsDelimiterTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.SnippetsDelimiter, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPETS_DELIMITER);
// valid value
string expected = String.Empty;
target.SnippetsDelimiter = expected;
Assert.AreEqual(expected, target.SnippetsDelimiter);
// invalid value
target.SnippetsDelimiter = null;
}
}
public void SnippetSizeLimitTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.SnippetSizeLimit, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPET_SIZE_LIMIT);
// valid value
int expected = 1;
target.SnippetSizeLimit = expected;
Assert.AreEqual(expected, target.SnippetSizeLimit);
// invalid value
target.SnippetSizeLimit = 0;
}
}
public void Constructor_PassValidArguments_CopyValues()
{
using (ConnectionBase connection = new ConnectionMock())
{
string[] documents = new string[] { "doc 1", "doc 2", "doc 3" };
string[] keywords = new string[] { "keyword1", "keyword2" };
string index = "test";
BuildExcerptsCommand target = new BuildExcerptsCommand(connection, documents, keywords, index);
target.Documents.Should().Have.SameValuesAs(documents);
target.Keywords.Should().Have.SameValuesAs(keywords);
target.Index.Should().Be.EqualTo(index);
}
}
public void BeforeMatchTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.BeforeMatch, BuildExcerptsCommand_Accessor.DEFAULT_BEFORE_MATCH);
// valid value
string expected = "<pre>";
target.BeforeMatch = expected;
target.BeforeMatch.Should().Be.EqualTo(expected);
// invalid value
target.BeforeMatch = null;
}
}
public void AfterMatchTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.AfterMatch, BuildExcerptsCommand_Accessor.DEFAULT_AFTER_MATCH);
// valid value
string expected = "</pre>";
target.AfterMatch = expected;
string actual = target.AfterMatch;
Assert.AreEqual(expected, actual);
// invalid value
target.AfterMatch = null;
}
}
public void ExecuteTest_EmptyIndex_ThrowsException()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
connection.SkipHandshake = true;
connection.SkipDeserializeCommand = true;
connection.SkipSerializeCommand = true;
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
target.Documents.Add("test doc content");
target.Keywords.Add("test");
Executing.This(target.Execute).Should().Throw <ArgumentException>();
target.Index = "test";
Executing.This(target.Execute).Should().NotThrow();
}
}
public void DeserializeResponseTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
bool deserializeCalled = false;
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
var accessor = GetCommandAccessor(target);
IBinaryReader arrayReader = new ArrayListReaderMock(new ArrayList());
accessor.Result = new MBuildExcerptsCommandResult
{
DeserializeIBinaryReaderInt32 = (reader, count) => { deserializeCalled = (reader == arrayReader && count == 1); }
};
target.Documents.Add("test");
accessor.DeserializeResponse(arrayReader);
Assert.IsTrue(deserializeCalled);
}
}
public void PassageBoundaryTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.PassageBoundary, BuildExcerptsCommand_Accessor.DEFAULT_PASSAGE_BOUNDARY);
// valid value
PassageBoundary expected = PassageBoundary.Paragraph;
target.PassageBoundary = expected;
Assert.AreEqual(expected, target.PassageBoundary);
}
}
public void DeserializeResponseTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
bool deserializeCalled = false;
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
var accessor = GetCommandAccessor(target);
IBinaryReader arrayReader = new ArrayListReaderMock(new ArrayList());
accessor.Result = new MBuildExcerptsCommandResult
{
DeserializeIBinaryReaderInt32 = (reader, count) => { deserializeCalled = (reader == arrayReader && count == 1); }
};
target.Documents.Add("test");
accessor.DeserializeResponse(arrayReader);
Assert.IsTrue(deserializeCalled);
}
}
protected BuildExcerptsCommand_Accessor GetCommandAccessor(BuildExcerptsCommand command)
{
PrivateObject po = new PrivateObject(command);
BuildExcerptsCommand_Accessor accessor = new BuildExcerptsCommand_Accessor(po);
return accessor;
}
public void ExecuteTest_EmptyIndex_ThrowsException()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
connection.SkipHandshake = true;
connection.SkipDeserializeCommand = true;
connection.SkipSerializeCommand = true;
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
target.Documents.Add("test doc content");
target.Keywords.Add("test");
Executing.This(target.Execute).Should().Throw<ArgumentException>();
target.Index = "test";
Executing.This(target.Execute).Should().NotThrow();
}
}
public void SerializeRequestTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
var accessor = GetCommandAccessor(target);
ArrayList values = new ArrayList();
IBinaryWriter writer = new ArrayListWriterMock(values);
accessor.SerializeRequest(writer);
Assert.AreEqual(values.Count, 15);
Assert.AreEqual(values[0], BuildExcerptsCommand_Accessor.MODE);
Assert.AreEqual(values[1], (int)target.Options);
Assert.AreEqual(values[2], target.Index);
// Keywords skipped, will be tested in unit-test for StringList class
Assert.AreEqual(values[4], target.BeforeMatch);
Assert.AreEqual(values[5], target.AfterMatch);
Assert.AreEqual(values[6], target.SnippetsDelimiter);
Assert.AreEqual(values[7], target.SnippetSizeLimit);
Assert.AreEqual(values[8], target.WordsAroundKeyword);
Assert.AreEqual(values[9], target.SnippetsCountLimit);
Assert.AreEqual(values[10], target.WordsCountLimit);
Assert.AreEqual(values[11], target.StartPassageId);
Assert.AreEqual(values[12], target.HtmlStripMode.ToString().ToLowerInvariant());
Assert.AreEqual(values[13], target.PassageBoundary.ToString().ToLowerInvariant());
// Documents skipped, for same reason
}
}
public void DocumentsTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
Assert.IsNotNull(target.Documents);
Assert.IsInstanceOfType(target.Documents, typeof (IList<string>));
}
}
public void CommandInfoTest()
{
using (ConnectionMock connection = new ConnectionMock("test"))
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
BuildExcerptsCommand_Accessor accessor = GetCommandAccessor(target);
Assert.IsNotNull(accessor.CommandInfo);
Assert.AreEqual(accessor.CommandInfo.Id, ServerCommand.Excerpt);
Assert.AreEqual(accessor.CommandInfo.Version, BuildExcerptsCommand_Accessor.COMMAND_VERSION);
}
}
public void OptionsTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.Options, BuildExcerptsCommand_Accessor.DEFAULT_OPTIONS);
// valid value
BuildExcerptsOptions expected = BuildExcerptsOptions.OrderByWeight;
target.Options = expected;
Assert.AreEqual(expected, target.Options);
}
}
public void IndexTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.Index, null);
// valid value
string expected = "test";
target.Index = expected;
Assert.AreEqual(expected, target.Index);
// invalid value
target.Index = null;
}
}
public void HtmlStripModeTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.HtmlStripMode, BuildExcerptsCommand_Accessor.DEFAULT_HTML_STRIP_MODE);
// valid value
HtmlStripMode expected = HtmlStripMode.Retain;
target.HtmlStripMode = expected;
Assert.AreEqual(expected, target.HtmlStripMode);
}
}
public void BeforeMatchTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.BeforeMatch, BuildExcerptsCommand_Accessor.DEFAULT_BEFORE_MATCH);
// valid value
string expected = "<pre>";
target.BeforeMatch = expected;
target.BeforeMatch.Should().Be.EqualTo(expected);
// invalid value
target.BeforeMatch = null;
}
}
public void StartPassageIdTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.StartPassageId, BuildExcerptsCommand_Accessor.DEFAULT_START_PASSAGE_ID);
// valid value
int expected = 1;
target.StartPassageId = expected;
Assert.AreEqual(expected, target.StartPassageId);
// valid value
target.StartPassageId = -1;
}
}
public void WordsCountLimitTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.WordsCountLimit, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_COUNT_LIMIT);
// valid value
int expected = 1;
target.WordsCountLimit = expected;
Assert.AreEqual(expected, target.WordsCountLimit);
// invalid value
target.WordsCountLimit = -1;
}
}
public void SnippetsDelimiterTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.SnippetsDelimiter, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPETS_DELIMITER);
// valid value
string expected = String.Empty;
target.SnippetsDelimiter = expected;
Assert.AreEqual(expected, target.SnippetsDelimiter);
// invalid value
target.SnippetsDelimiter = null;
}
}
public void SnippetSizeLimitTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.SnippetSizeLimit, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPET_SIZE_LIMIT);
// valid value
int expected = 1;
target.SnippetSizeLimit = expected;
Assert.AreEqual(expected, target.SnippetSizeLimit);
// invalid value
target.SnippetSizeLimit = 0;
}
}
public void WordsAroundKeywordTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.WordsAroundKeyword, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_AROUND_KEYWORD);
// valid value
int expected = 0;
target.WordsAroundKeyword = expected;
Assert.AreEqual(expected, target.WordsAroundKeyword);
// invalid value
target.WordsAroundKeyword = -1;
}
}
private IEnumerable<SphinxDocumentAnnounce> GetSphinxSearchResults(string q, string[] indexes = null)
{
if (string.IsNullOrEmpty(q))
return new SphinxDocumentAnnounce[0];
using (ConnectionBase connection = new PersistentTcpConnection(MeridianMonitor.Default.SphinxHost, MeridianMonitor.Default.SphinxPort))
{
q = q.Replace(" -", "¦").Replace("-", " ").Replace("¦", " -").Replace("!", "\\!").Replace("?", "\\?").Replace("@", "\\@");
if (q.LastIndexOf('-') == (q.Length - 1))
{
q = q.Substring(0, q.LastIndexOf('-') - 1).Trim();
}
q = string.Join(" ", q.Split(' ').Select(s => s.Trim()));
// Create new search query object and pass query text as argument
SearchQuery searchQuery = new SearchQuery(q);
// Set match mode to SPH_MATCH_EXTENDED2
searchQuery.MatchMode = MatchMode.All;
string[] protos = indexes ?? new string[]
{
typeof(hotels).Name,
//typeof(countries).Name,
typeof(deseases).Name,
typeof(cure_profiles).Name,
typeof(health_factors).Name,
//typeof(regions).Name,
//typeof(resort_zones).Name,
typeof(resorts).Name,
typeof(treatment_options).Name,
"static_pages",
typeof(dictionary).Name
};
var byIndexResults = new Dictionary<string, List<SphinxDocumentAnnounce>>();
foreach (var protoIndex in protos)
{
searchQuery.Indexes.Add(protoIndex);
byIndexResults[protoIndex] = new List<SphinxDocumentAnnounce>();
}
searchQuery.Limit = 5000;
SearchCommand searchCommand = new SearchCommand(connection);
searchCommand.QueryList.Add(searchQuery);
searchCommand.Execute();
var pubResult = new List<SphinxDocumentAnnounce>();
foreach (SearchQueryResult result in searchCommand.Result.QueryResults)
{
foreach (var match in result.Matches)
{
var otype = match.AttributesValues["objecttype"].GetValue().ToString().Trim();
var entityId = Convert.ToInt64(match.AttributesValues["entityid"].GetValue());
var documentId = new DocumentId(entityId);
if (match.AttributesValues.Contains("fieldsetid"))
documentId = new DocumentId(entityId,
Convert.ToInt64(match.AttributesValues["fieldsetid"].GetValue()));
if (!Meridian.Default.Exists(otype, entityId))
continue;
var entity = Meridian.Default.GetAs<ISphinxExportableEntity>(otype, entityId);
var document = entity.GetDocumentById(documentId);
if (document != null)
{
var item = new SphinxDocumentAnnounce(document.GetTitle(), document.GetBody(), document.GetUrl());
pubResult.Add(item);
byIndexResults[otype].Add(item);
}
}
}
var itemsArray = pubResult.ToArray();
var querySplit = q.Split(' ');
foreach (var protoIndex in protos)
{
var items = byIndexResults[protoIndex];
if (items.Count == 0)
continue;
BuildExcerptsCommand excerptsCommand = new BuildExcerptsCommand(connection,
items.Select(s => s.GetBody()), querySplit, protoIndex);
excerptsCommand.Execute();
var index = 0;
foreach (var result in excerptsCommand.Result.Excerpts)
{
var item = items[index++];
item.SetBody(result);
}
}
return itemsArray;
}
}
public void AfterMatchTest()
{
using (ConnectionBase connection = new ConnectionMock())
{
BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
// default value
Assert.AreEqual(target.AfterMatch, BuildExcerptsCommand_Accessor.DEFAULT_AFTER_MATCH);
// valid value
string expected = "</pre>";
target.AfterMatch = expected;
string actual = target.AfterMatch;
Assert.AreEqual(expected, actual);
// invalid value
target.AfterMatch = null;
}
}
