public void SetUp()
{
this.Utility = new Utility();
this.Parser = new ClaimsTransformationParser();
this.Cache = new ClaimsTransformationCache();
this.ClaimFactory = new ClaimFactory();
this.Engine = new ClaimsTransformationEngine(this.Parser, this.Cache, this.ClaimFactory);
}
public void RedeemHttpClaimToken()
{
using (var tokenStream = ClaimFactory.CreateCheck("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
Invoking(() => ClaimStore.Instance.Redeem(MessageMock.Object, ResourceTrackerMock.Object))
.Should().Throw <WebException>();
}
}
public void RedeemClaimTokenThrowsWhenUnexpectedToken()
{
using (var tokenStream = ClaimFactory.CreateCheckIn("d59cd2ea045744f4a085b18be678e4f0").AsStream())
{
MessageMock.Object.BodyPart.Data = tokenStream;
Invoking(() => ClaimStore.Instance.Redeem(MessageMock.Object, ResourceTrackerMock.Object))
.Should().Throw <InvalidOperationException>()
.WithMessage("Invalid token message, CheckIn token is not expected to be redeemed.");
}
}
public void CreateClaimExecute_NewPolicyId_InsertedClaimHasSameStatus()
{
// Arrange
var interactor = CreateClaimInteractorFactory.Create();
var newClaim = ClaimFactory.Create();
// Run
var result = interactor.Execute(newClaim.PolicyId, newClaim.StatusId);
// Assert
result.StatusId.ShouldBe(newClaim.StatusId);
}
public void UpdateStatus_NewClaimIdAndStatusId_UpdatedClaimHasNewStatusId()
{
// Arrange
var interactor = UpdateClaimInteractorFactory.Create();
ClaimEntity claimToUpdate = ClaimFactory.Create();
StatusEntity newStatus = StatusFactory.Create("Closed");
// Run
var result = interactor.UpdateStatus(claimToUpdate, newStatus);
// Assert
result.StatusId.ShouldBe(newStatus.Id);
}
public void AsMessageBodyCaptureDescriptor()
{
const string expected = "claim";
var originalStream = ClaimFactory.CreateCheckOut(expected).AsStream();
var part = new Mock <IBaseMessagePart>();
part.Setup(p => p.GetOriginalDataStream())
.Returns(originalStream);
var descriptor = part.Object.AsMessageBodyCaptureDescriptor();
descriptor.Data.Should().Be(expected);
}
public void ClaimMessageBody()
{
using (var configurationReaderMockInjectionScope = new SsoConfigurationReaderMockInjectionScope())
{
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckInDirectory)))
.Returns(Path.GetTempPath());
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckOutDirectory)))
.Returns(@"\\server\share");
using (var contentStream = TextStreamDummy.Create(1024 * 1024))
using (var trackingStream = new TrackingStream(contentStream))
{
MessageMock.Object.BodyPart.Data = trackingStream;
ClaimStore.Instance.SetupMessageBodyCapture(trackingStream, ActivityTrackingModes.Claim, null);
ClaimStore.Instance.Claim(MessageMock.Object, ResourceTrackerMock.Object);
// message's actual body stream has been exhausted (i.e. saved to disk)
contentStream.Position.Should().Be(contentStream.Length);
// message's body stream is replaced by a token message
using (var reader = new StreamReader(MessageMock.Object.BodyPart.Data))
{
reader.ReadToEnd().Should().Be(ClaimFactory.CreateCheckIn(trackingStream.CaptureDescriptor.Data).OuterXml);
}
// MessageType of token message is promoted in message context
var schemaMetadata = SchemaMetadata.For <Claim.CheckIn>();
MessageMock.Verify(m => m.Promote(BtsProperties.MessageType, schemaMetadata.MessageType), Times.Once());
MessageMock.Verify(m => m.Promote(BtsProperties.SchemaStrongName, schemaMetadata.DocumentSpec.DocSpecStrongName), Times.Once());
// payload is claimed to disk and file extension is .chk
var captureDescriptor = trackingStream.CaptureDescriptor;
captureDescriptor.CaptureMode.Should().Be(MessageBodyCaptureMode.Claimed);
captureDescriptor.Data.Should().StartWith(DateTime.Today.ToString(@"yyyyMMdd\\"));
File.Exists(Path.Combine(Path.GetTempPath(), captureDescriptor.Data.Replace("\\", "") + ".chk")).Should().BeTrue();
}
}
}
public void RedeemClaimToken()
{
const string content = "dummy";
const string url = "cca95baa39ab4e25a3c54971ea170911";
using (var file = File.CreateText(Path.Combine(Path.GetTempPath(), url)))
{
file.Write(content);
}
using (var configurationReaderMockInjectionScope = new SsoConfigurationReaderMockInjectionScope())
{
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckInDirectory)))
.Returns(Path.GetTempPath());
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckOutDirectory)))
.Returns(Path.GetTempPath());
using (var tokenStream = ClaimFactory.CreateCheck(url).AsStream())
{
MessageMock.Object.BodyPart.Data = tokenStream;
ClaimStore.Instance.Redeem(MessageMock.Object, ResourceTrackerMock.Object);
MessageMock.Object.BodyPart.Data.Should().BeOfType <TrackingStream>();
var captureDescriptor = ((TrackingStream)MessageMock.Object.BodyPart.Data).CaptureDescriptor;
captureDescriptor.CaptureMode.Should().Be(MessageBodyCaptureMode.Claimed);
// previously captured payload is reused and not captured/claimed anew
captureDescriptor.Data.Should().Be(url);
}
using (var reader = new StreamReader(MessageMock.Object.BodyPart.Data))
{
reader.ReadToEnd().Should().Be(content);
}
}
}
// Creates a Claim from a TClaim object (duck typing).
//
// The TClaim must have the following shape:
// class TClaim {
// string ClaimType { get; } // or just 'Type'
// string Value { get; }
// }
internal static Claim Create <TClaim>(TClaim claim)
{
return(ClaimFactory <TClaim> .Create(claim));
}
// Creates a Claim from a TClaim object (duck typing).
//
// The TClaim must have the following shape:
// class TClaim {
// string ClaimType { get; } // or just 'Type'
// string Value { get; }
// }
internal static Claim Create <TClaim>(TClaim claim) =>
ClaimFactory <TClaim> .Create(claim);
public static Task AddClaimAsync(this UserManager <IdentityUser, int> userManager, int userId, Enum claimType, Enum value)
{
return(userManager.AddClaimAsync(userId, ClaimFactory.Create(claimType, value)));
}
