public void RedeemHttpClaimToken()
 {
     using (var tokenStream = MessageFactory.CreateClaimCheck("http://nothing/that/exists.xml").AsStream())
     {
         MessageMock.Object.BodyPart.Data = tokenStream;
         // fails, and still, shows that resources can be redeemed from somewhere else than the claim store
         Assert.That(
             () => ClaimStore.Instance.Redeem(MessageMock.Object, ResourceTrackerMock.Object),
             Throws.TypeOf <WebException>());
     }
 }
Exemple #2
0
        /// <summary>
        /// Replace the message body's payload stream with either a <see cref="Schemas.Xml.Claim.Check"/> or a <see
        /// cref="Schemas.Xml.Claim.CheckIn"/> token message if its content has been assessed to be saved to disk while
        /// being tracked (see <see cref="SetupMessageBodyCapture"/>). Leave the message body's payload stream unaltered
        /// otherwise.
        /// </summary>
        /// <param name="message">
        /// The <see cref="IBaseMessage"/> whose message body's payload stream is going to be claimed and replace by a
        /// token message.
        /// </param>
        /// <param name="resourceTracker">
        /// Pipeline's <see cref="IResourceTracker"/> to which to report the newly created message token stream.
        /// </param>
        /// <remarks>
        /// The <see cref="IBaseMessage"/>'s <see cref="IBaseMessageContext"/> is also updated with the message type of
        /// the token message that is put in place of the actual message body's payload.
        /// </remarks>
        public virtual void Claim(IBaseMessage message, IResourceTracker resourceTracker)
        {
            var trackingStream = message.BodyPart.GetOriginalDataStream() as TrackingStream;

            if (trackingStream == null)
            {
                if (_logger.IsDebugEnabled)
                {
                    _logger.Debug("Skipping claim of message body stream's payload; BodyPart's OriginalDataStream is not a TrackingStream.");
                }
            }
            else if (trackingStream.CaptureDescriptor.CaptureMode != MessageBodyCaptureMode.Claimed)
            {
                if (_logger.IsDebugEnabled)
                {
                    _logger.Debug("Skipping claim of message body stream's payload; CaptureDescriptor.CaptureMode is not MessageBodyCaptureMode.Claimed.");
                }
            }
            else
            {
                if (_logger.IsDebugEnabled)
                {
                    _logger.DebugFormat("Performing claim of message body stream's payload '{0}'.", trackingStream.CaptureDescriptor.Data);
                }
                var          claimedMessageType = message.GetProperty(BtsProperties.MessageType);
                DocumentSpec documentSpec;
                Stream       tokenMessageStream;
                if (RequiresCheckInAndOut)
                {
                    documentSpec       = typeof(Claim.CheckIn).GetMetadata().DocumentSpec;
                    tokenMessageStream = MessageFactory.CreateClaimCheckIn(claimedMessageType, trackingStream.CaptureDescriptor.Data).AsStream();
                }
                else
                {
                    documentSpec       = typeof(Claim.Check).GetMetadata().DocumentSpec;
                    tokenMessageStream = MessageFactory.CreateClaimCheck(claimedMessageType, trackingStream.CaptureDescriptor.Data).AsStream();
                }

                // fix the message type before capturing the body stream so that it get captured while tracking MessagingStep
                message.Promote(BtsProperties.MessageType, documentSpec.DocType);
                message.Promote(BtsProperties.SchemaStrongName, documentSpec.DocSpecStrongName);

                // drain and capture body stream
                trackingStream.Capture();

                // replace message body's payload with the token message stream
                message.BodyPart.SetDataStream(tokenMessageStream, resourceTracker);
            }
        }
        public void RedeemClaimToken()
        {
            const string content = "dummy";
            const string url     = "cca95baa39ab4e25a3c54971ea170911";

            using (var file = File.CreateText(Path.Combine(Path.GetTempPath(), url)))
            {
                file.Write(content);
            }

            SsoSettingsReaderMock
            .Setup(ssr => ssr.ReadString(BizTalkFactorySettings.APPLICATION_NAME, BizTalkFactorySettings.CLAIM_STORE_CHECK_IN_DIRECTORY_PROPERTY_NAME))
            .Returns(Path.GetTempPath());
            SsoSettingsReaderMock
            .Setup(ssr => ssr.ReadString(BizTalkFactorySettings.APPLICATION_NAME, BizTalkFactorySettings.CLAIM_STORE_CHECK_OUT_DIRECTORY_PROPERTY_NAME))
            .Returns(Path.GetTempPath());

            using (var tokenStream = MessageFactory.CreateClaimCheck(url).AsStream())
            {
                MessageMock.Object.BodyPart.Data = tokenStream;

                ClaimStore.Instance.Redeem(MessageMock.Object, ResourceTrackerMock.Object);

                Assert.That(MessageMock.Object.BodyPart.Data, Is.TypeOf <TrackingStream>());
                // ReSharper disable once PossibleInvalidCastException
                var captureDescriptor = ((TrackingStream)MessageMock.Object.BodyPart.Data).CaptureDescriptor;
                Assert.That(captureDescriptor.CaptureMode, Is.EqualTo(MessageBodyCaptureMode.Claimed));
                // previously captured payload is reused and not captured/claimed anew
                Assert.That(captureDescriptor.Data, Is.EqualTo(url));
            }

            using (var reader = new StreamReader(MessageMock.Object.BodyPart.Data))
            {
                Assert.That(reader.ReadToEnd(), Is.EqualTo(content));
            }
        }