public void UnderlyingConnection_NoConnection_ReturnsNull() { // Arrange var factory = new FakeConnectionFactory(); // Act var result = factory.UnderlyingConnection; // Assert Assert.That(result,Is.Null); }
public void UnderlyingConnection_WithoutConnection_ReturnsEmptyList() { // Arrange var factory = new FakeConnectionFactory(); // Act var result = factory.UnderlyingModel; // Assert Assert.That(result, Is.Null); }
private void ConfigureQueueBinding(RabbitServer rabbitServer, string exchangeName, string queueName) { var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { channel.QueueDeclare(queue:queueName,durable:false,exclusive:false,autoDelete:false,arguments:null); channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Direct); channel.QueueBind(queueName,exchangeName,null); } }
public void WithRabbitServer_SetsServer() { // Arrange var factory = new FakeConnectionFactory(); var otherServer = new RabbitServer(); factory.WithRabbitServer(otherServer); // Act var result = factory.Server; // Assert Assert.That(result, Is.SameAs(otherServer)); }
public void WithConnection_WhenSet_SetsTheUnderlyingConnection() { // Arrange var factory = new FakeConnectionFactory(); var connection = new FakeConnection(new RabbitServer()); // Act factory.WithConnection(connection); // Assert Assert.That(factory.Connection,Is.SameAs(connection)); }
public void CreateConnection_ConnectionNotSupplied_ReturnsFakeConnection() { // Arrange var factory = new FakeConnectionFactory(); // Act var result = factory.CreateConnection(); // Assert Assert.That(result,Is.Not.Null); Assert.That(result,Is.InstanceOf<FakeConnection>()); Assert.That(factory.UnderlyingConnection, Is.SameAs(result)); }
public void UnderlyingConnection_WithConnection_ReturnsConnection() { // Arrange var factory = new FakeConnectionFactory(); var connection = new FakeConnection(new RabbitServer()); factory.WithConnection(connection); // Act var result = factory.UnderlyingConnection; // Assert Assert.That(result, Is.SameAs(connection)); }
public void ReceiveMessagesOnQueueWithBasicProperties() { var rabbitServer = new RabbitServer(); ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue"); var basicProperties = new BasicProperties { Headers = new Dictionary <string, object>() { { "TestKey", "TestValue" } }, CorrelationId = Guid.NewGuid().ToString(), ReplyTo = "TestQueue", Timestamp = new AmqpTimestamp(123456), ReplyToAddress = new PublicationAddress("exchangeType", "excahngeName", "routingKey"), ClusterId = "1", ContentEncoding = "encoding", ContentType = "type", DeliveryMode = 1, Expiration = "none", MessageId = "id", Priority = 1, Type = "type", UserId = "1", AppId = "1" }; SendMessage(rabbitServer, "my_exchange", "hello_world", basicProperties); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { // First message var message = channel.BasicGet("my_queue", noAck: false); Assert.That(message, Is.Not.Null); var messageBody = Encoding.ASCII.GetString(message.Body); Assert.That(messageBody, Is.EqualTo("hello_world")); var actualBasicProperties = message.BasicProperties; actualBasicProperties.ShouldBeEquivalentTo(basicProperties); channel.BasicAck(message.DeliveryTag, multiple: false); } }
public void TestMessageInQueue() { // Arrange Message message = new Message("Test Message"); ConnectionProperties connectionProperties = new ConnectionProperties("localhost", "test", "queue_vader", "queue_vader"); var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); ISendProcessor sendProcessor = new SendProcessor(connectionFactory, connectionProperties); // Act sendProcessor.SendToQueue(message); // Assert Assert.Equal(Encoding.UTF8.GetBytes("Test Message"), rabbitServer.Exchanges["test"].Messages.First().Body); }
public void CheckClosedConnection() { // Arrange Utils utils = new Utils(); var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); var connection = utils.SetupConnection(connectionFactory); // Act connection.Close(); // Assert Assert.False(connection.IsOpen); Assert.NotNull(connection.CloseReason); }
public void SendToExchangeOnly() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { const string message = "hello world!"; var messageBody = Encoding.ASCII.GetBytes(message); channel.BasicPublish(exchange:"my_exchange",routingKey:null,mandatory:false,basicProperties:null,body:messageBody); } Assert.That(rabbitServer.Exchanges["my_exchange"].Messages.Count,Is.EqualTo(1)); }
protected override void Before() { FakeConnectionFactory cf = new FakeConnectionFactory(); request = new IconUploadRequest(cf, WebsiteState, IconValidatorService, new FakeEmptyFileReceiver()); post = new IconPost() { Id = -1, Name = "test icon", Link = "a.com/b" }; }
public void SendToExchangeOnly() { // Arrange Message message = new Message("Test Message"); ConnectionProperties connectionProperties = new ConnectionProperties("localhost", "test", "queue_vader", "queue_vader"); var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); SendProcessor sendProcessor = new SendProcessor(connectionFactory, connectionProperties); // Act sendProcessor.SendToQueue(message); // Assert Assert.Equal(1, rabbitServer.Exchanges["test"].Messages.Count); }
public void SendToExchangeOnly() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { const string message = "hello world!"; var messageBody = Encoding.ASCII.GetBytes(message); channel.BasicPublish(exchange: "my_exchange", routingKey: null, mandatory: false, basicProperties: null, body: messageBody); } Assert.Single(rabbitServer.Exchanges["my_exchange"].Messages); }
public void ExecuteFullTest() { var operation = GetBasicAddQueueOperation() .SetMessageTimeToLive(5000) .SetAutoExpire(15000) .SetMaxLength(10000) .SetMaxLengthBytes(10000) .SetOverflowBehaviour("drop-head") .SetDeadLetterExchange("foo") .SetDeadLetterRoutingKey("bla") .SetMaxPriority(10) .SetLazyMode() .SetMasterLocation("server123"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { operation.Execute(connection, string.Empty); } Assert.AreEqual(1, server.Queues.Count); var queue = server.Queues.Values.First(); Assert.AreEqual(10, queue.Arguments.Count); Assert.IsTrue(queue.Arguments.ContainsKey("x-message-ttl")); Assert.AreEqual(5000, queue.Arguments["x-message-ttl"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-expires")); Assert.AreEqual(15000, queue.Arguments["x-expires"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-max-length")); Assert.AreEqual(10000, queue.Arguments["x-max-length"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-max-length-bytes")); Assert.AreEqual(10000, queue.Arguments["x-max-length-bytes"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-overflow")); Assert.AreEqual("drop-head", queue.Arguments["x-overflow"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-dead-letter-exchange")); Assert.AreEqual("foo", queue.Arguments["x-dead-letter-exchange"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-dead-letter-routing-key")); Assert.AreEqual("bla", queue.Arguments["x-dead-letter-routing-key"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-max-priority")); Assert.AreEqual(10, queue.Arguments["x-max-priority"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-queue-mode")); Assert.AreEqual("lazy", queue.Arguments["x-queue-mode"]); Assert.IsTrue(queue.Arguments.ContainsKey("x-queue-master-locator")); Assert.AreEqual("server123", queue.Arguments["x-queue-master-locator"]); }
public void SendToExchangeWithBoundQueue() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); ConfigureQueueBinding(rabbitServer, "my_exchange", "some_queue"); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { const string message = "hello world!"; var messageBody = Encoding.ASCII.GetBytes(message); channel.BasicPublish(exchange: "my_exchange", routingKey: null, mandatory: false, basicProperties: null, body: messageBody); } Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1)); }
public void SendMessageTest(string message, int expected) { var rabbitServer = GetConfiguredTestRabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); ConfigureQueueBinding(rabbitServer, queueName); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { var messageBody = Encoding.ASCII.GetBytes(message); channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: false, basicProperties: null, body: messageBody); } int actual = rabbitServer.Queues["iq-assessment"].Messages.Count; Assert.Equal(actual, expected); }
public void ExecuteTest() { var addBarQueueOperation = new AddQueueOperation() .SetName("bar"); var addFooExchangeOperation = new AddExchangeOperation() .SetName("foo"); var addTstQueueOperation = new AddQueueOperation() .SetName("tst") .AddQueueBind("foo", "bar"); var moveDataOperation = new MoveDataToExchangeOperation() .SetSourceQueueName("bar") .SetDestinationExchangeName("foo"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { addBarQueueOperation.Execute(connection, string.Empty); addFooExchangeOperation.Execute(connection, string.Empty); addTstQueueOperation.Execute(connection, string.Empty); using (var channel = connection.CreateModel()) { channel.ExchangeDeclare("", ExchangeType.Direct, true); channel.QueueBind("bar", "", "bar", null); for (int i = 0; i < 10; i++) { var props = channel.CreateBasicProperties(); props.Headers = new Dictionary <string, object>(); channel.BasicPublish("", "bar", false, props, Encoding.UTF8.GetBytes($"message{i}")); } } Assert.AreEqual(10, server.Queues.Values.First(x => x.Name == "bar").Messages.Count); Assert.AreEqual(0, server.Queues.Values.First(x => x.Name == "tst").Messages.Count); moveDataOperation.Execute(connection, string.Empty); Assert.AreEqual(0, server.Queues.Values.First(x => x.Name == "bar").Messages.Count); Assert.AreEqual(10, server.Queues.Values.First(x => x.Name == "tst").Messages.Count); } }
public void ExecuteTest() { var addOperation = new AddQueueOperation() .SetName("bar"); var delOperation = new DeleteQueueOperation() .SetName("bar"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { addOperation.Execute(connection, string.Empty); delOperation.Execute(connection, string.Empty); } Assert.AreEqual(0, server.Queues.Count); }
public async Task TestEventContractAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234", new Options() { Authenticator = new FakeAuthenticator() }); pusher.AddContract(EventContract.Create <FakeEvent>("fooHappened")); await pusher.ConnectAsync(); var sentEvent = new IncomingEvent <FakeEvent> { Channel = "foo", DataObject = new FakeEvent { Id = 1, Text = "foo" }, EventName = "fooHappened" }; var channel = await pusher.SubscribeToChannelAsync("foo"); var eventsReceived = 0; channel.GetEventSubscription <FakeEvent>().EventEmitted += (sender, receivedEvent) => { Assert.AreEqual(sentEvent.DataObject.Id, receivedEvent.DataObject.Id); Assert.AreEqual(sentEvent.DataObject.Text, receivedEvent.DataObject.Text); Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName); Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel); eventsReceived++; }; channel.EventEmitted += (sender, receivedEvent) => { Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName); Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel); eventsReceived++; Assert.AreEqual(typeof(IncomingEvent <FakeEvent>), receivedEvent.GetType()); }; factory.LastCreated.SendData(JsonConvert.SerializeObject(sentEvent)); Assert.AreEqual(2, eventsReceived); }
public async Task TestChannelTypesAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234", new Options() { Authenticator = new FakeAuthenticator() }); await pusher.ConnectAsync(); var privateChannel = await pusher.SubscribeToChannelAsync("private-foo"); var presenceChannel = await pusher.SubscribeToChannelAsync("presence-foo"); var normalChannel = await pusher.SubscribeToChannelAsync("foo"); Assert.AreEqual(typeof(PrivateChannel), privateChannel.GetType()); Assert.AreEqual(typeof(PresenceChannel), presenceChannel.GetType()); Assert.AreEqual(typeof(Channel), normalChannel.GetType()); }
public void ReceiveMessagesOnQueue_AutoAckEnabled() { var rabbitServer = new RabbitServer(); ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue"); SendMessage(rabbitServer, "my_exchange", "hello_world"); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { // First message var message = channel.BasicGet("my_queue", autoAck: true); Assert.That(message, Is.Not.Null); Assert.That(rabbitServer.Queues["my_queue"].Messages.Count == 0); } }
public void ExecuteFullTest() { var operation = GetBasicAddExchangeOperation() .SetAlternativeExchange("foo"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { operation.Execute(connection, string.Empty); } Assert.AreEqual(1, server.Exchanges.Count); var exchange = server.Exchanges.Values.First(); Assert.AreEqual(1, exchange.Arguments.Count); Assert.IsTrue(exchange.Arguments.Contains("alternate-exchange")); Assert.AreEqual("foo", exchange.Arguments["alternate-exchange"]); }
protected override void Before() { FakeConnectionFactory cf = new FakeConnectionFactory(); fileReceiver = new FakeFileReceiver(1, "Test File"); IconUploadRequest request = new IconUploadRequest(cf, WebsiteState, IconValidatorService, fileReceiver); IconPost post = new IconPost() { Id = -1, Name = "test icon", Link = LINK }; request.Process(post); newIcon = cf.IconInternal.Records.Single(); history = cf.IconHistoryInternal.Records.Single(); }
private PrepareHandlerMockResult BuildPrepareHandler(Action <TestConfigurationBuilder> configBuilderAct) { var factory = new FakeConnectionFactory(MockConnection); // create config var configBuilder = new TestConfigurationBuilder { ControlConnectionFactory = new FakeControlConnectionFactory(), ConnectionFactory = factory, Policies = new Cassandra.Policies(new RoundRobinPolicy(), new ConstantReconnectionPolicy(100), new DefaultRetryPolicy()) }; configBuilderAct(configBuilder); var config = configBuilder.Build(); var initializerMock = Mock.Of <IInitializer>(); Mock.Get(initializerMock).Setup(i => i.ContactPoints).Returns(new List <IPEndPoint> { new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9042), new IPEndPoint(IPAddress.Parse("127.0.0.2"), 9042), new IPEndPoint(IPAddress.Parse("127.0.0.3"), 9042) }); Mock.Get(initializerMock).Setup(i => i.GetConfiguration()).Returns(config); // create cluster var cluster = Cluster.BuildFrom(initializerMock, new List <string>()); cluster.Connect(); factory.CreatedConnections.Clear(); // create session var session = new Session(cluster, config, null, SerializerManager.Default, null); // create prepare handler var prepareHandler = new PrepareHandler(new SerializerManager(ProtocolVersion.V3).GetCurrentSerializer(), cluster); // create mock result object var mockResult = new PrepareHandlerMockResult(prepareHandler, session, factory); return(mockResult); }
public void ConsumeMessageTest(string producerMessage) { string expectedResponseMessage = string.Empty; string actualResponseMessage = string.Empty; string name; var rabbitServer = GetConfiguredTestRabbitServer(); SendMessage(rabbitServer, producerMessage); var connectionFactory = new FakeConnectionFactory(rabbitServer); using var connection = connectionFactory.CreateConnection(); using var channel = connection.CreateModel(); var consumer = new MessageConsumer(mockConsumerLogger.Object) { SettingsDictionary = new Dictionary <string, string> { ["ProducerMessagePrefix"] = producerMessagePrefix } }; var received = channel.BasicGet(queueName, autoAck: true); var messageBody = Encoding.ASCII.GetString(received.Body.ToArray()); if (consumer.IsValidMessage(messageBody, out name)) { actualResponseMessage = consumer.BuildResponseMessage(consumerMessagePrefix, name); expectedResponseMessage = string.Format(consumerMessagePrefix, name); } int expectedMessageCount = 0; int actualMessageCount = rabbitServer.Queues[queueName].Messages.Count; Assert.NotNull(producerMessage); Assert.NotNull(actualResponseMessage); Assert.NotNull(expectedResponseMessage); Assert.Equal(expectedMessageCount, actualMessageCount); Assert.Equal(expectedResponseMessage, actualResponseMessage); }
public void DoubleLockTest() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); var rabbitMqMigratorLock = new RabbitMqMigratorLock(connectionFactory); Assert.IsNotNull(rabbitMqMigratorLock); try { var rabbitMqMigratorLock2 = new RabbitMqMigratorLock(connectionFactory); Assert.IsNotNull(rabbitMqMigratorLock2); Assert.Fail(); } catch (OperationInterruptedException ex) { Assert.AreEqual(RabbitMqConstants.ResourceLocked, ex.ShutdownReason.ReplyCode); StringAssert.StartsWith(ex.ShutdownReason.ReplyText, "RESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'rmp.migrations.lock'"); } }
public void ExecuteFullTest() { var exchangeOperation = new AddExchangeOperation() .SetName("foo") .SetType(ExchangeType.Topic); var operation = new AddQueueOperation() .SetName("bar") .SetAutoDelete() .SetDurable(true) .SetExclusive() .AddArgument("foo", "foo-bar") .AddQueueBind("foo", "#"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { exchangeOperation.Execute(connection, string.Empty); operation.Execute(connection, string.Empty); } Assert.AreEqual(1, server.Queues.Count); var queue = server.Queues.Values.First(); Assert.AreEqual("bar", queue.Name); Assert.IsTrue(queue.IsAutoDelete); Assert.IsTrue(queue.IsDurable); Assert.IsTrue(queue.IsExclusive); Assert.AreEqual(1, queue.Arguments.Count); Assert.IsTrue(queue.Arguments.ContainsKey("foo")); Assert.AreEqual("foo-bar", queue.Arguments["foo"]); Assert.AreEqual(1, queue.Bindings.Count); var binding = queue.Bindings.First(); Assert.AreEqual("foo", binding.Value.Exchange.Name); Assert.AreEqual("bar", binding.Value.Queue.Name); Assert.AreEqual("#", binding.Value.RoutingKey); }
private ControlConnectionCreateResult CreateForContactPointTest(bool keepContactPointsUnresolved) { var connectionFactory = new FakeConnectionFactory(); var config = new TestConfigurationBuilder { ConnectionFactory = connectionFactory, KeepContactPointsUnresolved = keepContactPointsUnresolved }.Build(); _cp1 = new TestContactPoint(new List <IConnectionEndPoint> { new ConnectionEndPoint(_endpoint1, config.ServerNameResolver, _cp1) }); _cp2 = new TestContactPoint(new List <IConnectionEndPoint> { new ConnectionEndPoint(_endpoint2, config.ServerNameResolver, _cp2) }); _localhost = new TestContactPoint(new List <IConnectionEndPoint> { new ConnectionEndPoint(_endpoint1, config.ServerNameResolver, _localhost), new ConnectionEndPoint(_endpoint2, config.ServerNameResolver, _localhost) }); return(new ControlConnectionCreateResult { ConnectionFactory = connectionFactory, ControlConnection = new ControlConnection( Mock.Of <IInternalCluster>(), new ProtocolEventDebouncer( new FakeTimerFactory(), TimeSpan.Zero, TimeSpan.Zero), ProtocolVersion.V3, config, new Metadata(config), new List <IContactPoint> { _cp1, _cp2, _localhost }) }); }
public void TestRevertMigrations() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { channel.ExchangeDeclare("UnitTest.foo", ExchangeType.Direct, true); channel.QueueDeclare("UnitTest.bar", true); } var history = new Mock <IRabbitMqHistory>(); history.Setup(x => x.GetAppliedMigrations(It.IsAny <string>())).Returns <string>(prefix => new MigrationHistoryRow { Prefix = prefix, AppliedMigrations = new List <MigrationHistoryRowDetails> { new MigrationHistoryRowDetails { Name = "001_TestMigration" } } }); MigrationHistoryRow result = null; history.Setup(x => x.UpdateAppliedMigrations(It.IsAny <MigrationHistoryRow>())) .Callback <MigrationHistoryRow>(x => result = x); var migrator = new RabbitMqMigrator(connectionFactory, history.Object); migrator.RevertAll("UnitTest"); Assert.AreEqual(0, rabbitServer.Exchanges.Count); Assert.AreEqual(0, rabbitServer.Queues.Count); Assert.IsNotNull(result); Assert.AreEqual(0, result.AppliedMigrations.Count); }
public async Task TestRaiseAllEventsOnPusherAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234", new Options { RaiseAllEventsOnPusher = false }); await pusher.ConnectAsync(); var eventsOnPusher = 0; pusher.EventEmitted += (sender, evt) => eventsOnPusher++; var eventsOnChannel = 0; var channel = await pusher.SubscribeToChannelAsync("foo"); channel.EventEmitted += (sender, evt) => eventsOnChannel++; // the subscribe successful event is raised on channel, but it is raised before we can hook up the event Assert.AreEqual(0, eventsOnChannel); // RaiseAllEventsOnPusher = false prevents the subscribe successful event from being raised on pusher Assert.AreEqual(0, eventsOnPusher); }
public void TestMigrationAllReadyUp2DateSameHash() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); var history = new Mock <IRabbitMqHistory>(); history.Setup(x => x.GetAppliedMigrations(It.IsAny <string>())).Returns <string>(prefix => new MigrationHistoryRow { Prefix = prefix, AppliedMigrations = new List <MigrationHistoryRowDetails> { new MigrationHistoryRowDetails { Name = "001_TestMigration", Hash = "a6964237ffad49ed9492dca9318f9d793c64aa6d6c7645b7c0db0db9f68d3658" } } }); MigrationHistoryRow result = null; history.Setup(x => x.UpdateAppliedMigrations(It.IsAny <MigrationHistoryRow>())) .Callback <MigrationHistoryRow>(x => result = x); var migrator = new RabbitMqMigrator(connectionFactory, history.Object); migrator.UpdateModel("UnitTest"); Assert.AreEqual(0, rabbitServer.Exchanges.Count); Assert.AreEqual(0, rabbitServer.Queues.Count); Assert.IsNotNull(result); Assert.AreEqual(1, result.AppliedMigrations.Count); Assert.AreEqual("001_TestMigration", result.AppliedMigrations.First().Name); Assert.IsNotNull(result.AppliedMigrations.First().Hash); Assert.AreEqual("a6964237ffad49ed9492dca9318f9d793c64aa6d6c7645b7c0db0db9f68d3658", result.AppliedMigrations.First().Hash); }
public void LogInfo_nativeType_SendsMessage() { // Arrange var fakeConnectionFactory = new FakeConnectionFactory(); var appender = GetAppender(fakeConnectionFactory); BasicConfigurator.Configure(appender); var logger = LogManager.GetLogger(this.GetType()); // Act logger.Info(1); Thread.Sleep(2000); // Assert var publishedMessages = fakeConnectionFactory.UnderlyingModel.PublishedMessagesOnExchange("logging.test"); Assert.That(publishedMessages, Has.Count.EqualTo(1)); var messageBody = Encoding.UTF8.GetString(publishedMessages.First().body); Assert.That(messageBody, Is.EqualTo("1")); }
public void ExecuteMinimalTest() { var operation = new AddQueueOperation() .SetName("bar"); var server = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(server); using (var connection = connectionFactory.CreateConnection()) { operation.Execute(connection, string.Empty); } Assert.AreEqual(1, server.Queues.Count); var queue = server.Queues.Values.First(); Assert.AreEqual("bar", queue.Name); Assert.IsFalse(queue.IsAutoDelete); Assert.IsFalse(queue.IsDurable); Assert.IsFalse(queue.IsExclusive); Assert.AreEqual(0, queue.Arguments.Count); Assert.AreEqual(0, queue.Bindings.Count); }
public void ReceiveMessagesOnQueue() { var rabbitServer = new RabbitServer(); ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue"); SendMessage(rabbitServer, "my_exchange", "hello_world"); var connectionFactory = new FakeConnectionFactory(rabbitServer); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { // First message var message = channel.BasicGet("my_queue", autoAck: false); Assert.That(message, Is.Not.Null); var messageBody = Encoding.ASCII.GetString(message.Body.Span); Assert.That(messageBody, Is.EqualTo("hello_world")); channel.BasicAck(message.DeliveryTag, multiple: false); } }
public void SendingAndGettingMultipleMessages() { var rabbitServer = new RabbitServer(); var connectionFactory = new FakeConnectionFactory(rabbitServer); ConfigureQueueBinding(rabbitServer, "my_exchange", "some_queue"); using (var connection = connectionFactory.CreateConnection()) using (var channel = connection.CreateModel()) { const string message = "hello world!"; var messageBody = Encoding.ASCII.GetBytes(message); channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody); channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody); var result = channel.BasicGet("some_queue", false); Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(2)); channel.BasicAck(result.DeliveryTag, false); Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1)); result = channel.BasicGet("some_queue", false); Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1)); channel.BasicAck(result.DeliveryTag, false); Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(0)); } }
public async Task TestPusherEventsAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234", new Options { RaiseAllEventsOnPusher = true }); var events = new List<IIncomingEvent>(); pusher.GetEventSubscription<ConnectionEstablishedEventArgs>().EventEmitted += (sender, evt) => { Assert.AreEqual(evt.DataObject.SocketId, "a"); Assert.AreEqual(evt.EventName, "pusher:connection_established"); events.Add(evt); }; await pusher.ConnectAsync(); Assert.AreEqual(1, events.Count); events.Clear(); pusher.GetEventSubscription<SubscriptionSucceededEventArgs>().EventEmitted += (sender, evt) => { Assert.AreEqual(evt.Channel, "foo"); Assert.AreEqual(evt.EventName, "pusher_internal:subscription_succeeded"); events.Add(evt); }; await pusher.SubscribeToChannelAsync("foo"); Assert.AreEqual(1, events.Count); }
public async Task TestEventContractAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234", new Options() { Authenticator = new FakeAuthenticator() }); pusher.AddContract(EventContract.Create<FakeEvent>("fooHappened")); await pusher.ConnectAsync(); var sentEvent = new IncomingEvent<FakeEvent> { Channel = "foo", DataObject = new FakeEvent {Id = 1, Text = "foo"}, EventName = "fooHappened" }; var channel = await pusher.SubscribeToChannelAsync("foo"); var eventsReceived = 0; channel.GetEventSubscription<FakeEvent>().EventEmitted += (sender, receivedEvent) => { Assert.AreEqual(sentEvent.DataObject.Id, receivedEvent.DataObject.Id); Assert.AreEqual(sentEvent.DataObject.Text, receivedEvent.DataObject.Text); Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName); Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel); eventsReceived++; }; channel.EventEmitted += (sender, receivedEvent) => { Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName); Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel); eventsReceived++; Assert.AreEqual(typeof(IncomingEvent<FakeEvent>), receivedEvent.GetType()); }; factory.LastCreated.SendData(JsonConvert.SerializeObject(sentEvent)); Assert.AreEqual(2, eventsReceived); }
public async Task TestMissingAuthenticatorThrowsExceptionAsync() { var factory = new FakeConnectionFactory(); var pusher = new Pusher(factory, "abcd1234"); await pusher.ConnectAsync(); Assert.ThrowsException<AggregateException>(() => pusher.SubscribeToChannelAsync("private-foo").Wait()); }