public static RestyClient<object> GetClient(TestChannel channel)
{
var formatter = new Mock<IContentFormatter>();
formatter.Setup(f => f.SupportedMediaTypes).Returns(() => new[] { _mediaType });
formatter.Setup(f => f.ReadFromStream(It.IsAny<Stream>())).Returns(() => new object());
return new RestyClient<object>(_url.ToString(), new[] { formatter.Object }, client => client.Channel = channel);
}
public void ReceiveTest()
{
var packet = new TestChannel(16);
var received = false;
packet.Receive += (sender, message) => received = true;
packet.Send(new byte[packet.Size]);
Assert.IsTrue(received);
}
public void InvalidDataTest()
{
var packet = new TestChannel(16);
try
{
packet.Send(new byte[0]);
Assert.Fail();
}
catch (NotSupportedException)
{
}
}
public void ClientDisconnected_DisconnectedRaised()
{
var server = new TestChannelServer <ITestContract>(TntBuilder.UseContract <ITestContract, TestContractMock>());
server.StartListening();
ClientDisconnectEventArgs <ITestContract, TestChannel> disconnectedConnection = null;
server.Disconnected += (sender, args) => disconnectedConnection = args;
var clientChannel = new TestChannel();
var proxyConnection = TntBuilder.UseContract <ITestContract>().UseChannel(clientChannel).Build();
var pair = server.TestListener.ImmitateAccept(clientChannel);
pair.Disconnect();
Assert.IsNotNull(disconnectedConnection, "Disconnect not raised");
}
public void ServerAcceptConnection_BeforeConnectRaised()
{
var server = new TestChannelServer <ITestContract>(TntBuilder.UseContract <ITestContract, TestContractMock>());
server.StartListening();
BeforeConnectEventArgs <ITestContract, TestChannel> connectionArgs = null;
server.BeforeConnect += (sender, args) => connectionArgs = args;
var clientChannel = new TestChannel();
var proxyConnection = TntBuilder.UseContract <ITestContract>().UseChannel(clientChannel).Build();
server.TestListener.ImmitateAccept(clientChannel);
Assert.IsNotNull(connectionArgs, "AfterConnect not raised");
}
public void TestEmptyNioBuffers()
{
TestChannel channel = new TestChannel();
ChannelOutboundBuffer buffer = new ChannelOutboundBuffer(channel);
Assert.Equal(0, buffer.NioBufferCount);
var buffers = buffer.GetSharedBufferList();
Assert.NotNull(buffers);
foreach (var b in buffers)
{
Assert.Null(b.Array);
}
Assert.Equal(0, buffer.NioBufferCount);
Release(buffer);
}
public void ProxyBuilder_SayCalled_DataSent()
{
var channel = new TestChannel();
var proxyConnection = TntBuilder
.UseContract <ITestContract>()
.UseChannel(channel)
.Build();
proxyConnection.Channel.ImmitateConnect();
byte[] sentMessage = null;
proxyConnection.Channel.OnWrited += (s, msg) => sentMessage = msg;
proxyConnection.Contract.Say();
Assert.IsNotNull(sentMessage);
Assert.IsNotEmpty(sentMessage);
}
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed()
{
/* Setup */
using (var publisher = TestClientFactory.CreateNormal())
using (var subscriber = TestClientFactory.CreateNormal())
{
var firstMessage = new BasicMessage {
Prop = "Value"
};
var secondMessage = new BasicMessage {
Prop = "AnotherValue"
};
var firstRecievedTcs = new TaskCompletionSource <BasicMessage>();
var secondRecievedTcs = new TaskCompletionSource <BasicMessage>();
var recievedCount = 0;
var subscription = subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
recievedCount++;
if (!firstRecievedTcs.Task.IsCompleted)
{
firstRecievedTcs.SetResult(message);
}
return(Task.FromResult(true));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete(false)));
/* Test */
publisher.PublishAsync(firstMessage);
await firstRecievedTcs.Task;
subscription.Dispose();
var recievedAfterFirstPublish = recievedCount;
publisher.PublishAsync(secondMessage);
await Task.Delay(20);
publisher.SubscribeAsync <BasicMessage>((message, context) =>
{
secondRecievedTcs.SetResult(message);
return(Task.FromResult(true));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete(false)));
await secondRecievedTcs.Task;
TestChannel.QueueDelete(subscription.QueueName);
/* Assert */
Assert.Equal(recievedAfterFirstPublish, recievedCount);
Assert.Equal(firstRecievedTcs.Task.Result.Prop, firstMessage.Prop);
Assert.Equal(secondRecievedTcs.Task.Result.Prop, secondMessage.Prop);
}
}
public async Task Should_Be_Able_To_Subscribe_Initialized_Queue_And_Exchange()
{
using (var client = TestClientFactory.CreateNormal())
{
/* Setup */
const string exchangeName = "initialized.exchange";
const string queueName = "initialized.queue";
try
{
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Fanout);
TestChannel.QueueDeclare(queueName, true, false, false);
var tcs = new TaskCompletionSource <DynamicMessage>();
client.SubscribeAsync <DynamicMessage>((message, context) =>
{
tcs.TrySetResult(message);
return(Task.FromResult(true));
}, cfg => cfg
.WithQueue(q => q
.AssumeInitialized()
.WithName(queueName))
.WithSubscriberId(string.Empty)
.WithExchange(e => e
.AssumeInitialized()
.WithName(exchangeName)));
/* Test */
await client.PublishAsync(new DynamicMessage { Body = new { IsDynamic = true } },
configuration : cfg => cfg
.WithExchange(e => e
.AssumeInitialized()
.WithName(exchangeName)));
await tcs.Task;
/* Assert */
Assert.True(tcs.Task.Result.Body.IsDynamic);
}
finally
{
/* Teardown */
TestChannel.QueueDelete(queueName);
TestChannel.ExchangeDelete(exchangeName);
}
}
}
public async Task Should_Be_Able_To_Nack_One_In_Batch()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var nacked = new BasicMessage {
Prop = "Not me! Plz?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), conventions.ExchangeNamingConvention(message.GetType()), conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(nacked, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackableList = await client.GetManyAsync <BasicMessage>(3);
foreach (var ackableMsg in ackableList.Content)
{
if (string.Equals(ackableMsg.Content.Prop, message.Prop))
{
ackableMsg.Ack();
}
else
{
ackableMsg.Nack();
}
}
var getAgain = await client.GetAsync <BasicMessage>();
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.NotNull(getAgain);
Assert.Equal(getAgain.Content.Prop, nacked.Prop);
}
}
public void EnsureSubsequentRegistrationDoesNotFireActive()
{
var eventLoop = new Mock <IEventLoop>();
// This allows us to have a single-threaded test
eventLoop.SetupGet(x => x.InEventLoop).Returns(true);
eventLoop
.Setup(
x => x.Execute(It.IsAny <IRunnable>()))
.Callback((IRunnable task) =>
{
task.Run();
});
eventLoop
.Setup(
x => x.Execute(It.IsAny <Action>()))
.Callback((Action task) =>
{
task();
});
TestChannel channel = new TestChannel();
var handler = new Mock <IChannelHandler>();
channel.Pipeline.AddLast(handler.Object);
RegisterChannel(eventLoop.Object, channel);
channel.Unsafe.Deregister(new DefaultPromise());
RegisterChannel(eventLoop.Object, channel);
handler.Verify(
x => x.HandlerAdded(It.IsAny <IChannelHandlerContext>())
);
// Should register twice
handler.Verify(
x => x.ChannelRegistered(It.IsAny <IChannelHandlerContext>()),
Times.Exactly(2));
handler.Verify(
x => x.ChannelActive(It.IsAny <IChannelHandlerContext>())
);
handler.Verify(
x => x.ChannelUnregistered(It.IsAny <IChannelHandlerContext>())
);
}
public async Task Should_Be_Able_To_Get_BasicGetResult_When_Queue_IsEmpty()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage();
var conventions = new NamingConventions();
var queueName = conventions.QueueNamingConvention(message.GetType());
TestChannel.QueueDeclare(queueName, true, false, false, null);
/* Test */
var ackable = await client.GetAsync(cfg => cfg.FromQueue(queueName));
/* Assert */
Assert.NotNull(ackable);
Assert.Null(ackable.Content);
TestChannel.QueueDelete(queueName);
}
}
private void DeserializeAndCompare(MqttBasePacket packet, string expectedBase64Value)
{
var serializer = new DefaultMqttV311PacketSerializer();
var channel1 = new TestChannel();
serializer.SerializeAsync(packet, channel1).Wait();
var buffer1 = channel1.ToArray();
var channel2 = new TestChannel(buffer1);
var deserializedPacket = serializer.DeserializeAsync(channel2).Result;
var buffer2 = channel2.ToArray();
var channel3 = new TestChannel(buffer2);
serializer.SerializeAsync(deserializedPacket, channel3).Wait();
Assert.AreEqual(expectedBase64Value, Convert.ToBase64String(channel3.ToArray()));
}
public void BindingElementsOrdering()
{
IChannelBindingElement transformA = new MockTransformationBindingElement("a");
IChannelBindingElement transformB = new MockTransformationBindingElement("b");
IChannelBindingElement sign = new MockSigningBindingElement();
IChannelBindingElement replay = new MockReplayProtectionBindingElement();
IChannelBindingElement expire = new StandardExpirationBindingElement();
Channel channel = new TestChannel(
new TestMessageFactory(),
new[] { sign, replay, expire, transformB, transformA },
new DefaultOpenIdHostFactories());
Assert.AreEqual(5, channel.BindingElements.Count);
Assert.AreSame(transformB, channel.BindingElements[0]);
Assert.AreSame(transformA, channel.BindingElements[1]);
Assert.AreSame(replay, channel.BindingElements[2]);
Assert.AreSame(expire, channel.BindingElements[3]);
Assert.AreSame(sign, channel.BindingElements[4]);
}
/// <summary>
/// Dump all tuples out of channel cache
/// </summary>
/// <returns></returns>
public static List <TestOutput> GetOutput(this Component c)
{
List <TestOutput> res = new List <TestOutput>();
TestChannel comp_channel = (TestChannel)c.Channel;
while (comp_channel.IsEmpty() == false)
{
OutMessage message = comp_channel.OutputMessage();
if (message is SpoutTuple)
{
res.Add(new SpoutOutput((SpoutTuple)message, c.Context.ComponentId));
}
else if (message is BoltTuple)
{
res.Add(new BoltOutput((BoltTuple)message, c.Context.ComponentId));
}
}
return(res);
}
public MockConnectionPair(bool connect = true)
{
var serverBuilder = TntBuilder
.UseContract <TOriginContractInterface, TOriginContractType>()
// .UseReceiveDispatcher<NotThreadDispatcher>()
.SetMaxAnsDelay(200000);
ClientChannel = new TestChannel();
var clientBuilder = TntBuilder
.UseContract <TProxyContractInterface>()
// .UseReceiveDispatcher<NotThreadDispatcher>()
.SetMaxAnsDelay(200000);
Server = new TestChannelServer <TOriginContractInterface>(serverBuilder);
ProxyConnection = clientBuilder.UseChannel(ClientChannel).Build();
if (connect)
{
Connect();
}
}
public async Task Should_Honor_Last_Configuration()
{
/* Setup */
var client = RawRabbitFactory.GetExtendableClient();
const string exchangeName = "topology";
TestChannel.ExchangeDelete(exchangeName);
/* Test */
var result = await client.UpdateTopologyAsync(c => c
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Headers))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Topic))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Direct))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Fanout)));
/* Assert */
Assert.Equal(result.Exchanges[0].Exchange.ExchangeType, ExchangeType.Fanout.ToString().ToLower());
}
// Constructor Method:
public TestGame() {
DebugBot.DebugFunctionCall("TestGame; Constructor();", true);
ownPosX[0] = 1f;
targetPosX[0] = 2f;
ownVelX[0] = 3f;
targetVelX[0] = 4f;
// Brain Inputs!:
inputChannelsList = new List<TestChannel>();
TestChannel BIC_ownPosX = new TestChannel(ref ownPosX, true, "ownPosX");
inputChannelsList.Add (BIC_ownPosX); // 0
TestChannel BIC_targetPosX = new TestChannel(ref targetPosX, true, "targetPosX");
inputChannelsList.Add (BIC_targetPosX); // 1
TestChannel BIC_ownVelX = new TestChannel(ref ownVelX, false, "ownVelX");
inputChannelsList.Add (BIC_ownVelX); // 2
TestChannel BIC_targetVelX = new TestChannel(ref targetVelX, false, "targetVelX");
inputChannelsList.Add (BIC_targetVelX); // 3
// Brain Outputs!:
outputChannelsList = new List<TestChannel>();
TestChannel BOC_ownVelX = new TestChannel(ref ownVelX, true, "ownVelX");
outputChannelsList.Add (BOC_ownVelX); // 0
}
public async Task Should_Update_Exhange_Type()
{
/* Setup */
const string exchangeName = "topology";
TestChannel.ExchangeDelete(exchangeName);
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct);
var client = RawRabbitFactory.GetExtendableClient() as ExtendableBusClient <MessageContext>;
/* Test */
await client.UpdateTopologyAsync(t => t
.ForExchange(exchangeName)
.UseConfiguration(e => e
.WithType(ExchangeType.Topic)
.WithDurability(false))
);
/* Assert */
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Topic);
Assert.True(true, "Did not throw");
Assert.Throws <OperationInterruptedException>(() => TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct));
}
public void TestNioBuffersExpand()
{
TestChannel channel = new TestChannel();
ChannelOutboundBuffer buffer = new ChannelOutboundBuffer(channel);
IByteBuffer buf = Unpooled.DirectBuffer().WriteBytes(Encoding.ASCII.GetBytes("buf1"));
for (int i = 0; i < 64; i++)
{
buffer.AddMessage(buf.Copy(), buf.ReadableBytes, channel.VoidPromise());
}
Assert.Equal(0, buffer.NioBufferCount); // Should still be 0 as not flushed yet
buffer.AddFlush();
var buffers = buffer.GetSharedBufferList();
Assert.Equal(64, buffer.NioBufferCount);
for (int i = 0; i < buffer.NioBufferCount; i++)
{
Assert.Equal(buffers[i], buf.GetIoBuffer(buf.ReaderIndex, buf.ReadableBytes));
}
Release(buffer);
buf.Release();
}
public void EnsureInitialRegistrationFiresActive()
{
var eventLoop = new Mock <IEventLoop>();
// This allows us to have a single-threaded test
eventLoop.SetupGet(x => x.InEventLoop).Returns(true);
TestChannel channel = new TestChannel();
var handler = new Mock <IChannelHandler>();
channel.Pipeline.AddLast(handler.Object);
RegisterChannel(eventLoop.Object, channel);
handler.Verify(
x => x.HandlerAdded(It.IsAny <IChannelHandlerContext>())
);
handler.Verify(
x => x.ChannelRegistered(It.IsAny <IChannelHandlerContext>())
);
handler.Verify(
x => x.ChannelActive(It.IsAny <IChannelHandlerContext>())
);
}
public ThreadChannelTests()
{
_channel = new TestChannel <string>();
_threadChannel = new ThreadChannel <string>(_channel);
}
public override void Dispose()
{
TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages");
TestChannel.QueueDelete("basicmessage");
base.Dispose();
}
public TransmitterAdv(TestChannel ch) : base(1, 1)
{
this.ch = ch;
}
public ReceiverAdv(TestChannel ch) : base(1, 1)
{
this.ch = ch;
}
public static TestChannelPair CreateChannelPair(TestChannel cahnnelA, TestChannel channelB)
{
return(new TestChannelPair(cahnnelA, channelB));
}
public void FinishBuild(int id, string requestguid)
{
try
{
DefectBuild b = new DefectBuild(id)
{
STATUS = DefectBuild.BuildStatus.finishedok.ToString(), TESTGUID = requestguid
};
b.Store();
if (Settings.CurrentSettings.RELEASETTID == b.TTID.ToString() && b.TYPE == (int)DefectBuild.BuildType.releasebuild)
{
//release builder sends its own notifications
return;
}
Defect d = new Defect(b.TTID);
DefectUser u = new DefectUser(b.TTUSERID);
d.SetUpdater(new MPSUser(u.TRID));
List <DefectDispo> dsps = DefectDispo.EnumTestsStarted();
if (dsps.Count > 0)
{
string currentlock = Guid.NewGuid().ToString();
LockInfo li = Defect.Locktask(b.TTID.ToString(), currentlock, u.TRID.ToString(), true);
d.DISPO = dsps[0].ID.ToString();
if (d.PRIMARYHOURS == null)
{
d.PRIMARYHOURS = d.SPENT;
}
d.Store();
DefectEvent.AddEventByTask(id, DefectEvent.Eventtype.QualityAssurance, b.TTUSERID, "Sent for QA Automation");
Defect.UnLocktask(u.TRID.ToString(), currentlock);
}
if (Settings.CurrentSettings.RELEASETTID == b.TTID.ToString())
{
VersionBuilder.SendAlarm("✅New internal release build has been finished. Testing is starting...");
}
else
{
try
{
string mess = $"New task from {u.FULLNAME} is ready for tests!{Settings.CurrentSettings.GetTTAnchor(b.TTID, d.FIRE ? "taskfire.png" : "")}";
TestChannel.SendMessage(mess);
}
catch (Exception e)
{
Logger.Log(e);
}
}
string bst_b = d.BSTBATCHES.Trim();
string bst_c = d.BSTCOMMANDS.Trim();
if (!string.IsNullOrEmpty(bst_b) || !string.IsNullOrEmpty(bst_c))
{
string batches = string.Join(",", bst_b.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries));
string commands = string.Join(",", bst_c.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries));
using (var wcClient = new WebClient())
{
var reqparm = new NameValueCollection();
reqparm.Add("guid", requestguid);
reqparm.Add("commaseparatedbatches", batches);
reqparm.Add("commaseparatedcommands", commands);
reqparm.Add("priority", d.TESTPRIORITY);
//reqparm.Add("branch", d.BRANCHBST);
wcClient.UploadValues(Settings.CurrentSettings.BSTSITESERVICE + "/StartTest", reqparm);
}
}
}
catch (Exception e)
{
Logger.Log(e);
}
}
public override void Dispose()
{
TestChannel.QueueDelete("task_queue");
base.Dispose();
}
public TopicExchangeTests()
{
TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages");
TestChannel.QueueDelete("basicmessage");
TestChannel.QueueDelete("simplemessage");
}
public HelloWorldTest()
{
TestChannel.QueueDelete("hello");
}
public TopologyUpdaterTests()
{
TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages");
}
public WorkQueueTest()
{
TestChannel.QueueDelete("task_queue");
}
public override void Dispose()
{
TestChannel.QueueDelete("hello");
base.Dispose();
}
public override void Dispose()
{
try { TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages"); }
catch (Exception) { }
base.Dispose();
}
