public void HandleMultipleThrowingSubscriptions(
Exception exception,
SimpleEvent.EventPublisher publisher,
ThrowingSubscriber subscriber1,
ThrowingSubscriber subscriber2)
{
"Establish a registered publisher and throwing subscriber".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
subscriber1 = new ThrowingSubscriber();
subscriber2 = new ThrowingSubscriber();
this.eventBroker.Register(publisher);
this.eventBroker.Register(subscriber1);
this.eventBroker.Register(subscriber2);
});
"When firing an event".x(() =>
exception = Catch.Exception(() => publisher.FireEvent(EventArgs.Empty)));
"It should pass the exception to the publisher".x(() =>
exception
.Should().NotBeNull()
.And.Subject.As <Exception>().Message
.Should().Be("test"));
"It should stop executing subscribers after the first exception".x(() =>
subscriber2.Handled.Should().BeFalse("second subscriber should not be clled anymore"));
}
public void NoMatch(
EventBroker eventBroker,
SimpleEvent.EventPublisher publisher,
SimpleEvent.EventSubscriber subscriber)
{
"Establish an event broker with a matcher".x(() =>
{
eventBroker = new EventBroker();
eventBroker.AddGlobalMatcher(new Matcher(false));
});
"Establish a registered publisher".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
eventBroker.Register(publisher);
});
"Establish a registered subscriber".x(() =>
{
subscriber = new SimpleEvent.EventSubscriber();
eventBroker.Register(subscriber);
});
"When firing an event".x(() =>
publisher.FireEvent(EventArgs.Empty));
"It should not call subscriber".x(() =>
subscriber.HandledEvent
.Should().BeFalse("matcher should block call"));
}
public void FireEventOnPublisher(
SimpleEvent.EventPublisher publisher,
SimpleEvent.EventSubscriber subscriber,
EventArgs sentEventArgs)
{
"Establish a registered publisher".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
this.eventBroker.Register(publisher);
});
"Establish a registered subscriber".x(() =>
{
subscriber = new SimpleEvent.EventSubscriber();
this.eventBroker.Register(subscriber);
});
"Establish the event args".x(() =>
sentEventArgs = new EventArgs());
"When firing the event".x(() =>
publisher.FireEvent(sentEventArgs));
"It should call subscriber".x(() =>
subscriber.HandledEvent
.Should().BeTrue("event should be handled by subscriber"));
"It should pass event args to subscriber".x(() =>
subscriber.ReceivedEventArgs
.Should().BeSameAs(sentEventArgs));
}
public void FireEventWithSeveralPublishersHavingSameEventTopic(
SimpleEvent.EventPublisher publisher1,
SimpleEvent.EventPublisher publisher2,
SimpleEvent.EventSubscriber subscriber)
{
"Establish two registered publishers".x(() =>
{
publisher1 = new SimpleEvent.EventPublisher();
publisher2 = new SimpleEvent.EventPublisher();
this.eventBroker.Register(publisher1);
this.eventBroker.Register(publisher2);
});
"Establish a registered subscriber".x(() =>
{
subscriber = new SimpleEvent.EventSubscriber();
this.eventBroker.Register(subscriber);
});
"When firing an event on every publisher".x(() =>
{
publisher1.FireEvent(EventArgs.Empty);
publisher2.FireEvent(EventArgs.Empty);
});
"It should call subscriber every time".x(() =>
subscriber.CallCount.Should().Be(2, "subscriber should be called for every fire"));
}
public void FireEventWithSeveralSubscriber(
SimpleEvent.EventPublisher publisher,
SimpleEvent.EventSubscriber subscriber1,
SimpleEvent.EventSubscriber subscriber2)
{
"Establish a registered publisher".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
this.eventBroker.Register(publisher);
});
"Establish two registered subscribers".x(() =>
{
subscriber1 = new SimpleEvent.EventSubscriber();
subscriber2 = new SimpleEvent.EventSubscriber();
this.eventBroker.Register(subscriber1);
this.eventBroker.Register(subscriber2);
});
"When firing the event".x(() =>
publisher.FireEvent(EventArgs.Empty));
"It should call all subscribers".x(() =>
{
subscriber1.HandledEvent.Should().BeTrue("subscriber1 should be called");
subscriber2.HandledEvent.Should().BeTrue("subscriber2 should be called");
});
}
public void SubscriberCleanup(
EventBroker eventBroker,
SimpleEvent.EventPublisher publisher,
SimpleEvent.EventSubscriber subscriber,
SimpleEvent.EventSubscriber subscriberThatIsCollected,
SimpleEvent.RegisterableEventSubscriber registerableSubscriberThatIsCollected,
WeakReference referenceOnSubscriberThatIsCollected,
WeakReference referenceOnRegisterableSubscriberThatIsCollected)
{
"Establish an event broker".x(() =>
eventBroker = new EventBroker());
"Establish a registered publisher".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
eventBroker.Register(publisher);
});
"Establish a registered subscriber".x(() =>
{
subscriber = new SimpleEvent.EventSubscriber();
eventBroker.Register(subscriber);
});
"Establish a registered subscriber that is collected".x(() =>
{
subscriberThatIsCollected = new SimpleEvent.EventSubscriber();
eventBroker.Register(subscriberThatIsCollected);
});
"Establish a registerable subscriber that is collected".x(() =>
{
registerableSubscriberThatIsCollected = new SimpleEvent.RegisterableEventSubscriber();
eventBroker.Register(registerableSubscriberThatIsCollected);
});
"Establish a weak references to the collected subscribers".x(() =>
{
referenceOnSubscriberThatIsCollected = new WeakReference(subscriberThatIsCollected);
referenceOnRegisterableSubscriberThatIsCollected =
new WeakReference(registerableSubscriberThatIsCollected);
});
"When enforcing the garbage collection".x(() =>
{
subscriberThatIsCollected = null;
registerableSubscriberThatIsCollected = null;
GC.Collect();
});
"It should garbage collect the subscribers registered by attribute".x(() =>
referenceOnSubscriberThatIsCollected.IsAlive
.Should().BeFalse("subscriber should be collected"));
"It should garbage collect the subscribers registered by registrar".x(() =>
referenceOnRegisterableSubscriberThatIsCollected.IsAlive
.Should().BeFalse("subscriber should be collected"));
}
public void EventBrokerCleanup(
EventBroker eventBroker,
WeakReference publisher,
WeakReference registerablePublisher,
WeakReference subscriber,
WeakReference registerableSubscriber)
{
"Establish an event broker".x(() =>
eventBroker = new EventBroker());
"Establish a registered publisher".x(() =>
{
var p = new SimpleEvent.EventPublisher();
publisher = new WeakReference(p);
eventBroker.Register(p);
});
"Establish a registered registerable publisher".x(() =>
{
var p = new SimpleEvent.RegisterableEventPublisher();
registerablePublisher = new WeakReference(p);
eventBroker.Register(p);
});
"Establish a registered subscriber".x(() =>
{
var s = new SimpleEvent.EventSubscriber();
subscriber = new WeakReference(s);
eventBroker.Register(s);
});
"Establish a registered registerable subscriber".x(() =>
{
var s = new SimpleEvent.RegisterableEventSubscriber();
registerableSubscriber = new WeakReference(s);
eventBroker.Register(s);
});
"When enforcing the garbage collection".x(
GC.Collect);
"It should unregister publishers registered by attribute".x(() =>
publisher.IsAlive
.Should().BeFalse("publisher should not be referenced anymore"));
"It should unregister publishers registered by registrar".x(() =>
registerablePublisher.IsAlive
.Should().BeFalse("publisher should not be referenced anymore"));
"It should unregister subscribers registered by attribtue".x(() =>
subscriber.IsAlive
.Should().BeFalse("subscriber should not be referenced anymore"));
"It should unregister subscribers registered by registrar".x(() =>
registerableSubscriber.IsAlive
.Should().BeFalse("subscriber should not be referenced anymore"));
}
public void SetupEventBroker()
{
"Establish an event broker".x(() =>
this.eventBroker = new EventBroker());
"Establish an registered publisher".x(() =>
{
this.publisher = new SimpleEvent.EventPublisher();
this.eventBroker.Register(this.publisher);
});
}
public void Disposal(SimpleEvent.EventPublisher publisher)
{
"Establish an event broker with a publisher and an extension".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
this.eventBroker.Register(publisher);
this.eventBroker.AddExtension(this.extension);
});
"When disposing the event broker".x(() => this.eventBroker.Dispose());
"It should call the extension when the event topic was disposed".x(() =>
this.extension.Log.Should().Contain("Disposed"));
}
public void PublisherCleanup(
EventBroker eventBroker,
SimpleEvent.EventPublisher publisher,
SimpleEvent.RegisterableEventPublisher registerablePublisher,
SimpleEvent.EventSubscriber subscriber,
WeakReference weakReferenceOnPublisher,
WeakReference weakReferenceOnRegisterablePublisher)
{
"Establish an event broker".x(() =>
eventBroker = new EventBroker());
"Establish a registered publisher".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
eventBroker.Register(publisher);
});
"Establish a registered registerable publisher".x(() =>
{
registerablePublisher = new SimpleEvent.RegisterableEventPublisher();
eventBroker.Register(registerablePublisher);
});
"Establish a registered subscriber".x(() =>
{
subscriber = new SimpleEvent.EventSubscriber();
eventBroker.Register(subscriber);
});
"Establish a weak references to the collected subscribers".x(() =>
{
weakReferenceOnPublisher = new WeakReference(publisher);
weakReferenceOnRegisterablePublisher = new WeakReference(registerablePublisher);
});
"When enforcing the garbage collection".x(() =>
{
publisher = null;
registerablePublisher = null;
GC.Collect();
});
"It should garbage collect publisher registered by property".x(() =>
weakReferenceOnPublisher.IsAlive
.Should().BeFalse("publisher should be collected"));
"It should garbage collect subscribers registered by registrar".x(() =>
weakReferenceOnRegisterablePublisher.IsAlive
.Should().BeFalse("publisher should be collected"));
}
public void SetupEventBrokerAndExtensions()
{
"Establish an extension".x(() =>
this.extension = new Extension());
"Establish an event broker".x(() =>
this.eventBroker = new EventBroker());
"Establish an publisher".x(() =>
this.publisher = new SimpleEvent.EventPublisher());
"Establish a subscriber".x(() =>
this.subscriber = new SimpleEvent.EventSubscriber());
"Establish event args".x(() =>
this.sentEventArgs = new EventArgs());
}
public void HandleThrowingSubscriptionWithExtension(
Exception exception,
SimpleEvent.EventPublisher publisher,
ThrowingSubscriber subscriber)
{
"Establish a registered publisher and throwing subscriber".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
subscriber = new ThrowingSubscriber();
this.eventBroker.Register(publisher);
this.eventBroker.Register(subscriber);
this.eventBroker.AddExtension(new ExceptionHandlingExtension());
});
"When firing an event".x(() =>
exception = Catch.Exception(() => publisher.FireEvent(EventArgs.Empty)));
"It should not pass exception to the publisher".x(() =>
exception
.Should().BeNull());
}
public void HandleThrowingSubscription(
Exception exception,
SimpleEvent.EventPublisher publisher,
ThrowingSubscriber subscriber)
{
"Establish a registered publisher and throwing subscriber".x(() =>
{
publisher = new SimpleEvent.EventPublisher();
subscriber = new ThrowingSubscriber();
this.eventBroker.Register(publisher);
this.eventBroker.Register(subscriber);
});
"When firing an event".x(() =>
exception = Catch.Exception(() => publisher.FireEvent(EventArgs.Empty)));
"It should pass the exception to the publisher".x(() =>
exception
.Should().NotBeNull()
.And.Subject.As <Exception>().Message
.Should().Be("test"));
}
public void SubscriberRegistrationWithEventArgsNotMatchingPublication(
EventBroker eventBroker,
Exception exception,
SimpleEvent.EventPublisher eventPublisher)
{
"Establish an event broker".x(() =>
eventBroker = new EventBroker());
"Establish a registered publisher".x(() =>
{
eventPublisher = new SimpleEvent.EventPublisher();
eventBroker.Register(eventPublisher);
});
"When registering an subscriber with event args not matching the existing publication".x(() =>
exception = Catch.Exception(() =>
eventBroker.Register(new SubscriberWithWrongEventArgsType())));
"It should throw an exception".x(() =>
exception
.Should().NotBeNull()
.And.BeOfType <EventTopicException>());
}
