public void MockINGpROPERTIES_PropertySet_TestMethod()
{
var warehouse = Mock.Create <Iwarehouse>(Behavior.Strict);
Mock.ArrangeSet(() => warehouse.Manager = "John");
warehouse.Manager = "Scott";
}
public void ShouldAssertCallOriginalForPropertySet()
{
var foo = Mock.Create <FooAbstract>(Behavior.Strict);
Mock.ArrangeSet <FooAbstract>(() => { foo.Value = 1; }).CallOriginal();
Assert.Throws <NotImplementedException>(() => { foo.Value = 1; });
}
public void ShoudThrowForUninitializedIndexedSet()
{
var foo = Mock.Create <IFooIndexed>();
Mock.ArrangeSet <IFooIndexed>(() => foo[0] = "ping");
Assert.Throws <AssertionException>(() => Mock.AssertSet(() => foo[0] = "ping"));
}
public void ShouldAssertThrowOnProperty()
{
var foo = Mock.Create <IFoo>(Behavior.Strict);
Mock.ArrangeSet <IFoo>(() => foo.Value = 1).Throws(new ArgumentException());
Assert.Throws <ArgumentException>(() => foo.Value = 1);
}
public void ShouldArrangeMethodWithPointerArg()
{
var mock = Mock.Create <UnsafeClass1>();
int called = 0;
Mock.ArrangeSet(() => mock.Do((void *)0)).IgnoreArguments().DoInstead(() => called++);
mock.Do((void *)0);
mock.Do((void *)123);
Assert.Equal(2, called);
}
public void TestMethodShowingAssertFunctionalityOnPropSet()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet(() => foo.Bar = 0).MustBeCalled();
foo.Bar = 0;
Mock.Assert(foo);
}
public void ShouldAssertSetPropertyOccurenceForAnyValue()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet(() => foo.EffectiveFrom = DateTime.Now).IgnoreArguments();
foo.EffectiveFrom = DateTime.Now;
Assert.Throws <AssertionException>(() => Mock.AssertSet(() => foo.EffectiveFrom = Arg.IsAny <DateTime>(), Occurs.Never()));
}
public void ShouldAssertSetWithIndexerWithMatcher()
{
var foo = Mock.Create <IFooIndexed>();
Mock.ArrangeSet <IFooIndexed>(() => foo[0] = "ping");
foo[0] = "ping";
Mock.AssertSet(() => foo[0] = Arg.Matches <string>(x => x.StartsWith("p")));
}
public void ShouldAssertSetWUnArrangedPropertyOnLoose()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet <IFoo>(() => { foo.StrValue = string.Empty; }).Throws(new ArgumentException());
foo.StrValue = "Should not Throw";
Assert.Throws <ArgumentException>(() => foo.StrValue = string.Empty);
}
public void ShouldAssertPropertySet()
{
var foo = Mock.Create <IFoo>(Behavior.Strict);
Mock.ArrangeSet <IFoo>(() => { foo.Value = 3; });
foo.Value = 3;
Assert.Throws <MockException>(() => foo.Value = 2);
}
public void ShouldAssertIndexedSet()
{
var foo = Mock.Create <IIndexedFoo>(Behavior.Strict);
Mock.ArrangeSet <IIndexedFoo>(() => { foo[0] = "foo"; });
foo[0] = "foo";
Assert.Throws <MockException>(() => foo[0] = "fxx");
}
public void ShouldAssertIndexerSet()
{
var foo = Mock.Create <IFooIndexed>();
Mock.ArrangeSet <IFooIndexed>(() => foo[0] = "ping");
foo[0] = "ping";
Mock.AssertSet(() => foo[0] = "ping");
}
public void ShouldAssertMatcherSetupWithMatcherForIndexer()
{
var foo = Mock.Create <IFooIndexed>();
Mock.ArrangeSet <IFooIndexed>(() => foo[0] = Arg.IsAny <string>());
foo[0] = "ping";
Mock.AssertSet(() => foo[0] = Arg.Matches <string>(x => string.Compare("ping", x) == 0));
}
public void SHouldAssertIndexedSetWithMatcher()
{
var foo = Mock.Create <IIndexedFoo>(Behavior.Strict);
Mock.ArrangeSet <IIndexedFoo>(() => { foo[0] = Arg.Matches <string>(x => x.Equals("ping")); });
Mock.ArrangeSet <IIndexedFoo>(() => { foo[1] = Arg.IsAny <string>(); });
foo[0] = "ping";
foo[1] = "pong";
}
public void ShouldNotRaiseForAssertAllWhenArrangeSetIsApplied()
{
var foo = Mock.Create <Foo>();
Mock.ArrangeSet <Foo>(() => foo.Value = true);
foo.Value = true;
Mock.AssertAll(foo);
}
public void MockingProperties_PropertySet_TestMethod()
{
var warehouse = Mock.Create <Iwarehouse>();
Mock.ArrangeSet(() => warehouse.Manager = "John").Throws <ArgumentException>();
warehouse.Manager = "Scott";
warehouse.Manager = "John";
}
public void ShouldAssertEventHandlerAddingOccurrence()
{
var doc = Mock.Create <IDocument>();
Mock.ArrangeSet(() => doc.IsDirtyChanged += null).IgnoreArguments().OccursOnce();
Assert.Throws <AssertionException>(() => Mock.Assert(doc));
doc.IsDirtyChanged += (o, e) => { };
Mock.Assert(doc);
}
public void ShouldAssertDoInsteadOnProperySet()
{
bool expected = false;
var foo = Mock.Create <IFoo>(Behavior.Strict);
Mock.ArrangeSet <IFoo>(() => { foo.Value = 1; }).DoInstead(() => expected = true);
foo.Value = 1;
Assert.True(expected);
}
public void ShouldThrowSetIndexerWithMatcherThatIsNotCalled()
{
var foo = Mock.Create <IFooIndexed>();
Mock.ArrangeSet <IFooIndexed>(() => foo[0] = "ping");
Assert.Throws <AssertionException>(() =>
{
Mock.AssertSet(() => foo[0] = Arg.Matches <string>(x => x.StartsWith("p")));
});
}
public void ShouldThrowExpectionForASpecificSet()
{
var foo = Mock.Create <Foo>();
Mock.ArrangeSet <Foo>(() => foo.MyProperty = 10).Throws(new ArgumentException());
// should not throw any expection.
foo.MyProperty = 1;
Assert.Throws <ArgumentException>(() => { foo.MyProperty = 10; });
}
public void SHouldAssertPropertySetUsingMatcher()
{
var foo = Mock.Create <IFoo>(Behavior.Strict);
Mock.ArrangeSet <IFoo>(() => foo.Value = Arg.Matches <int>(x => x > 3));
foo.Value = 4;
foo.Value = 5;
Assert.Throws <MockException>(() => foo.Value = 3);
}
public void ShouldAssertPropertySetUsingAssertable()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet <IFoo>(() => { foo.Value = 1; }).DoNothing().MustBeCalled();
Assert.Throws <AssertionException>(() => Mock.Assert(foo));
foo.Value = 1;
Mock.Assert(foo);
}
public void ShouldAssertSpecificPropertySet()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet <IFoo>(() => { foo.Value = 1; });
Assert.Throws <AssertionException>(() => Mock.AssertSet(() => foo.Value = 1));
foo.Value = 1;
Mock.AssertSet(() => foo.Value = 1);
}
public void ShouldAsserInOrderExecutionForPropertySet()
{
var foo = Mock.Create <IFoo>();
Mock.ArrangeSet(() => foo.Value = 10).InOrder();
Mock.ArrangeSet(() => foo.Value = 11).InOrder();
foo.Value = 10;
foo.Value = 11;
Mock.Assert(foo);
}
public void ShouldAssertNestedPropertySet()
{
var foo = Mock.Create <IFoo>(Behavior.Strict);
Mock.ArrangeSet <IFoo>(() => { foo.Bar.Value = 5; }).DoNothing();
Assert.Throws <MockException>(() => foo.Bar.Value = 10);
foo.Bar.Value = 5;
Assert.NotNull(foo.Bar);
}
public void InvokeSetsAuthorizationHeaderAccordingHeadersDictionaryWhenAuthSchemeIsNotSet()
{
// Arrange
var mockedResponseMessage = Mock.Create <HttpResponseMessage>();
var mockedRequestHeaders = Mock.Create <HttpRequestHeaders>();
Mock.Arrange(() => HttpClient.DefaultRequestHeaders)
.IgnoreInstance()
.Returns(mockedRequestHeaders)
.Occurs(4);
Mock.ArrangeSet(() => mockedRequestHeaders.Authorization = new AuthenticationHeaderValue(BEARER_AUTH_SCHEME, SAMPLE_BEARER_TOKEN))
.OccursNever();
Mock.Arrange(() => mockedRequestHeaders.TryAddWithoutValidation(AUTHORIZATION_HEADER_KEY, SAMPLE_BEARER_TOKEN))
.OccursOnce();
Mock.Arrange(() => mockedRequestHeaders.Add(USER_AGENT_KEY, TEST_USER_AGENT))
.OccursOnce();
Mock.Arrange(() => mockedRequestHeaders.TryAddWithoutValidation(ACCEPT_HEADER_KEY, ACCEPT_HEADER_VALUE))
.OccursOnce();
Mock.Arrange(() => HttpClient.GetAsync(Arg.Is(new Uri(URI))).Result)
.IgnoreInstance()
.Returns(mockedResponseMessage)
.OccursOnce();
Mock.Arrange(() => mockedResponseMessage.EnsureSuccessStatusCode())
.OccursOnce();
Mock.Arrange(() => mockedResponseMessage.Content.ReadAsStringAsync().Result)
.Returns(SAMPLE_RESPONSE_BODY)
.OccursOnce();
RestCallExecutor restCallExecutor = new RestCallExecutor();
var headers = CreateSampleHeaders();
headers.Add(AUTHORIZATION_HEADER_KEY, SAMPLE_BEARER_TOKEN);
// Act
var result = restCallExecutor.Invoke(HttpMethod.Get, URI, headers, null);
// Assert
Assert.AreEqual(SAMPLE_RESPONSE_BODY, result);
Mock.Assert(HttpClient);
Mock.Assert(mockedRequestHeaders);
Mock.AssertSet(() => mockedRequestHeaders.Authorization = Arg.Is(new AuthenticationHeaderValue(BEARER_AUTH_SCHEME, SAMPLE_BEARER_TOKEN)));
Mock.Assert(mockedResponseMessage);
}
public void ShouldThrowAfterAllWithoutPrerequisites()
{
var foo = Mock.Create <IFoo>();
var init = Mock.Arrange(() => foo.Init());
Mock.ArrangeSet(() => foo.Value = Arg.AnyInt).AfterAll(init);
Mock.Arrange(() => foo.Save()).AfterAll(init);
foo.Value = 5;
foo.Save();
Assert.Throws <AssertionException>(() => Mock.AssertAll(foo));
}
public void Value_NotSet_ShouldNotBeCalled()
{
// ARRANGE
// Creating a mocked instance of the "IFoo" interface.
var foo = Mock.Create <IFoo>();
// Arranging: foo.Value should be set to 1 during the test.
Mock.ArrangeSet(() => { foo.Value = 1; }).MustBeCalled();
// ACT
// ASSERT - Asserting all arrangements on "foo".
Mock.Assert(foo);
}
public void ShouldAssertPropertySet()
{
// ARRANGE
// Creating a mocked instance of the "IFoo" interface.
var foo = Mock.Create <IFoo>();
// Arranging: That foo.Value must be set to 1 during the test method.
Mock.ArrangeSet(() => foo.Value = 1).MustBeCalled();
// ACT
foo.Value = 1;
// ASSERT - Asserting the expected foo.Value_SET.
Mock.AssertSet(() => foo.Value = 1);
}
public void Bar_OnSetWithArgument1_ShouldDoNothingAndMustBeCalled()
{
// ARRANGE
// Creating a mocked instance of the "IFoo" interface.
var foo = Mock.Create <IFoo>();
// Arranging: foo.Bar should do nothing when set to 1, but must be called.
Mock.ArrangeSet <IFoo>(() => foo.Bar = 1).DoNothing().MustBeCalled();
// ACT
foo.Bar = 1;
// ASSERT - Asserting all arrangements on "foo".
Mock.Assert(foo);
}
