public UnaryNotAssertion(IAssertion operand)
{
if (operand == null)
throw new ArgumentNullException("operand");
_operand = operand;
}
protected CompositeAssertion(IAssertion[] assertions)
{
if (assertions == null)
throw new ArgumentNullException("assertions");
foreach (IAssertion assertion in assertions)
{
if (assertion == null)
throw new ArgumentException(null, "assertions");
}
InnerList.AddRange(assertions);
}
public static string AssertionToString(IAssertion assertion)
{
string assertionDisplay = "NULL";
if (assertion != null) {
assertionDisplay = string.Format(
"ValidFromDate>{0}< " +
"ValidUntilDate>{1}< " +
"PrincipalName>{2}< " +
"Attributes Count>{3}<",
assertion.ValidFromDate, assertion.ValidUntilDate,
assertion.PrincipalName, assertion.Attributes.Count);
}
return assertionDisplay;
}
/// <summary>
/// Initializes the module and prepares it to handle requests.
/// </summary>
public virtual void Init(HttpApplication application)
{
if (application == null)
throw new ArgumentNullException("application");
var config = (ErrorFilterConfiguration) Configuration.GetSubsection("errorFilter");
if (config == null)
return;
_assertion = config.Assertion;
foreach (var module in HttpModuleRegistry.GetModules(application))
{
var filtering = module as IExceptionFiltering;
if (filtering != null)
filtering.Filtering += OnErrorModuleFiltering;
}
}
public static void Inconclusive(this IAssertion assertion, System.String message, System.Object[] parameters)
{
Assert.Inconclusive(message, parameters);
}
public static void Fail(this IAssertion assertion, System.String message, System.Object[] parameters)
{
Assert.Fail(message, parameters);
}
/// <summary>
/// Constructs a new Principal backed by the supplied Assertion, with
/// proxying capabilities.
/// </summary>
/// <param name="assertion">
/// the Assertion that backs this Principal
/// </param>
/// <param name="proxyGrantingTicket">
/// the proxy granting ticket associated with this Principal.
/// </param>
/// <param name="proxies">
/// The proxy path associated with this Principal
/// </param>
public CasPrincipal(IAssertion assertion, string proxyGrantingTicket, IEnumerable<string> proxies) {
Argument.ThrowIfNull(assertion, "assertion", "assertion cannot be null.");
Identity = new GenericIdentity(assertion.PrincipalName, CAS_AUTH_TYPE);
Assertion = assertion;
ProxyGrantingTicket = proxyGrantingTicket;
Proxies = proxies ?? Enumerable.Empty<string>();
}
internal void SetAssertion(IAssertion assertion)
{
_assertion = assertion != null ? assertion : StaticAssertion.False;
}
public virtual int IndexOf(IAssertion assertion)
{
return InnerList.IndexOf(assertion);
}
public virtual int IndexOf(IAssertion assertion)
{
return(InnerList.IndexOf(assertion));
}
public static Exception ThrowsAsync(this IAssertion assertion, Task task, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits)
{
return(ThrowsAsync <Exception>(task, null, ExceptionMessageCompareOptions.None, inheritOptions));
}
/// <summary>
/// Add assertion to the list
/// </summary>
/// <param name="assertion"></param>
public bool Remove(IAssertion assertion)
{
return(_assertionsByName.Remove(assertion.Name));
}
public virtual bool Contains(IAssertion assertion)
{
return(InnerList.Contains(assertion));
}
/// <summary>
/// Add assertion to the list
/// </summary>
/// <param name="assertion"></param>
public void Add(IAssertion assertion)
{
_assertionsByName.Add(assertion.Name, assertion);
}
private static Exception IsTrueForAnyActHelper(IAssertion<IEnumerable<bool>> values)
{
return CollectionActHelper(values, CollectionExtensions.IsTrueForAny(values, v => v));
}
private static Exception CollectionActHelper(IAssertion<IEnumerable<bool>> values, IVerifiable<IEnumerable<bool>> action)
{
Exception x = null;
try
{
action.Now();
}
catch (Exception e)
{
x = e;
}
return x;
}
public static void Inconclusive(this IAssertion assertion, System.String message)
{
Assert.Inconclusive(message);
}
/// <summary>
/// Constructs a new Principal backed by the supplied Assertion, with proxying cabilities.
/// </summary>
/// <param name="assertion">the Assertion that backs this Principal</param>
/// <param name="proxyGrantingTicket">
/// the proxy granting ticket associated with this Principal.
/// </param>
/// <param name="proxyRetriever">
/// the ProxyRetriever to call back to the CAS server.
/// </param>
public CasPrincipal(IAssertion assertion,
string proxyGrantingTicket,
IProxyRetriever proxyRetriever)
{
CommonUtils.AssertNotNull(assertion, "assertion cannot be null.");
this.Identity = new GenericIdentity(assertion.PrincipalName,
CommonUtils.CAS_AUTH_TYPE);
this.Assertion = assertion;
this.proxyGrantingTicket = proxyGrantingTicket;
this.proxyRetriever = proxyRetriever;
}
public static string AssertionToString(IAssertion assertion, string newLineDelim,
string initialLineIndent,
int initialLineIndentCount,
string dataDelim,
bool useDelimAlways)
{
StringBuilder sb = new StringBuilder();
string lineIndent = GenerateLineIndent(initialLineIndent, initialLineIndentCount);
sb.Append(string.Format("{0}Assertion:{1}", lineIndent, newLineDelim));
int memberLineIndentCount = initialLineIndentCount + 2;
string memberLineIndent = GenerateLineIndent(initialLineIndent, memberLineIndentCount);
if (assertion == null) {
sb.Append(string.Format("{0}UNDEFINED{1}", memberLineIndent, newLineDelim));
} else {
sb.Append(string.Format("{0}ValidFromDate: {1}{2}", memberLineIndent,
DataNullEmptyDisplay(assertion.ValidFromDate.ToString(), dataDelim, useDelimAlways),
newLineDelim));
sb.Append(string.Format("{0}ValidUntilDate: {1}{2}", memberLineIndent,
DataNullEmptyDisplay(assertion.ValidUntilDate.ToString(), dataDelim, useDelimAlways),
newLineDelim));
sb.Append(string.Format("{0}PrincipalName: {1}{2}", memberLineIndent,
DataNullEmptyDisplay(assertion.PrincipalName, dataDelim, useDelimAlways), newLineDelim));
sb.Append(AttributesToString(assertion.Attributes, newLineDelim, initialLineIndent,
memberLineIndentCount, dataDelim, useDelimAlways));
}
return sb.ToString();
}
public static IAssertionResult <T, TSource> Assert <T, TSource>(this IValueProvider <T, TSource> valueProvider, IAssertion <T> assertion, IAssertionConfiguration configuration)
{
return(Wait.Assertion(valueProvider, new AssertionConfiguration <T>
{
Timeout = configuration.Timeout,
Interval = configuration.Interval,
ExceptionMatcher = configuration.ExceptionMatcher,
Assertion = assertion
}));
}
public static T ThrowsAsync <T>(this IAssertion assertion, Task task, string expectedMessage, ExceptionMessageCompareOptions options, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits) where T : Exception
{
return(ThrowsAsync <T>(task, expectedMessage, options, inheritOptions));
}
/// <summary>
/// Add assertion to the list
/// </summary>
/// <param name="assertion"></param>
public bool Remove(IAssertion assertion)
{
return _assertionsByName.Remove(assertion.Name);
}
/// <summary>
/// Public CasAuthenticationTicket constructor
/// </summary>
/// <param name="serviceTicket">CAS Service Ticket associated with this CasAuthenticationTicket</param>
/// <param name="originatingServiceName">ServiceName used during CAS authentication/validation</param>
/// <param name="clientHostAddress">IP address of the client initiating the authentication request</param>
/// <param name="assertion">CAS assertion returned from the CAS server during ticket validation</param>
public CasAuthenticationTicket(string serviceTicket, string originatingServiceName, string clientHostAddress, IAssertion assertion)
{
CasAuthentication.Initialize();
Proxies = new List<string>();
NetId = assertion.PrincipalName;
ServiceTicket = serviceTicket;
OriginatingServiceName = originatingServiceName;
ClientHostAddress = clientHostAddress;
Assertion = assertion;
if (DateTime.MinValue.CompareTo(assertion.ValidFromDate) != 0)
{
ValidFromDate = assertion.ValidFromDate;
}
else
{
ValidFromDate = DateTime.Now;
}
DateTime localValidUntil = ValidFromDate.Add(CasAuthentication.FormsTimeout);
if (DateTime.MinValue.CompareTo(assertion.ValidUntilDate) != 0)
{
ValidUntilDate = localValidUntil.CompareTo(assertion.ValidUntilDate) < 0 ? localValidUntil : assertion.ValidUntilDate;
}
else
{
ValidUntilDate = localValidUntil;
}
}
/// <summary>
/// Add assertion to the list
/// </summary>
/// <param name="assertion"></param>
public void Add(IAssertion assertion)
{
_assertionsByName.Add(assertion.Name, assertion);
}
public static LogicalAssertion LogicalNot(IAssertion[] operands)
{
return new LogicalAssertion(operands, true, true);
}
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.Globalization.CultureInfo culture)
{
Assert.AreNotEqual(notExpected, actual, ignoreCase, culture);
}
public orAssertion(IAssertion one, IAssertion other)
{
this.one = one;
this.other = other;
}
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.Globalization.CultureInfo culture, System.String message, System.Object[] parameters)
{
Assert.AreNotEqual(notExpected, actual, ignoreCase, culture, message, parameters);
}
public static void Fail(this IAssertion assertion)
{
Assert.Fail();
}
public static void AreNotEqual(this IAssertion assertion, System.Double notExpected, System.Double actual, System.Double delta)
{
Assert.AreNotEqual(notExpected, actual, delta);
}
public static void Fail(this IAssertion assertion, System.String message)
{
Assert.Fail(message);
}
public static void AreEqual <T>(this IAssertion assertion, T expected, T actual)
{
Assert.AreEqual(expected, actual);
}
public static void AreEqual(this IAssertion assertion, System.String expected, System.String actual, System.Boolean ignoreCase)
{
Assert.AreEqual(expected, actual, ignoreCase);
}
/// <summary>
/// Constructs a new Principal backed by the supplied Assertion.
/// </summary>
/// <param name="assertion">
/// the Assertion that backs this Principal
/// </param>
public CasPrincipal(IAssertion assertion) : this(assertion, null, null) { }
public static void Inconclusive(this IAssertion assertion)
{
Assert.Inconclusive();
}
/// <summary>
/// Constructs a new Principal backed by the supplied Assertion, with
/// proxying capabilities.
/// </summary>
/// <param name="assertion">
/// the Assertion that backs this Principal
/// </param>
/// <param name="proxyGrantingTicket">
/// the proxy granting ticket associated with this Principal.
/// </param>
/// <param name="proxies">
/// The proxy path associated with this Principal
/// </param>
public CasPrincipal(IAssertion assertion, string proxyGrantingTicket, IEnumerable<string> proxies)
{
CommonUtils.AssertNotNull(assertion, "assertion cannot be null.");
Identity = new GenericIdentity(assertion.PrincipalName, CasClientConfiguration.Config.AuthenticationType);
Assertion = assertion;
ProxyGrantingTicket = proxyGrantingTicket;
if (proxies != null)
{
Proxies = proxies;
}
else
{
Proxies = new List<string>();
}
}
public static void AreNotEqual(this IAssertion assertion, System.Single notExpected, System.Single actual, System.Single delta, System.String message, System.Object[] parameters)
{
Assert.AreNotEqual(notExpected, actual, delta, message, parameters);
}
public static Exception ThrowsAsync(this IAssertion assertion, Task task, string expectedMessage, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits)
{
return(ThrowsAsync <Exception>(task, expectedMessage, ExceptionMessageCompareOptions.Exact, inheritOptions));
}
/// <summary>
/// Constructs a new Principal backed by the supplied Assertion, with
/// proxying capabilities.
/// </summary>
/// <param name="assertion">
/// the Assertion that backs this Principal
/// </param>
/// <param name="proxyGrantingTicket">
/// the proxy granting ticket associated with this Principal.
/// </param>
public CasPrincipal(IAssertion assertion, string proxyGrantingTicket) : this(assertion, proxyGrantingTicket, null) { }
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.String message)
{
Assert.AreNotEqual(notExpected, actual, ignoreCase, message);
}
public AndAssertion(Assertion one, Assertion other)
{
this.one = one;
this.other = other;
}
public static void AreNotEqual <T>(this IAssertion assertion, T notExpected, T actual)
{
Assert.AreNotEqual(notExpected, actual);
}
public virtual bool Contains(IAssertion assertion)
{
return InnerList.Contains(assertion);
}
public static void AreNotEqual <T>(this IAssertion assertion, T notExpected, T actual, System.String message, System.Object[] parameters)
{
Assert.AreNotEqual(notExpected, actual, message, parameters);
}
//public NotAssertion(IAssertion assertion) : base(assertion.Candidate, assertion.Message)
public NotAssertion(IAssertion assertion)
: base(assertion.Specification, assertion.Message)
{
wrapped = assertion;
}
public static void AreNotSame(this IAssertion assertion, System.Object notExpected, System.Object actual, System.String message)
{
Assert.AreNotSame(notExpected, actual, message);
}
public static IAssertion[] Create(XmlNodeList nodes)
{
if (nodes == null)
throw new ArgumentNullException("nodes");
//
// First count the number of elements, which will be used to
// allocate the array at its correct and final size.
//
var elementCount = 0;
foreach (XmlNode child in nodes)
{
var nodeType = child.NodeType;
//
// Skip comments and whitespaces.
//
if (nodeType == XmlNodeType.Comment || nodeType == XmlNodeType.Whitespace)
continue;
//
// Otherwise all elements only.
//
if (nodeType != XmlNodeType.Element)
{
throw new ConfigurationException(
string.Format("Unexpected type of node ({0}).", nodeType.ToString()),
child);
}
elementCount++;
}
//
// In the second pass, create and configure the assertions
// from each element.
//
var assertions = new IAssertion[elementCount];
elementCount = 0;
foreach (XmlNode node in nodes)
{
if (node.NodeType == XmlNodeType.Element)
assertions[elementCount++] = Create((XmlElement) node);
}
return assertions;
}
public static void AreEqual <T>(this IAssertion assertion, T expected, T actual, System.String message)
{
Assert.AreEqual(expected, actual, message);
}
private LogicalAssertion(IAssertion[] assertions, bool not, bool all)
: base(assertions)
{
_not = not;
_all = all;
}
public static void AreNotSame(this IAssertion assertion, System.Object notExpected, System.Object actual)
{
Assert.AreNotSame(notExpected, actual);
}
public static LogicalAssertion LogicalOr(IAssertion[] operands)
{
return new LogicalAssertion(operands, false, false);
}
public static void AreSame(this IAssertion assertion, System.Object expected, System.Object actual)
{
Assert.AreSame(expected, actual);
}
public static void AreSame(this IAssertion assertion, System.Object expected, System.Object actual, System.String message, System.Object[] parameters)
{
Assert.AreSame(expected, actual, message, parameters);
}
public static void Equals(this IAssertion assertion, System.Object objA, System.Object objB)
{
Assert.Equals(objA, objB);
}
/// <summary>
/// Public CasAuthenticationTicket constructor
/// </summary>
/// <param name="serviceTicket">CAS Service Ticket associated with this CasAuthenticationTicket</param>
/// <param name="originatingServiceName">ServiceName used during CAS authentication/validation</param>
/// <param name="clientHostAddress">IP address of the client initiating the authentication request</param>
/// <param name="assertion">CAS assertion returned from the CAS server during ticket validation</param>
/// <param name="clock"></param>
public CasAuthenticationTicket(
string serviceTicket,
string originatingServiceName,
string clientHostAddress,
IAssertion assertion,
DateTime validFromDate) {
Proxies = new List<string>();
NetId = assertion.PrincipalName;
ServiceTicket = serviceTicket;
OriginatingServiceName = originatingServiceName;
ClientHostAddress = clientHostAddress;
Assertion = assertion;
if (DateTime.MinValue.CompareTo(assertion.ValidFromDate) != 0) {
ValidFromDate = assertion.ValidFromDate;
}
else {
ValidFromDate = validFromDate;
}
DateTime localValidUntil = ValidFromDate.Add(TimeSpan.FromDays(30));
if (DateTime.MinValue.CompareTo(assertion.ValidUntilDate) != 0) {
ValidUntilDate = localValidUntil.CompareTo(assertion.ValidUntilDate) < 0 ? localValidUntil : assertion.ValidUntilDate;
}
else {
ValidUntilDate = localValidUntil;
}
}
public AbstractTestBase(IAssertion assertion)
{
context = new TestHttpContext();
Assert = assertion;
}
