Frühling + Mockito test Injektion

Meine Frage ist sehr ähnlich der Frage in Die Injektion Mockito mocks in eine Spring-bean. In der Tat, ich glaube, dass die akzeptierte Antwort, es könnte tatsächlich für mich arbeiten. Allerdings habe ich ein Problem mit der Antwort, und dann eine weitere Erklärung, falls die Antwort gibt es in der Tat nicht meine Antwort.

Also folgte ich dem link in der oben genannten post an die Springockito website. Ich veränderte meine test-config.xml etwas ähnlich dem folgenden:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mockito="http://www.mockito.org/spring/mockito"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.mockito.org/spring/mockito http://www.mockito.org/spring/mockito.xsd">

...

    <mockito:mock id="accountService" class="org.kubek2k.account.DefaultAccountService" />
...
</beans>

Scheint es etwas falsch mit der www.mockito.org redirect derzeit, so fand ich die XSD-code https://bitbucket.org/kubek2k/springockito/raw/16143b32095b/src/main/resources/spring/mockito.xsd und verändert Sie den letzten Eintrag in der xsi:schemaLocation diese bitbucket link.

Läuft mvn test dann erzeugt der folgende Fehler (Zeilenumbrüche Hinzugefügt, um die Lesbarkeit zu verbessern):

Caused by: org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException:
    Line 43 in XML document from class path resource [spring/test-context.xml] is invalid;
    nested exception is org.xml.sax.SAXParseException; lineNumber: 43; columnNumber: 91;
    The prefix "mockito" for element "mockito:mock" is not bound.

Also die Frage, Springockito ist: Ist es überhaupt noch möglich, diese aufzunehmen? Was bin ich?

Nun, auf zur weiteren Erklärung...

Habe ich eine Schnittstelle, deren Implementierung, die ich bin versucht zu testen:

public interface MobileService {
    public Login login(Login login);
    public User getUser(String accessCode, Date birthDate);
}

Die Umsetzung enthält ein DAO-Spring @Autowires in mir:

@Service
public class MobileServiceImpl implements MobileService {
    private MobileDao mobileDao;

    @Autowired
    public void setMobileDao(MobileDao mobileDao) {
        this.mobileDao = mobileDao;
    }
}

Möchte ich nicht ändern, meine Oberfläche um eine setMobileDao Methode, denn das wäre das hinzufügen von code, um meine unit-Tests. Ich versuche zu verspotten, aus dem DAO, da das eigentliche SUT hier ist die ServiceImpl. Wie kann ich das erreichen?

InformationsquelleAutor Mike | 2011-10-18

mockito spring

9

Wollen Sie nicht testen Sie Ihre Schnittstelle: es enthält überhaupt keinen code. Sie wollen testen Sie Ihre Implementierung. Also der setter verfügbar ist. Ganz einfach:
```
@Test
public void testLogin() {
    MobileServiceImpl toTest = new MobileServiceImpl();
    toTest.setMobileDao(mockMobileDao);
    //TODO call the login method and check that it works as expected.
}
```
Keine Notwendigkeit für einen spring-Kontext. Nur instantiieren Ihre POJO-service, injizieren mock Abhängigkeiten manuell und testen Sie die Methoden, die Sie testen möchten.
- Ich bin damit einverstanden, testen Sie einfach die Umsetzung. Es gibt keinen Punkt zu haben spring-Kontext für eine unit test. Und durch die Art und Weise Mockito bietet einige triviale dependency-injection-Mechanismus mit einer Kombination von @Mock und @InjectMocks Anmerkungen. Sie sollten finden Sie in den jeweiligen javadoc.
InformationsquelleAutor JB Nizet

Nach dem Kampf mit der Springockito XSD Problem, für eine Weile fand ich eine viel einfachere Lösung. Lassen Sie den Frühling Spritzen die Modelle für die Sie über eine factory-Methode, d.h. in applicationContext.xml setzen:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="com.gerrydevstory.mycoolbank.AccountsDAO"/>
  </bean>

  <bean class="com.gerrydevstory.mycoolbank.BankingService"/>

</beans>

wo die AccountsDAO bean injiziert BankingService Klasse. Die entsprechenden JUnit-Testfall ist:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/BankingServiceTest.xml")
public class BankingServiceTest {

  @Autowired private BankingService bankingService;
  @Autowired private AccountsDAO mockAccountsDAO;

  @Test
  public void testTransfer() throws Exception {
    //Setup 2 accounts
    Account acc1 = new Account();
    acc1.setBalance(800.00);
    Account acc2 = new Account();
    acc2.setBalance(200.00);

    //Tell mock DAO to return above accounts when 1011 or 2041 is queried respectively
    when(mockAccountsDAO.findById(1011)).thenReturn(acc1);
    when(mockAccountsDAO.findById(2041)).thenReturn(acc2);

    //Invoke the method to test
    bankingService.transfer(1011, 2041, 500.00);

    //Verify the money has been transferred
    assertEquals(300.00, acc1.getBalance(), 0.001);
    assertEquals(700.00, acc2.getBalance(), 0.001);
  }
}

Persönlich finde ich das sehr elegant und einfach zu verstehen. Für mehr details, siehe die original blog post.

InformationsquelleAutor Erica Kane

0

Haben Sie drei Möglichkeiten, um Ihre mock-dao:
1. Test der Implementierung - das gibt eine Naht, die für Ihre mock über die setDao Methode. (wie JB ' s Antwort)
2. Fügen Sie die setDao Methode der Schnittstelle - nicht erwünscht, da Sie nicht wollen, um code hinzuzufügen, nur zur Unterstützung Ihrer tests.
3. Fügen Sie einen Konstruktor der impl-Klasse zu akzeptieren, die die dao - nicht erwünscht, aus demselben Grund wie #2.
Wenn Sie wollte, zu tun, #3, müssen Sie einen Konstruktor der MobileService akzeptiert MobileDao.
```
   public MobileServiceImpl(MobileDao mobileDao) {
    this.mobileDao = mobileDao;
}
```
Dann ist dein test wird so Aussehen:
```
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;

import java.util.Date;

import org.junit.Before;
import org.junit.Test;

public class MobileServiceImplTest {

    private MobileService systemUnderTest;

    private MobileDao mobileDao;

    @Before
    public void setup() {
        mobileDao = mock(MobileDao.class);
        systemUnderTest = new MobileServiceImpl(mobileDao);
    }

    @Test
    public void testGetUser() {
        //if you need to, configure mock behavior here. 
        //i.e. when(mobileDao.someMethod(someObject)).thenReturn(someResponse);
        systemUnderTest.getUser("accessCode", new Date());

        verify(mobileDao).getUser("JeffAtwood");
    }
}
```
Bitte beachten Sie, dass Sie nicht zur Verfügung gestellt haben, uns mit den details der MobileDao so habe ich eine getUser-Methode akzeptiert eine Zeichenfolge.

Machen Sie den test pass, Ihre MobileServiceImpl würde, muss nur dieses:
```
mobileDao.getUser("JeffAtwood");
```
- Einfach wie das hinzufügen eines setMobileDao zu der Schnittstelle, hinzufügen von einem anderen ctor zu übergeben, in der DAO-Objekt, das verändern von code zur Unterstützung von unit-tests. Als pro @jb-nizet 's Antwort, wenn ich das alter meiner test-nicht verwenden, um nicht die Schnittstelle sondern die Umsetzung, dann habe ich schon Zugriff auf die setMobileDao Methode.
- Verstanden, dass Sie nicht wollen, etwas hinzufügen, um den code zur Unterstützung von tests. Die Prüfung der impl anstatt die Schnittstelle ist etwas, das ich getan habe in der Vergangenheit auch 😉 wollte Nur gibt Ihnen eine andere option.
InformationsquelleAutor Tony R
0

Das problem sieht wie der classpath enthält nicht die tatsächlichen springockito Glas - Sie müssen nicht zum ändern der URL ' s - diese sind nur die tokens, die verwendet werden, intern im Frühjahr - Sie sind nicht gelöst - alles, was Sie brauchen, ist eine neue, genug, der Frühling Verteilung und springockito auf classpath.

Kuba (Schöpfer der oben genannten lib 🙂 )

InformationsquelleAutor kubek2k
0

Ich hatte das gleiche problem, ich wollte verwenden springockito, indem nach deren wiki aber Validierungen xml-Fehler auslösen. Also, wenn ich versuchte, gehen an Orte, wo xsd sein soll, das hat sich nicht. So ich Lesen Sie diese und lernen Sie die Arbeit mit diesem:
```
xmlns:mockito="http://www.mockito.org/spring/mockito"
xsi:schemaLocation="http://www.mockito.org/spring/mockito 
    https://bitbucket.org/kubek2k/springockito/raw/16143b32095b/src/main/resources/spring/mockito.xsd">
```
Aber wenn ich suchen auf diesem link, hatte ein schlechtes Gefühl. Es scheint mir, dass nicht dauerhafte stabile Verbindung (Sie müssen überprüfen, wenn ich falsch Liege)
- Scheint, dass der link kaputt ist jetzt. Hat jemand eine neue?
InformationsquelleAutor Perlos

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.