public void TestSendOneWay_FlatFile_ISO88591() { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( connectionUri.Uri.AbsolutePath, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { adapter.Encoding = "ISO-8859-1"; string ffContent = "303330123333777;ABCD;00001;00002;2014-01-15;21:21:33.444;EFGH;"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(ffContent, Encoding.GetEncoding("ISO-8859-1")); OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnected(cb), testHelper); outboundHandler.Execute(msg, new TimeSpan(0, 0, 10)); //Here we wait for the event to be signalled testHelper.syncEvent.WaitOne(60000); //The event was signalled, we get the message stirng from the outBuffer string receivedResponse = GeneralTestHelper.GetMessageFromArray(testHelper.memStream.ToArray(), (int)testHelper.memStream.Length, Encoding.GetEncoding("ISO-8859-1")); Assert.AreEqual(ffContent, receivedResponse, "Contents of received message is different"); } }
public void TestSendTwoWay_XML_MediumMessage() { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( connectionUri.Uri.AbsolutePath, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody( File.ReadAllBytes("MediumMessage.xml")); //Setting up the BTS.IsSolicitResponse property msg.Properties.Add("http://schemas.microsoft.com/BizTalk/2003/system-properties#IsSolicitResponse", true); OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); //We set the response message content testHelper.responsePath = "MediumMessage.xml"; pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnectedSyncronous(cb), testHelper); Message responseMsg = outboundHandler.Execute(msg, new TimeSpan(0, 0, 10)); //Calculating the hashes of the messages and the file byte[] responseMessageBytes = GeneralTestHelper.GetBodyAsBytes(responseMsg); string receivedMessageHash = GeneralTestHelper.CalculateBytesHash(testHelper.memStream.ToArray()); string responseMessageHash = GeneralTestHelper.CalculateBytesHash(responseMessageBytes); string fileHash = GeneralTestHelper.CalculateFileHash("MediumMessage.xml"); //Validating the results Assert.AreEqual(fileHash, receivedMessageHash, "Contents of the request message is different"); Assert.AreEqual(fileHash, responseMessageHash, "Contents of the response message is different"); } }
public void TestSendTwoWay_XML() { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( connectionUri.Uri.AbsolutePath, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); //Setting up the BTS.IsSolicitResponse property msg.Properties.Add("http://schemas.microsoft.com/BizTalk/2003/system-properties#IsSolicitResponse", true); OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); //We set the response message content testHelper.responseXml = "<SomeTestMessageResponse><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessageResponse>"; pipeServer.BeginWaitForConnection(cb => testHelper .ClientConnectedSyncronous(cb, ctx => SendResponse(ctx)), testHelper); Message responseMsg = outboundHandler.Execute(msg, new TimeSpan(0, 0, 10)); var mockMessage = ConvertToMockMessage(testHelper.memStream); Assert.AreEqual(mockMessage.Body, xml, "Contents of the request message is different"); Assert.AreEqual(testHelper.responseXml, GeneralTestHelper.GetBodyAsString(responseMsg, Encoding.UTF8), "Contents of the response message is different"); } }
public void TestSendOneWay_XML_Unicode() { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( connectionUri.Uri.AbsolutePath, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { adapter.Encoding = "Unicode"; string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.Unicode); OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnected(cb), testHelper); outboundHandler.Execute(msg, new TimeSpan(0, 0, 10)); //Here we wait for the event to be signalled testHelper.syncEvent.WaitOne(60000); //The event was signalled, we get the message stirng from the outBuffer var mockMessage = ConvertToMockMessage(testHelper.memStream); Assert.AreEqual(xml, mockMessage.Body, "Contents of received message is different"); } }
public void TestSendOneWay_XML_WithProperties_InvalidProperty() { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( connectionUri.Uri.AbsolutePath, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); // Adding test properties AddPromotedProperty(msg, "http://schemas.microsoft.com/BizTalk/2003/zip-properties#Imaginary", "StillWorks"); OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnected(cb), testHelper); outboundHandler.Execute(msg, new TimeSpan(0, 0, 10)); //Here we wait for the event to be signalled testHelper.syncEvent.WaitOne(60000); //The event was signalled, we get the message stirng from the outBuffer var mockMessage = ConvertToMockMessage(testHelper.memStream); Assert.AreEqual(xml, mockMessage.Body, "Contents of received message is different"); Assert.IsTrue(mockMessage.Properties.Count == 1, "Number of properties received from outbound adapter is wrong"); Assert.AreEqual("StillWorks", mockMessage.Properties["http://schemas.microsoft.com/BizTalk/2003/zip-properties#Imaginary"], "The promoted property is not as expected"); } }
public void TestOneWayReceive_FlatFile_ISO88591() { inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); string ffContent = "303330123333777;ABCD;00001;00002;2014-01-15;21:21:33.444;EFGH;"; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] ffBytes = Encoding.GetEncoding("ISO-8859-1").GetBytes(ffContent); pipeClient.Connect(10000); pipeClient.Write(ffBytes, 0, ffBytes.Count()); pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(ffContent, GeneralTestHelper.GetBodyAsString(msg, Encoding.GetEncoding("ISO-8859-1")), "Message contents of received message is different"); }
public void TestOneWayReceive_XML_PromotePOP3AdapterProperties() { const string adapterNamespace = "http://schemas.microsoft.com/BizTalk/2003/pop3-properties"; string[] propertyArray = new string[] { "[email protected]", "POP3.Subject=Test mail", "[email protected]", "[email protected]", "[email protected]" }; //Initializing the inbound handler again and passing the desired property InitInboundHandler("mock://localhost/TestEndpoint", string.Join(";", propertyArray)); inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(xml, GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8), "Message contents of received message is different"); //Verify the promoted properties var promotedProperties = msg.Properties .Where(p => p.Key == "http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/Promote") .Single(); Assert.IsNotNull(promotedProperties, "The promoted properties list is not present"); var propertiesList = promotedProperties.Value as List <KeyValuePair <XmlQualifiedName, object> >; Assert.AreEqual(propertiesList.Count, 5, "The element count in the promoted properties list differ"); for (int i = 0; i < propertiesList.Count; i++) { string[] propertyDetails = propertyArray[i].Split('='); VerifyPromotedProperty(propertiesList[i], adapterNamespace, propertyDetails[0].Replace("POP3.", string.Empty), propertyDetails[1]); } }
public void TestOneWayReceive_XML_ISO88591() { adapter.Encoding = "ISO-8859-1"; inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); //TODO: implement sending XML message to the inbound handler string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.GetEncoding("ISO-8859-1").GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(xml, GeneralTestHelper.GetBodyAsString(msg, Encoding.GetEncoding("ISO-8859-1")), "Message contents of received message is different"); }
public void TestSendSmallMessage_FlatFile() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockSendStep step = new MockSendStep(); step.Url = connectionUri.Uri.OriginalString; step.RequestPath = "TestRequest.txt"; step.Encoding = "UTF-8"; step.Timeout = 30; //Validated the step step.Validate(context); //Executing the step step.Execute(context); //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(TimeSpan.FromSeconds(10), out msg, out reply); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(ReadRequestFileContent(step.RequestPath), GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8), "Message contents of received message is different"); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.AtLeastOnce(), "The LogData message was not called"); }
public void TestReceiveSmallMessage_XML_LambdaValidation() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockReceiveStep step = new MockReceiveStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.Timeout = 10; string xml = @"<SomeTestMessage> <Element1 attribute1=""attributeValue""> </Element1> <Element2>Some element content</Element2> </SomeTestMessage>"; // Calling Validate in order to start the pipe server step.Validate(context); // Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); // Creating the validation step var validationStep = new LambdaValidationStep() { MessageValidationCallback = (m) => { Assert.AreEqual(xml, m.Body, "Validation of received message failed"); return(true); } }; step.SubSteps.Add(validationStep); // here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); //Waiting for the manual event to be set manualEvent.WaitOne(1000); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.AtLeastOnce(), "The LogData message was not called"); }
public void TestTwoWayReceive_XML_Unicode() { adapter.Encoding = "Unicode"; inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { //TODO: implement sending XML message to the inbound handler string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; byte[] xmlBytes = Encoding.Unicode.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); //Send the EOF bytes //pipeClient.Write(new byte[] { 0x00, 0x00 }, 0, 2); pipeClient.WriteByte(0x00); pipeClient.WaitForPipeDrain(); //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(xml, GeneralTestHelper.GetBodyAsString(msg, Encoding.Unicode), "Message contents of received message is different"); //we send the response message string responseXml = "<Response><Description>The request was successfully processed</Description></Response>"; Message responseMessage = GeneralTestHelper.CreateMessageWithBase64EncodedBody(responseXml, Encoding.Unicode); byte[] inBuffer = new byte[256]; int bytesCountRead = 0, eofCountRead = 0; System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //We queue up the reply so that it executes from the context of another thread. System.Threading.ThreadPool.QueueUserWorkItem(cb => { //we try to read from the pipe bytesCountRead = pipeClient.Read(inBuffer, 0, inBuffer.Length); //read the EOF bytes. byte[] eofBytes = new byte[2]; eofCountRead = pipeClient.Read(eofBytes, 0, 1); manualEvent.Set(); } ); reply.Reply(responseMessage, new TimeSpan(0, 0, 10)); //We wait for the event to be signalled manualEvent.WaitOne(10000); string receivedResponseXml = GeneralTestHelper.GetMessageFromArray(inBuffer, bytesCountRead - (1 - eofCountRead), Encoding.Unicode); Assert.AreEqual(responseXml, receivedResponseXml, "The received response is not correct"); } }
public void TestReceiveSmallMessages_Debatch2_Expect3_XML() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockReceiveStep step = new MockReceiveStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.Timeout = 1; step.DebatchedMessageCount = 3; //Calling Validate in order to start the step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be bool timeoutExceptionThrown = false; System.Threading.ThreadPool.QueueUserWorkItem((state) => { try { step.Execute(context); manualEvent.Set(); } catch (TimeoutException) { timeoutExceptionThrown = true; } }); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; for (int i = 0; i < 2; i++) { Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); } // Waiting for the manual event to be set // The wait time is slightly longer than the step's timeout in order to // to be able to capture the TimeoutException correctly manualEvent.WaitOne(2000); Assert.IsTrue(timeoutExceptionThrown, "The expected exception was not thrown"); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.Exactly(2), "The LogData message was not called"); }
public void TestReceiveSmallMessages_Debatch3_SerialValidationSingleStep_XML() { // Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); BizUnit. MockReceiveStep step = new MockReceiveStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.Timeout = 30; step.DebatchedMessageCount = 3; // Setting up a validation step mock var validationStepMock = CreateSubStepMock(); step.SubSteps.Add(validationStepMock.Object); // Calling Validate in order to start the step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; for (int i = 0; i < 3; i++) { Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); } //Waiting for the manual event to be set manualEvent.WaitOne(1000); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.AtLeastOnce(), "The LogData message was not called"); validationStepMock.Verify(vs => vs.Execute( It.Is <Stream>(s => s != null), It.Is <Context>(c => c != null)), Times.Exactly(3), "The SubStep mock was not called the expected number of times"); }
public void TestReceiveSmallMessages_Debatch50_XML() { //Setting up the ILogger moq var loggerMock = TestMockReceiveStep.CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockRequestResponseStep step = new MockRequestResponseStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.ResponsePath = "TestResponse.xml"; step.Timeout = 30; step.DebatchedMessageCount = 50; //Calling Validate in order to start the step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); var responseMessageList = new List <Message>(3); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; for (int i = 0; i < 50; i++) { Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); msg.Properties.Add("http://schemas.microsoft.com/BizTalk/2003/system-properties#IsSolicitResponse", true); var responseMsg = outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); responseMessageList.Add(responseMsg); } //Waiting for the manual event to be set manualEvent.WaitOne(3000); //string expected = ReadResponseFileContent("TestResponse.xml").Trim().Replace("\r\n", string.Empty).Replace("\t", string.Empty); //string actual = GeneralTestHelper.GetBodyAsString(responseMsg, Encoding.UTF8).Trim().Replace("\r\n", string.Empty).Replace("\t", string.Empty); //Assert.AreEqual(expected, actual, // "Response message is not matching the expected content"); Assert.AreEqual(50, responseMessageList.Count, "The number of response messages is incorrect."); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.Exactly(100), "The LogData method was not called"); }
public void TestSendSmallMessage_XML_FaultResponse() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockSolicitResponseStep step = new MockSolicitResponseStep(); step.Url = connectionUri.Uri.OriginalString; step.RequestPath = "TestRequest.xml"; step.Encoding = "UTF-8"; step.Timeout = 30; //Validating the test step step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be Message msg = null; IInboundReply reply; //Creating the reply message //Message msgReply = GeneralTestHelper.CreateMessageWithBase64EncodedBody( // ReadRequestFileContent("CustomFault.xml"), Encoding.UTF8); Message msgReply = Message.CreateMessage( MessageVersion.Default, MessageFault.CreateFault( new FaultCode("Custom"), "wanna fail"), "Test action"); System.Threading.ThreadPool.QueueUserWorkItem((state) => { //Now we read the message in the inbound handler inboundHandler.TryReceive(TimeSpan.FromSeconds(10), out msg, out reply); reply.Reply(msgReply, TimeSpan.FromSeconds(10)); manualEvent.Set(); }); //Executing the step step.Execute(context); manualEvent.WaitOne(10000); Assert.IsNotNull(msg, "Message instance was not received"); string expectedRequest = ReadRequestFileContent(step.RequestPath); string actualRequest = GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8); Assert.AreEqual(expectedRequest, actualRequest, "Message contents of received message is different"); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.AtLeastOnce(), "The LogData message was not called"); }
public void TestOneWayReceive_XML_MediumMessage() { inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); byte[] xmlBytes = new byte[256]; int fileLength = 0; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { pipeClient.Connect(10000); int byteCountRead = 0; using (FileStream fs = File.OpenRead("MediumMessage.xml")) { fileLength = (int)fs.Length; while ((byteCountRead = fs.Read(xmlBytes, 0, xmlBytes.Length)) > 0) { pipeClient.Write(xmlBytes, 0, byteCountRead); } } pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.IsNotNull(reply, "Reply instance was not returned"); byte[] receivedMessageBytes = GeneralTestHelper.GetBodyAsBytes(msg); Assert.AreEqual(fileLength, receivedMessageBytes.Length, "The message length is wrong"); string fileHash = GeneralTestHelper.CalculateFileHash("MediumMessage.xml"); string messageHash = GeneralTestHelper.CalculateBytesHash(receivedMessageBytes); Assert.AreEqual(fileHash, messageHash, "Message contents of received message is different"); }
public void TestReceiveSmallMessage_ResponseSelector_XML() { //Setting up the ILogger moq var loggerMock = TestMockReceiveStep.CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockRequestResponseStep step = new MockRequestResponseStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.ResponseSelector = (request, index) => SelectStaticResponse(request, index); step.Timeout = 30; //Calling Validate in order to start the server step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); msg.Properties.Add("http://schemas.microsoft.com/BizTalk/2003/system-properties#IsSolicitResponse", true); Message responseMsg = outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); //Waiting for the manual event to be set manualEvent.WaitOne(1000); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.Exactly(2), "The LogData method was not called"); byte[] responseBytes = GeneralTestHelper.GetBodyAsBytes(responseMsg); Assert.AreEqual( GeneralTestHelper.CalculateFileHash("TestResponse.xml"), GeneralTestHelper.CalculateBytesHash(responseBytes), "The second response is not as expected"); }
public void TestOneWayReceive_XML_PromoteFTPAdapterProperties() { //Initializing the inbound handler again and passing the desired property InitInboundHandler("mock://localhost/TestEndpoint", @"FTP.ReceivedFileName=File1.xml"); inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); //TODO: implement sending XML message to the inbound handler string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(xml, GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8), "Message contents of received message is different"); //Verify the promoted properties var promotedProperties = msg.Properties .Where(p => p.Key == "http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/Promote") .Single(); Assert.IsNotNull(promotedProperties, "The promoted properties list is not present"); var propertiesList = promotedProperties.Value as List <KeyValuePair <XmlQualifiedName, object> >; Assert.AreEqual(propertiesList.Count, 1, "The element count in the promoted properties list differ"); VerifyPromotedProperty(propertiesList[0], "http://schemas.microsoft.com/BizTalk/2003/ftp-properties", "ReceivedFileName", "File1.xml"); }
public void TestReceiveSmallMessages_Debatch50_XML() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockReceiveStep step = new MockReceiveStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.Timeout = 10; step.DebatchedMessageCount = 50; //Calling Validate in order to start the step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; for (int i = 0; i < 50; i++) { Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(xml, Encoding.UTF8); outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); } //Waiting for the manual event to be set if (!manualEvent.WaitOne(1000)) { manualEvent.WaitOne(5000); } loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.Exactly(50), "The LogData method was not called"); }
public void TestReceiveSmallMessage_FlatFile() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockReceiveStep step = new MockReceiveStep(); step.Url = connectionUri.Uri.OriginalString; step.Encoding = "UTF-8"; step.Timeout = 30; //Colling Validate in order to start the step.Validate(context); //Setting up a manual reset event System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //here we queue up the step.Execute method in a separate thread as the execution model would actually be System.Threading.ThreadPool.QueueUserWorkItem((state) => { step.Execute(context); manualEvent.Set(); }); string ffContent = "303330123333777;ABCD;00001;00002;2014-01-15;21:21:33.444;EFGH;"; Message msg = GeneralTestHelper.CreateMessageWithBase64EncodedBody(ffContent, Encoding.UTF8); outboundHandler.Execute(msg, TimeSpan.FromSeconds(10)); //Waiting for the manual event to be set manualEvent.WaitOne(1000); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s) && s == "MockReceiveStep received a message with content"), It.Is <string>(s => !string.IsNullOrEmpty(s) && s == "303330123333777;ABCD;00001;00002;2014-01-15;21:21:33.444;EFGH;")), Times.AtLeastOnce(), "The LogData method was not called"); }
public void TestTwoWay_XML() { PipeSecurity ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule("USERS", PipeAccessRights.CreateNewInstance | PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow)); //We first spin a pipe server to make sure that the send port will be able to connect using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( "TwoWaySend", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps)) { string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; string responseXml = "<SomeTestMessageResponse><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessageResponse>"; OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer, responseXml); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnectedSyncronous(cb), testHelper); System.Threading.Thread.Sleep(100); //Here we spin the pipe client that will send the message to BizTalk using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", "TwoWayReceive", PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.Flush(); pipeClient.WriteByte(0x00);//writing the EOF byte pipeClient.Flush(); pipeClient.WaitForPipeDrain(); //Here we wait for the event to be signalled bool waitExpired = testHelper.syncEvent.WaitOne(10000); Assert.IsTrue(waitExpired, "The waiting time for the response has expired prior to receiving the response"); //The event was signalled, we get the message stirng from the outBuffer string receivedXml = Encoding.UTF8.GetString(testHelper.memStream.ToArray(), 0, (int)testHelper.memStream.Length); Assert.AreEqual(xml, receivedXml, "Contents of received message is different"); //Here we read from the pipeClient the response message byte[] responseBytes = new byte[256]; using (MemoryStream memStream = new MemoryStream(256)) { int byteCountRead = 0; bool eofReached = false; while (!eofReached) { byteCountRead = pipeClient.Read(responseBytes, 0, responseBytes.Length); if (byteCountRead > 2) { eofReached = (responseBytes[byteCountRead - 1] == 0x0 && responseBytes[byteCountRead - 2] != 0x0 && responseBytes[byteCountRead - 3] != 0x0); } else if (byteCountRead > 1 && !eofReached) { eofReached = (responseBytes[byteCountRead - 1] == 0x0 && responseBytes[byteCountRead - 2] == 0x0); } else if (byteCountRead == 1) { eofReached = responseBytes[byteCountRead - 1] == 0x0; } memStream.Write(responseBytes, 0, eofReached ? byteCountRead - 1 : byteCountRead); } string receivedResponseXml = GeneralTestHelper.GetMessageFromArray( memStream.ToArray(), (int)memStream.Length, Encoding.UTF8); Assert.AreEqual(responseXml, receivedResponseXml, "Contents of the response message is different"); } } } }
public void TestOneWayReceive_XML_PromoteMQAdapterProperties() { const string adapterNamespace = "http://schemas.microsoft.com/BizTalk/2003/mq-properties"; string[] propertyArray = new string[] { "MQMD.ApplIdentityData=SomeIdentityData", "MQMD.ApplOriginData=SAP123", "MQMD.CorrelId=TestCorrelationToken", "MQMD.Encoding=Binary", "MQMD.Expiry=2017-09-05T12:00:00", "MQMD.Format=Text", "MQMD.GroupID=", "MQMD.MsgId=TestMessageId", "MQMD.MsgSeqNumber=123", "MQMD.MsgType=Normal", "MQMD.Offset=0", "MQMD.OriginalLength=123456" }; string properties = string.Join(";", propertyArray); //Initializing the inbound handler again and passing the desired property InitInboundHandler("mock://localhost/TestEndpoint", properties); inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); //TODO: implement sending XML message to the inbound handler string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.WaitForPipeDrain(); } //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); //Sending empty message to emulate the exact behavior of BizTalk for one way communication reply.Reply(GeneralTestHelper.CreateMessageWithEmptyBody(), TimeSpan.FromSeconds(10)); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(xml, GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8), "Message contents of received message is different"); //Verify the promoted properties var promotedProperties = msg.Properties .Where(p => p.Key == "http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/Promote") .Single(); Assert.IsNotNull(promotedProperties, "The promoted properties list is not present"); var propertiesList = promotedProperties.Value as List <KeyValuePair <XmlQualifiedName, object> >; Assert.AreEqual(propertiesList.Count, propertyArray.Length, "The element count in the promoted properties list differ"); for (int i = 0; i < propertiesList.Count; i++) { string[] propertyDetails = propertyArray[i].Split('='); VerifyPromotedProperty(propertiesList[i], adapterNamespace, propertyDetails[0].Replace('.', '_'), propertyDetails[1]); } }
public void TestTwoWayReceive_XML_MediumRequestResponse() { inboundHandler.StartListener(null, new TimeSpan(0, 0, 60)); using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", connectionUri.Uri.AbsolutePath, PipeDirection.InOut, PipeOptions.Asynchronous)) { int bytesCountRead = 0; int fileLength = 0; byte[] xmlBytes = new byte[256]; pipeClient.Connect(10000); using (FileStream fs = File.OpenRead("MediumMessage.xml")) { fileLength = (int)fs.Length; while ((bytesCountRead = fs.Read(xmlBytes, 0, xmlBytes.Length)) > 0) { pipeClient.Write(xmlBytes, 0, bytesCountRead); } } //Send the EOF bytes pipeClient.WriteByte(0x00); pipeClient.WaitForPipeDrain(); //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(new TimeSpan(0, 0, 10), out msg, out reply); Assert.IsNotNull(msg, "Message instance was not returned"); byte[] msgBytes = GeneralTestHelper.GetBodyAsBytes(msg); Assert.AreEqual(fileLength, msgBytes.Length, "The message length is not correct"); string requestMessageHash = GeneralTestHelper.CalculateBytesHash(msgBytes); string fileHash = GeneralTestHelper.CalculateFileHash("MediumMessage.xml"); Assert.AreEqual(fileHash, requestMessageHash, "Message contents of received message is different"); //we send the response message Message responseMessage = GeneralTestHelper.CreateMessageWithBase64EncodedBody(File.ReadAllBytes("MediumMessage.xml")); byte[] inBuffer = new byte[512]; using (MemoryStream memStream = new MemoryStream(512)) { System.Threading.ManualResetEvent manualEvent = new System.Threading.ManualResetEvent(false); //We queue up the reply so that it executes from the context of another thread. System.Threading.ThreadPool.QueueUserWorkItem(cb => { bool eof = false; //we try to read from the pipe while (!eof) { bytesCountRead = pipeClient.Read(inBuffer, 0, inBuffer.Length); if (bytesCountRead > 0) { //if (inBuffer[bytesCountRead - 1] == 0x00 && // inBuffer[bytesCountRead - 2] == 0x00) if (inBuffer[bytesCountRead - 1] == 0x00) { eof = true; } memStream.Write(inBuffer, 0, !eof ? bytesCountRead : bytesCountRead - 1); } else { eof = true; } } manualEvent.Set(); } ); reply.Reply(responseMessage, new TimeSpan(0, 0, 10)); //We wait for the event to be signalled manualEvent.WaitOne(10000); string responseHash = GeneralTestHelper.CalculateBytesHash(memStream.ToArray()); Assert.AreEqual(fileHash, responseHash, "The received response is not correct"); } } }
public void TestSendSmallMessage_XML_MessageProperties() { //Setting up the ILogger moq var loggerMock = CreateLoggerMock(); Context context = new Context(loggerMock.Object); MockSendStep step = new MockSendStep(); step.Url = connectionUri.Uri.OriginalString; step.RequestPath = "TestRequest.xml"; step.Encoding = "UTF-8"; step.Timeout = 30; step.MessageProperties.Add( Utils.BizTalkProperties.BTS.Operation, "SomeTestOperation.com"); step.MessageProperties.Add( Utils.BizTalkProperties.FILE.ReceivedFileName, @"\blabla\bla\TestFile.xml"); //Validating the test step step.Validate(context); //Executing the step step.Execute(context); //Now we read the message in the inbound handler Message msg = null; IInboundReply reply; inboundHandler.TryReceive(TimeSpan.FromSeconds(10), out msg, out reply); Assert.IsNotNull(msg, "Message instance was not returned"); Assert.AreEqual(ReadRequestFileContent(step.RequestPath), GeneralTestHelper.GetBodyAsString(msg, Encoding.UTF8), "Message contents of received message is different"); loggerMock.Verify(l => l.LogData( It.Is <string>(s => !string.IsNullOrEmpty(s)), It.Is <string>(s => !string.IsNullOrEmpty(s))), Times.AtLeastOnce(), "The LogData message was not called"); //Verify the promoted properties var promotedProperties = msg.Properties .Where(p => p.Key == "http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/Promote") .SingleOrDefault(); Assert.IsNotNull(promotedProperties, "The promoted properties list is not present"); var propertiesList = promotedProperties.Value as List <KeyValuePair <XmlQualifiedName, object> >; Assert.AreEqual(2, propertiesList.Count, "The element count in the promoted properties list differ"); MessagePropertyValidator .ValidatePromotedProperty(propertiesList[0], "http://schemas.microsoft.com/BizTalk/2003/system-properties", "Operation", @"SomeTestOperation.com"); MessagePropertyValidator .ValidatePromotedProperty(propertiesList[1], "http://schemas.microsoft.com/BizTalk/2003/file-properties", "ReceivedFileName", @"\blabla\bla\TestFile.xml"); }