public void a_published_message_is_received_by_multiple_subscribers()
{
// When the bus publishes a message, it is sent through the socket
var consumer = new ZeroConsumer<Message>("tcp://localhost:5562");
var bus = new BusAdapter();
bus.AttachConsumer(consumer);
// Meanwhile, the aggregator waits for messages from the same socket
var producer = new ZeroProducer<Message>("tcp://*:5562");
var aggregator = new EventAggregator<Message>();
aggregator.AttachTo(producer);
// While two test consumers are subscribed to the aggregator
// (the syntax looks like it's the other way around)
var confirmById = new FakeEventConsumer();
var confirmAsReceived = new TestConsumer();
aggregator.SubscribeTo(confirmById);
aggregator.SubscribeTo(confirmAsReceived);
// When we drop a message on the bus, the test consumer should get it
var @event = new FakeEvent();
bus.Publish(@event);
// Pause the thread so the producer (via aggregator) can send to the test consumer
var timeout = TimeSpan.FromSeconds(1).TotalMilliseconds;
Thread.Sleep((int)timeout);
Assert.IsTrue(confirmAsReceived.Received);
Assert.AreEqual(@event.Id, confirmById.Id);
producer.Dispose();
consumer.Dispose();
}
public void CancelParsing()
{
var data = "#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,long,string,string,string,unknown\n"
+ "#group,false,false,false,false,false,false,false,false,false,true\n"
+ "#default,_result,,,,,,,,,\n"
+ ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n"
+ ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,12.25\n"
+ ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n";
var records = new List <FluxRecord>();
var defaultCancellable = new DefaultCancellable();
var consumer = new TestConsumer
(
acceptTable: (table) => { },
acceptRecord: (record) =>
{
defaultCancellable.Cancel();
records.Add(record);
}
);
_parser.ParseFluxResponse(FluxCsvParser.ToStream(data), defaultCancellable, consumer);
Assert.That(records.Count == 1);
}
public void message_is_produced()
{
var block = new ManualResetEvent(false);
var received = false;
var consumer = new TestConsumer();
var producer = new ZeroProducer<Message>("tcp://*:5562");
producer.AttachConsumer(consumer);
ThreadPool.QueueUserWorkItem(s =>
{
using (var context = new Context())
{
using (var socket = context.Socket(SocketType.REQ))
{
socket.Connect("tcp://localhost:5562");
using (var ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, new TestMessage());
socket.Send(ms.ToArray());
socket.Recv(); // ACK
}
}
}
received = true;
block.Set();
});
block.WaitOne();
Assert.IsTrue(received);
producer.Stop();
}
public void ScanConsumerTest([Values] TestUtils.DeviceType deviceType)
{
// Create log and device here (not in setup) because using DeviceType Enum which can't be used in Setup
string filename = path + "LogScanDefault" + deviceType.ToString() + ".log";
device = TestUtils.CreateTestDevice(deviceType, filename);
log = new FasterLog(new FasterLogSettings {
LogDevice = device, SegmentSizeBits = 22, LogCommitDir = path
});
PopulateLog(log);
// Basic default scan from start to end
// Indirectly used in other tests, but good to have the basic test here for completeness
// Read the log - Look for the flag so know each entry is unique
var consumer = new TestConsumer();
using (var iter = log.Scan(0, 100_000_000))
{
while (iter.TryConsumeNext(consumer))
{
}
}
// Make sure expected length is same as current - also makes sure that data verification was not skipped
Assert.AreEqual(entryLength, consumer.currentEntry);
}
public async Task GroupBy_Merge_Will_Should_2()
{
var expected = Enumerable.Range(1, 10);
using var producer = expected.AsProducer();
using var consumer = new TestConsumer <int>();
using var cancel = new CancellationTokenSource();
var tasks = new List <Task> {
producer
.Outbox
.GroupBy <int, int>(
x => x,
p => p.LinkTo(consumer.Inbox),
null,
cancel.Token),
producer,
consumer
};
await tasks.WhenAll(cancel);
var actual = consumer.Values.OrderBy(x => x);
Assert.Equal(expected, actual);
}
public static void Assert_EnqueueSingleProducerBounded(IEventQueueStorageStrategy <TestEvent> strategy, int maxEventCount)
{
/* PRECONDITION */
Debug.Assert(strategy != null);
Debug.Assert(maxEventCount >= 0);
Debug.Assert(strategy.IsClosed);
/* GIVEN */
var expectedEventCount = (maxEventCount < maxEvents) ? maxEventCount : maxEvents;
var producer = new TestProducer(strategy);
var consumer = new TestConsumer(strategy);
using var produceEvent = new ManualResetEvent(false);
using var consumeEvent = new ManualResetEvent(false);
/* WHEN */
strategy.Open();
Assert.IsTrue(!strategy.IsClosed);
consumer.Consume((@event, num) => num < expectedEventCount, result => result.EventSuccess(consumeEvent));
producer.Produce(num => num < maxEvents, result => result.EventSuccess(produceEvent));
/* THEN */
Assert.IsTrue(produceEvent.WaitOne(maxWaitTime), "Producer did not complete successfully");
Assert.IsTrue(consumeEvent.WaitOne(maxWaitTime), "Consumer did not complete successfully");
}
public void TestBoundedSingleConsumer_IsOccupied()
{
/* PRECONDITION */
Debug.Assert(Strategy != null);
using var allowedConsumerDidNotFailed = new ManualResetEvent(true);
using var invalidConsumerFailed = new ManualResetEvent(false);
/* GIVEN */
var consumer = new TestConsumer(Strategy);
consumer.Consume(
(@event, index) => true,
result => result?.EventSuccess(allowedConsumerDidNotFailed));
/* WHEN */
var invalidConsumer = new TestConsumer(Strategy);
invalidConsumer.Consume(
(@event, num) => true,
result => result?.EventThrows <ChannelConsumingException>(invalidConsumerFailed));
/* THEN */
Assert.IsTrue(allowedConsumerDidNotFailed.WaitOne(maxWaitTime), "An Error occurred while consuming using valid consumers.");
Assert.IsTrue(invalidConsumerFailed.WaitOne(maxWaitTime), "InvalidConsumer should fail.");
}
public void Load_ConsumerInstanceContainer_ConsumerInstanceContainer()
{
var consumer = new TestConsumer {
Name = "qux"
};
Assert.AreEqual("TestConsumer[qux].Empty", Identifier.Create <TestConsumer, EmptyConfiguration>(consumer, c => c.Name).ToString());
}
public void GivenNullConfig_ShouldThrowArgumentNullException()
{
var exception = Assert.Throws <ArgumentNullException>(() =>
{
_ = new TestConsumer(null);
});
exception.Message.Should().Contain(nameof(KafkaConfiguration));
}
public void WhenConsumerIsNotInitialized_ShouldThrowInvalidOperationException()
{
var consumer = new TestConsumer();
_ = Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await consumer.RunAsync();
});
}
protected override void ConfigureRabbitMqReceiveEndpoint(IRabbitMqReceiveEndpointConfigurator configurator)
{
_testConsumer = new TestConsumer(GetTask <A>(), GetTask <B>());
configurator.Consumer(typeof(TestConsumer), type =>
{
return(_testConsumer);
});
}
static void Main(string[] args)
{
var repository = new BaseRepository <DemoEntity>();
TestConsumer consumer = new TestConsumer(repository);
while (true)
{
Thread.Sleep(2000);
}
}
public void GivenValidConfiguration_ShouldCreateTestConsumer()
{
var config = new KafkaConfiguration
{
Topics = new[] { "MyTopic" },
GroupId = "groupId"
};
_ = new TestConsumer(config);
}
protected override void ConfigureInputQueueEndpoint(IRabbitMqReceiveEndpointConfigurator configurator)
{
base.ConfigureInputQueueEndpoint(configurator);
configurator.ConnectManagementEndpoint(_management);
configurator.UseConcurrencyLimit(32, _management);
_consumer = new TestConsumer(TestTimeout);
_consumer.Configure(configurator);
}
protected override void ConfigureInputQueueEndpoint(IRabbitMqReceiveEndpointConfigurator configurator)
{
base.ConfigureInputQueueEndpoint(configurator);
configurator.ConnectManagementEndpoint(_management);
configurator.UseConcurrencyLimit(32, _management);
_consumer = new TestConsumer(TestTimeout);
_consumer.Configure(configurator);
}
public void GivenNoGroupId_ShouldThrowArgumentException()
{
var config = new KafkaConfiguration
{
Topics = new[] { "MyTopic" }
};
var exception = Assert.Throws <ArgumentException>(() =>
{
_ = new TestConsumer(config);
});
exception.Message.Should().Contain("'group.id'");
}
public void GivenNoTopics_ShouldThrowArgumentNullException()
{
var config = new KafkaConfiguration
{
Topics = null,
GroupId = "groupId"
};
var exception = Assert.Throws <ArgumentNullException>(() =>
{
_ = new TestConsumer(config);
});
exception.Message.Should().Contain(nameof(KafkaConfiguration.Topics));
}
public void GivenNoTopicInTopics_ShouldThrowArgumentNullException()
{
var config = new KafkaConfiguration
{
Topics = new [] { null as string },
GroupId = "groupId"
};
var exception = Assert.Throws <ArgumentNullException>(() =>
{
_ = new TestConsumer(config);
});
exception.Message.Should().Contain("topic");
}
public void Initialize_GivenNoTopics_ShouldThrowArgumentNullException()
{
var config = new KafkaConfiguration
{
};
var consumer = new TestConsumer();
var exception = Assert.Throws <ArgumentNullException>(() =>
{
consumer.Initialize(config);
});
exception.Message.Should().Contain(nameof(KafkaConfiguration.Topics));
}
public void timeouts_occur_gracefully()
{
var block = new ManualResetEvent(false);
var consumer = new TestConsumer();
var producer = new ZeroProducer<Message>("tcp://*:5562");
producer.AttachConsumer(consumer);
producer.TimedOut += delegate
{
block.Set();
};
block.WaitOne();
}
public void ActivateLog()
{
byte[] buffer = new byte[1024 * 1024 * 10];
LogTunnel tunnelLog;
m_log = tunnelLog = CreateLog();
m_cfl = new ContinuesBinaryFileLogger(new InMemoryStreamProvider(new MemoryStream(buffer)), new SyncSubmitLogEntryFactory(), BufferPoolFactory.Instance);
m_cfl.AttachToTunnelLog(tunnelLog);
var readerFactory = new WhitelogBinaryReaderFactory();
readerFactory.RegisterReaderFactory(new ExpandableLogReaderFactory());
m_testConsumer = new TestConsumer();
m_logReader = readerFactory.GetLogReader(new MemoryStream(buffer), m_testConsumer);
}
/// <summary>
/// Initializes a new instance of the <see cref="HomeController"/> class.
/// </summary>
/// <param name="options"></param>
/// <param name="logger">The logger.</param>
/// <param name="consumer"></param>
/// <param name="producer"></param>
/// <param name="admin"></param>
public HomeController(
IOptions <TestOptions> options,
ILogger <HomeController> logger,
TestConsumer consumer,
TestProducer producer,
TestAdmin admin)
{
this.logger = logger;
this.options = options;
this.consumer = consumer;
this.producer = producer;
this.admin = admin;
this.logger.LogDebug($"{nameof(HomeController)}: Was initialized.");
}
public void Initialize_GivenNoTopicInTopics_ShouldThrowArgumentNullException()
{
var config = new KafkaConfiguration
{
Topics = new [] { null as string }
};
var consumer = new TestConsumer();
var exception = Assert.Throws <ArgumentNullException>(() =>
{
consumer.Initialize(config);
});
exception.Message.Should().Contain("topic");
}
public void Initialize_IfAlreadyInitializedWithCtor_ShouldThrowInvalidOperationException()
{
var config = new KafkaConfiguration
{
GroupId = "groupId",
Topics = new [] { "topic" }
};
var consumer = new TestConsumer(config);
var exception = Assert.Throws <InvalidOperationException>(() =>
{
consumer.Initialize(config);
});
exception.Message.Should().Be("KafkaConsumer is already initialized.");
}
public async Task Tap_Should_Tap_Into_Stream()
{
var producer = Enumerable.Range(1, 10).AsProducer();
var consumer = new TestConsumer <int>();
var expected = producer.Outbox;
object actual = null;
producer
.Outbox
.Tap(x => actual = x)
.LinkTo(consumer.Inbox);
await Task.WhenAll(producer, consumer);
Assert.Equal(expected, actual);
}
public async Task Tap_Should_Not_Change_Stream()
{
var expected = Enumerable.Range(1, 10);
var producer = expected.AsProducer();
var consumer = new TestConsumer <int>();
producer
.Outbox
.Tap(x => {})
.LinkTo(consumer.Inbox);
await Task.WhenAll(producer, consumer);
var actual = consumer.Values;
Assert.Equal(expected, actual);
}
public void Should_send_AddInstanceSubscriptionMessage_on_subscribe()
{
var container = CreateContainer();
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
var consumer = new TestConsumer();
// purposefully not calling dispose on the result of this method
bus.AddInstanceSubscription(consumer);
}
var messages = testQueue2.GetAllMessages();
Assert.Equal(1, messages.Length);
Assert.Equal("Rhino.ServiceBus.Messages.AddInstanceSubscription", messages[0].Label);
}
public CombinedTestResult TestCacheIsSet(CacheConfiguration config, TestRequest payload)
{
// Arrange
var consumer = new TestConsumer();
consumer.InitData();
var message = new Message <TestRequest>(MessageLabel.From("message.label"), payload);
var context = new TestContext(message);
var sut = new CachingConsumerOf <TestRequest>(consumer, config);
// Act
sut.Handle(context);
// Assert
var cachedValue = config?.Cache.ContainsKey(message) ?? false ? ((TestResponse)config.Cache[message]).Value : null;
return(new CombinedTestResult(cachedValue, context.Response.Value));
}
public async Task Unicast(IEnumerable <int> expected, ChannelOptions options)
{
var producer = expected.AsProducer();
var consumer = new TestConsumer <int>();
producer
.Outbox
.LinkTo(consumer.Inbox, options);
await Task.WhenAll(
producer,
consumer
);
var actual = consumer.Values;
Assert.Equal(expected, actual);
}
public void can_add_consumer()
{
testConsumer = TestConsumer.ForDeposit(Keccak.Zero)
.WithNode(1).AddSession().WithUnpaidUnits(10)
.And.Build();
ConsumerNode consumerNode = testConsumer.Node(1).Node;
INdmProviderPeer consumerPeer = consumerNode.Peer;
ConsumerNode[] pre = sessionManager.GetConsumerNodes().ToArray();
bool consumerAlreadyAdded = pre.Contains(consumerNode);
Assert.IsTrue(!consumerAlreadyAdded);
providerService.AddConsumerPeer(consumerPeer);
var addedConsumer = sessionManager.GetConsumerNodes().Where(node => node.Peer.Equals(consumerPeer));
Assert.IsTrue(addedConsumer != null);
}
public void Should_send_RemoveInstanceSubscriptionMessage_on_unsubscribe()
{
var container = CreateContainer();
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
var consumer = new TestConsumer();
using (bus.AddInstanceSubscription(consumer))
{
}
}
var messages = testQueue2.GetAllMessages();
Assert.Equal(2, messages.Length);
Assert.Equal("Rhino.ServiceBus.Messages.AddInstanceSubscription", messages[0].Label);
Assert.Equal("Rhino.ServiceBus.Messages.RemoveInstanceSubscription", messages[1].Label);
}
public async Task WindowTest2()
{
var numbers = Enumerable.Range(0, 1000);
var expected = numbers
.GroupBy(i => i / 10)
.Select(group => group.ToList());
var producer = numbers.AsProducer();
var consumer = new TestConsumer <IList <int> >();
var actual = consumer.Values;
producer.Outbox
.Window(10, options: new BoundedChannelOptions(1))
.Select(window => window.Buffer())
.Concat()
.LinkTo(consumer.Inbox);
await Task.WhenAll(producer, consumer);
Assert.Equal(expected, actual);
}
public async Task Transform_Should_Be_Able_To_Change_Type()
{
var expected = Enumerable.Range(1, 1000);
var producer = expected.AsProducer();
var consumer = new TestConsumer <string>();
producer
.Outbox
.Transform(x => x.ToString())
.LinkTo(consumer.Inbox);
await Task.WhenAll(
producer,
consumer
);
var actual = consumer.Values.Select(int.Parse);
Assert.Equal(expected, actual);
}
internal void Test()
{
ILogger logger = new Logger();
IOverlappedProducer <List <int> > producer = new TestProducer();
IOverlappedConsumer <List <int> > consumer = new TestConsumer(52);
logger.Information("OverlappedJobTest.Test, Press a key to stop...");
IJobDirector director = new OverlappedJobDirector <List <int> >(producer, consumer, logger);
Task task = director.StartAsync();
Task.WaitAny(KeyPressed(), task);
logger.Information("----");
director.StopAsync().Wait();
task.Wait();
logger.Information("OverlappedJobTest.Test, Press a key to exit...");
KeyPressed().Wait();
}
public async Task will_send_early_refund_ticket()
{
testConsumer = TestConsumer.ForDeposit(Keccak.Zero)
.WithNode(1).AddSession().WithUnpaidUnits(10)
.And.Build();
await consumerRepository.AddAsync(testConsumer.Consumer);
var consumerNode = testConsumer.Node(1).Node;
sessionManager.AddPeer(consumerNode.Peer);
sessionManager.SetSession(consumerNode.Sessions.First(), consumerNode.Peer);
refundPolicy.GetClaimableAfterUnits(testConsumer.DepositId).Returns((uint)1);
var depositId = await providerService.SendEarlyRefundTicketAsync(testConsumer.DepositId);
consumerNode.Peer.Received().SendEarlyRefundTicket(Arg.Any <EarlyRefundTicket>(), RefundReason.DataDiscontinued);
Assert.IsNotNull(depositId);
}
public void SetUp()
{
sut = new TestConsumer<TestMessage>();
sut.Handle(new TestMessage());
sut.Handle(new TestMessage());
}
public void SetUp()
{
sut = new TestConsumer<TestMessage>();
}
public void ParseAssociation()
{
IAssociationStore store = new DumbStore();
TestConsumer consumer = new TestConsumer(store, new SimpleFetcher());
Association assoc = consumer.TestParseAssociation();
if (assoc == null)
{
TestTools.Assert(false, "TestParseAssociation return a null association");
}
else
{
string result = CryptUtil.ToBase64String(assoc.Secret);
TestTools.Assert(SERVER_SECRET == result, result);
}
}
