Was sind Fixtures in der Programmierung?

Ich habe oft von diesem Begriff gehört (im Zusammenhang mit der Programmierung), konnte aber keine Erklärung dafür finden, was er bedeutete. Irgendwelche guten Artikel oder Erklärungen?

Ich denke, Sie beziehen sich auf Testvorrichtungen :

Der Zweck einer Testvorrichtung besteht darin, sicherzustellen, dass es eine bekannte und feste Umgebung gibt, in der Tests ausgeführt werden, damit die Ergebnisse wiederholbar sind. Einige Leute nennen dies den Testkontext.

Beispiele für Vorrichtungen:

• Laden einer Datenbank mit einem bestimmten, bekannten Datensatz
• Löschen einer Festplatte und Installieren einer bekannten sauberen Betriebssysteminstallation
• Kopieren eines bestimmten bekannten Satzes von Dateien
• Vorbereitung der Eingabedaten und Einrichtung / Erstellung von gefälschten oder Scheinobjekten

(Quelle: Wikipedia, siehe Link oben)

Hier finden Sie auch einige praktische Beispiele aus der Dokumentation des 'Google Test'-Frameworks .

Ich denke, PHP-Unit-Tests haben eine sehr gute Erklärung dafür:

Einer der zeitaufwändigsten Teile beim Schreiben von Tests besteht darin, den Code zu schreiben, um die Welt in einen bekannten Zustand zu versetzen und ihn nach Abschluss des Tests wieder in seinen ursprünglichen Zustand zu versetzen. Dieser bekannte Zustand wird als Fixpunkt des Tests bezeichnet.

Auch in Yii-Dokumenten wurde der Test der Vorrichtungen in einem guten Zustand beschrieben:

Automatisierte Tests müssen viele Male ausgeführt werden. Um sicherzustellen, dass der Testprozess wiederholbar ist, möchten wir die Tests in einem bekannten Zustand ausführen, der als Fixture bezeichnet wird. Um beispielsweise die Funktion zum Erstellen von Posts in einer Blog-Anwendung zu testen, sollten jedes Mal, wenn wir die Tests ausführen, die Tabellen, in denen relevante Daten zu Posts gespeichert sind (z. B. die Post-Tabelle, die Comment-Tabelle), in einem festen Zustand wiederhergestellt werden.

Hier das einfache Beispiel des Vorrichtungs-Tests

<?php
use PHPUnit\Framework\TestCase;

class StackTest extends TestCase
{
    protected $stack;

    protected function setUp()
    {
        $this->stack = [];
    }

    protected function tearDown()
    {
        $this->stack = [];
    }

    public function testEmpty()
    {
        $this->assertTrue(empty($this->stack));
    }

    public function testPush()
    {
        array_push($this->stack, 'foo');
        $this->assertEquals('foo', $this->stack[count($this->stack)-1]);
        $this->assertFalse(empty($this->stack));
    }

    public function testPop()
    {
        array_push($this->stack, 'foo');
        $this->assertEquals('foo', array_pop($this->stack));
        $this->assertTrue(empty($this->stack));
    }
}
?>

Diese PHP - Unit - Test hat Funktionen mit Namen setUpund tearDowndas vor Ihrem Test , den Sie Setup - Daten ausgeführt und fertig Sie können sie in den Ausgangszustand wiederherzustellen.

Der Begriff Fixture variiert je nach Kontext, Programmiersprache oder Framework.

1. Ein bekannter Zustand, gegen den ein Test ausgeführt wird

Einer der zeitaufwändigsten Teile beim Schreiben von Tests besteht darin, den Code zu schreiben, um die Welt in einen bekannten Zustand zu versetzen und ihn nach Abschluss des Tests wieder in seinen ursprünglichen Zustand zu versetzen. Dieser bekannte Zustand wird als Fixpunkt des Tests bezeichnet. PHP-Unit Dokumentation

Ein Testgerät (auch als Testkontext bezeichnet) ist eine Reihe von Voraussetzungen oder Zuständen, die zum Ausführen eines Tests erforderlich sind. Der Entwickler sollte vor den Tests einen bekannten guten Zustand einrichten und nach den Tests in den ursprünglichen Zustand zurückkehren. Wikipedia (xUnit)

2. Eine Datei mit Beispieldaten

Fixtures ist ein schickes Wort für Beispieldaten. Mit Fixtures können Sie Ihre Testdatenbank vor der Ausführung Ihrer Tests mit vordefinierten Daten füllen. Fixtures sind datenbankunabhängig und in YAML geschrieben. Es gibt eine Datei pro Modell. RubyOnRails.org

3. Ein Prozess, der einen erforderlichen Status einrichtet. 

Ein Software-Testgerät richtet das System für den Testprozess ein, indem es ihm den gesamten Code zur Initialisierung zur Verfügung stellt, wodurch alle gegebenen Voraussetzungen erfüllt werden. Ein Beispiel könnte das Laden einer Datenbank mit bekannten Parametern von einem Kundenstandort sein, bevor Sie Ihren Test ausführen. Wikipedia

Genau zu diesem Thema verfügt JUnit über ein gut erklärtes Dokument. Hier ist der Link!

Der verwandte Teil des Artikels ist:

Tests müssen vor dem Hintergrund einer bekannten Gruppe von Objekten ausgeführt werden. Diese Gruppe von Objekten wird als Testvorrichtung bezeichnet. Wenn Sie Tests schreiben, werden Sie häufig feststellen, dass Sie mehr Zeit damit verbringen, den Code zum Einrichten des Geräts zu schreiben, als beim tatsächlichen Testen von Werten.

Bis zu einem gewissen Grad können Sie das Schreiben des Fixture-Codes vereinfachen, indem Sie sorgfältig auf die von Ihnen geschriebenen Konstruktoren achten. Eine viel größere Einsparung ergibt sich jedoch aus der gemeinsamen Nutzung des Gerätecodes. Oft können Sie dasselbe Gerät für mehrere verschiedene Tests verwenden. Jeder Fall sendet leicht unterschiedliche Meldungen oder Parameter an das Gerät und prüft auf unterschiedliche Ergebnisse.

Wenn Sie ein gemeinsames Gerät haben, tun Sie Folgendes:

Fügen Sie ein Feld für jeden Teil des Geräts hinzu. Kommentieren Sie eine Methode mit @ org.junit.Vor und initialisieren Sie die Variablen in dieser Methode. Kommentieren Sie eine Methode mit @ org.junit.Nachher, um alle permanenten Ressourcen freizugeben, die Sie in setUp zugewiesen haben. Zum Beispiel zum Schreiben Mehrere Testfälle, die mit verschiedenen Kombinationen von 12 Schweizer Franken, 14 Schweizer Franken und 28 US-Dollar arbeiten möchten, bilden zunächst eine Vorrichtung:

public class MoneyTest {
    private Money f12CHF;
    private Money f14CHF;
    private Money f28USD;

    @Before public void setUp() {
    f12CHF= new Money(12, "CHF");
    f14CHF= new Money(14, "CHF");
    f28USD= new Money(28, "USD");
    }
}

In Xamarin.UITest wird dies wie folgt erklärt:

In der Regel wird jeder Xamarin.UITest als Methode geschrieben, die als Test bezeichnet wird. Die Klasse, die den Test enthält, wird als Testvorrichtung bezeichnet. Das Testgerät enthält entweder einen einzelnen Test oder eine logische Gruppierung von Tests und ist für alle Einstellungen verantwortlich, mit denen der Test ausgeführt werden soll, sowie für alle Bereinigungen, die nach Abschluss des Tests durchgeführt werden müssen. Jeder Test sollte dem Arrange-Act-Assert-Muster folgen:

• Anordnen - Der Test richtet die Bedingungen ein und initialisiert die Dinge, damit der Test ausgeführt werden kann.
• Act - Der Test interagiert mit der Anwendung, gibt Text ein, drückt Tasten usw.
• Assert - Der Test überprüft die Ergebnisse der im Schritt Act durchgeführten Aktionen, um die Richtigkeit festzustellen. Beispielsweise kann die Anwendung überprüfen, ob eine bestimmte Fehlermeldung angezeigt wird.

Link zum Originalartikel des obigen Auszugs

Und innerhalb des Xamarin.UITest-Codes sieht es folgendermaßen aus:

using System;
using System.IO;
using System.Linq;
using NUnit.Framework;
using Xamarin.UITest;
using Xamarin.UITest.Queries;

namespace xamarin_stembureau_poc_tests
{
    [TestFixture(Platform.Android)]
    [TestFixture(Platform.iOS)]
    public class TestLaunchScreen
    {
        IApp app;
        Platform platform;

        public Tests(Platform platform)
        {
            this.platform = platform;
        }

        [SetUp]
        public void BeforeEachTest()
        {
            app = AppInitializer.StartApp(platform);
        }

        [Test]
        public void AppLaunches()
        {
            app.Screenshot("First screen.");
        }

        [Test]
        public void LaunchScreenAnimationWorks()
        {
            app.Screenshot("Launch screen animation works.");
        }
    }
}

Ich hoffe, dies könnte für jemanden hilfreich sein, der nach einem besseren Verständnis für Fixtures in Programming sucht.