public async Task Should_Delete() { const int listId = 14; string path = $"/api/lists/{listId}"; MockRestClient.Setup(m => m.DeleteAsync <DeleteListResponse>(It.Is <string>(a => a == path))).ReturnsAsync(new ApiResponse <DeleteListResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new DeleteListResponse { Code = "Success" } }); ApiResponse <DeleteListResponse> response = await _listClient.DeleteAsync(listId).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.Equal("Success", response.Model.Code); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.DeleteAsync <DeleteListResponse>(It.Is <string>(a => a == path)), Times.Once); }
public async Task Should_Register_Device() { const string path = "/api/users/registerDeviceToken"; var request = new RegisterDeviceTokenRequest { Email = "*****@*****.**", UserId = "*****@*****.**" }; MockRestClient.Setup(m => m.PostAsync <RegisterDeviceTokenResponse>(It.Is <string>(a => a == path), It.IsAny <RegisterDeviceTokenRequest>())).ReturnsAsync(new ApiResponse <RegisterDeviceTokenResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new RegisterDeviceTokenResponse { Code = "Success" } }); ApiResponse <RegisterDeviceTokenResponse> response = await _userClient.RegisterDeviceTokenAsync(request).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.Equal("Success", response.Model.Code); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.PostAsync <RegisterDeviceTokenResponse>(It.Is <string>(a => a == path), It.IsAny <RegisterDeviceTokenRequest>()), Times.Once); }
public async Task Should_Update_Email() { string path = "/api/users/updateEmail"; var request = new UpdateEmailRequest { CurrentEmail = "*****@*****.**", NewEmail = "*****@*****.**" }; MockRestClient.Setup(m => m.PostAsync <UpdateUserResponse>(It.Is <string>(a => a == path), It.IsAny <UpdateEmailRequest>())).ReturnsAsync(new ApiResponse <UpdateUserResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new UpdateUserResponse { Code = "Success" } }); ApiResponse <UpdateUserResponse> response = await _userClient.UpdateEmailAsync(request).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.Equal("Success", response.Model.Code); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.PostAsync <UpdateUserResponse>(It.Is <string>(a => a == path), It.IsAny <UpdateEmailRequest>()), Times.Once); }
public async Task Should_Create_List() { const string path = "/api/lists"; const string name = "test_list"; const int listId = 14; MockRestClient.Setup(m => m.PostAsync <CreateListResponse>(It.Is <string>(a => a == path), It.Is <string>(a => a == name))).ReturnsAsync(new ApiResponse <CreateListResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new CreateListResponse { ListId = listId } }); ApiResponse <CreateListResponse> response = await _listClient.CreateAsync(name).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.Equal(listId, response.Model.ListId); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.PostAsync <CreateListResponse>(It.Is <string>(a => a == path), It.Is <string>(a => a == name)), Times.Once); }
public async Task Should_Retrieve_User() { const string userId = "*****@*****.**"; string path = $"/api/users/byUserId/{userId}"; MockRestClient.Setup(m => m.GetAsync <RetrieveUserResponse>(It.Is <string>(a => a == path))).ReturnsAsync(new ApiResponse <RetrieveUserResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new RetrieveUserResponse { User = new UserModel { Email = userId, UserId = userId } } }); ApiResponse <RetrieveUserResponse> response = await _userClient.GetByUserIdAsync(userId).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.NotNull(response.Model.User); Assert.Equal(userId, response.Model.User.Email); Assert.Equal(userId, response.Model.User.UserId); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.GetAsync <RetrieveUserResponse>(It.Is <string>(a => a == path)), Times.Once); }
public async Task Should_Retrieve_Users() { const int listId = 14; const string users = "[email protected]\[email protected]"; string path = $"/api/lists/getUsers?listId={listId}"; MockRestClient.Setup(m => m.GetContentAsync(It.Is <string>(a => a == path))).ReturnsAsync(new ApiResponse { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Content = users }); ApiResponse <GetUsersResponse> response = await _listClient.GetUsersAsync(listId).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.NotNull(response.Model.UserIds); Assert.True(response.Model.UserIds.Any()); Assert.Equal(2, response.Model.UserIds.Count()); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.GetContentAsync(It.Is <string>(a => a == path)), Times.Once); }
public void ShouldReturnHealthStatus() { var expected = new HealthStatus() { IsElasticsearchServerAvailable = true, IsMailServerAvailable = true, IsMessageQueueServerAvailable = true, }; var content = JsonConvert.SerializeObject(expected); var restResponse = new RestResponse() { Content = content }; MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource == HealthStatusName))) .Returns(restResponse); MockJsonConvert.Setup(x => x.DeserializeObject <HealthStatus>(content)) .Returns(expected); var actual = Subject.GetHealthStatus(); Assert.That(actual, Is.EqualTo(expected)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource == HealthStatusName)), Times.Once); MockJsonConvert.Verify(x => x.DeserializeObject <HealthStatus>(content), Times.Once); }
public async Task Should_Delete_User() { const string email = "*****@*****.**"; string path = $"/api/users/{email}"; MockRestClient.Setup(m => m.DeleteAsync <DeleteUserResponse>(It.Is <string>(a => a == path))).ReturnsAsync(new ApiResponse <DeleteUserResponse> { UrlPath = path, HttpStatusCode = HttpStatusCode.OK, Model = new DeleteUserResponse { Code = "Success" } }); ApiResponse <DeleteUserResponse> response = await _userClient.DeleteByEmailAsync(email).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Model); Assert.Equal("Success", response.Model.Code); Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode); Assert.Equal(path, response.UrlPath); MockRestClient.Verify(m => m.DeleteAsync <DeleteUserResponse>(It.Is <string>(a => a == path)), Times.Once); }
public void It_should_not_call_unfuddle_to_update_ticket_for_states_it_is_in_or_past() { Card card2 = new Card() { Id = 2, ExternalSystemName = "Unfuddle", ExternalCardID = "2" }; Card card4 = new Card() { Id = 4, ExternalSystemName = "Unfuddle", ExternalCardID = "4" }; ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card2, _mapping.LaneToStatesMap[2], _mapping); ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card4, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify( x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/2") && y.Method == Method.GET)), Times.Exactly(3)); MockRestClient.Verify( x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/2") && y.Method == Method.PUT)), Times.Exactly(2)); MockRestClient.Verify( x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.GET)), Times.Exactly(2)); MockRestClient.Verify( x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.PUT)), Times.Exactly(1)); }
public void It_should_call_leankit_to_create_card_if_existing_card_has_externalid_but_externalsystemname_does_not_match() { _mapping.Identity.LeanKit = 5; _mapping.Identity.Target = "5"; ((TestGitHubPulls)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/5/pulls") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(5, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_unfuddle_to_get_list_of_tickets() { _mapping.Identity.LeanKit = 1; _mapping.Identity.Target = "1"; ((TestUnfuddle)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("projects/1/ticket_reports") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(1, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_leankit_multiple_times_to_create_card_if_there_are_multiple_tickets() { _mapping.Identity.LeanKit = 3; _mapping.Identity.Target = "3"; ((TestUnfuddle)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("projects/3/ticket_reports") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(3, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(3)); }
public void It_should_call_leankit_once_to_create_card_if_there_is_one_pullrequest() { _mapping.Identity.LeanKit = 2; _mapping.Identity.Target = "2"; ((TestGitHubPulls)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/2/pulls") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(2, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_github_to_get_list_of_issues() { _mapping.Identity.LeanKit = 1; _mapping.Identity.Target = "1"; ((TestGitHubIssues)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/1/issues") && y.Method == Method.GET)), Times.Exactly(_mapping.QueryStates.Count)); MockLeanKitApi.Verify(x => x.AddCard(1, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_leankit_to_create_card_if_card_with_externalid_exists_but_different_externalsystemname() { _mapping.Identity.LeanKit = 5; _mapping.Identity.Target = "5"; ((TestGitHubIssues)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/5/issues") && y.Method == Method.GET)), Times.Exactly(_mapping.QueryStates.Count)); MockLeanKitApi.Verify(x => x.AddCard(5, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_leankit_multiple_times_to_create_card_if_there_are_multiple_issues() { _mapping.Identity.LeanKit = 3; _mapping.Identity.Target = "3"; ((TestGitHubIssues)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/3/issues") && y.Method == Method.GET)), Times.Exactly(_mapping.QueryStates.Count)); MockLeanKitApi.Verify(x => x.AddCard(3, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(3)); }
public void It_should_not_call_leankit_to_create_card_if_card_with_externalid_already_exists() { _mapping.Identity.LeanKit = 4; _mapping.Identity.Target = "4"; ((TestUnfuddle)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("projects/4/ticket_reports") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(4, It.IsAny <Card>(), It.IsAny <string>()), Times.Never()); }
public void It_should_call_leankit_create_card_if_card_with_externalid_exists_but_has_different_externalsystemname() { _mapping.Identity.LeanKit = 5; _mapping.Identity.Target = "5"; ((TestUnfuddle)TestItem).Syncronize(_mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("projects/5/ticket_reports") && y.Method == Method.GET)), Times.Exactly(1)); MockLeanKitApi.Verify(x => x.AddCard(5, It.IsAny <Card>(), It.IsAny <string>()), Times.Exactly(1)); }
public void It_should_call_github_to_update_issue_if_issue_state_is_not_end_state() { Card card = new Card() { Id = 1, ExternalSystemName = "GitHub", ExternalCardID = "1|1" }; ((TestGitHubIssues)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.GET)), Times.Exactly(1)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.PATCH)), Times.Exactly(1)); }
public void It_should_not_call_github_to_update_pull_if_github_does_not_have_matching_issue() { Card card = new Card() { Id = 3, ExternalSystemName = "GitHub", ExternalCardID = "3|3" }; ((TestGitHubPulls)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("pulls/3") && y.Method == Method.GET)), Times.Exactly(1)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("pulls/3") && y.Method == Method.PATCH)), Times.Never()); }
public void It_should_not_call_github_to_update_issue_if_externalsytemname_does_not_match() { Card card = new Card() { Id = 4, ExternalSystemName = "GitHubby", ExternalCardID = "4|4" }; ((TestGitHubIssues)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.GET)), Times.Never()); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.PATCH)), Times.Never()); }
public void It_should_call_unfuddle_to_update_ticket_for_each_state_of_workflow() { Card card = new Card() { Id = 1, ExternalSystemName = "Unfuddle", ExternalCardID = "1" }; ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/1") && y.Method == Method.GET)), Times.Exactly(4)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/1") && y.Method == Method.PUT)), Times.Exactly(3)); }
public void It_should_not_call_unfuddle_to_update_ticket_if_externalsystemname_does_not_match() { Card card = new Card() { Id = 4, ExternalSystemName = "Unfuddlest", ExternalCardID = "4" }; ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.GET)), Times.Never()); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.PUT)), Times.Never()); }
public void It_should_not_call_unfuddle_to_update_ticket_state_is_already_end_state() { Card card = new Card() { Id = 2, ExternalSystemName = "Unfuddle", ExternalCardID = "2" }; ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/2") && y.Method == Method.GET)), Times.Exactly(1)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/2") && y.Method == Method.PUT)), Times.Never()); }
public void It_should_not_call_github_to_update_issue_if_no_identified_properties_change() { Card card = new Card(); card.ExternalCardID = "4|4"; card.ExternalSystemName = "GitHub"; card.Description = "Issue 4"; card.Title = "Issue 4"; ((TestGitHubIssues)TestItem).TestCardUpdated(card, new List <string>(), _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.GET)), Times.Exactly(1)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.PATCH)), Times.Never()); }
public void It_should_not_call_github_to_update_issue_if_externalsystemname_does_not_match() { Card card = new Card(); card.ExternalCardID = "5|5"; card.ExternalSystemName = "GitHubber"; card.Description = "Issue 5"; card.Title = "Issue 5"; ((TestGitHubIssues)TestItem).TestCardUpdated(card, new List <string>(), _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/5") && y.Method == Method.GET)), Times.Never()); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/5") && y.Method == Method.PATCH)), Times.Never()); }
public void It_should_not_call_unfuddle_to_update_ticket_externalsystemname_does_not_match() { Card card = new Card(); card.ExternalCardID = "5"; card.ExternalSystemName = "Unfuddlest"; card.Description = "Ticket 5"; card.Title = "Ticket 5"; ((TestUnfuddle)TestItem).TestCardUpdated(card, new List <string>(), _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/5") && y.Method == Method.GET)), Times.Never()); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/5") && y.Method == Method.PUT)), Times.Never()); }
public void It_should_not_call_unfuddle_to_update_ticket_if_no_identified_properties_change() { Card card = new Card(); card.ExternalCardID = "4"; card.ExternalSystemName = "Unfuddle"; card.Description = "Ticket 4"; card.Title = "Ticket 4"; ((TestUnfuddle)TestItem).TestCardUpdated(card, new List <string>(), _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.GET)), Times.Exactly(1)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/4") && y.Method == Method.PUT)), Times.Never()); }
public void It_should_work_properly_with_spaces_between_states() { _mapping.LaneToStatesMap[2] = new List <string> { "accpted > resolved > closed" }; Card card = new Card() { Id = 3, ExternalSystemName = "Unfuddle", ExternalCardID = "3" }; ((TestUnfuddle)TestItem).TestUpdateStateOfExternalItem(card, _mapping.LaneToStatesMap[2], _mapping); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/3") && y.Method == Method.GET)), Times.Exactly(4)); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("tickets/3") && y.Method == Method.PUT)), Times.Exactly(3)); }
public void ShouldQueryTheHealthStatusEndpointAndReturnStatusCodeWhenPinging() { var restResponse = new RestResponse() { StatusCode = HttpStatusCode.OK }; MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource == HealthStatusName))).Returns(restResponse); var actual = Subject.Ping(); MockRestClient.Verify(x => x.Execute(It.Is <RestRequest>(y => y.Resource == HealthStatusName)), Times.Once); Assert.That(actual, Is.TypeOf(typeof(HttpStatusCode))); }