public void TestCreateUserPreference_ValidInput_True()
{
//Arrange
CreateUserPreferenceEvent createUser = new CreateUserPreferenceEvent()
{
PreferenceKeyUID = new Guid("2ccfe195-81ec-4aed-ba31-fc7d794cb75f"),
UserUID = new Guid("85293f9c-b713-4e95-a5ed-b36beb2c4aa2"),
PreferenceKeyName = "Key",
PreferenceJson = "Json",
SchemaVersion = "v1",
ActionUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()
{
new PreferenceKeyDto()
{
PreferenceKeyID = 10, PreferenceKeyName = "Key", PreferenceKeyUID = createUser.PreferenceKeyUID.Value
}
}); });
//Act
bool?result = preferenceService.CreateUserPreference(createUser);
//Assert
Assert.True(result);
transaction.Received(1).Upsert <DbUserPreference>(Arg.Is <DbUserPreference>(x => x.fk_UserUID == createUser.UserUID));
transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == createUser.UserUID.ToString()));
transaction.Received(1).Execute(Arg.Any <List <Action> >());
}
public void TestCreateUserPreference_ValidInputWithoutSchema_True()
{
//Arrange
CreateUserPreferenceEvent createUser = new CreateUserPreferenceEvent()
{
PreferenceKeyUID = new Guid("2ccfe195-81ec-4aed-ba31-fc7d794cb75f"),
UserUID = new Guid("fd4b9a47-4b67-40b9-b106-89047c88fa43"),
PreferenceKeyName = "Key",
PreferenceJson = "Json",
ActionUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()
{
new PreferenceKeyDto()
{
PreferenceKeyID = 9, PreferenceKeyName = "Key", PreferenceKeyUID = createUser.PreferenceKeyUID.Value
}
}); });
//Act
bool?result = preferenceService.CreateUserPreference(createUser);
//Assert
Assert.True(result);
transaction.Received(1).Upsert <DbUserPreference>(Arg.Is <DbUserPreference>(x => (x.fk_UserUID == createUser.UserUID && x.SchemaVersion == "1.0")));
transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == createUser.UserUID.ToString()));
transaction.Received(1).Execute(Arg.Any <List <Action> >());
}
public void UserPreferenceExistsForKey_DoesNotExist()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var task = PrefRepo.UserPreferenceExistsForKey(Guid.NewGuid());
task.Wait();
var result = task.Result;
Assert.IsFalse(result);
}
public void GetUserPreference_NoExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var task = PrefRepo.GetUserPreference(Guid.NewGuid(), prefEvent.PreferenceKeyName);
task.Wait();
var result = task.Result;
Assert.IsNull(result);
}
public void GetUserPreference_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var task = PrefRepo.GetUserPreference(userPrefEvent.UserUID, userPrefEvent.PreferenceKeyName);
task.Wait();
var result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(userPrefEvent.PreferenceKeyName, result.KeyName);
Assert.AreEqual(userPrefEvent.PreferenceKeyUID.ToString(), result.PreferenceKeyUID);
Assert.AreEqual(userPrefEvent.PreferenceJson, result.PreferenceJson);
Assert.AreEqual(userPrefEvent.SchemaVersion, result.SchemaVersion);
}
public void DeleteUserPreference_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var userPrefEvent2 = new DeleteUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
UserUID = userPrefEvent.UserUID
};
WriteEventToDb(userPrefEvent2);
}
public void CreateUserPreference_WithExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var userPrefEvent2 = new CreateUserPreferenceEvent
{
PreferenceKeyName = userPrefEvent.PreferenceKeyName,
PreferenceKeyUID = userPrefEvent.PreferenceKeyUID,
PreferenceJson = "some different json here",
SchemaVersion = "1.0",
UserUID = userPrefEvent.UserUID
};
WriteEventToDb(userPrefEvent2, "Existing user preference should not be created", 0);
}
private ActionResult DoUpsert(CreateUserPreferencePayload preferencePayload, bool allowUpdate)
{
var isExist = _preferenceService.DoesUserPreferenceExist(preferencePayload.TargetUserUID.Value,
preferencePayload.PreferenceKeyUID, preferencePayload.PreferenceKeyName);
if (allowUpdate && isExist)
{
var userPreferenceEvent = new UpdateUserPreferenceEvent
{
PreferenceKeyUID = preferencePayload.PreferenceKeyUID,
PreferenceKeyName = preferencePayload.PreferenceKeyName,
PreferenceJson = preferencePayload.PreferenceJson,
UserUID = preferencePayload.TargetUserUID,
SchemaVersion = preferencePayload.SchemaVersion,
ActionUTC = preferencePayload.ActionUTC.Value
};
var updateResult = PerformUpdateUserPreference(userPreferenceEvent);
return(updateResult);
}
else if (isExist == true && allowUpdate == false)
{
logger.LogError("UserPreference already exist");
return(BadRequest("UserPreference already exist"));
}
#region Create UserPreference
if (!isExist)
{
var preferenceEvent = new CreateUserPreferenceEvent
{
PreferenceKeyUID = preferencePayload.PreferenceKeyUID,
PreferenceKeyName = preferencePayload.PreferenceKeyName,
PreferenceJson = preferencePayload.PreferenceJson,
UserUID = preferencePayload.TargetUserUID,
SchemaVersion = preferencePayload.SchemaVersion,
ActionUTC = preferencePayload.ActionUTC.Value
};
bool?isSuccess = _preferenceService.CreateUserPreference(preferenceEvent);
if (isSuccess.HasValue && isSuccess.Value)
{
return(Ok());
}
else if (isSuccess == null)
{
logger.LogError("PreferenceKey does not Exist");
return(BadRequest("PreferenceKey does not Exist"));
}
}
#endregion
logger.LogError("Unable to save row to database");
return(BadRequest("Unable to save row to database"));
}
public bool?CreateUserPreference(CreateUserPreferenceEvent userPreference)
{
var preference = GetPreferenceKey(userPreference.PreferenceKeyUID, userPreference.PreferenceKeyName);
if (preference == null || userPreference.PreferenceKeyUID.HasValue &&
!preference.PreferenceKeyUID.Equals(userPreference.PreferenceKeyUID))
{
return(null);
}
if (string.IsNullOrEmpty(userPreference.SchemaVersion))
{
userPreference.SchemaVersion = "1.0";
}
var currentUtc = DateTime.UtcNow;
var insertUserPreference = new DbUserPreference()
{
fk_UserUID = userPreference.UserUID,
fk_PreferenceKeyID = preference.PreferenceKeyID,
PreferenceValue = userPreference.PreferenceJson,
SchemaVersion = userPreference.SchemaVersion,
InsertUTC = currentUtc,
UpdateUTC = currentUtc
};
var kafkaMessage = new KafkaMessage()
{
Key = userPreference.UserUID.ToString(),
Message = new { CreateUserPreferenceEvent = userPreference }
};
var actions = new List <Action>();
actions.Add(() => transaction.Upsert <DbUserPreference>(insertUserPreference));
actions.Add(() => topics.ToList().ForEach(topic =>
{
kafkaMessage.Topic = topic;
transaction.Publish(kafkaMessage);
}));
return(transaction.Execute(actions));
}
public async Task CreateUserPreferenceExecutor_HappyPath()
{
const string keyName = "some key";
var userUid = Guid.NewGuid();
var prefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = keyName,
PreferenceKeyUID = Guid.NewGuid(),
UserUID = userUid,
PreferenceJson = "some json",
SchemaVersion = "1.0"
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(1);
var userPref = new UserPrefKeyDataModel
{
KeyName = keyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID.Value.ToString(),
PreferenceJson = prefEvent.PreferenceJson,
SchemaVersion = prefEvent.SchemaVersion
};
mockPrefRepo.Setup(p => p.GetUserPreference(userUid, keyName))
.ReturnsAsync(userPref);
var executor = RequestExecutorContainerFactory.Build <CreateUserPreferenceExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var result = await executor.ProcessAsync(prefEvent) as UserPreferenceV1Result;
Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
Assert.Equal(prefEvent.SchemaVersion, result.SchemaVersion);
Assert.Equal(prefEvent.PreferenceJson, result.PreferenceJson);
Assert.Equal(prefEvent.PreferenceKeyName, result.PreferenceKeyName);
Assert.Equal(prefEvent.PreferenceKeyUID, result.PreferenceKeyUID);
}
public void TestCreateUserPreference_InvalidPreference_ReturnNull()
{
//Arrange
CreateUserPreferenceEvent createUser = new CreateUserPreferenceEvent()
{
PreferenceKeyUID = new Guid("2ccfe195-81ec-4aed-ba31-fc7d794cb75f"),
UserUID = new Guid("fd4b9a47-4b67-40b9-b106-89047c88fa43"),
PreferenceKeyName = "Key",
PreferenceJson = "Json",
ActionUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()); });
//Act
bool?result = preferenceService.CreateUserPreference(createUser);
//Assert
Assert.Null(result);
transaction.Received(1).Get <PreferenceKeyDto>(Arg.Any <string>());
transaction.Received(0).Upsert <DbUserPreference>(Arg.Any <DbUserPreference>());
transaction.Received(0).Publish(Arg.Any <KafkaMessage>());
transaction.Received(0).Execute(Arg.Any <List <Action> >());
}
public async Task CreateUserPreferenceExecutor_Existing()
{
var prefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = "some key",
PreferenceKeyUID = Guid.NewGuid(),
UserUID = Guid.NewGuid(),
PreferenceJson = "some new json",
SchemaVersion = "1.0"
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(0);
var executor = RequestExecutorContainerFactory.Build <CreateUserPreferenceExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent));
Assert.Equal(HttpStatusCode.InternalServerError, ex.Code);
var result = ex.GetResult;
Assert.Equal(2010, result.Code);
Assert.Equal("Unable to create user preference. ", result.Message);
}
