public void Constructor_2_OK() { var ex = new ServiceException( "x", new Exception()); }
public void ShouldBeSerializable() { Exception innerException = new Exception("Inner Error Message"); const string message = "Error message"; ServiceException exception = new ServiceException(message, innerException); SerializationHelper helper = new SerializationHelper(); ServiceException deserialized = helper.Roundtrip(exception); Assert.AreEqual(message, deserialized.Message, "The message was not serialized."); Assert.AreEqual(innerException.Message, deserialized.InnerException.Message, "The inner exception was not serialized."); }
public List<Entities.iDirectReports.ReportEntry> GetReport(DateTime startPeriod, DateTime endPeriod, List<uint> terminalIds) { try { return _iDirectReportDataSource.GetReport(startPeriod, endPeriod, terminalIds); } catch (Exception exception) { string additionalInfo = "Ошибка получения Networks"; ServiceException serviceException = new ServiceException(additionalInfo, exception); ServicesHelper.WriteErrorToDisk(typeof(iDirectReportService), serviceException); throw serviceException; } }
public void TestCaptureException() { ServiceException service = new ServiceException("Failed to invoke service.", new ServiceException("Failed to invoke other service.")); CapturedExceptionCollection<CapturedException> exceptions = ExceptionFormatter.CaptureException(service); Assert.IsNotNull(exceptions); Assert.IsNotEmpty(exceptions.GetEntities()); foreach (CapturedException exception in exceptions) { Assert.IsNotNull(exception); Console.WriteLine(exception); } }
public List<Network> GetTerminalsTree() { try { return _iDirectReportDataSource.GetTerminalsTree(); } catch (Exception exception) { string additionalInfo = "Ошибка получения Networks"; ServiceException serviceException = new ServiceException(additionalInfo, exception); ServicesHelper.WriteErrorToDisk(typeof(iDirectReportService), serviceException); throw serviceException; } }
public void GetSportTeamsNotFoundTest() { //Arrange. Exception internalEx = new SportNotFoundException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND); teamsRepo.Setup(r => r.GetSportTeams(It.IsAny <string>())).Throws(toThrow); //Act. IActionResult result = controllerToTest.GetTeams("Dummy"); NotFoundObjectResult notFound = result as NotFoundObjectResult; ErrorModelOut error = notFound.Value as ErrorModelOut; //Assert. teamsRepo.Verify(r => r.GetSportTeams(It.IsAny <string>()), Times.Once); Assert.IsNotNull(result); Assert.IsNotNull(notFound); Assert.AreEqual(404, notFound.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(toThrow.Message, error.ErrorMessage); }
public async void AddAsync_Throw_Exception_If_Regulation_Does_Not_Exist() { // arrange const string regulationId = "ID"; var rule = new WelcomeRegulationRule { RegulationId = regulationId }; _regulationRepositoryMock.Setup(o => o.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult <IRegulation>(null)); // act Task task = _service.AddAsync(rule); // assert ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await task); Assert.Equal("Regulation not found.", exception.Message); }
public void PutNoDataAccessTest() { //Arrange. Exception internalEx = new DataInaccessibleException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.DATA_INACCESSIBLE); teamsService.Setup(r => r.Modify(It.IsAny <TeamDto>())).Throws(toThrow); TeamModelIn input = CreateTeamModelIn(); //Act. IActionResult result = controller.Put(2, input); ObjectResult noData = result as ObjectResult; ErrorModelOut error = noData.Value as ErrorModelOut; //Assert. Assert.IsNotNull(result); Assert.IsNotNull(noData); Assert.AreEqual(500, noData.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(toThrow.Message, error.ErrorMessage); }
public async Task ExceedMaxRedirectsShouldThrowsException() { var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "http://example.org/foo"); var _response1 = new HttpResponseMessage(HttpStatusCode.Redirect); _response1.Headers.Location = new Uri("http://example.org/bar"); var _response2 = new HttpResponseMessage(HttpStatusCode.Redirect); _response2.Headers.Location = new Uri("http://example.org/foo"); this.testHttpMessageHandler.SetHttpResponse(_response1, _response2); ServiceException exception = await Assert.ThrowsAsync <ServiceException> (async() => await this.invoker.SendAsync( httpRequestMessage, CancellationToken.None)); Assert.True(exception.IsMatch(ErrorConstants.Codes.TooManyRedirects)); Assert.Equal(String.Format(ErrorConstants.Messages.TooManyRedirectsFormatString, 5), exception.Error.Message); Assert.IsType(typeof(ServiceException), exception); }
public void DeleteByIdNotExistentTest() { //Arrange. Exception internalEx = new TeamNotFoundException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND); teamsService.Setup(r => r.DeleteTeam(It.IsAny <int>())).Throws(toThrow); //Act. IActionResult result = controller.Delete(2); NotFoundObjectResult notFound = result as NotFoundObjectResult; ErrorModelOut error = notFound.Value as ErrorModelOut; //Assert. teamsService.Verify(r => r.DeleteTeam(2), Times.Once); Assert.IsNotNull(result); Assert.IsNotNull(notFound); Assert.AreEqual(404, notFound.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(toThrow.Message, error.ErrorMessage); }
public async Task SendAsync_ThrowsServiceExceptionWithEmptyMessageOnHTTPNotFoundWithoutErrorBody() { using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "https://localhost")) using (var stringContent = new StringContent("test")) using (var httpResponseMessage = new HttpResponseMessage()) { httpResponseMessage.Content = stringContent; httpResponseMessage.StatusCode = HttpStatusCode.NotFound; this.testHttpMessageHandler.AddResponseMapping(httpRequestMessage.RequestUri.ToString(), httpResponseMessage); this.serializer.Setup( mySerializer => mySerializer.DeserializeObject <ErrorResponse>( It.IsAny <Stream>())) .Returns((ErrorResponse)null); ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await this.simpleHttpProvider.SendAsync(httpRequestMessage)); Assert.True(exception.IsMatch(ErrorConstants.Codes.ItemNotFound)); Assert.True(string.IsNullOrEmpty(exception.Error.Message)); } }
public void CreateUserNoDataAccessTest() { //Arrange. Exception internalEx = new DataInaccessibleException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.DATA_INACCESSIBLE); service.Setup(us => us.AddUser(It.IsAny <UserDto>())).Throws(toThrow); //Act. IActionResult result = controller.Post(input); ObjectResult noData = result as ObjectResult; ErrorModelOut error = noData.Value as ErrorModelOut; //Assert. Assert.IsNotNull(result); Assert.IsNotNull(noData); Assert.AreEqual(500, noData.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(toThrow.Message, error.ErrorMessage); }
public async Task SendRequest_UnauthorizedWithNoAuthenticationProvider() { var httpRequestMessage = new HttpRequestMessage(HttpMethod.Put, "https://example.com/bar"); httpRequestMessage.Content = new StringContent("Hello World"); var unauthorizedResponse = new HttpResponseMessage(HttpStatusCode.Unauthorized); var okResponse = new HttpResponseMessage(HttpStatusCode.OK); testHttpMessageHandler.SetHttpResponse(unauthorizedResponse, okResponse); IList <DelegatingHandler> handlersWithNoAuthProvider = GraphClientFactory.CreateDefaultHandlers(null); using (HttpClient client = GraphClientFactory.Create(handlers: handlersWithNoAuthProvider, finalHandler: this.testHttpMessageHandler)) { ServiceException ex = await Assert.ThrowsAsync <ServiceException>(() => client.SendAsync(httpRequestMessage, new CancellationToken())); Assert.Equal(ErrorConstants.Codes.InvalidRequest, ex.Error.Code); Assert.Equal(ErrorConstants.Messages.AuthenticationProviderMissing, ex.Error.Message); } }
public async Task Get_CallBatchByUserIdsSevice_ThrowsServiceException() { // Arrange var activityInstance = this.GetDataStreamFacadeInstance(); this.sentNotificationDataRepository .Setup(x => x.GetStreamsAsync(this.notificationId, null)) .Returns(this.sentNotificationDataList.ToAsyncEnumerable()); var serviceException = new ServiceException(null, null, HttpStatusCode.Unauthorized); this.usersService .Setup(x => x.GetBatchByUserIds(It.IsAny <IEnumerable <IEnumerable <string> > >())) .ThrowsAsync(serviceException); // Act var userDataStream = activityInstance.GetUserDataStreamAsync(this.notificationId, this.notificationStatus); Func <Task> task = async() => await userDataStream.ForEachAsync(x => x.ToList()); // Assert await task.Should().ThrowAsync <ServiceException>(); }
public void CreateAlreadyExistentUserTest() { //Arrange. Exception internalEx = new UserAlreadyExistsException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_ALREADY_EXISTS); service.Setup(us => us.AddUser(It.IsAny <UserDto>())).Throws(toThrow); //Act. IActionResult result = controller.Post(input); BadRequestObjectResult badRequest = result as BadRequestObjectResult; ErrorModelOut error = badRequest.Value as ErrorModelOut; //Assert. service.Verify(us => us.AddUser(It.IsAny <UserDto>()), Times.Once); Assert.IsNotNull(result); Assert.IsNotNull(badRequest); Assert.AreEqual(400, badRequest.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(error.ErrorMessage, toThrow.Message); }
/// <summary> /// Get bookmark collection in word /// </summary> /// <returns>Dictionary with key is bookmark name and value is bookmark text</returns> public void GetBookmarkCollection(string key) { try { ContentServiceProfile contentProfile = Wkl.MainCtrl.ServiceCtrl.GetProfile(key).ContentService; Dictionary <string, string> bookmarks = new Dictionary <string, string>(); Bookmarks bms = Wkl.MainCtrl.CommonCtrl.CommonProfile.Bookmarks; foreach (Bookmark bookmark in bms) { if (bookmark.Name.Contains(ProntoMarkup.KeyImage)) { bookmarks.Add(bookmark.Name, MarkupUtilities.GetBizNameOfBookmarkImage(bookmark.Name, Wkl.MainCtrl.CommonCtrl.CommonProfile.ActiveDoc.InlineShapes)); } else { bookmarks.Add(bookmark.Name, MarkupUtilities.GetRangeText(bookmark.Range)); } } contentProfile.GetBookmarks_OListBM = bookmarks; } catch (BaseException srvExp) { Services.ServiceException newSrvExp = new Services.ServiceException(ErrorCode.ipe_GetWordBookmarksError); newSrvExp.Errors.Add(srvExp); throw newSrvExp; } catch (Exception ex) { ServiceException srvExp = new ServiceException(ErrorCode.ipe_GetWordBookmarksError, MessageUtils.Expand(Properties.Resources.ipe_GetWordBookmarksError, ex.Message), ex.StackTrace); throw srvExp; } }
public bool IsProntoDoc() { try { ProntoDoc.Framework.CoreObject.PdwxObjects.ChecksumInfo checksum = mainService.PropertyService.GetChecksum(); return(IsProntoDoc(checksum)); } catch (BaseException srvExp) { Services.ServiceException newSrvExp = new Services.ServiceException(ErrorCode.ipe_ValidateChecksumError); newSrvExp.Errors.Add(srvExp); throw newSrvExp; } catch (System.Exception ex) { ServiceException srvExp = new ServiceException(Core.ErrorCode.ipe_ValidateChecksumError, Core.MessageUtils.Expand(Properties.Resources.ipe_ValidateChecksumError, ex.Message), ex.StackTrace); throw srvExp; } }
public async void UpdateAsync_Throw_Exception_If_Rule_Does_Not_Exist() { // arrange const string regulationRuleId = "ID"; _regulationRepositoryMock.Setup(o => o.GetAsync(It.IsAny <string>())) .ReturnsAsync(new Core.Domain.Regulation()); _welcomeRegulationRuleRepositoryMock.Setup(o => o.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult <IWelcomeRegulationRule>(null)); // act Task task = _service.UpdateAsync(new WelcomeRegulationRule { RegulationId = regulationRuleId }); // assert ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await task); Assert.Equal("Regulation rule not found.", exception.Message); }
public void SaveSelectedDomainToFile(UserData userData) { try { string dataSerialize = ProntoDoc.Framework.Utils.ObjectSerializeHelper.SerializeToString(userData); FileAdapter.SaveUserData(dataSerialize); } catch (BaseException srvExp) { Services.ServiceException newSrvExp = new Services.ServiceException(ErrorCode.ipe_SaveFileError); newSrvExp.Errors.Add(srvExp); throw newSrvExp; } catch (Exception ex) { ServiceException srvExp = new ServiceException(Core.ErrorCode.ipe_SaveFileError, Core.MessageUtils.Expand(Properties.Resources.ipe_SaveFileError, ex.Message), ex.StackTrace); throw srvExp; } }
public async Task SyncAllUsers_ExpiredDeltaLink_ThrowsInvalidOperationException() { // Arrange var activityContext = this.GetSyncAllUsersActivity(); string deltaLink = "expiredDeltaLink"; IEnumerable <UserDataEntity> userDataResponse = new List <UserDataEntity>() { new UserDataEntity() { Name = string.Empty }, }; NotificationDataEntity notification = new NotificationDataEntity() { Id = "notificationId1", }; this.userDataRepository .Setup(x => x.GetDeltaLinkAsync()) .ReturnsAsync(deltaLink); this.userDataRepository .Setup(x => x.SetDeltaLinkAsync(It.IsAny <string>())) .Returns(Task.CompletedTask); this.userDataRepository .Setup(x => x.GetAllAsync(It.IsAny <string>(), null)) .ReturnsAsync(userDataResponse); var serviceException = new ServiceException(null, null, HttpStatusCode.BadRequest); this.userService.Setup(x => x.GetAllUsersAsync(It.IsAny <string>())).ThrowsAsync(serviceException); Func <Task> task = async() => await activityContext.RunAsync(notification, this.logger.Object); // Assert await task.Should().ThrowAsync <InvalidOperationException>(); this.userService.Verify(x => x.GetAllUsersAsync(It.IsAny <string>()), Times.Exactly(2)); }
public async Task SendAsync_CopyClientRequestIdHeader_AddClientRequestIdToError() { using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "https://localhost")) using (var stringContent = new StringContent("test")) using (var httpResponseMessage = new HttpResponseMessage()) { httpResponseMessage.Content = stringContent; const string clientRequestId = "3c9c5bc6-42d2-49ac-a99c-49c10513339a"; httpResponseMessage.StatusCode = HttpStatusCode.BadRequest; httpResponseMessage.Headers.Add(CoreConstants.Headers.ClientRequestId, clientRequestId); httpResponseMessage.RequestMessage = httpRequestMessage; this.testHttpMessageHandler.AddResponseMapping(httpRequestMessage.RequestUri.ToString(), httpResponseMessage); ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await this.simpleHttpProvider.SendAsync(httpRequestMessage)); Assert.NotNull(exception.Error); Assert.Equal(clientRequestId, exception.Error.ClientRequestId); } }
public async void AddAsync_Throw_Exception_If_Regulation_Already_Exists() { // arrange const string regulationId = "ID"; _regulationRepositoryMock.Setup(o => o.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult <IRegulation>(new Core.Domain.Regulation { Id = regulationId })); // act Task task = _service.AddAsync(new Core.Domain.Regulation { Id = regulationId }); // assert ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await task); Assert.Equal("Regulation already exists.", exception.Message); }
public void UnfollowTeamNotFoundTest() { //Arrange. TeamModelIn input = GetTeamModelIn(); Exception internalEx = new TeamNotFoundException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND); service.Setup(us => us.UnFollowTeam(It.IsAny <string>(), It.IsAny <int>())).Throws(toThrow); //Act. IActionResult result = controller.UnFollowTeam(3); NotFoundObjectResult notFound = result as NotFoundObjectResult; ErrorModelOut error = notFound.Value as ErrorModelOut; //Assert. service.Verify(us => us.UnFollowTeam(It.IsAny <string>(), It.IsAny <int>()), Times.Once); Assert.IsNotNull(result); Assert.IsNotNull(notFound); Assert.AreEqual(404, notFound.StatusCode); Assert.IsNotNull(error); Assert.AreEqual(error.ErrorMessage, toThrow.Message); }
public async Task Get_ForbiddenGraphPermission_ReturnsAdminConsentError() { // Arrange var activityInstance = this.GetDataStreamFacadeInstance(); var userDataList = new List <User>(); var error = new Graph.Error() { Code = HttpStatusCode.Forbidden.ToString(), Message = "UnAuthorized", }; var forbiddenException = new ServiceException(error, null, HttpStatusCode.Forbidden); this.sentNotificationDataRepository .Setup(x => x.GetStreamsAsync(this.notificationId, null)) .Returns(this.sentNotificationDataWithErrorList.ToAsyncEnumerable()); this.userDataRepository .Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync(new UserDataEntity()); var sendNotificationData = this.sentNotificationDataWithErrorList.Select(x => x.Where(y => y.RowKey == "RowKey").FirstOrDefault()).FirstOrDefault(); this.usersService .Setup(x => x.GetBatchByUserIds(It.IsAny <IEnumerable <IEnumerable <string> > >())) .ThrowsAsync(forbiddenException); string adminConsentError = "AdminConsentError"; var localizedString = new LocalizedString(adminConsentError, adminConsentError); this.localizer.Setup(_ => _[adminConsentError]).Returns(localizedString); // Act var userDataStream = await activityInstance.GetUserDataStreamAsync(this.notificationId).ToListAsync(); var userData = userDataStream.Select(x => x.Where(y => y.Id == "RowKey").FirstOrDefault()).FirstOrDefault(); // Assert Assert.Equal(userData.Name, adminConsentError); Assert.Equal(userData.Upn, adminConsentError); Assert.Equal(userData.UserType, adminConsentError); }
public static SkillException HandleGraphAPIException(ServiceException ex) { var skillExceptionType = SkillExceptionType.Other; if (ex.Message.Contains(APIErrorAccessDenied, StringComparison.InvariantCultureIgnoreCase)) { skillExceptionType = SkillExceptionType.APIAccessDenied; } else if (ex.StatusCode == System.Net.HttpStatusCode.Unauthorized) { skillExceptionType = SkillExceptionType.APIUnauthorized; } else if (ex.StatusCode == System.Net.HttpStatusCode.Forbidden) { skillExceptionType = SkillExceptionType.APIForbidden; } else if (ex.StatusCode == System.Net.HttpStatusCode.BadRequest) { skillExceptionType = SkillExceptionType.APIBadRequest; } return(new SkillException(skillExceptionType, ex.Message, ex)); }
public async Task <ActionResult> Schedule(int teamId = 0) { IEnumerable <Game> games = new List <Game>(); ServiceException error = null; try { games = await resultService.GetScheduleAsync(teamId); } catch (ServiceException e) { error = e; } var viewModel = new GamesViewModel(games, error); if (Request.IsAjaxRequest()) { return(PartialView(viewModel)); } return(View(viewModel)); }
public void LoginNotFoundTest() { //Arrange. Exception internalEx = new UserNotFoundException(); Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND); loginService.Setup(l => l.Login("otherUsername", "aPassword")).Throws(toThrow); //Act. LoginModelIn credentials = new LoginModelIn() { Username = "******", Password = "******" }; IActionResult result = controllerToTest.Authenticate(credentials); BadRequestObjectResult badRequestResult = result as BadRequestObjectResult; ErrorModelOut error = badRequestResult.Value as ErrorModelOut; //Assert. loginService.VerifyAll(); Assert.IsNotNull(badRequestResult); Assert.IsNotNull(error); Assert.AreEqual(toThrow.Message, error.ErrorMessage); }
/// <summary> /// Gen check sum /// </summary> /// <param name="srvPro"></param> /// <param name="lstJParam">List JParameter just buit with select (-> has new order)</param> private void GetCheckSum(ServicesProfile srvPro, List <ChecksumInfoItem> checksumItems, string dscColor, bool hasDsc) { try { GenChecksumHelper genChkHelper = new GenChecksumHelper(); srvPro.PdwInfo.ChecksumString = genChkHelper.GenChecksum( srvPro.PdwInfo.OsqlString, checksumItems, srvPro.TemplateType, dscColor, hasDsc, srvPro.FullDocName); } catch (BaseException srvExp) { Services.ServiceException newSrvExp = new Services.ServiceException(ErrorCode.ipe_GenChecksumError); newSrvExp.Errors.Add(srvExp); throw newSrvExp; } catch (Exception ex) { ServiceException srvExp = new ServiceException( ErrorCode.ipe_GenChecksumError, MessageUtils.Expand(Properties.Resources.ipe_GenChecksumError, ex.Message), ex.StackTrace); throw srvExp; } }
public async void DeleteAsync_Can_Not_Delete_If_Regulation_Assigned_With_Client() { // arrange const string regulationId = "ID"; _regulationRepositoryMock.Setup(o => o.GetAsync(It.IsAny <string>())) .ReturnsAsync(new Core.Domain.Regulation()); _clientRegulationRepositoryMock .Setup(o => o.GetByRegulationIdAsync(It.IsAny <string>())) .ReturnsAsync(new List <ClientRegulation> { new ClientRegulation() }); // act Task task = _service.DeleteAsync(regulationId); // assert ServiceException exception = await Assert.ThrowsAsync <ServiceException>(async() => await task); Assert.Equal("Can not delete regulation associated with one or more clients.", exception.Message); }
public async Task <ActionResult> Team(int teamId) { Group group = null; ServiceException error = null; try { group = await resultService.GetGroupForTeam(teamId); } catch (ServiceException e) { error = e; } var viewModel = new GroupViewModel(group, error); if (Request.IsAjaxRequest()) { return(PartialView(viewModel)); } return(View(viewModel)); }
public async Task Get_ForbiddenGraphPermission_ReturnsAdminConsentError() { // Arrange var getMetadataActivityInstance = this.GetMetadataActivity(); var notificationDataEntity = this.GetNotificationDataEntity(); var exportDataEntity = this.GetExportDataEntity(); var user = this.GetUser(); string key = "AdminConsentError"; var localizedString = new LocalizedString(key, key); this.localizer.Setup(_ => _[key]).Returns(localizedString); var serviceException = new ServiceException(null, null, HttpStatusCode.Forbidden); this.usersService.Setup(x => x.GetUserAsync(It.IsAny <string>())).ThrowsAsync(serviceException); // Act var result = await getMetadataActivityInstance.GetMetadataActivityAsync((notificationDataEntity, exportDataEntity)); // Assert Assert.NotNull(result); Assert.Equal(result.ExportedBy, key); }
public override void OnException(HttpActionExecutedContext context) { if (context.Exception != null) { HttpStatusCode code; ODataError report = null; if (context.Exception is HttpResponseException) { return; } else if (context.Exception is ServiceException) { var e = (ServiceException)context.Exception.GetLastInnerException(); report = e.Error; code = e.StatusCode; } else if (context.Exception is ModelStateException) { var e = new ServiceException((ModelStateException)context.Exception); report = e.Error; code = e.StatusCode; } else { report = CommunicationErrors.InternalServerError; report.InnerError = new ODataInnerError(context.Exception.GetLastInnerException()); code = HttpStatusCode.InternalServerError; } LogException(context, code, report); context.Exception = new HttpResponseException(context.Request.CreateResponse(code, report)); } }
public static async Task <bool> ShouldContinue(ServiceException mgsex, int currentRetry) { int waitForMilliSeconds; switch (mgsex.StatusCode) { case System.Net.HttpStatusCode.TooManyRequests: waitForMilliSeconds = 1000 * currentRetry * currentRetry; break; case System.Net.HttpStatusCode.Unauthorized: waitForMilliSeconds = 1000 * currentRetry * currentRetry; break; case System.Net.HttpStatusCode.BadGateway: waitForMilliSeconds = 1000 * currentRetry * currentRetry; break; case System.Net.HttpStatusCode.Forbidden: return(false); case System.Net.HttpStatusCode.NotFound: case System.Net.HttpStatusCode.BadRequest: default: return(false); } if (currentRetry == MaxRetry) { return(false); } else { await Task.Delay(waitForMilliSeconds); } return(true); }
private static void ExceptionSerializationTest() { var formatter = new XmlFormatter(); var ms = new MemoryStream(); try { formatter.Serialize(ms, new NotImplementedException("test ex 23432"), typeof(Exception)); } catch (Exception ex) { } try { var exObject = new ServiceException("test ex 234234"); var type = exObject.GetType(); formatter.Serialize(ms, exObject, type); ms.Position = 0; var dexObj = formatter.Deserialize(ms, type); } catch (Exception ex) { } try { var exObject = new NotImplementedException("test ex 23432"); var type = exObject.GetType(); formatter.Serialize(ms, exObject, type); ms.Position = 0; var dexObj = formatter.Deserialize(ms, type); } catch (Exception ex) { } }
/// <summary> /// Processes the specified action and wraps it with common error handling logic. /// </summary> /// <remarks> /// If any exception is thrown, the <see cref="ArgumentException"/>, <see cref="ConfigurationException"/>, /// and <see cref="ServiceException"/> exceptions will be simply re-thrown. /// All other exceptions will be wrapped in <see cref="ServiceException"/> and thrown. /// </remarks> /// <param name="action">The action to process.</param> /// <param name="logger">The logger.</param> /// <param name="methodDescription">The short description of what the source method does.</param> /// <param name="methodName">The full method name.</param> private static void Process(Action action, ILog logger, string methodDescription, string methodName) { Exception thrownException = null; try { action(); } catch (ArgumentException ex) { thrownException = ex; throw; } catch (ConfigurationException ex) { thrownException = ex; throw; } catch (ServiceException ex) { thrownException = ex; throw; } catch (Exception ex) { string errorMessage = $"Error occurred while {methodDescription}."; thrownException = new ServiceException(errorMessage, ex); throw thrownException; } finally { if (thrownException != null) { LogException(logger, methodName, thrownException); } } }
/// <summary> /// Handles a message routed to the service by the MessageBroker. /// </summary> /// <param name="message">The message that should be handled by the service.</param> /// <returns>The result of the message processing.</returns> public override object ServiceMessage(IMessage message) { CommandMessage commandMessage = message as CommandMessage; MessageDestination messageDestination = GetDestination(message) as MessageDestination; if( commandMessage != null ) { string clientId = commandMessage.clientId as string; MessageClient messageClient = messageDestination.SubscriptionManager.GetSubscriber(clientId); AcknowledgeMessage acknowledgeMessage = null; switch (commandMessage.operation) { case CommandMessage.SubscribeOperation: if (messageClient == null) { if (clientId == null) clientId = Guid.NewGuid().ToString("D"); if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.MessageServiceSubscribe, messageDestination.Id, clientId)); string endpointId = commandMessage.GetHeader(MessageBase.EndpointHeader) as string; if (_messageBroker.GetEndpoint(endpointId) == null) { ServiceException serviceException = new ServiceException("Endpoint was not specified"); serviceException.FaultCode = "Server.Processing.MissingEndpoint"; throw serviceException; } commandMessage.clientId = clientId; if (messageDestination.ServiceAdapter != null && messageDestination.ServiceAdapter.HandlesSubscriptions) { try { acknowledgeMessage = messageDestination.ServiceAdapter.Manage(commandMessage) as AcknowledgeMessage; } catch (MessageException me) { acknowledgeMessage = me.GetErrorMessage(); //Leave, do not subscribe return acknowledgeMessage; } catch (Exception ex) { //Guard against service adapter failure acknowledgeMessage = ErrorMessage.GetErrorMessage(commandMessage, ex); if (log.IsErrorEnabled) log.Error(__Res.GetString(__Res.ServiceAdapter_ManageFail, this.id, messageDestination.Id, commandMessage), ex); //Leave, do not subscribe return acknowledgeMessage; } } Subtopic subtopic = null; Selector selector = null; if (commandMessage.headers != null) { if (commandMessage.headers.ContainsKey(CommandMessage.SelectorHeader)) { selector = Selector.CreateSelector(commandMessage.headers[CommandMessage.SelectorHeader] as string); } if (commandMessage.headers.ContainsKey(AsyncMessage.SubtopicHeader)) { subtopic = new Subtopic(commandMessage.headers[AsyncMessage.SubtopicHeader] as string); } } IClient client = FluorineContext.Current.Client; client.Renew(); messageClient = messageDestination.SubscriptionManager.AddSubscriber(clientId, endpointId, subtopic, selector); if (acknowledgeMessage == null) acknowledgeMessage = new AcknowledgeMessage(); acknowledgeMessage.clientId = clientId; } else { acknowledgeMessage = new AcknowledgeMessage(); acknowledgeMessage.clientId = clientId; } return acknowledgeMessage; case CommandMessage.UnsubscribeOperation: if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.MessageServiceUnsubscribe, messageDestination.Id, clientId)); if (messageDestination.ServiceAdapter != null && messageDestination.ServiceAdapter.HandlesSubscriptions) { try { acknowledgeMessage = messageDestination.ServiceAdapter.Manage(commandMessage) as AcknowledgeMessage; } catch (MessageException me) { acknowledgeMessage = me.GetErrorMessage(); } catch (Exception ex) { //Guard against service adapter failure acknowledgeMessage = ErrorMessage.GetErrorMessage(commandMessage, ex); if (log.IsErrorEnabled) log.Error(__Res.GetString(__Res.ServiceAdapter_ManageFail, this.id, messageDestination.Id, commandMessage), ex); } } if (messageClient != null) messageDestination.SubscriptionManager.RemoveSubscriber(messageClient); if (acknowledgeMessage == null) acknowledgeMessage = new AcknowledgeMessage(); return acknowledgeMessage; case CommandMessage.PollOperation: { if (messageClient == null) { ServiceException serviceException = new ServiceException(string.Format("MessageClient is not subscribed to {0}", commandMessage.destination)); serviceException.FaultCode = "Server.Processing.NotSubscribed"; throw serviceException; } IClient client = FluorineContext.Current.Client; client.Renew(); try { acknowledgeMessage = messageDestination.ServiceAdapter.Manage(commandMessage) as AcknowledgeMessage; } catch (MessageException me) { acknowledgeMessage = me.GetErrorMessage(); } catch (Exception ex) { //Guard against service adapter failure acknowledgeMessage = ErrorMessage.GetErrorMessage(commandMessage, ex); if (log.IsErrorEnabled) log.Error(__Res.GetString(__Res.ServiceAdapter_ManageFail, this.id, messageDestination.Id, commandMessage), ex); } if (acknowledgeMessage == null) acknowledgeMessage = new AcknowledgeMessage(); return acknowledgeMessage; } case CommandMessage.ClientPingOperation: if (messageDestination.ServiceAdapter != null && messageDestination.ServiceAdapter.HandlesSubscriptions) { try { messageDestination.ServiceAdapter.Manage(commandMessage); } catch (MessageException) { return false; } catch (Exception ex) { //Guard against service adapter failure if (log.IsErrorEnabled) log.Error(__Res.GetString(__Res.ServiceAdapter_ManageFail, this.id, messageDestination.Id, commandMessage), ex); return false; } } return true; default: if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.MessageServiceUnknown, commandMessage.operation, messageDestination.Id)); try { acknowledgeMessage = messageDestination.ServiceAdapter.Manage(commandMessage) as AcknowledgeMessage; } catch (MessageException me) { acknowledgeMessage = me.GetErrorMessage(); } catch (Exception ex) { //Guard against service adapter failure acknowledgeMessage = ErrorMessage.GetErrorMessage(commandMessage, ex); if (log.IsErrorEnabled) log.Error(__Res.GetString(__Res.ServiceAdapter_ManageFail, this.id, messageDestination.Id, commandMessage), ex); } if (acknowledgeMessage == null) acknowledgeMessage = new AcknowledgeMessage(); return acknowledgeMessage; } } else { if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.MessageServiceRoute, messageDestination.Id, message.clientId)); if (FluorineContext.Current != null && FluorineContext.Current.Client != null)//Not set when user code initiates push { IClient client = FluorineContext.Current.Client; client.Renew(); } object result = messageDestination.ServiceAdapter.Invoke(message); return result; } }
public void Constructor_0_OK() { var ex = new ServiceException(); }
public void ShouldStoreMessagePassedToConstructor() { const string message = "Error Message"; ServiceException exception = new ServiceException(message); Assert.AreEqual(message, exception.Message); }
public void ShouldProvideDefaultMessage() { ServiceException serviceException = new ServiceException(); Assert.AreEqual("Exception of type 'ServiceInterfaces.ServiceException' was thrown.", serviceException.Message); }
private UploadChunkResult SetupGetChunkResponseTest(ServiceException serviceException = null, bool failsOnce = true, bool verifyTrackedExceptions = true) { var chunkSize = 320 * 1024; var bytesToUpload = new byte[] { 4, 8, 15, 16 }; var trackedExceptions = new List<Exception>(); this.uploadSession.Object.NextExpectedRanges = new[] { "0-" }; var stream = new MemoryStream(bytesToUpload.Length); stream.Write(bytesToUpload, 0, bytesToUpload.Length); stream.Seek(0, SeekOrigin.Begin); var provider = new ChunkedUploadProvider( this.uploadSession.Object, this.client.Object, stream, chunkSize); var mockRequest = new Mock<UploadChunkRequest>( this.uploadSession.Object.UploadUrl, this.client.Object, null, 0, bytesToUpload.Length - 1, bytesToUpload.Length); if (serviceException != null && failsOnce) { mockRequest.SetupSequence(r => r.PutAsync( It.IsAny<Stream>(), It.IsAny<CancellationToken>())) .Throws(serviceException) .Returns(Task.FromResult(new UploadChunkResult() { ItemResponse = new Item()})); } else if (serviceException != null) { mockRequest.Setup(r => r.PutAsync( It.IsAny<Stream>(), It.IsAny<CancellationToken>())) .Throws(serviceException); } else { mockRequest.Setup(r => r.PutAsync( It.IsAny<Stream>(), It.IsAny<CancellationToken>())) .Returns(Task.FromResult(new UploadChunkResult { ItemResponse = new Item()})); } var task = provider.GetChunkRequestResponseAsync(mockRequest.Object, bytesToUpload, trackedExceptions); try { task.Wait(); } catch (AggregateException exception) { throw exception.InnerException; } if (verifyTrackedExceptions) { Assert.IsTrue(trackedExceptions.Contains(serviceException), "Expected ServiceException in TrackedException list"); } return task.Result; }
internal ServiceFailedEventArgs(ServiceException error, object userToken) : base(userToken) { Error = error; }
public void GetChunkRequestResponseTest_Fail() { var exception = new ServiceException(new Error { Code = "Timeout" }); var result = this.SetupGetChunkResponseTest(exception, failsOnce: false); }
public void GetChunkRequestResponseTest_InvalidRange() { var exception = new ServiceException(new Error { Code = "InvalidRange" }); var result = this.SetupGetChunkResponseTest(exception, verifyTrackedExceptions: false); Assert.IsNull(result.ItemResponse, "Expected no Item in ItemResponse"); Assert.IsNull(result.UploadSession, "Expected no UploadSession in response"); }
public void GetChunkRequestResponseTest_SuccessAfterOneException() { var exception = new ServiceException(new Error {Code = "GeneralException"}); var result = this.SetupGetChunkResponseTest(exception); Assert.IsNotNull(result.ItemResponse, "Expected Item in ItemResponse"); Assert.IsTrue(result.UploadSucceeded); }
public ErrorDetails(string MethodName, string DateTime, ServiceException ExceptionType) { this.MethodName = MethodName; this.DateTime = DateTime; this.ExceptionType = ExceptionType; }
public List<HughesSpeedTest> GetHughesSpeedTests(HughesSpeedTest filter, int pageNumber, int pageSize) { try { _hughesSpeedTestDataSource.AdditionalQueryParameters = filter; _hughesSpeedTestDataSource.CurrentPage = pageNumber; _hughesSpeedTestDataSource.PageSize = pageSize; return _hughesSpeedTestDataSource.PageData; } catch (Exception exception) { ServiceException serviceException = new ServiceException(exception); ServicesHelper.WriteErrorToDisk(typeof(HughesSpeedTestService), serviceException); throw serviceException; } }
/// <summary> /// Получить подробную статистику для теста скорости /// </summary> /// <param name="testId">Id теста</param> /// <returns></returns> public List<HughesSpeedTestDetail> GetHughesSpeedTestDetails(int testId) { try { return _hughesSpeedTestDataSource.GetHughesSpeedTestDetails(testId); } catch (Exception exception) { string additionalInfo = string.Format("Ошибка получения HughesSpeedTestDetail для теста с testId = {0}", testId); ServiceException serviceException = new ServiceException(additionalInfo, exception); ServicesHelper.WriteErrorToDisk(typeof(ContractService), serviceException); throw serviceException; } }
public int GetHughesSpeedTestsCount( HughesSpeedTest filter, DateTime startPeriod, DateTime endPeriod) { try { _hughesSpeedTestDataSource.StartPeriod = startPeriod; _hughesSpeedTestDataSource.EndPeriod = endPeriod; _hughesSpeedTestDataSource.AdditionalQueryParameters = filter; return _hughesSpeedTestDataSource.TotalRecordCount; } catch (Exception exception) { ServiceException serviceException = new ServiceException(exception); ServicesHelper.WriteErrorToDisk(typeof(HughesSpeedTestService), serviceException); throw serviceException; } }