

Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS wird der Support für eingestellt. AWS IoT Greengrass Version 1 Nach dem 7. Oktober 2026 können Sie nicht mehr auf die Ressourcen zugreifen. AWS IoT Greengrass V1 Weitere Informationen finden Sie unter [Migrieren von AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie den IDT-Kontext
<a name="idt-context"></a>

Wenn IDT eine Testsuite ausführt, kann die Testsuite auf einen Datensatz zugreifen, anhand dessen bestimmt werden kann, wie die einzelnen Tests ausgeführt werden. Diese Daten werden als IDT-Kontext bezeichnet. Beispielsweise wird die Benutzerdatenkonfiguration, die von Testläufern in einer `userdata.json` Datei bereitgestellt wird, Testsuiten im IDT-Kontext zur Verfügung gestellt. 

Der IDT-Kontext kann als schreibgeschütztes JSON-Dokument betrachtet werden. Testsuiten können mithilfe von Standard-JSON-Datentypen wie Objekten, Arrays, Zahlen usw. Daten aus dem Kontext abrufen und Daten in den Kontext schreiben.

## Kontextschema
<a name="idt-context-schema"></a>

Der IDT-Kontext verwendet das folgende Format:

```
{
    "config": {
        <config-json-content>
        "timeoutMultiplier": timeout-multiplier
    },
    "device": {
        <device-json-device-element>
    },
    "devicePool": {
        <device-json-pool-element>
    },
    "resource": {
        "devices": [
            {
                <resource-json-device-element>
                "name": "<resource-name>"
            }
        ]
    },
    "testData": {
        "awsCredentials": {
            "awsAccessKeyId": "<access-key-id>",
            "awsSecretAccessKey": "<secret-access-key>",
            "awsSessionToken": "<session-token>"
        },
        "logFilePath": "/path/to/log/file"
    },
    "userData": {
        <userdata-json-content>
    }
}
```

`config`  
Informationen aus der [`config.json`Datei](gg-core.md#config-json). Das `config` Feld enthält außerdem das folgende zusätzliche Feld:    
`config.timeoutMultiplier`  
Der Multiplikator für jeden Timeout-Wert, der von der Testsuite verwendet wird. Dieser Wert wird vom Test-Runner über die IDT-CLI angegeben. Der Standardwert ist `1`.

`device`  
Informationen über das für den Testlauf ausgewählte Gerät. Diese Information entspricht dem `devices` Array-Element in der [`device.json`Datei](set-config-custom.md#device-config-custom) für das ausgewählte Gerät.

`devicePool`  
Informationen über den Gerätepool, der für den Testlauf ausgewählt wurde. Diese Informationen entsprechen dem Element des Gerätepool-Arrays der obersten Ebene, das in der `device.json` Datei für den ausgewählten Gerätepool definiert ist.

`resource`  
Informationen zu Ressourcengeräten aus der `resource.json` Datei.    
`resource.devices`  
Diese Informationen entsprechen dem in der `resource.json` Datei definierten `devices` Array. Jedes `devices` Element enthält das folgende zusätzliche Feld:    
`resource.device.name`  
Der Name des Ressourcengeräts. Dieser Wert ist auf den `requiredResource.name` Wert in der `test.json` Datei festgelegt.

`testData.awsCredentials`  
Die AWS Anmeldeinformationen, die vom Test für die Verbindung mit der AWS Cloud verwendet wurden. Diese Informationen werden aus der `config.json` Datei abgerufen.

`testData.logFilePath`  
Der Pfad zur Protokolldatei, in die der Testfall Protokollnachrichten schreibt. Die Testsuite erstellt diese Datei, falls sie nicht existiert. 

`userData`  
Informationen, die vom Testrunner in der [`userdata.json`Datei](set-config-custom.md#userdata-config-custom) bereitgestellt wurden.

## Greifen Sie auf Daten im Kontext zu
<a name="accessing-context-data"></a>

Sie können den Kontext mithilfe der JSONPath-Notation aus Ihren JSON-Dateien und aus Ihrer ausführbaren Textdatei mit den APIs `GetContextValue` und `GetContextString` abfragen. Die Syntax für JSONPath-Zeichenfolgen für den Zugriff auf den IDT-Kontext variiert wie folgt:
+ In `suite.json` und verwenden `test.json` Sie. `{{{{query}}}}` Das heißt, verwenden Sie nicht das Stammelement`$.`, um Ihren Ausdruck zu starten.
+ In`statemachine.json`, du benutzt`{{$.{{query}}}}`.
+ In API-Befehlen verwenden Sie je nach Befehl `{{query}}` oder`{{$.{{query}}}}`. Weitere Informationen finden Sie in der Inline-Dokumentation in den SDKs. 

In der folgenden Tabelle werden die Operatoren in einem typischen JSONPath-Ausdruck beschrieben:


| Operator  | Description  | 
| --- |--- |
| $ | Das Stammelement. Da es sich bei dem Kontextwert der obersten Ebene für IDT um ein Objekt handelt, verwenden Sie ihn normalerweise, um Ihre Abfragen $. zu starten. | 
| .childName | Greift auf das untergeordnete Element mit dem Namen eines Objekts childName zu. Wenn es auf ein Array angewendet wird, ergibt dies ein neues Array, bei dem dieser Operator auf jedes Element angewendet wird. Beim Elementnamen wird zwischen Groß- und Kleinschreibung unterschieden. Die Abfrage für den Zugriff auf den awsRegion Wert im config Objekt lautet beispielsweise$.config.awsRegion. | 
| [start:end] | Filtert Elemente aus einem Array und ruft Elemente ab, die mit dem start Index beginnen und bis zum end Index aufsteigen, jeweils inklusive. | 
| [index1, index2, ... , indexN] | Filtert Elemente aus einem Array und ruft nur Elemente aus den angegebenen Indizes ab. | 
| [?(expr)] | Filtert Elemente aus einem Array mithilfe des expr Ausdrucks. Dieser Ausdruck muss einen booleschen Wert ergeben. | 

Verwenden Sie die folgende Syntax, um Filterausdrücke zu erstellen:

```
{{<jsonpath>}} | {{<value>}} {{operator}} {{<jsonpath>}} | {{<value>}} 
```

In dieser Syntax gilt: 
+ `jsonpath`ist ein JSONPath, der die Standard-JSON-Syntax verwendet. 
+ `value`ist ein beliebiger benutzerdefinierter Wert, der die Standard-JSON-Syntax verwendet.
+ `operator`ist einer der folgenden Operatoren:
  + `<`(Weniger als)
  + `<=`(Weniger als oder gleich)
  + `==`(Gleich)

    Wenn der JSONPath oder der Wert in Ihrem Ausdruck ein Array, ein boolescher Wert oder ein Objektwert ist, dann ist dies der einzige unterstützte binäre Operator, den Sie verwenden können.
  + `>=`(Größer als oder gleich)
  + `>`(Größer als)
  + `=~`(Übereinstimmung mit regulären Ausdrücken). Um diesen Operator in einem Filterausdruck zu verwenden, muss der JSONPath oder der Wert auf der linken Seite Ihres Ausdrucks zu einer Zeichenfolge ausgewertet werden, und auf der rechten Seite muss es sich um einen Musterwert handeln, der der [RE2-Syntax](https://github.com/google/re2/wiki/Syntax) folgt.

Sie können JSONPath-Abfragen in der Form {{{{query}}}} als Platzhalterzeichenfolgen innerhalb der Felder und in Dateien `args` und innerhalb der `environmentVariables` Felder in `test.json` Dateien verwenden. `environmentVariables` `suite.json` IDT führt eine Kontextsuche durch und füllt die Felder mit dem ausgewerteten Wert der Abfrage. In der `suite.json` Datei können Sie beispielsweise Platzhalterzeichenfolgen verwenden, um Umgebungsvariablenwerte anzugeben, die sich mit jedem Testfall ändern, und IDT füllt die Umgebungsvariablen mit dem richtigen Wert für jeden Testfall. Wenn Sie jedoch Platzhalterzeichenfolgen in `test.json` und `suite.json` -Dateien verwenden, gelten für Ihre Abfragen die folgenden Überlegungen:
+ Sie müssen jedes Vorkommen des `devicePool` Schlüssels in Ihrer Abfrage in Kleinbuchstaben angeben. Das heißt, verwenden Sie `devicepool` stattdessen.
+ Für Arrays können Sie nur Zeichenketten-Arrays verwenden. Darüber hinaus verwenden Arrays ein nicht standardmäßiges Format. `item1, item2,...,itemN` Wenn das Array nur ein Element enthält, wird es als serialisiert`item`, sodass es nicht von einem Zeichenkettenfeld zu unterscheiden ist. 
+ Sie können keine Platzhalter verwenden, um Objekte aus dem Kontext abzurufen.

Aus diesen Gründen empfehlen wir, wann immer möglich, die API für den Zugriff auf den Kontext in Ihrer Testlogik anstelle von Platzhalterzeichenfolgen in `test.json` und `suite.json` -Dateien zu verwenden. In einigen Fällen kann es jedoch praktischer sein, JsonPath-Platzhalter zu verwenden, um einzelne Zeichenketten abzurufen, die als Umgebungsvariablen festgelegt werden sollen. 