Agent skill

Unity Editor Driver E2E

by kurotu in kurotu/VRCQuestTools

Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository.

MITAuto-check passedTesting & QA

Install Unity Editor Driver E2E

skills CLI
$ npx skills add kurotu/VRCQuestTools --skill unity-editor-driver-e2e -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install kurotu/VRCQuestTools unity-editor-driver-e2e --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/kurotu/VRCQuestTools.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/unity-editor-driver-e2e .claude/skills/unity-editor-driver-e2e && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
unity-editor-driver-e2e
GitHub stars
373
Token cost
~3.1k tokens
SKILL.md length
612 words
Files
2
Skills in repo
25
Repo updated
First seen
Licence
MIT

At a glance

Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository.

  • Works in 11 steps: Assembly Setup → Test Structure → Opening Windows and Inspectors → …
  • You need to write
  • SKILL.md covers Table of Contents, Assembly Setup, Test Structure and Opening Windows and Inspectors, plus 9 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Unity Editor Driver E2E is an agent skill from kurotu/VRCQuestTools. Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository. Use this skill whenever you need to write, fix, or extend EditMode E2E tests that interact with editor UI controls — even if the request only mentions "test", "automate inspector", "UI test", "check window behavior", or similar phrases. The framework works non-invasively: no changes to the target window or inspector code are ever required.

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `evals/evals.json`).

It sits in Testing & QA, covering End-to-end testing. It works with Unity. The repository describes itself as: Unity editor extension to support uploading VRChat avatars for Oculus Quest. The licence is MIT.

When your agent uses it

  • You need to write
  • Extend EditMode E2E tests that interact with editor UI controls — even if the request only mentions test
  • Automate inspector
  • Check window behavior

Example prompts

  • “automate inspector”
  • “UI test”
  • “check window behavior”
  • “/unity-editor-driver-e2e”

Workflow steps

11 steps, taken from the first numbered list in SKILL.md.

  1. Assembly Setup
  2. Test Structure
  3. Opening Windows and Inspectors
  4. Discovering Controls with Page.Scan
  5. Manual Control Descriptor with Page.Describe
  6. Locator API
  7. Interacting with Dynamic UIs
  8. State Verification Patterns
  9. UIElements-Specific Notes
  10. Screenshots
  11. Cross-Platform Notes

What it can do on your machine

Read from SKILL.md and the folder at commit c68d147. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are csharp, json and bash).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Unity Editor Driver E2E loads about 3.1k tokens when it runs. Until then it costs about 127 tokens; SKILL.md has 612 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~127
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from kurotu/VRCQuestTools at commit c68d147, republished under its MIT licence (© kurotu). 612 words, ~3,140 tokens.

Download SKILL.mdSave it as .claude/skills/unity-editor-driver-e2e/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
unity-editor-driver-e2e
description
Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository. Use this skill whenever you need to write, fix, or extend EditMode E2E tests that interact with editor UI controls — even if the request only mentions "test", "automate inspector", "UI test", "check window behavior", or similar phrases. The framework works non-invasively: no changes to the target window or inspector code are ever required.

unity-editor-driver E2E Testing

EditorDriver lets you automate and assert on Unity Editor windows and custom Inspectors without touching the target code. Tests live in EditMode test assemblies and run via Unity Test Runner.

Table of Contents

  1. Assembly Setup
  2. Test Structure
  3. Opening Windows and Inspectors
  4. Discovering Controls with Page.Scan
  5. Manual Control Descriptor with Page.Describe
  6. Locator API
  7. Interacting with Dynamic UIs
  8. State Verification Patterns
  9. UIElements-Specific Notes
  10. Screenshots
  11. Cross-Platform Notes

Assembly Setup

Create an .asmdef for your test assembly. Reference EditorDriver.Editor (and your target window/component assemblies). Enable UNITY_INCLUDE_TESTS so the assembly is only included in test builds.

json
{
  "name": "MyPlugin.E2ETests.Editor",
  "rootNamespace": "MyPlugin.Tests",
  "references": [
    "EditorDriver.Editor",
    "MyPlugin.Editor",
    "MyPlugin.Runtime"
  ],
  "includePlatforms": ["Editor"],
  "overrideReferences": true,
  "precompiledReferences": ["nunit.framework.dll"],
  "autoReferenced": false,
  "defineConstraints": ["UNITY_INCLUDE_TESTS"]
}

Test Structure

Every E2E test fixture follows the same shape:

csharp
using System.Collections;
using NUnit.Framework;
using UnityEngine.TestTools;
using EditorDriver;

[TestFixture]
public class MyWindowE2ETests
{
    private Driver _driver;

    [SetUp]
    public void SetUp()
    {
        _driver = new Driver();
    }

    [TearDown]
    public void TearDown()
    {
        _driver?.Dispose(); // closes all windows and destroys GameObjects
    }

    [UnityTest]
    public IEnumerator SomeTest()
    {
        var handle = _driver.OpenWindow<MyWindow>();
        yield return null; // let Unity process the window's first OnGUI

        // ... interact and assert ...
    }
}

Key rules:

  • Use [UnityTest] with IEnumerator for any test that needs an OnGUI frame.
  • Always yield return null immediately after opening a window or inspector.
  • Always call _driver.Dispose() (or CloseAll()) in [TearDown] — never rely on the test framework to clean up Unity objects.

Opening Windows and Inspectors

EditorWindows
csharp
// Opens a fresh instance (never reuses an existing window)
var handle = _driver.OpenWindow<MyWindow>();
var window = handle.Window; // the EditorWindow instance
Custom Inspectors
csharp
// Creates a temporary GameObject, adds TComponent, opens the default Editor in an isolated window
var handle = _driver.OpenInspector<MyComponent>();

// With an explicit Editor type
var handle = _driver.OpenInspector<MyComponent, MyComponentEditor>();

// InspectorHandle properties
handle.Window    // EditorWindow hosting the inspector
handle.Editor    // UnityEditor.Editor instance
handle.Component // the Component on the temporary GameObject
handle.GameObject // the temporary GameObject
Cleanup
csharp
_driver.CloseWindow(windowHandle);        // close a specific window
_driver.CloseInspector(inspectorHandle);  // close inspector and destroy its GameObject
_driver.CloseAll();                       // close everything (also called by Dispose)

Discovering Controls with Page.Scan

Page.Scan is the recommended approach. It auto-discovers all interactive controls without any manual descriptor. It works for both IMGUI and UIElements windows.

csharp
var handle = _driver.OpenWindow<MyWindow>();
yield return null;

var page = Page.Scan(handle.Window);
Querying controls
csharp
// By displayed text value (IMGUI and UIElements)
var locator = page.GetByValue("Hello World");

// By label text — works with UIElements; also works with IMGUI via Page.Describe
var locator = page.GetByLabel("Text Field");

// By type and zero-based index
var firstToggle  = page.GetByType(ControlType.Toggle, 0);
var secondToggle = page.GetByType(ControlType.Toggle, 1);

// All discovered controls
IReadOnlyList<ControlInfo> all = page.Controls;

GetByValue / GetByLabel / GetByType all throw InvalidOperationException when the control is not found — use this as an implicit assertion.


Manual Control Descriptor with Page.Describe

Use Page.Describe when you know the window's layout in advance and prefer label-based access. This works for both IMGUI and UIElements; the resolver is auto-detected.

csharp
var page = Page.Describe(handle.Window, p =>
{
    p.Label("Base Settings", EditorStyles.boldLabel);
    p.TextField("Text Field");
    p.BeginToggleGroup("Optional Settings");
    p.Toggle("Inner Toggle");
    p.Slider("Slider", -3f, 3f);
    p.EndToggleGroup();
    p.Button("Apply");
    p.IntField("Count");
    p.FloatField("Scale");
    p.ObjectField("Target");
});

page.GetByLabel("Text Field").Fill("new value");

Available descriptor methods: Label, TextField, Toggle, Slider, BeginToggleGroup, EndToggleGroup, Button, IntField, FloatField, ObjectField.


Locator API

All query methods return a Locator. Use it to interact with or inspect a single control.

MethodDescription
ReadText()Reads the displayed text (via clipboard SelectAll→Copy)
Fill(string)Clears the field and types the given text
Toggle()Clicks a checkbox or toggle control
SetSlider(float)Types a value into the slider's numeric field
Click()Clicks the center of the control
CaptureScreenshot()Returns a Texture2D cropped to the control area
.ControlTypeThe ControlType enum value
.RectThe Rect of the control in screen space

After Fill, Toggle, or SetSlider, always repaint and yield before asserting:

csharp
page.GetByValue("Hello World").Fill("New Text");
handle.Repaint();
yield return null;

page.Refresh(); // re-discover controls after UI change
Assert.AreEqual("New Text", page.GetByValue("New Text").ReadText());

Show full SKILL.md (263 more words)Show less

Interacting with Dynamic UIs

When the UI changes (e.g. a toggle group expands to reveal more controls), call page.Refresh() after the change to re-discover the new state. Controls inside a disabled group are not discoverable until the group is enabled.

csharp
var page = Page.Scan(handle.Window);
int countBefore = page.Controls.Count;

// Enable a toggle group (toggle at index 1 in this example)
page.GetByType(ControlType.Toggle, 1).Toggle();
handle.Repaint();
yield return null;

page.Refresh(); // picks up newly active controls

Assert.Greater(page.Controls.Count, countBefore);

// Inner slider is now reachable
var slider = page.GetByValue("1.23");
slider.Fill("2.5");

State Verification Patterns

EditorWindow — UI→State and State→UI

WindowHandle exposes reflection helpers for white-box state assertions:

csharp
// UI → State: interact, then read internal field
page.GetByValue("Hello World").Fill("Updated");
handle.Repaint();
yield return null;

string val = handle.GetFieldValue<string>("myString");
Assert.AreEqual("Updated", val);

// State → UI: write internal field, then verify it appears in the UI
handle.SetFieldValue("myString", "From Code");
handle.Repaint();
yield return null;

page.Refresh();
Assert.AreEqual("From Code", page.GetByValue("From Code").ReadText());
IMGUI Inspector — Component field access

For IMGUI inspectors, cast handle.Component and read/write public fields directly:

csharp
var component = (MyComponent)handle.Component;

// UI → State
page.GetByValue("Hello World").Fill("Inspector Test");
handle.Repaint();
yield return null;
Assert.AreEqual("Inspector Test", component.myString);

// State → UI
component.myString = "From Code";
handle.Repaint();
yield return null;
page.Refresh();
Assert.AreEqual("From Code", page.GetByValue("From Code").ReadText());
UIElements Inspector — SerializedObject sync required

UIElements inspectors use BindProperty, so after a direct field change you must notify the binding system via serializedObject.Update() before repainting:

csharp
var component = (MyUIElementsComponent)handle.Component;

// State → UI (UIElements binding requires serializedObject.Update)
component.myString = "From Code";
handle.Editor.serializedObject.Update();
handle.Repaint();
yield return WaitForBindings();

page.Refresh();
Assert.AreEqual("From Code", page.GetByLabel("Text Field").ReadText());

UIElements-Specific Notes

Waiting for bindings

UIElements bindings may not resolve in a single frame. For read operations on UIElements inspectors, yield multiple frames before scanning:

csharp
private static IEnumerator WaitForBindings()
{
    yield return null;
    yield return null;
    yield return null;
}

[UnityTest]
public IEnumerator ReadUIElementsField()
{
    var handle = _driver.OpenInspector<MyUIElementsComponent>();
    yield return WaitForBindings(); // instead of a single yield return null

    var page = Page.Scan(handle.Window);
    Assert.AreEqual("Hello World", page.GetByLabel("Text Field").ReadText());
}
Label-based lookup available

Unlike IMGUI Scan (value-only), UIElements Scan exposes labels from the visual tree, so GetByLabel works out of the box:

csharp
// UIElements windows support both:
page.GetByLabel("Text Field").Fill("new");
page.GetByValue("Hello World").ReadText();
InspectorHandle.Repaint()

On Linux, call handle.Repaint() before reading UIElements state after mutating serialized data. It walks IBindable elements and forces binding.PreUpdate()/binding.Update(), which avoids stale bindings.


Screenshots

Always build paths with Path.Combine and Path.GetTempPath() for cross-platform safety. Clean up in [TearDown].

csharp
using System.IO;

[SetUp]
public void SetUp()
{
    _driver = new Driver();
    _screenshotDir = Path.Combine(Path.GetTempPath(), "E2E_" + System.Guid.NewGuid().ToString("N"));
    Directory.CreateDirectory(_screenshotDir);
}

[TearDown]
public void TearDown()
{
    _driver?.Dispose();
    if (Directory.Exists(_screenshotDir))
        Directory.Delete(_screenshotDir, recursive: true);
}

[UnityTest]
public IEnumerator TakeScreenshot()
{
    var handle = _driver.OpenWindow<MyWindow>();
    yield return null;

    // Whole window
    var path = Path.Combine(_screenshotDir, "window.png");
    handle.Screenshot(path);
    Assert.IsTrue(File.Exists(path));

    // Individual control
    var page = Page.Scan(handle.Window);
    var tex = page.GetByValue("Hello World").CaptureScreenshot();
    Assert.Greater(tex.width, 0);
    UnityEngine.Object.DestroyImmediate(tex);
}

Cross-Platform Notes

  • Window positioning: Use EditorWindowExtensions.SetPosition() instead of assigning EditorWindow.position directly. On Linux, the window manager applies position changes asynchronously; SetPosition uses a min/max-size trick to make resizes deterministic.

  • UIElements on Linux: Call handle.Repaint() before reading UIElements state after mutating serialized data. This forces IBindable.binding.PreUpdate()/Update() and avoids stale bindings.

  • File paths: Always use Path.Combine(...) — never concatenate with \ or / directly.


Running Tests

bash
# Run all tests in the E2E assembly
uloop run-tests --filter-type assembly --filter-value "MyPlugin.E2ETests.Editor"

# Run a single test by full name
uloop run-tests --filter-type exact --filter-value "MyPlugin.Tests.MyWindowE2ETests.SomeTest"

See Assets/Tests/Editor/ for complete worked examples covering IMGUI windows, IMGUI inspectors, UIElements windows, and UIElements inspectors — including bidirectional state verification patterns.

© kurotu, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in .claude/skills/unity-editor-driver-e2e of kurotu/VRCQuestTools.

  • SKILL.md
  • evals/evals.json

Open the folder on GitHubat commit c68d147

Compare with similar skills

Unity Editor Driver E2E next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Unity Editor Driver E2E compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Unity Editor Driver E2E this skillkurotu/VRCQuestTools373—~3.1kAutomated safety check: PassMIT
Web Application Testinganthropics/skills180k51 repos~966Automated safety check: PassApache-2.0
OpenHarness End-to-End EvalsHKUDS/OpenHarness16k1 repos~2.1kAutomated safety check: NotesMIT
playwright-cli Browser Automationgithub/gh-aw5.4k24 repos~2.8kAutomated safety check: PassMIT
Write and Verify Playwright Testsappsmithorg/appsmith41k—~2.9kAutomated safety check: NotesApache-2.0
Cucumber and Playwright E2E Testslanggenius/dify158k—~682Automated safety check: PassCustom licence

Similar skills

  • Web Application Testing

    anthropics/skills

    Official

    Tests local web applications with Python Playwright scripts, checking frontend behavior, capturing screenshots and reading browser console logs.

    180k GitHub starsUsed in 51 repos~966 tokens
    Testing & QAAuto-check passed
  • Validates OpenHarness features by running real multi-turn agent loops with live LLM calls against an unfamiliar codebase, checking actual tool execution.

    16k GitHub starsUsed in 1 repo~2.1k tokens
    Testing & QAAuto-check: notes
  • Official

    Drives a real browser from the command line with playwright-cli to open pages, interact, mock requests, save state and work with Playwright tests.

    5.4k GitHub starsUsed in 24 repos~2.8k tokens
    Testing & QAAuto-check passed
  • Writes a Playwright end-to-end test from a prompt, runs it against a live Appsmith deployment and retries with fixes up to three times until it passes.

    41k GitHub stars~2.9k tokensUpdated today
    Testing & QAAuto-check: notes
  • Guides changes and reviews of the Cucumber and Playwright end-to-end suite under `e2e/`: feature files, step definitions, support code, tags, locators and assertions.

    158k GitHub stars~682 tokensUpdated today
    Testing & QAAuto-check passed
  • E2E Testing

    langflow-ai/langflow

    Write and review Playwright E2E tests for Langflow. An agent skill from langflow-ai/langflow.

    156k GitHub stars~3.3k tokensUpdated today
    Testing & QAAuto-check passed

More from kurotu/VRCQuestTools

All 25 skills in this repo
  • Uloop Replay Input

    kurotu/VRCQuestTools

    Replay recorded PlayMode keyboard and mouse input. An agent skill from kurotu/VRCQuestTools.

    373 GitHub starsUsed in 3 repos~615 tokens
    Auto-check passed
  • Uloop Screenshot

    kurotu/VRCQuestTools

    Capture Unity Editor windows or Game View rendering as PNG. An agent skill from kurotu/VRCQuestTools.

    373 GitHub starsUsed in 3 repos~1.2k tokens
    Auto-check passed
  • Uloop Execute Dynamic Code

    kurotu/VRCQuestTools

    Execute C with Unity APIs when existing uloop tools cannot inspect or edit enough.

    373 GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed
  • Uloop Find Game Objects

    kurotu/VRCQuestTools

    Find or inspect Unity GameObjects, especially objects the user currently selected in the Hierarchy.

    373 GitHub starsUsed in 3 repos~982 tokens
    Auto-check passed
  • Uloop Record Input

    kurotu/VRCQuestTools

    Record PlayMode keyboard and mouse input to JSON. An agent skill from kurotu/VRCQuestTools.

    373 GitHub starsUsed in 1 repo~605 tokens
    Auto-check passed
  • Uloop Get Hierarchy

    kurotu/VRCQuestTools

    Get the Unity scene hierarchy as a structured tree. An agent skill from kurotu/VRCQuestTools.

    373 GitHub starsUsed in 3 repos~587 tokens
    Auto-check passed

Works with

Categories

Questions about Unity Editor Driver E2E

What does Unity Editor Driver E2E do?

Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository. Unity Editor Driver E2E is an agent skill from kurotu/VRCQuestTools. Implement E2E tests for Unity Editor extensions (EditorWindow and custom Inspector) using the unity-editor-driver framework in this repository.

When should I use Unity Editor Driver E2E?

Unity Editor Driver E2E fits situations like: you need to write; extend EditMode E2E tests that interact with editor UI controls — even if the request only mentions test; automate inspector; check window behavior.

How do I install Unity Editor Driver E2E in Claude Code?

Run `npx skills add kurotu/VRCQuestTools --skill unity-editor-driver-e2e -a claude-code`. Or copy the skill folder (.claude/skills/unity-editor-driver-e2e in kurotu/VRCQuestTools) into .claude/skills/unity-editor-driver-e2e in your project. Claude Code loads it when a task matches its description.

How do I install Unity Editor Driver E2E in Codex?

Run `npx skills add kurotu/VRCQuestTools --skill unity-editor-driver-e2e -a codex`. Or copy the skill folder (.claude/skills/unity-editor-driver-e2e in kurotu/VRCQuestTools) into .agents/skills/unity-editor-driver-e2e in your project. Codex loads it when a task matches its description.

Can I use Unity Editor Driver E2E in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add kurotu/VRCQuestTools --skill unity-editor-driver-e2e -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/unity-editor-driver-e2e, .gemini/skills/unity-editor-driver-e2e, .github/skills/unity-editor-driver-e2e and .opencode/skills/unity-editor-driver-e2e in your project.

What does Unity Editor Driver E2E need to run?

SKILL.md names no scripts, command-line tools or credentials: Unity Editor Driver E2E is instructions for the agent only.

Does Unity Editor Driver E2E access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Unity Editor Driver E2E safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Unity Editor Driver E2E use?

Unity Editor Driver E2E is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Unity Editor Driver E2E use?

About 3.1k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Unity Editor Driver E2E?

Skills that share tags, products or a category with Unity Editor Driver E2E: Web Application Testing (anthropics/skills, 180k stars), OpenHarness End-to-End Evals (HKUDS/OpenHarness, 16k stars), playwright-cli Browser Automation (github/gh-aw, 5.4k stars) and Write and Verify Playwright Tests (appsmithorg/appsmith, 41k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Unity Editor Driver E2E?

kurotu (a GitHub user) maintains it in kurotu/VRCQuestTools, which has 373 GitHub stars. The repository holds 25 skills in this directory. The repository was last updated on September 30, 2026.

Source: kurotu/VRCQuestTools on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.