Just模拟-hero
SuWhere pWhere port .5,净 .网6 RC1 & .网络核心

Telerik Just模拟

最快、最灵活、最完整的模拟工具
用于制作单元测试.

下载免费试用
trust-radius-badge

Telerik获得多个TrustRadius的2021年最佳开发奖

Telerik赢得了 最好的特性集最好的客户SuWhere pWhere port.

trust-radius-badge

Telerik UI赢得TrustRadius的2021年最高评级奖

Progress Telerik UI赢得了TrustRadius的最高评级奖 软件组件 .网络的发展.

big_wave_dblue_hero

探索平博注册的一些惊人的功能

ninja-peeking
[TestMethod]
公共 无效 Should模拟GenericClass()
{
    int 预期Value = 1;

    / /安排
    // Creating a mock instance of the "喷火Generic" class.
    var 喷火 = 模拟.创建<喷火Generic<int>>();

    //当虚拟喷火.得到()被调用时,参数为任何整数,它应该返回预期Value.
    模拟.安排(() => 喷火.得到(参数.IsAny<int>())).返回(预期Value);

    / /行为
    int 实际Value = 喷火.得到(0);

    / /维护
    断言.AreEqual(预期Value, 实际Value);
}
                        
<TestMethod> _
公共 Sub Should模拟GenericClass()
    昏暗的 预期Value As 整数 = 1

    的安排
    ' Creating a mock instance of the "喷火Generic" class.
    昏暗的 喷火 = 模拟.创建(Of 喷火Generic(Of 整数))()

    当虚拟喷火.得到()被调用时,参数为任何整数,它应该返回预期Value.
    模拟.安排(函数() 喷火.[得到](参数.IsAny(Of 整数)())).返回(预期Value)

    的行为
    昏暗的 实际Value As 整数 = 喷火.[得到](0)

    的断言
    断言.AreEqual(预期Value, 实际Value)
结束 Sub
                        
[TestMethod]
公共 无效 Should断言WithCustomSelect()
{
    var simpleDataInstance =  SimpleData();

    / /安排 -当simpledatinstance . sh.产品_GET被调用时,它应该返回预期的集合.
    模拟.安排(() => simpleDataInstance.产品).返回Collection(ReturnExpextedCollectionOf产品());

    / /行为 -应用一个LINQ查询simpleData模拟.产品.
    var 实际 = ( p in simpleDataInstance.产品
                    在哪里 p.unitsinstocks == 50
                    select p.ProductID).SingleOrDefault();

    / /维护
    断言.AreEqual(2, 实际);
}
                        
<TestMethod> _
公共 Sub Should断言WithCustomSelect()
    昏暗的 simpleDataInstance =  SimpleData()

    '安排-当simpledatinstance.产品_GET被调用时,它应该返回预期的集合.
    模拟.安排(函数() simpleDataInstance.产品).返回Collection(ReturnExpextedCollectionOf产品())

    的行为 -为simpleData模拟应用LINQ查询.产品.
    昏暗的 实际 = (从p In simpleDataInstance.产品 _
                    p.unitsinstocks = 50 _
                    Select p.ProductID).SingleOrDefault()

    的断言
    断言.AreEqual(2, 实际)
结束 Sub
                        
[TestMethod]
公共 无效 Do公共_OnExecute_ShouldCallDoPrivate()
{
    var 被称为 = ;
    
    喷火 喷火 =  喷火();
    
    / /安排 -当从喷火实例调用非公共方法dopprivate()时, 
    //它应该设置被称为为真正的,而不是执行原来的逻辑.
    模拟.非公开.安排(喷火, “DoPrivate”).DoInstead(() => 被称为 = 真正的);
    
    / /行为
    喷火.Do公共(); // 公共()应该调用private ().
    
    / /维护
    断言.Is真正的(被称为);
}
                        
<TestMethod>
公共 Sub Do公共_OnExecute_ShouldCallDoPrivate()
    昏暗的 被称为 = 

    昏暗的 喷火 As  喷火()

    的安排 -当从喷火实例调用非公共方法dopprivate()时, 
    ,它应该将被称为设置为真正的,而不是执行原来的逻辑.
    模拟.非公开.安排(喷火, “DoPrivate”).DoInstead(函数() InlineAssignHelper(被称为, 真正的))

    的行为 - 公共()应该调用private ().
    喷火.Do公共()

    的断言
    断言.Is真正的(被称为)
结束 Sub
                        
[TestMethod]
公共 无效 ShouldFake静态Property得到()
{
    保龄球 被称为 = ;
    var 预期 = 1;

    / /安排
    //让静态实例(喷火)准备好模拟忽略构造函数和应用严格行为.
    //如果不模拟构造函数,将抛出NotImplementedException异常.
    模拟.Setup静态(typeof(喷火), 行为.严格的, 静态Constructor.嘲笑);

    //当static(喷火.必选_GET)属性被调用, 
    //它应该给被称为赋值真正的,而返回预期.
    模拟.安排(() => 喷火.必选).DoInstead(() => { 被称为 = 真正的; }).返回(预期);

    / /行为
    var 实际 = 喷火.必选;

    / /维护
    断言.AreEqual(预期, 实际);
    断言.Is真正的(被称为);
}

                        
<TestMethod>
公共 Sub ShouldFake静态Property得到()
    昏暗的 被称为 As 布尔 = 
    昏暗的 预期 = 1

    的安排
    让静态实例(喷火)准备好模仿,忽略构造函数并应用严格的行为.
    '如果平博注册不模拟构造函数,一个NotImplementedException将被抛出.
    模拟.Setup静态(方法(喷火), 行为.(严格的), 静态Constructor.嘲笑)

    '当静态(喷火.必选_GET)属性被调用, 
    ,它应该给被称为赋值真正的,而不是返回预期.
    模拟.安排(函数() 喷火.必选).DoInstead(Sub() 被称为 = 真正的).返回(预期)

    的行为
    昏暗的 实际 = 喷火.必选

    的断言
    断言.AreEqual(预期, 实际)
    断言.Is真正的(被称为)
结束 Sub

                        
[TestMethod]
公共 无效 ShouldApplyIgnoreInstanceToVirtual()
{
    var 预期 = 10;

    / /安排
    //创建一个模拟实例的"微积分"类.
    //这个mock也将被用作一个给定类型的假值,用于将将来的实例期望应用到该类型.
    var 微积分 = 模拟.创建<微积分>();

    / /当微积分.当调用总和()时,它应该返回预期的结果.
    //同时,这个期望将适用于所有新创建的微积分类的实例 
    //测试过程中.
    模拟.安排(() => 微积分.总和()).IgnoreInstance().返回(预期);

    / /行为
    var valueFromExistingInstance = 微积分.总和();
    var valueFrom新Instance =  微积分().总和();

    / /维护
    断言.AreEqual(预期, valueFromExistingInstance); //验证已经存在的实例的值.
    断言.AreEqual(预期, valueFrom新Instance); //验证新创建的实例的值.
}

                        
<TestMethod>
公共 Sub ShouldApplyIgnoreInstanceToVirtual()
    昏暗的 预期 = 10

    的安排
    '创建一个' 微积分 '类的模拟实例.
    '这个mock也将被用作一个给定类型的伪函数,用于将将来的实例期望应用到该类型.
    昏暗的 微积分 = 模拟.创建(Of 微积分)()

    “当微积分.当调用总和()时,它应该返回预期的结果.
    同样,这个期望也适用于所有新创建的微积分类实例 
    在测试期间.
    模拟.安排(函数() 微积分.总和()).IgnoreInstance().返回(预期)

    的行为
    昏暗的 valueFromExistingInstance = 微积分.总和()
    昏暗的 valueFrom新Instance =  微积分().总和()

    的断言
    断言.AreEqual(预期, valueFromExistingInstance) '从已经存在的实例验证该值.
    断言.AreEqual(预期, valueFrom新Instance) '验证新创建的实例的值.
结束 Sub

                        
[TestMethod]
公共 无效 Should断言CustomValueForDateTime现在()
{
    var 预期 =  DateTime(1900, 4, 12);

    //安排-这里平博注册安排,当DateTime.现在被调用,它应该返回预期的DateTime.
    模拟.安排(() => DateTime.现在).返回(预期);

    / /行为
    var 现在 = DateTime.现在;

    //断言-日期确实是被安排的.
    断言.AreEqual(预期.一年, 现在.一年);
    断言.AreEqual(预期., 现在.);
    断言.AreEqual(预期.一天, 现在.一天);
}

                        
<TestMethod>
公共 Sub Should断言CustomValueForDateTime现在()
    昏暗的 预期 =  DateTime(1900, 4, 12)

    '安排-这里平博注册安排,当DateTime.现在被调用,它应该返回预期的DateTime.
    模拟.安排(函数() DateTime.现在).返回(预期)

    的行为
    昏暗的 现在 = DateTime.现在

    “断言——日期确实是事先安排好的.
    断言.AreEqual(预期.一年, 现在.一年)
    断言.AreEqual(预期., 现在.)
    断言.AreEqual(预期.一天, 现在.一天)
结束 Sub

                        
[TestMethod]
公共 无效 ShouldReturnFakeDbSet_WhenDbContextPropertyIsCalled()
{
    / /安排
    Nerd晚餐 nerd晚餐 =  Nerd晚餐();

    //当DBSet属性nerd正餐.当调用dinner时,它应该返回一个预定义的包含3个项目的伪集合.
    模拟.安排(() => nerd晚餐.晚餐).返回Collection(Fake晚餐());

    //行动——平博注册称之为书呆子晚宴.晚餐,并搜索具有特定DinnerID的晚餐.
    var 实际Query =  d in nerd晚餐.晚餐
                        在哪里 d.DinnerID == 1
                        select d;

    //断言——平博注册断言书呆子晚宴.晚餐收集实际上会返回一个包含3个项目的集合.
    断言.AreEqual(3, nerd晚餐.晚餐.());
    //平博注册断言集合中只有一个项的DinnerID为1.
    断言.AreEqual(1, 实际Query.());
    断言.AreEqual(1, 实际Query.第一个().DinnerID);
}
                        
<TestMethod>
公共 Sub ShouldReturnFakeDbSet_WhenDbContextPropertyIsCalled()
    的安排
    昏暗的 nerd晚餐 As  Nerd晚餐()

    当DBSet的财产书呆子晚餐.当调用dinner时,它应该返回一个预定义的包含3个项目的伪集合.
    模拟.安排(函数() nerd晚餐.晚餐).返回Collection(Fake晚餐())

    “行动——平博注册称之为书呆子晚宴.晚餐,并搜索具有特定DinnerID的晚餐.
    昏暗的 实际Query = 从d In nerd晚餐.晚餐在维.DinnerID = 1D

    “断言——平博注册断言书呆子晚宴.晚餐收集实际上会返回一个包含3个项目的集合.
    断言.AreEqual(3, nerd晚餐.晚餐.())
    平博注册断言,在平博注册的系列中,只有一件物品的DinnerID等于1.
    断言.AreEqual(1, 实际Query.())
    断言.AreEqual(1, 实际Query.第一个().DinnerID)
结束 Sub

                        
副本!

为什么选择Just模拟

Just模拟功能的完整列表

在行动中看到它

下载免费试用
ninja-v1-opt

升级到Telerik DevCraft完成

为任何项目做好准备 & 技术

通过获得1250 +,节省50%的开发时间 .净和JavaScript UI组件,用于构建web、桌面和移动应用程序.

让钱花得最值

享受单元测试的mock工具和15个产品 .净和JavaScript应用程序开发和嵌入式报告,同时节省高达90%的升级价格.
“我最近放弃了另一个领先的嘲笑工具,转而SuWhere pWhere portJust模拟. 我对其他工具的语法从来都不满意,但我在市场上找不到其他工具. 我发现Just模拟是一个更愉快的体验.”

布拉德·厄比

.净架构师和再造的作者 .净,再造工程 .净

当试图对遗留代码或数据库进行测试时,隔离测试方法变得困难, Just模拟真的开始与众不同了. 它的功能,如MsCorlib, 密封, 静态, 私有方法和实体框架模拟使得看起来不可测试, 可测试的.”

布拉德利·布雷斯韦特

软件开发者,知足的程序员

“我已经使用了一系列的嘲笑工具,我相信Just模拟的API是我到目前为止遇到的最成熟的. 我对框架工具的最高评价是,它的语义足够可读,以至于您在阅读代码时根本不用考虑它们, Just模拟也是如此.”

埃里克·迪特里希

软件开发人员,DaedTech

有什么新鲜事

对Linux的SuWhere pWhere port

对Linux的SuWhere pWhere port

Telerik Just模拟现在是一个跨平台产品,新引入了对Linux的SuWhere pWhere port.

Visual Studio 2022SuWhere pWhere port

Visual Studio 2022SuWhere pWhere port

忠实于平博注册的承诺,SuWhere pWhere port最新的技术趋势, 平博注册已经引入了对Visual Studio 2022的SuWhere pWhere port.

SuWhere pWhere port .净 6发布候选1

SuWhere pWhere port .网络6 rc 1

Telerik Just模拟舰船SuWhere pWhere port .净 6发布候选1.

行业领先的SuWhere pWhere port

专家及及时支援

直接从构建这个UI套件的开发人员那里获得问题的答案, 即使是在你的试用期.

联络SuWhere pWhere port

需要评估的帮助?

如果你不是开发人员或没有时间评估平博注册的产品, 请将您的项目要求发送给平博注册. 平博注册将评估您所需要的功能,并让您知道平博注册的产品是否符合您的需求.

请将您的项目要求发送给平博注册
Background-NextSteps

下一个步骤

看到计划 & 定价

购买单独的产品或任何捆绑

下载免费试用

提供专业技术SuWhere pWhere port.

<喷火ter class="TK-喷火ter" data-tlrk-nav-template="喷火ter-big-rel-markup" data-tlrk-nav-version="3.2.3">
友情链接: 1 2 3 4 5 6 7 8 9 10