/// <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(); }