public async Task ThenExecuteStepSucceedsAsync() { // Arrange AS4Message as4Message = await GetEncryptedAS4MessageAsync(); var context = new MessagingContext(as4Message, MessagingContextMode.Receive) { ReceivingPMode = new ReceivingProcessingMode { Security = { Decryption = { Encryption = Limit.Allowed, DecryptCertificateInformation = new CertificateFindCriteria { CertificateFindValue = "", CertificateFindType = X509FindType.FindByIssuerName } } } } }; // Act StepResult stepResult = await ExerciseDecryption(context); // Assert Assert.False(stepResult.MessagingContext.AS4Message.IsEncrypted); }
/// <summary> /// Create a new <see cref="AS4Response"/> instance. /// </summary> /// <param name="requestMessage"></param> /// <param name="webResponse"></param> /// <returns></returns> public static async Task <AS4Response> Create(MessagingContext requestMessage, HttpWebResponse webResponse) { var response = new AS4Response(requestMessage, webResponse); var responseStream = webResponse.GetResponseStream() ?? Stream.Null; var contentStream = VirtualStream.Create(webResponse.ContentLength, forAsync: true); await responseStream.CopyToFastAsync(contentStream); contentStream.Position = 0; response.ReceivedStream = new ReceivedMessage( contentStream, webResponse.ContentType, webResponse.ResponseUri?.AbsolutePath ?? "unknown", webResponse.ContentLength); response.ReceivedAS4Message = await TryDeserializeReceivedStream(response.ReceivedStream, CancellationToken.None); if (Logger.IsInfoEnabled) { if (response.ReceivedAS4Message.IsEmpty == false) { LogReceivedAS4Response( requestMessage.AS4Message, response.ReceivedAS4Message); } } return(response); }
protected override async Task <CompareItemsResult> ExecuteAsync(CompareItemsMessage message) { return(await Task.Run(() => { var buildPath = Path.Combine(MessagingContext.GetBuildPath(), message.AppName, message.SessionId); var files = new List <string> (); using (var hashAlgorithm = Hash.GetAlgorithm()) { foreach (var file in message.Items) { var targetPath = Path.Combine(buildPath, PlatformPath.GetPathForCurrentPlatform(file.ItemSpec)); if (!File.Exists(targetPath)) { files.Add(file.ItemSpec); } else { using (var stream = File.OpenRead(targetPath)) { var localHash = hashAlgorithm.ComputeHashAsString(stream); if (file.Hash != localHash) { files.Add(file.ItemSpec); } } } } } return new CompareItemsResult { MissingFiles = files }; }).ConfigureAwait(continueOnCapturedContext: false)); }
/// <summary> /// Execute the step for a given <paramref name="messagingContext" />. /// </summary> /// <param name="messagingContext">Message used during the step execution.</param> /// <returns></returns> public Task <StepResult> ExecuteAsync(MessagingContext messagingContext) { if (messagingContext == null) { throw new ArgumentNullException(nameof(messagingContext)); } if (messagingContext.AS4Message == null) { throw new InvalidOperationException( $"{nameof(VerifyPullRequestAuthorizationStep)} requires a MessagingContext with a AS4Message to verify the PullRequest"); } AS4Message as4Message = messagingContext.AS4Message; var authorizationMap = new PullAuthorizationMapService(_pullAuthorizationMapProvider); if (authorizationMap.IsPullRequestAuthorized(as4Message)) { return(StepResult.SuccessAsync(messagingContext)); } string mpc = (as4Message.FirstSignalMessage as PullRequest)?.Mpc ?? string.Empty; throw new SecurityException( $"{messagingContext.LogTag} PullRequest for MPC {mpc} is not authorized. " + "Either change the PullRequest MPC or add the MPC value to the authorization map"); }
private async Task <MessagingContext> InsertReceivedAS4MessageAsync(MessagingContext messagingContext) { using (DatastoreContext context = _createDatastoreContext()) { MessageExchangePattern messageExchangePattern = messagingContext.Mode == MessagingContextMode.PullReceive ? MessageExchangePattern.Pull : MessageExchangePattern.Push; try { var service = new InMessageService(_config, new DatastoreRepository(context)); AS4Message as4Message = await service .InsertAS4MessageAsync( messagingContext.AS4Message, messagingContext.ReceivedMessage, messagingContext.SendingPMode, messageExchangePattern, _messageBodyStore) .ConfigureAwait(false); messagingContext.ModifyContext(as4Message); await context.SaveChangesAsync().ConfigureAwait(false); return(messagingContext); } catch (Exception ex) { return(new MessagingContext(ex)); } } }
public async Task Returns_With_Error_PMode_Not_Found_When_ReceivePMode_Is_Not_Defined(string id) { // Arrange var stub = new Mock <IConfig>(); stub.Setup(c => c.GetReceivingPModes()) .Returns(new[] { new ReceivingProcessingMode { Id = "existing-id" } }); var sut = new ReceiveMessageTransformer(stub.Object); sut.Configure( new Dictionary <string, string> { [ReceiveMessageTransformer.ReceivingPModeKey] = id }); var msg = new ReceivedMessage( AS4Message.Empty.ToStream(), Constants.ContentTypes.Soap); // Act MessagingContext actual = await sut.TransformAsync(msg); // Assert MessageUnit primaryMessageUnit = actual.AS4Message.MessageUnits.First(); Assert.IsType <Error>(primaryMessageUnit); var error = (Error)primaryMessageUnit; Assert.Equal( ErrorAlias.ProcessingModeMismatch, error.ErrorLines.First().ShortDescription); }
public async Task SendingPModeCorrectlyDetermined() { const string sendingPModeId = "Forward_SendingPMode_Id"; var receivingPMode = new ReceivingProcessingMode() { MessageHandling = new MessageHandling() { Item = new AS4.Model.PMode.Forward() { SendingPMode = sendingPModeId } } }; var config = new StubConfig(sendingPModes: new Dictionary <string, SendingProcessingMode>() { { sendingPModeId, new SendingProcessingMode() { Id = sendingPModeId } } }, receivingPModes: new Dictionary <string, ReceivingProcessingMode>()); var context = new MessagingContext(new ReceivedMessage(Stream.Null), MessagingContextMode.Forward) { ReceivingPMode = receivingPMode }; var sut = new DetermineRoutingStep(config); var result = await sut.ExecuteAsync(context); Assert.True(result.Succeeded); Assert.NotNull(result.MessagingContext.SendingPMode); }
/// <summary> /// Execute the step for a given <paramref name="messagingContext"/>. /// </summary> /// <param name="messagingContext">The Message used during the step execution.</param> /// <returns></returns> public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext) { if (messagingContext?.AS4Message == null) { throw new InvalidOperationException( $"{nameof(StoreAS4MessageStep)} requires an AS4Message to save but no AS4Message is present in the MessagingContext"); } Logger.Trace("Storing the AS4Message with Operation=ToBeProcessed..."); using (DatastoreContext context = _createContext()) { var repository = new DatastoreRepository(context); var service = new OutMessageService(_config, repository, _messageBodyStore); service.InsertAS4Message( messagingContext.AS4Message, messagingContext.SendingPMode, messagingContext.ReceivingPMode); try { await context.SaveChangesAsync().ConfigureAwait(false); } catch { messagingContext.ErrorResult = new ErrorResult( "Unable to store the received message due to an exception occured during the saving operation", ErrorAlias.Other); throw; } } Logger.Trace("Stored the AS4Message with Operation=ToBeProcesed"); return(await StepResult.SuccessAsync(messagingContext)); }
public async Task Adds_ReceivePMode_When_PMode_Setting_Is_Defined(string id) { // Arrange var stub = new Mock <IConfig>(); stub.Setup(c => c.GetReceivingPModes()) .Returns(new[] { new ReceivingProcessingMode { Id = "existing-id" } }); var sut = new ReceiveMessageTransformer(stub.Object); sut.Configure( new Dictionary <string, string> { [ReceiveMessageTransformer.ReceivingPModeKey] = null }); var msg = new ReceivedMessage( AS4Message.Empty.ToStream(), Constants.ContentTypes.Soap); // Act MessagingContext result = await sut.TransformAsync(msg); // Assert bool expectedNotConfiguredPMode = result.ReceivingPMode == null; bool expectedConfiguredPMode = result.ReceivingPMode?.Id == id; Assert.True(expectedNotConfiguredPMode || expectedConfiguredPMode); }
public ActionResult Index() { string user = User.Identity.GetUserName(); using (var db = new MessagingContext()) { var query = from m in db.Messages orderby m.Time where m.ToUserID == user && !m.Seen select new MessageViewModel { fromUser = m.FromUserID, MessageText = m.MessageText, Time = m.Time, Image = m.Image }; MessagesViewModel messagesVM = new MessagesViewModel(); messagesVM.Messages = query.ToList(); return(View(messagesVM)); } }
public JsonResult MessagesViewed() { string user = User.Identity.GetUserName(); using (var db = new MessagingContext()) { var updateQuery = db.Messages.Where(f => f.ToUserID == user).ToList(); updateQuery.ForEach(a => a.Seen = true); var ImageDeleteQuery = db.Messages.Where(f => f.ToUserID == user && f.Image != null).ToList(); foreach (var item in ImageDeleteQuery) { string fullPath = Request.MapPath("~/ContentUser/" + Encoding.ASCII.GetString(item.Image)); if (System.IO.File.Exists(fullPath)) { System.IO.File.Delete(fullPath); } } //db.Messages.RemoveRange(db.Messages.Where(f => f.ToUserID == user && f.Image != null)); db.SaveChanges(); return(Json(new { result = "ok" })); } }
/// <summary> /// Transform a given <see cref="ReceivedMessage"/> to a Canonical <see cref="MessagingContext"/> instance. /// </summary> /// <param name="message">Given message to transform.</param> /// <returns></returns> public async Task <MessagingContext> TransformAsync(ReceivedMessage message) { // We receive an AS4Message from Minder, we should convert it to a SubmitMessage if the action is submit. // In any other case, we should just return an MessagingContext which contains the as4Message. var transformer = new AS4MessageTransformer(); var messagingContext = await transformer.TransformAsync(message); var as4Message = messagingContext.AS4Message; if (as4Message?.FirstUserMessage?.CollaborationInfo?.Action?.Equals("Submit", StringComparison.OrdinalIgnoreCase) ?? false) { var properties = as4Message.FirstUserMessage?.MessageProperties; UserMessage transformed = TransformUserMessage(as4Message.FirstUserMessage, properties); as4Message.UpdateMessageUnit(as4Message.FirstUserMessage, transformed); messagingContext = new MessagingContext(as4Message, MessagingContextMode.Submit); AssignPModeToContext(messagingContext); return(messagingContext); } return(new MessagingContext(as4Message, MessagingContextMode.Receive)); }
private static async Task <StepResult> ExerciseCompression(MessagingContext context) { var sut = new CompressAttachmentsStep(); // Act return(await sut.ExecuteAsync(context)); }
private X509Certificate2 GetCertificate(MessagingContext messagingContext) { Decryption decryption = messagingContext.ReceivingPMode.Security.Decryption; if (decryption.DecryptCertificateInformation == null) { throw new ConfigurationErrorsException( "Cannot start decrypting: no certificate information found " + $"in ReceivingPMode {messagingContext.ReceivingPMode.Id} to decrypt the message. " + "Please use either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> to specify the certificate information"); } if (decryption.DecryptCertificateInformation is CertificateFindCriteria certFindCriteria) { return(_certificateRepository.GetCertificate( certFindCriteria.CertificateFindType, certFindCriteria.CertificateFindValue)); } if (decryption.DecryptCertificateInformation is PrivateKeyCertificate embeddedCertInfo) { return(new X509Certificate2( rawData: Convert.FromBase64String(embeddedCertInfo.Certificate), password: embeddedCertInfo.Password, keyStorageFlags: X509KeyStorageFlags.Exportable | X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet)); } throw new NotSupportedException( "The decrypt-certificate information specified in the ReceivingPMode " + $"{messagingContext.ReceivingPMode.Id} could not be used to retrieve the certificate used for decryption. " + "Please use either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> to specify the certificate information"); }
public async Task TestIfAttachmentContentTypeIsSetBackToOriginal() { // Arrange AS4Message as4Message = await GetEncryptedAS4MessageAsync(); var context = new MessagingContext(as4Message, MessagingContextMode.Receive) { ReceivingPMode = new ReceivingProcessingMode { Security = { Decryption = { Encryption = Limit.Allowed, DecryptCertificateInformation = new CertificateFindCriteria { CertificateFindType = X509FindType.FindBySerialNumber } } } } }; // Act StepResult result = await ExerciseDecryption(context); // Assert IEnumerable <Attachment> attachments = result.MessagingContext.AS4Message.Attachments; Assert.All(attachments, a => Assert.Equal("image/jpeg", a.ContentType)); }
private static async void ReceiveEntity(Entity entity, Function messageCallback, CancellationToken token) { var message = new ReceivedEntityMessage(entity); MessagingContext result = await messageCallback(message, token).ConfigureAwait(false); result?.Dispose(); }
public void CommitQueue(int userId, int nodeId, int readerId, int readerNodeId, string queueName) { using (var ctx = new MessagingContext()) { //var r = ctx.Readers.FirstOrDefault(reader => reader.UserId == userId && reader.NodeId == nodeId); var r = ctx.Readers.FirstOrDefault(reader => reader.UserId == readerId && reader.NodeId == readerNodeId); /* For now, remember messages only until the last user read them */ var q = ctx.MsgQueues.FirstOrDefault(queue => queue.Name == queueName && queue.UserId == userId && queue.NodeId == nodeId); int highestIndex = ctx.Readers.FirstOrDefault(reader => reader.UserId == readerId && reader.NodeId == readerNodeId).Position; foreach (Message m in q.Messages.FindAll(m => (m.MsgIdx > highestIndex))) { if (m.MsgIdx > highestIndex) { highestIndex = m.MsgIdx; } } r.Position = highestIndex; q.Messages.RemoveAll(m => (m.MsgIdx <= q.Readers.Min(rUser => (rUser.Position)))); ctx.SaveChanges(); } }
private async Task <StepResult> DecryptAS4MessageAsync(MessagingContext messagingContext) { try { Logger.Trace("Start decrypting AS4Message ..."); X509Certificate2 decryptionCertificate = GetCertificate(messagingContext); messagingContext.AS4Message.Decrypt(decryptionCertificate); Logger.Info($"{messagingContext.LogTag} AS4Message is decrypted correctly"); JournalLogEntry entry = JournalLogEntry.CreateFrom( messagingContext.AS4Message, $"Decrypted using certificate {decryptionCertificate.FriendlyName}"); return(await StepResult .Success(messagingContext) .WithJournalAsync(entry)); } catch (Exception ex) when(ex is CryptoException || ex is CryptographicException) { Logger.Error(ex); messagingContext.ErrorResult = new ErrorResult( description: "Decryption of message failed", alias: ErrorAlias.FailedDecryption); Logger.Error(messagingContext.ErrorResult.Description); return(StepResult.Failed(messagingContext)); } }
public async Task MessageIsCreatedWithMessageProperties() { // Arrange var pmode = CreateSendingPMode(fromParty: null, toParty: null); var submitMessage = CreateSubmitMessage(pmode, fromParty: null, toParty: null); submitMessage.MessageProperties = new [] { new AS4.Model.Common.MessageProperty("originalSender", "unregistered:C1"), new AS4.Model.Common.MessageProperty("finalRecipient", "unregistered:C2") }; var context = new MessagingContext(submitMessage) { SendingPMode = pmode }; // Act var result = await ExerciseCreation(context); var as4Message = result.MessagingContext.AS4Message; // Assert Assert.True(result.Succeeded); Assert.Equal(2, as4Message.FirstUserMessage.MessageProperties.Count()); Assert.Equal("unregistered:C1", as4Message.FirstUserMessage.MessageProperties.FirstOrDefault(p => p.Name.Equals("originalSender"))?.Value); Assert.Equal("unregistered:C2", as4Message.FirstUserMessage.MessageProperties.FirstOrDefault(p => p.Name.Equals("finalRecipient"))?.Value); }
protected MessagingContext CreateEncryptedAS4Message() { Stream attachmentStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, encrypt me")); var attachment = new Attachment("attachment-id", attachmentStream, "text/plain"); AS4Message as4Message = AS4Message.Empty; as4Message.AddMessageUnit(new UserMessage($"user-{Guid.NewGuid()}")); as4Message.AddAttachment(attachment); var message = new MessagingContext(as4Message, MessagingContextMode.Unknown) { SendingPMode = new SendingProcessingMode() }; message.SendingPMode.Security.Encryption.IsEnabled = true; message.SendingPMode.Security.Encryption.Algorithm = "http://www.w3.org/2009/xmlenc11#aes128-gcm"; message.SendingPMode.Security.Encryption.CertificateType = PublicKeyCertificateChoiceType.CertificateFindCriteria; message.SendingPMode.Security.Encryption.EncryptionCertificateInformation = new CertificateFindCriteria() { CertificateFindType = X509FindType.FindBySerialNumber, CertificateFindValue = "some dummy value" }; return(message); }
public async Task CanCreateMessageWithPModeWithoutFromParty() { // Arrange var receivingParty = CreatePModeParty("receiver", "c3", "eu.edelivery.services"); var pmode = CreateSendingPMode(fromParty: null, toParty: receivingParty); var fromParty = CreateSubmitMessageParty("sender", "type", "c2"); var submitMessage = CreateSubmitMessage(pmode, fromParty: fromParty, toParty: null); var context = new MessagingContext(submitMessage) { SendingPMode = pmode }; // Act StepResult result = await ExerciseCreation(context); // Assert Assert.True(result.Succeeded); var as4Message = result.MessagingContext.AS4Message; Assert.False(as4Message.IsEmpty); Assert.True(as4Message.IsUserMessage); Assert.Equal(fromParty.Role, as4Message.FirstUserMessage.Sender.Role); Assert.Equal(fromParty.PartyIds.First().Id, as4Message.FirstUserMessage.Sender.PartyIds.First().Id); Assert.Equal(fromParty.PartyIds.First().Type, as4Message.FirstUserMessage.Sender.PartyIds.First().Type.UnsafeGet); }
private async Task <AS4Message> ExerciseCreateError(MessagingContext ctx) { var sut = new CreateAS4ErrorStep(GetDataStoreContext); StepResult result = await sut.ExecuteAsync(ctx); return(result.MessagingContext.AS4Message); }
private async Task UpdateRetryStatusForMessageAsync(MessagingContext ctx, SendResult result) { if (ctx.MessageEntityId.HasValue) { using (DatastoreContext db = _createDatastore()) { var repository = new DatastoreRepository(db); var service = new MarkForRetryService(repository); service.UpdateAS4MessageForSendResult( messageId: ctx.MessageEntityId.Value, status: result); await db.SaveChangesAsync() .ConfigureAwait(false); } } if (ctx.AS4Message?.IsPullRequest == true) { using (DatastoreContext db = _createDatastore()) { var service = new PiggyBackingService(db); service.ResetSignalMessagesToBePiggyBacked(ctx.AS4Message.SignalMessages, result); await db.SaveChangesAsync() .ConfigureAwait(false); } } }
public async Task Fails_To_Store_SignalMessage_When_ReplyPattern_Response_For_Pulled_UserMessage() { // Arrange string userMessageId = $"user-{Guid.NewGuid()}"; GetDataStoreContext.InsertInMessage( new InMessage(userMessageId) { MEP = MessageExchangePattern.Pull }); var receipt = new Receipt($"receipt-{Guid.NewGuid()}", userMessageId); var context = new MessagingContext( AS4Message.Create(receipt), MessagingContextMode.Receive) { SendingPMode = new SendingProcessingMode { Id = "shortcut-send-pmode-retrieval" }, ReceivingPMode = new ReceivingProcessingMode { ReplyHandling = { ReplyPattern = ReplyPattern.Response } } }; // Act / Assert await Assert.ThrowsAsync <InvalidOperationException>( () => ExerciseStoreSignalMessageAsync(context)); }
protected override async Task <GetItemResult> ExecuteAsync(GetItemMessage message) { return(await Task.Run <GetItemResult> (() => { var targetPath = Path.GetFullPath(Path.Combine( MessagingContext.GetBuildPath(), message.AppName, message.SessionId, PlatformPath.GetPathForCurrentPlatform(message.ItemSpec))); var result = new GetItemResult(); if (File.Exists(targetPath)) { result.FileExists = true; // Avoiding sending the payload if the file is too large based on the defined limit by the the client if (new System.IO.FileInfo(targetPath).Length > message.LimitLength) { result.FileLengthExceedsLimit = true; } else { result.Content = File.ReadAllBytes(targetPath); } } return result; }).ConfigureAwait(continueOnCapturedContext: false)); }
public async Task ThenAgreementRefIsNotEnoughAsync(string name, string type) { // Arrange var agreementRef = new AS4.Model.PMode.AgreementReference { Value = name, Type = type, PModeId = "pmode-id" }; ArrangePModeThenAgreementRefIsNotEnough(agreementRef); var userMessage = new UserMessage( Guid.NewGuid().ToString(), new AS4.Model.Core.CollaborationInfo( agreement: new AgreementReference(name, type, "pmode-id"), service: new Service("service"), action: "action", conversationId: "1")); var messagingContext = new MessagingContext(AS4Message.Create(userMessage), MessagingContextMode.Receive); // Act StepResult result = await _step.ExecuteAsync(messagingContext); // Assert Assert.False(result.Succeeded); ErrorResult errorResult = result.MessagingContext.ErrorResult; Assert.Equal(ErrorCode.Ebms0010, errorResult.Code); }
private static async Task <StepResult> ExecuteSteps( IEnumerable <IStep> steps, MessagingContext context) { StepResult result = StepResult.Success(context); var currentContext = context; foreach (IStep step in steps) { result = await step.ExecuteAsync(currentContext).ConfigureAwait(false); if (result.CanProceed == false || result.Succeeded == false || result.MessagingContext?.Exception != null) { return(result); } if (result.MessagingContext != null && currentContext != result.MessagingContext) { currentContext = result.MessagingContext; } } return(result); }
private static async Task <StepResult> ExerciseEncryption(MessagingContext message) { var sut = new EncryptAS4MessageStep(CreateStubCertificateRepository().Object); // Act return(await sut.ExecuteAsync(message)); }
/* This thread ensures that messages aggregated from various partners are added to the queue in the correct order */ public void HandleQueueBuffer() { /* Iterate over all the queues and look for messages that expired their indexing period and should enter the queue */ using (var ctx = new MessagingContext()) { foreach (var q in ctx.MsgQueues) { var messages = ctx.QueueBuffer.Where(m => (m.QueueId == q.Id)); var messageList = new List <QueueBuffer>(); foreach (var m in messages) { if (DateTime.UtcNow.Ticks + Config <long> .GetInstance()["TIMEZONE_CORRECTION"] > m.Timestamp + Config <int> .GetInstance()["QUEUE_GRACE_PERIOD"]) { /* Add this message to the queue. We assume that by now all slaves have synced */ messageList.Add(m); } } /* Sort by time of arrival */ messageList.Sort((a, b) => ((int)(a.Timestamp - b.Timestamp))); foreach (var m in messageList) { WriteQueue(ctx, m.UserId, m.NodeId, m.QueueId, m.Data, m.Timestamp); ctx.QueueBuffer.Remove(m); /* Important to save here for consistancy */ ctx.SaveChanges(); } } } }
public async Task Takes_Sending_PMode_Into_Account_When_Verifies_Non_Multihop_Signal() { // Arrange var as4Msg = AS4Message.Create(new Receipt($"receipt-{Guid.NewGuid()}", $"reftoid-{Guid.NewGuid()}")); as4Msg.AddMessageUnit(new UserMessage(messageId: $"user-{Guid.NewGuid()}")); var ctx = new MessagingContext(as4Msg, MessagingContextMode.Receive) { ReceivingPMode = new ReceivingProcessingMode { Security = { SigningVerification = { Signature = Limit.Required } } }, SendingPMode = new SendingProcessingMode { Security = { SigningVerification = { Signature = Limit.Ignored } } } }; // Act StepResult result = await ExerciseVerify(ctx); // Assert Assert.True(result.CanProceed); }
public static void CleanupTestTrack() { int deleteResult = -1; MessagingContext context = null; #region Clean database of records added during test try { using (context = new MessagingContext(connectionStringName)) { MessagePing recordToDelete = context.FindOne(new object[] { recordId }); bool recordIsNotAvailable = null != recordToDelete; if (recordIsNotAvailable) { context.Remove(recordToDelete); deleteResult = context.SaveChanges(); } } } catch { } finally { if (null != context) { context.Dispose(); } } #endregion }
public void ConnectToDatabase() { using (var context = new MessagingContext(connectionStringName)) { Assert.IsNotNull(context, "Context could not be instantiated."); Assert.IsNotNull(context.Database, "Context is instantiated, but Database reference is not set."); Assert.IsNotNull(context.Database.Connection, "Active connection refernece could not be obtained"); try { context.Database.Connection.Open(); Assert.IsTrue(context.Database.Connection.State == ConnectionState.Open, "Connection is not in open state, Current state - " + context.Database.Connection.State.ToString()); } catch { } finally { context.Database.Connection.Close(); } Assert.IsTrue(context.Database.Connection.State == ConnectionState.Closed, "Connection is successfully closed, Current state - " + context.Database.Connection.State.ToString()); } }
private MessagePing SeedRecord() { MessagePing testSubject = new MessagePing(); MessagePing operationResult = null; testSubject.Id = recordId; testSubject.Source = "+919840200524"; testSubject.Destination = "+918903442090"; testSubject.Message = "Hello!!"; testSubject.MessageSentUTC = DateTime.UtcNow; using (var context = new MessagingContext(connectionStringName)) { operationResult = context.Add(testSubject); } return operationResult; }
private MessagePing AssertRecordExistence(Guid recordId, MessagingContext context) { MessagePing testSubject; testSubject = context.FindOne(new object[] { recordId }); try { Assert.IsNotNull(testSubject, "Record not found in database"); } catch { testSubject = SeedRecord(); } return testSubject; }
public void SearchMessageInDatabase() { #region Test Setup List<MessagePing> testSubjects; string source = "+919840200524"; #endregion #region Test using (var context = new MessagingContext(connectionStringName)) { var checkRecordExistence = AssertRecordExistence(recordId, context); testSubjects = context.Where(d => d.Source == source).ToList<MessagePing>(); Assert.IsNotNull(testSubjects, "Record not found in database"); CollectionAssert.Contains(testSubjects, checkRecordExistence, "Record found in the database did not match record id"); } #endregion }
public void GetMessageRecordFromDatabase() { #region Test Setup MessagePing testSubject; #endregion #region Test using (var context = new MessagingContext(connectionStringName)) { var checkRecordExistence = AssertRecordExistence(recordId, context); testSubject = context.FindOne(new object[] { recordId }); Assert.IsNotNull(testSubject, "Record not found in database"); Assert.IsTrue(recordId == testSubject.Id, "Record found in the database did not match record id"); } #endregion }
public void UpdateRecordToDatabase() { #region Test Setup MessagePing testSubject; #endregion #region Test using (var context = new MessagingContext(connectionStringName)) { try { testSubject = AssertRecordExistence(recordId, context); } catch (AssertFailedException) { AddRecordsToDatabase(); testSubject = AssertRecordExistence(recordId, context); } testSubject.Message = updatedMessage; context.SaveChanges(); } testSubject = null; using (var context = new MessagingContext(connectionStringName)) { testSubject = context.FindOne(new object[] { recordId }); Assert.IsNotNull(testSubject, "Record not found in database"); Assert.IsTrue(updatedMessage == testSubject.Message, "Record was not updated"); } #endregion }
internal WorkerProcess(DbContext storageInstance, IMembershipService membershipInstance, IProfileService profileInstance) { this.Storage = storageInstance as MessagingContext; MembershipService = membershipInstance; ProfileService = profileInstance; }