public void TestPublisherChannelReader()
{
var publisherConsumer = new MockChannelReaderConsumer();
var publisherAccess = publisherConsumer.AfterCompleting(1);
var publisher = new MulticastPublisherReader(
"test-publisher",
new Group("237.37.37.2", 37381),
37389,
1024,
publisherConsumer,
ConsoleLogger.TestInstance());
var socketWriter = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37389,
AddressType.Main),
ConsoleLogger.TestInstance());
socketWriter.Write(RawMessage.From(1, 1, "test-response"), new MemoryStream());
publisher.ProcessChannel();
Assert.Equal(1, publisherAccess.ReadFrom <int>("count"));
}
public void TestPublisherChannelReader()
{
var publisherConsumer = new MockChannelReaderConsumer();
var publisherAccess = publisherConsumer.AfterCompleting(1);
var publisher = new MulticastPublisherReader(
"test-publisher",
new Group("237.37.37.2", 37381),
37389,
1024,
publisherConsumer,
ConsoleLogger.TestInstance());
var socketWriter = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37389,
AddressType.Main),
ConsoleLogger.TestInstance());
Func <int> write = () => socketWriter.Write(RawMessage.From(1, 1, "test-response"), new MemoryStream());
ProbeUntilConsumed(() => publisherAccess.ReadFromNow <int>("count") < 1, publisher, write, 10);
Assert.Equal(1, publisherAccess.ReadFromExpecting("count", 1, 10_000));
}
public void TestPublisherChannelReader()
{
var publisherCount = 0;
var accessSafely = AccessSafely.AfterCompleting(1)
.WritingWith <int>("publisherCount", (value) => publisherCount += value)
.ReadingWith("publisherCount", () => publisherCount);
var publisherConsumer = new MockChannelReaderConsumer("publisherCount");
publisherConsumer.UntilConsume = accessSafely;
var publisher = new MulticastPublisherReader(
"test-publisher",
new Group("237.37.37.2", 37381),
37389,
1024,
publisherConsumer,
ConsoleLogger.TestInstance());
var socketWriter = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37389,
AddressType.Main),
ConsoleLogger.TestInstance());
socketWriter.Write(RawMessage.From(1, 1, "test-response"), new MemoryStream());
publisher.ProcessChannel();
Assert.Equal(1, publisherCount);
}
public SocketChannelWriterTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
var node = Node.With(Id.Of(2), Name.Of("node2"), Host.Of("localhost"), 37377, 37378);
var logger = ConsoleLogger.TestInstance();
_channelWriter = new SocketChannelWriter(node.OperationalAddress, logger);
_channelReader = new SocketChannelInboundReader(node.OperationalAddress.Port, "test-reader", 1024, logger);
}
public void TestPublisherChannelReaderWithMultipleClients()
{
var publisherConsumer = new MockChannelReaderConsumer();
var publisherAccess = publisherConsumer.AfterCompleting(4);
var publisher = new MulticastPublisherReader(
"test-publisher",
new Group("237.37.37.2", 37391),
37399,
1024,
publisherConsumer,
ConsoleLogger.TestInstance());
var client1 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
var client2 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
var client3 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
Func <int> write1 = () => client1.Write(RawMessage.From(1, 1, "test-response1"), new MemoryStream());
Func <int> write2 = () => client2.Write(RawMessage.From(1, 1, "test-response2"), new MemoryStream());
Func <int> write3 = () => client3.Write(RawMessage.From(1, 1, "test-response3"), new MemoryStream());
Func <int> writes = () =>
{
write1();
write2();
write3();
return(write1());
};
ProbeUntilConsumed(() => publisherAccess.ReadFromNow <int>("count") < 4, publisher, writes, 10);
Assert.True(publisherAccess.ReadFrom <int>("count") >= 4);
}
//====================================
// internal implementation
//====================================
private void ManageDirectoryChannel(string maybePublisherAvailability)
{
var publisherAvailability = PublisherAvailability.From(maybePublisherAvailability);
if (publisherAvailability.IsValid)
{
if (!publisherAvailability.Equals(_directory))
{
_directory = publisherAvailability;
_directoryChannel?.Close();
_directoryChannel = new SocketChannelWriter(_testAddress ?? _directory.ToAddress(), Logger);
}
}
}
public void TestPublisherChannelReaderWithMultipleClients()
{
var publisherConsumer = new MockChannelReaderConsumer();
var publisherAccess = publisherConsumer.AfterCompleting(4);
var publisher = new MulticastPublisherReader(
"test-publisher",
new Group("237.37.37.2", 37391),
37399,
1024,
publisherConsumer,
ConsoleLogger.TestInstance());
var client1 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
var client2 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
var client3 = new SocketChannelWriter(
Address.From(
Host.Of("localhost"),
37399,
AddressType.Main),
ConsoleLogger.TestInstance());
client1.Write(RawMessage.From(1, 1, "test-response1"), new MemoryStream());
client2.Write(RawMessage.From(1, 1, "test-response2"), new MemoryStream());
client3.Write(RawMessage.From(1, 1, "test-response3"), new MemoryStream());
client1.Write(RawMessage.From(1, 1, "test-response1"), new MemoryStream());
publisher.ProbeChannel();
publisher.ProbeChannel();
publisher.ProbeChannel();
publisher.ProbeChannel();
Assert.Equal(4, publisherAccess.ReadFrom <int>("count"));
}
