Telerik JustMock

[TestMethod]
public void ShouldAssertWithCustomSelect()
{
    var simpleDataInstance = new SimpleData();

    // Arrange - When simpleDataInstance.Products_GET is called, it should return expected collection.
    Mock.Arrange(() => simpleDataInstance.Products).ReturnsCollection(ReturnExpextedCollectionOfProducts());

    // Act - Applying a LINQ query for simpleDataMock.Products.
    var actual = (from p in simpleDataInstance.Products
                    where p.UnitsInStock == 50
                    select p.ProductID).SingleOrDefault();

    // Assert
    Assert.AreEqual(2, actual);
}
                        

[TestMethod]
public void DoPublic_OnExecute_ShouldCallDoPrivate()
{
    var isCalled = false;
    
    Foo foo = new Foo();
    
    // Arrange - When the non-public method DoPrivate() is called from the foo instance, 
    // it should set isCalled to true instead of executing its original logic.
    Mock.NonPublic.Arrange(foo, "DoPrivate").DoInstead(() => isCalled = true);
    
    // Act
    foo.DoPublic(); // DoPublic() should call DoPrivate().
    
    // Assert
    Assert.IsTrue(isCalled);
}
                        

[TestMethod]
public void ShouldFakeStaticPropertyGet()
{
    bool isCalled = false;
    var expected = 1;

    // Arrange
    // Getting the static instance(Foo) ready for mocking disregarding the constructor and applying strict behavior.
    // If we don't mock the constructor, a NotImplementedException will be thrown.
    Mock.SetupStatic(typeof(Foo), Behavior.Strict, StaticConstructor.Mocked);

    // When the static(Foo.FooProp_GET) property is called, 
    // it should assign true to isCalled and return expected instead.
    Mock.Arrange(() => Foo.FooProp).DoInstead(() => { isCalled = true; }).Returns(expected);

    // Act
    var actual = Foo.FooProp;

    // Assert
    Assert.AreEqual(expected, actual);
    Assert.IsTrue(isCalled);
}

                        

[TestMethod]
public void ShouldApplyIgnoreInstanceToVirtual()
{
    var expected = 10;

    // Arrange
    // Creating a mocked instance of the "Calculus" class.
    // This mock will also be used as a fake of a given type for applying a future instance expectation to that type.
    var calculus = Mock.Create<Calculus>();

    // When calculus.Sum() is called, it should return expected.
    // Also, this expectations will apply for all newly created instances of the Calculus class 
    // during the test.
    Mock.Arrange(() => calculus.Sum()).IgnoreInstance().Returns(expected);

    // Act
    var valueFromExistingInstance = calculus.Sum();
    var valueFromNewInstance = new Calculus().Sum();

    // Assert
    Assert.AreEqual(expected, valueFromExistingInstance); // Verifying the value from an already existing instance.
    Assert.AreEqual(expected, valueFromNewInstance); // Verifying the value from a newly created instance.
}

                        

[TestMethod]
public void ShouldAssertCustomValueForDateTimeNow()
{
    var expected = new DateTime(1900, 4, 12);

    // Arrange - Here we arrange, when DateTime.Now is called it should return expected DateTime.
    Mock.Arrange(() => DateTime.Now).Returns(expected);

    // Act
    var now = DateTime.Now;

    // Assert - the date is indeed what was arranged.
    Assert.AreEqual(expected.Year, now.Year);
    Assert.AreEqual(expected.Month, now.Month);
    Assert.AreEqual(expected.Day, now.Day);
}

                        

[TestMethod]
public void ShouldReturnFakeDbSet_WhenDbContextPropertyIsCalled()
{
    // Arrange
    NerdDinners nerdDinners = new NerdDinners();

    // When the DBSet property nerdDinners.Dinners is called, it should return a predefined fake collection containing 3 items.
    Mock.Arrange(() => nerdDinners.Dinners).ReturnsCollection(FakeDinners());

    // Act - We call the nerdDinners.Dinners and search for a dinner with a certain DinnerID.
    var actualQuery = from d in nerdDinners.Dinners
                        where d.DinnerID == 1
                        select d;

    // Assert - We assert that the nerdDinners.Dinners collection will actually return a collection with 3 items.
    Assert.AreEqual(3, nerdDinners.Dinners.Count());
    // We assert that there is only one item in our collection that has DinnerID equal to one.
    Assert.AreEqual(1, actualQuery.Count());
    Assert.AreEqual(1, actualQuery.First().DinnerID);
}