public void ShouldCreateSessionRunNoThrow()
{
ProtocolObjectFactory.ObjManager = new ProtocolObjectManager();
var newObject = ProtocolObjectFactory.CreateObject(Protocol.Types.SessionRun);
newObject.Should().BeOfType <SessionRun>();
}
public void CallMessageFromCallBuilder()
{
var p = new ProtocolObjectFactory();
byte[] buffer;
using (var s = new MemoryStream())
{
var call = new RpcCallParameters();
call.ServiceName = this.serviceName;
call.MethodName = this.methodName;
call.IsAsync = this.isAsync;
call.ObjectId = this.objectId;
call.CallData = this.callData;
var c = p.BuildCall(call);
p.WriteMessage(s, this.requestId, c, null);
buffer = s.ToArray();
}
using (var s = new MemoryStream(buffer))
{
var message = p.RpcMessageFromStream(s);
Assert.That(s.Position, Is.EqualTo(s.Length));
Assert.That(message.RequestId, Is.EqualTo(this.requestId));
Assert.That(message.Call, Is.Not.Null);
Assert.That(message.Result, Is.Null);
Assert.That(message.Call.ObjectId, Is.EqualTo(this.objectId));
Assert.That(message.Call.ServiceName, Is.EqualTo(this.serviceName));
Assert.That(message.Call.MethodName, Is.EqualTo(this.methodName));
Assert.That(message.Call.IsAsync, Is.EqualTo(this.isAsync));
Assert.That(message.Call.CallData, Is.EquivalentTo(this.callData));
}
}
public void ShouldCreateAuthorizationTokenNoThrow()
{
ProtocolObjectFactory.ObjManager = new ProtocolObjectManager();
var newObject = ProtocolObjectFactory.CreateObject(Protocol.Types.AuthorizationToken);
newObject.Should().BeOfType <AuthorizationToken>();
}
public void MessageWithUninitializedCall()
{
var p = new ProtocolObjectFactory();
byte[] buffer;
using (var s = new MemoryStream())
{
var call = p.BuildCall(new RpcCallParameters());
p.WriteMessage(s, this.requestId, call, null);
buffer = s.ToArray();
}
using (var s = new MemoryStream(buffer))
{
var message = p.RpcMessageFromStream(s);
Assert.That(message.RequestId, Is.EqualTo(this.requestId));
Assert.That(message.Call, Is.Not.Null);
Assert.That(message.Result, Is.Null);
Assert.That(s.Position, Is.EqualTo(s.Length));
Assert.That(0, Is.EqualTo(message.Call.ObjectId));
Assert.That(message.Call.ServiceName, Is.Empty);
Assert.That(message.Call.MethodName, Is.Empty);
Assert.That(message.Call.IsAsync, Is.False);
Assert.That(message.Call.ObjectId, Is.EqualTo(0));
Assert.That(message.Call.CallData, Is.Empty);
}
}
public void ShouldProcessTestsObjectNoThrow(string jsonString)
{
var moqMemoryStream = new Mock <MemoryStream>();
moqMemoryStream.Setup(x => x.CanRead).Returns(true);
var moqReader = new Mock <Reader>(moqMemoryStream.Object);
var objFactory = new ProtocolObjectFactory(new ProtocolObjectManager());
var requestReader = new RequestReader(moqReader.Object, objFactory);
requestReader.CurrentObjectData = jsonString;
var createdObject = requestReader.CreateObjectFromData();
}
public void CallBuilderDefaults()
{
var p = new ProtocolObjectFactory();
var c = new RpcCallParameters();
Assert.That(c, Is.Not.Null);
Assert.That(c.ServiceName, Is.Null);
Assert.That(c.MethodName, Is.Null);
Assert.That(c.IsAsync, Is.False);
Assert.That(c.ObjectId, Is.EqualTo(0));
Assert.That(c.CallData, Is.Null);
}
public void RpcCallDefaults()
{
var p = new ProtocolObjectFactory();
var c = p.CreateRpcCall();
Assert.That(c, Is.Not.Null);
Assert.That(c.ServiceName, Is.Null);
Assert.That(c.MethodName, Is.Null);
Assert.That(c.IsAsync, Is.False);
Assert.That(c.ObjectId, Is.EqualTo(0));
Assert.That(c.CallData, Is.Null);
}
//[InlineData(Protocol.Types.ResultNext)]
//[InlineData(Protocol.Types.SessionRun)]
//[InlineData(Protocol.Types.TransactionRun)] //TODO... need to reimplement these.
public void ShouldWriteValidResponse(Protocol.Types objectType)
{
var moqStream = new Mock <Stream>();
moqStream.Setup(x => x.CanWrite).Returns(true);
var moqWriter = new Mock <Writer>(moqStream.Object);
var responseWriter = new ResponseWriter(moqWriter.Object);
var objFactory = new ProtocolObjectFactory(new ProtocolObjectManager());
IProtocolObject protocolObject = objFactory.CreateObject(objectType);
var resultString = responseWriter.WriteResponse(protocolObject);
resultString.Should().Be("#response begin\n" + protocolObject.Response() + "\n#response end");
}
public void ShouldCreateMultipleDriverObjectsNoThrow()
{
const int count = 2;
var objManager = new ProtocolObjectManager();
for (int i = 0; i < count; i++)
{
ProtocolObjectFactory.ObjManager = objManager;
var newObject = ProtocolObjectFactory.CreateObject(Protocol.Types.NewDriver);
newObject.Should().BeOfType <NewDriver>();
var newDriver = (NewDriver)newObject;
newDriver.uniqueId.Should().Be(i.ToString());
}
objManager.ObjectCount.Should().Be(count);
}
public void CallBuilderProperties()
{
var p = new ProtocolObjectFactory();
var c = new RpcCallParameters();
Assume.That(c, Is.Not.Null);
c.ServiceName = this.serviceName;
c.MethodName = this.methodName;
c.IsAsync = this.isAsync;
c.ObjectId = this.objectId;
c.CallData = this.callData;
Assert.That(c.ServiceName, Is.EqualTo(this.serviceName));
Assert.That(c.MethodName, Is.EqualTo(this.methodName));
Assert.That(c.IsAsync, Is.EqualTo(this.isAsync));
Assert.That(c.ObjectId, Is.EqualTo(this.objectId));
Assert.That(c.CallData, Is.EquivalentTo(this.callData));
}
public async Task ShouldProcessNext(string testString, string resultString)
{
using (MemoryStream memStream = new MemoryStream(100))
{
using (StreamWriter streamWriter = new StreamWriter(memStream))
{
streamWriter.Write(testString);
streamWriter.Flush();
memStream.Seek(0, SeekOrigin.Begin);
var reader = new Reader(memStream);
var objFactory = new ProtocolObjectFactory(new ProtocolObjectManager());
RequestReader parser = new RequestReader(reader, objFactory);
await parser.ParseNextRequest();
parser.CurrentObjectData.Should().Be(resultString);
}
}
}
public void EmptyMessage()
{
var p = new ProtocolObjectFactory();
byte[] buffer;
using (var s = new MemoryStream())
{
p.WriteMessage(s, this.requestId, null, null);
buffer = s.ToArray();
}
using (var s = new MemoryStream(buffer))
{
var message = p.RpcMessageFromStream(s);
Assert.That(message.RequestId, Is.EqualTo(this.requestId));
Assert.That(message.Call, Is.Null);
Assert.That(message.Result, Is.Null);
Assert.That(s.Position, Is.EqualTo(s.Length));
}
}
public void MessageWithResult()
{
var p = new ProtocolObjectFactory();
byte[] buffer;
using (var s = new MemoryStream())
{
var result = p.CreateRpcResult();
p.WriteMessage(s, this.requestId, null, result);
buffer = s.ToArray();
}
using (var s = new MemoryStream(buffer))
{
var message = p.RpcMessageFromStream(s);
Assert.That(this.requestId, Is.EqualTo(message.RequestId));
Assert.That(message.Call, Is.Null);
Assert.That(message.Result, Is.Not.Null);
Assert.That(s.Position, Is.EqualTo(s.Length));
Assert.That(message.Result.Status, Is.EqualTo(RpcStatus.Succeeded));
Assert.That(message.Result.ResultData, Is.Empty);
}
}
