Testul unității este doar testarea unei unități specifice. Deci, dacă scrieți o specificație pentru clasa A, este ideal dacă clasa A nu are versiunile reale concrete ale clasei B și C.
Ok, am observat că tag-ul pentru această întrebare include C ++/Python, dar principiile sunt aceleași:
public class A : InterfaceA
{
InterfaceB b;
InterfaceC c;
public A(InterfaceB b, InterfaceC c) {
this._b = b;
this._c = c; }
public string SomeOperation(string input)
{
return this._b.SomeOtherOperation(input)
+ this._c.EvenAnotherOperation(input);
}
}
Deoarece sistemul A de mai sus injecta interfețe la sistemele B și C, puteți testa unitatea doar sistemul A, fără ca funcționalitatea reală să fie executată de orice alt sistem. Acesta este testul unitar.
Iată o modalitate inteligentă pentru abordarea unui sistem de la creație până la finalizare, cu o altă specificație Când se specifică pentru fiecare piesă de comportament:
public class When_system_A_has_some_operation_called_with_valid_input : SystemASpecification
{
private string _actualString;
private string _expectedString;
private string _input;
private string _returnB;
private string _returnC;
[It]
public void Should_return_the_expected_string()
{
_actualString.Should().Be.EqualTo(this._expectedString);
}
public override void GivenThat()
{
var randomGenerator = new RandomGenerator();
this._input = randomGenerator.Generate();
this._returnB = randomGenerator.Generate();
this._returnC = randomGenerator.Generate();
Dep().Stub(b => b.SomeOtherOperation(_input))
.Return(this._returnB);
Dep().Stub(c => c.EvenAnotherOperation(_input))
.Return(this._returnC);
this._expectedString = this._returnB + this._returnC;
}
public override void WhenIRun()
{
this._actualString = Sut.SomeOperation(this._input);
}
}
Așadar, în concluzie, o singură unitate/specificație poate avea mai multe comportamente, iar specificația crește atunci când dezvolți unitatea/sistemul; iar dacă sistemul dvs. este testat depinde de alte sisteme concrete din interiorul acestuia, aveți grijă.