Come posso fare il mio test di unità non riescono se posso aggiungere qualcosa al mio codice?

Question

Voglio che i miei test di unità per coprire il mio POCO.

Come devo testarli?

Che cosa succede se aggiungo una nuova proprietà? Come rendere la mia prova?

Test le proprietà ei metodi che conosco, ma il problema è, come per assicurarsi che i miei test falliscono è nulla viene aggiunto al mio poco di.

Answer 1

Dalla lettura della tua domanda, si sia fraintendono quello che un POCO è, o si fraintendono unit testing.

A POCO è solo un vecchio oggetto antiquato. Ha stato e il comportamento. È unità di testare lo stato mettendo valori (impostazione) per le proprietà, e affermando che il valore è quello che ti aspettavi. È un comportamento unit test, affermando aspettative contro i metodi.

Qui sarebbe un esempio semplificato di un POCO e le sue prove. Si noti che non c'è più il codice di prova di codice di implementazione. Quando unit testing è fatto bene (TDD), questo è il caso.

public class Person
{
    private Name name = Name.Empty;
    private Address address = Address.Empty;
    private bool canMove;

    public Name Name
    {
        set { name = value; }
        get { return name; }
    }

    public Address Address
    {
        private set { address = value; }
        get { return address; }
    }

    public bool CanMove
    {
        set { canMove = value; }
        get { return value; }
    }

    public bool MoveToNewAddress(Address newAddress)
    {
        if (!CanMove) return false;
        address = newAddress;
        return true;
    }
}

[TestFixture]
public class PersonTests
{
    private Person toTest;
    private readonly static Name NAME = new Name { First = "Charlie", Last = "Brown" };
    private readonly static Address ADDRESS =
        new Address {
            Line1 = "1600 Pennsylvania Ave NW",
            City = "Washington",
            State = "DC",
            ZipCode = "20500" };

    [SetUp]
    public void SetUp()
    {
        toTest = new Person;
    }

    [Test]
    public void NameDefaultsToEmpty()
    {
        Assert.AreEqual(Name.Empty, toTest.Name);
    }

    [Test]
    public void CanMoveDefaultsToTrue()
    {
        Assert.AreEqual(true, toTest.CanMove);
    }

    [Test]
    public void AddressDefaultsToEmpty()
    {
        Assert.AreEqual(Address.Empty, toTest.Address);
    }

    [Test]
    public void NameIsSet()
    {

        toTest.Name = NAME;
        Assert.AreEqual(NAME, toTest.Name);
    }

    [Test]
    public void CanMoveIsSet()
    {
        toTest.CanMove = false;
        Assert.AreEqual(false, toTest.CanMove);
    }

    [Test]
    public void AddressIsChanged()
    {
        Assert.IsTrue(toTest.MoveToNewAddress(ADDRESS));
        Assert.AreEqual(ADDRESS, toTest.Address);
    }

    [Test]
    public void AddressIsNotChanged()
    {
        toTest.CanMove = false;
        Assert.IsFalse(toTest.MoveToNewAddress(ADDRESS));
        Assert.AreNotEqual(ADDRESS, toTest.Address);
    }
}

Per effettuare il test sicuro prima, stub metodo o proprietà, ma non attuare alcun comportamento. Eseguire i test, vederli fallire, quindi aggiungere nel comportamento di una riga alla volta finché non passa. Una volta che passa, stop. Non scrivere più codice a meno che non si scrive più test (a meno che non si sta refactoring, nel qual caso non si aggiunge il comportamento).

Answer 2

Il test è verificare se su ciò che è scritto è in grado di fare quello che dovrebbe fare, niente di più, niente di meno. Quindi, se si scrive un codice, lo si fa per un motivo. I suoi test dovrebbero riflettere sul fatto che il codice corrisponde in effetti la ragione che hai scritto il codice per. Questo è tutto, non c'è altro. I.o.w .: se si scrive un gruppo di classi, è necessario verificare se il comportamento che hai scritto è davvero corretto rispetto a quello che il comportamento dovrebbe fare.

Answer 3

1. Io credo che non si dovrebbe provare il quadro con il proprio codice per esempio, se si dispone di un auto Proprietà generato in questo modo:

   public string Name
   {get;set;}
   

   Non è necessario avere un test metodo per vedere se funziona bene.

2. Non si dovrebbe verificare lo stato interiore di voi classe invece è necessario verificare il suo comportamento.
3. A volte (qualcuno potrebbe dire sempre) è meglio scrivere il test prima di scrivere il modo code.This bisogna capire cosa si vuole fare per invece di capire come farlo. (Questo approccio è chiamato Test Driven Development)

Ecco il ciclo TDD:

• Scrivi il test e ottenere un segnale rosso
• Scrivi il codice e ottenere un segnale verde
• refactoring del codice e si dovrebbe ottenere un segnale verde

Answer 4

Se si desidera aggiungere una nuova funzionalità per la classe, scrivere un test che non riesce perché la funzionalità non è stata attuata, quindi implementare la funzione e vedere il passaggio di prova.

Oppure ...

metriche eseguire codice-copertura come parte della costruzione. Essi indicheranno se il gas codice stato aggiunto senza essere coperti dai test.

Oppure ...

Esegui test di mutazione come parte della costruzione. Essi indicheranno se tutte le prove che coprono il codice sono solo in esecuzione attraverso di essa e non effettivamente testare nulla.

o tutto quanto sopra.

Answer 5

Forse da pocos volevi dire DTOs, nel qual caso la risposta sarebbe:

No non si dovrebbe testare le vostre DTOs - piuttosto, provare i servizi che lavorano con loro

.