public void ServicePublishesMessages()
{
var logger = new Mock<ILogger>();
var repo = new Mock<IRepository<SampleEntity>>();
var env = new Mock<IEnvironment>();
var bus = BusFactory.CreateMessageBus();
var queue = QueueFactory.CreatQueue(bus);
var exchange = ExchangeFactory.CreatExchange(bus);
bus.Bind(exchange, queue, "A.*");
var publisher = new MessagePublisher(bus, logger.Object, exchange,queue);
var dataOps = new DataOperations(logger.Object, publisher,repo.Object,env.Object);
var filter = new MessageFilter(env.Object, logger.Object);
var logicClass = new MessageRouter(logger.Object, dataOps, filter);
var messageData = TestMessages.GetTestCreateSampleEntityMessage();
env.Setup(e => e.GetServiceName()).Returns("Fake-Service");
env.Setup(e => e.GetServiceVersion()).Returns(2);
var newEntities = new List<SampleEntity>();
var entity = new SampleEntity
{
UpdatedDate = DateTime.UtcNow,
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid().ToString(),
NewDecimalValue = 1.02M,
NewGuidValue = Guid.NewGuid(),
NewIntValue = 3,
NewStringValue = "test"
};
newEntities.Add(entity);
var recivedMessages = new List<dynamic>();
var consumer = bus.Consume<object>(queue, (message, info) =>
Task.Factory.StartNew(() =>
recivedMessages.Add(message)
)
);
logicClass.RouteSampleMessage(messageData);
System.Threading.Thread.Sleep(5000);
consumer.Dispose();
Assert.IsTrue(recivedMessages.Count >= 1);
}
public void DeleteOperationLogsUnableToRemoveEntity()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new Mock<IRepository<SampleEntity>>();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo.Object, env.Object);
var message = TestMessages.GetTestDeleteSampleEntityMesssage();
var entitys = TestEntities.SetUpSampleEntities(message);
var logResponse = new List<string>();
var responseList = new List<dynamic>();
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<dynamic, string>((msg, str) => responseList.Add(msg));
logger.Setup(l => l.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()))
.Callback<Exception, string, object[]>((ex, msg, obj) => logResponse.Add(msg));
repo.Setup(r => r.Delete(It.IsAny<string>())).Throws(new Exception("test exception"));
logicClass.DeleteSampleEntities(message);
Assert.IsTrue(logResponse[0].Contains("Faild to remove entity"));
}
public void DeleteOperationLogsEntityToBeRemoved()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
var message = TestMessages.GetTestDeleteSampleEntityMesssage();
var entitys = TestEntities.SetUpSampleEntities(message);
var logResponse = new List<string>();
var responseList = new List<dynamic>();
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<dynamic, string>((msg, str) => responseList.Add(msg));
logger.Setup(l => l.Info(It.IsAny<string>(), It.IsAny<object[]>()))
.Callback<string, object[]>((msg, obj) => logResponse.Add(msg));
repo.Entities = entitys;
logicClass.DeleteSampleEntities(message);
Assert.IsTrue(logResponse[0].Contains("Removing entity"));
}
public void PutOperationUpdatesEntity()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
var message = TestMessages.GetTestUpdateSampleEntityMesssage();
var entitys = TestEntities.SetUpSampleEntityFromMessage(message);
var responseList = new List<dynamic>();
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<dynamic, string>((msg, str) => responseList.Add(msg));
message.Needs[0].NewStringValue = "Updated Test";
message.Needs[0].NewIntValue = 456;
repo.Entities = entitys;
logicClass.UpdateSampleEntities(message);
Assert.IsTrue(repo.Entities[0].NewStringValue == "Updated Test");
}
public void PostOperationWith2SolutionsLogsSuccessfullStoreOfEntitieTwice()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
var invocations = new List<string>();
logger.Setup(l => l.Info(It.IsAny<string>(), It.IsAny<object>()))
.Callback<string, object[]>((message, obj) => invocations.Add(message));
logicClass.CreateSampleEntities(TestMessages.GetTestCreateSampleEntityMessageWithMultiple());
Assert.IsTrue(invocations[1].Contains("Created entity"));
Assert.IsTrue(invocations[2].Contains("Created entity"));
Assert.IsTrue(invocations.Count == 3);
}
public void PutOperationLogsUpdateFailed()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new Mock<IRepository<SampleEntity>>();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo.Object, env.Object);
var message = TestMessages.GetTestUpdateSampleEntityMesssage();
var entitys = TestEntities.SetUpSampleEntityFromMessage(message);
var logResponse = new List<string>();
var responseList = new List<dynamic>();
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<dynamic, string>((msg, str) => responseList.Add(msg));
logger.Setup(l => l.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()))
.Callback<Exception, string, object[]>((ex, msg, obj) => logResponse.Add(msg));
repo.Setup(r => r.Update(It.IsAny<List<SampleEntity>>())).Throws(new Exception("test exception"));
message.Needs[0].NewStringValue = "Updated Test";
message.Needs[0].NewIntValue = 456;
logicClass.UpdateSampleEntities(message);
Assert.IsTrue(logResponse[0].Contains("Unable to update entity"));
}
public void PostOperationRaisesNewEvent()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
var loggerInvocations = new List<string>();
var messageInvocations = new List<dynamic>();
logger.Setup(l => l.Info(It.IsAny<string>(), It.IsAny<object>()))
.Callback<string, object[]>((message, obj) => loggerInvocations.Add(message));
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<object, string>((msg, str) => messageInvocations.Add(msg));
logicClass.CreateSampleEntities(TestMessages.GetTestCreateSampleEntityMessageWithMultiple());
Assert.IsTrue(messageInvocations.Count > 0);
}
public void PostOperationRaisesFailEventIfUnableToStore()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new Mock<IRepository<SampleEntity>>();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo.Object, env.Object);
var invocations = new List<string>();
var messageInvocations = new List<dynamic>();
logger.Setup(l => l.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()))
.Callback<Exception, string, object[]>((ex, message, obj) => invocations.Add(message));
repo.Setup(r => r.Add(It.IsAny<IEnumerable<SampleEntity>>())).Throws(new Exception("Test exception"));
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<object, string>((msg, str) => messageInvocations.Add(msg));
logicClass.CreateSampleEntities(TestMessages.GetTestCreateSampleEntityMessageWithMultiple());
Assert.IsTrue(invocations[0].Contains("Test Error")); //what the hell should we check for));
}
public void PostOperationLogsErrorIfUnableToStore()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new Mock<IRepository<SampleEntity>>();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo.Object, env.Object);
var invocations = new List<string>();
logger.Setup(l => l.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()))
.Callback<Exception, string, object[]>((ex, message, obj) => invocations.Add(message));
repo.Setup(r => r.Add(It.IsAny<IEnumerable<SampleEntity>>())).Throws(new Exception("Test exception"));
logicClass.CreateSampleEntities(TestMessages.GetTestCreateSampleEntityMessageWithMultiple());
Assert.IsTrue(invocations[0].Contains("Unable to create entity"));
}
public void PostOperationCreatesSingleDataEntity()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
logicClass.CreateSampleEntities(TestMessages.GetTestCreateSampleEntityMessage());
Assert.IsTrue(repo.Entities.Count.Equals(1));
}
public void GetOperationRetrivesSingleEntityByPrimaryKey()
{
var publisher = new Mock<IMessagePublisher>();
var logger = new Mock<ILogger>();
var repo = new FakeRepository();
var env = new Mock<IEnvironment>();
var logicClass = new DataOperations(logger.Object, publisher.Object, repo, env.Object);
var message = TestMessages.GetTestReadSampleEntityMessage();
var entitys = TestEntities.SetUpSampleEntities(message);
var responseList = new List<dynamic>();
publisher.Setup(p => p.Publish(It.IsAny<object>(), It.IsAny<string>())).Callback<dynamic, string>((msg, str) => responseList.Add(msg));
repo.Entities = entitys;
logicClass.GetSampleEntities(message);
var result = JObject.Parse(responseList[0]);
Assert.IsTrue(message.Needs[0].SampleUuid.ToString() == result.Solutions[0].SampleUuid.ToString());
}
