无需调用Add方法测试方法删除 [英] Testing Remove method without a call to Add method

问题描述

我写测试类这就是管理标签对象树：

 公共类标签
 {
酒店的公共虚拟INT标识{搞定;组; } 
公共虚拟字符串描述{搞定;组; } 
私人的IList<标记和GT;孩子=新的List<吊牌及GT;（）; 
公共虚拟IEnumerable的<标记和GT;儿童
 {
 {返回儿童.ToArray（）;} 
} 
公共无效AddChildTag（标签的孩子）
 {
 children.Add（子）; 
} 
公共无效RemoveChildTag（标签的孩子）
 {
 children.Remove（小孩）; 
} 
} 
  

正如你可以看到设置父的唯一模式属性是通过 AddChildTag 法，这正是我想要的，我的问题是单元测试：因为每个测试应该是原子的，我怎么能测试 RemoveChildTag 方法？

只有我看到的方法是add方法后来到删除一个电话，但以这种方式，如果添加因为一些错误，删除，甚至会导致测试失败，那么原子就会丢失。

那怎么可以呢？

修改结果
我删除parent属性从标签对象，因为我不再用这根据使用的解决方案
部分测试的NUnit和FluentAssertion

  [测试] 
公共无效AddChildTagAddsChildren（）
 {
 //安排
标签父=新标签（）; 
标记的孩子=新标签（）; 
 //法案
 parent.AddChildTag（小孩）; 
 //断言
 parent.Children.Should（）含（小孩）; 
} 
 [测试] 
公共无效RemoveChildTagRemovesAddedChildren（）
 {
 //安排
标签父=新标签（）; 
标记的孩子=新标签（）; 
 parent.AddChildTag（小孩）; 
 //法案
 parent.RemoveChildTag（小孩）; 
 //断言
 parent.Children.Should（）NotContain（子）。 
} 
 [测试] 
公共无效RemoveChildTagThrowsNothingWhenNoChild（）
 {
 //安排
标签父=新标签（）; 
标记的孩子=新标签（）; 
 //法案
行动removeChild之=（）=> parent.RemoveChildTag（小孩）; 
 //断言
 RemoveChild.ShouldNotThrow（）; 
} 
  

解决方案

您的单元测试应该反映实际的使用你的类的案件。你的消费者将如何使用 RemoveChildTag 的方法？这使得更多的意义吗？ ？这是你如何使用对象的集合

  VAR父=新标签（）; 
 //后面
 parent.RemoveChildTag（小孩）; 
  

...或

  VAR父=新标签（）; 
 parent.AddChildTag（小孩）; 
 //后面
 parent.RemoveChildTag（小孩）; 
  

您的消费者将删除对象，他们的之前添加即可。这是您的使用情况下，的删除删除先前添加的元素的（请注意，它也产生优异的测试方法名）。

添加和删除方法往往相辅相成的 - 你无法测试一个没有其他

I am writing test for a class thats manage trees of Tag objects:

public class Tag
{
    public virtual int Id { get; set; }
    public virtual string Description{ get; set; }
    private IList<Tag> children = new List<Tag>();
    public virtual IEnumerable<Tag> Children
    {
        get {return children .ToArray();}
    }
    public void AddChildTag(Tag child)
    {
        children.Add(child);
    }
    public void RemoveChildTag(Tag child)
    {
        children.Remove(child);
    }
}

As you can see the only mode to set the parent property is via the AddChildTag method and this is exactly what i want, my problem is in unit test: since every test should be atomic, how can i test the RemoveChildTag method?

Only way i see is a call to the add method and later to the remove, but in this way if Add as some errors, even the test of remove will fail, so atomicity is lost.

How can that be done?

EDIT
I removed parent property from Tag object, since i no more use it Some test according to solution using NUnit and FluentAssertion

    [Test]
    public void AddChildTagAddsChildren()
    {
        //Arrange
        Tag parent = new Tag();
        Tag child = new Tag();
        //Act
        parent.AddChildTag(child);
        //Assert
        parent.Children.Should().Contain(child);
    }
    [Test]
    public void RemoveChildTagRemovesAddedChildren()
    {
        //Arrange
        Tag parent = new Tag();
        Tag child = new Tag();
        parent.AddChildTag(child);
        //Act
        parent.RemoveChildTag(child);
        //Assert
        parent.Children.Should().NotContain(child);
    }
    [Test]
    public void RemoveChildTagThrowsNothingWhenNoChild()
    {
        //Arrange
        Tag parent= new Tag();
        Tag child= new Tag();
        //Act
        Action RemoveChild = () => parent.RemoveChildTag(child);
        //Assert
        RemoveChild.ShouldNotThrow();
    }

解决方案

Your unit tests should reflect actual use cases of your class. How will your consumers use RemoveChildTag method? Which makes more sense? Which is how you'd use collection of objects?

var parent = new Tag();
// later
parent.RemoveChildTag(child);

… or

var parent = new Tag();
parent.AddChildTag(child);
// later
parent.RemoveChildTag(child);

Your consumers will remove objects they previously added. This is your use case, "Remove removes elements previously added" (note that it also produces excellent test method name).

Add and Remove methods are often complementary - you can't test one without the other.

这篇关于无需调用Add方法测试方法删除的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！