La façon de traiter avec Setter/Getter-Méthodes de Simulacres?

Donc, je suis toujours avoir des problèmes avec l'utilisation de Mockito. Supposons donc j'ai suivantes de la classe (s'il vous Plaît ignorer la logique, ou de la structure de ça, c'est juste un petit exemple que j'ai créé à partir d'une autre classe, avec des noms différents et ainsi de suite.) :

public class Restaurant(
    @Autowired
    private CustomerService customerService;

    private CustomerInputData updateCustomer(CustomerInputData inputData){
        String customerId = inputData.getID();
        Customer customer = customerService.getCustomerById(customerID);
        if(customer.getAddress() != null){
            inputData.setCustomerName(customer.getCustomerName());
            inputData.setCustomerCity(customer.getCustomerCity);
            inputData.setCustomerLanguage(customer.getLanguage);
        }

        return inputData
    }
}

Donc ma compréhension de l'Unité-Tests, pour isoler toutes les dépendances. Ici, je voudrais demander au Client de la classe et le Service à la Clientèle.

Donc d'écrire un test de la classe, je voudrais le font actuellement les suivantes:

public class RestaurantTest()
{
    @Mock(name="customerService");
    private CustomerService customerService;

    @InjectMocks
    private Restaurant classUnderTest;

    @Before
    public void setUp(){
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void updateCustomer_WithValidInput_ShouldReturnUpdatedInput(){
        //Some Mocking first
        String customerId = "customerId";
        Customer customer = mock(Customer.class);
        CustomerInputData = mock(CustomerInputData.class);

        doReturn(customer).when(customerService.getCustomerById(any(String.class)));
        doReturn(customerId).when(inputData.getId());

        doReturn("address").when(customer.getAddress());
        doReturn("Name").when(customer.getName());
        doReturn("City").when(customer.getCity());
        doReturn("Language").when(customer.getLanguage());

        doNothing().when(inputData).setCustomerName(any(String.class));
        doNothing().when(inputData).setCustomerCity(any(String.class));
        doNothing().when(inputData).setCustomerLanguage(any(String.class));

        verify(customer.getAddress(), atLeastOnce());
        verify(customer.getName(), atLeastOnce());
        //and so on...

        verify(inputData, atLeastOnce()).setCustomerName(eq("Name"));
        verify(inputData, atLeastOnce()).setCustomerCity(eq("City"));
        verify(inputData, atLeastOnce()).setCustomerLanguage(eq("Language");

    }
}

Donc actuellement je n'ai pas l'Affirmer, je n'ai vérifier si les bonnes méthodes appelées. La raison, pourquoi j'essaie de le faire comme cela, et ne pas laisser le Test de l'appel de classe le setter/getter est à cause de l'isolement. Supposons inputData.setCustomerCity est brisé, mon test échoue. C'est donc en fonction de la CustomerInputData de Classe.

Maintenant, comment puis je m'approche de ces accesseurs et des mutateurs, quelle est la meilleure pratique?

Faire, je n'ai pas compris Mockito assez bon? Lorsque j'utilise la maquette(), puis-je simplement utiliser le setter-méthodes et gethods, et n'ont pas besoin de s'inquiéter à propos de l'utilisation doReturns et ainsi de suite?

Je sais que c'est une whitebox-test, je sais que les méthodes et ce qui se passe.

De ma compréhension, je voudrais tester les getters/setters dans les Épreuves de la classes respectives. Il n'est pas le devoir de RestaurantTest. Si setCustomerName est cassé, le code de Restaurant pourrait encore être correct. Donc, les tests ici peut même induire en erreur votre bughunt ...
C'est tout mon intention. Je ne peux pas tester le Setter/Getter là, j'ai donc besoin de se moquer d'eux, ou de ne rien faire/doReturn quand ils sont appelés. Mais est-ce la bonne façon, ou, comment puis-je tester cette classe? Parce que j'ai maintenant deux problèmes, je ne peux vérifier, si le Restaurant-classe appelle le droit des méthodes et j'ai beaucoup de doReturn/ne rien faire pour écrire..

OriginalL'auteur user5417542 | 2015-10-29

7

Seulement se moquer des choses que vous ne pouvez pas créer ou de passer par vous-même. Ne pas se moquer de tout passé dans les entités; la fourniture d'une fausse version est souvent de loin supérieur.

Dans ce scénario, nous pouvons en tirer avec un couple de choses depuis que nous nous connaissons peu de choses à propos de notre test:
- Nous revenons d'un Customer instance de la customerService, mais nous n'avons pas besoin de faire toute sorte de validation de cette instance.
- Nous ont de se moquer de l' customerService car c'est de l'injection de dépendance.
À la lumière de ces deux choses, on devrait se moquer de sortir CustomerService, ce qui n'genre de succès puisque le champ est nommé la même vous n'avez pas besoin de l'appoint de métadonnées dans l'annotation.
```
@Mock
private CustomerService customerService;
```
Vous devriez aussi regarder pour utiliser le lanceur de test fourni avec Mockito de sorte que vous n'avez pas explicitement à initialiser les objets fantaisie.
```
@RunWith(MockitoJUnitRunner.class)
public class RestaurantTest {
    //tests
}
```
Maintenant, le test de l'unité. La seule chose qui est vraiment nulle, c'est que vous avez de fournir un exemple d'un Client à utiliser, mais en dehors de cela, il n'est pas trop mauvais. Notre givens sont l'instance de CustomerData nous voulons transformer, et le Customer nous mettons à la disposition pour le test. Nous avons alors de simplement affirmer les valeurs que nous nous soucions de sont de retour pour notre test CustomerData instance.
```
@Test
public void updateCustomer_WithValidInput_ShouldReturnUpdatedInput(){
    //given
    final Customer customer = new Customer();
    customer.setId("123");
    customer.setAddress("Addr1");
    customer.setName("Bob");
    customer.setCity("St8")
    customer.setLanguage("Java");

    final CustomerInputData inputData = new CustomerInputData();
    inputData.setId(customer.getId());

    //when
    when(customerService.getCustomerById(customer.getId())).thenReturn(customer);
    classUnderTest.updateCustomer(customerData);

    //then
    verify(customerService.getCustomerById("123"));
    assertThat(customerData.getCustomerName(), equalTo(customer.getName()))
    //and so forth
}
```
Ok, donc en gros, il ne faut jamais se moquer de tout ce qui se est passé à une méthode, ou est retourné. Je demande, parce que pour moi il est logique de se moquer de la Clientèle, puisque je n'ai pas de soins si la setId(), setAddress-méthodes et donc sur le travail, je veux juste pour s'assurer, qu'ils sont appelés. Mais deux choses: - j'ai entendu, que vous ne devez utiliser un faire valoir par la méthode. Donc, je ne devrais pas faire: assertEquals(client, classUnderTest.updateCustomer(customerData))? Et concernant la vérification de l', dans votre exemple, vous ne passez pas d'autre chose comme la fois(1). Est-ce conseillé, ou que faut-il faire? Btw merci pour votre aide

OriginalL'auteur Makoto

Qui n'est pas la "bonne" façon d'aller à ce sujet, depuis les moqueries des objets de valeur est largement considéré comme une mauvaise pratique (il dit même si dans Mockito de la documentation).

Votre test devrait plutôt ressembler à ceci:

@Test
public void updateCustomer_WithValidInput_ShouldReturnUpdatedInput() {
    String customerId = "customerId";
    String name = "Name";
    String address = "address";
    String language = "language";
    Customer customer = new Customer();
    customer.setName(name);
    customer.setAddress(address);
    customer.setLanguage(language);
    CustomerInputData inputData = new CustomerInputData();
    inputData.setId(customerId);

    doReturn(customer).when(customerService).getCustomerById(customerId);

    CustomerInputData updatedInput = classUnderTest.updateCustomer(inputData);

    assertSame(inputData, updatedInput);
    assertEquals(name, updatedInput.getCustomerName());
    assertEquals(address, updatedInput.getCustomerCity());
    assertEquals(language, updatedInput.getLanguage());
}

Pour une bonne présentation sur les tests unitaires, voir Martin Fowler article récent.

OriginalL'auteur Rogério

Vous devez vous connecter pour publier un commentaire.