public static void RaiseEventsWhenTargetIsNull()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation(expectations);
Assert.That(() => information.RaiseEvents((null as IMockWithEvents) !), Throws.TypeOf <ArgumentNullException>());
}
public static void Create()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var handler = new HandlerInformation <string>(expectations);
Assert.That(handler.ReturnValue, Is.EqualTo(default(string)), nameof(handler.ReturnValue));
}
public void Create()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var handler = new HandlerInformation<string>(expectations);
var returnValue = new MethodAdornments<string>(handler);
Assert.AreEqual(default(string), handler.ReturnValue, nameof(handler.ReturnValue));
}
public void SetReturnValue()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var information = new HandlerInformation<int>(expectations);
information.ReturnValue = 1;
Assert.AreEqual(1, information.ReturnValue, nameof(information.ReturnValue));
}
public static void Create()
{
var info = new HandlerInformation();
var events = info.GetRaiseEvents();
Assert.That(events.Count, Is.EqualTo(0), nameof(events.Count));
}
public void CreateWithExpectedCallCount()
{
var information = new HandlerInformation(2);
Assert.IsNull(information.Method, nameof(information.Method));
Assert.AreEqual(2, information.ExpectedCallCount, nameof(information.ExpectedCallCount));
Assert.AreEqual(0, information.CallCount, nameof(information.CallCount));
Assert.AreEqual(0, information.Expectations.Count, nameof(information.Expectations.Count));
}
public static void VerifyWhenExpectedCallCountIsNotSpecifiedAndIncrementCallCountIsNotCalled()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation(expectations);
var result = information.Verify();
Assert.That(result.Count, Is.EqualTo(1), nameof(result.Count));
}
public void Create()
{
var info = new HandlerInformation();
var adornments = new MethodAdornments(info);
var events = info.GetRaiseEvents();
Assert.AreEqual(0, events.Count, nameof(events.Count));
}
public void SetReturnValueFunction()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var newReturnValue = "a";
var handler = new HandlerInformation<string>(expectations);
var returnValue = new MethodAdornments<string>(handler);
returnValue.Returns(new Func<string>(() => newReturnValue));
Assert.AreEqual(newReturnValue, handler.ReturnValue, nameof(handler.ReturnValue));
}
public void CreateWithExpectedCallCount()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var information = new HandlerInformation<int>(2, expectations);
Assert.IsNull(information.Method, nameof(information.Method));
Assert.AreEqual(2, information.ExpectedCallCount, nameof(information.ExpectedCallCount));
Assert.AreEqual(0, information.CallCount, nameof(information.CallCount));
Assert.AreEqual(default(int), information.ReturnValue, nameof(information.ReturnValue));
}
public void CreateWithMethodAndExpectedCallCount()
{
var method = new Action(() => { });
var information = new HandlerInformation(method, 2);
Assert.AreSame(method, information.Method, nameof(information.Method));
Assert.AreEqual(2, information.ExpectedCallCount, nameof(information.ExpectedCallCount));
Assert.AreEqual(0, information.CallCount, nameof(information.CallCount));
Assert.AreEqual(0, information.Expectations.Count, nameof(information.Expectations.Count));
}
public static void IncrementCallCount()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation(expectations);
information.IncrementCallCount();
Assert.That(information.CallCount, Is.EqualTo(1), nameof(information.CallCount));
}
public static void CreateWithExpectedCallCount()
{
var information = new HandlerInformation(2);
Assert.That(information.Method, Is.Null, nameof(information.Method));
Assert.That(information.ExpectedCallCount, Is.EqualTo(2), nameof(information.ExpectedCallCount));
Assert.That(information.CallCount, Is.EqualTo(0), nameof(information.CallCount));
Assert.That(information.Expectations.Count, Is.EqualTo(0), nameof(information.Expectations.Count));
}
public static void SetReturnValue()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation <int>(expectations)
{
ReturnValue = 1
};
Assert.That(information.ReturnValue, Is.EqualTo(1), nameof(information.ReturnValue));
}
public void CreateWithMethod()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var method = new Action(() => { });
var information = new HandlerInformation<int>(method, expectations);
Assert.AreSame(method, information.Method, nameof(information.Method));
Assert.AreEqual(1, information.ExpectedCallCount, nameof(information.ExpectedCallCount));
Assert.AreEqual(0, information.CallCount, nameof(information.CallCount));
Assert.AreEqual(default(int), information.ReturnValue, nameof(information.ReturnValue));
}
public static void SetReturnValue()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var newReturnValue = "a";
var handler = new HandlerInformation <string>(expectations);
var returnValue = new MethodAdornments <string>(handler);
returnValue.Returns(newReturnValue);
Assert.That(handler.ReturnValue, Is.EqualTo(newReturnValue), nameof(handler.ReturnValue));
}
public static void CreateWithExpectedCallCount()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation <int>(2, expectations);
Assert.That(information.Method, Is.Null, nameof(information.Method));
Assert.That(information.ExpectedCallCount, Is.EqualTo(2), nameof(information.ExpectedCallCount));
Assert.That(information.CallCount, Is.EqualTo(0), nameof(information.CallCount));
Assert.That(information.ReturnValue, Is.EqualTo(default(int)), nameof(information.ReturnValue));
}
public static void CreateWithMethodAndExpectedCallCount()
{
var method = new Action(() => { });
var information = new HandlerInformation(method, 2);
Assert.That(information.Method, Is.SameAs(method), nameof(information.Method));
Assert.That(information.ExpectedCallCount, Is.EqualTo(2), nameof(information.ExpectedCallCount));
Assert.That(information.CallCount, Is.EqualTo(0), nameof(information.CallCount));
Assert.That(information.Expectations.Count, Is.EqualTo(0), nameof(information.Expectations.Count));
}
public static void CreateWithOnlySetter()
{
var setterInfo = new HandlerInformation();
var setter = new MethodAdornments(setterInfo);
var adornments = new PropertyMethodAdornments(null, setter);
adornments.RaisesOnGetter("a", EventArgs.Empty);
adornments.RaisesOnSetter("b", EventArgs.Empty);
Assert.That(setterInfo.GetRaiseEvents().Count, Is.EqualTo(1));
}
public void CreateWithExpectedCallCountAndExpectations()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(
new Dictionary<string, ArgumentExpectation>
{
{ "a", new ArgumentExpectation<int>() }
});
var information = new HandlerInformation(2, expectations);
Assert.IsNull(information.Method, nameof(information.Method));
Assert.AreEqual(2, information.ExpectedCallCount, nameof(information.ExpectedCallCount));
Assert.AreEqual(0, information.CallCount, nameof(information.CallCount));
Assert.AreEqual(1, information.Expectations.Count, nameof(information.Expectations.Count));
}
public static void CreateWithExpectedCallCountAndExpectations()
{
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(
new Dictionary <string, ArgumentExpectation>
{
{ "a", new ArgumentIsAnyExpectation <int>() }
});
var information = new HandlerInformation(2, expectations);
Assert.That(information.Method, Is.Null, nameof(information.Method));
Assert.That(information.ExpectedCallCount, Is.EqualTo(2), nameof(information.ExpectedCallCount));
Assert.That(information.CallCount, Is.EqualTo(0), nameof(information.CallCount));
Assert.That(information.Expectations.Count, Is.EqualTo(1), nameof(information.Expectations.Count));
}
public void Raises()
{
var args = new EventArgs();
var info = new HandlerInformation();
var adornments = new MethodAdornments(info);
var newAdornments = adornments.Raises("a", args);
var events = info.GetRaiseEvents();
Assert.AreEqual(1, events.Count);
var @event = events[0];
Assert.AreEqual("a", @event.Name, nameof(@event.Name));
Assert.AreSame(args, @event.Args, nameof(@event.Args));
Assert.AreSame(adornments, newAdornments, nameof(newAdornments));
}
public void Create()
{
var getterInfo = new HandlerInformation();
var setterInfo = new HandlerInformation();
var getter = new MethodAdornments(getterInfo);
var setter = new MethodAdornments(setterInfo);
var adornments = new PropertyMethodAdornments(getter, setter);
adornments.RaisesOnGetter("a", EventArgs.Empty);
adornments.RaisesOnSetter("b", EventArgs.Empty);
Assert.AreEqual(1, getterInfo.GetRaiseEvents().Count);
Assert.AreEqual(1, setterInfo.GetRaiseEvents().Count);
}
public static void Raises()
{
var args = new EventArgs();
var info = new HandlerInformation();
var adornments = new MethodAdornments(info);
var newAdornments = adornments.Raises("a", args);
var events = info.GetRaiseEvents();
Assert.That(events.Count, Is.EqualTo(1), nameof(events.Count));
var @event = events[0];
Assert.That(@event.Name, Is.EqualTo("a"), nameof(@event.Name));
Assert.That(@event.Args, Is.EqualTo(args), nameof(@event.Args));
Assert.That(newAdornments, Is.EqualTo(adornments), nameof(newAdornments));
}
public static void RaiseEvents()
{
var name = nameof(RaiseEvents);
var args = new EventArgs();
var expectations = new ReadOnlyDictionary <string, ArgumentExpectation>(new Dictionary <string, ArgumentExpectation>());
var information = new HandlerInformation(expectations);
information.AddRaiseEvent(new RaiseEventInformation(name, args));
var mock = Rock.Create <IMockWithEvents>();
mock.Handle(_ => _.Raise(name, args));
information.RaiseEvents(mock.Make());
mock.Verify();
}
public void IncrementCallCount()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var information = new HandlerInformation(expectations);
information.IncrementCallCount();
Assert.AreEqual(1, information.CallCount, nameof(information.CallCount));
}
public void VerifyWhenExpectedCallCountIsIncorrect()
{
var expectations = new ReadOnlyDictionary<string, ArgumentExpectation>(new Dictionary<string, ArgumentExpectation>());
var information = new HandlerInformation(2, expectations);
information.IncrementCallCount();
var result = information.Verify();
Assert.AreEqual(1, result.Count, nameof(result.Count));
}
internal MethodAdornments(HandlerInformation <TResult> handler)
: base(handler)
{
}
