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); }