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);
}
public void GetPreferenceKey_NoExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var keyName2 = "some other preference key";
var keyUid2 = Guid.NewGuid();
//Get by key name
var task = PrefRepo.GetPreferenceKey(prefKeyName: keyName2);
task.Wait();
var result = task.Result;
Assert.IsNull(result);
//Get by key UID
task = PrefRepo.GetPreferenceKey(keyUid2);
task.Wait();
result = task.Result;
Assert.IsNull(result);
//Get by both key name and UID
task = PrefRepo.GetPreferenceKey(keyUid2, keyName2);
task.Wait();
result = task.Result;
Assert.IsNull(result);
}
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 bool?CreatePreferenceKey(CreatePreferenceKeyEvent preferenceKey)
{
if (GetPreferenceKey(preferenceKey.PreferenceKeyUID) != null ||
GetPreferenceKey(null, preferenceKey.PreferenceKeyName) != null)
{
return(null);
}
var currentUtc = DateTime.UtcNow;
var createPreferenceKey = new DbPreferenceKey()
{
PreferenceKeyName = preferenceKey.PreferenceKeyName,
PreferenceKeyUID = preferenceKey.PreferenceKeyUID.Value,
InsertUTC = currentUtc,
UpdateUTC = currentUtc
};
var kafkaMessage = new KafkaMessage()
{
Key = preferenceKey.PreferenceKeyUID.ToString(),
Message = new { CreateUserPreferenceKeyEvent = preferenceKey }
};
var actions = new List <Action>();
actions.Add(() => transaction.Upsert <DbPreferenceKey>(createPreferenceKey));
actions.Add(() => topics.ToList().ForEach(topic =>
{
kafkaMessage.Topic = topic;
transaction.Publish(kafkaMessage);
}));
return(transaction.Execute(actions));
}
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 async Task CreatePreferenceKeyExecutor_DuplicateKeyUID()
{
var keyUid = Guid.NewGuid();
var prefKeyDatabase = new PrefKeyDataModel
{
KeyName = "some key",
PreferenceKeyUID = keyUid.ToString(),
PreferenceKeyID = 12345
};
mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, null))
.ReturnsAsync(prefKeyDatabase);
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = "some other key",
PreferenceKeyUID = keyUid
};
var executor = RequestExecutorContainerFactory.Build <CreatePreferenceKeyExecutor>
(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(2005, result.Code);
Assert.Equal($"Duplicate preference key UID. {keyUid}", result.Message);
}
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 CreatePreferenceKey_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
}
public async Task <PreferenceKeyV1Result> CreatePreferenceKey([FromBody] CreatePreferenceKeyEvent preferenceEvent)
{
var methodName = $"{nameof(CreatePreferenceKey)}";
Logger.LogInformation($"{methodName} preferenceEvent: {0}", JsonConvert.SerializeObject(preferenceEvent));
var result = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <CreatePreferenceKeyExecutor>(LoggerFactory, ServiceExceptionHandler, PreferenceRepo)
.ProcessAsync(preferenceEvent)
) as PreferenceKeyV1Result;
Logger.LogResult(methodName, JsonConvert.SerializeObject(preferenceEvent), result);
return(result);
}
public void CreatePreferenceKey_DuplicateKeyName()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var prefEvent2 = new CreatePreferenceKeyEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent2, "Preference key with duplicate name should not be created", 0);
}
public void DeleteUserPreference_NoExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new DeleteUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent, "Non-existent user preference should not be deleted", 0);
}
public void UpdateUserPreference_NoExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new UpdateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent, "Non-existent user preference should not be updated", 0);
}
public async Task CreatePreferenceKeyExecutor_HappyPath()
{
const string keyName = "some key";
var keyUid = Guid.NewGuid();
mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName))
.ReturnsAsync((PrefKeyDataModel)null);
mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, null))
.ReturnsAsync((PrefKeyDataModel)null);
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = keyName,
PreferenceKeyUID = keyUid
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(1);
var prefKeyDatabase = new PrefKeyDataModel
{
KeyName = keyName,
PreferenceKeyUID = keyUid.ToString(),
PreferenceKeyID = 12345
};
mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, keyName))
.ReturnsAsync(prefKeyDatabase);
var executor = RequestExecutorContainerFactory.Build <CreatePreferenceKeyExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var result = await executor.ProcessAsync(prefEvent) as PreferenceKeyV1Result;
Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
Assert.Equal(prefEvent.PreferenceKeyName, result.PreferenceKeyName);
Assert.Equal(prefEvent.PreferenceKeyUID, result.PreferenceKeyUID);
}
public ActionResult CreatePreferenceKey([FromBody] CreatePreferenceKeyEvent preferenceEvent)
{
try
{
bool?isSuccess = _preferenceService.CreatePreferenceKey(preferenceEvent);
if (isSuccess.HasValue && isSuccess == true)
{
return(Ok());
}
else if (isSuccess == null)
{
logger.LogError("PreferenceKey already exist");
return(BadRequest("PreferenceKey already exist"));
}
logger.LogError("Unable to save to db. Make sure request is not duplicated and all keys exist");
return(BadRequest("Unable to save to db. Make sure request is not duplicated and all keys exist"));
}
catch (Exception ex)
{
logger.LogError(ex.Message + ex.StackTrace);
return(StatusCode(500, ex.Message));
}
}
public void TestCreatePreferenceKey_ValidInput_True()
{
//Arrange
CreatePreferenceKeyEvent createPreference = new CreatePreferenceKeyEvent()
{
PreferenceKeyUID = new Guid("2ae9019e-b840-4121-8639-366eecac91c1"),
PreferenceKeyName = "Key",
ActionUTC = DateTime.UtcNow
};
transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()
{
null
}); });
//Act
bool?result = preferenceService.CreatePreferenceKey(createPreference);
//Assert
Assert.True(result);
transaction.Received(1).Upsert(Arg.Is <DbPreferenceKey>(x => x.PreferenceKeyUID == createPreference.PreferenceKeyUID && x.PreferenceKeyName == createPreference.PreferenceKeyName));
transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == createPreference.PreferenceKeyUID.ToString()));
transaction.Received(1).Execute(Arg.Any <List <Action> >());
}
public void GetPreferenceKey_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
//Get by key name
var task = PrefRepo.GetPreferenceKey(prefKeyName: prefEvent.PreferenceKeyName);
task.Wait();
var result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(prefEvent.PreferenceKeyName, result.KeyName);
Assert.AreEqual(prefEvent.PreferenceKeyUID.ToString(), result.PreferenceKeyUID);
//Get by key UID
task = PrefRepo.GetPreferenceKey(prefEvent.PreferenceKeyUID);
task.Wait();
result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(prefEvent.PreferenceKeyName, result.KeyName);
Assert.AreEqual(prefEvent.PreferenceKeyUID.ToString(), result.PreferenceKeyUID);
//Get by both key name and UID
task = PrefRepo.GetPreferenceKey(prefEvent.PreferenceKeyUID, prefEvent.PreferenceKeyName);
task.Wait();
result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(prefEvent.PreferenceKeyName, result.KeyName);
Assert.AreEqual(prefEvent.PreferenceKeyUID.ToString(), result.PreferenceKeyUID);
}
/// <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);
}
