Vai al contenuto principale
ProdottiStrumenti desktopTASTECADVisualizzazione disegniTASTEFILESGestione fileTASTEFTPTrasferimento fileTASTESSHSpazio di lavoro remotoTASTEZIPCompressione ed estrazioneStrumenti per sviluppatoriTASTECODEAmbiente di sviluppo integrato per RustTASTESTUDIOAmbiente integrato di sviluppo e testTASTEETLIntegrazione dati (ETL)ServerTASTEREMOTEServer di desktop remotoTASTEGEOServer geospazialeTASTEMAILSpazio di lavoro emailIniziaDownloadDocumentazioneAcquistaTutti i prodotti
Marketplace
Notizie
TecnologiaNotizieNotizie di sviluppo di oggiDocumentazioneLinguaggi di programmazioneRustTypeScriptJavaScriptPythonGoC#JavaCC++KotlinDartFramework frontend webNext.jsReactVue.js · NuxtSvelteKitAngularFramework serverSpring BootDjangoFastAPIASP.NET CoreNestJS · ExpressFramework per app e desktopTauriFlutterReact NativeElectronAlgoritmiBasi degli algoritmiAlgoritmi fondamentaliAlgoritmi avanzatiAlgoritmi pratici
CommunityProgettiLog di sviluppoPromptProblemi degli strumenti di IAVetrinaGuida alla community
CollaboraTrasferimento tecnicoRealizzazione del sito webRealizzazione di app desktopPipeline di rilascio e pagamentoPartner commercialeContatti
ServiziDesktop remotoPacchetti di installazione su misura
TASTEDEV
Prodotti

Strumenti desktop

TASTECADApri con leggerezza anche i disegni più complessiTASTEFILESSolo i file che servono, alla massima velocitàTASTEFTPLa via più ordinata per i tuoi fileTASTESSHUn legame più solido tra te e i tuoi serverTASTEZIPComprimi più veloce, estrai più sicuro

Strumenti per sviluppatori

TASTECODEModifica, compila, esegui il debug e testa app Rust in un'unica finestraTASTESTUDIODalla modifica ai test remoti e alle correzioni IA approvateTASTEETLSposta i dati guardando i valori

Server

TASTEREMOTEUn desktop remoto che gira sul tuo serverTASTEGEOUn server geospaziale compatibile con GeoServer, ricostruito in RustTASTEMAILRiprendi il controllo della tua posta

Inizia

DownloadUltime versioni di ogni prodottoDocsCome usare ogni prodottoAcquistaAbbonamenti e licenze perpetueTutti i prodottiTutti i prodotti a colpo d’occhio
Tutti i prodotti
MarketplaceNotizie
Tecnologia

Notizie

Notizie di sviluppo di oggiAnnunci ufficiali su linguaggi, framework, GitHub e IADocumentazioneGuide a linguaggi, framework e algoritmi

Linguaggi di programmazione

RustTypeScriptJavaScriptPythonGoC#JavaCC++KotlinDart

Framework

Framework frontend webNext.jsReactVue.js · NuxtSvelteKitAngular
Framework serverSpring BootDjangoFastAPIASP.NET CoreNestJS · Express
Framework per app e desktopTauriFlutterReact NativeElectron

Algoritmi

Basi degli algoritmiAnalisi della complessità · Ordinamento · Ricerca · Strutture dati di base · Alberi e heapAlgoritmi fondamentaliVisita dei grafi · Cammini minimi e alberi ricoprenti · Programmazione dinamica · Algoritmi greedy · Divide et impera · BacktrackingAlgoritmi avanzatiAlgoritmi sulle stringhe · Matematica e teoria dei numeri · Manipolazione dei bit · Alberi di segmenti · Union-FindAlgoritmi praticiStrategia per colloqui di programmazione · Cache LRU · Rate limiting · Hashing consistente
Tutta la documentazione di sviluppo
Community
ProgettiScopri sviluppatori e lavoriLog di sviluppoDecisioni e lezioni appresePromptIstruzioni riutilizzabiliProblemi degli strumenti di IAProblemi e alternative di Claude, Codex, GeminiVetrinaRisultati completatiGuida alla communityCome sviluppiamo in modo aperto
Collabora
Trasferimento tecnicoApp native in Rust ed eguiRealizzazione del sito web10 lingue, account, documentazione e downloadRealizzazione di app desktopRust ed egui, senza WebViewPipeline di rilascio e pagamentoFirma, MSI, deb, rpm, AppImage, hashPartner commercialeConsigliaci e ricevi il 30%ContattiSviluppo, partnership e investimenti
Servizi
Desktop remotoRaggiungi il tuo computer dal browserPacchetti di installazione su misuraSolo il necessario, impostazioni precaricate
Acquista
IT
한국어EnglishDeutschEspañolFrançaisItalianoPortuguês (Brasil)日本語简体中文繁體中文
Accedi
Accedi
TASTEDEV

Dai piccoli strumenti a uno sviluppo migliore.

support@tastedev.netSostieni TASTEDEV
ProdottiGamma di prodottiAcquistaDocsDownloadMarketplaceAssistenza
CommunityProgettiLog di sviluppoPromptProblemi degli strumenti di IAVetrina
NormeInformativa sulla privacyTermini di servizioCondizioni di abbonamentoRimborsiLinee guida della community
AccountAccediRegistrati
Visitatori
Oggi
012345678901234567890123456789012345678901234567890123456789
Ieri
012345678901234567890123456789012345678901234567890123456789
Visualizzazioni totali
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
Società
GXSOFT
Rappresentante
CHOI YOUNG GU
Numero di registrazione
853-44-00368
Indirizzo
9F V24, 351 Gyeongin-ro, Michuhol-gu, Incheon, Republic of Korea
Telefono
+82-10-4404-1523
E-mail
whitecalvin@tastedev.net
Responsabile privacy
CHOI YOUNG GU

© 2026 TASTEDEVLe informazioni sui prodotti si basano su fonti di sviluppo verificate.Rilasciato · in miglioramento

Documentazione di Spring Boot
Spring Boot
Getting Started with Spring BootProject Structure and ConfigurationCore ConceptsData and StateTestingDeployment
Discussioni

Guida a Spring Boot · 5/6

Testing

Per ora questo capitolo è disponibile solo in inglese.

Spring Boot bundles JUnit Jupiter, AssertJ, Mockito and Spring Test, and supports both slice tests, which start only part of the application, and integration tests, which start all of it. This chapter goes from the fastest kind of test to the slowest.

Test dependencies and running tests

Projects generated by Initializr include a test starter per technology (spring-boot-starter-webmvc-test, spring-boot-starter-data-jpa-test and so on). Run tests through the build tool:

./gradlew test
./mvnw test

# Run a single test class
./gradlew test --tests "com.example.demo.todo.TodoServiceTests"

Plain unit tests

With constructor injection you can create objects by hand and test them without Spring at all. These tests are the fastest, so use them for business rules.

class GreetingServiceTests {

    @Test
    void greetsInTheMorning() {
        Clock morning = Clock.fixed(Instant.parse("2025-01-01T08:00:00Z"), ZoneOffset.UTC);
        GreetingService service = new GreetingService(morning);

        assertThat(service.greet("Kim")).isEqualTo("Good morning, Kim");
    }
}

Web slice: @WebMvcTest

@WebMvcTest starts only the MVC infrastructure (controllers, JSON conversion, validation) and registers no services or repositories. Replace the beans a controller depends on with mocks via @MockitoBean. MockMvcTester lets you assert on requests and responses in AssertJ style.

@WebMvcTest(TodoController.class)
class TodoControllerTests {

    @Autowired
    MockMvcTester mvc;

    @MockitoBean
    TodoService service;

    @Test
    void returnsTodo() {
        given(service.find(1L)).willReturn(new TodoResponse(1L, "Write docs", false));

        assertThat(mvc.get().uri("/api/todos/1"))
            .hasStatusOk()
            .bodyJson().extractingPath("$.title").isEqualTo("Write docs");
    }

    @Test
    void rejectsBlankTitle() {
        assertThat(mvc.post().uri("/api/todos")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"title\": \"\"}"))
            .hasStatus(HttpStatus.BAD_REQUEST);
    }
}

The previous generation used @MockBean; it has been replaced by Spring Framework's @MockitoBean.

Data slice: @DataJpaTest

@DataJpaTest configures only JPA-related beans and runs each test in a transaction that is rolled back afterwards. If an embedded database such as H2 is on the classpath, it is used in place of your configured one by default. To run the example below as is, add testRuntimeOnly("com.h2database:h2"), or use Testcontainers as shown later.

@DataJpaTest
class TodoRepositoryTests {

    @Autowired
    TestEntityManager entityManager;

    @Autowired
    TodoRepository repository;

    @Test
    void findsOpenTodos() {
        entityManager.persist(new Todo("open"));
        Todo done = new Todo("done");
        done.complete();
        entityManager.persist(done);

        assertThat(repository.findByDoneFalseOrderByIdAsc())
            .extracting(Todo::getTitle)
            .containsExactly("open");
    }
}
Domande su questo capitolo?
Capitolo precedenteData and StateCapitolo successivoDeployment

Full integration tests: @SpringBootTest

@SpringBootTest starts the same context as the real application. Add @AutoConfigureMockMvc when you want MockMvc, or set webEnvironment = WebEnvironment.RANDOM_PORT to start a real server on a random port.

A real database with Testcontainers

To test against the same database you run in production, use Testcontainers. It starts the database in Docker, and @ServiceConnection wires the connection details for you, so no spring.datasource.url is needed.

@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class TodoRepositoryPostgresTests {

    @Container
    @ServiceConnection
    static PostgreSQLContainer postgres = new PostgreSQLContainer("postgres:alpine");

    @Autowired
    TodoRepository repository;

    @Test
    void savesTodo() {
        Todo saved = repository.save(new Todo("from container"));
        assertThat(saved.getId()).isNotNull();
    }
}

replace = NONE tells Spring Boot to keep the container instead of swapping in an embedded database, and your Flyway migrations run against it too. When you pick testcontainers in Initializr, it also generates TestcontainersConfiguration and TestDemoApplication, so ./gradlew bootTestRun (or ./mvnw spring-boot:test-run) runs the app locally against a container database.

Summary

  • Test business rules quickly with plain unit tests, no Spring required.
  • Slice the web layer with @WebMvcTest and @MockitoBean, and the data layer with @DataJpaTest.
  • Verify complete flows with @SpringBootTest.
  • Attach a real database easily with Testcontainers and @ServiceConnection.

0 commenti

Commenti principaliPrima i più recenti

Accedi · Accedi per lasciare un commento.