public async Task DeletePreferenceKeyExecutor_MissingKeyUID()
{
var keyUid = Guid.NewGuid();
mockPrefRepo.Setup(p => p.UserPreferenceExistsForKey(keyUid))
.ReturnsAsync(false);
var prefEvent = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = keyUid
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(0);
var executor = RequestExecutorContainerFactory.Build <DeletePreferenceKeyExecutor>
(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(2007, result.Code);
Assert.Equal("Unable to delete preference key. ", result.Message);
}
public void TestDeletePreferenceKey_ValidInput_True()
{
//Arrange
DeletePreferenceKeyEvent deleteUser = new DeletePreferenceKeyEvent()
{
PreferenceKeyUID = new Guid("1762f4cd-1322-4be7-96b7-bb4f8b8ff510"),
ActionUTC = DateTime.UtcNow
};
var dbPreferenceKey = new PreferenceKeyDto()
{
PreferenceKeyUID = deleteUser.PreferenceKeyUID,
PreferenceKeyName = "Key",
PreferenceKeyID = 10,
InsertUTC = DateTime.UtcNow.AddDays(-1),
UpdateUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()
{
dbPreferenceKey
}); });
//Act
bool?result = preferenceService.DeletePreferenceKey(deleteUser);
//Assert
Assert.True(result);
transaction.Received(1).Get <PreferenceKeyDto>(Arg.Any <string>());
transaction.Received(1).Delete(Arg.Is <string>(x => x.Contains(deleteUser.PreferenceKeyUID.ToStringAndWrapWithUnhex())));
transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == deleteUser.PreferenceKeyUID.ToString()));
transaction.Received(1).Execute(Arg.Any <List <Action> >());
}
public void DeletePreferenceKey_NoExisting()
{
var prefEvent = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent, "Non-existent preference key should not be deleted", 0);
}
public async Task <ContractExecutionResult> DeletePreferenceKey([FromBody] DeletePreferenceKeyEvent preferenceEvent)
{
var methodName = $"{nameof(DeletePreferenceKey)}";
Logger.LogInformation($"{methodName} preferenceEvent: {0}", JsonConvert.SerializeObject(preferenceEvent));
var result = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <DeletePreferenceKeyExecutor>(LoggerFactory, ServiceExceptionHandler, PreferenceRepo)
.ProcessAsync(preferenceEvent)
);
Logger.LogResult(methodName, JsonConvert.SerializeObject(preferenceEvent), result);
return(result);
}
public void DeletePreferenceKey_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var prefEvent2 = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = prefEvent.PreferenceKeyUID
};
WriteEventToDb(prefEvent2);
}
public void TestDeletePreferenceKey_PreferenceNotExist_ReturnNull()
{
//Arrange
DeletePreferenceKeyEvent deleteUser = new DeletePreferenceKeyEvent()
{
PreferenceKeyUID = new Guid("1762f4cd-1322-4be7-96b7-bb4f8b8ff510"),
ActionUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()); });
//Act
bool?result = preferenceService.DeletePreferenceKey(deleteUser);
//Assert
Assert.Null(result);
transaction.Received(1).Get <PreferenceKeyDto>(Arg.Any <string>());
transaction.Received(0).Delete(Arg.Any <string>());
transaction.Received(0).Publish(Arg.Any <KafkaMessage>());
transaction.Received(0).Execute(Arg.Any <List <Action> >());
}
public bool?DeletePreferenceKey(DeletePreferenceKeyEvent preferenceKey)
{
try
{
var preference = GetPreferenceKey(preferenceKey.PreferenceKeyUID);
if (preference == null)
{
return(null);
}
var deleteQuery = string.Format("Delete from md_preference_PreferenceKey where PreferenceKeyUID = {0}",
preferenceKey.PreferenceKeyUID.ToStringAndWrapWithUnhex());
var kafkaMessage = new KafkaMessage()
{
Key = preference.PreferenceKeyUID.ToString(),
Message = new { DeleteUserPreferenceKey = preferenceKey }
};
var actions = new List <Action>();
actions.Add(() => transaction.Delete(deleteQuery));
actions.Add(() => topics.ToList().ForEach(topic =>
{
kafkaMessage.Topic = topic;
transaction.Publish(kafkaMessage);
}));
return(transaction.Execute(actions));
}
catch (MySqlException ex)
{
if (!ex.Message.Contains("foreign key constraint"))
{
throw ex;
}
}
return(false);
}
public async Task DeletePreferenceKeyExecutor_HappyPath()
{
var keyUid = Guid.NewGuid();
mockPrefRepo.Setup(p => p.UserPreferenceExistsForKey(keyUid))
.ReturnsAsync(false);
var prefEvent = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = keyUid
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(1);
var executor = RequestExecutorContainerFactory.Build <DeletePreferenceKeyExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var result = await executor.ProcessAsync(prefEvent);
Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
}
public async Task DeletePreferenceKeyExecutor_UserPreferenceExists()
{
var keyUid = Guid.NewGuid();
mockPrefRepo.Setup(p => p.UserPreferenceExistsForKey(keyUid))
.ReturnsAsync(true);
var prefEvent = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = keyUid
};
var executor = RequestExecutorContainerFactory.Build <DeletePreferenceKeyExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent));
Assert.Equal(HttpStatusCode.BadRequest, ex.Code);
var result = ex.GetResult;
Assert.Equal(2006, result.Code);
Assert.Equal($"Cannot delete preference key as user preferences exist. {keyUid}", result.Message);
}
public ActionResult DeletePreferenceKey(string preferenceKeyGuid = null)
{
try
{
Guid preferenceKeyUid;
if (!Guid.TryParse(preferenceKeyGuid, out preferenceKeyUid))
{
logger.LogError("PreferenceKeyGuid is not valid");
return(BadRequest("PreferenceKeyGuid is not valid"));
}
var preferenceEvent = new DeletePreferenceKeyEvent()
{
PreferenceKeyUID = preferenceKeyUid,
ActionUTC = DateTime.UtcNow
};
bool?isSuccess = _preferenceService.DeletePreferenceKey(preferenceEvent);
if (isSuccess.HasValue && isSuccess == true)
{
return(Ok());
}
else if (isSuccess == null)
{
logger.LogError("PreferenceKey does not exist");
return(BadRequest("PreferenceKey does not exist"));
}
logger.LogError("Unable to delete in db");
return(BadRequest("Unable to delete in db"));
}
catch (Exception ex)
{
logger.LogError(ex.Message + ex.StackTrace);
return(StatusCode(500, ex.Message));
}
}
/// <summary>
/// Create an instance of the master data events. Convert to JSON.
/// </summary>
/// <param name="eventObject">event to be published</param>
/// <returns>json string with event serialized</returns>
private string BuildEventIntoObject(dynamic eventObject)
{
var jsonString = string.Empty;
string eventType = eventObject.EventType;
switch (eventType)
{
case "CreateUserPreferenceRequest":
case "UpdateUserPreferenceRequest":
var request = new UpsertUserPreferenceRequest();
if (HasProperty(eventObject, "TargetUserUID"))
{
request.TargetUserUID = Guid.Parse(eventObject.TargetUserUID);
}
if (HasProperty(eventObject, "SchemaVersion"))
{
request.SchemaVersion = eventObject.SchemaVersion;
}
if (HasProperty(eventObject, "PreferenceJson"))
{
request.PreferenceJson = eventObject.PreferenceJson;
}
if (HasProperty(eventObject, "PreferenceKeyName"))
{
request.PreferenceKeyName = eventObject.PreferenceKeyName;
}
if (HasProperty(eventObject, "PreferenceKeyUID"))
{
request.PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID);
}
jsonString = JsonConvert.SerializeObject(request, JsonSettings);
break;
case "CreatePreferenceKeyEvent":
var createPrefKeyEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = eventObject.PreferenceKeyName,
PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID)
};
jsonString = JsonConvert.SerializeObject(createPrefKeyEvent, JsonSettings);
break;
case "UpdatePreferenceKeyEvent":
var updatePrefKeyEvent = new UpdatePreferenceKeyEvent
{
PreferenceKeyName = eventObject.PreferenceKeyName,
PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID)
};
jsonString = JsonConvert.SerializeObject(updatePrefKeyEvent, JsonSettings);
break;
case "DeletePreferenceKeyEvent":
var deletePrefKeyEvent = new DeletePreferenceKeyEvent
{
PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID)
};
jsonString = JsonConvert.SerializeObject(deletePrefKeyEvent, JsonSettings);
break;
}
return(jsonString);
}
