/// <inheritdoc cref="IDiffService" />
public Task AddDiffAsync(int id, Side side, DiffRequest request)
{
var comparison = Store.GetOrAdd(id, f => new Comparison());
comparison[side] = request.Data;
// simulate I/O operations
return(Task.CompletedTask);
}
public async Task Calls_Diff_Service_With_Correct_Parameters(DiffRequest request, Guid id)
{
// Act
await _objectToTest.SetDiffLeft(id, request);
// Assert
_mockEntryService.Verify(x => x.AddSideToCompare(id, request.Data, Side.Left), Times.Once);
}
private void enqueueDiffRequest(DiffRequest diffRequest)
{
_requestedDiff.Enqueue(diffRequest);
if (_requestedDiff.Count == 1)
{
BeginInvoke(new Action(() => processDiffQueue()));
}
}
internal static Dictionary <string, string> GenerateQueryParams(DiffRequest request)
{
var queryParams = new Dictionary <string, string>
{
{ "api-version", request.ApiVersion },
{ "deltaLink", request.DeltaLink }
};
return(queryParams);
}
public async Task <IActionResult> Put(int id, Side side, [FromBody] DiffRequest diff)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _service.AddDiffAsync(id, side, diff);
return(StatusCode((int)HttpStatusCode.Created));
}
public async Task Returns_Ok_Response(DiffRequest request, Guid id)
{
// Act
var result = await _objectToTest.SetDiffLeft(id, request);
// Assert
using (new AssertionScope())
{
result.Should().NotBeNull();
result.Should().BeOfType <OkResult>();
}
}
/// <summary>
/// Process the input for the diff
/// </summary>
/// <param name="id">The id of the comparision</param>
/// <param name="side">left or right</param>
/// <param name="request">JSON base64 encoded binary data</param>
/// <returns>HTTP Response</returns>
private IHttpActionResult ProcessInput(string id, string side, DiffRequest request)
{
if (string.IsNullOrEmpty(request?.Data))
{
return(BadRequest());
}
Initialize();
_dataManager.Add($"{id}-{side}", request.Data);
return(Created($"v1/diff/{id}/{side}", request.Data));
}
private async Task <HttpResponseMessage> PutAsync(string url, string diff = null)
{
using var client = _factory.CreateClient();
var data = new DiffRequest {
Data = diff
};
var content = new StringContent(JsonSerializer.Serialize <DiffRequest>(data));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(await client.PutAsync(url, content).ConfigureAwait(false));
}
public void ItGeneratesBasicParams()
{
// g
var expected = new Dictionary <string, string>
{
{ "api-version", "1.5" },
{ "deltaLink", "" }
};
var request = new DiffRequest();
// w
var actual = DiffHelpers.GenerateQueryParams(request);
// t
actual.ShouldBeEquivalentTo(expected);
}
private async Task <ActionResult> SetDiffSide(Guid id, DiffRequest request, Side side)
{
try
{
await _entryService.AddSideToCompare(id, request.Data, side);
return(Ok());
}
catch (InvalidInputException ex)
{
return(StatusCode(StatusCodes.Status400BadRequest, ex.Message));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.UNEXPECTED_ERROR));
}
}
public async Task Result_Changes_If_Side_Is_Updated(string initialData, string updatedData)
{
// Arrange
// Setup first case to return response equal
var initialCaseRequest = new DiffRequest {
Data = initialData
};
var responseLeft = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(initialCaseRequest));
responseLeft.EnsureSuccessStatusCode();
var responseRight = await _httpClient.PostAsync(API_RIGHT_URL, GetJsonHttpContent(initialCaseRequest));
responseRight.EnsureSuccessStatusCode();
var initialDiffResponse = await _httpClient.GetAsync(API_DIFF_URL);
// Act
//Update left side and save response
var updateSideRequest = new DiffRequest {
Data = updatedData
};
var updatedSideResponse = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(updateSideRequest));
updatedSideResponse.EnsureSuccessStatusCode();
var updatedSideDiffResponse = await _httpClient.GetAsync(API_DIFF_URL);
// Assert
var initialResponseString = await initialDiffResponse.Content.ReadAsStringAsync();
var initialResult = JsonConvert.DeserializeObject <DiffResult>(initialResponseString);
var updatedResponseString = await updatedSideDiffResponse.Content.ReadAsStringAsync();
var updatedResult = JsonConvert.DeserializeObject <DiffResult>(updatedResponseString);
using (new AssertionScope())
{
initialResult.Status.Should().NotBe(updatedResult.Status);
}
}
public ActionResult AddRightMember([FromRoute] int id, [FromBody] DiffRequest request)
{
if (string.IsNullOrEmpty(request.Data) || !IsBase64String(request.Data))
{
return(BadRequest());
}
try
{
var binaryData = Convert.FromBase64String(request.Data);
diffService.AddRightMember(id, binaryData);
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
return(Ok());
}
public async Task DiffControllerCallsService()
{
var id = 12;
var side = Side.Right;
var data = new DiffRequest {
Data = "AA"
};
// arrange
_diffServiceMock.Setup(x => x.AddDiffAsync(id, side, data))
.Returns(Task.FromResult(null as object))
.Verifiable();
// act
var result = await _target.Put(id, side, data);
// assert
_diffServiceMock.Verify(x => x.AddDiffAsync(id, side, data), Times.Once);
}
public async Task Returns_Ok_Response_On_Post_To_Set_Sides(string data)
{
// Arrange
var requestLeft = new DiffRequest {
Data = data
};
var requestRight = new DiffRequest {
Data = data
};
// Act
var resultLeft = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(requestRight));
var resultRight = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(requestRight));
// Assert
resultLeft.EnsureSuccessStatusCode();
resultRight.EnsureSuccessStatusCode();
}
public void Update_PutNewObject_ExpectedDataInFields()
{
// arrange
var repository = new InMemoryDiffRequestsRepository();
var id = 1;
var newObject = new DiffRequest()
{
Left = new byte[] { 0 },
Right = new byte[] { 1 }
};
// action
repository.Update(id, newObject);
var result = repository.Single(id);
// assert
Assert.AreEqual(0, result.Left[0]);
Assert.AreEqual(1, result.Right[0]);
}
public async Task Returns_Ok_Response_On_GetDiff(string left, string right, DiffStatus resultStatus, int expectedCount)
{
// Arrange
var requestLeft = new DiffRequest {
Data = left
};
var requestRight = new DiffRequest {
Data = right
};
var responseLeft = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(requestLeft));
responseLeft.EnsureSuccessStatusCode();
var responseRight = await _httpClient.PostAsync(API_RIGHT_URL, GetJsonHttpContent(requestRight));
responseRight.EnsureSuccessStatusCode();
// Act
var response = await _httpClient.GetAsync(API_DIFF_URL);
// Assert
var responseString = await response.Content.ReadAsStringAsync();
var actualResult = JsonConvert.DeserializeObject <DiffResult>(responseString);
// Assert
using (new AssertionScope())
{
actualResult.Status.Should().Be(resultStatus);
if (expectedCount > 0)
{
actualResult.Differences.Should().NotBeNullOrEmpty();
actualResult.Differences.Count().Should().Be(expectedCount);
}
else
{
actualResult.Differences.Should().BeNull();
}
}
}
public async Task Returns_Bad_Request_Response_On_GetDiff_If_Some_Side_Missing(string setSiderequestUrl, string data, string getDiffRequest)
{
// Arrange
var request = new DiffRequest {
Data = data
};
var responseCreate = await _httpClient.PostAsync(setSiderequestUrl, GetJsonHttpContent(request));
responseCreate.EnsureSuccessStatusCode();
// Act
var response = await _httpClient.GetAsync(getDiffRequest);
// Assert
using (new AssertionScope())
{
response.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
}
}
public void Update_ReplaceObject_ReferencesAreNotEqual()
{
// arrange
var repository = new InMemoryDiffRequestsRepository();
var id = 1;
var oldObject = new DiffRequest()
{
Left = new byte[] { 0 }
};
repository.Update(id, oldObject);
oldObject = repository.Single(id);
// action
repository.Update(id, oldObject);
var newObject = repository.Single(id);
// assert
Assert.IsFalse(ReferenceEquals(oldObject, newObject));
}
public async Task Returns_Bad_Request_Response_On_Non_Base64_Input(string data)
{
// Arrange
var requestLeft = new DiffRequest {
Data = data
};
var requestRight = new DiffRequest {
Data = data
};
// Act
var resultLeft = await _httpClient.PostAsync(API_LEFT_URL, GetJsonHttpContent(requestLeft));
var resultRight = await _httpClient.PostAsync(API_RIGHT_URL, GetJsonHttpContent(requestRight));
// Assert
using (new AssertionScope())
{
resultLeft.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
resultRight.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
}
}
public async Task <GraphResponse> GetObjectsAsync(string deltaLink = "")
{
try
{
var request = new DiffRequest {
DeltaLink = deltaLink
};
var queryParams = DiffHelpers.GenerateQueryParams(request);
var requestUri =
new Uri($"https://graph.windows.net/{_tenantId}/directoryObjects").AddQueryParameters(
queryParams);
var data = await CallAdAsync(requestUri).ConfigureAwait(false);
return(data == null
? GraphResponse.CreateFailedResponse("Something went wrong")
: GraphResponse.Create(data));
}
catch (Exception ex)
{
_errorLogger("Something went wrong", ex.ToString());
return(GraphResponse.CreateFailedResponse(ex.ToString()));
}
}
public void Update_ReplaceObject_ExpectedDataInFields()
{
// arrange
var repository = new InMemoryDiffRequestsRepository();
var id = 1;
var oldObject = new DiffRequest()
{
Left = new byte[] { 0 }
};
var newObject = new DiffRequest()
{
Left = new byte[] { 1 }
};
// action
repository.Update(id, oldObject);
oldObject = repository.Single(id);
repository.Update(id, newObject);
newObject = repository.Single(id);
// assert
Assert.AreNotEqual(oldObject.Left[0], newObject.Left[0]);
}
private void processDiffQueue()
{
if (!_requestedDiff.Any())
{
return;
}
DiffRequest diffRequest = _requestedDiff.Peek();
try
{
SnapshotSerializer serializer = new SnapshotSerializer();
Snapshot snapshot;
try
{
snapshot = serializer.DeserializeFromDisk(diffRequest.GitPID);
}
catch (Exception ex)
{
ExceptionHandlers.Handle("Cannot read serialized Snapshot object", ex);
MessageBox.Show(
"Make sure that diff tool was launched from Merge Request Helper which is still running",
"Cannot create a discussion",
MessageBoxButtons.OK, MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
if (_storageFactory == null || _storageFactory.ParentFolder != snapshot.TempFolder)
{
Trace.TraceWarning("[MainForm] File Storage folder was changed after launching diff tool");
MessageBox.Show("It seems that file storage folder was changed after launching diff tool. " +
"Please restart diff tool.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
Core.Matching.MatchInfo matchInfo;
try
{
DiffArgumentParser diffArgumentParser = new DiffArgumentParser(diffRequest.DiffArguments);
matchInfo = diffArgumentParser.Parse(getDiffTempFolder(snapshot));
Debug.Assert(matchInfo != null);
}
catch (ArgumentException ex)
{
ExceptionHandlers.Handle("Cannot parse diff tool arguments", ex);
MessageBox.Show("Bad arguments passed from diff tool", "Cannot create a discussion",
MessageBoxButtons.OK, MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
ProjectKey projectKey = new ProjectKey(snapshot.Host, snapshot.Project);
ILocalCommitStorage storage = getCommitStorage(projectKey, false);
if (storage.Git == null)
{
Trace.TraceError("[MainForm] storage.Git is null");
Debug.Assert(false);
return;
}
DataCache dataCache = getDataCacheByName(snapshot.DataCacheName);
if (dataCache == null || getCurrentUser() == null)
{
// It is unexpected to get here when we are not connected to a host
Debug.Assert(false);
return;
}
DiffCallHandler handler = new DiffCallHandler(storage.Git, _modificationNotifier, getCurrentUser(),
(mrk) =>
{
dataCache.DiscussionCache?.RequestUpdate(mrk,
Constants.DiscussionCheckOnNewThreadFromDiffToolInterval, null);
});
handler.Handle(matchInfo, snapshot);
}
finally
{
if (_requestedDiff.Any())
{
_requestedDiff.Dequeue();
BeginInvoke(new Action(() => processDiffQueue()));
}
}
}
public IHttpActionResult PostRight(string id, [FromBody] DiffRequest request)
{
return(ProcessInput(id, "right", request));
}
public async Task Returns_Internal_Server_Error_Response_If_Exception_Thrown(DiffRequest request, Guid id)
{
// Arrange
_mockEntryService
.Setup(x => x.AddSideToCompare(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <Side>()))
.Throws <Exception>();
// Act
var result = await _objectToTest.SetDiffRight(id, request);
// Assert
using (new AssertionScope())
{
result.Should().BeOfType <ObjectResult>();
var objectResult = result as ObjectResult;
objectResult.StatusCode.Should().Be(StatusCodes.Status500InternalServerError);
}
}
public async Task Returns_Bad_Request_Response_If_Invalid_Input_Exception_Exception_Thrown(DiffRequest request, Guid id)
{
// Arrange
_mockEntryService
.Setup(x => x.AddSideToCompare(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <Side>()))
.Throws <InvalidInputException>();
// Act
var result = await _objectToTest.SetDiffLeft(id, request);
// Assert
using (new AssertionScope())
{
result.Should().BeOfType <ObjectResult>();
var objectResult = result as ObjectResult;
objectResult.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
}
}
public async Task <ActionResult> SetDiffRight(Guid id, [FromBody] DiffRequest request)
{
return(await SetDiffSide(id, request, Side.Right));
}
public DiffRequest SingleOrDefault(int id, DiffRequest defaultEntity)
{
var entity = Single(id);
return(entity ?? defaultEntity);
}
public void Update(int id, DiffRequest entity)
{
entity.Id = id;
_dictionary[id] = entity.Clone();
}
