Как выполнить модульное тестирование Dispose() с использованием отражения?

Question

Я хочу написать модульные тесты для класса, который реализует IDisposable. Класс имеет множество частных полей, которые также реализуют IDisposable. В своем тесте я хочу проверить, что, когда я звоню Dispose(), он правильно вызывает Dispose() во всех своих IDisposable-полях. По сути, я хочу, чтобы мой модульный тест выглядел так:

var o = new ObjectUnderTest(); 
o.Dispose(); 
Assert.IsFalse(ObjectHasUndisposedDisposables(o)); 

Я думал об использовании отражения для достижения этого. Похоже, это было бы довольно распространенным требованием, но я не могу найти никаких примеров этого.

Кто-нибудь это пробовал?

EDIT - Я не хочу, чтобы вводить Disposables в тестируемый класс.

Answer 1

Единственный способ проверить поведение, которое вы ищете без какого-либо рефакторинга в своем коде, - использовать инструменты ткачества кода. Например; Типовой изолятор, MsFakes и т. Д. ...

Следующий фрагмент кода показывает способ проверить поведение с помощью MsFakes:

[TestMethod] 
public void TestMethod1() 
{ 
    var wasCalled = false; 
    using (ShimsContext.Create()) 
    { 
     ForMsFakes.Fakes.ShimDependency.AllInstances.Dispose = dependency => 
     { 
      wasCalled = true; 
     }; 

     var o = new ObjectUnderTest(); 

     o.Dispose(); 
    } 

    Assert.IsTrue(wasCalled); 
} 

public class Dependency : IDisposable 
{ 
    public void Dispose() {} 
} 

public class ObjectUnderTest: IDisposable 
{ 
    private readonly Dependency _d = new Dependency(); 

    public void Dispose() 
    { 
     _d.Dispose(); 
    } 
} 

Answer 2

Нет общего способа справиться с этим. интерфейс IDisposeable не требует, чтобы вы отслеживали, был ли вызов dispose или нет.

Единственный способ, которым я мог бы подумать, что вы могли бы справиться с этим, - это все эти одноразовые классы, в которые вводится инъекция зависимости. Если вы это сделали, вы могли бы издеваться над введенными классами и отслеживать, если вызов был выведен.

[TestMethod] 
    public void TestAllDisposeablesAreDisposed() 
    { 
     var fooMock = new Mock<IFoo>(); 
     fooMock.Setup(x=>x.Dispose()) 
      .Verifiable("Dispose never called on Foo"); 

     var barMock = new Mock<IBar>(); 
     barMock.Setup(x => x.Dispose()) 
      .Verifiable("Dispose never called on Bar"); 

     using (var myClass = new MyClass(fooMock.Object, barMock.Object)) 
     { 
     } 

     fooMock.Verify(); 
     barMock.Verify(); 
    } 

Answer 3

Вы пытаетесь проверить, работает ли ваше IDisposable поведения в пределах данного класса, или вы хотите, чтобы проверить, является ли или нет на самом деле вызывает то, что управляет вашим одноразовым класс IDisposable? Это действительно, если вы не уверены, что его звонят, и вы хотите быть уверенным. (Я написал тесты для этого.)

Для этого вы можете создать простой класс, как это:

public class DisposeMe : IDisposable 
{ 
    public bool Disposed {get;set;} 
    public void Dispose() 
    { 
     Disposed = true; 
    } 
} 

Тогда вы можете просто утверждать, что Disposed верно, когда вы ожидаете, что утилизированы.

Например, я использовал это, когда создаю классы из контейнера DI, и хочу подтвердить, что, когда класс, созданный контейнером, освобождается, его удаленные зависимости будут удалены. Я не могу отслеживать это в конкретных конкретных классах, но я могу проверить, что контейнер DI делает то, что, как я полагаю, должен делать. (Это не тест, который я бы написал снова и снова. Как только я подтвердил ожидаемое поведение Виндзора, например, я не собираюсь писать для него единичные тесты.)

Answer 4

Если вы не желаете используйте инъекцию зависимостей в конструкторе, потому что это заставит вас изменить свой интерфейс, после чего вы сможете вводить свои зависимости через свойства. Дайте вашей собственности значение по умолчанию, если ничего не вводится, так что, когда вы используете класс, который вам не нужно помнить, чтобы пройти в реальной реализации

E.g.

public class ObjectUnderTest : IDisposable 
{ 
    private IObjectNeedingDisposal _foo; 

    public IObjectNeedingDisposal Foo 
    { 
     get { return _foo ?? (_foo = new ObjectNeedingDisposal()); } 
     set { _foo = value; } 
    } 

    public void MethodUsingDisposable() 
    { 
     Foo.DoStuff(); 
    } 

    public void Dispose() 
    { 
     Foo.Dispose(); 
    } 
} 

В своих тестах вы могли бы создать экземпляр вашего объекта и передать в макете версии своего класса, но в реальной реализации, можно оставить его отключенным и это будет по умолчанию к экземпляру типа вы хотели