UI-Automatisierungstest mit Selenium und NUnit Reihenfolge der Tests Ausführungen

Question

Es ist fast mein Beginn der Automatisierungsprüfung, also möchte ich mich entschuldigen, wenn ich Sie nicht klar machen kann!

So, nach 2 Wochen von Blogs über Automatisierung zu lesen, ich habe NUnit mit Selen WebDriver für UI-Automatisierung zu verwenden, entschieden.

Meine Anwendung ist von Unternehmensebene, die für 3 Jahre noch in Entwicklung ist. Es ist ein Projekt- und Portfolio-Management-System.

Ich habe Hunderte von Seiten und etwa 50% von denen führen CRUD Operationen.

Ich beschloss, die folgende strucutre für meine Anwendung:

I Testdaten als JSON bin mit Format in folgenden und diese Daten zu meiner Ansicht Modelle retrive:

[ 
    { 
    "Name": "Finance", 
    "Description": "division with complete test data", 
    "Color": "#ff0000", 
    "ExpectedStatus": { 
     "WillBeAdded": true, 
     "WillBeDeleted": true, 
     "WillBeUpdated": true 
    }, 
    "PerformableActions": { 
     "ShouldAdd": true, 
     "ShouldDelete": false, 
     "ShouldUpdate": true 
    } 
    }, 
    { 
    "Name": "IT", 
    "Description": "IT projects", 
    "Color": "pink", 
    "ExpectedStatus": { 
     "WillBeAdded": true, 
     "WillBeDeleted": true, 
     "WillBeUpdated": true 
    }, 
    "PerformableActions": { 
     "ShouldAdd": true, 
     "ShouldDelete": false, 
     "ShouldUpdate": true 
    } 
    }, 
    { 
    "Name": "Business", 
    "Description": "division with name and color name", 
    "Color": "yellow", 
    "ExpectedStatus": { 
     "WillBeAdded": true, 
     "WillBeDeleted": true, 
     "WillBeUpdated": true 
    }, 
    "PerformableActions": { 
     "ShouldAdd": true, 
     "ShouldDelete": false, 
     "ShouldUpdate": true 
    } 
    }, 
    { 
    "Name": "", 
    "Description": "division without name and color name, should add white color", 
    "Color": "", 
    "ExpectedStatus": { 
     "WillBeAdded": true, 
     "WillBeDeleted": true, 
     "WillBeUpdated": true 
    }, 
    "PerformableActions": { 
     "ShouldAdd": true, 
     "ShouldDelete": true, 
     "ShouldUpdate": true 
    } 
    }, 
    { 
    "Name": "", 
    "Description": "without name and color name and will not be added", 
    "Color": "black", 
    "ExpectedStatus": { 
     "WillBeAdded": false, 
     "WillBeDeleted": false, 
     "WillBeUpdated": false 
    }, 
    "PerformableActions": { 
     "ShouldAdd": true, 
     "ShouldDelete": false, 
     "ShouldUpdate": false 
    } 
    } 
] 

Ich bin hier mit zwei sachen:

1. PerformableActions ie was Aktionen kann ich mit diesen Testfalldaten durchführen. ZB soll Add bedeutet, dass dieser Testfall für das Hinzufügen eines Datensatzes durchgeführt werden soll, bedeutet sentDelete, dass dieser Testfall zum Löschen des Datensatzes ausgeführt werden soll, ähnlich sollte auch update ausgeführt werden.

2. ExpectedStatus das heißt, was das erwartete Ergebnis des Testfall werden, WillBeAdded Mittel diese Daten Gitter hinzugefügt werden würde. Ähnlich funktionieren WillBeDeleted und WillBeUpdated.

Fragen:

1) I für all CUD Operationen gleiche Testdaten verwenden, ist der Grund dafür, dass ich die CUD fließen in meinen app zu halten habe. Da ich nur die Benutzeroberfläche testen muss, gehe ich davon aus, dass Create, Retrieve und Delete in der richtigen Reihenfolge funktionieren.

Ist dies der richtige Test für CRUD-Operationen?

2) Denken Sie, dass ich alle Tests in meinem Projekt auszuführen haben, ist esHunderte oder Tausende sein kann, Wie würde ich Ordnung aufrechtzuerhalten, da ich die einzige Möglichkeit Bestellen Attribut zu verwenden, sehen kann, ist in NUNit. Wie kann ich das verwenden oder gibt es Alternativen, um eine Gruppe unabhängiger Module und abhängiger Module einzeln zu testen?

Answer 1

1. Es ist nichts falsch mit Ihrem Ansatz. Sie können für jeden Fall eine Funktion erstellen und C, U und D in der von Ihnen gewünschten Reihenfolge erstellen. Vielleicht müssen Sie wait s zwischen ihnen hinzufügen, damit das Backend seine Enterprisys macht.
2. OrderAttribute mit NUnit funktioniert gut genug, auch wenn es bessere Möglichkeiten gibt. Sie können auch Listen von Testfällen erstellen und diese nacheinander in der Reihenfolge ausführen. Warum nicht? Beschränke dich nicht auf Klassen und Methoden.

3. Ich weiß, Sie haben Ihre Frage mit C# markiert, aber für diese Menge an Arbeit lohnt es sich vielleicht, einige andere Bibliotheken zu betrachten, als Sie jetzt haben. Wenn Ihr keine Angst vor sehr wenig Lernen, können Sie F # genießen:

   • mit Expecto haben Sie die volle Kontrolle, in welcher Reihenfolge und welche testen Sie
   • mit Canopy führen Sie einen schönen DSL für das Selen haben. Hier ist die starter kit mit kleinem Beispiel. Und Sie können es sogar in der docker mit Chrom laufen in Headless Modus
   • und Sie können sogar Intellisense für Ihre Json Testdefinitionen mit Json Type Provider

UPDATE erhalten: für die Bestellung Sie die definieren eigene Attribute, oder verwenden Sie sogar existierende von NUnit, und rufen Sie die Methoden pro Reflexion in der richtigen Reihenfolge auf. Oder Sie definieren eigenes DSL für Tests und durchlaufen die Listen und extrahieren die benötigten Informationen.

public struct CRUD 
{ 
    public bool C; 
    public bool R; 
    public bool U; 
    public bool D; 
    public CRUD(bool c, bool r, bool u, bool d) 
    { 
     this.C = c; 
     this.R = r; 
     this.U = u; 
     this.D = d; 
    } 
} 
public enum ActionKind 
{ 
    Create, 
    Read, 
    Update, 
    Delete 
} 
public struct TestResult 
{ 
    public ActionKind Action; 
    public bool IsPerformed; 
} 
public class TestCase 
{ 
    public string Name { get; set; } 
    public string Description { get; set; } 
    public string Color { get; set; } 
    public CRUD Action { get; set; } 
    public List<TestResult> Actual { get; set; } 
    public List<TestResult> Expected { get; set; } // or List<TestResult> 

} 
public class Tests 
{ 
    public void TestAListOfCases() 
    { 
     var cases = new List<TestCase> 
     { 
      new TestCase { Name = "Finance", Description = "division with complete test data", Color = "#ff0000", 
       Expected = new List<TestResult> {new TestResult {Action = ActionKind.Create, IsPerformed = true }, 
               new TestResult {Action = ActionKind.Update, IsPerformed = false}, 
               new TestResult {Action = ActionKind.Delete, IsPerformed = true } 
       }}, 
      new TestCase { Name = "IT", Description = "Description"} 
     }; 

     cases 
      .Where(x => x.Name == "IT") 
      .Where(x => x.Color != "pink") 
      .Select(RunTestCase) 
      .Where(x => !x.Item2) 
      .Select(x => OutputFailedTestCase(x.Item1)); // boah c# is verbose 
    } 
    public Tuple<TestCase, bool> RunTestCase(TestCase testCase) 
    { 
     foreach(var exp in testCase.Expected) 
     { 
      switch (exp.Action) { 
       case ActionKind.Delete: 
        // do delete if needed and create actual result 
        var actual = exp.IsPerformed 
         ? new TestResult { Action = exp.Action, IsPerformed = true } 
         : new TestResult { Action = exp.Action, IsPerformed = false }; 
        break; 

      } 
     } 
     var isFailed = 
      Enumerable.Zip(
       testCase.Actual, 
       testCase.Expected, 
       (expected, actual) => expected.Action == actual.Action && expected.IsPerformed == actual.IsPerformed) 
      .All(x=>x); 
     // your selenium stuff 
     return Tuple.Create(testCase, isFailed); 
    } 
    public bool OutputFailedTestCase(TestCase testCase) 
    { 
     // write to console or do something else 
     Console.Write($"{testCase.Name} is failed to perform following actions: {calculateFailedActions}"); 
     return true; 
    } 
}