Fatal编程技术网
  • csharp/
  • C# 为什么指定倍数时NSubstitute只返回最后一个值

C# 为什么指定倍数时NSubstitute只返回最后一个值

c#

C# 为什么指定倍数时NSubstitute只返回最后一个值,c#,mocking,nsubstitute,C#,Mocking,Nsubstitute,我试图在DAO类中模拟IDbConnection，但收到以下错误： 字符串长度均为5。字符串在索引0处不同。 预期：“11111” 但是是：“22222” 这是我的密码： 测试中的课程 内部类ImportAcquisitionDataDAO:IImportAcquisitionDataDAO { 私有静态记录器log=LogManager.GetCurrentClassLogger（）； 专用只读IDB连接； 内部ImportAcquisitionDataDAO（IDbConnection） {

我试图在DAO类中模拟IDbConnection，但收到以下错误：

字符串长度均为5。字符串在索引0处不同。 预期：“11111” 但是是：“22222”

这是我的密码：

测试中的课程

内部类ImportAcquisitionDataDAO:IImportAcquisitionDataDAO
{
私有静态记录器log=LogManager.GetCurrentClassLogger（）；
专用只读IDB连接；
内部ImportAcquisitionDataDAO（IDbConnection）
{
这个连接=连接；
}
内部列表GetDefinitions（）
{
Debug（“从数据库获取定义”）；
变量定义=新列表（）；
使用（连接）
{
connection.Open（）；
log.Trace（“数据库连接已打开”）；
IDbCommand=connection.CreateCommand（）；
command.CommandText=@“选择*
“来自映射”；
IDataReader reader=command.ExecuteReader（）；
Trace（“执行的命令：\n{0}”，Command.CommandText）；
定义=GetMeterEntries（读卡器）；
}
Debug（“获得{0}个定义。”，definitions.Count）；
返回定义；
}
私有列表GetMeterEntries（IDataReader阅读器）
{
Trace（“解析来自响应的定义”）；
var result=新列表（）；
while（reader.Read（））
{
变量定义=新定义条目(
reader.GetString（0），
reader.GetString（1），
reader.GetString（2），
reader.IsDBNull（3）？null:reader.GetString（3），
reader.IsDBNull（4）？null:reader.GetString（4），
reader.IsDBNull（5）？null:reader.GetString（5），
reader.IsDBNull（6）？null:reader.GetString（6）
);
log.Trace（definition.ToString（））；
结果.增加（定义）；
}
返回结果；
}
}
公共类定义条目
{
公共字符串MeterSN{get；private set；}
公共字符串匹配{get；private set；}
公共字符串IpAddress{get；private set；}
公共字符串SIM{get；private set；}
公共字符串ModulID{get；private set；}
公共字符串SIMUser{get；private set；}
公共字符串SIMPassword{get；private set；}
公共定义条目（字符串meterSN、字符串matnr、字符串ipAddress、字符串sim、字符串modulId、字符串simUser、字符串simPassword）
{
MeterSN=MeterSN；
MATNR=MATNR；
IP地址=IP地址；
SIM=SIM；
ModulID=ModulID；
SIMUser=SIMUser；
SIMPassword=SIMPassword；
}
}
测试班

[TestFixture]
公共类ImportAcquisitionDataDAOTests
{
私有连接；
私有idbcomck命令；
私人IDataReader mockReader；
私人进口收购数据道；
[设置]
公共作废设置（）
{
mockConnection=替换.For（）；
mockCommand=replacement.For（）；
mockReader=Substitute.For（）；
dao=新的ImportAcquisitionDataDAO（mockConnection）；
mockConnection.CreateCommand（）返回（mockCommand）；
mockCommand.ExecuteReader（）返回（mockReader）；
}
[测试]
公共void TestGetDefinitions（）
{
//嘲弄
var databaseDefinitionFirst=新定义条目（“11111”、“AS3000-5/100-400-P”、“10.42.42.26”、“SIM-001”、“12345lkj”、“阿里巴巴”、“阿布拉卡达布拉”）；
var databaseDefinitionSecond=新定义条目（“22222”、“AS3000-5/100-400-Q”、“10.42.42.158”、null、null、null、null）；
mockReader.Read（）返回（true、true、false）；
GetString（Arg.Is（0））.Returns（databaseDefinitionFirst.MeterSN，databaseDefinitionSecond.MeterSN）；
GetString（Arg.Is（1））.Returns（databaseDefinitionFirst.MATNR，databaseDefinitionSecond.MATNR）；
GetString（Arg.Is（2））.Returns（databaseDefinitionFirst.IpAddress，databaseDefinitionSecond.IpAddress）；
IsDBNull（参数为（3））.Returns（false，true）；
GetString（Arg.Is（3））.Returns（databaseDefinitionFirst.SIM）；
IsDBNull（参数为（4））.Returns（false，true）；
GetString（Arg.Is（4））.Returns（databaseDefinitionFirst.moduleId）；
IsDBNull（参数为（5））.Returns（false，true）；
GetString（Arg.Is（5））.Returns（databaseDefinitionFirst.SIMUser）；
IsDBNull（参数为（6））.Returns（false，true）；
GetString（Arg.Is（6））.Returns（databaseDefinitionFirst.SIMPassword）；
//使用
List tested=dao.GetDefinitions（）；
//核实
Assert.AreEqual（2，tested.Count）；
AssertDefinitionEntry（databaseDefinitionFirst，tested.First（））；
AssertDefinitionEntry（databaseDefinitionSecond，tested.Last（））；
}
私有无效资产定义项（预期定义项，测试定义项）
{
Assert.AreEqual（expected.MeterSN，tested.MeterSN）；
Assert.AreEqual（expected.MATNR，tested.MATNR）；
Assert.AreEqual（预期的.IpAddress，测试的.IpAddress）；
Assert.AreEqual（expected.SIM，tested.SIM）；
Assert.AreEqual（expected.moduleId，tested.moduleId）；
Assert.AreEqual（expected.SIMUser，tested.SIMUser）；
Assert.AreEqual（预期为.SIMPassword，测试为.SIMPassword）；
}
}
这是执行第一个断言之前的调试屏幕：

除MeterSN字段外，所有设置都与预期相同，这两个条目都是相同的。但我无法找出为什么这是一个相当微妙的问题

简短答复:

Move
mockReader.GetString（参数为（0））.Returns（databaseDefinitionFirst.MeterSN，databaseDefinitionSecond.MeterSN）
是最后一个存根调用（就在
mockReader.GetString（Arg.Is（6））
下面）

internal class ImportAcquisitionDataDAO : IImportAcquisitionDataDAO { private static Logger log = LogManager.GetCurrentClassLogger(); private readonly IDbConnection connection; internal ImportAcquisitionDataDAO(IDbConnection connection) { this.connection = connection; } internal List<DefinitionEntry> GetDefinitions() { log.Debug("Getting definitions from database."); var definitions = new List<DefinitionEntry>(); using (connection) { connection.Open(); log.Trace("Database connection opened"); IDbCommand command = connection.CreateCommand(); command.CommandText = @"SELECT * FROM MAPPING"; IDataReader reader = command.ExecuteReader(); log.Trace("Command executed:\n{0}", command.CommandText); definitions = GetMeterEntries(reader); } log.Debug("Obtained {0} definitions.", definitions.Count); return definitions; } private List<DefinitionEntry> GetMeterEntries(IDataReader reader) { log.Trace("Parsing definitions from response"); var result = new List<DefinitionEntry>(); while (reader.Read()) { var definition = new DefinitionEntry( reader.GetString(0), reader.GetString(1), reader.GetString(2), reader.IsDBNull(3) ? null : reader.GetString(3), reader.IsDBNull(4) ? null : reader.GetString(4), reader.IsDBNull(5) ? null : reader.GetString(5), reader.IsDBNull(6) ? null : reader.GetString(6) ); log.Trace(definition.ToString()); result.Add(definition); } return result; } } public class DefinitionEntry { public string MeterSN { get; private set; } public string MATNR { get; private set; } public string IpAddress { get; private set; } public string SIM { get; private set; } public string ModulID { get; private set; } public string SIMUser { get; private set; } public string SIMPassword { get; private set; } public DefinitionEntry(string meterSN, string matnr, string ipAddress, string sim, string modulId, string simUser, string simPassword) { MeterSN = meterSN; MATNR = matnr; IpAddress = ipAddress; SIM = sim; ModulID = modulId; SIMUser = simUser; SIMPassword = simPassword; } } 

[TestFixture]
public class ImportAcquisitionDataDAOTests
{
    private IDbConnection mockConnection;
    private IDbCommand mockCommand;
    private IDataReader mockReader;
    private ImportAcquisitionDataDAO dao;

    [SetUp]
    public void SetUp()
    {
        mockConnection = Substitute.For<IDbConnection>();
        mockCommand = Substitute.For<IDbCommand>();
        mockReader = Substitute.For<IDataReader>();
        dao = new ImportAcquisitionDataDAO(mockConnection);

        mockConnection.CreateCommand().Returns(mockCommand);
        mockCommand.ExecuteReader().Returns(mockReader);
    }

    [Test]
    public void TestGetDefinitions()
    {
        // mock
        var databaseDefinitionFirst = new DefinitionEntry("11111", "AS3000-5/100-400-P", "10.42.42.26", "SIM-001", "12345lkj", "alibaba", "abrakadabra");
        var databaseDefinitionSecond = new DefinitionEntry("22222", "AS3000-5/100-400-Q", "10.42.42.158", null, null, null, null);

        mockReader.Read().Returns(true, true, false);
        mockReader.GetString(Arg.Is<int>(0)).Returns(databaseDefinitionFirst.MeterSN, databaseDefinitionSecond.MeterSN);
        mockReader.GetString(Arg.Is<int>(1)).Returns(databaseDefinitionFirst.MATNR, databaseDefinitionSecond.MATNR);
        mockReader.GetString(Arg.Is<int>(2)).Returns(databaseDefinitionFirst.IpAddress, databaseDefinitionSecond.IpAddress);
        mockReader.IsDBNull(Arg.Is<int>(3)).Returns(false, true);
        mockReader.GetString(Arg.Is<int>(3)).Returns(databaseDefinitionFirst.SIM);
        mockReader.IsDBNull(Arg.Is<int>(4)).Returns(false, true);
        mockReader.GetString(Arg.Is<int>(4)).Returns(databaseDefinitionFirst.ModulID);
        mockReader.IsDBNull(Arg.Is<int>(5)).Returns(false, true);
        mockReader.GetString(Arg.Is<int>(5)).Returns(databaseDefinitionFirst.SIMUser);
        mockReader.IsDBNull(Arg.Is<int>(6)).Returns(false, true);
        mockReader.GetString(Arg.Is<int>(6)).Returns(databaseDefinitionFirst.SIMPassword);

        // use
        List<DefinitionEntry> tested = dao.GetDefinitions();

        // verify
        Assert.AreEqual(2, tested.Count);
        AssertDefinitionEntry(databaseDefinitionFirst, tested.First());
        AssertDefinitionEntry(databaseDefinitionSecond, tested.Last());
    }

    private void AssertDefinitionEntry(DefinitionEntry expected, DefinitionEntry tested)
    {
        Assert.AreEqual(expected.MeterSN, tested.MeterSN);
        Assert.AreEqual(expected.MATNR, tested.MATNR);
        Assert.AreEqual(expected.IpAddress, tested.IpAddress);
        Assert.AreEqual(expected.SIM, tested.SIM);
        Assert.AreEqual(expected.ModulID, tested.ModulID);
        Assert.AreEqual(expected.SIMUser, tested.SIMUser);
        Assert.AreEqual(expected.SIMPassword, tested.SIMPassword);
    }
}

        DataTable dt = new DataTable();
        dt.Columns.AddRange(
            new [] {
                new DataColumn("a", typeof(string)),
                new DataColumn("b", typeof(string)),
                new DataColumn("c", typeof(string)),
                new DataColumn("d", typeof(string)),
                new DataColumn("e", typeof(string)),
                new DataColumn("f", typeof(string)),
                new DataColumn("g", typeof(string))
            });
        dt.Rows.Add("11111", "AS3000-5/100-400-P", "10.42.42.26", "SIM-001", "12345lkj", "alibaba", "abrakadabra");
        dt.Rows.Add("22222", "AS3000-5/100-400-Q", "10.42.42.158", null, null, null, null);
        mockReader = new DataTableReader(dt);