protected PersistentTcpConnection_Accessor GetConnectionAccessor(PersistentTcpConnection connection)
{
PrivateObject po = new PrivateObject(connection);
PersistentTcpConnection_Accessor accessor = new PersistentTcpConnection_Accessor(po);
return(accessor);
}
public virtual void PortTest()
{
string host = "test";
int expected = 123;
// valid value by constructor
PersistentTcpConnection target = CreateConnection(host, expected);
Assert.AreEqual(expected, target.Port);
expected = 321;
// valid value by property
target.Port = expected;
Assert.AreEqual(expected, target.Port);
// invalid value by constuctor
try
{
target = CreateConnection(host, 0);
Assert.Fail("Constructor must throw ArgumentOutOfRangeException");
}
catch (ArgumentOutOfRangeException)
{
// ArgumentOutOfRangeException has thrown, test passed
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public virtual void ConnectionConstructorTest_IPEndPoint()
{
string host = "1.2.3.4";
int expected = 123;
// valid value by constructor
PersistentTcpConnection target = CreateConnection(new IPEndPoint(new IPAddress(new byte[] { 1, 2, 3, 4 }), expected));
Assert.AreEqual(host, target.Host);
Assert.AreEqual(expected, target.Port);
expected = 321;
// invalid value by constructor
try
{
IPEndPoint adr = null;
CreateConnection(adr);
Assert.Fail("Constructor must throw ArgumentException");
}
catch (ArgumentException)
{
// ArgumentException has thrown, test passed
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public virtual void ConnectToSphinx()
{
using (var connection = new PersistentTcpConnection(TestSettings.Default.Host, TestSettings.Default.Port))
{
connection.Open();
Assert.IsTrue(connection.IsConnected);
connection.Close();
Assert.IsFalse(connection.IsConnected);
}
}
public virtual void SendHandshakeTest()
{
PersistentTcpConnection conn = CreateConnection("test");
try
{
PersistentTcpConnection_Accessor accessor = GetConnectionAccessor(conn);
// assign mock socket and open fake stream
accessor.Socket = new ClientSocketMock();
// underlying socket sholud be already opened
accessor.Socket.Open();
// assign mock binary formatter factory
XmlFormatterFactoryMock factory = new XmlFormatterFactoryMock();
accessor.FormatterFactory = factory;
IBinaryWriter writer = factory.CreateWriter(accessor.DataStream);
// preserialize server protocol version and rewind to start pos. (emulate first stage of handshake procedure)
int protocolVersion = TcpConnection_Accessor.MAJOR_PROTOCOL_VERSION;
writer.Write(protocolVersion);
StreamAdapter_Accessor streamAccessor = GetStreamAccessor((StreamAdapter)accessor.DataStream);
long pos = streamAccessor.Stream.Position;
streamAccessor.Stream.Seek(0, SeekOrigin.Begin);
accessor.SendHandshake();
// restore stream pos
streamAccessor.Stream.Seek(pos, SeekOrigin.Begin);
IBinaryReader reader = factory.CreateReader(accessor.DataStream);
// read client response
int actual = reader.ReadInt32();
Assert.AreEqual(actual, protocolVersion);
// read persistent connection command id and version
ServerCommand id = (ServerCommand)reader.ReadInt16();
Assert.AreEqual(ServerCommand.Persist, id);
short ver = reader.ReadInt16();
Assert.AreEqual(PersistentTcpConnection_Accessor.PERSIST_COMMAND_VERSION, ver);
// read command length & body
int length = reader.ReadInt32();
Assert.AreEqual(sizeof(int), length);
int body = reader.ReadInt32();
Assert.AreEqual(PersistentTcpConnection_Accessor.PERSIST_COMMAND_BODY, body);
}
finally
{
conn.Close();
}
}
public virtual void DisposeTest()
{
PersistentTcpConnection conn = CreateConnection("test");
try
{
GetConnectionAccessor(conn).Socket = new ClientSocketMock();
conn.Open();
Assert.IsTrue(conn.IsConnected);
conn.Dispose();
Assert.IsFalse(conn.IsConnected);
}
finally
{
conn.Close();
}
}
public virtual void DataStreamTest()
{
PersistentTcpConnection conn = CreateConnection("test");
try
{
PersistentTcpConnection_Accessor accessor = GetConnectionAccessor(conn);
accessor.Socket = new ClientSocketMock();
Assert.IsNull(accessor.DataStream);
conn.Open();
Assert.IsNotNull(accessor.DataStream);
}
finally
{
conn.Close();
}
}
public virtual void ConnectionTimeoutTest()
{
PersistentTcpConnection conn = CreateConnection("test");
try
{
PersistentTcpConnection_Accessor accessor = GetConnectionAccessor(conn);
accessor.Socket = new ClientSocketMock();
const int timeout = 100;
conn.ConnectionTimeout = timeout;
Assert.AreEqual(timeout, conn.ConnectionTimeout);
conn.Open();
// wait "timeout" time and give timer little time to set new property value
Thread.Sleep(timeout + 100);
Assert.IsFalse(conn.IsConnected);
}
finally
{
conn.Close();
}
}
public virtual void ConnectionConstructorTest_Host()
{
// valid value using constructor argument
string expected = "localhost";
PersistentTcpConnection target = CreateConnection(expected);
Assert.AreEqual(expected, target.Host);
// invalid value by constructor
try
{
string host = null;
CreateConnection(host);
Assert.Fail("Constructor must throw ArgumentException");
}
catch (ArgumentException)
{
// ArgumentException has thrown, test passed
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
// invalid value by constructor
try
{
string host = String.Empty;
CreateConnection(host);
Assert.Fail("Constructor must throw ArgumentException");
}
catch (ArgumentException)
{
// ArgumentException has thrown, test passed
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public virtual void HostTest()
{
PersistentTcpConnection target = CreateConnection();
// valid value
string expected = "test host name";
target.Host = expected;
Assert.AreEqual(expected, target.Host);
// invalid value
try
{
target.Host = string.Empty;
Assert.Fail("Property setter must throw ArgumentException");
}
catch (ArgumentException)
{
// ArgumentException has thrown, test passed
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public virtual void PerformCommandTest()
{
PersistentTcpConnection conn = CreateConnection("test");
try
{
PersistentTcpConnection_Accessor accessor = GetConnectionAccessor(conn);
// assign mock socket
accessor.Socket = new ClientSocketMock();
accessor.Socket.Open();
XmlFormatterFactoryMock factory = new XmlFormatterFactoryMock();
accessor.FormatterFactory = factory;
IBinaryWriter writer = factory.CreateWriter(accessor.DataStream);
// command id and version
const ServerCommand id = ServerCommand.Status;
const short ver = 1;
MockCommand command = new MockCommand(conn, id, ver);
accessor.PerformCommand(command);
StreamAdapter_Accessor streamAccessor = GetStreamAccessor((StreamAdapter)accessor.DataStream);
streamAccessor.Stream.Seek(0, SeekOrigin.Begin);
IBinaryReader reader = factory.CreateReader(accessor.DataStream);
// read & check data sent by mock command code
ServerCommand actualId = (ServerCommand)reader.ReadInt16();
Assert.AreEqual(id, actualId);
short actualVer = reader.ReadInt16();
Assert.AreEqual(ver, actualVer);
}
finally
{
conn.Close();
}
}
private string DoSearch()
{
// set hostname and port defaults
using (TcpConnection connection = new PersistentTcpConnection(Host, Port))
{
SearchCommand search = new SearchCommand(connection);
SearchQuery query = new SearchQuery(QueryString);
// Sphinx indexes
query.Indexes.UnionWith(Indexes);
// select fields clause
query.Select = SelectFields;
// match type
query.MatchMode = MatchMode;
// ranking
query.RankingMode = RankingMode;
// comment
query.Comment = Comment;
// sorting
query.SortMode = SortMode;
query.SortBy = SortClause;
// limits
query.Limit = query.MaxMatches = MaxMatches;
// document id filtering
query.MinDocumentId = MinDocumentId;
query.MaxDocumentId = MaxDocumentId;
// grouping
query.GroupFunc = GroupFunc;
query.GroupBy = GroupBy;
query.GroupSort = GroupSortBy;
query.GroupDistinct = GroupDistinct;
// index weights
foreach (NameValuePair item in _indexWeights)
{
if (!query.IndexWeights.ContainsKey(item.Name))
{
query.IndexWeights.Add(item.Name, item.Value);
}
}
// fields weights
foreach (NameValuePair item in _fieldWeights)
{
if (!query.FieldWeights.ContainsKey(item.Name))
{
query.FieldWeights.Add(item.Name, item.Value);
}
}
// attribute overrides
foreach (AttributeOverrideMapping item in _attributeOverrides)
{
AttributeOverrideBase attr;
AttributeType type = (AttributeType)item.Type;
if (!query.AttributeOverrides.Contains(item.Name))
{
switch (type)
{
case AttributeType.Integer:
Dictionary <long, int> ints = new Dictionary <long, int>();
ints.Add(item.DocumentId, Convert.ToInt32(item.Value));
attr = new AttributeOverrideInt32(item.Name, ints);
break;
case AttributeType.Bigint:
Dictionary <long, long> longs = new Dictionary <long, long>();
longs.Add(item.DocumentId, Convert.ToInt64(item.Value));
attr = new AttributeOverrideInt64(item.Name, longs);
break;
case AttributeType.Boolean:
Dictionary <long, bool> bools = new Dictionary <long, bool>();
bools.Add(item.DocumentId, Convert.ToBoolean(item.Value));
attr = new AttributeOverrideBoolean(item.Name, bools);
break;
case AttributeType.Float:
Dictionary <long, float> floats = new Dictionary <long, float>();
floats.Add(item.DocumentId, float.Parse(item.Value.ToString()));
attr = new AttributeOverrideFloat(item.Name, floats);
break;
case AttributeType.Ordinal:
Dictionary <long, int> ordinals = new Dictionary <long, int>();
ordinals.Add(item.DocumentId, Convert.ToInt32(item.Value));
attr = new AttributeOverrideOrdinal(item.Name, ordinals);
break;
case AttributeType.Timestamp:
Dictionary <long, DateTime> timestamps = new Dictionary <long, DateTime>();
timestamps.Add(item.DocumentId, Convert.ToDateTime(item.Value));
attr = new AttributeOverrideDateTime(item.Name, timestamps);
break;
default:
throw new InvalidOperationException("Unknown attribute type");
}
query.AttributeOverrides.Add(attr);
}
else
{
attr = query.AttributeOverrides[item.Name];
if (type != attr.AttributeType)
{
throw new InvalidOperationException("Attribute type mismatch");
}
switch (type)
{
case AttributeType.Integer:
((AttributeOverrideInt32)attr).Values.Add(item.DocumentId, Convert.ToInt32(item.Value));
break;
case AttributeType.Bigint:
((AttributeOverrideInt64)attr).Values.Add(item.DocumentId, Convert.ToInt64(item.Value));
break;
case AttributeType.Boolean:
((AttributeOverrideBoolean)attr).Values.Add(item.DocumentId, Convert.ToBoolean(item.Value));
break;
case AttributeType.Float:
((AttributeOverrideFloat)attr).Values.Add(item.DocumentId, float.Parse(item.Value.ToString()));
break;
case AttributeType.Ordinal:
((AttributeOverrideOrdinal)attr).Values.Add(item.DocumentId, Convert.ToInt32(item.Value));
break;
case AttributeType.Timestamp:
((AttributeOverrideDateTime)attr).Values.Add(item.DocumentId, Convert.ToDateTime(item.Value));
break;
default:
throw new InvalidOperationException("Unknown attribute type");
}
}
}
// add new query
search.QueryList.Add(query);
// run the query and get the results
string output = "";
try
{
search.Execute();
}
catch (SphinxException ex)
{
output = "<h2 style='color: red;'>Error is occured:<h2>" + ex.Message;
return(output);
}
if (search.Result.Status == CommandStatus.Warning)
{
output = "<h2 style='color: olive;'>Warnings: </h2><ul>";
foreach (var s in search.Result.Warnings)
{
output += "<li>" + s + "</li>";
}
output += "</ul>";
}
foreach (SearchQueryResult res in search.Result.QueryResults)
{
output += ParseResult(res);
}
return(output);
}
}
