在dapper中嘲笑匿名类型参数，并通过参数属性进行过滤结果

Question

我对欧文和努尼特的熟悉程度不太熟悉，这就是为什么我为此而苦苦挣扎。我正在使用Dapper作为通用存储库，并已将其注入到服务中，然后用来满足逻辑。我的问题是，我将其在Linq的选择中使用，从上一个对象传递参数。而且我不知道如何在模拟中反映这一点...

这是我的服务：

public class StudyService: IStudyService
    {
        private readonly ILogger<StudyService> _logger;
        private readonly IDataRepository _dataRepository;

        public StudyService(ILogger<StudyService> logger, IDataRepository dataRepository)
        {
            _logger = logger;
            _dataRepository = dataRepository;
        }
[...]
        // This is the method to test:
        public async Task<StudiesResponse> GetAllStudies()
        {
            StudiesResponse studies = new StudiesResponse();
            List<StudyReponse> list = new List<StudyReponse>();

            foreach (StudyDAO study in await _dataRepository.GetEntitiesAsync<StudyDAO>())
            {
                StudyReponse resp = new StudyReponse()
                {
                    StudyCode = study.StudyCode,
                    Participators = _dataRepository.GetEntitiesAsync<RoleUserDAO>(new { @StudyId = study.Id }).Result.Select(x => new ParticipatorsResponse()
                    {
                        UserEmail = _dataRepository.GetEntityAsync<UserDAO>(new { @Id = x.Id }).Result.Email,
                        RoleName = _dataRepository.GetEntityAsync<RoleDAO>(new { @Id = x.Id }).Result.Name
                    })
                };


                list.Add(resp);
            }

            studies.Studies = list;
            return studies;
        }
[...]
   }
}

您可以看到检索用户邮件和rolename的呼叫是由先前的“ _datarepository.getentitiessync”选择的，这就是我不喜欢的。 t有一个线索如何模拟...

这是我的通用/匿名存储库：

   public class DataRepository : IDataRepository
    {
        private readonly IConfiguration _configuration;
       
        public DataRepository(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        public async Task<IEnumerable<T>> GetEntitiesAsync<T>()
        {
            using(IDbConnection conn = new SqlConnection(_configuration.GetConnectionString("SqlConnection")))
            {
                return await conn.GetListAsync<T>();
            }   
        }
        public async Task<IEnumerable<T>> GetEntitiesAsync<T>(object query)
        {
            using (IDbConnection conn = new SqlConnection(_configuration.GetConnectionString("SqlConnection")))
            {
                return await conn.GetListAsync<T>(query);
            }
        }

        public async Task<T> GetEntityAsync<T>(object query)
        {
            using (IDbConnection conn = new SqlConnection(_configuration.GetConnectionString("SqlConnection")))
            {
                IEnumerable<T> result = await conn.GetListAsync<T>(query);
                return result.FirstOrDefault();
            }
        }
[...]

这是我的测试类：

[TestFixture]
    public class Tests
    {
        IEnumerable<StudyDAO> _studies;
        IEnumerable<UserDAO> _users;
        IEnumerable<RoleDAO> _roles;
        IEnumerable<RoleUserDAO> _roleUsers;

        
        [SetUp]
        public void Setup()
        {
            _studies = MockedDAOs.GetMockedStudies();
            _users = MockedDAOs.GetMockedUsers();
            _roles = MockedDAOs.GetMockedRoles();
            _roleUsers = MockedDAOs.GetMockedRoleUsers();
        }

        [Test]
        public void GetAllStudiesTest()
        {
            var _data = new Mock<IDataRepository>();
            _data.Setup(m => m.GetEntitiesAsync<StudyDAO>()).Returns(Task.FromResult(_studies));
            _data.Setup(m => m.GetEntitiesAsync<RoleUserDAO>(It.IsAny<Object>())).Returns(Task.FromResult(_roleUsers));
            _data.Setup(m => m.GetEntityAsync<UserDAO>(It.IsAny<Object>())).Returns(Task.FromResult(_users.Where(u => u.Id ==????)));
            _data.Setup(m => m.GetEntityAsync<RoleDAO>(It.IsAny<Object>())).Returns(Task.FromResult(_roles.Where(u => u.Id ==????)));

            var _logger = Mock.Of<ILogger<StudyService>>();
            StudyService _service = new StudyService(_logger, _data.Object);

            var result = _service.GetAllStudies();

            Assert.Pass();
        }
    }

这是我的“模拟”数据构造函数：

 public static class MockedDAOs
    {
        public static IEnumerable<UserDAO> GetMockedUsers()
        {
            List<UserDAO> users = new List<UserDAO>();
            users.Add(new UserDAO()
            {
                Id = 1,
                Email = "[email protected]",
                Address = "Alderaan Sector 1234",
                LanguajePreference = "English",
                UpdateUser = "Admin"
            });
            users.Add(new UserDAO()
            {
                Id = 2,
                Email = "[email protected]",
                Address = "Alderaan Sector 1233",
                LanguajePreference = "English",
                UpdateUser = "Admin"
            });
            users.Add(new UserDAO()
            {
                Id = 3,
                Email = "[email protected]",
                Address = "Alderaan Sector 1232",
                LanguajePreference = "English",
                UpdateUser = "Admin"
            });
            users.Add(new UserDAO()
            {
                Id = 4,
                Email = "[email protected]",
                Address = "Alderaan Sector 1231",
                LanguajePreference = "English",
                UpdateUser = "Admin"
            });
            return users;
        }

        public static IEnumerable<StudyDAO> GetMockedStudies()
        {
            List<StudyDAO> studies = new List<StudyDAO>();
            studies.Add(new StudyDAO()
            {
                Id = 1,
                StudyCode = "order66",
                Company = "Galactic Empire",
                UpdateUser = "Admin"
            });

            return studies;
        }

        public static IEnumerable<RoleDAO> GetMockedRoles()
        {
            List<RoleDAO> roles = new List<RoleDAO>();
            roles.Add(new RoleDAO()
            {
                Id = 1,
                Name = "General Director",
                Curriculum = "Ruthless Management I",
                UpdateUser = "Admin"
            });
            roles.Add(new RoleDAO()
            {
                Id = 2,
                Name = "CEO",
                Curriculum = "Smoke and Mirrors I",
                UpdateUser = "Admin"
            });
            roles.Add(new RoleDAO()
            {
                Id = 3,
                Name = "Strategy Director",
                Curriculum = "Detecting Critical Targets",
                UpdateUser = "Admin"
            });
            roles.Add(new RoleDAO()
            {
                Id = 4,
                Name = "Deliver",
                Curriculum = "Silent Aproaches",
                UpdateUser = "Admin"
            });
            return roles;
        }

        public static IEnumerable<RoleUserDAO> GetMockedRoleUsers()
        {
            List<RoleUserDAO> roleUsers = new List<RoleUserDAO>();
            roleUsers.Add(new RoleUserDAO()
            {
                Id = 1,
                UserId = 1,
                RoleId = 1,
                StudyId = 1,
                UpdateUser = "Admin"
            });
            roleUsers.Add(new RoleUserDAO()
            {
                Id = 2,
                UserId = 2,
                RoleId = 2,
                StudyId = 1,
                UpdateUser = "Admin"
            });
            roleUsers.Add(new RoleUserDAO()
            {
                Id = 3,
                UserId = 3,
                RoleId = 3,
                StudyId = 1,
                UpdateUser = "Admin"
            });
            roleUsers.Add(new RoleUserDAO()
            {
                Id = 4,
                UserId = 4,
                RoleId = 4,
                StudyId = 1,
                UpdateUser = "Admin"
            });
            return roleUsers;
        }

        public static StudiesResponse GetMockedStudiesResponse()
        {
            List<ParticipatorsResponse> participatorsResponse = new List<ParticipatorsResponse>();
            participatorsResponse.Add(new ParticipatorsResponse(){
                UserEmail = "[email protected]",
                RoleName = "General Director"
            });
            participatorsResponse.Add(new ParticipatorsResponse()
            {
                UserEmail = "[email protected]",
                RoleName = "CEO"
            });
            participatorsResponse.Add(new ParticipatorsResponse()
            {
                UserEmail = "[email protected]",
                RoleName = "Strategy Director"
            });
            participatorsResponse.Add(new ParticipatorsResponse()
            {
                UserEmail = "[email protected]",
                RoleName = "Deliver"
            });

            List<StudyReponse> studyResponse = new List<StudyReponse>();
            studyResponse.Add(new StudyReponse()
            {
                StudyCode = "order66",
                Participators = participatorsResponse
            });

            return new StudiesResponse()
            {
                Studies = studyResponse
            };
        }
    }

我没有想法，我找不到任何示例这样的场景...

编辑： 好的，我找到了一个我认为可以使用的东西的帖子：

测试：

        [Test]
        public void GetAllStudiesTest()
        {
            var _data = new Mock<IDataRepository>();
            _data.Setup(m => m.GetEntitiesAsync<StudyDAO>()).Returns(Task.FromResult(_studies));
            _data.Setup(m => m.GetEntitiesAsync<RoleUserDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _roleUsers.Where(x => x.Id == obj.Id));
            _data.Setup(m => m.GetEntityAsync<UserDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _users.Where(x => x.Id == obj.Id).FirstOrDefault());
            _data.Setup(m => m.GetEntityAsync<RoleDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _roles.Where(x => x.Id == obj.Id).FirstOrDefault());

            var _logger = Mock.Of<ILogger<StudyService>>();
            StudyService _service = new StudyService(_logger, _data.Object);

            var result = _service.GetAllStudies();

            Assert.True(comparator.Compare(result, MockedDAOs.GetMockedStudiesResponse()).AreEqual); 
        }

但是它不起作用。使用此代码，第一个调用恢复IEnumerable的返回0结果...我会继续寻找。任何帮助将不胜感激。

Answer 1

我设法解决了这个问题。测试的正确代码是：

        [Test]
        public void GetAllStudiesTest()
        {
            var _data = new Mock<IDataRepository>();
            _data.Setup(m => m.GetEntitiesAsync<StudyDAO>()).Returns(Task.FromResult(_studies));
            _data.Setup(m => m.GetEntitiesAsync<RoleUserDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _roleUsers.Where(x => x.StudyId == (int)obj.GetType().GetProperty("StudyId").GetValue(obj, null)));
            _data.Setup(m => m.GetEntityAsync<UserDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _users.Where(x => x.Id == (int)obj.GetType().GetProperty("Id").GetValue(obj, null)).FirstOrDefault());
            _data.Setup(m => m.GetEntityAsync<RoleDAO>(It.IsAny<Object>())).ReturnsAsync((Object obj) => _roles.Where(x => x.Id == (int)obj.GetType().GetProperty("Id").GetValue(obj, null)).FirstOrDefault());

            var _logger = Mock.Of<ILogger<StudyService>>();
            StudyService _service = new StudyService(_logger, _data.Object);

            StudiesResponse result = _service.GetAllStudies().Result;
            StudiesResponse expectedResult = MockedDAOs.GetMockedStudiesResponse();

            var comparation = comparator.Compare(result, expectedResult);

            Assert.True(comparation.AreEqual); 
        }

您可以看到我正在使用 kellermansoftware.com parenetObjects 进行断言，这就是为什么我必须修改测试方法，从linq whereSelect响应中解析参与者到列表，因此比较器不会看到我构造的预期响应有所不同。

这是略有不同的方法代码：

        public async Task<StudiesResponse> GetAllStudies()
        {
            StudiesResponse studies = new StudiesResponse();
            List<StudyReponse> list = new List<StudyReponse>();
            foreach (StudyDAO study in await _dataRepository.GetEntitiesAsync<StudyDAO>())
            {
                StudyReponse resp = new StudyReponse()
                {
                    StudyCode = study.StudyCode,
                    Participators = _dataRepository.GetEntitiesAsync<RoleUserDAO>(new { @StudyId = study.Id }).Result.Select(x => new ParticipatorsResponse()
                    {
                        UserEmail = _dataRepository.GetEntityAsync<UserDAO>(new { @Id = x.Id }).Result.Email,
                        RoleName = _dataRepository.GetEntityAsync<RoleDAO>(new { @Id = x.Id }).Result.Name
                    }).ToList()
                };
                list.Add(resp);
            }
            studies.Studies = list;
            return studies;
        }