public void Reset()
{
ServiceLocator.Reset();
ExceptionFactory.Reset();
SecurityDoctor.Reset();
SecurityCache.ClearCache(Lifecycle.HybridHttpContext);
SecurityCache.ClearCache(Lifecycle.HybridHttpSession);
}
[OneTimeSetUp] //[SetUp]
public void Reset()
{
ServiceLocator.Reset();
ExceptionFactory.Reset();
SecurityDoctor.Reset();
SecurityRuntime.HttpContextAccessor = new Mock <IHttpContextAccessor>().Object;
SecurityCache.ClearCache(Lifecycle.HybridHttpContext);
SecurityCache.ClearCache(Lifecycle.HybridHttpSession);
}
public void Should_create_a_new_instance_of_SecurityDoctor()
{
// Arrange
var securityDoctor = SecurityDoctor.Current;
SecurityDoctor.Reset();
// Assert
Assert.That(SecurityDoctor.Current, Is.Not.EqualTo(securityDoctor));
}
public void Should_find_a_single_event_listener()
{
// Arrange
SecurityDoctor.Reset();
// Act
SecurityDoctor.ScanForEventListeners();
// Assert
Assert.That(SecurityDoctor.Listeners.Single(), Is.TypeOf <TestSecurityEventListener>());
}
public void Should_register_event_listener_using_the_static_method()
{
// Arrange
SecurityDoctor.Reset();
ISecurityEventListener eventListener = new TestSecurityEventListener();
// Act
SecurityDoctor.Register(eventListener);
// Assert
Assert.That(SecurityDoctor.Current.Listeners.Single(), Is.EqualTo(eventListener));
}
public void Should_register_anonymous_event_listener_using_the_static_method()
{
// Arrange
SecurityDoctor.Reset();
Action <ISecurityEvent> eventListener = e => { };
// Act
SecurityDoctor.Register(eventListener);
// Assert
Assert.That(SecurityDoctor.Current.Listeners.Cast <AnonymousSecurityEventListener>().Single().EventListener, Is.EqualTo(eventListener));
}
public void Should_not_scan_for_eventlistners()
{
// Arrange
SecurityDoctor.Reset();
SecurityDoctor.Current.ScanForEventListenersOnConfigure = false;
// Act
SecurityConfigurator.Configure(configuration => {});
// Assert
Assert.That(SecurityDoctor.Current.ScannedForEventListeners, Is.False);
}
public void Should_reset_event_listeners()
{
// Arrange
SecurityDoctor.Register(e => {});
SecurityDoctor.Register(e => {});
SecurityDoctor.Register(e => {});
// Act
SecurityDoctor.Reset();
// Assert
Assert.That(SecurityDoctor.Listeners, Is.Null);
}
public void Should_register_multiple_event_listener()
{
// Arrange
SecurityDoctor.Reset();
Action <ISecurityEvent> eventListener1 = e => {};
Action <ISecurityEvent> eventListener2 = e => {};
// Act
SecurityDoctor.Register(eventListener1);
SecurityDoctor.Register(eventListener2);
// Assert
Assert.That(SecurityDoctor.Listeners.Count(), Is.EqualTo(2));
Assert.That(SecurityDoctor.Listeners.Cast <AnonymousSecurityEventListener>().First().EventListener, Is.EqualTo(eventListener1));
Assert.That(SecurityDoctor.Listeners.Cast <AnonymousSecurityEventListener>().Last().EventListener, Is.EqualTo(eventListener2));
}
public void Should_return_result_when_no_event_listener_is_registered()
{
// Arrange
SecurityDoctor.Reset();
var context = TestDataFactory.CreateSecurityContext(false);
var expectedResult1 = new {};
var expectedResult2 = new {};
var expectedResult3 = new {};
// Act
var result1 = Publish.ConfigurationEvent(() => expectedResult1, r => null);
var result2 = Publish.RuntimeEvent(() => expectedResult2, r => null, context);
var result3 = Publish.RuntimePolicyEvent(() => expectedResult3, r => null, context);
// Assert
Assert.That(result1, Is.EqualTo(expectedResult1));
Assert.That(result2, Is.EqualTo(expectedResult2));
Assert.That(result3, Is.EqualTo(expectedResult3));
}
public void SetUp()
{
SecurityDoctor.Reset();
}