Git bisect: come identificare un bug nel codice?

In questo articolo su git bisect, scopri come il comando 'git bisect' aiuta a rilevare il primo commit errato che introduce un bug utilizzando l'algoritmo di ricerca binaria.

Il mio codice funzionava bene fino a ieri, ma non fino a quando un recente pull dal repository remoto ha rotto il codice !!!

Se ti trovi in ​​una situazione simile e non lo sai quale cambiamento ha rotto il codice o chi di molti collaboratori possiede Questo bug / funzionalità , allora git bisect è la tua via d'uscita. Quindi, in questo articolo su git bisect imparerai come 'git bisect'Comando arriva a rescue nel rilevare il primo bad commit che introduce il bug utilizzando l'algoritmo di ricerca binaria.



Gli argomenti trattati in questo articolo sono i seguenti:



Perché usare git bisect?

Non c'è dubbio nel fatto che tendi a creare un numero di commit per ogni piccola modifica in . In uno scenario del genere, il debug del codice diventa un'attività noiosa, poiché è necessario tornare manualmente indietro nel tempo ad ogni singola revisione dell'istantanea del progetto per testare il codice funzionante e rilevare il bug. Ora, questo diventa ancora di più complesso quando hai il lavoro di altri da ispezionare senza un punto di partenza, anche chiedere a ciascuno di ripulire i propri errori non sembra molto fattibile.
Lungo la strada, potresti anche creare e scartare una serie di rami 'funzionalità' (o hotfix) nel processo e finire per perdere tempo e fatica mentre ti allontani dalla linea principale di sviluppo.



Quindi, per evitare tali scenari, puoi usare ilgit bisectcomando per trovare la revisione del progetto (o l'istantanea) errata ed eventualmente correggerla con ilgit revertcomando.

Come esegue la ricerca 'git bisect'?



Questo comando bisette (divide) la tua storia tra i file bene e il cattivo commettere gamma. Punta il tuo attuale progetto stato ad un fascia media commettere istantanea. Il comando git bisect quindi si sposta ogni ID commit tra questo intervallo mentre pausa ad ogni istantanea per permetterti di farlo testare il codice . Se il bug esiste, dichiari il commit come cattivo, se non come bene a meno che la ricerca non finisca.

Sintassi

git bisect

Per capire meglio git bisect, creiamo un progetto che sviluppi il codice per una semplice app di navigazione da utilizzare in un'auto.

Configurazione iniziale del progetto

Per creare un progetto che sviluppi il codice per una semplice app di navigazione da utilizzare in auto, puoi seguire i seguenti passaggi:

Passo 1: Crea una nuova directory nella tua cartella $ HOME:

cd $ HOME mkdir my_nav_app

Passo 2: Vai alla nuova directory:

cd $ my_nav_app

Passaggio 3: Clona per scaricare il progetto dalla mia pagina GitHub:

git clone https://github.com/divyabhushan/my_nav_app.git

Ora, comprendiamo le directory del progetto e il layout dei file, come stampato dal comando:ls -lTR

Layout del codice sorgente - Git Bisect - Edureka

Quindi, vediamo il diario della cronologia del progetto per visualizzare i commit che ho fatto per generare questo codice-

Ad esempio, un semplice comando git log stampa la cronologia in dettaglio, tuttavia, mi piace formattare e personalizzare la cronologia. Quindi, lasciaci imposta un nome alias - 'hist' usando il git alias comando come mostrato di seguito:

git alias.hist 'log --pretty = format:'% C (giallo)% h% Creset% ad | % C (verde)% s% Creset% C (rosso)% d% Creset% C (blu) [% an] '--graph --decorate --date = short'

Ora, eseguirò questa funzione di correzione dei bug in un ramo separato, in modo da non interferire con lo sviluppo principale sul ramo 'master'. Per farlo, segui il seguente set di comandi:

  • Crea ramo 'dev': [maestro] $git branch dev
  • Passa al ramo 'dev': $git checkout dev
  • Elenca i registri della cronologia: [dev] $vai hist[Nota: comando 'alias' utilizzato qui]

Inoltre, ho evidenziato l'ultimo commit valido noto che so in cui il mio script ha funzionato bene con i risultati del test case attesi, questa istantanea del commit è etichettato come v1.0.

Quindi, ora che conosciamo il nostro ultimo buon impegno, andiamo avanti in questo articolo su 'git bisect' e testiamo l'applicazione.

Testare l'applicazione

Esegui lo script come - $./scripts/myApplication.sh[prima prova]



Chiaramente, il mio attuale stato di progetto è in errore e non sono sicuro di quale cambiamento ho fatto in quale commit che ha introdotto questo cambiamento. Quindi, nel prossimo articolo su git bisect, vediamo come identificare il bad commit.

Identificazione del bad commit

Per iniziare a ispezionare il bad commit, segui i passaggi seguenti:

  • Avvia il comando bisect :git bisect start
  • Indica l'ID del commit errato: git bisect bad HEADogit bisect c5b3ca8
  • Indica l'ultimo ID di commit valido: git bisect buona v1.0ogit bisect 93859d8

Questo taglia in due l'intervallo della cronologia dei commit all'incirca a metà strada tra i commit buoni e quelli cattivi che ci porta all'ID commit: f61a7e8

Quindi, il comando ha verificato la versione del progetto com'era in questo ID commit. Ora andiamo avanti e testiamo di nuovo la nostra applicazione.

Comando per eseguire l'applicazione : $./scripts/myApplication.sh[prova la seconda volta]


Dal momento che l'applicazione passato in questo commit, questo commit non è certamente il cattivo commit. Quindi, dopo, devi informare lo stesso del comando bisect come - $git bisect buono

creare un pacchetto in java


Ora, questo restringerà ulteriormente il risultato della ricerca nella prima metà dell'intervallo come mostrato -


Prova di nuovo la tua applicazione - Comando: $./scripts/myApplication.sh[prova per la terza volta]


Quindi, poiché vediamo un errore come sopra, questo è un cattivo commit.

Fai sapere al comando bisect, esegui $git bisect male


Ciò restringe ulteriormente la ricerca e ti porta all'ultima revisione centrale cerchiata in blu: a6ac769

Quindi, provo la mia applicazione un'ultima volta usando lo stesso comando: $./scripts/myApplication.sh[testare la quarta volta]

Ora, poiché l'applicazione non è riuscita di nuovo, è ancora un cattivo commit. Quindi, eseguiamo il seguente comando:

Esegui il comando: git bisect male

Rilevato commit errato

Questo conclude l'unico ultimo commit rimasto che è cattivo-


Quindi sai che è qui che il codice si è rotto. E dopo?

Comprendi quale file conteneva il bug

In questo caso, l'output fornisce informazioni minime sul file commit id , nome dell'autore , e il data di creazione insieme con il messaggio di commit e il sentiero che è stato modificato.

differenza tra c c # e c ++

Se desideri eseguire il debug ulteriormente, devi farlo leggere il oggetto id commit .

Comando: git mostra a6ac76994b3f6c7519204f910fc787b7928cf8ef

Questo leggerà l'oggetto commit e stamperà il messaggio di log e il diff testuale.

Potresti anche utilizzare il comando 'git blame' per analizzare come e in quale commit ogni riga è stata modificata da quale autore, eseguire il comando come:git incolpa il codice / Develop_nav.sh

Interrompi la ricerca

Per interrompere la ricerca, utilizzare il seguente comando:

Comando: git bisect reset


Pertanto, il processo di bisezione viene interrotto e si torna sul ramo da cui è stata avviata la ricerca. Ora, il passaggio successivo è correggere o eseguire il debug del codice.

Come riparare / eseguire il debug del codice?

Bene, ci sono un paio di soluzioni alternative che potresti fare per correggere lo stato corrente del progetto ora che hai identificato il commit che ha portato il bug in primo luogo.
Tuttavia, se stai modificando un commit su un file repository condiviso è meglio ripristinare la modifica utilizzando il ' git revert 'Comando.

Compito: Ripristina le modifiche apportate dal commit errato menzionato

Comando: git ripristina a6ac769

Di conseguenza, il ripristino delle modifiche apportate da questo commit ha fatto 2 cose:

  • Ha eliminato le ultime 3 righe aggiunte (indicate in verde) e ha aggiunto la riga eliminata (indicata in rosso). (retro di a6ac769)
  • Creato un commit aggiuntivo con le informazioni sul messaggio di ripristino

'Il comando Ripristina rende anche più facile tenere traccia della modifica annullata dal commit originale'

Usa il 'spettacolo' comando di nuovo per leggere l'id oggetto, in questo modo-

Comando: git mostra 801f029

Ora vai avanti e prova l'applicazione. Verrà eseguito correttamente.

Comando: $./scripts/myApplication.sh

Al contrario, se vuoi rimuovere il bad commit dalla cronologia:

  • Potresti usare ' git reset 'Comando con '--difficile'Opzione (sebbene non consigliata in un repository condiviso).

  • Controlla una versione precedente di un singolo file utilizzando 'git checkout'Comando con'-' opzione.

Va notato che questo apporterà modifiche solo nel tuo repository locale fino a quando non invii le modifiche a un repository remoto. Poiché alcune modifiche creano un nuovo ID oggetto commit come nel nostro caso precedente, in tali casi un normale push al repository remoto viene rifiutato poiché la cronologia sarebbe divergente. Devi usare ' git push 'Comando con'--vigore' opzione.

Aggiorna il ramo 'principale'

Mentre ho corretto il bug sul mio ramo 'dev', ora posso unire questa modifica anche con il ramo 'master '-

  • passa a 'master', comando:git checkout master
  • estrarre gli aggiornamenti recenti da 'origine / master' a 'master', comando:git pull origine
  • unisci le modifiche 'dev', comando:git merge giant

Tuttavia, la tua unione potrebbe generare conflitti se ci sono più commit dal repository remoto. Risolvi i conflitti e continua con l'unione.
Infine, invia solo i commit del ramo 'master' stabile al repository remoto mentre svolgi il tuo lavoro sporco (bug, funzionalità, miglioramenti) solo sui rami delle funzionalità come 'dev' in questo esempio.
Inoltre, è meglio adottare una logica strategia di ramificazione per semplificare e proteggere il processo del flusso di lavoro git.

Per riassumere, 'git bisect' è un comando pratico e utile che rapidamente identificare il commit id quello introdotto per colpa nel codice in esecuzione con l'aiuto di un esteso ricerca binaria logicamente dividendo i log di commit a metà tra il file bene e cattivo commettere gamma . Per concludere, hai imparato a farlo rilevare il commit difettoso e ripristinare la modifica apportata da esso.

Inoltre, per i sottocomandi 'buono' e 'cattivo' puoi anche utilizzare termini come nuovo e vecchio per descrivere lo stato di revisione. È possibile eseguire il comando più volte passando diversi sottocomandi e ID di revisione / commit per identificare diversi ID commit (she-1). In alternativa, è possibile eseguire anche uno script di test automatizzato per creare il codice danneggiato utilizzando questo comando. Inoltre, trova una descrizione dettagliata di questo comando eseguendogit bisect --helpsul terminale. Quindi, gente con questo, arriviamo alla fine di questo articolo su Git Bisect.

L'intenzione di DevOps è creare software di migliore qualità più rapidamente e con maggiore affidabilità, invitando al contempo una maggiore comunicazione e collaborazione tra i team. Se sei incuriosito da questo articolo, c diamine il da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Il corso di formazione sulla certificazione DevOps di Edureka aiuta gli studenti a capire cos'è DevOps e ad acquisire esperienza in vari processi e strumenti DevOps come Puppet, Jenkins, Nagios, Ansible, Chef, Saltstack e GIT per l'automazione di più passaggi in SDLC.

Hai domande per noi? Per favore, menzionalo nella sezione commenti dell'articolo 'Git Bisect' e ti risponderemo al più presto.