public void TestConflictResult_should_work_as_expected_with_method_without_arguments()
{
ApiControllerHttpActionResultActionTester actionTester = _controllerTester.Action(x => x.HttpActionResultActionWithoutArguments);
_controller.HttpActionResult = new ConflictResult(_controller);
ConflictResult result = null;
ConflictResult validatedResult = null;
bool validateWasCalled = false;
Action action = () =>
{
result = actionTester.TestConflictResult(r =>
{
validatedResult = r;
validateWasCalled = true;
});
};
action.Should().NotThrow();
result.Should().Be(_controller.HttpActionResult);
validateWasCalled.Should().BeTrue();
validatedResult.Should().Be(_controller.HttpActionResult);
_controller.HttpActionResult = _okResult;
action.Should().Throw <ControllerTestException>().WithMessage(
"Expected IHttpActionResult type System.Web.Http.Results.ConflictResult. Actual: System.Web.Http.Results.OkResult.");
}
public void ConflictResult_InitializesStatusCode()
{
// Arrange & act
var conflictResult = new ConflictResult();
// Assert
Assert.Equal(StatusCodes.Status409Conflict, conflictResult.StatusCode);
}
private string GetErrorMessage(IActionResult actionResult, string providerVersionId)
{
return(actionResult switch
{
ConflictResult _ => $"ProviderVersion alreay exists for - {providerVersionId}",
BadRequestObjectResult r => $"Validation Errors - {r.AsJson()}",
_ => string.Empty,
});
public void ConflictResultHasStatusCode409()
{
// Arrange
var result = new ConflictResult();
// Assert
Assert.Equal(409, result.StatusCode);
}
public virtual ConflictResult Conflict(ErrorViewModel value)
{
ConflictResult result = new ConflictResult(value);
value.StatusCode = result.StatusCode.GetValueOrDefault();
return(result);
}
public void HasConflict_True()
{
ICourseRepository courseRepository = new ConflictingCourseRepo();
ConflictDetector detector = new ConflictDetector(courseRepository);
ConflictResult result = detector.FindConflicts();
Assert.IsTrue(result.HasConflicts);
}
public void HasConflict_False()
{
ICourseRepository courseRepository = new NonConflictingCourseRepo();
ConflictDetectorTests detector = new ConflictDetector(courseRepository);
ConflictResult result = detector.FindConflicts();
Assert.IsFalse(result.HasConflicts);
}
public void BeConflictObjectResult_GivenNotConflictObject_ShouldFail()
{
ActionResult result = new ConflictResult();
var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundYWithReason("result", typeof(ConflictObjectResult), typeof(ConflictResult));
Action a = () => result.Should().BeConflictObjectResult(Reason, ReasonArgs);
a.Should().Throw <Exception>()
.WithMessage(failureMessage);
}
protected override ConflictResult GetConflict(string packageId)
{
// For project installs we first try to base behavior (using the live graph)
// then we look for conflicts for packages installed into the current project.
ConflictResult result = base.GetConflict(packageId);
if (result == null) {
IPackage package = Repository.FindPackage(packageId);
if (package != null) {
result = new ConflictResult(package, Repository, _dependentsResolver);
}
}
return result;
}
protected override ConflictResult GetConflict(string packageId)
{
// For project installs we first try to base behavior (using the live graph)
// then we look for conflicts for packages installed into the current project.
ConflictResult result = base.GetConflict(packageId);
if (result == null)
{
IPackage package = Repository.FindPackage(packageId);
if (package != null)
{
result = new ConflictResult(package, Repository, _dependentsResolver);
}
}
return(result);
}
public void SubscribeUserToExistentChannelAlreadySubscribed()
{
this.sessionContext.Channels = this.GetFakeChannels();
this.sessionContext.Channels.FirstOrDefault(x => x.ChannelName == "test channel 2").Subscribers = new List <ChatUser>();
this.sessionContext.Channels.FirstOrDefault(x => x.ChannelName == "test channel 2").Subscribers.Add(new ChatUser {
UserName = "******"
});
ConflictResult result = this.channelController.Subscribe(
new Channel {
ChannelName = "test channel 2", Subscribers = new List <ChatUser> {
new ChatUser {
UserName = "******"
}
}
}) as ConflictResult;
Assert.AreEqual(1, this.sessionContext.Channels.FirstOrDefault(x => x.ChannelName == "test channel 2").Subscribers.Count(), "the channel was not properly subscribed to");
Assert.IsNotNull(result, "the response status was not correct");
}
public async Task PutAccount_ReturnConflict()
{
// Act
Account account = new Account()
{
firstName = "testFirstName",
lastName = "testLastName",
dateOfBirth = new DateTime(2020, 1, 1),
email = "*****@*****.**",
licensePlateNumber = "AA-12-AA",
username = "******",
password = "******"
};
var result = await controller.UpdateAccountAsync(account);
// Assert
ConflictResult actionResult = Assert.IsType <ConflictResult>(result);
Assert.NotNull(actionResult);
Dispose();
}
public async Task UpdateBrother_DbConcurrencyExceptionIsThrownOnSave_ReturnsConflictAndRecordIsUnchanged()
{
ClaimsPrincipal principal = new ClaimsPrincipal(new ClaimsIdentity(new[] {
new Claim(JwtClaimTypes.Scope, Constants.Scopes.Administrator),
new Claim(JwtClaimTypes.Subject, "some-subject"),
new Claim(JwtClaimTypes.Scope, "directory")
}));
int id = _dbContext.Brother.Add(new Brother {
FirstName = "ShouldNot", LastName = "BeModified"
}).Entity.Id;
await _dbContext.SaveChangesAsync();
Mock <DirectoryContext> mockedContext = new Mock <DirectoryContext>();
mockedContext.SetupGet(m => m.Brother).Returns(_dbContext.Brother);
List <IUpdateEntry> entries = new List <IUpdateEntry>(new[] { Mock.Of <IUpdateEntry>() });
mockedContext.Setup(m => m.Entry(It.IsAny <Brother>())).Throws(new DbUpdateConcurrencyException(string.Empty, entries));
BrotherController controller = new BrotherController(mockedContext.Object, principal, Mock.Of <ILogger <BrotherController> >());
Brother brother = new Brother {
Id = id,
FirstName = "firstname1",
LastName = "lastname1"
};
ConflictResult result = await controller.UpdateBrother(id, brother) as ConflictResult;
Assert.Multiple((() => {
Assert.That(result, Is.Not.Null);
Brother changed = _dbContext.Brother.FirstOrDefault(b => b.Id == id);
Assert.That(changed, Is.Not.Null);
Assert.That(changed.FirstName, Is.EqualTo("ShouldNot"));
Assert.That(changed.LastName, Is.EqualTo("BeModified"));
}));
}
public void ImplicitOperatorTests()
{
// Arrange
var result = new OperationResult <Value>();
// Act
OperationResult <Value> fromBadRequest = new BadRequestResult();
OperationResult <Value> fromConflict = new ConflictResult();
OperationResult <Value> fromNoContent = new NoContentResult();
OperationResult <Value> fromNotFound = new NotFoundResult();
OperationResult <Value> fromOk = new OkResult();
OperationResult <Value> fromUnauthorized = new UnauthorizedResult();
OperationResult <Value> fromUnprocessableEntity = new UnprocessableEntityResult();
OperationResult <Value> unsupportedMediaType = new UnprocessableEntityResult();
Assert.NotNull(fromBadRequest);
Assert.NotNull(fromConflict);
Assert.NotNull(fromNoContent);
Assert.NotNull(fromNotFound);
Assert.NotNull(fromOk);
Assert.NotNull(fromUnauthorized);
Assert.NotNull(fromUnprocessableEntity);
Assert.NotNull(unsupportedMediaType);
}
public async Task PostAccount_ReturnConflict()
{
// Act
string id = "082E3E718496E3B303C46ED5";
Account account = new Account()
{
accountID = id,
firstName = "testFirstName",
lastName = "testLastName",
dateOfBirth = new DateTime(2020, 1, 1),
email = "*****@*****.**",
licensePlateNumber = "AA-12-AA",
username = "******",
password = "******"
};
var result = await controller.CreateAccountAsync(account);
// Assert
ConflictResult actionResult = Assert.IsType <ConflictResult>(result);
Assert.NotNull(actionResult);
Dispose();
}
public TestConflictResult(ConflictResult innerResult)
: base(innerResult)
{
}
public virtual Response Visit(ConflictResult <T> result)
{
return(new Response().WithStatusCode(HttpStatusCode.Conflict));
}
public void BeConflictResult_GivenConflict_ShouldPass()
{
ActionResult result = new ConflictResult();
result.Should().BeConflictResult();
}
private void ResolveConflict(ConflictResult result, SaveData localSave, SaveData cloudSave)
{
LoadState cloudState;
switch (result)
{
case ConflictResult.Cloud:
Debug.Log("SaveGameManager (ResolveConflict) :: Resolving conflict with cloud save!");
if (OverrideLocalSave(cloudSave, localSave))
{
m_comparator.ReconcileData(localSave, cloudSave);
cloudSave.Save();
cloudState = LoadSystems(cloudSave);
if (cloudState == LoadState.OK)
{
m_saveData = cloudSave;
m_syncCompleteCallback(null, SyncState.Successful);
}
else
{
//Reset to local
LoadSystems(localSave);
m_saveData = localSave;
//TODO may need more specific errors
m_syncCompleteCallback(new SyncError("Failed to load resolved cloud save", ErrorCodes.SaveError), SyncState.Error);
}
}
else
{
m_syncCompleteCallback(new SyncError("Failed to Override Local Save", ErrorCodes.SaveError), SyncState.Error);
}
break;
case ConflictResult.Local:
Debug.Log("SaveGameManager (ResolveConflict) :: Resolving conflict with local save!");
m_comparator.ReconcileData(localSave, cloudSave);
localSave.Save();
LoadState localState = LoadSystems(localSave);
if (localState == LoadState.OK)
{
UploadSave(m_syncUser, localSave, delegate(Error error)
{
if (error != null && error.GetType() != typeof(UploadDisallowedError))
{
m_syncCompleteCallback(error, SyncState.Error);
}
else
{
m_saveData = localSave;
m_syncCompleteCallback(null, SyncState.Successful);
}
});
}
else
{
//TODO may need more specific errors
m_syncCompleteCallback(new SyncError("Failed to load resolved cloud save", ErrorCodes.SaveError), SyncState.Error);
}
break;
case ConflictResult.ForceCloud:
SyncError forceCloudError = null;
// Make sure we reset force override as otherwise user save file will get overriden again next time
// If the flag doesn't exist (upgrading from old save?), just ignore the exception
try
{
cloudSave["User.ForceOverride"] = false;
localSave["User.ForceOverride"] = false;
}
catch (Exception e)
{
Debug.LogException(e);
}
if (OverrideLocalSave(cloudSave, localSave))
{
cloudSave.Save();
cloudState = LoadSystems(cloudSave);
if (cloudState == LoadState.OK)
{
m_saveData = cloudSave;
m_saveData.Save();
}
else
{
//Reset to local
LoadSystems(localSave);
m_saveData = localSave;
//TODO may need more specific errors
forceCloudError = new SyncError("Failed to load resolved cloud save", ErrorCodes.SaveError);
}
}
else
{
m_saveData = localSave;
forceCloudError = new SyncError("Failed to Override Local Save", ErrorCodes.SaveError);
}
// Upload the new save to cloud to delete forceOverride flag
UploadSave(m_syncUser, m_saveData, delegate(Error error)
{
if (error != null)
{
m_syncCompleteCallback(error, SyncState.Error);
}
else
{
m_syncCompleteCallback(forceCloudError, forceCloudError == null ? SyncState.Successful : SyncState.Error);
}
});
break;
}
}
