Cum să automatizați sarcini repetitive de calitate folosind macro-urile Excel (Exemple)

how automate repetitive qa tasks using excel macros

Acest ghid detaliat despre Macro Mindset-ul QA explică modul de automatizare a sarcinilor QA repetitive utilizând macro-urile Excel cu exemple și capturi de ecran ale foilor Excel:

Nevoia de automatizare în lumea de astăzi este una dintre cerințele esențiale și în creștere. Astăzi toată lumea caută ceva care să-i ușureze munca sau problemele implicate în munca de rutină.

În zilele noastre, nimeni nu vrea să viziteze un magazin mobil, să stea în cozi pentru a-și reîncărca telefonul, este convenabil să nu vizitați fizic nicăieri, ci să reîncărcați telefonul online într-o fracțiune de secundă.

Începând de la plata facturilor dvs. de utilități prin intermediul serviciilor bancare pe net, rezervarea și urmărirea cabinei dvs. online, cumpărarea de lucruri online pe diverse site-uri de e-commerce până la utilizarea diferitelor aparate automate precum mașini de spălat, cuptor cu microunde, gheizer și smartphone-urile în continuă evoluție etc., lumea de astăzi este cu adevărat pofta de produse inteligente și automate sub formă de servicii sau gadgeturi.

În acest articol, nu vom discuta despre utilizarea niciunui instrument de automatizare sau nimic despre inteligența artificială sau învățarea automată, dar accentul va fi pus pe simpla utilizare a Excelului pentru automatizarea sarcinilor zilnice de rutină ale unui QA.

Ce veți învăța:

• Macro Mindset al QA
  • Setare rapidă a contextului
  • Exemplu de utilizare # 1
  • Exemplu de utilizare # 2
  • Exemplu de utilizare # 3
  • Exemplu de utilizare # 4
  • Cod VBA (macro) pentru foaia de estimări
  • Cod VBA (macro) pentru foaia de diagrame
  • Modalități de a executa o macro
  • Adăugați un buton de control pentru formulare în Excel
• Concluzie
  • Lectură recomandată

Macro Mindset al QA

Testerii manuali au, de obicei, ideea că eu, care sunt tester manual, nu au nimic de-a face cu nimic tehnic sau, cu alte cuvinte, „cunoștințele de codificare nu sunt ceașca mea de ceai”. Aceasta este probabil o mentalitate greșită care ar putea opri creșterea noastră ca ingineri.

Un QA manual are multe sarcini zilnice care ar putea fi repetitive după același flux de lucru. Un QA poate identifica foarte bine astfel de sarcini și le poate automatiza folosind macrocomenzi Excel și / sau formule.

Acest lucru ar putea ajuta în două moduri:

• Reduce timpul consumat în eforturile manuale.
• De asemenea, inspiră QA să învețe și să se adapteze la gândirea logică și la perfecționare pe plan tehnic.

Lucrurile pot fi automatizate pentru toate fazele de testare enumerate mai jos:

• Planificarea și estimarea testelor.
• Proiectarea testului sau pregătirea cazului de testare.
• Actualizarea stării de execuție a testului.
• Crearea raportului de testare și a valorilor.

Setare rapidă a contextului

# 1) Un excel salvat cu. extensia xlsxm este un Excel activat pentru macro.

#Două) Pentru a activa macro pe un Excel, selectați Fișier -> Opțiuni -> Centrul de încredere -> Setări centru de încredere -> Setări macro -> Selectați butonul radio „Activați toate macrocomenzile” și bifați caseta de selectare „Acces de încredere la modelul de obiect al proiectului VBA”. Faceți clic pe OK.

# 3) Selectați meniul Vizualizare -> Macro -> Înregistrați macrocomenzi -> Efectuați o anumită activitate și Opriți macrocomenzile . Puteți edita macro-ul și puteți vizualiza codul VBA înregistrat în Editor VBA fereastră. În mod similar, puteți adăuga codurile în mod explicit pentru a crea o macro.

# 4) Vom arunca o privire asupra anumitor exemple de astfel de sarcini repetitive care ar putea fi candidați buni pentru automatizare prin macrocomenzi / formule Excel.

Exemplu de utilizare # 1

La sfârșitul fiecărei faze funcționale, trebuie să existe câteva cazuri de testare identificate pentru regresie din suita funcțională. Acesta este un proces care trebuie urmat în fiecare sprint sau iterație.

Soluţie

Pentru a reduce efortul de identificare și de creare manuală a unei suite de regresie, poate fi implementat procesul inovator de mai jos.

1. Puteți crea o foaie cu cazuri de testare funcțională cu o coloană suplimentară pentru marcarea cazurilor de testare / scenarii ca Da / Nu pentru regresie.
2. Apoi creați o macrocomandă pentru aceeași, astfel încât atunci când macrocomanda rulează, toate cazurile / scenariile de testare cu regresie marcată ca „Da” să fie copiate într-o altă foaie.
3. Astfel, acest lucru va evita un exercițiu suplimentar de a trece prin toate cazurile de testare funcționale la sfârșitul sprintului și apoi de a depune eforturi suplimentare pentru ca fiecare caz de test să fie extras în suita de regresie.

Demo

• Prima foaie „FunctionalTestScenarios” conține toate scenariile de testare funcțională / cazurile de testare.
• Există o coloană suplimentară „Includeți în suita Regression?” adăugat la sfârșitul coloanelor de testare pentru a marca „Da” sau „Nu”, identificând dacă fiecare dintre scenariile de testare trebuie să fie inclus în suita de regresie.
• Există o a doua foaie creată ca „RegressionSuite” iar acest lucru va prelua automat toate scenariile testului de regresie prin macro.
• CTRL + SHIFT + S este setat ca comandă rapidă pentru executarea macro-ului.

FunctionalTestScenarios

RegressionSuite

Cod VBA (Macro)

Explicația Codului

1. Foi de calcul („FunctionalTestScenarios”). Activati: Când există mai multe foi în Excel, metoda Activare activează prima foaie și, prin urmare, focalizarea este setată în mod explicit la prima foaie.
2. Rânduri („1: 1”). Selectați: Această declarație selectează primul rând pentru toate coloanele primei foi.
3. Selection.AutoFilter: Această declarație aplică filtrul pe primul rând selectat.
4. Sheet1.Range („$ A $ 1: $ D $ 38”). Câmpul AutoFilter: = 4, Criteria1: = ”Da”: Această declarație aplică filtrul automat pe coloana numărul 4, adică „Includeți în suita Regression?” și filtrează înregistrările pentru valoarea „Da”.
5. Lastrow = Sheets („FunctionalTestScenarios”). Celule (Foi („FunctionalTestScenarios”). Rows.Count, „A”). End (xlUp) .Row: Această declarație obține ultimul număr de rânduri ale primei foi.
6. Gama („A2: C2” și Lastrow). Selectați: Această declarație selectează toate rândurile și coloanele primei foi cu Includeți în suita de regresie? = Da.
7. Selecție Copiere: Această declarație copiază toate înregistrările selectate.
8. Foi de calcul („RegressionSuite”). Selectați: Această afirmație deschide 2^ndfoaie.
9. Gama („A2”). Selectați: Această afirmație selectează celula A2 din 2^ndfoaie.
10. Selection.PasteSpecial Paste: = xlPasteValues, Operation: = xlNone, SkipBlanks _: = False, Transpose: = False: Această declarație copiază valoarea sursei selectate a celulei în foaia de destinație. Intervalul de celule de destinație conține doar valorile calculate folosind formulele. Alternativ, se poate utiliza și Lipire: = xlValues. Nu sunt omise goluri. Celulele sursă nu sunt transpuse și nu se efectuează operații matematice.

Exemplu de utilizare # 2

Există momente în care trebuie să aveți cazuri de test create pentru 100 de state sau 1000 de entități (cum ar fi 1000 de formulare de asigurare). Pașii de testare pentru această listă imensă de state sau entități ar putea fi aceiași și repetitivi.

În ciuda acestui fapt, pregătirea cazului de testare ar putea fi una dintre activitățile care consumă mai mult timp, faptul că a avea documentul cazului de testare la locul lui este foarte important pentru a înscrie estimările cerute de la client și pentru ca echipa de control al calității să testeze fiecare caz de test calendarele corect estimate.

Soluţie

În astfel de cazuri, orele lungi de eforturi de pregătire a cazurilor de testare pot fi reduse la o fracțiune de secunde folosind macro-ul.

• Puteți crea o foaie în care doar furnizați intrarea ca un ID de caz de testare și lista unică de entități.
• Creați o macrocomandă care, atunci când este executată, adaugă linii repetitive de pași de testare pentru fiecare dintre aceste entități, iar documentul cazului de testare este gata în câteva secunde, fără a fi nevoie să cheltuiți cantitatea substanțială de eforturi manuale necesare pentru pregătirea cazurilor de testare.

Demo

• Prima foaie „GetTestcasesASAP” este singura foaie bazată pe macro care este goală inițial.
• O altă foaie „Exemple de date de intrare” nu joacă niciun rol în macro. Deține doar eșantionul de date de intrare în scopuri demonstrative.
• Copiați-lipiți datele din intervalul de date de intrare eșantion A2 la B12 în prima foaie.
• Puteți copia-lipi datele de intrare în format - Coloana A = ……. și Coloana B =.
• Odată ce datele de intrare sunt gata, apăsați CTRL + SHIFT + T ca taste de comandă rapidă pentru executarea macro-ului.
• Pașii de testare sunt adăugați automat pentru fiecare ID de caz de testare și documentul cazului de testare este pregătit în doar câteva secunde.

GetTestcasesASAP

Exemplu de date de intrare

Datele de intrare sunt lipite în prima foaie.

Imagine în timpul execuției macro prin apăsarea CTRL + SHIFT + T.

Cod VBA (Macro)

Explicația Codului

(a) Foi de calcul („GetTestcasesASAP”). Activați: Această declarație activează prima foaie.

ce este planificarea testelor și strategia de testare

(b) lastrow = Foi („GetTestcasesASAP”). Celule (Foi („GetTestcasesASAP”). Rânduri. Număr, „A”). End (xlUp) .Rând: Această declarație obține ultimul număr de rânduri. De data aceasta va obține numărul total de număr de rânduri pentru ID-urile inițiale ale cazului de testare tocmai adăugate ca parte a datelor de intrare înainte de executarea macro-ului.

(c) Dim AddRows As Inger: Această declarație declară variabila AddRows ca un tip de date întreg.

(d) AddRows = 5: Această declarație inițializează AddRows cu 5. Variabila este utilizată pentru a insera câteva linii după fiecare ID de caz de testare, astfel încât să poată fi adăugați pași de testare statici pentru fiecare caz de testare.

(e) Dim i Integer: Această declarație declară variabila i ca întreg.

(f) i = lastrow : Această instrucțiune atribuie ultimul număr inițial de rând variabilei i.

(g) Faceți În timp ce i 1 : Acest lucru se face în timp ce bucla introduce 6 rânduri goale după fiecare ID de caz de testare. Buclarea începe de la ultimul ID al cazului de test care progresează până la primul ID al cazului de test.
Rânduri (i & „:” & i + AddRows). Inserați
i = i - 1
Buclă

(h) ScreenUpdating = Adevărat : Această declarație face vizibilă fiecare actualizare a ecranului. Prin urmare, performanța macro-ului ar putea fi ușor lentă. Pentru a optimiza performanța macro-ului, puteți seta și ScreenUpdating = False .

Setarea ScreenUddating la False îmbunătățește performanța macro-ului și accelerează execuția acestuia, cu toate acestea, nu veți putea vedea modificările intermitente care au loc în timpul execuției macro-ului. În schimb, modificările vor apărea numai după finalizarea executării macro-ului.

(i) lastrow = Sheets („GetTestcasesASAP”). Celule (Foi („GetTestcasesASAP”). Rows.Count, „A”). End (xlUp) .Row : Această declarație calculează din nou ultimul număr de rânduri după adăugarea a 6 rânduri noi pentru fiecare probă.

(j) i = 2

(k) În timp ce i<= lastrow + 6
Foi de calcul („GetTestcasesASAP”). Celule (i, 3) = „Validați combinațiile factor-rate”
Foi de calcul („GetTestcasesASAP”). Celule (i + 1, 3) = „Programarea și rularea lucrărilor în lot. „
Foi („GetTestcasesASAP”). Celule (i + 2, 3) = „Punerea în funcțiune a calculelor decontări”
Foi de calcul („GetTestcasesASAP”). Celule (i + 3, 3) = „Deviz rapid și detaliat”
Foi de calcul („GetTestcasesASAP”). Celule (i + 4, 3) = „Ilustrația avantajului“
Foi de calcul („GetTestcasesASAP”). Celule (i + 5, 3) = „Validare sumară a beneficiilor”
i = i + 7
aplica

Acest fragment din bucla while adaugă 6 pași de pași de testare statici pentru fiecare testcase, setând aceste linii ulterior după fiecare ID-uri ale testcasei.

Pașii de testare statici adăugați pentru fiecare caz de testare sunt după cum urmează:

• Pasul 1: Validați combinațiile factor-rate.
• Pasul 2: Lotul de programe și alergări de locuri de muncă.
• Pasul 3: Punerea în funcțiune a calculelor decontări.
• Pasul 4: Deviz rapid și detaliat.
• Pasul 5: Ilustrația beneficiilor.
• Pasul 6: Validarea sumară a beneficiilor.

În plus, împinge, de asemenea, următorul Id al cazului de test în secvență la 6 + 2, adică 8^arând.

De exemplu: Dacă TC1 este pe primul rând, pașii sunt adăugați de la al doilea la al șaptelea rând și TC2 este împins la al optulea rând. O modă similară este urmată și pentru restul codurilor de testare.

Exemplu de utilizare # 3

Există cazuri când un fișier de date imens undeva aproape de 1000 de înregistrări sau mai multe este furnizat de client și scrierea de cazuri de testare pentru aceste înregistrări umeste și maparea fiecărei date cu fiecare pas de testare este o sarcină plictisitoare. Macro poate reduce zilele de efort la câteva minute, economisind astfel timpul de pregătire a cazului de testare.

Soluţie

Fișierul de date furnizat de client poate fi copiat în foaia activată pentru macro. La executarea macro-ului, cazurile de testare sunt create automat în a doua foaie prin maparea automată a datelor de testare cu fiecare etapă de testare pentru fiecare caz de testare.

Demo

• Prima foaie 'Fișier de intrare' iar a doua foaie „ReadyTestCases” sunt principalii contribuabili la macro.
• O altă foaie „Sample -InputFile” nu joacă niciun rol în macro. Deține doar eșantionul de fișiere de date de intrare în scopuri demonstrative.
• Odată ce datele de la „Sample-InputFile” sau fișierul de date furnizat de client este copiat în prima foaie, adică „InputFile”,
• Executați macrocomanda și cazurile de testare sunt create automat pentru fiecare caz de testare în care ID-urile comenzii sunt setate ca id-uri ale cazurilor de testare ( Notă: Nu uitați să plasați identificatorul unic plasat ca prima coloană în Fișierul de intrare).
• Deocamdată, nu avem setată o tastă de comandă rapidă pentru executarea macro, ci trebuie să o rulăm prin opțiunea de executare de pe Vizualizare -> Macro -> Selectați Macro -> Editare -> Fereastra VBA.
• Codul macro gestionează adăugarea dinamică a etapelor de testare. Face o verificare, în cele din urmă, pentru a vedea dacă vreuna dintre valorile câmpului este necompletată, dacă da, șterge pasul de testare la fel ca și pasul nu ar fi necesar pentru un câmp necompletat. De exemplu, dacă vă uitați la fișierul de intrare de mai jos, 2^ndînregistrarea nu are valoare pentru Data Expedierii, iar al treilea rând nu are valoare pentru Regiune. Prin urmare, după executarea macro-ului, cazurile de testare care sunt create automat nu vor avea pași de testare corespunzători acestor valori goale.

Sample- InputFile

InputFile: după efectuarea copierii și lipirii datelor din eșantionul InputFile în InputFile

Notă:

• Nu lipiți antetul coloanei din foaia „Sample-InputFile”.
• Câmpurile galbene evidențiate sunt goale, prin urmare pașii de testare corespunzători acestor valori goale nu ar trebui create prin intermediul macro.

Imagine a foii ReadyTestcases după Macro Run.

Cod VBA (Macro)

Explicația Codului

# 1) ScreenUpdating = False: Actualizările de ecran nu vor fi vizibile setând ScreenUpdating la False.

# 2) ThisWorkbook.Sheets („InputFile”). Activați: Această declarație activează foaia „InputFile”.

# 3) nrow = ThisWorkbook.Sheets („InputFile”). Celule (Rows.Count, 1) .End (xlUp) .Row: Această declarație obține numărul total de rânduri.

# 4) ncol = ThisWorkbook.Sheets („InputFile”). Celule (1, Columns.Count). End (xlToLeft) .Column: Această declarație obține numărul total de coloane.

# 5) i = 1: Această afirmație inițializează i cu 1.

# 6) j = 1: Această afirmație inițializează j cu 1.

# 7) For i = 1 To nrow
ThisWorkbook.Sheets („ReadyTestCases”). Cells (i, 1) = ThisWorkbook.Sheets („InputFile”). Cells (i, 1)
Apoi eu : Acest fragment de copiere pentru buclă For lipește prima valoare a coloanei (ID-ul comenzii în acest caz) a foii „InputFile” în fiecare rând al foii „ReadyTestCases” ca id al testcasei.

# 8) lastrow = Sheets („InputFile”). Celule (Foi („InputFile”). Rows.Count, „A”). End (xlUp) .Row: Această instrucțiune recalculează ultimul număr de rânduri al InputFile.

# 9) AddRows = 21: Această declarație atribuie 21 variabilei AddRows. Această variabilă a fost atribuită 21 cu intenția de a insera 21 de rânduri goale suplimentare pentru fiecare caz de testare pentru adăugarea etapelor de testare.

# 10) i = lastrow: Această declarație atribuie ultimul număr de rânduri lui i.

# 11) Fă în timp ce eu 1
Rânduri (i & „:” & i + AddRows - 1) .Insert
i = i - 1
Buclă: Această declarație adaugă 20 de rânduri pentru fiecare probă, începând de la partea de jos până la partea de sus.

# 12) lastrow = Foi („ReadyTestCases”). Celule (Foi („ReadyTestCases”). Rânduri. Număr, „A”). End (xlUp). Rând: Această declarație recalculează cel mai recent număr total de rânduri.

# 13) ThisWorkbook.Sheets („ReadyTestCases”). Activati: A doua foaie este activată prin această declarație.

# 14) Dim pentru: Această declarație declară variabila a.

# 15) a = 1: Această declarație atribuie 1 la a.

# 16) Pentru a = 1 Pentru a lastrow

ThisWorkbook.Sheets („ReadyTestCases”). Cells (a, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 2)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 1, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 3)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 2, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 4)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 3, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 5)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 4, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 6)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 5, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 7)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 6, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 8)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 7, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 9)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 8, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 10)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 9, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 11)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 10, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 12)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 11, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 13)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 12, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 14)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 13, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 15)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 14, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 16)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 15, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 17)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 16, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 18)
ThisWorkbook.Sheets („ReadyTestCases”). Cells (a + 17, 3) = ThisWorkbook.Sheets („InputFile”). Cells (a, 19)
a = a + 21
Următorul a: Fragmentul pentru bucla for mapează valorile din fiecare coloană a foii InputFile cu fiecare etapă de testare pentru fiecare ID de caz de testare.

# 17) lastrow = Foi („ReadyTestCases”). Celule (Foi („ReadyTestCases”). Rows.Count, „C”). End (xlUp) .Row : Această declarație recalculează numărul total de rânduri Foaie ReadyTestCases după adăugarea a 21 de rânduri pentru fiecare ID de caz de testare.

# 18) a = 1: Această declarație atribuie 1 variabilei a.

# 19) ThisWorkbook.Sheets („ReadyTestCases”). Activați: Această declarație activează foaia ReadyTestCases.

# 20) Pentru a = 1 Pentru a lastrow

ThisWorkbook.Sheets („ReadyTestCases”). Celule (a, 2) = „Verificați data comenzii”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 1, 2) = „Verificați data expedierii”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 2, 2) = „Verificați modul navei”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 3, 2) = „Verificați codul clientului”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 4, 2) = „Verificați numele clientului”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 5, 2) = „Verificați segmentul”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 6, 2) = „Verificați orașul”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 7, 2) = „Verify State”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 8, 2) = „Verificați codul poștal”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 9, 2) = „Verificați regiunea”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 10, 2) = „Verificați codul produsului”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 11, 2) = „Verificați categoria”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 12, 2) = „Verificați subcategoria”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 13, 2) = „Verificați numele produsului”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 14, 2) = „Verificați vânzările”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 15, 2) = „Verificați cantitatea”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 16, 2) = „Verificați reducerea”
ThisWorkbook.Sheets („ReadyTestCases”). Celule (a + 17, 2) = „Verificați profitul”
a = a + 21
Următorul a - Acest fragment de buclă For adaugă pași de testare statici pentru fiecare caz de testare.

# 21) Deleteblankrows („ReadyTestCases”): Apelați funcția Deleteblankrow pentru foaia „Ready TestCases”.

# 22) ScreenUpdating = Adevărat: Acest lucru vă permite să vizualizați actualizările de ecran care se întâmplă ca parte a execuției macro.

# 23) Sub Deleteblankrows (ByVal Sheet As String): Codul de mai jos este pentru funcția Deletblankrows care va verifica dinamic dacă există valori goale în câmpurile de date. Dacă da, pasul de test creat pentru datele necompletate va fi șters la rândul lor prin ștergerea acestor rânduri.

# 24) Dim wks Ca foaie de lucru: Această declarație declară variabilă wks ca foaie de lucru.

# 25) Set wks = ThisWorkbook.Worksheets (Sheet): Această declarație atribuie foaia wks furnizată ca parametru de intrare.

# 26) Dim i As Long: Această căptușeală declară că eu sunt lung.

# 28) săptămâni. Activați: Această declarație activează foaia.

# 29) lastrow = wks.Cells (Sheets (Sheet) .Rows.Count, „C”). End (xlUp). Rând: Această declarație obține numărul ultimului rând de pe foaie.

# 30) Pentru i = 1 Pentru a lastrow: Bucla For iterează de la primul rând până la ultimul rând.

# 31) Dacă WorksheetFunction.CountBlank (Range (Cells (i, 2), Cells (i, 3))) = 1 Apoi: Această condiție verifică dacă pentru fiecare rând, a doua și a treia coloană contează până la valoarea goală ca 1.

# 32) Selecție.Rânduri (i). Întreg rând. Ștergeți: Această declarație șterge rândul selectat dacă condiția este adevărată.

Exemplu de utilizare # 4

Formulele Excel din șablonul Estimări de test pot fi rulate folosind și o macro. De asemenea, se creează o diagramă folosind macro-ul.

Demo

• Se păstrează o foaie „Estimări” care va permite utilizatorilor să adauge ore estimate pentru fazele de testare, începând de la înțelegerea cerințelor companiei până la crearea, executarea și refacerea la actualizarea scripturilor de testare.
• Celulele verde evidențiate sunt activate pentru intrarea utilizatorului. Acestea sunt câmpurile de intrare.
• Cele evidențiate în albastru sunt derivate automat.
• Cea de-a doua foaie include indicatori Rework și a treia foaie include indicatori de complexitate.
• Utilizatorul introduce dimensiunea complexității în termeni de H, L și M în coloana D, iar coloana E recuperează automat factorul de complexitate utilizând vlookup din „Valori de complexitate” foaie.
• Utilizatorul introduce dimensiunea de prelucrare în termeni de H, L și M în coloana F, iar coloana G preia automat factorul de complexitate utilizând vlookup din foaia „Măsuri de reluare”.
• Factorii sunt apoi utilizați în coloana H pentru a obține eforturile totale pentru estimare.
• O altă macro, atunci când este executată, pregătește graficul și îl adaugă pe a patra foaie „Grafic”.
• Formulele incluse sunt conduse prin macro utilizând tasta de comandă rapidă CTRL + SHIFT + E.

Estimări

Valori de reelaborare

Valori de complexitate

Diagramă

Cod VBA (macro) pentru foaia de estimări

Explicația Codului

(a) ThisWorkbook.Sheets (1). Activează: Prima foaie „Estimări” se activează.

(b) Foi („Estimări”). Celule (4, 8) = Foi („Estimări”). Celule (4, 2) * Foi („Estimări”). Celule (4, 3) * Foi („Estimări”) ) .Celule (4, 5) * Foi („Estimări”). Celule (4, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 4.

(c) Foi („Estimări”). Celule (5, 8) = Foi („Estimări”). Celule (5, 2) * Foi („Estimări”). Celule (5, 3) * Foi („Estimări”) ) .Celule (5, 5) * Foi („Estimări”). Celule (5, 7): Această afirmație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 5.

(d) Foi („Estimări”). Celule (6, 8) = Foi („Estimări”). Celule (6, 2) * Foi („Estimări”). Celule (6, 3) * Foi („Estimări”) ) .Celule (6, 5) * Foi („Estimări”). Celule (6, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 6.

(e) Foi („Estimări”). Celule (7, 8) = Foi („Estimări”). Celule (7, 2) * Foi („Estimări”). Celule (7, 3) * Foi („Estimări”) ) .Celule (7, 5) * Foi („Estimări”). Celule (7, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 7.

(f) Foi („Estimări”). Celule (8, 8) = Foi („Estimări”). Celule (8, 2) * Foi („Estimări”). Celule (8, 3) * Foi („Estimări”) ) .Celule (8, 5) * Foi („Estimări”). Celule (8, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 8.

(g) Foi („Estimări”). Celule (9, 8) = Foi („Estimări”). Celule (9, 2) * Foi („Estimări”). Celule (9, 3) * Foi („Estimări”) ) .Celule (9, 5) * Foi („Estimări”). Celule (9, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 9.

(h) Foi („Estimări”). Celule (10, 8) = Foi („Estimări”). Celule (10, 2) * Foi („Estimări”). Celule (10, 3) * Foi („Estimări”) ) .Celule (10, 5) * Foi („Estimări”). Celule (10, 7): Această declarație calculează coloana B * coloana C * coloana E * coloana G și atribuie coloanei H pentru rândul 10.

(i) Foi („Estimări”). Celule (11, 8) = Foi („Estimări”). Celule (4, 8) + Foi („Estimări”). Celule (5, 8) + Foi („Estimări”) ) .Celule (6, 8) + Foi („Estimări”). Celule (7, 8) + Foi („Estimări”). Celule (8, 8) + Foi („Estimări”). Celule (9, 8) + Foi („Estimări”). Celule (10, 8): Această declarație rezumă celula H2 la H10 și atribuie valoarea finală la H11. Această valoare oferă efort total (în ore).

(j) Pentru i = 3-10
Foi („Grafic”). Celule (i - 2, 1) = Foi („Estimări”). Celule (i, 1)
Foi („Grafic”). Celule (i - 2, 2) = Foi („Estimări”). Celule (i, 8)

Apoi eu : Această copie pentru buclă lipește datele din coloana 1 și coloana 8 din foaia Estimări pe foaia Grafic. Acest lucru se face astfel încât datele din foaia de diagrame să poată fi utilizate pentru a pregăti o diagramă circulară. Există o altă macro scrisă pentru foaia „Diagramă” care pregătește o diagramă pentru aceeași.

Cod VBA (macro) pentru foaia de diagrame

Explicația Codului

1. Dim rng As Range: Această declarație declară rng ca valoare Range.
2. Dim este ca obiect: Această declarație declară est ca valoare a obiectului.
3. Acest registru de lucru. Foi („Grafic”). Activați: Această declarație activează foaia de diagrame.
4. Setați rng = ActiveSheet.Range („A2: B8”): Intervalul de la A2 la B8 al tablei este setat la rng.
5. Set est = ThisWorkbook.Sheets („Chart”). Shapes.AddChart2: Această afirmație este utilizată pentru a iniția crearea unui nou grafic pe foaia-grafic.
6. est.Chart.SetSourceData Source: = rng: Această afirmație oferă o gamă de date pentru contemplare în grafic.
7. est.Chart.ChartType = xl3DPieExploded: Tipul graficului este setat la 3D Pie de tip Exploded. xl3DPieExploded ajută la determinarea acestui tip de diagramă.
8. est.Chart.HasTitle = Adevărat: Această afirmație verifică dacă graficul are deja un titlu.
9. est.Chart.ChartTitle.Text = „Estimări de testare”: Această declarație înlocuiește titlul graficului la „Estimări de testare”.
10. est.Chart.SetElement (msoElementDataLabelCenter): Această declarație stabilește etichetele de date și legendele pentru grafic.
11. est.Chart.SetElement (msoElementLegendBottom): Această declarație stabilește etichetele de date în partea de jos a graficului.

Modalități de a executa o macro

S-ar putea executa o macro folosind 4 moduri:

1. Folosind pictograma Run din fereastra editorului VBA.
2. În fișierul Excel, selectați opțiunea de meniu Vizualizare -> Macro -> Vizualizare macro -> Selectați numele macro și selectați Executare.
3. Creați o comandă rapidă în timp ce creați macrocomanda și apăsând tastele de comenzi rapide va declanșa executarea macrocomenzii.
4. Cel mai ușor de utilizat este crearea unui buton de acțiune ( De exemplu. Buton de comandă) căruia i se va atribui o macro care, atunci când faceți clic, ar declanșa executarea macro-ului.

Vom vedea cum să adăugăm un buton de comandă și să atribuim o macro butonului. Butonul când faceți clic va executa executarea macro-ului.

Adăugați un buton de control pentru formulare în Excel

• Selectați Meniul „Dezvoltator” -> Inserare -> Comenzi formular -> Pictogramă buton Selectare și adăugați butonul de pe foaia Excel.
• Introduceți numele și valoarea textului pentru buton. Numele butonului este utilizat în codarea VBA pentru a recunoaște acest buton de comandă, în timp ce textul este ceea ce se afișează pe buton.

• Acum faceți clic dreapta pe butonul de comandă și selectați opțiunea „Atribuiți macro” , apare lista de macrocomenzi, selectați numele macrocomenzii pe care doriți să o atribuiți.
• Odată ce macro-ul este alocat, făcând clic pe buton declanșează executarea macro-ului atribuit.
• În acest exemplu, „Obțineți estimări de testare” butonul este atribuit „Estimări” macro.
• În mod similar, vom adăuga un buton de comandă pentru foaia Grafic și vom atribui macrocomanda pentru Grafic pentru a declanșa generarea graficului.

• Dând clic pe „Creați diagramă” butonul rulează macro-ul pentru Grafic. Acest lucru îmbunătățește gradul de utilizare a macro-ului.

Concluzie

Acestea au fost câteva exemple în timp real care ar putea face parte din rutina zilnică a testerului la locul de muncă, care ar putea fi identificate inteligent pentru generarea macro și, prin urmare, ar putea economisi o cantitate suficientă de timp în eforturile manuale irelevante și repetitive prin automatizarea sarcinii.

Capturile de ecran relevante, codul VBA și înțelegerea detaliată a fiecărei linii de cod au fost tratate în acest articol. Sper, acest lucru va oferi un început bun pentru QA-uri cu privire la modul de a te transforma dintr-o mentalitate de testare manuală într-o mentalitate macro.

Pentru persoanele care consideră că munca testerilor manuali este pur și simplu non-tehnică, să le dovedim greșite prin aplicarea necesară a cunoștințelor tehnice pentru a îmbunătăți productivitatea.

Autor: Această postare utilă aprofundată este scrisă de Shobha D. Ea lucrează ca șef de proiect și are peste 9 ani de experiență în testarea manuală, automatizare (IBM RFT și Selenium folosind Java) și testarea API.

Lectură recomandată

• Lucrul cu obiecte Excel VBScript
• Crearea cadrului Selenium și accesarea datelor de testare din Excel - Tutorial Selenium # 21
• Cele mai frecvente sarcini de testare 5 testeri uită să testeze (și cum să eviți asta)
• Primele 5 lucruri pe care trebuie să le aibă un tester pentru Excel (și perspectivele schimbătoare ale testerului software)
• Sub-sarcină JIRA cu exemplu (JIRA Create Sub-task)