/// <exception cref="NotSupportedMessageException">Raised when message type is not supported</exception>
public IMessageHandler CreateHandler <T>()
{
var configuration = new AppConfigConfiguration();
var csProvider = new ConnectionStringProvider();
var dbCommands = new DatabaseCommands(csProvider, configuration);
var messagingLogger = new MessagingLogger(dbCommands);
if (typeof(T) == typeof(PriceBandUpdated))
{
var validator = new PriceBandUpdatedValidator(dbCommands);
return(new PriceBandEventHandler(dbCommands, validator, messagingLogger, configuration));
}
if (typeof(T) == typeof(AccountCreated))
{
var validator = new AccountCreatedValidator(dbCommands);
var handler = new AccountCreatedEventHandler(dbCommands, validator, configuration, messagingLogger);
handler.OnProcessed += SendMessage;
return(handler);
}
if (typeof(T) == typeof(AccountCreateFailed))
{
var validator = new AccountCreateFailedValidator(dbCommands);
return(new AccountCreateFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountUpdated))
{
var validator = new AccountUpdatedValidator(dbCommands);
return(new AccountUpdatedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountUpdateFailed))
{
var validator = new AccountUpdateFailedValidator(dbCommands);
return(new AccountUpdateFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountStatusChanged))
{
var validator = new AccountStatusChangedValidator(dbCommands);
return(new AccountStatusChangedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountStatusChangeFailed))
{
var validator = new AccountStatusChangeFailedValidator(dbCommands);
return(new AccountStatusChangeFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(FileUploadCompleted))
{
var validator = new FileUploadEventValidator(dbCommands);
return(new FileUploadCompletedHandler(dbCommands, validator, messagingLogger));
}
throw new NotSupportedMessageException(string.Format("Message type {0} is not supported.", typeof(T).Name));
}
public void Should_create_a_new_user()
{
const int LOGIN_ID = 123;
const string USERNAME = "******";
const string FIRST_NAME = "first_name";
const string LAST_NAME = "last_name";
const string EMAIL_ADDRESS = "email";
var externalId = Guid.NewGuid().ToString();
var builder = AccountCreated.CreateBuilder();
builder
.SetInternalId(LOGIN_ID.ToString())
.SetUsername(USERNAME)
.SetFirstName(FIRST_NAME)
.SetLastName(LAST_NAME)
.SetEmailAddress(EMAIL_ADDRESS)
.SetSource(SourceSystem.STARCHEF)
.SetExternalId(externalId);
var payload = builder.Build();
var validator = new Mock <IEventValidator>();
validator.Setup(m => m.IsAllowedEvent(It.IsAny <object>())).Returns(true);
validator.Setup(m => m.IsValidPayload(It.IsAny <object>())).Returns(true);
var messagingLogger = new Mock <IMessagingLogger>();
var dbCommands = new Mock <IDatabaseCommands>();
dbCommands.Setup(m => m.IsUserExists(It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(false)); // user is not exists
var config = new Mock <IConfiguration>();
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator.Object, config.Object, messagingLogger.Object);
// act
var result = handler.HandleAsync(payload, "1").Result;
// assertions
Assert.Equal(MessageHandlerResult.Success, result);
// while check loginId AND loginName are used
dbCommands.Verify(m => m.IsUserExists(It.Is <int?>(p => p.Value == LOGIN_ID), It.Is <string>(p => p == null), It.Is <string>(p => p == USERNAME)), Times.Once);
dbCommands.Verify(m => m.AddUser(It.Is <AccountCreatedTransferObject>(p =>
p.EmailAddress == EMAIL_ADDRESS &&
p.Username == USERNAME &&
p.FirstName == FIRST_NAME &&
p.LastName == LAST_NAME &&
p.ExternalLoginId == externalId
)), Times.Once);
}
public void Should_log_listener_exceptions_and_have_correct_internal_id()
{
// arrange
var builder = AccountCreated.CreateBuilder();
builder
.SetInternalId("1")
.SetFirstName("1")
.SetLastName("1")
.SetEmailAddress("1")
.SetSource(SourceSystem.STARCHEF)
.SetExternalId(Guid.Empty.ToString());
var payload = builder.Build();
var dbCommands = new Mock <IDatabaseCommands>();
dbCommands.Setup(d => d.IsUserExists(It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <string>())).Throws(new ListenerException());
var validator = new Mock <IEventValidator>(MockBehavior.Strict);
validator.Setup(m => m.IsAllowedEvent(payload)).Returns(true);
validator.Setup(m => m.IsValidPayload(It.IsAny <object>())).Returns(true);
var messagingLogger = new Mock <IMessagingLogger>();
var config = new Mock <IConfiguration>();
var logChecker = new LogChecker(typeof(AccountCreatedEventHandler), Level.All);
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator.Object, config.Object, messagingLogger.Object, logChecker.GetLogger());
// act
var result = handler.HandleAsync(payload, "1").Result;
var messageList = logChecker.LoggingEvents;
logChecker.Dispose();
// assert
Assert.All(messageList, item =>
{
Assert.Equal("1", item.Properties[AccountCreatedEventHandler.INTERNAL_ID]);
});
Assert.NotNull(
messageList.Where(
item =>
item.ExceptionObject != null &&
item.ExceptionObject.GetType() == typeof(ListenerException)).FirstOrDefault()
);
Assert.Null(ThreadContext.Properties[AccountCreatedEventHandler.INTERNAL_ID]);
}
public void Should_updated_valid_data_and_log_to_messaging_events2()
{
string internalId = Guid.NewGuid().ToString();
int creted_loginId = 15;
string USERNAME = "******";
string FIRST_NAME = "first_name";
string LAST_NAME = "last_name";
string EMAIL_ADDRESS = "email";
var externalId = Guid.NewGuid().ToString();
var builder = AccountCreated.CreateBuilder();
builder
.SetInternalId(internalId)
.SetUsername(USERNAME)
.SetFirstName(FIRST_NAME)
.SetLastName(LAST_NAME)
.SetEmailAddress(EMAIL_ADDRESS)
.SetSource(SourceSystem.USER_MANAGEMENT)
.SetExternalId(externalId);
builder.AddPermissionSets("Star_Chef");
var payload = builder.Build();
var dbCommands = new Mock <IDatabaseCommands>();
dbCommands.Setup(m => m.IsUserExists(It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(false));
dbCommands.Setup(m => m.AddUser(It.IsAny <AccountCreatedTransferObject>())).Returns(Task.FromResult(creted_loginId));
var validator = new AccountCreatedValidator(dbCommands.Object);
var messagingLogger = new Mock <IMessagingLogger>();
var config = new Mock <IConfiguration>();
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator, config.Object, messagingLogger.Object);
var result = handler.HandleAsync(payload, "1").Result;
// assertions
Assert.Equal(MessageHandlerResult.Success, result);
dbCommands.Verify(m => m.AddUser(It.Is <AccountCreatedTransferObject>(p =>
p.InternalLoginId == creted_loginId &&
p.InternalId.Equals(internalId, StringComparison.CurrentCultureIgnoreCase) &&
p.ExternalLoginId == externalId
)), Times.Once);
messagingLogger.Verify(m => m.MessageProcessedSuccessfully(It.Is <object>(p => ReferenceEquals(p, payload)), It.IsAny <string>()), Times.Once);
}
private async Task SendMessage(AccountCreatedEventHandler sender, AccountCreatedTransferObject user, IConfiguration config)
{
if (sender == null)
{
return;
}
try
{
var userDetail = await sender.DbCommands.GetLoginUserIdAndCustomerDb(user.InternalLoginId);
ThreadContext.Properties["OrganisationId"] = userDetail.Item2;
var db = new DatabaseManager();
var publishEnabled = db.IsPublishEnabled(userDetail.Item3, (int)Constants.EntityType.User);
if (publishEnabled)
{
SqlParameter[] parameters = new SqlParameter[] {
new SqlParameter("@EntityId", userDetail.Item1),
new SqlParameter("@EntityTypeId", (int)Constants.EntityType.User),
new SqlParameter("@RetryCount", 0)
{
Value = 0, DbType = System.Data.DbType.Int32
},
new SqlParameter("@StatusId", 1),
new SqlParameter("@DateCreated", DateTime.UtcNow),
new SqlParameter("@ExternalId", string.Empty),
new SqlParameter("@MessageActionTypeId", (int)Constants.MessageActionType.SalesForceUserCreated)
};
db.Execute(userDetail.Item3, "sc_calculation_enqueue", Constants.TIMEOUT_MSMQ_EXEC_STOREDPROC, true, parameters);
}
_logger.InfoFormat("Enque userId: {0}, databaseId: {1}", userDetail.Item1, userDetail.Item2);
}
catch (Exception ex)
{
_logger.Error(ex);
throw;
}
finally
{
ThreadContext.Properties.Remove("OrganisationId");
}
}
public void Should_register_error_with_model()
{
// arrange
var payload = PayloadHelpers.Construct <AccountCreated>();
var dbCommands = new Mock <IDatabaseCommands>();
var validator = new Mock <IEventValidator>();
validator.Setup(m => m.IsAllowedEvent(It.IsAny <object>())).Returns(true);
validator.Setup(m => m.IsValidPayload(It.IsAny <object>())).Returns(false);
var messagingLogger = new Mock <IMessagingLogger>();
var config = new Mock <IConfiguration>();
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator.Object, config.Object, messagingLogger.Object);
// act
var result = handler.HandleAsync(payload, "1").Result;
// assert
Assert.Equal(MessageHandlerResult.Fatal, result);
messagingLogger.Verify(m => m.ReceivedInvalidModel(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <string>()), Times.Once);
}
public void All_logs_should_have_correct_internal_id_invalid_payload()
{
// arrange
var builder = AccountCreated.CreateBuilder();
builder
.SetInternalId("1")
.SetFirstName("1")
.SetLastName("1")
.SetEmailAddress("1")
.SetSource(SourceSystem.STARCHEF)
.SetExternalId(Guid.Empty.ToString());
var payload = builder.Build();
var dbCommands = new Mock <IDatabaseCommands>();
var validator = new Mock <IEventValidator>(MockBehavior.Strict);
validator.Setup(m => m.IsAllowedEvent(payload)).Returns(true);
validator.Setup(m => m.IsValidPayload(It.IsAny <object>())).Returns(false);
validator.Setup(m => m.GetErrors()).Returns(string.Empty);
var messagingLogger = new Mock <IMessagingLogger>();
var config = new Mock <IConfiguration>();
var logChecker = new LogChecker(typeof(AccountCreatedEventHandler), Level.All);
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator.Object, config.Object, messagingLogger.Object, logChecker.GetLogger());
// act
var result = handler.HandleAsync(payload, "1").Result;
var messageList = logChecker.LoggingEvents;
logChecker.Dispose();
// assert
Assert.All(messageList, item =>
{
Assert.Equal("1", item.Properties[AccountCreatedEventHandler.INTERNAL_ID]);
});
Assert.Null(ThreadContext.Properties[AccountCreatedEventHandler.INTERNAL_ID]);
}
public void Should_not_have_log_for_non_starchef_events()
{
// arrange
var builder = AccountCreated.CreateBuilder();
builder
.SetInternalId("1")
.SetFirstName("1")
.SetLastName("1")
.SetEmailAddress("1")
.SetSource(SourceSystem.ADACO)
.SetExternalId(Guid.Empty.ToString());
var payload = builder.Build();
var dbCommands = new Mock <IDatabaseCommands>();
var validator = new Mock <IEventValidator>(MockBehavior.Strict);
validator.Setup(m => m.IsAllowedEvent(payload)).Returns(false);
var messagingLogger = new Mock <IMessagingLogger>();
var config = new Mock <IConfiguration>();
var logChecker = new LogChecker(typeof(AccountCreatedEventHandler), Level.All);
var handler = new AccountCreatedEventHandler(dbCommands.Object, validator.Object, config.Object, messagingLogger.Object, logChecker.GetLogger());
// act
var result = handler.HandleAsync(payload, "1").Result;
var messageList = logChecker.LoggingEvents;
logChecker.Dispose();
// assert
Assert.Empty(messageList);
Assert.Null(ThreadContext.Properties[AccountCreatedEventHandler.INTERNAL_ID]);
}
