C# 单元测试模拟方法不起作用（为什么？）

我正在测试一个控制器

那是我的控制器：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Pmanager.Models;
using RBravoDLL;
using System.Globalization;
using Resources;
using Pmanager.Helpers;

namespace Pmanager.Controllers
{
    [Authorize]
    public class GroupController : DefaultController
    {
        private Group m_group;
        public Group p_group
        {
            get
            {
                if (m_group == null)
                {
                    m_group = new Group();
                }
                return m_group;
            }
            set
            {
                m_group = value;
            }
        }

        [HttpPost]
        [AllowAdminOperationsOnly]
        public ActionResult NewGroup(Group _group)
        {
            try
            {
                int id_group = 0;
                if (ModelState.IsValid)
                {
                    id_group = p_group.NewGroup(_group);
                }
                else
                {
                    ThrowErrorMessages();
                }
                return Json(new
                {
                    status = "success",
                    title = @Resources.Global.success,
                    text = @Resources.Groups.success_creating_group,
                    messageType = "success",
                    id_group = id_group
                }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception err)
            {
                return ErrorHelper(@Resources.Global.error, @Resources.Groups.error_creating_group, err.Message);
            }
        }
    }
}

这就是我的模型：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Resources;
using System.Security.AccessControl;
using Pmanager.DAL;

namespace Pmanager.Models
{
    public enum Permission
    {
        Not = 0, Read = 1, Analyse = 2, Edit = 3, Admin = 4
    }

    public class Group : IGroup
    {
        public int ID { get; set; }
        [Required]
        [StringLength(50)]
        [Index(IsUnique = true)]
        public string Name { get; set; }
        [Required]
        public bool IsOperations { get; set; }
        public Permission? OperationPermission { get; set; }

        public virtual ICollection<UserGroup> UserGroups { get; set; }

        public int NewGroup(Group group)
        {
            RioBravoManagerContext ctx = new RioBravoManagerContext();
            ctx.Groups.Add(group);
            ctx.SaveChanges();
            return group.ID;
        }

        public void UpdateGroup(Group group)
        {
            RioBravoManagerContext ctx = new RioBravoManagerContext();
            if (ctx.Groups.Where(g => g.ID == group.ID).Any())
            {
                Group cgroup = ctx.Groups.Where(g => g.ID == group.ID).SingleOrDefault();
                cgroup.Name = group.Name;
                cgroup.IsOperations = group.IsOperations;
                cgroup.OperationPermission = group.OperationPermission;
            }
            else
            {
                ctx.Groups.Add(group);
            }
            ctx.SaveChanges();
        }
    }

    public interface IGroup
    {
        void UpdateGroup(Group group);
        int NewGroup(Group group);
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用System.Web；
使用System.ComponentModel.DataAnnotations；
使用System.ComponentModel.DataAnnotations.Schema；
利用资源；
使用System.Security.AccessControl；
使用Pmanager.DAL；
命名空间Pmanager.Models
{
公共枚举权限
{
Not=0，Read=1，analysis=2，Edit=3，Admin=4
}
公共类组：IGroup
{
公共int ID{get；set；}
[必需]
[长度（50）]
[索引（IsUnique=true）]
公共字符串名称{get；set；}
[必需]
公共布尔等运算{get；set；}
公共权限？操作权限{get；set；}
公共虚拟ICollection用户组{get；set；}
公共int新组（组）
{
RioBravoManagerContext ctx=新的RioBravoManagerContext（）；
ctx.Groups.Add（组）；
ctx.SaveChanges（）；
返回组ID；
}
公共无效更新组（组）
{
RioBravoManagerContext ctx=新的RioBravoManagerContext（）；
if（ctx.Groups.Where（g=>g.ID==group.ID）.Any（））
{
groupcgroup=ctx.Groups.Where（g=>g.ID==Group.ID）.SingleOrDefault（）；
cgroup.Name=group.Name；
cgroup.IsOperations=group.IsOperations；
cgroup.OperationPermission=group.OperationPermission；
}
其他的
{
ctx.Groups.Add（组）；
}
ctx.SaveChanges（）；
}
}
公共接口IGroup
{
无效更新组（组）；
int新集团（集团）；
}
}

测试类别为：

using System.Web.Mvc;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Pmanager.Controllers;
using Pmanager.Tests.Helpers;
using System.Web.Script.Serialization;
using System.Collections.Generic;
using Pmanager.Models;
using System;
using Moq;

namespace Pmanager.Tests.Controllers
{
    [TestClass]
    public class GroupControllerTest
    {
        JavaScriptSerializer m_serializer;
        ControllerContext m_context;

        [TestInitialize]
        public void TestInitialize()
        {
            m_serializer = new JavaScriptSerializer();
            m_context = TestModelHelper.AdminControllerContext();
        }

        public void GroupController_UpdateGroup_Valid()
        {
            // Arrange
            GroupController controller = new GroupController();
            controller.ControllerContext = m_context;

            var _group = new Mock<IGroup>();
            _group.Setup(g => g.UpdateGroup(It.IsAny<Group>())).Callback((Group group) => { });

            controller.p_group = _group.Object as Group;

            Group _gp = new Group
            {
                ID = 1,
                Name = "Group Name",
                IsOperations = false,
                OperationPermission = Permission.Read
            };

            // Act
            var result = (JsonResult)controller.UpdateGroup(_gp);
            JsonGroup resultFund = m_serializer.Deserialize<JsonGroup>(m_serializer.Serialize(result.Data));

            // Assert
            Assert.IsNotNull(result.Data, "There should be some data for the JsonResult");
            Assert.IsNotNull(resultFund.status, "JSON record does not contain 'status' required property.");
            Assert.IsTrue(resultFund.status.Equals("success"), "status must be 'success'");
        }

        [TestMethod]
        public void GroupController_UpdateGroup_Invalid()
        {

            // Arrange
            GroupController controller = new GroupController();
            controller.ControllerContext = m_context;
            var _group = new Mock<IGroup>();
            _group.Setup(g => g.UpdateGroup(It.IsAny<Group>())).Callback((Group group) => { });
            controller.p_group = _group.Object as Group;
            controller.ModelState.AddModelError("Name", @"Missing Name");

            Group _gp = new Group
            {
                ID = 1,
                IsOperations = false,
                OperationPermission = Permission.Read
            };

            // Act
            var result = (JsonResult)controller.UpdateGroup(_gp);
            JsonGroup resultFund = m_serializer.Deserialize<JsonGroup>(m_serializer.Serialize(result.Data));

            // Assert
            Assert.IsNotNull(result.Data, "There should be some data for the JsonResult");
            Assert.IsNotNull(resultFund.status, "JSON record does not contain 'status' required property.");
            Assert.IsTrue(resultFund.status.Equals("fail"), "status must be 'fail'");
        }

        [TestMethod]
        public void GroupController_NewGroup_Valid()
        {

            // Arrange
            GroupController controller = new GroupController();
            controller.ControllerContext = m_context;

            var _fakegroup = new Mock<IGroup>() { CallBase = false };
            _fakegroup.Setup(g => g.NewGroup(It.IsAny<Group>())).Returns<Group>((group) => { return 0; }).Verifiable();

            controller.p_group = _fakegroup.Object as Group;

            Group _gp = new Group
            {
                ID = 0,
                Name = "Group Name",
                IsOperations = false,
                OperationPermission = Permission.Read
            };

            // Act
            var result = (JsonResult)controller.NewGroup(_gp);
            JsonGroup resultFund = m_serializer.Deserialize<JsonGroup>(m_serializer.Serialize(result.Data));

            // Assert
            Assert.IsNotNull(result.Data, "There should be some data for the JsonResult");
            Assert.IsNotNull(resultFund.status, "JSON record does not contain 'status' required property.");
            Assert.IsTrue(resultFund.status.Equals("success"), "status must be 'success'");
        }

        [TestMethod]
        public void GroupController_NewGroup_Invalid()
        {

            // Arrange
            GroupController controller = new GroupController();
            controller.ControllerContext = m_context;
            var _group = new Mock<IGroup>();
            _group.Setup(g => g.NewGroup(It.IsAny<Group>())).Returns((Group group) => { return 0; });
            controller.p_group = _group.Object as Group;
            controller.ModelState.AddModelError("Name", @"Missing Name");

            Group _gp = new Group
            {
                ID = 1,
                IsOperations = false,
                OperationPermission = Permission.Read
            };

            // Act
            var result = (JsonResult)controller.NewGroup(_gp);
            JsonGroup resultFund = m_serializer.Deserialize<JsonGroup>(m_serializer.Serialize(result.Data));

            // Assert
            Assert.IsNotNull(result.Data, "There should be some data for the JsonResult");
            Assert.IsNotNull(resultFund.status, "JSON record does not contain 'status' required property.");
            Assert.IsTrue(resultFund.status.Equals("fail"), "status must be 'fail'");
        }
    }

    public class JsonGroup
    {
        public string status { get; set; }
        public List<SimpleGroup> groups { get; set; }
    }
}

使用System.Web.Mvc；
使用Microsoft.VisualStudio.TestTools.UnitTesting；
使用Pmanager.Controllers；
使用Pmanager.Tests.Helpers；
使用System.Web.Script.Serialization；
使用System.Collections.Generic；
使用Pmanager.Models；
使用制度；
使用最小起订量；
命名空间Pmanager.Tests.Controllers
{
[测试类]
公共类GroupControllerTest
{
JavaScriptSerializer m_serializer；
控制器上下文m_上下文；
[测试初始化]
public void TestInitialize（）
{
m_serializer=新的JavaScriptSerializer（）；
m_context=TestModelHelper.AdminControllerContext（）；
}
public void GroupController\u UpdateGroup\u Valid（）
{
//安排
GroupController=新的GroupController（）；
controller.ControllerContext=m_上下文；
var_group=new Mock（）；
_group.Setup（g=>g.UpdateGroup（It.IsAny（））.Callback（（组组）=>{}）；
controller.p_group=_group.Object作为组；
组_gp=新组
{
ID=1，
Name=“组名”，
等操作=假，
OperationPermission=权限。读取
};
//表演
var result=（JsonResult）controller.UpdateGroup（_gp）；
JsonGroup resultFund=m_serializer.Deserialize（m_serializer.Serialize（result.Data））；
//断言
Assert.IsNotNull（result.Data，“JsonResult应该有一些数据”）；
IsNotNull（resultFund.status，“JSON记录不包含'status'必需属性”）；
Assert.IsTrue（resultFund.status.Equals（“成功”），“状态必须为‘成功’”）；
}
[测试方法]
public void GroupController\u UpdateGroup\u Invalid（）
{
//安排
GroupController=新的GroupController（）；
controller.ControllerContext=m_上下文；
var_group=new Mock（）；
_group.Setup（g=>g.UpdateGroup（It.IsAny（））.Callback（（组组）=>{}）；
controller.p_group=_group.Object作为组；
controller.ModelState.AddModelError（“名称”，@“缺少名称”）；
组_gp=新组
{
ID=1，
等操作=假，
OperationPermission=权限。读取
};
//表演
var result=（JsonResult）controller.UpdateGroup（_gp）；
JsonGroup resultFund=m_serializer.Deserialize（m_serializer.Serialize（result.Data））；
//断言
Assert.IsNotNull（result.Data，“JsonResult应该有一些数据”）；
IsNotNull（resultFund.status，“JSON记录不包含'status'必需属性”）；
Assert.IsTrue（resultFund.status.Equals（“失败”），“状态必须为“失败”）；
}
[测试方法]
public void GroupController\u NewGroup\u Valid（）
{
//安排
GroupController=新的GroupController（）；
controller.ControllerContext=m_上下文；
var_fakegroup=newmock（）{CallBase=false}；
_Setup（g=>g.NewGroup（It.IsAny（））。返回（（group）=>{return 0；}）。可验证（）；
controller.p_group=_fakegroup.Object作为组；
组_gp=新组
{
ID=0，
Name=“组名”，
等操作=假，
OperationPermission=权限。读取
};
//表演
var result=（JsonResult）controller.NewGroup（_gp）；
JsonGroup resultFund=m_serializer.Deserialize（m_serializer.Serialize（result.Data））；
//断言
Assert.IsNotNull（result.Data，“JsonResult应该有一些数据”）；
IsNotNull（resultFund.status，“JSON记录不包含'status'必需属性”）；
Assert.IsTrue（resultFund.status.Equals（“成功”），“状态必须为‘成功’”）；
}
[测试
var _fakegroup = new Mock<IGroup>() { CallBase = false };
_fakegroup.Setup(g => g.NewGroup(It.IsAny<Group>())).Returns<Group>((group) => { return 0; }).Verifiable();

public interface IGroupService {
    void UpdateGroup(Group group);
    int NewGroup(Group group);
}

public class GroupService : IGroupService {

    public int NewGroup(Group group) {
        RioBravoManagerContext ctx = new RioBravoManagerContext();
        ctx.Groups.Add(group);
        ctx.SaveChanges();
        return group.ID;
    }

    public void UpdateGroup(Group group) {
        RioBravoManagerContext ctx = new RioBravoManagerContext();
        if (ctx.Groups.Where(g => g.ID == group.ID).Any()) {
            Group cgroup = ctx.Groups.Where(g => g.ID == group.ID).SingleOrDefault();
            cgroup.Name = group.Name;
            cgroup.IsOperations = group.IsOperations;
            cgroup.OperationPermission = group.OperationPermission;
        } else {
            ctx.Groups.Add(group);
        }
        ctx.SaveChanges();
    }
}

public enum Permission {
    Not = 0, Read = 1, Analyse = 2, Edit = 3, Admin = 4
}

public class Group {
    public int ID { get; set; }
    [Required]
    [StringLength(50)]
    [Index(IsUnique = true)]
    public string Name { get; set; }
    [Required]
    public bool IsOperations { get; set; }
    public Permission? OperationPermission { get; set; }

    public virtual ICollection<UserGroup> UserGroups { get; set; }
}

[Authorize]
public class GroupController : DefaultController {
    private readonly IGroupService groupService;

    public GroupController(IGroupService groupService) {
        this.groupService = groupService;
    }

    [HttpPost]
    [AllowAdminOperationsOnly]
    public ActionResult NewGroup(Group _group) {
        try {
            int id_group = 0;
            if (ModelState.IsValid) {
                id_group = groupService.NewGroup(_group);
            } else {
                ThrowErrorMessages();
            }
            return Json(new
            {
                status = "success",
                title = @Resources.Global.success,
                text = @Resources.Groups.success_creating_group,
                messageType = "success",
                id_group = id_group
            }, JsonRequestBehavior.AllowGet);
        } catch (Exception err) {
            return ErrorHelper(@Resources.Global.error, @Resources.Groups.error_creating_group, err.Message);
        }
    }
}

[TestMethod]
public void GroupController_NewGroup_Valid() {

    // Arrange

    var _fakegroup = new Mock<IGroupService>();
    _fakegroup.Setup(g => g.NewGroup(It.IsAny<Group>())).Returns(1).Verifiable();

    var controller = new GroupController(_fakegroup.Object);

    var _gp = new Group {
        ID = 0,
        Name = "Group Name",
        IsOperations = false,
        OperationPermission = Permission.Read
    };

    // Act
    var result = controller.NewGroup(_gp) as JsonResult;

    // Assert

    _fakegroup.Verify();

    Assert.IsNotNull(result.Data, "There should be some data for the JsonResult");

    dynamic data = result.Data;

    Assert.IsNotNull(data.status, "JSON record does not contain 'status' required property.");
    Assert.IsTrue(data.status.Equals("success"), "status must be 'success'");
}

   private IGroup m_group;
    public IGroup p_group
    {
        get
        {
            if (m_group == null)
            {
                m_group = new Group();
            }
            return m_group;
        }
        set
        {
            m_group = value;
        }
    }