I check unitari sono spesso trascurati nel processo di sviluppo del software program, ma ci sono molti bei effetti collaterali dei check unitari di scrittura. Dopo aver scritto il codice software program di produzione per più di un decennio, che ha servito miliardi di utenti per applicazioni su scala pianeta, posso dire con sicurezza che i check unitari contengono un luogo critico nel ciclo di vita dello sviluppo del software program.
Nonostante l’importanza dei check unitari, molti ingegneri spesso li trascurano a causa dei vincoli della sequenza temporale o della loro dipendenza eccessiva ai check manuali. C’è anche un’concept sbagliata che i check unitari rallentano lo sviluppo del software program che non è necessariamente vero. Difatti, studio rivela che lo sviluppo guidato dai check (TDD) può avere un impatto positivo sulla produttività dello sviluppo del software program. A lungo termine, i check unitari rendono il codice sul codice più semplice e più veloce.
Sulla base della mia esperienza di scrittura di codice per più di un decennio, i check unitari hanno anche altri vantaggi secondari oltre alla produttività degli sviluppatori.
-
I check unitari riducono i tempi di revisione del codice rendendo il codice più semplice da comprendere e dare alla sicurezza ai revisori attraverso una copertura di check chiara e affidabile.
-
Check dell’unità un tempo di onboarding inferiore per i nuovi ingegneri su una base di codice poiché i check unitari forzano il codice di forza per avere una migliore struttura e aumentare la modularità per la base di codice.
-
I check unitari forniscono la possibilità di refactor Codice con sicurezza poiché le modifiche possono essere convalidate rapidamente eseguendo i check unitari.
-
I check unitari migliorano l’affidabilità per il sistema in quanto molti casi di bordo possono essere coperti da Codebase che ha un’alta copertura del check unitario. Questi check aiutano a catturare duramente i problemi di produzione in fase di sviluppo.
-
I check unitari migliorano la struttura per il codice in quanto è necessario seguire i principi come Iniezione di dipendenza per scrivere check unitari in modo efficace. Se un codice è ben strutturato, è possibile sfruttare gli strumenti basati su LLM come Github Copilot Per scrivere check unitari per il tuo codice che può generare casi di check per te.
Cos’è un buon check unitario?
È importante comprendere alcune delle proprietà per un buon check unitario ed evitare cattive pratiche durante la scrittura di check unitari.
Un buon check unitario ha le seguenti proprietà:
È deterministico
Un buon check unitario è deterministico: se si esegue un check più volte, produce sempre un risultato deterministico. L’esecuzione di un check più volte (stress check) è uno dei modi per convalidare che un check unitario è deterministico. Per capire perché i check unitari possono essere non deterministici, possiamo esaminare alcuni dei modelli e delle cattive pratiche mentre scriviamo un check unitario:
-
Cattiva pratica 1: I check unitari assumono la dipendenza da un ambiente esterno e quando l’ambiente cambia, i check unitari diventano traballante. Un esempio di ciò sarebbe quello di assumere la dipendenza da un determinato parametro della riga di comando, un determinato valore di configurazione che viene impostato o si aspetta una determinata risposta da una chiamata RPC nel check.
-
Cattiva pratica 2: I check unitari assumono certe cose su ambienti di codice o {hardware} non deterministici. I check unitari dovrebbero essere agnostici dell’ambiente. Pochi esempi di questi sono:
-
Il check unitario presuppone che una determinata funzione complessa richiederà più di 100 ms per eseguire e convalida che il tempo impiegato per completare sia sempre maggiore di 100 ms. Questo è un male da assumere ed è dipendente dall’ambiente, quindi i check unitari dovrebbero essere progettati per non fare questi ipotesi.
-
Il check unitario presuppone che
intè 32 ma questo in realtà non è agnostico {hardware} in C ++ a meno che non si utilizzi la larghezza fissa tipi interi Piaceint32_t, int64_t.
-
-
Cattiva pratica 3: I check unitari effettuano alcune ipotesi sull’output restituite dalle funzioni della libreria mentre l’output può cambiare. Gli sviluppatori dovrebbero leggere le specifiche per le funzioni della libreria quando si fanno tali ipotesi. Pochi esempi di queste ipotesi sono:
-
Supponendo che l’ordine di inserti e iterazioni nella mappa sia uguale. UN Mappa hash commonplace in CPP Piace
std::unordered_mapnon dà questa garanzia. Se si inseriscono i valori in ordine{1,2,3}mentre iterando la mappa può essere l’ordine del valore{1,2,3}O{2,1,3}o qualcos’altro. Se si assume che l’ordine sia uguale agli inserti, il check potrebbe essere traballante. -
Supponendo che la stringa di serializzazione JSON per un determinato oggetto dinamico in C ++ sarà sempre la stessa. La libreria Folly C ++ supporta oggetti dinamici e ha un’opzione per serializzali a JSON. Tuttavia, se si esegue una funzione di serializzazione come
folly::Json(obj)non è garantito restituire la stessa stringa serializzata ogni volta. Il check dell’unità potrebbe fallire come ordine sottostante delle chiavi JSON non è garantito. -
Come stressare i check delle unità per la sfioratura per assicurarsi che siano deterministici?
-
Un check dell’unità ben scritto dovrebbe essere in grado di eseguire più volte in parallelo e dovrebbe passare determinalmente. Per i check unitari scritti utilizzando Google Check Framework (Gtest), puoi sfruttare una biblioteca come Gtest-parallelo che consente di eseguire check in parallelo per rilevare la sfioratura.
-
Esempio
-
Ha un unico scopo
-
Un buon check unitario viene scritto con un unico scopo e check solo un caso di check per check. Il nome del check unitario dovrebbe indicare questo.
-
Quando un check unitario fallisce, dovrebbe essere facile da dire dal nome del check unitario quale parte del codice sottostante sta fallendo.
-
Ciò rende i check unitari leggibili e mantenibili a lungo termine e li mantiene anche più piccoli.
Evita la configurazione duplicata
-
Non c’è nulla di speciale nei check unitari qui in particolare e questa dovrebbe essere una buona pratica generale per non avere un codice duplicato.
-
Tuttavia, è abbastanza comune per i check unitari copiare il codice in pasta e avere un codice duplicato tra casi di check con piccole modifiche. Questo è spesso codice di preparazione dei dati o codice di configurazione per i check unitari. Ciò rende i check unitari più difficili da mantenere e le raccomandazioni per evitare questo sono:
-
Estrarre la logica necessaria per impostare l’ambiente per i check unitari in funzioni di util separate.
-
Estrarre la logica necessaria per affermare i risultati se una validazione simile viene utilizzata in più check nelle funzioni UTIL.
-
È indipendente/isolato
-
I check unitari dovrebbero essere indipendenti e isolati. Non ci dovrebbe essere dipendenza tra due check.
-
Il punto sopra per quanto riguarda l’evitamento della configurazione duplicata aiuta anche a mantenere i check indipendenti poiché la configurazione di un check non dovrebbe influire su altri check.
Struttura di un buon check unitario – un esempio
Un buon modo per strutturare un check unitario è ricordare 3as (AAA), ASSERT ACT-ACT. Questi sono descritti di seguito:
Organizzare:
Act (Motion):
Affermare:
-
Ciò convalida quell’azione è stata effettivamente eseguita correttamente. Un check unitario che non afferma che nulla è un check unitario incompleto. Potrebbe dare una copertura del codice ma non è molto significativo. In generale, evitare più affermazioni con obiettivi diversi nei check unitari è una buona concept.
Esempio di AAA per un check unitario
Godbolt Hyperlink: Compilatore Explorer
#embrace
class ConfigIf{
public:
digital int getValue()=0;
};
class Config: public ConfigIf{
public:
int getValue() override {
return 7;
}
};
class MockConfig:public ConfigIf{
public:
int getValue() override {
return val_;
}
void overrideVal(int val){
val_ = val;
}
non-public:
int val_ = 5;
};
int multiplyBasedOnConfig(int num, ConfigIf& config) {
return num * config.getValue();
}
void testMultiplyBasedOnConfig()
{
// Organize: Setup a mock config object to a selected worth
MockConfig mockConfig;
mockConfig.overrideVal(10);
int expectedAnswer = 50;
// Act: Right here, we name multiplyBasedOnConfig to get a worth
int reply = multiplyBasedOnConfig(5, mockConfig);
// Assert: Check that reply is similar as anticipated reply
// We must be utilizing GMock framework to really assert however we are going to cowl that later within the information.
if(reply == expectedAnswer) {
std::cout Nel codice sopra:
-
L’esempio si concentra sul modello di assert di OCCACT e vede come impostiamo un oggetto di configurazione per controllare l’uscita della funzione e quindi lo afferma su di ciò.
-
Il codice scritto qui utilizza il principio di iniezione di dipendenza in cui
ConfigIfDefinisce l’interfaccia per la configurazione che è una dipendenza per la funzionetestMultiplyBasedOnConfig. L’iniezione di dipendenze tramite interfaccia consente dipendenze simulate per un check unitario. -
L’obiettivo dell’esempio di cui sopra è spiegare come funziona il beffardo e intenzionalmente non usa un framework come GMock e si affida alla STD Biblioteca C ++. Nella sezione successiva, riscriveremo il check di cui sopra usando GMock e Gtest Framework in modo da poter vedere come l’uso di un framework di check può aiutare.
Check unitario utilizzando Google Check e Google Mock Framework
In generale, utilizzando un framework di check unitari come Google Check e Google Mock Semplifica la scrittura dei check unitari fornendo strumenti di asserzione, gestione dei casi di check e deroga per le dipendenze che rendono efficienti i check. In breve, non è necessario un framework di check per scrivere check unitari ma lo rende molto più semplice. Abbiamo scritto il check unitario nella sezione sopra senza un framework di check, ma ora riscriveremo story check utilizzando il framework di check di Google.
Esempio di check di cui sopra usando il framework GMock
Godbolt Hyperlink: Compilatore Explorer
// The library used for google mock
#embrace
#embrace
class ConfigIf{
public:
digital int getValue()=0;
};
class MockConfig : public ConfigIf {
public:
// MOCK_METHOD permits to generate mock methodology and makes mocking simpler
// GMock framework gives simpler mocking choices
MOCK_METHOD(int, getValue, (), (override));
};
int multiplyBasedOnConfig(int num, ConfigIf& config) {
return num * config.getValue();
}
TEST(ExampleTest, multiplyBasedOnConfigTest) {
// Organize: Setup a mock config object to a selected worth
MockConfig mockConfig;
// EXPECT_CALL supplied by GMock framework permits to
// replace return worth from mocked strategies
EXPECT_CALL(mockConfig, getValue()).WillOnce(::testing::Return(7));
// Act: Right here, we name multiplyBasedOnConfig to get a worth
auto worth = multiplyBasedOnConfig(5, mockConfig);
// Assert: Check that reply is similar as anticipated reply
ASSERT_EQ(worth, 35);
}
int essential(int argc, char** argv) {
// The next line should be executed to initialize Google Mock
// (and Google Check) earlier than working the assessments.
::testing::InitGoogleMock(&argc, argv);
return RUN_ALL_TESTS();
}
Nel codice sopra:
-
Abbiamo incluso il
gmock library : gmock/gmock.hche fornisce macro similiMOCK_METHODEEXPECT_CALLIl che rende più facile scrivere check unitari. -
Abbiamo riscritto il check utilizzando Google Check Framework. È molto facile scrivere metodi finti e check unitari se il codice sottostante è ben scritto usando l’iniezione di dipendenza.
-
Il codice del check unitario stesso segue il principio AAA ma sfrutta il framework di Google Mock e usa
EXPECT_CALLPer controllare il valore di ritorno dal metodo simulato. -
La funzione principale fornisce solo il codice necessario per inizializzare GMock ed eseguire il metodo di prova.
Conclusione
Possiamo ricapitolare gli apprendimenti e concludere che i check unitari rendono il codice modulare, aiuta nell’affidabilità e nella produttività degli sviluppatori e aiuta advert aderire a buoni principi di progettazione come l’iniezione di dipendenza per il codice. Inoltre, l’utilizzo di check e derogni di framework come Google Check e Google Mock semplifica la scrittura e la gestione dei check unitari.
