public void Can_Update_Key_For_Item()
{
// Arrange
var page = new Page { Name = "New Page" };
var model = new FakeModel();
var culture = new CultureInfo("en");
var site = new Site("English", culture);
site.Trie = CreateTrie();
var session = new Mock<IAsyncDocumentSession>();
session.Setup(documentSession => documentSession.StoreAsync(page, CancellationToken.None));
session.Setup(documentSession => documentSession.LoadAsync<Site>("sites/en", CancellationToken.None))
.ReturnsAsync(site);
// Act
var operation = new AsyncLocalizationOperation(session.Object, culture);
operation.Page = new Page { Id = "articles/1" };
Task task = Task.Run(() => operation.ForModel(model).ForUrl("/changed-slug").StoreAsync(page));
task.Wait();
// Assert
Assert.True(task.IsCompleted);
Assert.Equal(3, site.Trie.Count);
Assert.True(site.Trie.Keys.Contains("/changed-slug"));
}
public void ChannelFlow_SetsIfTheChannelIsActive(bool value)
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.ChannelFlow(value);
// Assert
Assert.That(model.IsChannelFlowActive,Is.EqualTo(value));
}
public void CreateStreamProperties_ReturnsStreamProperties()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
var result = model.CreateStreamProperties();
// Assert
Assert.That(result, Is.Not.Null);
}
public void Should_pass_model_instance_to_validator()
{
// Given
var model = new FakeModel();
var validator = A.Fake<IModelValidator>();
A.CallTo(() => validatorLocator.GetValidatorForType(A<Type>.Ignored)).Returns(validator);
// When
subject.Validate(model);
// Then
A.CallTo(() => validator.Validate(model, A<NancyContext>._)).MustHaveHappened();
}
public void ExchangeDeclare_AllArguments_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
const bool isAutoDelete = false;
var arguments = new Hashtable();
// Act
model.ExchangeDeclare(exchange:exchangeName,type:exchangeType,durable:isDurable,autoDelete:isAutoDelete,arguments:arguments);
// Assert
Assert.That(node.Exchanges,Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, isAutoDelete, arguments, isDurable, exchangeType);
}
public void Should_add_errors_to_existing_module_errors()
{
//Given
subject.ModelValidationResult =
new ModelValidationResult(new[] { new ModelValidationError("FirstName", "Please enter a name") });
var model = new FakeModel();
var validator = A.Fake<IModelValidator>();
A.CallTo(() => validatorLocator.GetValidatorForType(A<Type>.Ignored)).Returns(validator);
A.CallTo(() => validator.Validate(model, A<NancyContext>._))
.Returns(
new ModelValidationResult(new[] { new ModelValidationError("LastName", "Please enter a last name") }));
// When
subject.Validate(model);
// Then
subject.ModelValidationResult.Errors.ShouldHaveCount(2);
}
public void QueueDeclare_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = false;
var arguments = new Dictionary <string, object>();
// Act
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
var queue = node.Queues.First();
AssertQueueDetails(queue, queueName, isAutoDelete, arguments, isDurable, isExclusive);
}
public void QueueUnbind_RemovesBinding()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
model.ExchangeBind(exchangeName, queueName, routingKey, arguments);
// Act
model.QueueUnbind(queueName, exchangeName, routingKey, arguments);
// Assert
Assert.That(node.Exchanges[exchangeName].Bindings, Is.Empty);
Assert.That(node.Queues[queueName].Bindings, Is.Empty);
}
public void ExchangeDeclareNoWait_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
const bool isAutoDelete = false;
var arguments = new Dictionary <string, object>();
// Act
model.ExchangeDeclareNoWait(exchange: exchangeName, type: exchangeType, durable: isDurable, autoDelete: isAutoDelete, arguments: arguments);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, isAutoDelete, arguments, isDurable, exchangeType);
}
public void BasicGet_MessageOnQueue_GetsMessage()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Act
var response = model.BasicGet("my_queue", false);
// Assert
Assert.That(response.Body, Is.EqualTo(encodedMessage));
Assert.That(response.DeliveryTag, Is.GreaterThan(0));
}
public void QueueDeclare_WithExclusive_DifferentModel_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
var model2 = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = true;
var arguments = new Dictionary <string, object>();
// Act
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
var ex = Assert.Throws <OperationInterruptedException>(
delegate { model2.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments); });
// Assert
Assert.That(ex.ShutdownReason.ReplyCode, Is.EqualTo(405));
Assert.That(ex.ShutdownReason.Initiator, Is.EqualTo(ShutdownInitiator.Peer));
StringAssert.StartsWith($"RESOURCE_LOCKED - cannot obtain exclusive access to locked queue '{queueName}'", ex.ShutdownReason.ReplyText);
}
public void Execute_returns_result_of_last_filter()
{
// Arrange
var newValue = fixture.Create <FakeModel>();
var lastValue = fixture.Create <FakeModel>();
var firstResult = fixture.Create <FakeModel>();
var firstFilter = Mock.Of <IStreamFilter <FakeModel> >(
x => x.Execute(newValue, lastValue) == firstResult);
var secondResult = fixture.Create <FakeModel>();
var secondFilter = Mock.Of <IStreamFilter <FakeModel> >(
x => x.Execute(firstResult, lastValue) == secondResult);
var sut = new CompositeStreamFilter <FakeModel>(
firstFilter, secondFilter);
// Act
FakeModel actual = sut.Execute(newValue, lastValue);
// Assert
actual.Should().BeSameAs(secondResult);
}
public void SetUp()
{
model = new FakeModel
{
Title = "Test Title",
Date = DateTime.Now,
Done = true,
Id = 123,
Person = new FakeChildModel {
FirstName = "Mick", LastName = "Jagger"
},
Numbers = new [] { 1, 3 },
Customers = new List <FakeChildModel>
{
new FakeChildModel {
FirstName = "John", LastName = "Wyane", Balance = 123.33m
},
new FakeChildModel {
FirstName = "Marlin", LastName = "Brando", Balance = 234.56m
}
}
};
}
public void QueuePurge_RemovesAllMessagesFromQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.QueueDeclarePassive("my_other_queue");
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
model.QueueDeclarePassive("my_queue");
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
// Act
model.QueuePurge("my_queue");
// Assert
Assert.That(node.Queues["my_queue"].Messages, Is.Empty);
Assert.That(node.Queues["my_other_queue"].Messages, Is.Not.Empty);
}
public void BasicAck()
{
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, new EventingBasicConsumer(model));
// Act
var deliveryTag = model.WorkingMessages.First().Key;
model.BasicAck(deliveryTag, false);
// Assert
Assert.That(node.Queues["my_queue"].Messages.Count, Is.EqualTo(0));
}
public void Nacking_Message_Should_Not_Reenqueue_Brand_New_Message(bool requeue, int expectedMessageCount)
{
// arrange
var node = new RabbitServer();
var model = new FakeModel(node);
var consumer = new QueueingBasicConsumer();
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, consumer);
// act
consumer.Queue.TryDequeue(out var message);
model.BasicNack(message.DeliveryTag, false, requeue);
// assert
Assert.That(consumer.Queue.Count, Is.EqualTo(expectedMessageCount));
Assert.That(model.WorkingMessages.Count, Is.EqualTo(expectedMessageCount));
}
public void GetModel_ByFilterExpression_ReturnsModel <TEntity, TKey>(
TKey defaultKey,
TEntity entity,
Expression <Func <TEntity, bool> > filterExpression)
where TEntity : class, IEntity <TKey>
{
// Arrange
var model = new FakeModel();
var mockRepository = new Mock <IRepository <TEntity, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.Get <FakeModel>(
It.Is <QueryParameters <TEntity, TKey> >(
y => y.Filter.Expression == filterExpression &&
y.Sort == null &&
y.Page == null
)
)
)
.Returns(model);
var repository = mockRepository.Object;
// Act
var result = repository.Get <FakeModel, TEntity, TKey>(filterExpression);
// Assert
if (entity != null && entity.Id != null)
{
Assert.IsType(defaultKey.GetType(), entity.Id);
}
Assert.Equal(model, result);
}
public void ExchangeDeleteNoWait_ExchangeExists_RemovesTheExchange(bool ifUnused)
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDeleteNoWait(exchange: exchangeName, ifUnused: ifUnused);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(0));
}
public void sut_implements_IModel()
{
var sut = new FakeModel(Guid.NewGuid());
sut.Should().BeAssignableTo <IModel <Guid> >();
}
public void ExchangeDelete_ExchangeDoesNotExists_DoesNothing()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDelete(exchange: "someOtherExchange");
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
}
public void QueueBind_BindsAnExchangeToAQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Hashtable();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
// Act
model.QueueBind(queueName, exchangeName, routingKey, arguments);
// Assert
AssertBinding(node, exchangeName, routingKey, queueName);
}
public void QueueDeleteNoWait_WithArguments_DeletesTheQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someName";
model.QueueDeclare(queueName, true, true, true, null);
// Act
model.QueueDeleteNoWait(queueName, true, true);
// Assert
Assert.That(node.Queues, Is.Empty);
}
protected override void EstablishContext()
{
MockConfigValueProvider();
MockInvocation("ObjectMethod");
MockCacheKeyGenerator("abc");
suppliedCacheValue = new FakeModel { Id = 1, Name = "One" };
MockCacheProvider("abc", binaryFormatterSerializer.Serialize(suppliedCacheValue), true);
}
public IEnumerable <FakeModel> getStudentsWithIndividualSubjectMarks(Boolean sortTable = false, Boolean showStatus = false, Boolean addGrace = false)
{
List <FakeModel> list = new List <FakeModel>();
FakeModel obj = new FakeModel();
var allStudents = getAllStudents();
//var query = allstudents
// .groupby(s => s.fstudentname)
// .select(g => new
// {
// studentname = g.key,
// ec1 = g.where(s => s.fsubject == "ec1").select(s => s.fmarks),
// ec2 = g.where(s => s.fsubject == "ec2").select(s => s.fmarks),
// ec3 = g.where(s => s.fsubject == "ec3").select(s => s.fmarks),
// ec4 = g.where(s => s.fsubject == "ec4").select(s => s.fmarks),
// ec5 = g.where(s => s.fsubject == "ec5").select(s => s.fmarks)
// });
Console.WriteLine("**********************", allStudents);
foreach (var q in allStudents)
{
if (q.Fsubject == "EC1")
{
obj = new FakeModel();
obj.studentName = q.FstudentName;
obj.EC1 = q.Fmarks;
obj.Total = obj.EC1;
if (q.Fmarks < 30)
{
obj.Status = "Fail";
obj.TotalFailedSubjects += 1;
}
else
{
obj.Status = "Pass";
}
}
if (q.Fsubject == "EC2")
{
obj.EC2 = q.Fmarks;
obj.Total += obj.EC2;
if (q.Fmarks < 30)
{
obj.Status = "Fail";
obj.TotalFailedSubjects += 1;
}
}
if (q.Fsubject == "EC3")
{
obj.EC3 = q.Fmarks;
obj.Total += obj.EC3;
if (q.Fmarks < 30)
{
obj.Status = "Fail";
obj.TotalFailedSubjects += 1;
}
}
if (q.Fsubject == "EC4")
{
obj.EC4 = q.Fmarks;
obj.Total += obj.EC4;
if (q.Fmarks < 30)
{
obj.Status = "Fail";
obj.TotalFailedSubjects += 1;
}
}
if (q.Fsubject == "EC5")
{
obj.EC5 = q.Fmarks;
obj.Total += obj.EC5;
if (q.Fmarks < 30)
{
obj.Status = "Fail";
obj.TotalFailedSubjects += 1;
}
list.Add(obj);
}
}
if (sortTable)
{
return(list.OrderByDescending(q => q.Total));
}
if (addGrace)
{
return(Grace());
}
return(list);
}
public void BasicGet_MessageOnQueue_GetsMessage()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Act
var response = model.BasicGet("my_queue",false);
// Assert
Assert.That(response.Body, Is.EqualTo(encodedMessage));
Assert.That(response.DeliveryTag, Is.GreaterThan(0));
}
public void QueueDeclare_NoArguments_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.QueueDeclare();
// Assert
Assert.That(node.Queues,Has.Count.EqualTo(1));
}
public void BasicPublish_PublishesMessage()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange",ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
// Act
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Assert
Assert.That(node.Queues["my_queue"].Messages.Count,Is.EqualTo(1));
Assert.That(node.Queues["my_queue"].Messages.First().Body, Is.EqualTo(encodedMessage));
}
public void Abort_WithArguments_ClosesTheChannel()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.Abort(5, "some message");
// Assert
Assert.That(model.IsClosed, Is.True);
Assert.That(model.IsOpen, Is.False);
Assert.That(model.CloseReason, Is.Not.Null);
}
public void Close_ClosesTheChannel()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.Close();
// Assert
Assert.That(model.IsClosed,Is.True);
Assert.That(model.IsOpen,Is.False);
Assert.That(model.CloseReason,Is.Not.Null);
}
public void QueueDeclarePassive_WithName_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "myQueue";
// Act
model.QueueDeclarePassive(queueName);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
Assert.That(node.Queues.First().Key, Is.EqualTo(queueName));
Assert.That(node.Queues.First().Value.Name, Is.EqualTo(queueName));
}
public void QueueDelete_NonExistentQueue_DoesNothing()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.QueueDelete("someQueue");
// Assert
Assert.That(node.Queues, Is.Empty);
}
public void ExchangeDeclarePassive_WithName_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
// Act
model.ExchangeDeclarePassive(exchange: exchangeName);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, false, null, false, null);
}
public void BasicGet_NoQueue_ReturnsNull()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
var response = model.BasicGet("my_queue", false);
// Assert
Assert.That(response, Is.Null);
}
public void QueueUnbind_RemovesBinding()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Hashtable();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
model.ExchangeBind(exchangeName, queueName, routingKey, arguments);
// Act
model.QueueUnbind(queueName, exchangeName, routingKey, arguments);
// Assert
Assert.That(node.Exchanges[exchangeName].Bindings, Is.Empty);
Assert.That(node.Queues[queueName].Bindings, Is.Empty);
}
protected override void EstablishContext()
{
MockConfigValueProvider();
MockInvocation("ObjectMethod");
MockCacheKeyGenerator("abc");
suppliedCacheValue = new FakeModel { Id = 1, Name = "One" };
invocation.ReturnValue = suppliedCacheValue;
//Create Default cache provider without the cache value.
defaultCacheProvider = MockCacheProvider();
//Populate constraintBag with with values passed to insert.
defaultCacheProvider.Expect(x => x.Insert(null, null, DateTime.Now, TimeSpan.Parse("1:00")));
constraintBag = new ExpandoObject();
LastCall.Constraints(
new ActionConstraint<string>(x => constraintBag.key = x),
new ActionConstraint<object>(x => constraintBag.value = x),
new ActionConstraint<DateTime>(x => constraintBag.absoluteExpiration = x),
new ActionConstraint<TimeSpan>(x => constraintBag.slidingExpiration = x)
);
secondaryCacheProvider = MockCacheProvider();
//Populate constraintBag with with values passed to insert.
secondaryCacheProvider.Expect(x => x.Insert(null, null, DateTime.Now, TimeSpan.Parse("1:00")));
secondaryConstraintBag = new ExpandoObject();
LastCall.Constraints(
new ActionConstraint<string>(x => secondaryConstraintBag.key = x),
new ActionConstraint<object>(x => secondaryConstraintBag.value = x),
new ActionConstraint<DateTime>(x => secondaryConstraintBag.absoluteExpiration = x),
new ActionConstraint<TimeSpan>(x => secondaryConstraintBag.slidingExpiration = x)
);
cacheProviders = new[] { defaultCacheProvider, secondaryCacheProvider };
}
public void ExchangeDeclare_WithNameTypeAndDurable_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
// Act
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType, durable: isDurable);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, false, null, isDurable, exchangeType);
}
public void QueuePurge_RemovesAllMessagesFromQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.QueueDeclarePassive("my_other_queue");
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
model.QueueDeclarePassive("my_queue");
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
// Act
model.QueuePurge("my_queue");
// Assert
Assert.That(node.Queues["my_queue"].Messages, Is.Empty);
Assert.That(node.Queues["my_other_queue"].Messages, Is.Not.Empty);
}
public void QueueDeclare_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = false;
var arguments = new Hashtable();
// Act
model.QueueDeclare(queue:queueName,durable:isDurable,exclusive:isExclusive,autoDelete:isAutoDelete,arguments:arguments);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
var queue = node.Queues.First();
AssertQueueDetails(queue, queueName, isAutoDelete, arguments, isDurable, isExclusive);
}
