Cycle de développement

Cycle en cascade

Cycle en V

Agile

Types de tests

Origines

Origines

  • L'environnement de test SUnit   pour le langage Smalltalk => 1994

  • JUnit => 1997

  • xUnit : Ensemble des frameworks de tests unitaires

Avoir un retour rapide

Tester unitairement

Vérifier que le résultat = attentes

Sécuriser la maintenance

Documenter le code

CI / CD

(Continuous Integration / Continuous Deployment)

10 Commandements

10 Commandements

  • Un test unitaire doit être véritablement unitaire

  • Si une classe est difficile à tester, il est temps de faire du refactoring

  • Un test unitaire doit s’exécuter le plus rapidement possible != test d’intégration

  • Chouchoutez vos tests unitaires
    • Faites du refactoring sur leur code
    • Respectez les bonnes pratiques

  • Isolez les dépendances de la classe testée grâce à l’injection de dépendances.

10 Commandements

  • Ne testez qu’un comportement à la fois

  • Pensez à utiliser un framework de mocks pour injecter les dépendances sous forme de bouchons

  • Identifiez précisément les étapes setup, exercise, verify, teardown dans votre code

  • Ne vous concentrez pas sur une couverture de code à 100%

  • Ne développez pas vos tests unitaires « plus tard »

Mauvaises pratiques

  • Écrire du code incompréhensible dans les classes de test

  • Avoir des tests dépendants du temps

  • Négliger la vraie sémantique des types utilisés

  • Faire trop de tests

  • Faux-positifs

TDD (Test Driven Development)

TDD (Test Driven Development)

Intérêts

  • Préciser les spécifications du code

  • S'assurer que le code produit est testable unitairement

  • Peut s’utiliser avec l’XP (eXtreme programming)

Exemples

RUnit

foo <- function(x) {
    x <- x*x
    x <- 2*x
    return(x)
}
test.foo <- function() {
    checkTrue(is.numeric(foo(1:10)))
    checkEquals(length(foo(1:10)), 10)
    checkEqualsNumeric(foo(1), 2)
}

Scala

import collection.mutable.Stack
import org.scalatest._

class ExampleSpec extends FlatSpec with Matchers {

  "A Stack" should "pop values in last-in-first-out order" in {
    val stack = new Stack[Int]
    stack.push(1)
    stack.push(2)
    stack.pop() should be (2)
    stack.pop() should be (1)
  }

  it should "throw NoSuchElementException if an empty stack is popped" in {
    val emptyStack = new Stack[Int]
    a [NoSuchElementException] should be thrownBy {
      emptyStack.pop()
    } 
  }
}

Java


import org.junit.Assert;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;

public class AppTest
{
    @Test
    public void testList()
    {
       List
                
                 list = Arrays.asList("test1","test2");
       Assert.assertEquals("test1",list.get(0));
    }
}

Javascript

import test from 'ava';

test('foo', t => {
	t.pass();
});

test('bar', async t => {
	const bar = Promise.resolve('bar');

	t.is(await bar, 'bar');
});
var assert = require('assert');
describe('Array', function() {
  describe('#indexOf()', function() {
    it('should return -1 when the value is not present', function() {
      assert.equal(-1, [1,2,3].indexOf(4));
    });
  });
});
Made with Slides.com