├── Chickensoft.GodotTestDriver.Tests
    ├── test
    │   ├── Tests.cs.uid
    │   ├── src
    │   │   ├── Drivers
    │   │   │   ├── DriverTest.cs.uid
    │   │   │   ├── ButtonDriverTest.cs.uid
    │   │   │   ├── LabelDriverTest.cs.uid
    │   │   │   ├── WindowDriverTest.cs.uid
    │   │   │   ├── Camera2DDriverTest.cs.uid
    │   │   │   ├── CheckBoxDriverTest.cs.uid
    │   │   │   ├── GraphEditDriverTest.cs.uid
    │   │   │   ├── ItemListDriverTest.cs.uid
    │   │   │   ├── LineEditDriverTest.cs.uid
    │   │   │   ├── PopupMenuDriverTest.cs.uid
    │   │   │   ├── Sprite2DDriverTest.cs.uid
    │   │   │   ├── TextEditDriverTest.cs.uid
    │   │   │   ├── OptionButtonDriverTest.cs.uid
    │   │   │   ├── RichTextLabelDriverTest.cs.uid
    │   │   │   ├── TabContainerDriverTest.cs.uid
    │   │   │   ├── LineEditDriverTest.tscn
    │   │   │   ├── LabelDriverTest.tscn
    │   │   │   ├── TextEditDriverTest.tscn
    │   │   │   ├── CheckBoxDriverTest.tscn
    │   │   │   ├── ItemListDriverTest.tscn
    │   │   │   ├── Sprite2DDriverTest.tscn
    │   │   │   ├── RichTextLabelDriverTest.tscn
    │   │   │   ├── Camera2DDriverTest.tscn
    │   │   │   ├── OptionButtonDriverTest.tscn
    │   │   │   ├── LabelDriverTest.cs
    │   │   │   ├── DriverTest.cs
    │   │   │   ├── TabContainerDriverTest.tscn
    │   │   │   ├── PopupMenuDriverTest.tscn
    │   │   │   ├── CheckBoxDriverTest.cs
    │   │   │   ├── ButtonDriverTest.tscn
    │   │   │   ├── WindowDriverTest.tscn
    │   │   │   ├── RichTextLabelDriverTest.cs
    │   │   │   ├── WindowDriverTest.cs
    │   │   │   ├── Sprite2DDriverTest.cs
    │   │   │   ├── ButtonDriverTest.cs
    │   │   │   ├── Camera2DDriverTest.cs
    │   │   │   ├── TextEditDriverTest.cs
    │   │   │   ├── TabContainerDriverTest.cs
    │   │   │   ├── PopupMenuDriverTest.cs
    │   │   │   ├── GraphEditDriverTest.tscn
    │   │   │   ├── LineEditDriverTest.cs
    │   │   │   ├── OptionButtonDriverTest.cs
    │   │   │   ├── GraphEditDriverTest.cs
    │   │   │   └── ItemListDriverTest.cs
    │   │   └── Input
    │   │   │   ├── InputTest.cs.uid
    │   │   │   ├── ActionsInputExtensionsTest.cs.uid
    │   │   │   ├── ControllerInputExtensionsTest.cs.uid
    │   │   │   ├── ActionsInputExtensionsTest.tscn
    │   │   │   ├── ControllerInputExtensionsTest.tscn
    │   │   │   ├── InputTest.cs
    │   │   │   ├── ActionsInputExtensionsTest.cs
    │   │   │   └── ControllerInputExtensionsTest.cs
    │   ├── Tests.tscn
    │   └── Tests.cs
    ├── nuget.config
    ├── project.godot
    ├── icon.svg.import
    ├── Chickensoft.GodotTestDriver.Tests.csproj
    ├── Chickensoft.GodotTestDriver.Tests.sln
    └── icon.svg
├── .gitattributes
├── renovate.json
├── Chickensoft.GodotTestDriver
    ├── icon.png
    ├── src
    │   ├── Util
    │   │   ├── Timeout.cs
    │   │   ├── Log.cs
    │   │   └── InternalUtil.cs
    │   ├── Drivers
    │   │   ├── Node2DDriver.cs
    │   │   ├── ButtonDriver.cs
    │   │   ├── LabelDriver.cs
    │   │   ├── CheckBoxDriver.cs
    │   │   ├── CanvasItemDriver.cs
    │   │   ├── RichTextLabelDriver.cs
    │   │   ├── Port.cs
    │   │   ├── Sprite2DDriver.cs
    │   │   ├── TextEditDriver.cs
    │   │   ├── BaseButtonDriver.cs
    │   │   ├── ControlDriver.cs
    │   │   ├── LineEditDriver.cs
    │   │   ├── Camera2DDriver.cs
    │   │   ├── WindowDriver.cs
    │   │   ├── TabContainerDriver.cs
    │   │   ├── NodeDriver.cs
    │   │   ├── OptionButtonDriver.cs
    │   │   ├── GraphEditDriver.cs
    │   │   ├── ItemListDriver.cs
    │   │   ├── PopupMenuDriver.cs
    │   │   └── GraphNodeDriver.cs
    │   └── Input
    │   │   ├── ActionsInputExtensions.cs
    │   │   ├── KeyboardInputExtensions.cs
    │   │   ├── MouseInputExtensions.cs
    │   │   └── ControllerInputExtensions.cs
    ├── Configuration.cs
    ├── Chickensoft.GodotTestDriver.csproj
    └── Fixture.cs
├── global.json
├── .gitignore
├── .github
    └── workflows
    │   ├── spellcheck.yaml
    │   ├── auto_release.yaml
    │   ├── visual_tests.yaml
    │   └── release.yaml
├── LICENSE
├── .vscode
    ├── launch.json
    ├── tasks.json
    └── settings.json
├── cspell.json
├── CONTRIBUTING.md
└── Chickensoft.GodotTestDriver.sln


/Chickensoft.GodotTestDriver.Tests/test/Tests.cs.uid:
--------------------------------------------------------------------------------
1 | uid://hy0f6ptrmrqf
2 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto eol=lf
2 | *.png filter=lfs diff=lfs merge=lfs -text
3 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/DriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://dopgap6n7v77
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/InputTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://d2dscy0ooqvhg
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ButtonDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bma6r4vcefwq7
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LabelDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bk0kg8a2tqnlt
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/WindowDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://dd7q1my4fb0ei
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Camera2DDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://cikqsnkgf5lps
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/CheckBoxDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://csy46l1gpccxe
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/GraphEditDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://d2xus62t6wcjo
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ItemListDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://d3pedejniwavv
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LineEditDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://lkgdd4ifr7ty
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/PopupMenuDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://ckcfbcp7skgns
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Sprite2DDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bwq1rptdt4348
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TextEditDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://kelhlyvjidun
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/OptionButtonDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://cn26m54qqj8tn
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/RichTextLabelDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bb05oj18e7r3l
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TabContainerDriverTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bog85erwxjjis
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ActionsInputExtensionsTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://cliqwyhsavysb
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ControllerInputExtensionsTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://cgiif6jvm2lxo
2 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |   "extends": ["github>chickensoft-games/renovate:godot"]
4 | }
5 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/icon.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:47fb952db9c95108d064a2112a124b2e8bb0dddde7135dea9bd51b01fd471370
3 | size 464484
4 | 


--------------------------------------------------------------------------------
/global.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "msbuild-sdks": {
 3 |     "Godot.NET.Sdk": "4.5.1"
 4 |   },
 5 |   "sdk": {
 6 |     "rollForward": "major",
 7 |     "version": "8.0.416"
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ActionsInputExtensionsTest.tscn:
--------------------------------------------------------------------------------
1 | [gd_scene format=3 uid="uid://busk27caw7oi8"]
2 | 
3 | [node name="ActionsControlExtensionsTest" type="Node"]
4 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ControllerInputExtensionsTest.tscn:
--------------------------------------------------------------------------------
1 | [gd_scene format=3 uid="uid://blvfape3o5unh"]
2 | 
3 | [node name="ControllerInputExtensionsTest" type="Node"]
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | **/coverage/*
 2 | !**/coverage/.gdignore
 3 | nupkg/
 4 | **/.godot/
 5 | **/.import/
 6 | bin/
 7 | obj/
 8 | .generated/
 9 | .DS_Store
10 | *.DotSettings.user
11 | *.binlog
12 | 
13 | # IDEs
14 | **/.idea
15 | .vs/
16 | .vscode/extensions.json
17 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/Tests.tscn:
--------------------------------------------------------------------------------
1 | [gd_scene load_steps=2 format=3 uid="uid://iwpykuj2u0st"]
2 | 
3 | [ext_resource type="Script" uid="uid://hy0f6ptrmrqf" path="res://test/Tests.cs" id="1_rncp0"]
4 | 
5 | [node name="Tests" type="Node2D"]
6 | script = ExtResource("1_rncp0")
7 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LineEditDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://d1sy0we7k2jcd"]
 2 | 
 3 | [node name="LineEditDriverTest" type="Node2D"]
 4 | 
 5 | [node name="LineEdit" type="LineEdit" parent="."]
 6 | offset_left = 104.0
 7 | offset_top = 51.0
 8 | offset_right = 350.0
 9 | offset_bottom = 97.0
10 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LabelDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://dvrsoja7h1mm2"]
 2 | 
 3 | [node name="LabelDriverTest" type="Node2D"]
 4 | 
 5 | [node name="Label" type="Label" parent="."]
 6 | offset_left = 193.0
 7 | offset_top = 144.0
 8 | offset_right = 517.0
 9 | offset_bottom = 179.0
10 | text = "Hello World!"
11 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TextEditDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://dworisxq0kj3r"]
 2 | 
 3 | [node name="TextEditDriverTest" type="Node2D"]
 4 | 
 5 | [node name="TextEdit" type="TextEdit" parent="."]
 6 | offset_left = 517.0
 7 | offset_top = 268.0
 8 | offset_right = 820.0
 9 | offset_bottom = 418.0
10 | text = "Lorem ipsum"
11 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/CheckBoxDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://c0dcedt5pjata"]
 2 | 
 3 | [node name="CheckBoxDriverTest" type="Node2D"]
 4 | 
 5 | [node name="CheckBox" type="CheckBox" parent="."]
 6 | offset_left = 213.0
 7 | offset_top = 153.0
 8 | offset_right = 467.0
 9 | offset_bottom = 199.0
10 | text = "I am a checkbox"
11 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/nuget.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <configuration>
 3 |   <packageSources>
 4 |     <clear />
 5 |     <add key="coverlet" value="https://pkgs.dev.azure.com/tonerdo/coverlet/_packaging/coverlet-nightly/nuget/v3/index.json" />
 6 |     <!-- Default nuget feed -->
 7 |     <add key="nuget" value="https://api.nuget.org/v3/index.json" />
 8 |   </packageSources>
 9 | </configuration>
10 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/Tests.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests;
 2 | 
 3 | using System.Reflection;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | 
 7 | public partial class Tests : Node2D
 8 | {
 9 |   /// <summary>
10 |   /// Called when the node enters the scene tree for the first time.
11 |   /// </summary>
12 |   public override void _Ready() => CallDeferred("Go");
13 | 
14 |   private void Go() => GoTest.RunTests(Assembly.GetExecutingAssembly(), this);
15 | }
16 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ItemListDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://b81ckv34wmjlc"]
 2 | 
 3 | [node name="ItemListDriverTest" type="Node2D"]
 4 | 
 5 | [node name="ItemList" type="ItemList" parent="."]
 6 | offset_left = 324.0
 7 | offset_top = 100.0
 8 | offset_right = 604.0
 9 | offset_bottom = 472.0
10 | select_mode = 1
11 | item_count = 4
12 | item_0/text = "Normal Item 1"
13 | item_1/text = "Normal Item 2"
14 | item_2/text = "NonSelectable Item"
15 | item_2/selectable = false
16 | item_3/text = "Disabled Item"
17 | item_3/selectable = false
18 | item_3/disabled = true
19 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Sprite2DDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=3 uid="uid://d4h68q1tnthl8"]
 2 | 
 3 | [ext_resource type="Texture2D" uid="uid://da2tcc2mhkfgi" path="res://icon.svg" id="1_00i83"]
 4 | 
 5 | [node name="Sprite2DDriverTest" type="Node2D"]
 6 | 
 7 | [node name="Sprite2D" type="Sprite2D" parent="."]
 8 | position = Vector2(536, 270)
 9 | texture = ExtResource("1_00i83")
10 | flip_v = true
11 | 
12 | [node name="PartiallyVisibleSprite2D" type="Sprite2D" parent="."]
13 | position = Vector2(0, 641)
14 | texture = ExtResource("1_00i83")
15 | flip_h = true
16 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/RichTextLabelDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://c3virdkgqd06g"]
 2 | 
 3 | [node name="RichTextLabelDriverTest" type="Node2D"]
 4 | 
 5 | [node name="RichTextLabel" type="RichTextLabel" parent="."]
 6 | offset_left = 140.0
 7 | offset_top = 120.0
 8 | offset_right = 443.0
 9 | offset_bottom = 269.0
10 | text = "Hello World!"
11 | 
12 | [node name="BbCodeRichTextLabel" type="RichTextLabel" parent="."]
13 | offset_left = 589.0
14 | offset_top = 229.0
15 | offset_right = 892.0
16 | offset_bottom = 378.0
17 | bbcode_enabled = true
18 | text = "Hello [b]World![/b]"
19 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Camera2DDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=3 uid="uid://dv7ckjksq1etn"]
 2 | 
 3 | [ext_resource type="Texture2D" uid="uid://da2tcc2mhkfgi" path="res://icon.svg" id="1_3y0um"]
 4 | 
 5 | [node name="Camera2DDriverTest" type="Node2D"]
 6 | 
 7 | [node name="Camera2D" type="Camera2D" parent="."]
 8 | position_smoothing_enabled = true
 9 | 
10 | [node name="CenterSprite" type="Sprite2D" parent="."]
11 | texture = ExtResource("1_3y0um")
12 | 
13 | [node name="OffCenterSprite" type="Sprite2D" parent="."]
14 | position = Vector2(776, 457)
15 | texture = ExtResource("1_3y0um")
16 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/OptionButtonDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://hgwgepqes1tp"]
 2 | 
 3 | [node name="OptionButtonDriverTest" type="Node2D"]
 4 | 
 5 | [node name="OptionButton" type="OptionButton" parent="."]
 6 | offset_left = 405.0
 7 | offset_top = 156.0
 8 | offset_right = 560.0
 9 | offset_bottom = 187.0
10 | item_count = 4
11 | popup/item_0/text = "Normal Item 1"
12 | popup/item_0/id = 0
13 | popup/item_1/text = "Normal Item 2"
14 | popup/item_1/id = 1
15 | popup/item_2/text = "Separator"
16 | popup/item_2/id = 2
17 | popup/item_2/separator = true
18 | popup/item_3/text = "Disabled Item"
19 | popup/item_3/id = 3
20 | popup/item_3/disabled = true
21 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LabelDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using Chickensoft.GoDotTest;
 4 | using Godot;
 5 | using GodotTestDriver.Drivers;
 6 | using Shouldly;
 7 | 
 8 | public class LabelDriverTest : DriverTest
 9 | {
10 |   private readonly LabelDriver _label;
11 | 
12 |   public LabelDriverTest(Node testScene) : base(testScene)
13 |   {
14 |     _label = new LabelDriver(() => RootNode.GetNode<Label>("Label"));
15 |   }
16 | 
17 |   [Test]
18 |   public void InspectionWorks() =>
19 |     // WHEN
20 |     // everything is set up
21 | 
22 |     // THEN
23 |     // the label text is "Hello World!"
24 |     _label.Text.ShouldBe("Hello World!");
25 | }
26 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/InputTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Input;
 2 | 
 3 | using System.Threading.Tasks;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | 
 7 | public abstract class InputTest : TestClass
 8 | {
 9 |   protected Fixture Fixture { get; }
10 |   protected Node RootNode { get; private set; } = null!;
11 | 
12 |   protected InputTest(Node testScene) : base(testScene)
13 |   {
14 |     Fixture = new Fixture(testScene.GetTree());
15 |   }
16 | 
17 |   [Setup]
18 |   public async Task Setup() =>
19 |     RootNode = await Fixture.LoadAndAddScene<Node>(
20 |       $"res://test/src/Input/{GetType().Name}.tscn"
21 |     );
22 | 
23 |   [Cleanup]
24 |   public async Task Cleanup() => await Fixture.Cleanup();
25 | }
26 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/DriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System.Threading.Tasks;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | 
 7 | public abstract class DriverTest : TestClass
 8 | {
 9 |   protected Fixture Fixture { get; }
10 |   protected Node RootNode { get; private set; } = null!;
11 | 
12 |   protected DriverTest(Node testScene) : base(testScene)
13 |   {
14 |     Fixture = new Fixture(testScene.GetTree());
15 |   }
16 | 
17 |   [Setup]
18 |   public async Task Setup()
19 |   {
20 |     RootNode = await Fixture.LoadAndAddScene<Node>(
21 |       $"res://test/src/Drivers/{GetType().Name}.tscn"
22 |     );
23 |   }
24 | 
25 |   [Cleanup]
26 |   public async Task Cleanup() => await Fixture.Cleanup();
27 | }
28 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TabContainerDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://be50rnvsdsler"]
 2 | 
 3 | [node name="TabContainerDriverTest" type="Node2D"]
 4 | 
 5 | [node name="TabContainer" type="TabContainer" parent="."]
 6 | offset_left = 314.0
 7 | offset_top = 208.0
 8 | offset_right = 758.0
 9 | offset_bottom = 454.0
10 | 
11 | [node name="First Tab" type="VBoxContainer" parent="TabContainer"]
12 | layout_mode = 2
13 | 
14 | [node name="First Tab Content" type="Label" parent="TabContainer/First Tab"]
15 | layout_mode = 2
16 | text = "First Tab Content"
17 | 
18 | [node name="Second Tab" type="VBoxContainer" parent="TabContainer"]
19 | visible = false
20 | layout_mode = 2
21 | 
22 | [node name="Second Tab Content" type="Label" parent="TabContainer/Second Tab"]
23 | layout_mode = 2
24 | text = "Second Tab Content"
25 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/project.godot:
--------------------------------------------------------------------------------
 1 | ; Engine configuration file.
 2 | ; It's best edited using the editor UI and not directly,
 3 | ; since the parameters that go here are not all obvious.
 4 | ;
 5 | ; Format:
 6 | ;   [section] ; section goes between []
 7 | ;   param=value ; assign values to parameters
 8 | 
 9 | config_version=5
10 | 
11 | [application]
12 | 
13 | config/name="Chickensoft.GodotTestDriver.Tests"
14 | run/main_scene="res://test/Tests.tscn"
15 | config/features=PackedStringArray("4.4", "C#", "Mobile")
16 | config/icon="res://icon.svg"
17 | 
18 | [dotnet]
19 | 
20 | project/assembly_name="Chickensoft.GodotTestDriver.Tests"
21 | 
22 | [editor]
23 | 
24 | naming/scene_name_casing=1
25 | 
26 | [input]
27 | 
28 | test_action={
29 | "deadzone": 0.5,
30 | "events": []
31 | }
32 | 
33 | [rendering]
34 | 
35 | renderer/rendering_method="mobile"
36 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Util/Timeout.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Util;
 2 | 
 3 | using System;
 4 | 
 5 | /// <summary>
 6 | /// Timeout mechanism that determines if a given span of time has elapsed.
 7 | /// </summary>
 8 | public readonly struct Timeout
 9 | {
10 |   private readonly float _seconds;
11 |   private readonly long _start;
12 | 
13 |   /// <summary>
14 |   /// Create a new timeout with the given duration.
15 |   /// </summary>
16 |   /// <param name="seconds">Time, in seconds.</param>
17 |   public Timeout(float seconds)
18 |   {
19 |     _seconds = seconds;
20 |     _start = DateTimeOffset.Now.ToUnixTimeMilliseconds();
21 |   }
22 | 
23 |   /// <summary>
24 |   /// Whether the given duration has elapsed.
25 |   /// </summary>
26 |   public bool IsReached =>
27 |     DateTimeOffset.Now.ToUnixTimeMilliseconds() - _start > 1000f * _seconds;
28 | }
29 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/PopupMenuDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://cmigiji403pdc"]
 2 | 
 3 | [node name="PopupMenuDriverTest" type="Node2D"]
 4 | 
 5 | [node name="Button" type="Button" parent="."]
 6 | offset_left = 247.0
 7 | offset_top = 279.0
 8 | offset_right = 403.0
 9 | offset_bottom = 339.0
10 | text = "Show me the popup"
11 | 
12 | [node name="PopupMenu" type="PopupMenu" parent="."]
13 | position = Vector2i(400, 300)
14 | size = Vector2i(152, 116)
15 | item_count = 4
16 | item_0/text = "Normal Item 1"
17 | item_0/id = 0
18 | item_1/text = "Normal Item 2"
19 | item_1/checkable = 1
20 | item_1/checked = true
21 | item_1/id = 1
22 | item_2/text = "Separator"
23 | item_2/id = 2
24 | item_2/separator = true
25 | item_3/text = "Disabled Item"
26 | item_3/id = 3
27 | item_3/disabled = true
28 | 
29 | [connection signal="pressed" from="Button" to="PopupMenu" method="popup"]
30 | 


--------------------------------------------------------------------------------
/.github/workflows/spellcheck.yaml:
--------------------------------------------------------------------------------
 1 | name: '🧑‍🏫 Spellcheck'
 2 | on:
 3 |   push:
 4 |   pull_request:
 5 | 
 6 | jobs:
 7 |   spellcheck:
 8 |     name: '🧑‍🏫 Spellcheck'
 9 |     # Only run the workflow if it's not a PR or if it's a PR from a fork.
10 |     # This prevents duplicate workflows from running on PR's that originate
11 |     # from the repository itself.
12 |     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
13 |     runs-on: ubuntu-latest
14 |     defaults:
15 |       run:
16 |         working-directory: '.'
17 |     steps:
18 |       - uses: actions/checkout@v6
19 |         name: 🧾 Checkout
20 | 
21 |       - uses: streetsidesoftware/cspell-action@v8
22 |         name: 📝 Check Spelling
23 |         with:
24 |           config: './cspell.json'
25 |           incremental_files_only: false
26 |           root: '.'
27 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/CheckBoxDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using Chickensoft.GoDotTest;
 4 | using Godot;
 5 | using GodotTestDriver.Drivers;
 6 | using Shouldly;
 7 | 
 8 | public class CheckBoxDriverTest : DriverTest
 9 | {
10 |   private readonly CheckBoxDriver _checkBox;
11 | 
12 |   public CheckBoxDriverTest(Node testScene) : base(testScene)
13 |   {
14 |     _checkBox = new CheckBoxDriver(
15 |       () => RootNode.GetNode<CheckBox>("CheckBox")
16 |     );
17 |   }
18 | 
19 |   [Test]
20 |   public void ClickingChecksAndUnchecks()
21 |   {
22 |     // WHEN
23 |     // i click the checkbox
24 |     _checkBox.ClickCenter();
25 | 
26 |     // THEN
27 |     // the checkbox is checked
28 |     _checkBox.IsChecked.ShouldBeTrue();
29 | 
30 |     // WHEN
31 |     // i click the checkbox again
32 |     _checkBox.ClickCenter();
33 | 
34 |     // THEN
35 |     // the checkbox is unchecked
36 |     _checkBox.IsChecked.ShouldBeFalse();
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ButtonDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene format=3 uid="uid://dnr1yh0xx8uqi"]
 2 | 
 3 | [node name="ButtonDriverTest" type="Control"]
 4 | layout_mode = 3
 5 | anchors_preset = 15
 6 | anchor_right = 1.0
 7 | anchor_bottom = 1.0
 8 | grow_horizontal = 2
 9 | grow_vertical = 2
10 | 
11 | [node name="Panel" type="Panel" parent="."]
12 | layout_mode = 0
13 | offset_left = 470.0
14 | offset_top = 161.0
15 | offset_right = 718.0
16 | offset_bottom = 327.0
17 | 
18 | [node name="Button" type="Button" parent="."]
19 | layout_mode = 0
20 | offset_right = 168.0
21 | offset_bottom = 59.0
22 | text = "Lorem"
23 | 
24 | [node name="Label" type="Label" parent="."]
25 | layout_mode = 0
26 | offset_left = 18.0
27 | offset_top = 112.0
28 | offset_right = 159.0
29 | offset_bottom = 165.0
30 | text = "didn't work"
31 | 
32 | [connection signal="pressed" from="Button" to="Panel" method="set_visible" binds= [false]]
33 | [connection signal="pressed" from="Button" to="Label" method="set_text" binds= ["did work"]]
34 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/icon.svg.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="CompressedTexture2D"
 5 | uid="uid://da2tcc2mhkfgi"
 6 | path="res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"
 7 | metadata={
 8 | "vram_texture": false
 9 | }
10 | 
11 | [deps]
12 | 
13 | source_file="res://icon.svg"
14 | dest_files=["res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"]
15 | 
16 | [params]
17 | 
18 | compress/mode=0
19 | compress/high_quality=false
20 | compress/lossy_quality=0.7
21 | compress/hdr_compression=1
22 | compress/normal_map=0
23 | compress/channel_pack=0
24 | mipmaps/generate=false
25 | mipmaps/limit=-1
26 | roughness/mode=0
27 | roughness/src_normal=""
28 | process/fix_alpha_border=true
29 | process/premult_alpha=false
30 | process/normal_map_invert_y=false
31 | process/hdr_as_srgb=false
32 | process/hdr_clamp_exposure=false
33 | process/size_limit=0
34 | detect_3d/compress_to=1
35 | svg/scale=1.0
36 | editor/scale_with_editor_scale=false
37 | editor/convert_colors_with_editor_theme=false
38 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/Node2DDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for <see cref="Node2D"/> nodes.
 8 | /// </summary>
 9 | /// <typeparam name="T">Node2D Type.</typeparam>
10 | public class Node2DDriver<T> : CanvasItemDriver<T> where T : Node2D
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic Node2DDriver.
14 |   /// </summary>
15 |   /// <param name="producer">Producer that creates a Node2D subclass.</param>
16 |   /// <param name="description">Driver description.</param>
17 |   public Node2DDriver(Func<T> producer, string description = "")
18 |     : base(producer, description)
19 |   {
20 |   }
21 | 
22 |   /// <summary>
23 |   /// The global position of the node.
24 |   /// </summary>
25 |   public Vector2 GlobalPosition => PresentRoot.GlobalPosition;
26 | 
27 |   /// <summary>
28 |   /// The position of the node relative to its parent.
29 |   /// </summary>
30 |   public Vector2 Position => PresentRoot.Position;
31 | }
32 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Util/Log.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Util;
 2 | 
 3 | using System;
 4 | using System.Globalization;
 5 | using Godot;
 6 | 
 7 | internal static class Log
 8 | {
 9 |   public static Action<string, object[]> DebugLogger { get; set; } = static (s, p) =>
10 |     GD.Print("DEBUG: " + string.Format(CultureInfo.InvariantCulture, s, p));
11 |   public static Action<string, object[]> InfoLogger { get; set; } = (s, p) =>
12 |     GD.Print("INFO: " + string.Format(CultureInfo.InvariantCulture, s, p));
13 |   public static Action<string, object[]> ErrorLogger { get; set; } = (s, p) =>
14 |     GD.PrintErr("ERROR: " + string.Format(CultureInfo.InvariantCulture, s, p));
15 | 
16 |   public static void Debug(string format, params object[] args) =>
17 |     DebugLogger?.Invoke(format, args);
18 | 
19 |   public static void Info(string format, params object[] args) =>
20 |     InfoLogger?.Invoke(format, args);
21 | 
22 |   public static void Error(string format, params object[] args) =>
23 |     ErrorLogger?.Invoke(format, args);
24 | }
25 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/WindowDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=3 uid="uid://bibyxgo1h087j"]
 2 | 
 3 | [sub_resource type="GDScript" id="GDScript_hsdjn"]
 4 | resource_name = "WindowDriverTestScript"
 5 | script/source = "extends Window
 6 | 
 7 | func _on_close_requested():
 8 | 	hide()
 9 | "
10 | 
11 | [node name="WindowDriverTest" type="Node2D"]
12 | 
13 | [node name="Window" type="Window" parent="."]
14 | title = "I am some window"
15 | position = Vector2i(200, 200)
16 | size = Vector2i(400, 300)
17 | script = SubResource("GDScript_hsdjn")
18 | 
19 | [node name="PanelContainer" type="PanelContainer" parent="Window"]
20 | anchors_preset = 15
21 | anchor_right = 1.0
22 | anchor_bottom = 1.0
23 | grow_horizontal = 2
24 | grow_vertical = 2
25 | 
26 | [node name="CenterContainer" type="CenterContainer" parent="Window/PanelContainer"]
27 | layout_mode = 2
28 | 
29 | [node name="Label" type="Label" parent="Window/PanelContainer/CenterContainer"]
30 | layout_mode = 2
31 | text = "Lorem ipsum dolor"
32 | 
33 | [connection signal="close_requested" from="Window" to="Window" method="_on_close_requested"]
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Jan Thomä
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/Chickensoft.GodotTestDriver.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Godot.NET.Sdk/4.5.1">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net8.0</TargetFramework>
 4 |     <EnableDynamicLoading>true</EnableDynamicLoading>
 5 |     <LangVersion>preview</LangVersion>
 6 |     <RootNamespace>Chickensoft.GodotTestDriver.Tests</RootNamespace>
 7 |     <!-- Required for some nuget packages to work -->
 8 |     <!-- godotengine/godot/issues/42271#issuecomment-751423827 -->
 9 |     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
10 |     <!-- To show generated files -->
11 |     <!--
12 |         <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
13 |         <CompilerGeneratedFilesOutputPath>
14 |         .generated
15 |         </CompilerGeneratedFilesOutputPath>
16 |         -->
17 |     <DebugType>full</DebugType>
18 |     <DebugSymbols>true</DebugSymbols>
19 |   </PropertyGroup>
20 |   <ItemGroup>
21 |     <PackageReference Include="Chickensoft.GoDotTest" Version="2.0.27" />
22 |     <PackageReference Include="Shouldly" Version="4.3.0" />
23 |     <ProjectReference Include="../Chickensoft.GodotTestDriver/Chickensoft.GodotTestDriver.csproj" />
24 |   </ItemGroup>
25 | </Project>
26 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/ButtonDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for <see cref="Button"/> controls.
 8 | /// </summary>
 9 | /// <typeparam name="T">Button type.</typeparam>
10 | public class ButtonDriver<T> : BaseButtonDriver<T> where T : Button
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic ButtonDriver.
14 |   /// </summary>
15 |   /// <param name="producer">Producer that creates a Button subclass.</param>
16 |   /// <param name="description">Driver description.</param>
17 |   public ButtonDriver(Func<T> producer, string description = "")
18 |     : base(producer, description)
19 |   {
20 |   }
21 | }
22 | 
23 | /// <summary>
24 | /// Driver for <see cref="Button"/> controls.
25 | /// </summary>
26 | public sealed class ButtonDriver : ButtonDriver<Button>
27 | {
28 |   /// <summary>
29 |   /// Creates a new ButtonDriver.
30 |   /// </summary>
31 |   /// <param name="producer">Producer that creates a Button subclass.</param>
32 |   /// <param name="description">Driver description.</param>
33 |   public ButtonDriver(Func<Button> producer, string description = "")
34 |     : base(producer, description)
35 |   {
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/Configuration.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver;
 2 | 
 3 | using System;
 4 | using GodotTestDriver.Util;
 5 | 
 6 | /// <summary>
 7 | /// Godot test driver configuration class.
 8 | /// </summary>
 9 | public static class Configuration
10 | {
11 |   /// <summary>
12 |   /// Logging configuration instance.
13 |   /// </summary>
14 |   public static LoggingConfiguration Logging { get; } =
15 |     new LoggingConfiguration();
16 | 
17 |   /// <summary>
18 |   /// Logging configuration.
19 |   /// </summary>
20 |   public class LoggingConfiguration
21 |   {
22 |     /// <summary>
23 |     /// Debug logger.
24 |     /// </summary>
25 |     public static Action<string, object[]> DebugLogger
26 |     {
27 |       get => Log.DebugLogger;
28 |       set => Log.DebugLogger = value;
29 |     }
30 | 
31 |     /// <summary>
32 |     /// Info logger.
33 |     /// </summary>
34 |     public static Action<string, object[]> InfoLogger
35 |     {
36 |       get => Log.InfoLogger;
37 |       set => Log.InfoLogger = value;
38 |     }
39 | 
40 |     /// <summary>
41 |     /// Error logger.
42 |     /// </summary>
43 |     public static Action<string, object[]> ErrorLogger
44 |     {
45 |       get => Log.ErrorLogger;
46 |       set => Log.ErrorLogger = value;
47 |     }
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "0.2.0",
 3 |   "configurations": [
 4 |     // For these launch configurations to work, you need to setup a GODOT4
 5 |     // environment variable. On mac or linux, this can be done by adding
 6 |     // the following to your .zshrc, .bashrc, or .bash_profile file:
 7 |     // export GODOT4="/Applications/Godot.app/Contents/MacOS/Godot"
 8 |     {
 9 |       "name": "🧪 Debug Tests",
10 |       "type": "coreclr",
11 |       "request": "launch",
12 |       "preLaunchTask": "build",
13 |       "program": "${env:GODOT}",
14 |       "args": [
15 |         // These command line flags are used by GoDotTest to run tests.
16 |         "--run-tests",
17 |         "--quit-on-finish"
18 |       ],
19 |       "cwd": "${workspaceFolder}/Chickensoft.GodotTestDriver.Tests",
20 |       "stopAtEntry": false,
21 |     },
22 |     {
23 |       "name": "🔬 Debug Current Test",
24 |       "type": "coreclr",
25 |       "request": "launch",
26 |       "preLaunchTask": "build",
27 |       "program": "${env:GODOT}",
28 |       "args": [
29 |         // These command line flags are used by GoDotTest to run tests.
30 |         "--run-tests=${fileBasenameNoExtension}",
31 |         "--quit-on-finish"
32 |       ],
33 |       "cwd": "${workspaceFolder}/Chickensoft.GodotTestDriver.Tests",
34 |       "stopAtEntry": false,
35 |     },
36 |   ]
37 | }
38 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/RichTextLabelDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using Chickensoft.GoDotTest;
 4 | using Godot;
 5 | using GodotTestDriver.Drivers;
 6 | using Shouldly;
 7 | 
 8 | public class RichTextLabelDriverTest : DriverTest
 9 | {
10 |   private readonly RichTextLabelDriver _richTextLabel;
11 |   private readonly RichTextLabelDriver _bbCodeRichTextLabel;
12 | 
13 |   public RichTextLabelDriverTest(Node testScene) : base(testScene)
14 |   {
15 |     _richTextLabel = new RichTextLabelDriver(
16 |       () => RootNode.GetNode<RichTextLabel>("RichTextLabel")
17 |     );
18 |     _bbCodeRichTextLabel = new RichTextLabelDriver(
19 |       () => RootNode.GetNode<RichTextLabel>("BbCodeRichTextLabel")
20 |     );
21 |   }
22 | 
23 |   [Test]
24 |   public void InspectionWorks()
25 |   {
26 |     // WHEN
27 |     // everything is set up
28 | 
29 |     // THEN
30 |     // the rich text label has "Hello World!" as text and bbcode is disabled
31 |     _richTextLabel.Text.ShouldBe("Hello World!");
32 |     _richTextLabel.IsBbcodeEnabled.ShouldBeFalse();
33 | 
34 |     // and the bbcode rich text label has "Hello [b]World![/b]" as text and
35 |     // bbcode is enabled
36 |     _bbCodeRichTextLabel.Text.ShouldBe("Hello [b]World![/b]");
37 |     _bbCodeRichTextLabel.IsBbcodeEnabled.ShouldBeTrue();
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/WindowDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using Chickensoft.GoDotTest;
 4 | using Godot;
 5 | using GodotTestDriver.Drivers;
 6 | using Shouldly;
 7 | 
 8 | public class WindowDriverTest : DriverTest
 9 | {
10 |   private readonly WindowDriver _window;
11 | 
12 |   public WindowDriverTest(Node testScene) : base(testScene)
13 |   {
14 |     _window = new WindowDriver(() => RootNode.GetNode<Window>("Window"));
15 |   }
16 | 
17 |   [Test]
18 |   public void WindowClosingWorks()
19 |   {
20 |     // GIVEN
21 |     // the window is visible
22 |     _window.IsVisible.ShouldBeTrue();
23 | 
24 |     // WHEN
25 |     // i close the window
26 |     _window.Close();
27 | 
28 |     // THEN
29 |     // the window is not visible
30 |     _window.IsVisible.ShouldBeFalse();
31 |   }
32 | 
33 |   /// <summary>
34 |   /// dragging the window works
35 |   /// </summary>
36 |   [Test]
37 |   public void WindowDraggingWorks()
38 |   {
39 |     var initialPosition = _window.Position;
40 |     // WHEN
41 |     // i drag the window
42 |     _window.DragByPixels(100, 100);
43 | 
44 |     // THEN
45 |     // the window is visible
46 |     _window.IsVisible.ShouldBeTrue();
47 |     // and the window is at the correct position
48 |     _window.Position.ShouldBe(initialPosition + new Vector2I(100, 100));
49 |   }
50 | }
51 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/LabelDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for the <see cref="Label"/> control.
 8 | /// </summary>
 9 | /// <typeparam name="T">Label type.</typeparam>
10 | public class LabelDriver<T> : ControlDriver<T> where T : Label
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic LabelDriver.
14 |   /// </summary>
15 |   /// <param name="producer">Producer that creates a Label subclass.</param>
16 |   /// <param name="description">Driver description.</param>
17 |   public LabelDriver(Func<T> producer, string description = "")
18 |     : base(producer, description)
19 |   {
20 |   }
21 | 
22 |   /// <summary>
23 |   /// The current text of the label.
24 |   /// </summary>
25 |   public string Text => PresentRoot.Text;
26 | }
27 | 
28 | /// <summary>
29 | /// Driver for the <see cref="Label"/> control.
30 | /// </summary>
31 | public sealed class LabelDriver : LabelDriver<Label>
32 | {
33 |   /// <summary>
34 |   /// Creates a new LabelDriver.
35 |   /// </summary>
36 |   /// <param name="producer">Producer that creates a Label subclass.</param>
37 |   /// <param name="description">Driver description.</param>
38 |   public LabelDriver(Func<Label> producer, string description = "")
39 |     : base(producer, description)
40 |   {
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/CheckBoxDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for a <see cref="CheckBox"/>.
 8 | /// </summary>
 9 | /// <typeparam name="T">CheckBox type.</typeparam>
10 | public class CheckBoxDriver<T> : ButtonDriver<T> where T : CheckBox
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic CheckBoxDriver.
14 |   /// </summary>
15 |   /// <param name="producer">Producer that creates a CheckBox subclass.</param>
16 |   /// <param name="description">Driver description.</param>
17 |   public CheckBoxDriver(Func<T> producer, string description = "")
18 |     : base(producer, description)
19 |   {
20 |   }
21 | 
22 |   /// <summary>
23 |   /// Whether the checkbox is currently checked.
24 |   /// </summary>
25 |   public bool IsChecked => PresentRoot.ButtonPressed;
26 | }
27 | 
28 | /// <summary>
29 | /// Driver for a <see cref="CheckBox"/>.
30 | /// </summary>
31 | public sealed class CheckBoxDriver : CheckBoxDriver<CheckBox>
32 | {
33 |   /// <summary>
34 |   /// Creates a new CheckBoxDriver.
35 |   /// </summary>
36 |   /// <param name="producer">Producer that creates a CheckBox subclass.</param>
37 |   /// <param name="description">Driver description.</param>
38 |   public CheckBoxDriver(Func<CheckBox> producer, string description = "")
39 |     : base(producer, description)
40 |   {
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/Chickensoft.GodotTestDriver.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Godot.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net8.0</TargetFramework>
 4 |     <EnableDynamicLoading>true</EnableDynamicLoading>
 5 |     <LangVersion>preview</LangVersion>
 6 |     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 7 |     <GenerateDocumentationFile>true</GenerateDocumentationFile>
 8 |     <OutputPath>./nupkg</OutputPath>
 9 |     <DebugType>portable</DebugType>
10 |     <Nullable>enable</Nullable>
11 | 
12 |     <Title>GodotTestDriver</Title>
13 |     <Description>Easy integration testing for Godot with simulated input, node drivers, and fixtures.</Description>
14 |     <Copyright>(C) 2022-2024 Jan Thomä and Chickensoft</Copyright>
15 | 
16 |     <PackageId>Chickensoft.GodotTestDriver</PackageId>
17 |     <PackageVersion>0.0.0-devbuild</PackageVersion>
18 |     <PackageReadmeFile>README.md</PackageReadmeFile>
19 |     <PackageReleaseNotes>GodotTestDriver release.</PackageReleaseNotes>
20 |     <PackageProjectUrl>https://github.com/chickensoft-games/GodotTestDriver</PackageProjectUrl>
21 |     <PackageLicenseFile>LICENSE</PackageLicenseFile>
22 | 
23 |     <RepositoryType>git</RepositoryType>
24 |     <RepositoryUrl>https://github.com/chickensoft-games/GodotTestDriver.git</RepositoryUrl>
25 |   </PropertyGroup>
26 |   <ItemGroup>
27 |     <None Include="../README.md" Pack="true" PackagePath="\" />
28 |     <None Include="../LICENSE" Pack="true" PackagePath="\" />
29 |     <None Include="./icon.png" Pack="true" PackagePath="" />
30 |   </ItemGroup>
31 | </Project>
32 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/CanvasItemDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for <see cref="CanvasItem"/> nodes.
 8 | /// </summary>
 9 | /// <typeparam name="T">CanvasItem type.</typeparam>
10 | public class CanvasItemDriver<T> : NodeDriver<T> where T : CanvasItem
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic CanvasItemDriver.
14 |   /// </summary>
15 |   /// <param name="producer">
16 |   /// Producer that creates a CanvasItem subclass.
17 |   /// </param>
18 |   /// <param name="description">Driver description.</param>
19 |   public CanvasItemDriver(Func<T> producer, string description = "")
20 |     : base(producer, description)
21 |   {
22 |   }
23 | 
24 |   /// <summary>
25 |   /// Is the CanvasItem currently visible?
26 |   /// </summary>
27 |   public bool IsVisible => PresentRoot.IsVisibleInTree();
28 | 
29 |   /// <summary>
30 |   /// The viewport that this canvas item is rendering to.
31 |   /// </summary>
32 |   public Viewport Viewport => PresentRoot.GetViewport();
33 | 
34 |   /// <summary>
35 |   /// Returns the root node but ensures it is visible.
36 |   /// </summary>
37 |   /// <exception cref="InvalidOperationException"/>
38 |   protected T VisibleRoot
39 |   {
40 |     get
41 |     {
42 |       var root = PresentRoot;
43 |       return !root.IsVisibleInTree()
44 |         ? throw new InvalidOperationException(
45 |           ErrorMessage("Cannot interact with CanvasItem because it is not visible.")
46 |         )
47 |         : root;
48 |     }
49 |   }
50 | }
51 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "2.0.0",
 3 |   "tasks": [
 4 |     {
 5 |       "label": "build",
 6 |       "command": "dotnet",
 7 |       "type": "process",
 8 |       "args": [
 9 |         "build",
10 |         "--no-restore"
11 |       ],
12 |       "problemMatcher": "$msCompile",
13 |       "presentation": {
14 |         "echo": true,
15 |         "reveal": "silent",
16 |         "focus": false,
17 |         "panel": "shared",
18 |         "showReuseMessage": false,
19 |         "clear": false
20 |       }
21 |     },
22 |     {
23 |       "label": "coverage",
24 |       "group": "test",
25 |       "command": "${workspaceFolder}/Chickensoft.GodotTestDriver.Tests/coverage.sh",
26 |       "type": "shell",
27 |       "options": {
28 |         "cwd": "${workspaceFolder}/Chickensoft.GodotTestDriver.Tests"
29 |       },
30 |       "presentation": {
31 |         "echo": true,
32 |         "reveal": "always",
33 |         "focus": false,
34 |         "panel": "shared",
35 |         "showReuseMessage": false,
36 |         "clear": true
37 |       },
38 |     },
39 |     {
40 |       "label": "build-solutions",
41 |       "group": "test",
42 |       "command": "dotnet restore; ${env:GODOT4} --headless --build-solutions --quit || exit 0",
43 |       "type": "shell",
44 |       "options": {
45 |         "cwd": "${workspaceFolder}/Chickensoft.GodotTestDriver.Tests"
46 |       },
47 |       "presentation": {
48 |         "echo": true,
49 |         "reveal": "silent",
50 |         "focus": false,
51 |         "panel": "shared",
52 |         "showReuseMessage": false,
53 |         "clear": false
54 |       }
55 |     },
56 |   ]
57 | }
58 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Sprite2DDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using Chickensoft.GoDotTest;
 4 | using Godot;
 5 | using GodotTestDriver.Drivers;
 6 | using Shouldly;
 7 | 
 8 | public class Sprite2DDriverTest : DriverTest
 9 | {
10 |   private readonly Sprite2DDriver _sprite2D;
11 |   private readonly Sprite2DDriver _partiallyVisibleSprite2D;
12 | 
13 |   public Sprite2DDriverTest(Node testScene) : base(testScene)
14 |   {
15 |     _sprite2D = new Sprite2DDriver(
16 |       () => RootNode.GetNode<Sprite2D>("Sprite2D")
17 |     );
18 |     _partiallyVisibleSprite2D = new Sprite2DDriver(
19 |       () => RootNode.GetNode<Sprite2D>("PartiallyVisibleSprite2D")
20 |     );
21 |   }
22 | 
23 |   [Test]
24 |   public void InspectionWorks()
25 |   {
26 |     // WHEN
27 |     // everything is set up
28 | 
29 |     // THEN
30 |     // the sprite is visible
31 |     _sprite2D.IsVisible.ShouldBeTrue();
32 |     // it is not flipped horizontally but it is flipped vertically
33 |     _sprite2D.IsFlippedHorizontally.ShouldBeFalse();
34 |     _sprite2D.IsFlippedVertically.ShouldBeTrue();
35 |     // and is fully in view
36 |     _sprite2D.IsFullyInView.ShouldBeTrue();
37 | 
38 |     // and the partially visible sprite is visible
39 |     _partiallyVisibleSprite2D.IsVisible.ShouldBeTrue();
40 |     // is flipped horizontally but not vertically
41 |     _partiallyVisibleSprite2D.IsFlippedHorizontally.ShouldBeTrue();
42 |     _partiallyVisibleSprite2D.IsFlippedVertically.ShouldBeFalse();
43 | 
44 |     // and is not fully in view
45 |     _partiallyVisibleSprite2D.IsFullyInView.ShouldBeFalse();
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ButtonDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using Shouldly;
 8 | 
 9 | public class ButtonDriverTest : DriverTest
10 | {
11 |   private readonly ButtonDriver _button;
12 |   private readonly LabelDriver _label;
13 |   private readonly ControlDriver<Panel> _panel;
14 | 
15 |   public ButtonDriverTest(Node testScene) : base(testScene)
16 |   {
17 |     _button = new ButtonDriver(() => RootNode.GetNode<Button>("Button"));
18 |     _label = new LabelDriver(() => RootNode.GetNode<Label>("Label"));
19 |     _panel = new ControlDriver<Panel>(() => RootNode.GetNode<Panel>("Panel"));
20 |   }
21 | 
22 |   [Test]
23 |   public void ClickingWorks()
24 |   {
25 |     // WHEN
26 |     // i click the button
27 |     _button.ClickCenter();
28 |     // the label text changes.
29 |     _label.Text.ShouldBe("did work");
30 |     // and the panel disappears
31 |     _panel.IsVisible.ShouldBeFalse();
32 |   }
33 | 
34 |   [Test]
35 |   public void ClickingDisabledButtonThrowsException()
36 |   {
37 |     // SETUP
38 |     _button.PresentRoot.Disabled = true;
39 |     // WHEN
40 |     // i click the button then an exception is thrown
41 |     Should.Throw<InvalidOperationException>(() => _button.ClickCenter());
42 |   }
43 | 
44 |   [Test]
45 |   public void ClickingHiddenButtonThrowsException()
46 |   {
47 |     // SETUP
48 |     _button.PresentRoot.Visible = false;
49 |     // WHEN
50 |     // i click the button then an exception is thrown
51 |     Should.Throw<InvalidOperationException>(() => _button.ClickCenter());
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/Camera2DDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System.Threading.Tasks;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using Shouldly;
 8 | 
 9 | public class Camera2DDriverTest : DriverTest
10 | {
11 |   private readonly Camera2DDriver _camera2D;
12 |   private readonly Sprite2DDriver _centerSprite;
13 |   private readonly Sprite2DDriver _offCenterSprite;
14 | 
15 |   public Camera2DDriverTest(Node testScene) : base(testScene)
16 |   {
17 |     _camera2D = new Camera2DDriver(
18 |       () => RootNode.GetNode<Camera2D>("Camera2D")
19 |     );
20 |     _centerSprite = new Sprite2DDriver(
21 |       () => RootNode.GetNode<Sprite2D>("CenterSprite")
22 |     );
23 |     _offCenterSprite = new Sprite2DDriver(
24 |       () => RootNode.GetNode<Sprite2D>("OffCenterSprite")
25 |     );
26 |   }
27 | 
28 |   [Test]
29 |   public void Camera2DIsPresent()
30 |   {
31 |     _camera2D.IsPresent.ShouldBeTrue();
32 |     //  and center sprite is visible
33 |     _centerSprite.IsFullyInView.ShouldBeTrue();
34 |     //  and off center sprite is not visible
35 |     _offCenterSprite.IsFullyInView.ShouldBeFalse();
36 |   }
37 | 
38 |   [Test]
39 |   public async Task Camera2DCanMove()
40 |   {
41 |     // WHEN
42 |     // I move camera to off-center sprite
43 |     var moveTask = _camera2D.MoveIntoView(_offCenterSprite.GlobalPosition, 2);
44 | 
45 |     // THEN
46 |     //  the camera has successfully moved to the new position
47 |     (await moveTask).ShouldBeTrue();
48 | 
49 |     //  and off center sprite is visible
50 |     _offCenterSprite.IsFullyInView.ShouldBeTrue();
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/Chickensoft.GodotTestDriver.Tests.sln:
--------------------------------------------------------------------------------
 1 | Microsoft Visual Studio Solution File, Format Version 12.00
 2 | # Visual Studio 2012
 3 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Chickensoft.GodotTestDriver.Tests", "Chickensoft.GodotTestDriver.Tests.csproj", "{85275D7D-B506-49F3-9F53-96C81C221093}"
 4 | EndProject
 5 | Global
 6 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 7 | 		Debug|Any CPU = Debug|Any CPU
 8 | 		Debug|x64 = Debug|x64
 9 | 		Debug|x86 = Debug|x86
10 | 		Release|Any CPU = Release|Any CPU
11 | 		Release|x64 = Release|x64
12 | 		Release|x86 = Release|x86
13 | 	EndGlobalSection
14 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
15 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
16 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|Any CPU.Build.0 = Debug|Any CPU
17 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|x64.ActiveCfg = Debug|Any CPU
18 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|x64.Build.0 = Debug|Any CPU
19 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|x86.ActiveCfg = Debug|Any CPU
20 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Debug|x86.Build.0 = Debug|Any CPU
21 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|Any CPU.ActiveCfg = Debug|Any CPU
22 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|Any CPU.Build.0 = Debug|Any CPU
23 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|x64.ActiveCfg = Debug|Any CPU
24 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|x64.Build.0 = Debug|Any CPU
25 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|x86.ActiveCfg = Debug|Any CPU
26 | 		{85275D7D-B506-49F3-9F53-96C81C221093}.Release|x86.Build.0 = Debug|Any CPU
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/RichTextLabelDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for the <see cref="RichTextLabel"/> control.
 8 | /// </summary>
 9 | /// <typeparam name="T">RichTextLabel type.</typeparam>
10 | public class RichTextLabelDriver<T> : ControlDriver<T> where T : RichTextLabel
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic RichTextLabelDriver.
14 |   /// </summary>
15 |   /// <param name="producer">
16 |   /// Producer that creates a RichTextLabel subclass.
17 |   /// </param>
18 |   /// <param name="description">Driver description.</param>
19 |   public RichTextLabelDriver(Func<T> producer, string description = "")
20 |     : base(producer, description)
21 |   {
22 |   }
23 | 
24 |   /// <summary>
25 |   /// The current text of the label.
26 |   /// </summary>
27 |   public string Text => PresentRoot.Text;
28 | 
29 |   /// <summary>
30 |   /// Returns true if the label has bbcode enabled.
31 |   /// </summary>
32 |   public bool IsBbcodeEnabled => PresentRoot.BbcodeEnabled;
33 | }
34 | 
35 | /// <summary>
36 | /// Driver for the <see cref="RichTextLabel"/> control.
37 | /// </summary>
38 | public sealed class RichTextLabelDriver : RichTextLabelDriver<RichTextLabel>
39 | {
40 |   /// <summary>
41 |   /// Creates a new RichTextLabelDriver.
42 |   /// </summary>
43 |   /// <param name="producer">
44 |   /// Producer that creates a RichTextLabel subclass.
45 |   /// </param>
46 |   /// <param name="description">Driver description.</param>
47 |   public RichTextLabelDriver(
48 |     Func<RichTextLabel> producer,
49 |     string description = ""
50 |   )
51 |     : base(producer, description)
52 |   {
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/cspell.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "files": [
 3 |     "**/*.*"
 4 |   ],
 5 |   "ignorePaths": [
 6 |     "**/*.tscn",
 7 |     "**/*.import",
 8 |     "**/*.uid",
 9 |     "**/badges/**/*.*",
10 |     "**/coverage/**/*.*",
11 |     "**/.godot/**/*.*",
12 |     "**/obj/**/*.*",
13 |     "**/bin/**/*.*",
14 |     "**/nupkg/**/*.*",
15 |   ],
16 |   "words": [
17 |     "assemblyfilters",
18 |     "automerge",
19 |     "basisxform",
20 |     "bbcode",
21 |     "branchcoverage",
22 |     "brandedoutcast",
23 |     "buildtransitive",
24 |     "camelcase",
25 |     "chickenpackage",
26 |     "Chickensoft",
27 |     "classfilters",
28 |     "contentfiles",
29 |     "CYGWIN",
30 |     "deadzone",
31 |     "definitelyokay",
32 |     "derkork",
33 |     "devbuild",
34 |     "endregion",
35 |     "enduml",
36 |     "finalizer",
37 |     "finalizers",
38 |     "gamedev",
39 |     "globaltool",
40 |     "godotengine",
41 |     "godotpackage",
42 |     "graphviz",
43 |     "issuecomment",
44 |     "jebbs",
45 |     "joypad",
46 |     "lcov",
47 |     "libexec",
48 |     "linecoverage",
49 |     "Linq",
50 |     "methodcoverage",
51 |     "missingall",
52 |     "Moq's",
53 |     "msbuild",
54 |     "MSYS",
55 |     "nameof",
56 |     "netstandard",
57 |     "NOLOGO",
58 |     "nupkg",
59 |     "Omnisharp",
60 |     "opencover",
61 |     "OPTOUT",
62 |     "paramref",
63 |     "pascalcase",
64 |     "picoweb",
65 |     "plantuml",
66 |     "puml",
67 |     "renovatebot",
68 |     "reportgenerator",
69 |     "reporttypes",
70 |     "savegame",
71 |     "Shouldly",
72 |     "startuml",
73 |     "statechart",
74 |     "statecharts",
75 |     "struct",
76 |     "Subclassing",
77 |     "subfolders",
78 |     "Substate",
79 |     "targetargs",
80 |     "targetdir",
81 |     "Theraot",
82 |     "Thomä",
83 |     "thumbstick",
84 |     "tscn",
85 |     "typeof",
86 |     "typeparam",
87 |     "typeparamref",
88 |     "ulong",
89 |     "VBCS",
90 |     "Xunit"
91 |   ]
92 | }
93 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | Thank you for taking the time to read this contributing guide and for showing interest in helping this project!
 4 | 
 5 | ## Getting Started
 6 | 
 7 | Need a helping hand to get started? Check out these resources!
 8 | 
 9 | - [Discord Server][discord]
10 | - [Chickensoft Website][chickensoft]
11 | 
12 | Please read our [code of conduct](#code-of-conduct). We do our best to treat others fairly and foster a welcoming environment.
13 | 
14 | ## Project Setup
15 | 
16 | This is a C# nuget package, for use with the .NET SDK 8. As such, the `dotnet` tool will allow you to restore packages and build projects.
17 | 
18 | The `Chickensoft.GodotTestDriver.Tests` project must be built with the Godot editor at least once before `dotnet build` will succeed. Godot has to generate the .NET bindings for the project, since tests run in an actual game environment.
19 | 
20 | ## Coding Guidelines
21 | 
22 | Your IDE should automatically adhere to the style guidelines in the provided `.editorconfig` file. Please try to keep lines under 80 characters long whenever possible.
23 | 
24 | We try to write tests for our projects to ensure a certain level of quality. We are willing to give you support and guidance if you need help!
25 | 
26 | ## Code of Conduct
27 | 
28 | We follow the [Contributor Covenant][covenant].
29 | 
30 | In short:
31 | 
32 | > We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
33 | 
34 | <!-- Links -->
35 | 
36 | [discord]: https://discord.gg/gSjaPgMmYW
37 | [chickensoft]: https://chickensoft.games
38 | [covenant]: https://www.contributor-covenant.org/version/2/1/code_of_conduct/
39 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/Port.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// This structure identifies a port of a <see cref="GraphNode"/>
 8 | /// </summary>
 9 | public readonly struct Port
10 | {
11 |   /// <summary>
12 |   /// The index of the port.
13 |   /// </summary>
14 |   public int PortIndex { get; }
15 | 
16 |   private readonly bool _isInput;
17 | 
18 |   /// <summary>
19 |   /// Whether this port is an input port.
20 |   /// </summary>
21 |   public bool IsInput => IsDefined && _isInput;
22 | 
23 |   /// <summary>
24 |   /// Whether this port is an output port.
25 |   /// </summary>
26 |   public bool IsOutput => IsDefined && !_isInput;
27 | 
28 |   /// <summary>
29 |   /// The default value of this is false, so if you do a Port foo = default you
30 |   /// will get an undefined port id.
31 |   /// </summary>
32 |   public bool IsDefined { get; }
33 | 
34 |   private Port(int port, bool isInput)
35 |   {
36 |     ArgumentOutOfRangeException.ThrowIfNegative(port);
37 |     PortIndex = port;
38 |     _isInput = isInput;
39 |     IsDefined = true;
40 |   }
41 | 
42 |   /// <summary>
43 |   /// Creates a new input port.
44 |   /// </summary>
45 |   /// <param name="port">Port index.</param>
46 |   /// <returns>A new port instance.</returns>
47 |   public static Port Input(int port) => new(port, true);
48 | 
49 |   /// <summary>
50 |   /// Creates a new output port.
51 |   /// </summary>
52 |   /// <param name="port">Port index.</param>
53 |   /// <returns>A new port instance.</returns>
54 |   public static Port Output(int port) => new(port, false);
55 | 
56 |   /// <summary>
57 |   /// The default Port is undefined and represents no port.
58 |   /// </summary>
59 |   public static readonly Port None;
60 | 
61 |   /// <summary>
62 |   /// String representation of the port.
63 |   /// </summary>
64 |   public override string ToString() =>
65 |     IsInput
66 |       ? $"Input Port {PortIndex}"
67 |       : $"Output Port {PortIndex}";
68 | }
69 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TextEditDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using Shouldly;
 8 | 
 9 | public class TextEditDriverTest : DriverTest
10 | {
11 |   private readonly TextEditDriver _textEdit;
12 | 
13 |   public TextEditDriverTest(Node testScene) : base(testScene)
14 |   {
15 |     _textEdit = new TextEditDriver(
16 |       () => RootNode.GetNode<TextEdit>("TextEdit")
17 |     );
18 |   }
19 | 
20 |   [Test]
21 |   public void TypingWorks()
22 |   {
23 |     // get the signal awaiter
24 |     var signalAwaiter = _textEdit.GetSignalAwaiter(
25 |       TextEdit.SignalName.TextChanged
26 |     );
27 | 
28 |     // WHEN
29 |     // i type "Hello World!" into the text edit
30 |     _textEdit.Type("Hello World!");
31 | 
32 |     // THEN
33 |     // the text edit text is "Hello World!"
34 |     _textEdit.Text.ShouldBe("Hello World!");
35 | 
36 |     // and the text changed signal was emitted
37 |     signalAwaiter.IsCompleted.ShouldBeTrue();
38 |   }
39 | 
40 |   [Test]
41 |   public void TypingThrowsExceptionIfNotEditable()
42 |   {
43 |     // GIVEN
44 |     // the text edit is not editable
45 |     _textEdit.PresentRoot.Editable = false;
46 | 
47 |     // WHEN
48 |     // i try to type "Hello World!" into the text edit
49 |     var exception = Should.Throw<InvalidOperationException>(
50 |       () => _textEdit.Type("Hello World!")
51 |     );
52 | 
53 |     // THEN
54 |     // the exception message is correct
55 |     exception.Message.ShouldContain("it is read-only");
56 |   }
57 | 
58 |   [Test]
59 |   public void ReadOnlyStatusIsProperlyDetected()
60 |   {
61 |     // GIVEN
62 |     // the text edit is editable
63 |     _textEdit.PresentRoot.Editable = true;
64 | 
65 |     // THEN
66 |     // the text edit is not read-only
67 |     _textEdit.ReadOnly.ShouldBeFalse();
68 | 
69 |     // GIVEN
70 |     // the text edit is not editable
71 |     _textEdit.PresentRoot.Editable = false;
72 | 
73 |     // THEN
74 |     // the text edit is read-only
75 |     _textEdit.ReadOnly.ShouldBeTrue();
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/Sprite2DDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | using GodotTestDriver.Util;
 6 | 
 7 | /// <summary>
 8 | /// Driver for <see cref="Sprite2D"/> nodes.
 9 | /// </summary>
10 | /// <typeparam name="T">Sprite2D type.</typeparam>
11 | /// [PublicAPI]
12 | public class Sprite2DDriver<T> : Node2DDriver<T> where T : Sprite2D
13 | {
14 |   /// <summary>
15 |   /// Creates a new generic Sprite2DDriver.
16 |   /// </summary>
17 |   /// <param name="producer">Producer that creates a Sprite2D subclass.</param>
18 |   /// <param name="description">Driver description.</param>
19 |   public Sprite2DDriver(Func<T> producer, string description = "")
20 |     : base(producer, description)
21 |   {
22 |   }
23 | 
24 |   /// <summary>
25 |   /// Whether the sprite is flipped horizontally.
26 |   /// </summary>
27 |   public bool IsFlippedHorizontally => PresentRoot.FlipH;
28 | 
29 |   /// <summary>
30 |   /// Whether the sprite is flipped vertically.
31 |   /// </summary>
32 |   public bool IsFlippedVertically => PresentRoot.FlipV;
33 | 
34 |   /// <summary>
35 |   /// Returns true if the Node is visible and fully inside the viewport rect.
36 |   /// </summary>
37 |   public bool IsFullyInView
38 |   {
39 |     get
40 |     {
41 |       if (!IsVisible)
42 |       {
43 |         return false;
44 |       }
45 | 
46 |       var sprite = VisibleRoot;
47 |       var screenRect = sprite
48 |         .GetViewport()
49 |         .WorldToScreen(sprite.GetRect().ToGlobalRect(sprite.GlobalPosition));
50 |       return sprite.GetViewportRect().Encloses(screenRect);
51 |     }
52 |   }
53 | }
54 | 
55 | /// <summary>
56 | /// Driver for <see cref="Sprite2D"/> nodes.
57 | /// </summary>
58 | public class Sprite2DDriver : Sprite2DDriver<Sprite2D>
59 | {
60 |   /// <summary>
61 |   /// Creates a new Sprite2DDriver.
62 |   /// </summary>
63 |   /// <param name="producer">Producer that creates a Sprite2D subclass.</param>
64 |   /// <param name="description">Driver description.</param>
65 |   public Sprite2DDriver(Func<Sprite2D> producer, string description = "")
66 |     : base(producer, description)
67 |   {
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/TextEditDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for the <see cref="TextEdit"/> control.
 8 | /// </summary>
 9 | /// <typeparam name="T">TextEdit type.</typeparam>
10 | /// [PublicAPI]
11 | public class TextEditDriver<T> : ControlDriver<T> where T : TextEdit
12 | {
13 |   /// <summary>
14 |   /// Creates a new generic TextEditDriver.
15 |   /// </summary>
16 |   /// <param name="producer">Producer that creates a TextEdit subclass.</param>
17 |   /// <param name="description">Driver description.</param>
18 |   public TextEditDriver(Func<T> producer, string description = "")
19 |     : base(producer, description)
20 |   {
21 |   }
22 | 
23 |   /// <summary>
24 |   /// Text contents.
25 |   /// </summary>
26 |   public string Text => PresentRoot.Text;
27 | 
28 |   /// <summary>
29 |   /// Whether the text edit is currently editable.
30 |   /// </summary>
31 |   public bool ReadOnly => !PresentRoot.Editable;
32 | 
33 |   /// <summary>
34 |   /// Types the given text into the text edit. Existing text will be overwritten.
35 |   /// </summary>
36 |   /// <param name="text">Text to input.</param>
37 |   /// <exception cref="InvalidOperationException" />
38 |   public void Type(string text)
39 |   {
40 |     if (ReadOnly)
41 |     {
42 |       throw new InvalidOperationException(
43 |         ErrorMessage("Cannot type text into TextEdit because it is read-only.")
44 |       );
45 |     }
46 | 
47 |     var edit = VisibleRoot;
48 |     ClickCenter();
49 |     edit.Text = text;
50 |     edit.EmitSignal(TextEdit.SignalName.TextChanged, text);
51 |   }
52 | }
53 | 
54 | /// <summary>
55 | /// Driver for the <see cref="TextEdit"/> control.
56 | /// </summary>
57 | public class TextEditDriver : TextEditDriver<TextEdit>
58 | {
59 |   /// <summary>
60 |   /// Creates a new TextEditDriver.
61 |   /// </summary>
62 |   /// <param name="producer">Producer that creates a TextEdit subclass.</param>
63 |   /// <param name="description">Driver description.</param>
64 |   public TextEditDriver(Func<TextEdit> producer, string description = "")
65 |     : base(producer, description)
66 |   {
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Input/ActionsInputExtensions.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Input;
 2 | 
 3 | using System.Threading.Tasks;
 4 | using Godot;
 5 | using GodotTestDriver.Util;
 6 | 
 7 | #pragma warning disable IDE0060
 8 | 
 9 | /// <summary>
10 | /// Extensions for simulating action inputs.
11 | /// </summary>
12 | public static class ActionsInputExtensions
13 | {
14 |   /// <summary>
15 |   /// Hold an input action for a given duration.
16 |   /// </summary>
17 |   /// <param name="node">Node that generates simulated input.</param>
18 |   /// <param name="seconds">Time, in seconds.</param>
19 |   /// <param name="actionName">Name of the action.</param>
20 |   /// <returns>Task that completes when the input finishes.</returns>
21 |   public static async Task HoldActionFor(
22 |       this Node node,
23 |       float seconds,
24 |       string actionName
25 |   )
26 |   {
27 |     node.StartAction(actionName);
28 |     await node.Wait(seconds);
29 |     node.EndAction(actionName);
30 |   }
31 | 
32 |   /// <summary>
33 |   /// Start an input action.
34 |   /// </summary>
35 |   /// <param name="node">Node that generates simulated input.</param>
36 |   /// <param name="actionName">Name of the action.</param>
37 |   /// <param name="strength">
38 |   /// Action strength (optional — default is 1.0).
39 |   /// </param>
40 |   public static void StartAction(
41 |       this Node node, string actionName, float strength = 1f
42 |   )
43 |   {
44 |     Input.ParseInputEvent(new InputEventAction
45 |     {
46 |       Action = actionName,
47 |       Pressed = true,
48 |       Strength = strength
49 |     });
50 |     Input.ActionPress(actionName, strength);
51 |     Input.FlushBufferedEvents();
52 |   }
53 | 
54 |   /// <summary>
55 |   /// End an input action.
56 |   /// </summary>
57 |   /// <param name="node">Node that generates simulated input.</param>
58 |   /// <param name="actionName">Name of the action.</param>
59 |   public static void EndAction(this Node node, string actionName)
60 |   {
61 |     Input.ParseInputEvent(new InputEventAction
62 |     {
63 |       Action = actionName,
64 |       Pressed = false
65 |     });
66 |     Input.ActionRelease(actionName);
67 |     Input.FlushBufferedEvents();
68 |   }
69 | }
70 | 
71 | #pragma warning restore IDE0060
72 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/BaseButtonDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for <see cref="BaseButton"/> controls.
 8 | /// </summary>
 9 | /// <typeparam name="T">BaseButton type.</typeparam>
10 | public class BaseButtonDriver<T> : ControlDriver<T> where T : BaseButton
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic BaseButtonDriver.
14 |   /// </summary>
15 |   /// <param name="producer">
16 |   /// Producer that creates a BaseButton subclass.
17 |   /// </param>
18 |   /// <param name="description">Driver description.</param>
19 |   public BaseButtonDriver(Func<T> producer, string description = "")
20 |     : base(producer, description)
21 |   {
22 |   }
23 | 
24 |   /// <summary>
25 |   /// Whether the button is currently disabled.
26 |   /// </summary>
27 |   public bool Disabled => PresentRoot.Disabled;
28 | 
29 |   /// <summary>
30 |   /// Whether the button is currently enabled. Inverted from
31 |   /// <see cref="Disabled"/>.
32 |   /// </summary>
33 |   public bool Enabled => !Disabled;
34 | 
35 |   /// <summary>
36 |   /// Whether the button is currently pressed.
37 |   /// </summary>
38 |   public bool Pressed => PresentRoot.ButtonPressed;
39 | 
40 |   /// <summary>
41 |   ///  Simulates a button press by simply sending the press event.
42 |   /// </summary>
43 |   /// <exception cref="InvalidOperationException"/>
44 |   public void Press()
45 |   {
46 |     var button = VisibleRoot;
47 | 
48 |     if (button.Disabled)
49 |     {
50 |       throw new InvalidOperationException(
51 |         ErrorMessage("Button is disabled and cannot be pressed.")
52 |       );
53 |     }
54 | 
55 |     button.EmitSignal(BaseButton.SignalName.Pressed);
56 |   }
57 | 
58 |   /// <summary>
59 |   /// Clicks the center of the button.
60 |   /// </summary>
61 |   /// <param name="button">Mouse button.</param>
62 |   /// <exception cref="InvalidOperationException" />
63 |   public override void ClickCenter(MouseButton button = MouseButton.Left)
64 |   {
65 |     if (Disabled)
66 |     {
67 |       throw new InvalidOperationException(
68 |         ErrorMessage("Button is disabled and cannot be pressed.")
69 |       );
70 |     }
71 | 
72 |     base.ClickCenter(button);
73 |   }
74 | }
75 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/TabContainerDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System.Threading.Tasks;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using GodotTestDriver.Util;
 8 | using Shouldly;
 9 | 
10 | public class TabContainerDriverTest : DriverTest
11 | {
12 |   private readonly TabContainerDriver _tabContainer;
13 |   private readonly ControlDriver<Control> _firstTabContent;
14 |   private readonly ControlDriver<Control> _secondTabContent;
15 | 
16 |   public TabContainerDriverTest(Node testScene) : base(testScene)
17 |   {
18 |     _tabContainer = new TabContainerDriver(
19 |       () => RootNode.GetNode<TabContainer>("TabContainer")
20 |     );
21 |     _firstTabContent = new ControlDriver<Control>(
22 |       () => _tabContainer.Root?.FindChild("First Tab Content") as Control
23 |     );
24 |     _secondTabContent = new ControlDriver<Control>(
25 |       () => _tabContainer.Root?.FindChild("Second Tab Content") as Control
26 |     );
27 |   }
28 | 
29 |   [Test]
30 |   public void InspectionWorks()
31 |   {
32 |     // WHEN
33 |     // everything is set up
34 | 
35 |     // THEN
36 |     // the tab container has two tabs
37 |     _tabContainer.TabCount.ShouldBe(2);
38 |     // the first tab is selected
39 |     _tabContainer.SelectedTabIndex.ShouldBe(0);
40 |     // the first tab has the correct title
41 |     _tabContainer.SelectedTabTitle.ShouldBe("First Tab");
42 |     // the first tab has the correct content
43 |     _firstTabContent.IsVisible.ShouldBeTrue();
44 |     _secondTabContent.IsVisible.ShouldBeFalse();
45 |   }
46 | 
47 |   /// <summary>
48 |   /// changing a tab works
49 |   /// </summary>
50 |   [Test]
51 |   public async Task ChangingTabsWorks()
52 |   {
53 |     // WHEN
54 |     // the second tab is selected
55 |     _tabContainer.SelectTabWithTitle("Second Tab");
56 |     // and we've waited an additional frame for Godot to change visibility
57 |     await _tabContainer.PresentRoot.ProcessFrame();
58 | 
59 |     // THEN
60 |     // the second tab is selected
61 |     _tabContainer.SelectedTabIndex.ShouldBe(1);
62 |     // the second tab has the correct title
63 |     _tabContainer.SelectedTabTitle.ShouldBe("Second Tab");
64 |     // the second tab has the correct content
65 |     _firstTabContent.IsVisible.ShouldBeFalse();
66 |     _secondTabContent.IsVisible.ShouldBeTrue();
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/PopupMenuDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System.Linq;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using Shouldly;
 8 | 
 9 | public class PopupMenuDriverTest : DriverTest
10 | {
11 |   private readonly PopupMenuDriver _popupMenu;
12 |   private readonly ButtonDriver _button;
13 | 
14 |   public PopupMenuDriverTest(Node testScene) : base(testScene)
15 |   {
16 |     _popupMenu = new PopupMenuDriver(
17 |       () => RootNode.GetNode<PopupMenu>("PopupMenu")
18 |     );
19 |     _button = new ButtonDriver(() => RootNode.GetNode<Button>("Button"));
20 |   }
21 | 
22 |   [Test]
23 |   public void HiddenCheckWorks() =>
24 |     // WHEN
25 |     // everything is set up
26 | 
27 |     _popupMenu.IsVisible.ShouldBeFalse();
28 | 
29 |   [Test]
30 |   public void InspectionWorks()
31 |   {
32 |     // WHEN
33 |     // we press the button
34 |     _button.Press();
35 | 
36 |     // THEN
37 |     // the popup menu is visible
38 |     _popupMenu.IsVisible.ShouldBeTrue();
39 | 
40 |     // and we have two selectable items
41 |     _popupMenu.SelectableItems.Count().ShouldBe(2);
42 | 
43 |     // named "Normal Item 1" and "Normal Item 2"
44 |     _popupMenu.SelectableItems.First().ShouldBe("Normal Item 1");
45 |     _popupMenu.SelectableItems.Last().ShouldBe("Normal Item 2");
46 | 
47 |     // and the second item should be checked
48 |     _popupMenu.IsItemChecked("Normal Item 2").ShouldBeTrue();
49 | 
50 |     // and the "Separator" item should be a separator
51 |     _popupMenu.IsItemSeparator("Separator").ShouldBeTrue();
52 | 
53 |     // and the "Disabled Item" item should be disabled
54 |     _popupMenu.IsItemDisabled("Disabled Item").ShouldBeTrue();
55 |   }
56 | 
57 |   // popup introspection shows two selectable items
58 |   // named "Normal Item 1" and "Normal Item 2"
59 | 
60 |   [Test]
61 |   public void SelectingAnItemWorks()
62 |   {
63 |     // WHEN
64 |     // we press the button
65 |     _button.Press();
66 | 
67 |     // and we select the first item
68 |     var signalAwaiter = _popupMenu.GetSignalAwaiter(
69 |       PopupMenu.SignalName.IndexPressed
70 |     );
71 |     _popupMenu.SelectItemWithText("Normal Item 1");
72 | 
73 |     // THEN
74 |     // the popup menu should be hidden
75 |     _popupMenu.IsVisible.ShouldBeFalse();
76 | 
77 |     // and the signal is emitted
78 |     signalAwaiter.IsCompleted.ShouldBeTrue();
79 |     signalAwaiter.GetResult()[0].ShouldBe(0); // the first item is selected
80 |   }
81 | }
82 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/ControlDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using System.Threading.Tasks;
 5 | using Godot;
 6 | using GodotTestDriver.Input;
 7 | using GodotTestDriver.Util;
 8 | 
 9 | /// <summary>
10 | /// Driver for <see cref="Control"/> nodes.
11 | /// </summary>
12 | /// <typeparam name="T">Control type.</typeparam>
13 | public class ControlDriver<T> : CanvasItemDriver<T> where T : Control
14 | {
15 |   /// <summary>
16 |   /// Creates a new generic ControlDriver.
17 |   /// </summary>
18 |   /// <param name="producer">Producer that creates a Control subclass.</param>
19 |   /// <param name="description">Driver description.</param>
20 |   public ControlDriver(Func<T> producer, string description = "")
21 |     : base(producer, description)
22 |   {
23 |   }
24 | 
25 |   /// <summary>
26 |   /// Returns true if the Node is visible and fully inside the viewport rect.
27 |   /// </summary>
28 |   public bool IsFullyInView
29 |   {
30 |     get
31 |     {
32 |       if (!IsVisible)
33 |       {
34 |         return false;
35 |       }
36 | 
37 |       var control = VisibleRoot;
38 |       var screenRect = control
39 |         .GetViewport()
40 |         .WorldToScreen(control.GetGlobalRect());
41 |       return control.GetViewportRect().Encloses(screenRect);
42 |     }
43 |   }
44 | 
45 |   /// <summary>
46 |   /// Clicks the control with the mouse in the center.
47 |   /// </summary>
48 |   /// <param name="button">Mouse button.</param>
49 |   public virtual void ClickCenter(MouseButton button = MouseButton.Left)
50 |   {
51 |     var control = VisibleRoot;
52 |     control
53 |       .GetViewport()
54 |       .ClickMouseAt(control.GetGlobalRect().Center(), button);
55 |   }
56 | 
57 |   /// <summary>
58 |   /// Moves the mouse to the center of the control and hovers for the given
59 |   /// time in seconds.
60 |   /// </summary>
61 |   /// <param name="seconds">Number of seconds.</param>
62 |   public async Task Hover(float seconds)
63 |   {
64 |     var control = VisibleRoot;
65 |     control.GetViewport().MoveMouseTo(control.GetGlobalRect().Center());
66 |     await control.SleepSeconds(seconds);
67 |   }
68 | 
69 |   /// <summary>
70 |   /// Instructs the control to release the focus.
71 |   /// </summary>
72 |   public void ReleaseFocus()
73 |   {
74 |     var control = VisibleRoot;
75 |     control.ReleaseFocus();
76 |   }
77 | 
78 |   /// <summary>
79 |   /// Instructs the control to grab the focus.
80 |   /// </summary>
81 |   public void GrabFocus()
82 |   {
83 |     var control = VisibleRoot;
84 |     control.GrabFocus();
85 |   }
86 | }
87 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/GraphEditDriverTest.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=3 uid="uid://cqu3gtnaysjxj"]
 2 | 
 3 | [sub_resource type="GDScript" id="GDScript_bjxs1"]
 4 | resource_name = "GraphEditTestScript"
 5 | script/source = "extends GraphEdit
 6 | 
 7 | 
 8 | # Called when the node enters the scene tree for the first time.
 9 | func _ready():
10 | 	pass # Replace with function body.
11 | 
12 | 
13 | # Called every frame. 'delta' is the elapsed time since the previous frame.
14 | func _process(delta):
15 | 	pass
16 | 
17 | 
18 | 
19 | func _on_connection_request(from_node, from_port, to_node, to_port):
20 | 	connect_node(from_node, from_port, to_node, to_port)
21 | 
22 | 
23 | func _on_disconnection_request(from_node, from_port, to_node, to_port):
24 | 	disconnect_node(from_node, from_port, to_node, to_port)
25 | "
26 | 
27 | [node name="GraphEditDriverTest" type="Node"]
28 | 
29 | [node name="GraphEdit" type="GraphEdit" parent="."]
30 | anchors_preset = 15
31 | anchor_right = 1.0
32 | anchor_bottom = 1.0
33 | grow_horizontal = 2
34 | grow_vertical = 2
35 | right_disconnects = true
36 | script = SubResource("GDScript_bjxs1")
37 | 
38 | [node name="Node1" type="GraphNode" parent="GraphEdit"]
39 | layout_mode = 0
40 | offset_left = 231.0
41 | offset_top = 194.0
42 | offset_right = 360.0
43 | offset_bottom = 320.0
44 | mouse_filter = 1
45 | title = "I am Node 1"
46 | position_offset = Vector2(231, 194)
47 | slot/0/left_enabled = false
48 | slot/0/left_type = 0
49 | slot/0/left_color = Color(1, 1, 1, 1)
50 | slot/0/left_icon = null
51 | slot/0/right_enabled = true
52 | slot/0/right_type = 0
53 | slot/0/right_color = Color(1, 1, 1, 1)
54 | slot/0/right_icon = null
55 | slot/0/draw_stylebox = true
56 | 
57 | [node name="Label" type="Label" parent="GraphEdit/Node1"]
58 | layout_mode = 2
59 | text = "Lorem"
60 | 
61 | [node name="Node2" type="GraphNode" parent="GraphEdit"]
62 | layout_mode = 0
63 | offset_left = 721.0
64 | offset_top = 169.0
65 | offset_right = 850.0
66 | offset_bottom = 295.0
67 | mouse_filter = 1
68 | title = "I am Node 2"
69 | position_offset = Vector2(721, 169)
70 | slot/0/left_enabled = true
71 | slot/0/left_type = 0
72 | slot/0/left_color = Color(1, 1, 1, 1)
73 | slot/0/left_icon = null
74 | slot/0/right_enabled = false
75 | slot/0/right_type = 0
76 | slot/0/right_color = Color(1, 1, 1, 1)
77 | slot/0/right_icon = null
78 | slot/0/draw_stylebox = true
79 | 
80 | [node name="Label" type="Label" parent="GraphEdit/Node2"]
81 | layout_mode = 2
82 | text = "Ipsum"
83 | 
84 | [connection signal="connection_request" from="GraphEdit" to="GraphEdit" method="_on_connection_request"]
85 | [connection signal="disconnection_request" from="GraphEdit" to="GraphEdit" method="_on_disconnection_request"]
86 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/LineEditDriverTest.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
 2 | 
 3 | using System;
 4 | using Chickensoft.GoDotTest;
 5 | using Godot;
 6 | using GodotTestDriver.Drivers;
 7 | using Shouldly;
 8 | 
 9 | public class LineEditDriverTest : DriverTest
10 | {
11 |   private readonly LineEditDriver _lineEdit;
12 | 
13 |   public LineEditDriverTest(Node testScene) : base(testScene)
14 |   {
15 |     _lineEdit = new LineEditDriver(
16 |       () => RootNode.GetNode<LineEdit>("LineEdit")
17 |     );
18 |   }
19 | 
20 |   [Test]
21 |   public void TextChanges()
22 |   {
23 |     // WHEN
24 |     // i type "hello" into the line edit
25 |     _lineEdit.Type("hello");
26 |     // THEN
27 |     // the text changes
28 |     _lineEdit.Text.ShouldBe("hello");
29 |   }
30 | 
31 |   [Test]
32 |   public void SubmittingTextSendsSignal()
33 |   {
34 |     var awaiter = _lineEdit.GetSignalAwaiter(LineEdit.SignalName.TextSubmitted);
35 |     // WHEN
36 |     // i type "hello" into the line edit and press enter
37 |     _lineEdit.Submit("hello");
38 |     // THEN
39 |     // the text changes
40 |     _lineEdit.Text.ShouldBe("hello");
41 |     // and the text submitted signal is emitted
42 |     awaiter.IsCompleted.ShouldBeTrue();
43 |   }
44 | 
45 |   [Test]
46 |   public void DisabledLineEditCannotBeEdited()
47 |   {
48 |     // SETUP
49 |     _lineEdit.PresentRoot.Editable = false;
50 | 
51 |     // WHEN
52 |     // i try to type into the disabled line edit
53 |     // THEN
54 |     // an exception is thrown
55 |     Should.Throw<InvalidOperationException>(() => _lineEdit.Type("hello"));
56 |   }
57 | 
58 |   [Test]
59 |   public void DisabledLineEditCannotBeSubmitted()
60 |   {
61 |     // SETUP
62 |     _lineEdit.PresentRoot.Editable = false;
63 | 
64 |     // WHEN
65 |     // i try to submit text into the disabled line edit
66 |     // THEN
67 |     // an exception is thrown
68 |     Should.Throw<InvalidOperationException>(() => _lineEdit.Submit("hello"));
69 |   }
70 | 
71 |   [Test]
72 |   public void InvisibleLineEditCannotBeEdited()
73 |   {
74 |     // SETUP
75 |     _lineEdit.PresentRoot.Visible = false;
76 | 
77 |     // WHEN
78 |     // i try to type into the invisible line edit
79 |     // THEN
80 |     // an exception is thrown
81 |     Should.Throw<InvalidOperationException>(() => _lineEdit.Type("hello"));
82 |   }
83 | 
84 |   [Test]
85 |   public void InvisibleLineEditCannotBeSubmitted()
86 |   {
87 |     // SETUP
88 |     _lineEdit.PresentRoot.Visible = false;
89 | 
90 |     // WHEN
91 |     // i try to submit text into the invisible line edit
92 |     // THEN
93 |     // an exception is thrown
94 |     Should.Throw<InvalidOperationException>(() => _lineEdit.Submit("hello"));
95 |   }
96 | }
97 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/LineEditDriver.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Drivers;
 2 | 
 3 | using System;
 4 | using Godot;
 5 | 
 6 | /// <summary>
 7 | /// Driver for the <see cref="LineEdit"/> control.
 8 | /// </summary>
 9 | /// <typeparam name="T">LineEdit type.</typeparam>
10 | public class LineEditDriver<T> : ControlDriver<T> where T : LineEdit
11 | {
12 |   /// <summary>
13 |   /// Creates a new generic LineEditDriver.
14 |   /// </summary>
15 |   /// <param name="producer">Producer that creates a LineEdit subclass.</param>
16 |   /// <param name="description">Driver description.</param>
17 |   public LineEditDriver(Func<T> producer, string description = "")
18 |     : base(producer, description)
19 |   {
20 |   }
21 | 
22 |   /// <summary>
23 |   /// The current text of the line edit.
24 |   /// </summary>
25 |   public string Text => PresentRoot.Text;
26 | 
27 |   /// <summary>
28 |   /// Whether the line edit is currently editable.
29 |   /// </summary>
30 |   public bool Editable => PresentRoot.Editable;
31 | 
32 |   /// <summary>
33 |   /// Types the given text into the line edit. Existing text will be overwritten.
34 |   /// </summary>
35 |   /// <param name="text">Text contents.</param>
36 |   /// <exception cref="InvalidOperationException"/>
37 |   public void Type(string text)
38 |   {
39 |     if (!Editable)
40 |     {
41 |       throw new InvalidOperationException(
42 |         ErrorMessage("Cannot type text into LineEdit because it is not editable.")
43 |       );
44 |     }
45 | 
46 |     var edit = VisibleRoot;
47 |     ClickCenter();
48 |     edit.Text = text;
49 |     edit.EmitSignal(LineEdit.SignalName.TextChanged, text);
50 |   }
51 | 
52 |   /// <summary>
53 |   /// Types the given text into the line edit. Existing text will be
54 |   /// overwritten. Presses "enter" afterwards.
55 |   /// </summary>
56 |   /// <param name="text">Text contents.</param>
57 |   /// <exception cref="InvalidOperationException"/>
58 |   public void Submit(string text)
59 |   {
60 |     if (!Editable)
61 |     {
62 |       throw new InvalidOperationException(
63 |         ErrorMessage("Cannot type text into LineEdit because it is not editable.")
64 |       );
65 |     }
66 | 
67 |     var edit = VisibleRoot;
68 |     // first type the text, so the text change events are triggered
69 |     Type(text);
70 |     // then send the "TextSubmitted" event
71 |     edit.EmitSignal(LineEdit.SignalName.TextSubmitted, text);
72 |   }
73 | }
74 | 
75 | /// <summary>
76 | /// Driver for the <see cref="LineEdit"/> control.
77 | /// </summary>
78 | public sealed class LineEditDriver : LineEditDriver<LineEdit>
79 | {
80 |   /// <summary>
81 |   /// Creates a new LineEditDriver.
82 |   /// </summary>
83 |   /// <param name="producer">Producer that creates a LineEdit subclass.</param>
84 |   /// <param name="description">Driver description.</param>
85 |   public LineEditDriver(Func<LineEdit> producer, string description = "")
86 |     : base(producer, description)
87 |   {
88 |   }
89 | }
90 | 


--------------------------------------------------------------------------------
/.github/workflows/auto_release.yaml:
--------------------------------------------------------------------------------
 1 | # This workflow will run whenever tests finish running. If tests pass, it will
 2 | # look at the last commit message to see if it contains the phrase
 3 | # "chore(deps): update all dependencies".
 4 | #
 5 | # If it finds a commit with that phrase, and the testing workflow has passed,
 6 | # it will automatically release a new version of the project by running the
 7 | # publish workflow.
 8 | #
 9 | # The commit message phrase above is always used by renovatebot when opening
10 | # PR's to update dependencies. If you have renovatebot enabled and set to
11 | # automatically merge in dependency updates, this can automatically release and
12 | # publish the updated version of the project.
13 | #
14 | # You can disable this action by setting the DISABLE_AUTO_RELEASE repository
15 | # variable to true.
16 | 
17 | name: '🦾 Auto-Release'
18 | on:
19 |   workflow_run:
20 |     workflows: ["🖼 Visual Tests"]
21 |     branches:
22 |       - main
23 |     types:
24 |       - completed
25 | 
26 | jobs:
27 |   auto_release:
28 |     name: 🦾 Auto-Release
29 |     runs-on: ubuntu-latest
30 |     outputs:
31 |       should_release: ${{ steps.release.outputs.should_release }}
32 |     steps:
33 |       - name: 🧾 Checkout
34 |         uses: actions/checkout@v6
35 |         with:
36 |           lfs: true
37 |           submodules: 'recursive'
38 | 
39 |       - name: 🧑‍🔬 Check Test Results
40 |         id: tests
41 |         run: |
42 |           echo "passed=${{ github.event.workflow_run.conclusion == 'success' }}" >> "$GITHUB_OUTPUT"
43 | 
44 |       - name: 📄 Check If Dependencies Changed
45 |         id: deps
46 |         run: |
47 |           message=$(git log -1 --pretty=%B)
48 | 
49 |           if [[ $message == *"chore(deps)"* ]]; then
50 |             echo "changed=true" >> "$GITHUB_OUTPUT"
51 |           else
52 |             echo "changed=false" >> "$GITHUB_OUTPUT"
53 |           fi
54 | 
55 |       - name: 📝 Check Release Status
56 |         id: release
57 |         run: |
58 |           echo "Tests passed: ${{ steps.tests.outputs.passed }}"
59 |           echo "Dependencies changed: ${{ steps.deps.outputs.changed }}"
60 |           disable_auto_release='${{ vars.DISABLE_AUTO_RELEASE }}'
61 |           echo "DISABLE_AUTO_RELEASE=$disable_auto_release"
62 | 
63 |           if [[ ${{ steps.tests.outputs.passed }} == "true" && ${{ steps.deps.outputs.changed }} == "true" && $disable_auto_release != "true" ]]; then
64 |             echo "should_release=true" >> "$GITHUB_OUTPUT"
65 |             echo "🦾 Creating a release!"
66 |           else
67 |             echo "should_release=false" >> "$GITHUB_OUTPUT"
68 |             echo "✋ Not creating a release."
69 |           fi
70 | 
71 |   trigger_release:
72 |     uses: './.github/workflows/release.yaml'
73 |     needs: auto_release
74 |     if: needs.auto_release.outputs.should_release == 'true'
75 |     secrets:
76 |       NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
77 |       GH_BASIC: ${{ secrets.GH_BASIC }}
78 |     with:
79 |       bump: patch
80 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Util/InternalUtil.cs:
--------------------------------------------------------------------------------
 1 | namespace Chickensoft.GodotTestDriver.Util;
 2 | 
 3 | using Godot;
 4 | 
 5 | /// <summary>
 6 | /// Some useful extension methods. These are declared internal instead using GodotExt, so users can decide what
 7 | /// they want.
 8 | /// </summary>
 9 | internal static class InternalUtil
10 | {
11 |   /// <summary>
12 |   /// Returns the center of the given rect.
13 |   /// </summary>
14 |   /// <param name="rect2">Rectangle to compute the center of.</param>
15 |   public static Vector2 Center(this Rect2 rect2) =>
16 |   rect2.Position + (rect2.Size / 2);
17 | 
18 |   /// <summary>
19 |   /// Sleeps for the given amount of seconds.
20 |   /// </summary>
21 |   /// <param name="source">Node in the scene tree.</param>
22 |   /// <param name="sleepTime">Time to sleep, in seconds.</param>
23 |   public static SignalAwaiter SleepSeconds(this Node source, float sleepTime) =>
24 |     source.ToSignal(
25 |       source.GetTree().CreateTimer(sleepTime),
26 |       SceneTreeTimer.SignalName.Timeout
27 |     );
28 | 
29 |   /// <summary>
30 |   /// Converts the given rect to global coordinates.
31 |   /// </summary>
32 |   /// <param name="localRect">Local rectangle.</param>
33 |   /// <param name="globalPosition">Global position.</param>
34 |   public static Rect2 ToGlobalRect(
35 |     this Rect2 localRect,
36 |     Vector2 globalPosition
37 |   ) =>
38 |     new(globalPosition + localRect.Position, localRect.Size);
39 | 
40 |   /// <summary>
41 |   /// Converts the given world position to viewport screen coordinates.
42 |   /// </summary>
43 |   /// <param name="viewport">Viewport.</param>
44 |   /// <param name="worldPosition">World position.</param>
45 |   public static Vector2 WorldToScreen(
46 |     this Viewport viewport,
47 |     Vector2 worldPosition
48 |   ) =>
49 |     viewport.CanvasTransform * worldPosition;
50 | 
51 |   /// <summary>
52 |   /// Converts the given viewport screen coordinates to world position.
53 |   /// </summary>
54 |   /// <param name="viewport">Viewport.</param>
55 |   /// <param name="screenPosition">Screen position.</param>
56 |   public static Vector2 ScreenToWorld(
57 |     this Viewport viewport,
58 |     Vector2 screenPosition
59 |   ) =>
60 |     screenPosition * viewport.CanvasTransform;
61 | 
62 |   // same for Rect2
63 | 
64 |   /// <summary>
65 |   /// Converts the given world rect to viewport screen coordinates.
66 |   /// </summary>
67 |   /// <param name="viewport">Viewport.</param>
68 |   /// <param name="worldRect">Rectangle in world coordinates.</param>
69 |   public static Rect2 WorldToScreen(this Viewport viewport, Rect2 worldRect) =>
70 |     viewport.CanvasTransform * worldRect;
71 | 
72 |   /// <summary>
73 |   /// Converts the given viewport screen coordinates to world rect.
74 |   /// </summary>
75 |   /// <param name="viewport">Viewport.</param>
76 |   /// <param name="screenRect">Rectangle in screen coordinates.</param>
77 |   public static Rect2 ScreenToWorld(this Viewport viewport, Rect2 screenRect) =>
78 |     screenRect * viewport.CanvasTransform;
79 | }
80 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.31903.59
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Chickensoft.GodotTestDriver", "Chickensoft.GodotTestDriver\Chickensoft.GodotTestDriver.csproj", "{2C7FA81E-82F4-4583-841D-885B8E364C27}"
 7 | EndProject
 8 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Chickensoft.GodotTestDriver.Tests", "Chickensoft.GodotTestDriver.Tests\Chickensoft.GodotTestDriver.Tests.csproj", "{EA11D1A5-9108-4969-B16E-933A16719D63}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionProperties) = preSolution
12 | 		HideSolutionNode = FALSE
13 | 	EndGlobalSection
14 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
15 | 		Debug|Any CPU = Debug|Any CPU
16 | 		Debug|x64 = Debug|x64
17 | 		Debug|x86 = Debug|x86
18 | 		Release|Any CPU = Release|Any CPU
19 | 		Release|x64 = Release|x64
20 | 		Release|x86 = Release|x86
21 | 	EndGlobalSection
22 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
23 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
24 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|Any CPU.Build.0 = Debug|Any CPU
25 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|x64.ActiveCfg = Debug|Any CPU
26 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|x64.Build.0 = Debug|Any CPU
27 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|x86.ActiveCfg = Debug|Any CPU
28 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Debug|x86.Build.0 = Debug|Any CPU
29 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|Any CPU.ActiveCfg = Debug|Any CPU
30 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|Any CPU.Build.0 = Debug|Any CPU
31 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|x64.ActiveCfg = Debug|Any CPU
32 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|x64.Build.0 = Debug|Any CPU
33 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|x86.ActiveCfg = Debug|Any CPU
34 | 		{2C7FA81E-82F4-4583-841D-885B8E364C27}.Release|x86.Build.0 = Debug|Any CPU
35 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
36 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|Any CPU.Build.0 = Debug|Any CPU
37 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|x64.ActiveCfg = Debug|Any CPU
38 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|x64.Build.0 = Debug|Any CPU
39 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|x86.ActiveCfg = Debug|Any CPU
40 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Debug|x86.Build.0 = Debug|Any CPU
41 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|Any CPU.ActiveCfg = Debug|Any CPU
42 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|Any CPU.Build.0 = Debug|Any CPU
43 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|x64.ActiveCfg = Debug|Any CPU
44 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|x64.Build.0 = Debug|Any CPU
45 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|x86.ActiveCfg = Debug|Any CPU
46 | 		{EA11D1A5-9108-4969-B16E-933A16719D63}.Release|x86.Build.0 = Debug|Any CPU
47 | 	EndGlobalSection
48 | EndGlobal
49 | 


--------------------------------------------------------------------------------
/.github/workflows/visual_tests.yaml:
--------------------------------------------------------------------------------
 1 | name: 🖼 Visual Tests
 2 | on:
 3 |   push:
 4 |   pull_request:
 5 | 
 6 | jobs:
 7 |   tests:
 8 |     name: 🖼 Visual Tests with ${{ matrix.render-driver }}
 9 |     runs-on: ubuntu-latest
10 |     # Only run the workflow if it's not a PR or if it's a PR from a fork.
11 |     # This prevents duplicate workflows from running on PR's that originate
12 |     # from the repository itself.
13 |     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
14 |     env:
15 |       DOTNET_CLI_TELEMETRY_OPTOUT: true
16 |       DOTNET_NOLOGO: true
17 |     strategy:
18 |       # Don't cancel other runners if one fails.
19 |       fail-fast: false
20 |       matrix:
21 |         # Put the operating systems you want to run on here.
22 |         render-driver: [vulkan]
23 |     defaults:
24 |       run:
25 |         shell: bash
26 |     steps:
27 |       - name: 🧾 Checkout
28 |         uses: actions/checkout@v6
29 |         with:
30 |           lfs: true
31 |           submodules: 'recursive'
32 | 
33 |       - name: 💽 Setup .NET SDK
34 |         uses: actions/setup-dotnet@v5
35 |         with:
36 |           # Use the .NET SDK from global.json in the root of the repository.
37 |           global-json-file: global.json
38 | 
39 |       - name: 📦 Restore Dependencies
40 |         run: dotnet restore
41 | 
42 |       - name: 💾 Add Graphics Driver Emulators Source
43 |         run: |
44 |           sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
45 |           sudo add-apt-repository -n ppa:kisak/kisak-mesa
46 | 
47 |       - name: 💾 Install Graphics Driver Emulators
48 |         uses: awalsh128/cache-apt-pkgs-action@latest
49 |         with:
50 |           packages: mesa-vulkan-drivers binutils
51 |           version: 1.0
52 | 
53 |       - name: 🤖 Setup Godot
54 |         uses: chickensoft-games/setup-godot@v2
55 |         with:
56 |           # Version must include major, minor, and patch, and be >= 4.0.0
57 |           # Pre-release label is optional.
58 |           #
59 |           # In this case, we are using the version from global.json.
60 |           #
61 |           # This allows checks on renovatebot PR's to succeed whenever
62 |           # renovatebot updates the Godot SDK version.
63 |           version: global.json
64 | 
65 |       - name: 🧑‍🔬 Generate .NET Bindings
66 |         working-directory: Chickensoft.GodotTestDriver.Tests
67 |         run: godot --headless --build-solutions --quit || exit 0
68 | 
69 |       - name: 🌋 Run Tests in Godot
70 |         working-directory: Chickensoft.GodotTestDriver.Tests
71 |         run: |
72 |           xvfb-run godot --audio-driver Dummy --rendering-driver ${{ matrix.render-driver }} --run-tests --quit-on-finish --coverage
73 |           echo "Finished running tests in Godot with emulated ${{ matrix.render-driver }} graphics."
74 | 
75 |           # The --coverage flag is used by GoDotTest to control the exit code
76 |           # of Godot by force-exiting through C#.
77 |           #
78 |           # Since Godot tends to exit with non-zero exit codes (even on success)
79 |           # this flag allows GoDotTest to ensure that this step will only fail
80 |           # when the tests fail.
81 | 
82 |           echo "Finished running tests in Godot with emulated ${{ matrix.render-driver }} graphics."
83 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/Camera2DDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Threading.Tasks;
  5 | using Godot;
  6 | using GodotTestDriver.Util;
  7 | 
  8 | /// <summary>
  9 | /// Driver for the Camera2D node.
 10 | /// </summary>
 11 | /// <typeparam name="T">Camera2D type.</typeparam>
 12 | public class Camera2DDriver<T> : Node2DDriver<T> where T : Camera2D
 13 | {
 14 |   /// <summary>
 15 |   /// Creates a new generic Camera2DDriver.
 16 |   /// </summary>
 17 |   /// <param name="producer">Producer that creates a Camera2D subclass.</param>
 18 |   /// <param name="description">Driver description.</param>
 19 |   public Camera2DDriver(Func<T> producer, string description = "")
 20 |     : base(producer, description)
 21 |   {
 22 |   }
 23 | 
 24 |   /// <summary>
 25 |   /// Starts moving the given position into the view of the camera. This does
 26 |   /// NOT wait for the camera to finish moving.
 27 |   /// </summary>
 28 |   /// <param name="worldPosition">World position to move into view.</param>
 29 |   /// <seealso cref="MoveIntoView(Vector2, float)"/>
 30 |   /// <seealso cref="WaitUntilSteady(float)"/>
 31 |   public void StartMoveIntoView(Vector2 worldPosition) =>
 32 |     PresentRoot.GlobalPosition = worldPosition;
 33 | 
 34 |   /// <summary>
 35 |   /// Moves the given position into the view of the camera. This will wait for
 36 |   /// the given amount of seconds until the camera no longer moves.
 37 |   /// </summary>
 38 |   /// <param name="worldPosition">World position.</param>
 39 |   /// <param name="timeoutSeconds">Timeout, in seconds.</param>
 40 |   public async Task<bool> MoveIntoView(
 41 |     Vector2 worldPosition,
 42 |     float timeoutSeconds
 43 |   )
 44 |   {
 45 |     StartMoveIntoView(worldPosition);
 46 |     return await WaitUntilSteady(timeoutSeconds);
 47 |   }
 48 | 
 49 |   /// <summary>
 50 |   /// Waits until the camera steady (e.g. not moving for three frames).
 51 |   /// </summary>
 52 |   /// <param name="timeoutSeconds">Timeout, in seconds.</param>
 53 |   public async Task<bool> WaitUntilSteady(float timeoutSeconds)
 54 |   {
 55 |     var timeout = new Timeout(timeoutSeconds);
 56 |     var screenPos = PresentRoot.GetScreenCenterPosition();
 57 |     // we treat the camera as steady when it hasn't moved over 3 frames.
 58 |     var frameCount = 0;
 59 | 
 60 |     do
 61 |     {
 62 |       var newScreenPos = PresentRoot.GetScreenCenterPosition();
 63 |       if ((newScreenPos - screenPos).LengthSquared() < 0.001)
 64 |       {
 65 |         frameCount++;
 66 |       }
 67 |       else
 68 |       {
 69 |         frameCount = 0;
 70 |       }
 71 | 
 72 |       if (frameCount >= 3)
 73 |       {
 74 |         return true;
 75 |       }
 76 | 
 77 |       screenPos = newScreenPos;
 78 |       await PresentRoot.GetTree().NextFrame();
 79 |     } while (!timeout.IsReached);
 80 | 
 81 |     return false;
 82 |   }
 83 | }
 84 | 
 85 | /// <summary>
 86 | /// Driver for the Camera2D node.
 87 | /// </summary>
 88 | public sealed class Camera2DDriver : Camera2DDriver<Camera2D>
 89 | {
 90 |   /// <summary>
 91 |   /// Creates a new Camera2DDriver.
 92 |   /// </summary>
 93 |   /// <param name="producer">Producer that creates a Camera2D subclass.</param>
 94 |   /// <param name="description">Driver description.</param>
 95 |   public Camera2DDriver(Func<Camera2D> producer, string description = "")
 96 |     : base(producer, description)
 97 |   {
 98 |   }
 99 | }
100 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/OptionButtonDriverTest.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
  2 | 
  3 | using System;
  4 | using System.Linq;
  5 | using Chickensoft.GoDotTest;
  6 | using Godot;
  7 | using GodotTestDriver.Drivers;
  8 | using Shouldly;
  9 | 
 10 | public class OptionButtonDriverTest : DriverTest
 11 | {
 12 |   private readonly OptionButtonDriver _optionButton;
 13 | 
 14 |   public OptionButtonDriverTest(Node testScene) : base(testScene)
 15 |   {
 16 |     _optionButton = new OptionButtonDriver(
 17 |       () => RootNode.GetNode<OptionButton>("OptionButton")
 18 |     );
 19 |   }
 20 | 
 21 |   [Test]
 22 |   public void InspectionWorks()
 23 |   {
 24 |     // WHEN
 25 |     // everything is set up
 26 | 
 27 |     // THEN
 28 |     // we should have two selectable items
 29 |     _optionButton.SelectableItems.Count().ShouldBe(2);
 30 | 
 31 |     // named "Normal Item 1" and "Normal Item 2"
 32 |     _optionButton.SelectableItems.First().ShouldBe("Normal Item 1");
 33 |     _optionButton.SelectableItems.Last().ShouldBe("Normal Item 2");
 34 |   }
 35 | 
 36 |   [Test]
 37 |   public void SelectingAnItemWorks()
 38 |   {
 39 |     // WHEN
 40 |     // we select the first item
 41 |     var signalAwaiter = _optionButton.GetSignalAwaiter(
 42 |       OptionButton.SignalName.ItemSelected
 43 |     );
 44 |     _optionButton.SelectItemWithText("Normal Item 1");
 45 | 
 46 |     // THEN
 47 |     // the first item is selected
 48 |     _optionButton.SelectedItem.ShouldBe("Normal Item 1");
 49 | 
 50 |     // and the signal is emitted
 51 |     signalAwaiter.IsCompleted.ShouldBeTrue();
 52 |   }
 53 | 
 54 |   [Test]
 55 |   public void SelectingANonExistingItemThrowsException()
 56 |   {
 57 |     // WHEN
 58 |     // we select a non-existing item
 59 |     var signalAwaiter = _optionButton.GetSignalAwaiter(
 60 |       OptionButton.SignalName.ItemSelected
 61 |     );
 62 |     var exception = Should.Throw<Exception>(
 63 |       () => _optionButton.SelectItemWithText("Non-existing Item")
 64 |     );
 65 | 
 66 |     // THEN
 67 |     // the exception is thrown
 68 |     exception.Message.ShouldContain("does not contain");
 69 | 
 70 |     // and the signal is not emitted
 71 |     signalAwaiter.IsCompleted.ShouldBeFalse();
 72 |   }
 73 | 
 74 |   [Test]
 75 |   public void SelectingADisabledItemThrowsException()
 76 |   {
 77 |     // WHEN
 78 |     // we select a disabled item
 79 |     var signalAwaiter = _optionButton.GetSignalAwaiter(
 80 |       OptionButton.SignalName.ItemSelected
 81 |     );
 82 |     var exception = Should.Throw<Exception>(
 83 |       () => _optionButton.SelectItemWithText("Disabled Item")
 84 |     );
 85 | 
 86 |     // THEN
 87 |     // the exception is thrown
 88 |     exception.Message.ShouldContain("is not selectable");
 89 | 
 90 |     // and the signal is not emitted
 91 |     signalAwaiter.IsCompleted.ShouldBeFalse();
 92 |   }
 93 | 
 94 |   [Test]
 95 |   public void SelectingASeparatorThrowsException()
 96 |   {
 97 |     // WHEN
 98 |     // we select a separator
 99 |     var signalAwaiter = _optionButton.GetSignalAwaiter(
100 |       OptionButton.SignalName.ItemSelected
101 |     );
102 |     var exception = Should.Throw<Exception>(
103 |       () => _optionButton.SelectItemWithText("Separator")
104 |     );
105 | 
106 |     // THEN
107 |     // the exception is thrown
108 |     exception.Message.ShouldContain("is not selectable");
109 | 
110 |     // and the signal is not emitted
111 |     signalAwaiter.IsCompleted.ShouldBeFalse();
112 |   }
113 | }
114 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yaml:
--------------------------------------------------------------------------------
  1 | name: '📦 Release'
  2 | on:
  3 |   # Make a release whenever the developer wants.
  4 |   workflow_dispatch:
  5 |     inputs:
  6 |       bump:
  7 |         type: string
  8 |         description: "major, minor, or patch"
  9 |         required: true
 10 |         default: "patch"
 11 |   # Make a release whenever we're told to by another workflow.
 12 |   workflow_call:
 13 |     secrets:
 14 |       NUGET_API_KEY:
 15 |         description: "API key for Nuget"
 16 |         required: true
 17 |       GH_BASIC:
 18 |         description: "Personal access token (PAT) for GitHub"
 19 |         required: true
 20 |     # Input unifies with the workflow dispatch since it's identical.
 21 |     inputs:
 22 |       bump:
 23 |         type: string
 24 |         description: "major, minor, or patch"
 25 |         required: true
 26 |         default: "patch"
 27 | jobs:
 28 |   release:
 29 |     name: '📦 Release'
 30 |     runs-on: ubuntu-latest
 31 |     if: github.repository == 'chickensoft-games/GodotTestDriver'
 32 |     env:
 33 |       DOTNET_CLI_TELEMETRY_OPTOUT: true
 34 |       DOTNET_NOLOGO: true
 35 |     steps:
 36 |       - name: 🧾 Checkout
 37 |         uses: actions/checkout@v6
 38 |         with:
 39 |           lfs: true
 40 |           submodules: 'recursive'
 41 |           fetch-depth: 0 # So we can get all tags.
 42 | 
 43 |       - name: 🔎 Read Current Project Version
 44 |         id: current-version
 45 |         uses: WyriHaximus/github-action-get-previous-tag@v1
 46 |         with:
 47 |           fallback: "0.0.0-devbuild"
 48 | 
 49 |       - name: 🖨 Print Current Version
 50 |         run: |
 51 |           echo "Current Version: ${{ steps.current-version.outputs.tag }}"
 52 | 
 53 |       - name: 🧮 Compute Next Version
 54 |         uses: chickensoft-games/next-godot-csproj-version@v1
 55 |         id: next-version
 56 |         with:
 57 |           project-version: ${{ steps.current-version.outputs.tag }}
 58 |           godot-version: global.json
 59 |           bump: ${{ inputs.bump }}
 60 | 
 61 |       - uses: actions/setup-dotnet@v5
 62 |         name: 💽 Setup .NET SDK
 63 |         with:
 64 |           # Use the .NET SDK from global.json in the root of the repository.
 65 |           global-json-file: global.json
 66 | 
 67 |       # Write version to file so .NET will build correct version.
 68 |       - name: 📝 Write Version to File
 69 |         uses: jacobtomlinson/gha-find-replace@v3
 70 |         with:
 71 |           find: "0.0.0-devbuild"
 72 |           replace: ${{ steps.next-version.outputs.version }}
 73 |           regex: false
 74 |           include: Chickensoft.GodotTestDriver/Chickensoft.GodotTestDriver.csproj
 75 | 
 76 |       - name: 📦 Build
 77 |         working-directory: Chickensoft.GodotTestDriver
 78 |         run: dotnet build -c Release
 79 | 
 80 |       - name: 🔎 Get Package Path
 81 |         id: package-path
 82 |         run: |
 83 |           package=$(find ./Chickensoft.GodotTestDriver/nupkg -name "*.nupkg")
 84 |           echo "package=$package" >> "$GITHUB_OUTPUT"
 85 |           echo "📦 Found package: $package"
 86 | 
 87 |       - name: ✨ Create Release
 88 |         env:
 89 |           GITHUB_TOKEN: ${{ secrets.GH_BASIC }}
 90 |         run: |
 91 |           version="${{ steps.next-version.outputs.version }}"
 92 |           gh release create --title "v$version" --generate-notes "$version" \
 93 |             "${{ steps.package-path.outputs.package }}"
 94 | 
 95 |       - name: 🛜 Publish to Nuget
 96 |         run: |
 97 |           dotnet nuget push "${{ steps.package-path.outputs.package }}" \
 98 |             --api-key "${{ secrets.NUGET_API_KEY }}" \
 99 |             --source "https://api.nuget.org/v3/index.json" --skip-duplicate
100 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ActionsInputExtensionsTest.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Tests.Input;
  2 | 
  3 | using Chickensoft.GoDotTest;
  4 | using Godot;
  5 | using GodotTestDriver.Input;
  6 | using Shouldly;
  7 | 
  8 | public partial class ActionsInputExtensionsTest : InputTest
  9 | {
 10 |   private sealed partial class ActionInputEventTestNode : Node
 11 |   {
 12 |     public bool HasInputEventFired { get; set; }
 13 |     public bool WasInputPressed { get; set; }
 14 |     public StringName InputEventName { get; set; } = string.Empty;
 15 | 
 16 |     public override void _Input(InputEvent @event)
 17 |     {
 18 |       if (@event.IsAction(InputEventName))
 19 |       {
 20 |         HasInputEventFired = true;
 21 |         WasInputPressed = @event.IsActionPressed(InputEventName);
 22 |       }
 23 |     }
 24 |   }
 25 | 
 26 |   private const string TEST_ACTION = "test_action";
 27 | 
 28 |   public ActionsInputExtensionsTest(Node testScene) : base(testScene)
 29 |   {
 30 |   }
 31 | 
 32 |   [Test]
 33 |   public void StartActionSetsGlobalActionPressed()
 34 |   {
 35 |     Input.IsActionPressed(TEST_ACTION).ShouldBeFalse();
 36 |     RootNode.StartAction(TEST_ACTION);
 37 |     Input.IsActionPressed(TEST_ACTION).ShouldBeTrue();
 38 |     RootNode.EndAction(TEST_ACTION);
 39 |   }
 40 | 
 41 |   [Test]
 42 |   public void StartActionClampsStrengthBetweenZeroAndOne()
 43 |   {
 44 |     RootNode.StartAction(TEST_ACTION, -1);
 45 |     Input.GetActionStrength(TEST_ACTION).ShouldBe(0);
 46 |     RootNode.EndAction(TEST_ACTION);
 47 |     RootNode.StartAction(TEST_ACTION, 2);
 48 |     Input.GetActionStrength(TEST_ACTION).ShouldBe(1);
 49 |     RootNode.EndAction(TEST_ACTION);
 50 |   }
 51 | 
 52 |   [Test]
 53 |   public void EndActionRemovesGlobalActionPressed()
 54 |   {
 55 |     RootNode.StartAction(TEST_ACTION);
 56 |     RootNode.EndAction(TEST_ACTION);
 57 |     Input.IsActionPressed(TEST_ACTION).ShouldBeFalse();
 58 |   }
 59 | 
 60 |   [Test]
 61 |   public void StartActionSetsGlobalActionJustPressed()
 62 |   {
 63 |     RootNode.StartAction(TEST_ACTION);
 64 |     Input.IsActionJustPressed(TEST_ACTION).ShouldBeTrue();
 65 |     RootNode.EndAction(TEST_ACTION);
 66 |   }
 67 | 
 68 |   [Test]
 69 |   public void EndActionSetsGlobalActionJustReleased()
 70 |   {
 71 |     RootNode.StartAction(TEST_ACTION);
 72 |     RootNode.EndAction(TEST_ACTION);
 73 |     Input.IsActionJustReleased(TEST_ACTION).ShouldBeTrue();
 74 |   }
 75 | 
 76 |   [Test]
 77 |   public void StartActionSendsInputEvent()
 78 |   {
 79 |     var inputTestNode = new ActionInputEventTestNode
 80 |     {
 81 |       InputEventName = TEST_ACTION
 82 |     };
 83 |     RootNode.AddChild(inputTestNode);
 84 |     inputTestNode.HasInputEventFired.ShouldBeFalse();
 85 |     inputTestNode.StartAction(TEST_ACTION);
 86 |     inputTestNode.HasInputEventFired.ShouldBeTrue();
 87 |     inputTestNode.WasInputPressed.ShouldBeTrue();
 88 |     inputTestNode.EndAction(TEST_ACTION);
 89 |     // Remove immediately since we won't wait a frame for the free
 90 |     RootNode.RemoveChild(inputTestNode);
 91 |     inputTestNode.QueueFree();
 92 |   }
 93 | 
 94 |   [Test]
 95 |   public void EndActionSendsInputEvent()
 96 |   {
 97 |     var inputTestNode = new ActionInputEventTestNode
 98 |     {
 99 |       InputEventName = TEST_ACTION
100 |     };
101 |     RootNode.AddChild(inputTestNode);
102 |     inputTestNode.HasInputEventFired.ShouldBeFalse();
103 |     inputTestNode.EndAction(TEST_ACTION);
104 |     inputTestNode.HasInputEventFired.ShouldBeTrue();
105 |     inputTestNode.WasInputPressed.ShouldBeFalse();
106 |     // Remove immediately since we won't wait a frame for the free
107 |     RootNode.RemoveChild(inputTestNode);
108 |     inputTestNode.QueueFree();
109 |   }
110 | }
111 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/icon.svg:
--------------------------------------------------------------------------------
1 | <svg height="128" width="128" xmlns="http://www.w3.org/2000/svg"><g transform="translate(32 32)"><path d="m-16-32c-8.86 0-16 7.13-16 15.99v95.98c0 8.86 7.13 15.99 16 15.99h96c8.86 0 16-7.13 16-15.99v-95.98c0-8.85-7.14-15.99-16-15.99z" fill="#363d52"/><path d="m-16-32c-8.86 0-16 7.13-16 15.99v95.98c0 8.86 7.13 15.99 16 15.99h96c8.86 0 16-7.13 16-15.99v-95.98c0-8.85-7.14-15.99-16-15.99zm0 4h96c6.64 0 12 5.35 12 11.99v95.98c0 6.64-5.35 11.99-12 11.99h-96c-6.64 0-12-5.35-12-11.99v-95.98c0-6.64 5.36-11.99 12-11.99z" fill-opacity=".4"/></g><g stroke-width="9.92746" transform="matrix(.10073078 0 0 .10073078 12.425923 2.256365)"><path d="m0 0s-.325 1.994-.515 1.976l-36.182-3.491c-2.879-.278-5.115-2.574-5.317-5.459l-.994-14.247-27.992-1.997-1.904 12.912c-.424 2.872-2.932 5.037-5.835 5.037h-38.188c-2.902 0-5.41-2.165-5.834-5.037l-1.905-12.912-27.992 1.997-.994 14.247c-.202 2.886-2.438 5.182-5.317 5.46l-36.2 3.49c-.187.018-.324-1.978-.511-1.978l-.049-7.83 30.658-4.944 1.004-14.374c.203-2.91 2.551-5.263 5.463-5.472l38.551-2.75c.146-.01.29-.016.434-.016 2.897 0 5.401 2.166 5.825 5.038l1.959 13.286h28.005l1.959-13.286c.423-2.871 2.93-5.037 5.831-5.037.142 0 .284.005.423.015l38.556 2.75c2.911.209 5.26 2.562 5.463 5.472l1.003 14.374 30.645 4.966z" fill="#fff" transform="matrix(4.162611 0 0 -4.162611 919.24059 771.67186)"/><path d="m0 0v-47.514-6.035-5.492c.108-.001.216-.005.323-.015l36.196-3.49c1.896-.183 3.382-1.709 3.514-3.609l1.116-15.978 31.574-2.253 2.175 14.747c.282 1.912 1.922 3.329 3.856 3.329h38.188c1.933 0 3.573-1.417 3.855-3.329l2.175-14.747 31.575 2.253 1.115 15.978c.133 1.9 1.618 3.425 3.514 3.609l36.182 3.49c.107.01.214.014.322.015v4.711l.015.005v54.325c5.09692 6.4164715 9.92323 13.494208 13.621 19.449-5.651 9.62-12.575 18.217-19.976 26.182-6.864-3.455-13.531-7.369-19.828-11.534-3.151 3.132-6.7 5.694-10.186 8.372-3.425 2.751-7.285 4.768-10.946 7.118 1.09 8.117 1.629 16.108 1.846 24.448-9.446 4.754-19.519 7.906-29.708 10.17-4.068-6.837-7.788-14.241-11.028-21.479-3.842.642-7.702.88-11.567.926v.006c-.027 0-.052-.006-.075-.006-.024 0-.049.006-.073.006v-.006c-3.872-.046-7.729-.284-11.572-.926-3.238 7.238-6.956 14.642-11.03 21.479-10.184-2.264-20.258-5.416-29.703-10.17.216-8.34.755-16.331 1.848-24.448-3.668-2.35-7.523-4.367-10.949-7.118-3.481-2.678-7.036-5.24-10.188-8.372-6.297 4.165-12.962 8.079-19.828 11.534-7.401-7.965-14.321-16.562-19.974-26.182 4.4426579-6.973692 9.2079702-13.9828876 13.621-19.449z" fill="#478cbf" transform="matrix(4.162611 0 0 -4.162611 104.69892 525.90697)"/><path d="m0 0-1.121-16.063c-.135-1.936-1.675-3.477-3.611-3.616l-38.555-2.751c-.094-.007-.188-.01-.281-.01-1.916 0-3.569 1.406-3.852 3.33l-2.211 14.994h-31.459l-2.211-14.994c-.297-2.018-2.101-3.469-4.133-3.32l-38.555 2.751c-1.936.139-3.476 1.68-3.611 3.616l-1.121 16.063-32.547 3.138c.015-3.498.06-7.33.06-8.093 0-34.374 43.605-50.896 97.781-51.086h.066.067c54.176.19 97.766 16.712 97.766 51.086 0 .777.047 4.593.063 8.093z" fill="#478cbf" transform="matrix(4.162611 0 0 -4.162611 784.07144 817.24284)"/><path d="m0 0c0-12.052-9.765-21.815-21.813-21.815-12.042 0-21.81 9.763-21.81 21.815 0 12.044 9.768 21.802 21.81 21.802 12.048 0 21.813-9.758 21.813-21.802" fill="#fff" transform="matrix(4.162611 0 0 -4.162611 389.21484 625.67104)"/><path d="m0 0c0-7.994-6.479-14.473-14.479-14.473-7.996 0-14.479 6.479-14.479 14.473s6.483 14.479 14.479 14.479c8 0 14.479-6.485 14.479-14.479" fill="#414042" transform="matrix(4.162611 0 0 -4.162611 367.36686 631.05679)"/><path d="m0 0c-3.878 0-7.021 2.858-7.021 6.381v20.081c0 3.52 3.143 6.381 7.021 6.381s7.028-2.861 7.028-6.381v-20.081c0-3.523-3.15-6.381-7.028-6.381" fill="#fff" transform="matrix(4.162611 0 0 -4.162611 511.99336 724.73954)"/><path d="m0 0c0-12.052 9.765-21.815 21.815-21.815 12.041 0 21.808 9.763 21.808 21.815 0 12.044-9.767 21.802-21.808 21.802-12.05 0-21.815-9.758-21.815-21.802" fill="#fff" transform="matrix(4.162611 0 0 -4.162611 634.78706 625.67104)"/><path d="m0 0c0-7.994 6.477-14.473 14.471-14.473 8.002 0 14.479 6.479 14.479 14.473s-6.477 14.479-14.479 14.479c-7.994 0-14.471-6.485-14.471-14.479" fill="#414042" transform="matrix(4.162611 0 0 -4.162611 656.64056 631.05679)"/></g></svg>
2 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/WindowDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using Godot;
  5 | using GodotTestDriver.Input;
  6 | 
  7 | /// <summary>
  8 | /// A driver for UI Windows.
  9 | /// </summary>
 10 | /// <typeparam name="T">Window type.</typeparam>
 11 | public class WindowDriver<T> : NodeDriver<T> where T : Window
 12 | {
 13 |   /// <summary>
 14 |   /// Creates a new generic WindowDriver.
 15 |   /// </summary>
 16 |   /// <param name="producer">Producer that creates a Window subclass.</param>
 17 |   /// <param name="description">Driver description.</param>
 18 |   public WindowDriver(Func<T> producer, string description = "")
 19 |     : base(producer, description)
 20 |   {
 21 |   }
 22 | 
 23 |   /// <summary>
 24 |   /// Is the window currently visible?
 25 |   /// </summary>
 26 |   public bool IsVisible => PresentRoot.Visible;
 27 | 
 28 |   /// <summary>
 29 |   /// The viewport that this window item is rendering to.
 30 |   /// </summary>
 31 |   public Viewport Viewport => PresentRoot.GetViewport();
 32 | 
 33 |   /// <summary>
 34 |   /// The position of the window in pixels.
 35 |   /// </summary>
 36 |   public Vector2I Position => PresentRoot.Position;
 37 | 
 38 |   /// <summary>
 39 |   /// Returns the root node but ensures it is visible.
 40 |   /// </summary>
 41 |   /// <exception cref="InvalidOperationException"/>
 42 |   protected T VisibleRoot
 43 |   {
 44 |     get
 45 |     {
 46 |       var root = PresentRoot;
 47 |       if (!root.Visible)
 48 |       {
 49 |         throw new InvalidOperationException(
 50 |           ErrorMessage("Cannot interact with window because it is not visible.")
 51 |         );
 52 |       }
 53 |       return root;
 54 |     }
 55 |   }
 56 | 
 57 |   /// <summary>
 58 |   /// Closes the window.
 59 |   /// </summary>
 60 |   public void Close()
 61 |   {
 62 |     var window = VisibleRoot;
 63 |     window.EmitSignal(Window.SignalName.CloseRequested);
 64 |   }
 65 | 
 66 |   /// <summary>
 67 |   /// Drags the window by the given offset.
 68 |   /// </summary>
 69 |   /// <param name="x">Horizontal cartesian coordinate component.</param>
 70 |   /// <param name="y">Vertical cartesian coordinate component.</param>
 71 |   public void DragByPixels(int x, int y) => DragByPixels(new Vector2I(x, y));
 72 | 
 73 |   /// <summary>
 74 |   /// Drags the window by the given offset.
 75 |   /// </summary>
 76 |   /// <param name="offset">Offset vector.</param>
 77 |   /// <exception cref="InvalidOperationException"/>
 78 |   public void DragByPixels(Vector2I offset)
 79 |   {
 80 |     var window = VisibleRoot;
 81 | 
 82 |     // check that the window has a parent otherwise we can't drag it
 83 |     if (window.GetParent() == null)
 84 |     {
 85 |       throw new InvalidOperationException(
 86 |         ErrorMessage("Dragging of root windows is not supported.")
 87 |       );
 88 |     }
 89 | 
 90 |     var titleBarHeight = window.GetThemeConstant("title_height");
 91 | 
 92 |     // get position and width of window, then use the title bar height to get
 93 |     // the center of the title bar note that the title bar is ABOVE the window,
 94 |     // so we need to subtract the title bar height from the window's position to
 95 |     // get the top of the title bar
 96 |     var pos = window.Position;
 97 |     var width = window.Size.X;
 98 |     var startSpot = new Vector2(
 99 |       pos.X + (width / 2f),
100 |       pos.Y - (titleBarHeight / 2f)
101 |     );
102 |     var endSpot = startSpot + offset;
103 | 
104 |     window.GetParent().GetViewport().DragMouse(startSpot, endSpot);
105 |   }
106 | }
107 | 
108 | /// <summary>
109 | /// A driver for UI Windows.
110 | /// </summary>
111 | public class WindowDriver : WindowDriver<Window>
112 | {
113 |   /// <summary>
114 |   /// Creates a new WindowDriver.
115 |   /// </summary>
116 |   /// <param name="producer">Producer that creates a Window subclass.</param>
117 |   /// <param name="description">Driver description.</param>
118 |   public WindowDriver(Func<Window> producer, string description = "")
119 |     : base(producer, description)
120 |   {
121 |   }
122 | }
123 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/TabContainerDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using Godot;
  7 | 
  8 | /// <summary>
  9 | /// A driver for the <see cref="TabContainer"/> control.
 10 | /// </summary>
 11 | /// <typeparam name="T">TabContainer type.</typeparam>
 12 | public class TabContainerDriver<T> : ControlDriver<T> where T : TabContainer
 13 | {
 14 |   /// <summary>
 15 |   /// Creates a new generic TabContainerDriver.
 16 |   /// </summary>
 17 |   /// <param name="producer">
 18 |   /// Producer that creates a TabContainer subclass.
 19 |   /// </param>
 20 |   /// <param name="description">Driver description.</param>
 21 |   public TabContainerDriver(Func<T> producer, string description = "")
 22 |     : base(producer, description)
 23 |   {
 24 |   }
 25 | 
 26 |   /// <summary>
 27 |   /// The amount of tabs currently open in the tab control.
 28 |   /// </summary>
 29 |   public int TabCount => PresentRoot.GetTabCount();
 30 | 
 31 |   /// <summary>
 32 |   /// Returns the titles of the currently open tabs.
 33 |   /// </summary>
 34 |   public IEnumerable<string> TabTitles
 35 |   {
 36 |     get
 37 |     {
 38 |       for (var i = 0; i < PresentRoot.GetTabCount(); i++)
 39 |       {
 40 |         yield return PresentRoot.GetTabTitle(i);
 41 |       }
 42 |     }
 43 |   }
 44 | 
 45 |   /// <summary>
 46 |   /// Returns the tab index that is currently selected.
 47 |   /// </summary>
 48 |   public int SelectedTabIndex => PresentRoot.CurrentTab;
 49 | 
 50 |   /// <summary>
 51 |   /// Returns the title of the currently selected tab.
 52 |   /// </summary>
 53 |   public string SelectedTabTitle => PresentRoot.GetTabTitle(SelectedTabIndex);
 54 | 
 55 |   /// <summary>
 56 |   /// Selects the tab with the given index.
 57 |   /// </summary>
 58 |   /// <remarks>
 59 |   /// Note that Godot requires one additional frame to set visibility of
 60 |   /// contents.
 61 |   /// </remarks>
 62 |   /// <param name="index">Tab index.</param>
 63 |   /// <exception cref="ArgumentOutOfRangeException"/>
 64 |   public void SelectTabWithIndex(int index)
 65 |   {
 66 |     var tab = VisibleRoot;
 67 | 
 68 |     if (index < 0 || index >= tab.GetTabCount())
 69 |     {
 70 |       throw new ArgumentOutOfRangeException(nameof(index), index,
 71 |           "Index must be between 0 and the amount of tabs in the tab control.");
 72 |     }
 73 | 
 74 |     var previousTab = tab.CurrentTab;
 75 | 
 76 |     tab.CurrentTab = index;
 77 | 
 78 |     // emit the signals for the tab change
 79 |     tab.EmitSignal(TabContainer.SignalName.TabSelected, index);
 80 |     if (previousTab != index)
 81 |     {
 82 |       tab.EmitSignal(TabContainer.SignalName.TabChanged, index);
 83 |     }
 84 |   }
 85 | 
 86 |   /// <summary>
 87 |   /// Selects the tab with the given title
 88 |   /// </summary>
 89 |   /// <remarks>
 90 |   /// Note that Godot requires one additional frame to set visibility of
 91 |   /// contents.
 92 |   /// </remarks>
 93 |   /// <param name="title">Tab label.</param>
 94 |   /// <exception cref="ArgumentException"/>
 95 |   public void SelectTabWithTitle(string title)
 96 |   {
 97 |     var index = TabTitles.ToList().IndexOf(title);
 98 |     if (index < 0)
 99 |     {
100 |       throw new ArgumentException(
101 |         $"No tab with the title '{title}' was found.",
102 |         nameof(title)
103 |       );
104 |     }
105 | 
106 |     SelectTabWithIndex(index);
107 |   }
108 | }
109 | 
110 | /// <summary>
111 | /// A driver for the <see cref="TabContainer"/> control.
112 | /// </summary>
113 | public sealed class TabContainerDriver : TabContainerDriver<TabContainer>
114 | {
115 |   /// <summary>
116 |   /// Creates a new TabContainerDriver.
117 |   /// </summary>
118 |   /// <param name="producer">
119 |   /// Producer that creates a TabContainer subclass.
120 |   /// </param>
121 |   /// <param name="description">Driver description.</param>
122 |   public TabContainerDriver(
123 |     Func<TabContainer> producer, string description = ""
124 |   )
125 |     : base(producer, description)
126 |   {
127 |   }
128 | }
129 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/GraphEditDriverTest.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
  2 | 
  3 | using System.Linq;
  4 | using Chickensoft.GoDotTest;
  5 | using Godot;
  6 | using GodotTestDriver.Drivers;
  7 | using Shouldly;
  8 | 
  9 | public class GraphEditDriverTest : DriverTest
 10 | {
 11 |   private readonly GraphEditDriver _graphEdit;
 12 | 
 13 |   public GraphEditDriverTest(Node testScene) : base(testScene)
 14 |   {
 15 |     _graphEdit = new GraphEditDriver(() =>
 16 |       RootNode.GetNode<GraphEdit>("GraphEdit"));
 17 |   }
 18 | 
 19 |   [Test]
 20 |   public void InspectionWorks()
 21 |   {
 22 |     // WHEN
 23 |     // everything is set up
 24 | 
 25 |     // THEN
 26 |     // the graph edit has two nodes
 27 |     _graphEdit.Nodes.Count().ShouldBe(2);
 28 | 
 29 |     var firstNode = _graphEdit.Nodes.First();
 30 |     var secondNode = _graphEdit.Nodes.Last();
 31 | 
 32 |     // both nodes are fully in view
 33 |     firstNode.IsFullyInView.ShouldBeTrue();
 34 |     secondNode.IsFullyInView.ShouldBeTrue();
 35 | 
 36 |     // the first node has no connection
 37 |     _graphEdit.HasConnectionFrom(firstNode, Port.Output(0)).ShouldBeFalse();
 38 | 
 39 |     // the second node has no connection
 40 |     _graphEdit.HasConnectionFrom(secondNode, Port.Output(0)).ShouldBeFalse();
 41 | 
 42 |     // the first node has an output port but no input port
 43 |     firstNode.OutputPortCount.ShouldBe(1);
 44 |     firstNode.InputPortCount.ShouldBe(0);
 45 | 
 46 |     // the second node has an input port but no output port
 47 |     secondNode.OutputPortCount.ShouldBe(0);
 48 |     secondNode.InputPortCount.ShouldBe(1);
 49 |   }
 50 | 
 51 |   [Test]
 52 |   public void DraggingNodesWorks()
 53 |   {
 54 |     // SETUP
 55 |     var firstNode = _graphEdit.Nodes.First();
 56 | 
 57 |     var firstNodeOffset = firstNode.Offset;
 58 |     // WHEN
 59 |     // i drag the first node
 60 |     firstNode.DragByOwnSize(2, 0);
 61 | 
 62 |     // THEN
 63 |     // the offset has changed by 2x it's width
 64 |     // (pixels seem to be doubled on macOS :P)
 65 |     var scale = (OS.GetName() == "macOS") ? 2f : 1f;
 66 |     (firstNode.Offset.X * scale).ShouldBe(
 67 |         firstNodeOffset.X + (firstNode.Rect.Size.X * 2), 10
 68 |     );
 69 |   }
 70 | 
 71 |   [Test]
 72 |   public void DraggingConnectionsWorks()
 73 |   {
 74 |     // SETUP
 75 |     var firstNode = _graphEdit.Nodes.First();
 76 |     var secondNode = _graphEdit.Nodes.Last();
 77 | 
 78 |     // WHEN
 79 |     // i drag a connection from the first node to the second node
 80 |     firstNode.DragConnection(Port.Output(0), secondNode, Port.Input(0));
 81 | 
 82 |     // THEN
 83 |     // the connection works
 84 |     _graphEdit.HasConnection(
 85 |       firstNode,
 86 |       Port.Output(0),
 87 |       secondNode,
 88 |       Port.Input(0)
 89 |     ).ShouldBeTrue();
 90 |   }
 91 | 
 92 |   [Test]
 93 |   public void DraggingConnectionsInReverseWorks()
 94 |   {
 95 |     // SETUP
 96 |     var firstNode = _graphEdit.Nodes.First();
 97 |     var secondNode = _graphEdit.Nodes.Last();
 98 | 
 99 |     // WHEN
100 |     // i drag a connection from the second node to the first node
101 |     secondNode.DragConnection(Port.Input(0), firstNode, Port.Output(0));
102 | 
103 |     // THEN
104 |     // the connection works
105 |     _graphEdit.HasConnection(
106 |       firstNode,
107 |       Port.Output(0),
108 |       secondNode,
109 |       Port.Input(0)
110 |     ).ShouldBeTrue();
111 |   }
112 | 
113 |   [Test]
114 |   public void DisconnectingWorks()
115 |   {
116 |     // SETUP
117 |     var firstNode = _graphEdit.Nodes.First();
118 |     var secondNode = _graphEdit.Nodes.Last();
119 | 
120 |     // make a connection
121 |     firstNode.DragConnection(Port.Output(0), secondNode, Port.Input(0));
122 | 
123 |     // WHEN
124 |     // i disconnect the connection, by dragging it from the second node to the
125 |     // first node
126 |     secondNode.DragConnection(Port.Input(0), firstNode, Port.Output(0));
127 | 
128 |     // THEN
129 |     // the connection is gone
130 |     _graphEdit.HasConnection(
131 |       firstNode,
132 |       Port.Output(0),
133 |       secondNode,
134 |       Port.Input(0)
135 |     ).ShouldBeFalse();
136 |   }
137 | }
138 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Input/KeyboardInputExtensions.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Input;
  2 | 
  3 | using System.Threading.Tasks;
  4 | using Godot;
  5 | using GodotTestDriver.Util;
  6 | 
  7 | /// <summary>
  8 | /// Extensions for simulating keyboard inputs.
  9 | /// </summary>
 10 | public static class KeyboardInputExtensions
 11 | {
 12 |   /// <summary>
 13 |   /// Presses the given key with the given modifiers.
 14 |   /// </summary>
 15 |   /// <param name="_">Node that generates simulated input.</param>
 16 |   /// <param name="key">Keyboard key.</param>
 17 |   /// <param name="control">Control modifier.</param>
 18 |   /// <param name="alt">Alt modifier.</param>
 19 |   /// <param name="shift">Shift modifier.</param>
 20 |   /// <param name="meta">Meta-key (Windows, Command) modifier.</param>
 21 |   public static void PressKey(
 22 |       this Node _,
 23 |       Key key,
 24 |       bool control = false,
 25 |       bool alt = false,
 26 |       bool shift = false,
 27 |       bool meta = false
 28 |   )
 29 |   {
 30 |     var inputEvent = new InputEventKey
 31 |     {
 32 |       Pressed = true,
 33 |       Keycode = key,
 34 |       AltPressed = alt,
 35 |       CtrlPressed = control,
 36 |       ShiftPressed = shift,
 37 |       MetaPressed = meta
 38 |     };
 39 | 
 40 |     Input.ParseInputEvent(inputEvent);
 41 |     Input.FlushBufferedEvents();
 42 |   }
 43 | 
 44 |   /// <summary>
 45 |   /// Simulate a key being pressed for a certain amount of time.
 46 |   /// </summary>
 47 |   /// <param name="node">Node that generates simulated input.</param>
 48 |   /// <param name="seconds">Input duration, in seconds.</param>
 49 |   /// <param name="key">Keyboard key.</param>
 50 |   /// <param name="control">Control modifier.</param>
 51 |   /// <param name="alt">Alt modifier.</param>
 52 |   /// <param name="shift">Shift modifier.</param>
 53 |   /// <param name="meta">Meta-key (Windows, Command) modifier.</param>
 54 |   /// <returns>Asynchronous task completed when key is released.</returns>
 55 |   public static async Task HoldKeyFor(
 56 |       this Node node,
 57 |       float seconds,
 58 |       Key key,
 59 |       bool control = false,
 60 |       bool alt = false,
 61 |       bool shift = false,
 62 |       bool meta = false
 63 |   )
 64 |   {
 65 |     node.PressKey(key, control, alt, shift, meta);
 66 |     await node.Wait(seconds);
 67 |     node.ReleaseKey(key, control, alt, shift, meta);
 68 |   }
 69 | 
 70 |   /// <summary>
 71 |   /// Releases the given key with the given modifier state.
 72 |   /// </summary>
 73 |   /// <param name="_">Node that generates simulated input.</param>
 74 |   /// <param name="key">Keyboard key.</param>
 75 |   /// <param name="control">Control modifier.</param>
 76 |   /// <param name="alt">Alt modifier.</param>
 77 |   /// <param name="shift">Shift modifier.</param>
 78 |   /// <param name="meta">Meta-key (Windows, Command) modifier.</param>
 79 |   public static void ReleaseKey(
 80 |       this Node _,
 81 |       Key key,
 82 |       bool control = false,
 83 |       bool alt = false,
 84 |       bool shift = false,
 85 |       bool meta = false
 86 |   )
 87 |   {
 88 |     var inputEvent = new InputEventKey
 89 |     {
 90 |       Pressed = false,
 91 |       Keycode = key,
 92 |       CtrlPressed = control,
 93 |       AltPressed = alt,
 94 |       ShiftPressed = shift,
 95 |       MetaPressed = meta
 96 |     };
 97 | 
 98 |     Input.ParseInputEvent(inputEvent);
 99 |     Input.FlushBufferedEvents();
100 |   }
101 | 
102 |   /// <summary>
103 |   /// Presses and releases a key with the given modifiers.
104 |   /// </summary>
105 |   /// <param name="node">Node that generates simulated input.</param>
106 |   /// <param name="key">Keyboard key.</param>
107 |   /// <param name="control">Control modifier.</param>
108 |   /// <param name="alt">Alt modifier.</param>
109 |   /// <param name="shift">Shift modifier.</param>
110 |   /// <param name="meta">Meta-key (Windows, Command) modifier.</param>
111 |   public static void TypeKey(
112 |       this Node node,
113 |       Key key,
114 |       bool control = false,
115 |       bool alt = false,
116 |       bool shift = false,
117 |       bool meta = false
118 |   )
119 |   {
120 |     node.PressKey(key, control, alt, shift, meta);
121 |     node.ReleaseKey(key, control, alt, shift, meta);
122 |   }
123 | }
124 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/NodeDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using Godot;
  7 | 
  8 | /// <summary>
  9 | /// Base class for test drivers that work on nodes. This is the non-generic
 10 | /// variant, which will make it easier to create some fluent APIs.
 11 | /// </summary>
 12 | public abstract class NodeDriver
 13 | {
 14 | }
 15 | 
 16 | /// <summary>
 17 | /// Base class for test drivers that work on nodes.
 18 | /// </summary>
 19 | /// <typeparam name="T">Node type.</typeparam>
 20 | public abstract class NodeDriver<T> : NodeDriver where T : Node
 21 | {
 22 |   private readonly Func<T> _producer;
 23 | 
 24 |   /// <summary>
 25 |   /// The description given to the test driver.
 26 |   /// </summary>
 27 |   public string Description { get; }
 28 | 
 29 |   /// <summary>
 30 |   /// Creates a new generic NodeDriver.
 31 |   /// </summary>
 32 |   /// <param name="producer">Producer that creates a Node subclass.</param>
 33 |   /// <param name="description">Driver description.</param>
 34 |   protected NodeDriver(Func<T> producer, string description = "")
 35 |   {
 36 |     _producer = producer;
 37 |     Description = description;
 38 |   }
 39 | 
 40 |   /// <summary>
 41 |   /// Is the node currently present in the tree?
 42 |   /// </summary>
 43 |   public bool IsPresent => Root != null;
 44 | 
 45 |   /// <summary>
 46 |   /// Builds drivers for a set of children of the current driver's root node.
 47 |   /// The first function needs to return the currently applicable child nodes,
 48 |   /// the second function will produce a driver for each child.
 49 |   /// </summary>
 50 |   /// <typeparam name="TDriver">Driver type.</typeparam>
 51 |   /// <typeparam name="TNode">Node type.</typeparam>
 52 |   /// <param name="childSelector">Child selector.</param>
 53 |   /// <param name="driverFactory">Driver factory.</param>
 54 |   protected IEnumerable<TDriver> BuildDrivers<TDriver, TNode>(
 55 |     Func<T, IEnumerable<TNode>> childSelector,
 56 |     Func<Func<TNode>, TDriver> driverFactory
 57 |   )
 58 |     where TDriver : NodeDriver
 59 |     where TNode : Node
 60 |   {
 61 |     var root = Root;
 62 |     if (root == null)
 63 |     {
 64 |       yield break;
 65 |     }
 66 | 
 67 |     foreach (var child in childSelector(root).ToList())
 68 |     {
 69 |       yield return driverFactory(() => root.GetNode<TNode>(child.GetPath()));
 70 |     }
 71 |   }
 72 | 
 73 |   /// <summary>
 74 |   /// Helper function to build an error message. Prefixes the message with a
 75 |   /// human readable description of this driver.
 76 |   /// </summary>
 77 |   /// <param name="message">Error message.</param>
 78 |   protected string ErrorMessage(string message)
 79 |   {
 80 |     // if description is blank or empty, use the type name as description
 81 |     var typeName = GetType().Name;
 82 |     if (string.IsNullOrEmpty(Description))
 83 |     {
 84 |       return $"{typeName}: {message}";
 85 |     }
 86 | 
 87 |     return $"{typeName} [{Description}] {message}";
 88 |   }
 89 | 
 90 |   /// <summary>
 91 |   /// Returns the root node. Can be null in case the root
 92 |   /// node is not currently present in the scene tree or if the root node is not
 93 |   /// a valid instance anymore.
 94 |   /// </summary>
 95 |   public T? Root
 96 |   {
 97 |     get
 98 |     {
 99 |       var node = _producer();
100 |       return GodotObject.IsInstanceValid(node) && node.IsInsideTree() ? node : null;
101 |     }
102 |   }
103 | 
104 |   /// <summary>
105 |   /// Returns the root node and ensures it is present.
106 |   /// </summary>
107 |   /// <exception cref="InvalidOperationException"/>
108 |   public T PresentRoot => Root ?? throw new InvalidOperationException(
109 |     ErrorMessage("Node is not present in the scene tree.")
110 |   );
111 | 
112 |   /// <summary>
113 |   /// Returns whether this node has the given signal connected to the given
114 |   /// target.
115 |   /// </summary>
116 |   /// <param name="signal">Signal name.</param>
117 |   /// <param name="target">Target object.</param>
118 |   /// <param name="method">Method name.</param>
119 |   public bool IsSignalConnected(
120 |     string signal,
121 |     GodotObject target,
122 |     string method
123 |   ) =>
124 |     PresentRoot.IsConnected(signal, new Callable(target, method));
125 | 
126 |   /// <summary>
127 |   /// Returns whether the given signal of this node is connected to any other
128 |   /// node.
129 |   /// </summary>
130 |   /// <param name="signal">Signal name.</param>
131 |   public bool IsSignalConnectedToAnywhere(string signal) =>
132 |     PresentRoot.GetSignalConnectionList(signal).Count > 0;
133 | 
134 |   /// <summary>
135 |   /// Returns a signal awaiter that can be used to wait for the given signal.
136 |   /// </summary>
137 |   /// <param name="signal">Signal name.</param>
138 |   public SignalAwaiter GetSignalAwaiter(StringName signal) =>
139 |     PresentRoot.ToSignal(PresentRoot, signal);
140 | }
141 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Input/MouseInputExtensions.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Input;
  2 | 
  3 | using Godot;
  4 | 
  5 | /// <summary>
  6 | /// Extensions for simulating mouse inputs.
  7 | /// </summary>
  8 | public static class MouseInputExtensions
  9 | {
 10 |   /// <summary>
 11 |   /// Clicks the mouse at the specified position.
 12 |   /// </summary>
 13 |   /// <param name="viewport">Viewport that generates simulated input.</param>
 14 |   /// <param name="position">Position, in viewport coordinates.</param>
 15 |   /// <param name="button">Mouse button.</param>
 16 |   public static void ClickMouseAt(
 17 |     this Viewport viewport,
 18 |     Vector2 position,
 19 |     MouseButton button = MouseButton.Left
 20 |   )
 21 |   {
 22 |     viewport.PressMouseAt(position, button);
 23 |     viewport.ReleaseMouseAt(position, button);
 24 |   }
 25 | 
 26 |   /// <summary>
 27 |   /// Moves the mouse to the specified position.
 28 |   /// </summary>
 29 |   /// <param name="viewport">Viewport that generates simulated input.</param>
 30 |   /// <param name="position">Position, in viewport coordinates.</param>
 31 |   public static void MoveMouseTo(this Viewport viewport, Vector2 position)
 32 |   {
 33 |     var oldPosition = viewport.GetMousePosition();
 34 |     var stretchedPosition = viewport.StretchedPosition(position);
 35 | 
 36 |     viewport.WarpMouse(position);
 37 |     var inputEvent = new InputEventMouseMotion
 38 |     {
 39 |       GlobalPosition = stretchedPosition,
 40 |       Position = stretchedPosition,
 41 |       Relative = position - oldPosition
 42 |     };
 43 |     Input.ParseInputEvent(inputEvent);
 44 |     Input.FlushBufferedEvents();
 45 |   }
 46 | 
 47 |   /// <summary>
 48 |   /// Drags the mouse from the start position to the end position.
 49 |   /// </summary>
 50 |   /// <param name="viewport">Viewport that generates simulated input.</param>
 51 |   /// <param name="start">Start position, in viewport coordinates.</param>
 52 |   /// <param name="end">End position, in viewport coordinates.</param>
 53 |   /// <param name="button">Mouse button.</param>
 54 |   public static void DragMouse(
 55 |     this Viewport viewport,
 56 |     Vector2 start,
 57 |     Vector2 end,
 58 |     MouseButton button = MouseButton.Left
 59 |   )
 60 |   {
 61 |     viewport.PressMouseAt(start, button);
 62 |     viewport.ReleaseMouseAt(end, button);
 63 |   }
 64 | 
 65 |   /// <summary>
 66 |   /// Presses the given mouse button.
 67 |   /// </summary>
 68 |   /// <param name="_">Viewport that generates simulated input.</param>
 69 |   /// <param name="button">Mouse button (left by default).</param>
 70 |   public static void PressMouse(
 71 |     this Viewport _,
 72 |     MouseButton button = MouseButton.Left
 73 |   )
 74 |   {
 75 |     var action = new InputEventMouseButton
 76 |     {
 77 |       ButtonIndex = button,
 78 |       Pressed = true
 79 |     };
 80 |     Input.ParseInputEvent(action);
 81 |     Input.FlushBufferedEvents();
 82 |   }
 83 | 
 84 |   /// <summary>
 85 |   /// Releases the given mouse button.
 86 |   /// </summary>
 87 |   /// <param name="_">Viewport that generates simulated input.</param>
 88 |   /// <param name="button">Mouse button (left by default).</param>
 89 |   public static void ReleaseMouse(
 90 |     this Viewport _,
 91 |     MouseButton button = MouseButton.Left
 92 |   )
 93 |   {
 94 |     var action = new InputEventMouseButton
 95 |     {
 96 |       ButtonIndex = button,
 97 |       Pressed = false
 98 |     };
 99 |     Input.ParseInputEvent(action);
100 |     Input.FlushBufferedEvents();
101 |   }
102 | 
103 |   private static void PressMouseAt(
104 |     this Viewport viewport,
105 |     Vector2 position,
106 |     MouseButton button = MouseButton.Left
107 |   )
108 |   {
109 |     viewport.MoveMouseTo(position);
110 |     var stretchedPosition = viewport.StretchedPosition(position);
111 | 
112 |     var action = new InputEventMouseButton
113 |     {
114 |       ButtonIndex = button,
115 |       Pressed = true,
116 |       Position = stretchedPosition,
117 |       GlobalPosition = stretchedPosition
118 |     };
119 |     Input.ParseInputEvent(action);
120 |     Input.FlushBufferedEvents();
121 |   }
122 | 
123 |   private static void ReleaseMouseAt(
124 |     this Viewport viewport,
125 |     Vector2 position,
126 |     MouseButton button = MouseButton.Left
127 |   )
128 |   {
129 |     viewport.MoveMouseTo(position);
130 |     var stretchedPosition = viewport.StretchedPosition(position);
131 | 
132 |     var action = new InputEventMouseButton
133 |     {
134 |       ButtonIndex = button,
135 |       Pressed = false,
136 |       Position = stretchedPosition,
137 |       GlobalPosition = stretchedPosition
138 |     };
139 |     Input.ParseInputEvent(action);
140 |     Input.FlushBufferedEvents();
141 |   }
142 | 
143 |   // Correct for viewport's stretch transform
144 |   // see https://docs.godotengine.org/en/stable/tutorials/2d/2d_transforms.html#stretch-transform
145 |   private static Vector2 StretchedPosition(
146 |     this Viewport viewport,
147 |     Vector2 position
148 |   )
149 |   {
150 |     var screenTransform = viewport.GetFinalTransform();
151 |     return screenTransform.BasisXform(position) + screenTransform.Origin;
152 |   }
153 | }
154 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Drivers/ItemListDriverTest.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Tests.Drivers;
  2 | 
  3 | using System;
  4 | using System.Linq;
  5 | using Chickensoft.GoDotTest;
  6 | using Godot;
  7 | using GodotTestDriver.Drivers;
  8 | using Shouldly;
  9 | 
 10 | public class ItemListDriverTest : DriverTest
 11 | {
 12 |   private readonly ItemListDriver _itemList;
 13 | 
 14 |   public ItemListDriverTest(Node testScene) : base(testScene)
 15 |   {
 16 |     _itemList = new ItemListDriver(() =>
 17 |       RootNode.GetNode<ItemList>("ItemList"));
 18 |   }
 19 | 
 20 |   [Test]
 21 |   public void InspectionWorks()
 22 |   {
 23 |     // WHEN
 24 |     // everything is set up
 25 | 
 26 |     // THEN
 27 |     // we should have two selectable items
 28 |     _itemList.SelectableItems.Count.ShouldBe(2);
 29 | 
 30 |     // named "Normal Item 1" and "Normal Item 2"
 31 |     _itemList.SelectableItems[0].ShouldBe("Normal Item 1");
 32 |     _itemList.SelectableItems.Last().ShouldBe("Normal Item 2");
 33 | 
 34 |     // and we should have a total of 4 items
 35 |     _itemList.ItemCount.ShouldBe(4);
 36 |   }
 37 | 
 38 |   [Test]
 39 |   public void SelectingItemsWorks()
 40 |   {
 41 |     // WHEN
 42 |     // we select the first item
 43 |     var signalAwaiter = _itemList.GetSignalAwaiter(
 44 |       ItemList.SignalName.ItemSelected
 45 |     );
 46 |     _itemList.SelectItemWithText("Normal Item 1");
 47 | 
 48 |     // THEN
 49 |     // the first item is selected
 50 |     _itemList.SelectedItems.Count.ShouldBe(1);
 51 |     _itemList.SelectedItems[0].ShouldBe("Normal Item 1");
 52 | 
 53 |     // and the signal is emitted
 54 |     signalAwaiter.IsCompleted.ShouldBeTrue();
 55 | 
 56 |     // WHEN
 57 |     // we select the second item
 58 |     var signalAwaiter2 = _itemList.GetSignalAwaiter(
 59 |       ItemList.SignalName.ItemSelected
 60 |     );
 61 |     _itemList.SelectItemWithText("Normal Item 2");
 62 | 
 63 |     // THEN
 64 |     // the second item is selected
 65 |     _itemList.SelectedItems.Count.ShouldBe(1);
 66 |     _itemList.SelectedItems[0].ShouldBe("Normal Item 2");
 67 | 
 68 |     // and the signal is emitted
 69 |     signalAwaiter2.IsCompleted.ShouldBeTrue();
 70 |   }
 71 | 
 72 |   [Test]
 73 |   public void MultiSelectionWorks()
 74 |   {
 75 |     // WHEN
 76 |     // we select the first item
 77 |     _itemList.SelectItemWithText("Normal Item 1");
 78 | 
 79 |     // and adding the second item
 80 |     _itemList.SelectItemWithText("Normal Item 2", true);
 81 | 
 82 |     // THEN
 83 |     // both items are selected
 84 |     _itemList.SelectedItems.Count.ShouldBe(2);
 85 |     _itemList.SelectedItems[0].ShouldBe("Normal Item 1");
 86 |     _itemList.SelectedItems.Last().ShouldBe("Normal Item 2");
 87 |   }
 88 | 
 89 |   [Test]
 90 |   public void MassSelectionWorks()
 91 |   {
 92 |     // WHEN
 93 |     // we select all items
 94 |     _itemList.SelectItemsWithText("Normal Item 1", "Normal Item 2");
 95 | 
 96 |     // THEN
 97 |     // both items are selected
 98 |     _itemList.SelectedItems.Count.ShouldBe(2);
 99 |     _itemList.SelectedItems[0].ShouldBe("Normal Item 1");
100 |     _itemList.SelectedItems.Last().ShouldBe("Normal Item 2");
101 |   }
102 | 
103 |   [Test]
104 |   public void DeselectionWorks()
105 |   {
106 |     // WHEN
107 |     // we select the first item
108 |     _itemList.SelectItemWithText("Normal Item 1");
109 | 
110 |     // and deselect it
111 |     _itemList.DeselectItemWithText("Normal Item 1");
112 | 
113 |     // THEN
114 |     // no items are selected
115 |     _itemList.SelectedItems.Count.ShouldBe(0);
116 |   }
117 | 
118 |   [Test]
119 |   public void MassDeselectionWorks()
120 |   {
121 |     // WHEN
122 |     // we select the two items
123 |     _itemList.SelectItemWithText("Normal Item 1");
124 |     _itemList.SelectItemWithText("Normal Item 2", true);
125 | 
126 |     // and deselect all
127 |     _itemList.DeselectAll();
128 | 
129 |     // THEN
130 |     // no items are selected
131 |     _itemList.SelectedItems.Count.ShouldBe(0);
132 |   }
133 | 
134 |   [Test]
135 |   public void ActivatingItemsWorks()
136 |   {
137 |     // WHEN
138 |     // we activate the first item
139 |     var signalAwaiter = _itemList.GetSignalAwaiter(
140 |       ItemList.SignalName.ItemActivated
141 |     );
142 |     _itemList.ActivateItemWithText("Normal Item 1");
143 | 
144 |     // THEN
145 |     // the signal is emitted
146 |     signalAwaiter.IsCompleted.ShouldBeTrue();
147 |   }
148 | 
149 |   [Test]
150 |   public void SelectingDisabledItemsDoesNotWork() =>
151 |     // WHEN
152 |     // we try to select a disabled item, an InvalidOperationException should be thrown
153 |     Should.Throw<InvalidOperationException>(
154 |       () => _itemList.SelectItemWithText("Disabled Item")
155 |     );
156 | 
157 |   [Test]
158 |   public void SelectingNonExistingItemsDoesNotWork() =>
159 |     // WHEN
160 |     // we try to select a non-existing item, an InvalidOperationException should be thrown
161 |     Should.Throw<InvalidOperationException>(
162 |       () => _itemList.SelectItemWithText("Non-existing Item")
163 |     );
164 | 
165 |   [Test]
166 |   public void SelectingUnselectableItemsDoesNotWork() =>
167 |     // WHEN
168 |     // we try to select an unselectable item, an InvalidOperationException should be thrown
169 |     Should.Throw<InvalidOperationException>(
170 |       () => _itemList.SelectItemWithText("NonSelectable Item")
171 |     );
172 | }
173 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "[csharp]": {
  3 |     "editor.codeActionsOnSave": {
  4 |       "source.addMissingImports": "explicit",
  5 |       "source.fixAll": "explicit",
  6 |       "source.organizeImports": "explicit"
  7 |     },
  8 |     "editor.formatOnPaste": true,
  9 |     "editor.formatOnSave": true,
 10 |     "editor.formatOnType": true
 11 |   },
 12 |   "csharp.semanticHighlighting.enabled": true,
 13 |   "dotnet.completion.showCompletionItemsFromUnimportedNamespaces": true,
 14 |   // Required to keep the C# language server from getting confused about which
 15 |   // solution to open.
 16 |   "dotnet.defaultSolution": "Chickensoft.GodotTestDriver.sln",
 17 |   "editor.semanticHighlighting.enabled": true,
 18 |   "editor.rulers": [80, 120],
 19 |   // C# doc comment colorization gets lost with semantic highlighting, but we
 20 |   // need semantic highlighting for proper syntax highlighting with record
 21 |   // shorthand.
 22 |   //
 23 |   // Here's a workaround for doc comment highlighting from
 24 |   // https://github.com/OmniSharp/omnisharp-vscode/issues/3816
 25 |   "editor.tokenColorCustomizations": {
 26 |     "[*]": {
 27 |       // Themes that don't include the word "Dark" or "Light" in them.
 28 |       // These are some bold colors that show up well against most dark and
 29 |       // light themes.
 30 |       //
 31 |       // Change them to something that goes well with your preferred theme :)
 32 |       "textMateRules": [
 33 |         {
 34 |           "scope": "comment.documentation",
 35 |           "settings": {
 36 |             "foreground": "#0091ff"
 37 |           }
 38 |         },
 39 |         {
 40 |           "scope": "comment.documentation.attribute",
 41 |           "settings": {
 42 |             "foreground": "#8480ff"
 43 |           }
 44 |         },
 45 |         {
 46 |           "scope": "comment.documentation.cdata",
 47 |           "settings": {
 48 |             "foreground": "#0091ff"
 49 |           }
 50 |         },
 51 |         {
 52 |           "scope": "comment.documentation.delimiter",
 53 |           "settings": {
 54 |             "foreground": "#aa00ff"
 55 |           }
 56 |         },
 57 |         {
 58 |           "scope": "comment.documentation.name",
 59 |           "settings": {
 60 |             "foreground": "#ef0074"
 61 |           }
 62 |         }
 63 |       ]
 64 |     },
 65 |     "[*Dark*]": {
 66 |       // Themes that include the word "Dark" in them.
 67 |       "textMateRules": [
 68 |         {
 69 |           "scope": "comment.documentation",
 70 |           "settings": {
 71 |             "foreground": "#608B4E"
 72 |           }
 73 |         },
 74 |         {
 75 |           "scope": "comment.documentation.attribute",
 76 |           "settings": {
 77 |             "foreground": "#C8C8C8"
 78 |           }
 79 |         },
 80 |         {
 81 |           "scope": "comment.documentation.cdata",
 82 |           "settings": {
 83 |             "foreground": "#E9D585"
 84 |           }
 85 |         },
 86 |         {
 87 |           "scope": "comment.documentation.delimiter",
 88 |           "settings": {
 89 |             "foreground": "#808080"
 90 |           }
 91 |         },
 92 |         {
 93 |           "scope": "comment.documentation.name",
 94 |           "settings": {
 95 |             "foreground": "#569CD6"
 96 |           }
 97 |         }
 98 |       ]
 99 |     },
100 |     "[*Light*]": {
101 |       // Themes that include the word "Light" in them.
102 |       "textMateRules": [
103 |         {
104 |           "scope": "comment.documentation",
105 |           "settings": {
106 |             "foreground": "#008000"
107 |           }
108 |         },
109 |         {
110 |           "scope": "comment.documentation.attribute",
111 |           "settings": {
112 |             "foreground": "#282828"
113 |           }
114 |         },
115 |         {
116 |           "scope": "comment.documentation.cdata",
117 |           "settings": {
118 |             "foreground": "#808080"
119 |           }
120 |         },
121 |         {
122 |           "scope": "comment.documentation.delimiter",
123 |           "settings": {
124 |             "foreground": "#808080"
125 |           }
126 |         },
127 |         {
128 |           "scope": "comment.documentation.name",
129 |           "settings": {
130 |             "foreground": "#808080"
131 |           }
132 |         }
133 |       ]
134 |     }
135 |   },
136 |   "markdownlint.config": {
137 |     // Allow non-unique heading names so we don't break the changelog.
138 |     "MD024": false,
139 |     // Allow html in markdown.
140 |     "MD033": false
141 |   },
142 |   "markdownlint.lintWorkspaceGlobs": [
143 |     "!**/LICENSE"
144 |   ],
145 |   "omnisharp.enableEditorConfigSupport": true,
146 |   "omnisharp.enableMsBuildLoadProjectsOnDemand": false,
147 |   "omnisharp.maxFindSymbolsItems": 3000,
148 |   "omnisharp.useModernNet": true,
149 |   // Remove these if you're happy with your terminal profiles.
150 |   "terminal.integrated.defaultProfile.windows": "Git Bash",
151 |   "terminal.integrated.profiles.windows": {
152 |     "Command Prompt": {
153 |       "icon": "terminal-cmd",
154 |       "path": [
155 |         "${env:windir}\\Sysnative\\cmd.exe",
156 |         "${env:windir}\\System32\\cmd.exe"
157 |       ]
158 |     },
159 |     "Git Bash": {
160 |       "icon": "terminal",
161 |       "source": "Git Bash"
162 |     },
163 |     "PowerShell": {
164 |       "icon": "terminal-powershell",
165 |       "source": "PowerShell"
166 |     }
167 |   },
168 |   "dotnet.formatting.organizeImportsOnFormat": true
169 | }
170 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/OptionButtonDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using Godot;
  6 | 
  7 | /// <summary>
  8 | /// Driver for <see cref="OptionButton"/> controls.
  9 | /// </summary>
 10 | /// <typeparam name="T">OptionButton type.</typeparam>
 11 | public class OptionButtonDriver<T> : BaseButtonDriver<T> where T : OptionButton
 12 | {
 13 |   /// <summary>
 14 |   /// Creates a new generic OptionButtonDriver.
 15 |   /// </summary>
 16 |   /// <param name="producer">
 17 |   /// Producer that creates a OptionButton subclass.
 18 |   /// </param>
 19 |   /// <param name="description">Driver description.</param>
 20 |   public OptionButtonDriver(Func<T> producer, string description = "")
 21 |     : base(producer, description)
 22 |   {
 23 |   }
 24 | 
 25 |   /// <summary>
 26 |   /// Returns a list of all items in the option button.
 27 |   /// </summary>
 28 |   public IEnumerable<string> Items
 29 |   {
 30 |     get
 31 |     {
 32 |       var uiControl = PresentRoot;
 33 |       for (var i = 0; i < uiControl.ItemCount; i++)
 34 |       {
 35 |         yield return uiControl.GetItemText(i);
 36 |       }
 37 |     }
 38 |   }
 39 | 
 40 |   /// <summary>
 41 |   /// Returns a list of all items in the option button that are currently
 42 |   /// selectable (e.g. not disabled).
 43 |   /// </summary>
 44 |   public IEnumerable<string> SelectableItems
 45 |   {
 46 |     get
 47 |     {
 48 |       var uiControl = PresentRoot;
 49 | 
 50 |       for (var i = 0; i < uiControl.ItemCount; i++)
 51 |       {
 52 |         if (!uiControl.IsItemDisabled(i) && !uiControl.IsItemSeparator(i))
 53 |         {
 54 |           yield return uiControl.GetItemText(i);
 55 |         }
 56 |       }
 57 |     }
 58 |   }
 59 | 
 60 |   /// <summary>
 61 |   /// Returns the currently selected item, or null if no item is selected.
 62 |   /// </summary>
 63 |   public string? SelectedItem
 64 |   {
 65 |     get
 66 |     {
 67 |       var uiControl = PresentRoot;
 68 |       return uiControl.Selected < 0
 69 |         ? null
 70 |         : uiControl.GetItemText(uiControl.Selected);
 71 |     }
 72 |   }
 73 | 
 74 |   /// <summary>
 75 |   /// Returns the currently selected item index, or -1 if no item is selected.
 76 |   /// </summary>
 77 |   public int SelectedIndex => PresentRoot.Selected;
 78 | 
 79 |   /// <summary>
 80 |   /// Returns the currently selected item ID, or -1 if no item is selected.
 81 |   /// </summary>
 82 |   public int SelectedId =>
 83 |     PresentRoot.Selected < 0
 84 |       ? -1
 85 |       : PresentRoot.GetItemId(PresentRoot.Selected);
 86 | 
 87 |   /// <summary>
 88 |   /// Returns the index of the item with the given text. Throws an exception if
 89 |   /// the item is not found or not selectable.
 90 |   /// </summary>
 91 |   /// <param name="text">Option label.</param>
 92 |   /// <exception cref="InvalidOperationException" />
 93 |   private int IndexOf(string text)
 94 |   {
 95 |     var uiControl = VisibleRoot;
 96 |     for (var i = 0; i < uiControl.ItemCount; i++)
 97 |     {
 98 |       if (uiControl.GetItemText(i) == text)
 99 |       {
100 |         if (uiControl.IsItemDisabled(i) || uiControl.IsItemSeparator(i))
101 |         {
102 |           throw new InvalidOperationException(
103 |             ErrorMessage($"Item with text '{text}' is not selectable.")
104 |           );
105 |         }
106 | 
107 |         return i;
108 |       }
109 |     }
110 | 
111 |     throw new InvalidOperationException(
112 |       ErrorMessage($"Option button does not contain item with name '{text}'.")
113 |     );
114 |   }
115 | 
116 |   /// <summary>
117 |   /// Selects an item with the given text.
118 |   /// </summary>
119 |   /// <param name="text">Option label.</param>
120 |   public void SelectItemWithText(string text)
121 |   {
122 |     var uiControl = VisibleRoot;
123 |     var index = IndexOf(text);
124 |     uiControl.Select(index);
125 |     // calling this function will not emit the signal so we need to do this
126 |     // ourselves
127 |     uiControl.EmitSignal(OptionButton.SignalName.ItemSelected, index);
128 |   }
129 | 
130 |   /// <summary>
131 |   /// Selects an item with the given ID.
132 |   /// </summary>
133 |   /// <param name="id">Option id.</param>
134 |   /// <exception cref="InvalidOperationException" />
135 |   public void SelectItemWithId(int id)
136 |   {
137 |     var uiControl = VisibleRoot;
138 | 
139 |     for (var i = 0; i < uiControl.ItemCount; i++)
140 |     {
141 |       if (uiControl.GetItemId(i) != id)
142 |       {
143 |         continue;
144 |       }
145 | 
146 |       if (uiControl.IsItemDisabled(i))
147 |       {
148 |         throw new InvalidOperationException(
149 |           ErrorMessage($"Item with ID '{id}' is not selectable.")
150 |         );
151 |       }
152 | 
153 |       uiControl.Select(i);
154 |       // calling this function will not emit the signal so we need to do this
155 |       // ourselves
156 |       uiControl.EmitSignal(OptionButton.SignalName.ItemSelected, i);
157 |       return;
158 |     }
159 | 
160 |     throw new InvalidOperationException(
161 |       ErrorMessage($"Option button does not contain item with ID '{id}'.")
162 |     );
163 |   }
164 | }
165 | 
166 | /// <summary>
167 | /// Driver for <see cref="OptionButton"/> controls.
168 | /// </summary>
169 | public sealed class OptionButtonDriver : OptionButtonDriver<OptionButton>
170 | {
171 |   /// <summary>
172 |   /// Creates a new OptionButtonDriver.
173 |   /// </summary>
174 |   /// <param name="producer">
175 |   /// Producer that creates a OptionButton subclass.
176 |   /// </param>
177 |   /// <param name="description">Driver description.</param>
178 |   public OptionButtonDriver(
179 |     Func<OptionButton> producer,
180 |     string description = ""
181 |   )
182 |     : base(producer, description)
183 |   {
184 |   }
185 | }
186 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/GraphEditDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using Godot;
  7 | using Godot.Collections;
  8 | 
  9 | /// <summary>
 10 | /// Driver for a <see cref="GraphEdit"/>.
 11 | /// </summary>
 12 | /// <typeparam name="TGraphEdit">GraphEdit type.</typeparam>
 13 | /// <typeparam name="TGraphNodeDriver">GraphNodeDriver type.</typeparam>
 14 | /// <typeparam name="TGraphNode">GraphNode type.</typeparam>
 15 | public class GraphEditDriver<TGraphEdit, TGraphNodeDriver, TGraphNode>
 16 |   : ControlDriver<TGraphEdit>
 17 |     where TGraphEdit : GraphEdit
 18 |     where TGraphNode : GraphNode
 19 |     where TGraphNodeDriver : GraphNodeDriver<TGraphNode>
 20 | {
 21 |   private readonly Func<Func<TGraphNode>, string, TGraphNodeDriver>
 22 |     _nodeDriverProducer;
 23 | 
 24 |   /// <summary>
 25 |   /// Constructs a new GraphEdit driver.
 26 |   /// </summary>
 27 |   /// <param name="producer">
 28 |   /// Producer that produces the <see cref="GraphEdit"/> this driver works on.
 29 |   /// </param>
 30 |   /// <param name="nodeDriverProducer">
 31 |   /// Producer that produces a driver for a <see cref="GraphNode"/> child of the
 32 |   /// <see cref="GraphEdit"/>.
 33 |   /// </param>
 34 |   /// <param name="description">a description for the node.</param>
 35 |   public GraphEditDriver(Func<TGraphEdit> producer,
 36 |       Func<Func<TGraphNode>, string, TGraphNodeDriver> nodeDriverProducer,
 37 |       string description = "") : base(producer, description)
 38 |   {
 39 |     _nodeDriverProducer = nodeDriverProducer;
 40 |   }
 41 | 
 42 |   /// <summary>
 43 |   /// Checks if the graph edit has a connection from the given node to the given
 44 |   /// target node on the given ports.
 45 |   /// </summary>
 46 |   /// <param name="from">Source GraphNodeDriver.</param>
 47 |   /// <param name="fromPort">Source port.</param>
 48 |   /// <param name="to">Target GraphNodeDriver.</param>
 49 |   /// <param name="toPort">Target port.</param>
 50 |   /// <exception cref="ArgumentException" />
 51 |   public bool HasConnection(
 52 |     TGraphNodeDriver from,
 53 |     Port fromPort,
 54 |     TGraphNodeDriver to,
 55 |     Port toPort
 56 |   )
 57 |   {
 58 |     if (!fromPort.IsOutput)
 59 |     {
 60 |       throw new ArgumentException("fromPort must be an output port");
 61 |     }
 62 | 
 63 |     if (!toPort.IsInput)
 64 |     {
 65 |       throw new ArgumentException("toPort must be an input port");
 66 |     }
 67 | 
 68 |     var graphEdit = PresentRoot;
 69 |     var fromRoot = from.PresentRoot;
 70 |     var toRoot = to.PresentRoot;
 71 | 
 72 |     return graphEdit.GetConnectionList()
 73 |         .Any(connection =>
 74 |             (string)connection["from_node"] == fromRoot.Name
 75 |             && (int)connection["from_port"] == fromPort.PortIndex
 76 |             && (string)connection["to_node"] == toRoot.Name
 77 |             && (int)connection["to_port"] == toPort.PortIndex);
 78 |   }
 79 | 
 80 |   /// <summary>
 81 |   /// Checks if he graph edit has a connection originating from the given node
 82 |   /// on the given port.
 83 |   /// </summary>
 84 |   /// <param name="from">Source GraphNodeDriver.</param>
 85 |   /// <param name="fromPort">Source port.</param>
 86 |   /// <exception cref="ArgumentException"/>
 87 |   public bool HasConnectionFrom(TGraphNodeDriver from, Port fromPort)
 88 |   {
 89 |     if (!fromPort.IsOutput)
 90 |     {
 91 |       throw new ArgumentException("fromPort must be an output port");
 92 |     }
 93 | 
 94 |     var graphEdit = PresentRoot;
 95 |     var fromRoot = from.PresentRoot;
 96 | 
 97 |     return graphEdit.GetConnectionList().Cast<Dictionary>()
 98 |         .Any(connection =>
 99 |             (string)connection["from_node"] == fromRoot.Name
100 |             && (int)connection["from_port"] == fromPort.PortIndex
101 |         );
102 |   }
103 | 
104 |   /// <summary>
105 |   /// Checks if he graph edit has a connection originating from the given node
106 |   /// on the given port.
107 |   /// </summary>
108 |   /// <param name="to">Target GraphNodeDriver.</param>
109 |   /// <param name="toPort">Target port.</param>
110 |   /// <exception cref="ArgumentException"/>
111 |   public bool HasConnectionTo(TGraphNodeDriver to, Port toPort)
112 |   {
113 |     if (!toPort.IsInput)
114 |     {
115 |       throw new ArgumentException("toPort must be an input port");
116 |     }
117 | 
118 |     var graphEdit = PresentRoot;
119 |     var toRoot = to.PresentRoot;
120 | 
121 |     return graphEdit.GetConnectionList().Cast<Dictionary>()
122 |         .Any(connection =>
123 |             (string)connection["to_node"] == toRoot.Name
124 |             && (int)connection["to_port"] == toPort.PortIndex
125 |         );
126 |   }
127 | 
128 |   /// <summary>
129 |   /// Drivers corresponding to the nodes in the graph.
130 |   /// </summary>
131 |   public IEnumerable<TGraphNodeDriver> Nodes =>
132 |       BuildDrivers(root => root.GetChildren().OfType<TGraphNode>(),
133 |           node => _nodeDriverProducer(node, "-> GraphNode")
134 |       );
135 | }
136 | 
137 | /// <summary>
138 | /// Driver for a <see cref="GraphEdit"/>.
139 | /// </summary>
140 | public class GraphEditDriver
141 |   : GraphEditDriver<GraphEdit, GraphNodeDriver, GraphNode>
142 | {
143 |   /// <summary>
144 |   /// Constructs a new GraphEdit driver.
145 |   /// </summary>
146 |   /// <param name="producer">
147 |   /// Producer that produces the <see cref="GraphEdit"/> this driver works on.
148 |   /// </param>
149 |   /// <param name="description">Driver description.</param>
150 |   public GraphEditDriver(Func<GraphEdit> producer, string description = "")
151 |     : base(
152 |         producer,
153 |         (node, nodeDescription) =>
154 |           new GraphNodeDriver(node, $"{description}-> {nodeDescription}"),
155 |         description
156 |       )
157 |   {
158 |   }
159 | }
160 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/ItemListDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using Godot;
  7 | 
  8 | /// <summary>
  9 | /// Driver for an ItemList control.
 10 | /// </summary>
 11 | /// <typeparam name="T">Item list type.</typeparam>
 12 | public class ItemListDriver<T> : ControlDriver<T> where T : ItemList
 13 | {
 14 |   /// <summary>
 15 |   /// Creates a new generic ItemListDriver.
 16 |   /// </summary>
 17 |   /// <param name="producer">Producer that creates a ItemList subclass.</param>
 18 |   /// <param name="description">Driver description.</param>
 19 |   public ItemListDriver(Func<T> producer, string description = "")
 20 |     : base(producer, description)
 21 |   {
 22 |   }
 23 | 
 24 |   /// <summary>
 25 |   /// Returns a list of all items in the list that are currently selectable.
 26 |   /// </summary>
 27 |   public List<string> SelectableItems
 28 |   {
 29 |     get
 30 |     {
 31 |       var uiControl = PresentRoot;
 32 | 
 33 |       var result = new List<string>();
 34 |       for (var i = 0; i < uiControl.ItemCount; i++)
 35 |       {
 36 |         if (uiControl.IsItemSelectable(i) && !uiControl.IsItemDisabled(i))
 37 |         {
 38 |           result.Add(uiControl.GetItemText(i));
 39 |         }
 40 |       }
 41 | 
 42 |       return result;
 43 |     }
 44 |   }
 45 | 
 46 |   /// <summary>
 47 |   /// Returns true if something is selected.
 48 |   /// </summary>
 49 |   public bool HasSelection => PresentRoot.GetSelectedItems().Length > 0;
 50 | 
 51 |   /// <summary>
 52 |   /// Returns the number of items in the list.
 53 |   /// </summary>
 54 |   public int ItemCount => PresentRoot.ItemCount;
 55 | 
 56 |   /// <summary>
 57 |   /// Returns the currently selected items.
 58 |   /// </summary>
 59 |   public List<string> SelectedItems
 60 |   {
 61 |     get
 62 |     {
 63 |       var uiControl = PresentRoot;
 64 |       return
 65 |         [.. uiControl.GetSelectedItems().Select(i => uiControl.GetItemText(i))];
 66 |     }
 67 |   }
 68 | 
 69 |   /// <summary>
 70 |   /// Returns the indices of the currently selected items.
 71 |   /// </summary>
 72 |   public List<int> SelectedIndices
 73 |   {
 74 |     get
 75 |     {
 76 |       var uiControl = PresentRoot;
 77 |       return [.. uiControl.GetSelectedItems()];
 78 |     }
 79 |   }
 80 | 
 81 |   /// <summary>
 82 |   /// Returns the index of the item with the given text. Throws an exception if the item is not found.
 83 |   /// </summary>
 84 |   /// <param name="text">Item label.</param>
 85 |   /// <exception cref="InvalidOperationException"/>
 86 |   private int IndexOf(string text)
 87 |   {
 88 |     var uiControl = PresentRoot;
 89 |     for (var i = 0; i < uiControl.ItemCount; i++)
 90 |     {
 91 |       if (uiControl.GetItemText(i) == text)
 92 |       {
 93 |         return i;
 94 |       }
 95 |     }
 96 | 
 97 |     throw new InvalidOperationException(
 98 |       ErrorMessage($"List does not contain item with text '{text}'.")
 99 |     );
100 |   }
101 | 
102 |   /// <summary>
103 |   /// Selects an item with the given text.
104 |   /// </summary>
105 |   /// <param name="text">Item label.</param>
106 |   /// <param name="addToSelection">
107 |   /// True to add to the current selection, false to change the selection.
108 |   /// </param>
109 |   /// <exception cref="InvalidOperationException"/>
110 |   public void SelectItemWithText(string text, bool addToSelection = false)
111 |   {
112 |     var uiControl = VisibleRoot;
113 | 
114 |     if (addToSelection && uiControl.SelectMode != ItemList.SelectModeEnum.Multi)
115 |     {
116 |       throw new InvalidOperationException(
117 |         ErrorMessage("Cannot select multiple items because selection mode is not allowing it.")
118 |       );
119 |     }
120 | 
121 |     var i = IndexOf(text);
122 |     if (!uiControl.IsItemSelectable(i) || uiControl.IsItemDisabled(i))
123 |     {
124 |       throw new InvalidOperationException(
125 |         ErrorMessage($"Item with text '{text}' is not selectable.")
126 |       );
127 |     }
128 | 
129 |     // check if the item is already selected
130 |     var wasSelectedBefore = uiControl.IsSelected(i);
131 | 
132 |     uiControl.Select(i, !addToSelection);
133 |     // calling this function will not emit the signal so we need to do this
134 |     // ourselves if the item was already selected before then only emit the
135 |     // signal if AllowReselect is true
136 |     if (!wasSelectedBefore || uiControl.AllowReselect)
137 |     {
138 |       uiControl.EmitSignal(ItemList.SignalName.ItemSelected, i);
139 |     }
140 |   }
141 | 
142 |   /// <summary>
143 |   /// Selects multiple items with the given texts.
144 |   /// </summary>
145 |   /// <param name="texts">Item label.</param>
146 |   public void SelectItemsWithText(IEnumerable<string> texts)
147 |   {
148 |     foreach (var text in texts)
149 |     {
150 |       SelectItemWithText(text, true);
151 |     }
152 |   }
153 | 
154 |   /// <summary>
155 |   /// Selects multiple items with the given texts.
156 |   /// </summary>
157 |   /// <param name="texts">Item labels.</param>
158 |   public void SelectItemsWithText(params string[] texts) =>
159 |     SelectItemsWithText(texts.AsEnumerable());
160 | 
161 |   /// <summary>
162 |   /// Deselects an item with the given text.
163 |   /// </summary>
164 |   /// <param name="text">Item label.</param>
165 |   /// <exception cref="InvalidOperationException"/>
166 |   public void DeselectItemWithText(string text)
167 |   {
168 |     var uiControl = VisibleRoot;
169 | 
170 |     var i = IndexOf(text);
171 |     if (!uiControl.IsItemSelectable(i) || uiControl.IsItemDisabled(i))
172 |     {
173 |       throw new InvalidOperationException(
174 |         ErrorMessage($"Item with text '{text}' is not selectable.")
175 |       );
176 |     }
177 | 
178 |     uiControl.Deselect(i);
179 |   }
180 | 
181 |   /// <summary>
182 |   /// Deselects all items.
183 |   /// </summary>
184 |   public void DeselectAll()
185 |   {
186 |     var uiControl = VisibleRoot;
187 |     uiControl.DeselectAll();
188 |   }
189 | 
190 |   /// <summary>
191 |   /// Activates the item with the given text.
192 |   /// </summary>
193 |   /// <param name="text">Item label.</param>
194 |   public void ActivateItemWithText(string text)
195 |   {
196 |     var uiControl = VisibleRoot;
197 |     SelectItemWithText(text);
198 | 
199 |     // send the activation signal
200 |     uiControl.EmitSignal(ItemList.SignalName.ItemActivated, IndexOf(text));
201 |   }
202 | }
203 | 
204 | /// <summary>
205 | /// Driver for an ItemList control.
206 | /// </summary>
207 | public sealed class ItemListDriver : ItemListDriver<ItemList>
208 | {
209 |   /// <summary>
210 |   /// Creates a new ItemListDriver.
211 |   /// </summary>
212 |   /// <param name="producer">Producer that creates a ItemList subclass.</param>
213 |   /// <param name="description">Driver description.</param>
214 |   public ItemListDriver(Func<ItemList> producer, string description = "")
215 |     : base(producer, description)
216 |   {
217 |   }
218 | }
219 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Input/ControllerInputExtensions.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Input;
  2 | 
  3 | using System.Threading.Tasks;
  4 | using Chickensoft.GodotTestDriver.Util;
  5 | using Godot;
  6 | 
  7 | /// <summary>
  8 | /// Extensions for simulating controller inputs.
  9 | /// </summary>
 10 | /// <seealso cref="ActionsInputExtensions"/>
 11 | public static class ControllerInputExtensions
 12 | {
 13 |   /// <summary>
 14 |   /// Holds a controller axis at a given position for a given period of time
 15 |   /// before releasing it, causing <see cref="InputEventJoypadMotion"/> events
 16 |   /// to fire at an appropriate interval.
 17 |   /// </summary>
 18 |   /// <remarks>
 19 |   /// Does not affect the values of
 20 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/>,
 21 |   /// <see cref="Input.GetJoyAxis(int, JoyAxis)"/>, or
 22 |   /// <see cref="Input.GetActionStrength(StringName, bool)"/>.
 23 |   /// </remarks>
 24 |   /// <param name="node">Node that generates simulated input.</param>
 25 |   /// <param name="seconds">Input duration, in seconds.</param>
 26 |   /// <param name="axis">The controller axis to set.</param>
 27 |   /// <param name="axisValue">
 28 |   /// The axis position, in the range -1.0f to 1.0f.
 29 |   /// </param>
 30 |   /// <param name="device">Input device that is the source of the event.</param>
 31 |   /// <returns>
 32 |   /// Asynchronous task completed when the button is released.
 33 |   /// </returns>
 34 |   /// <seealso cref="MoveJoypadAxisTo(Node, JoyAxis, float, int)"/>
 35 |   public static async Task HoldJoypadAxisFor(
 36 |     this Node node,
 37 |     float seconds,
 38 |     JoyAxis axis,
 39 |     float axisValue,
 40 |     int device = 0
 41 |   )
 42 |   {
 43 |     node.MoveJoypadAxisTo(axis, axisValue, device);
 44 |     await node.Wait(seconds);
 45 |     node.ReleaseJoypadAxis(axis, device);
 46 |   }
 47 | 
 48 |   /// <summary>
 49 |   /// Holds a controller button down for a given period of time before releasing
 50 |   /// it, causing <see cref="InputEventJoypadButton"/> events to fire at an
 51 |   /// appropriate interval.
 52 |   /// </summary>
 53 |   /// <remarks>
 54 |   /// Does not affect the value of
 55 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/> or
 56 |   /// <see cref="Input.IsJoyButtonPressed(int, JoyButton)"/>.
 57 |   /// </remarks>
 58 |   /// <param name="node">Node that generates simulated input.</param>
 59 |   /// <param name="seconds">Input duration, in seconds.</param>
 60 |   /// <param name="buttonIndex">Button that will be pressed.</param>
 61 |   /// <param name="device">Input device that is the source of the event.</param>
 62 |   /// <returns>
 63 |   /// Asynchronous task completed when the button is released.
 64 |   /// </returns>
 65 |   public static async Task HoldJoypadButtonFor(
 66 |     this Node node,
 67 |     float seconds,
 68 |     JoyButton buttonIndex,
 69 |     int device = 0
 70 |   )
 71 |   {
 72 |     node.PressJoypadButton(buttonIndex, device);
 73 |     await node.Wait(seconds);
 74 |     node.ReleaseJoypadButton(buttonIndex, device);
 75 |   }
 76 | 
 77 |   /// <summary>
 78 |   /// Presses and releases a controller button, causing
 79 |   /// <see cref="InputEventJoypadButton"/> events to fire.
 80 |   /// </summary>
 81 |   /// <remarks>
 82 |   /// Does not affect the value of
 83 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/> or
 84 |   /// <see cref="Input.IsJoyButtonPressed(int, JoyButton)"/>.
 85 |   /// </remarks>
 86 |   /// <param name="node">Node that generates simulated input.</param>
 87 |   /// <param name="buttonIndex">Button that will be pressed.</param>
 88 |   /// <param name="device">Input device that is the source of the event.</param>
 89 |   public static void TapJoypadButton(
 90 |     this Node node,
 91 |     JoyButton buttonIndex,
 92 |     int device = 0
 93 |   )
 94 |   {
 95 |     node.PressJoypadButton(buttonIndex, device);
 96 |     node.ReleaseJoypadButton(buttonIndex, device);
 97 |   }
 98 | 
 99 |   /// <summary>
100 |   /// Set a controller axis to a given position, causing a
101 |   /// <see cref="InputEventJoypadMotion"/> to fire.
102 |   /// </summary>
103 |   /// <remarks>
104 |   /// Although the full valid range of <paramref name="axisValue"/> is -1.0f to
105 |   /// 1.0f, some controller axes (e.g., gamepad triggers) only generate values
106 |   /// between 0.0f and 1.0f. Does not affect the values of
107 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/>,
108 |   /// <see cref="Input.GetJoyAxis(int, JoyAxis)"/>, or
109 |   /// <see cref="Input.GetActionStrength(StringName, bool)"/>.
110 |   /// </remarks>
111 |   /// <param name="_">Node that generates simulated input.</param>
112 |   /// <param name="axis">The controller axis to set.</param>
113 |   /// <param name="axisValue">
114 |   /// The axis position, in the range -1.0f to 1.0f.
115 |   /// </param>
116 |   /// <param name="device">Input device that is the source of the event.</param>
117 |   public static void MoveJoypadAxisTo(
118 |     this Node _,
119 |     JoyAxis axis,
120 |     float axisValue,
121 |     int device = 0
122 |   )
123 |   {
124 |     var inputEvent = new InputEventJoypadMotion
125 |     {
126 |       Axis = axis,
127 |       AxisValue = axisValue,
128 |       Device = device
129 |     };
130 |     Input.ParseInputEvent(inputEvent);
131 |     Input.FlushBufferedEvents();
132 |   }
133 | 
134 |   /// <summary>
135 |   /// Release a controller axis, setting it to its rest position, causing a
136 |   /// <see cref="InputEventJoypadMotion"/> to fire.
137 |   /// </summary>
138 |   /// <remarks>
139 |   /// Equivalent to <c>node.MoveJoypadAxisTo(axis, 0.0f, device)</c>. Does not
140 |   /// affect the values of
141 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/>,
142 |   /// <see cref="Input.GetJoyAxis(int, JoyAxis)"/>, or
143 |   /// <see cref="Input.GetActionStrength(StringName, bool)"/>.
144 |   /// </remarks>
145 |   /// <param name="node">Node that generates simulated input.</param>
146 |   /// <param name="axis">The controller axis to release.</param>
147 |   /// <param name="device">Input device that is the source of the event.</param>
148 |   /// <seealso cref="MoveJoypadAxisTo(Node, JoyAxis, float, int)"/>
149 |   public static void ReleaseJoypadAxis(
150 |     this Node node,
151 |     JoyAxis axis,
152 |     int device = 0
153 |   ) =>
154 |     node.MoveJoypadAxisTo(axis, 0.0f, device);
155 | 
156 |   /// <summary>
157 |   /// Presses a controller button, causing an
158 |   /// <see cref="InputEventJoypadButton"/> to fire.
159 |   /// </summary>
160 |   /// <remarks>
161 |   /// Does not affect the values of
162 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/> or
163 |   /// <see cref="Input.IsJoyButtonPressed(int, JoyButton)"/>.
164 |   /// </remarks>
165 |   /// <param name="_">Node that generates simulated input.</param>
166 |   /// <param name="buttonIndex">Button that will be pressed.</param>
167 |   /// <param name="device">Input device that is the source of the event.</param>
168 |   public static void PressJoypadButton(
169 |     this Node _,
170 |     JoyButton buttonIndex,
171 |     int device = 0
172 |   )
173 |   {
174 |     var inputEvent = new InputEventJoypadButton
175 |     {
176 |       Pressed = true,
177 |       ButtonIndex = buttonIndex,
178 |       Device = device
179 |     };
180 |     Input.ParseInputEvent(inputEvent);
181 |     Input.FlushBufferedEvents();
182 |   }
183 | 
184 |   /// <summary>
185 |   /// Releases a controller button, causing an
186 |   /// <see cref="InputEventJoypadButton"/> to fire.
187 |   /// </summary>
188 |   /// <remarks>
189 |   /// Does not affect the values of
190 |   /// <see cref="Input.IsActionPressed(StringName, bool)"/> or
191 |   /// <see cref="Input.IsJoyButtonPressed(int, JoyButton)"/>.
192 |   /// </remarks>
193 |   /// <param name="_">Node that generates simulated input.</param>
194 |   /// <param name="buttonIndex">Button that will be released.</param>
195 |   /// <param name="device">Input device that is the source of the event.</param>
196 |   public static void ReleaseJoypadButton(
197 |     this Node _,
198 |     JoyButton buttonIndex,
199 |     int device = 0
200 |   )
201 |   {
202 |     var inputEvent = new InputEventJoypadButton
203 |     {
204 |       Pressed = false,
205 |       ButtonIndex = buttonIndex,
206 |       Device = device
207 |     };
208 |     Input.ParseInputEvent(inputEvent);
209 |     Input.FlushBufferedEvents();
210 |   }
211 | }
212 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/PopupMenuDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using Godot;
  6 | 
  7 | /// <summary>
  8 | /// Driver for a popup menu.
  9 | /// </summary>
 10 | /// <typeparam name="T">PopupMenu type.</typeparam>
 11 | public class PopupMenuDriver<T> : WindowDriver<T> where T : PopupMenu
 12 | {
 13 |   /// <summary>
 14 |   /// Creates a new generic PopupMenuDriver.
 15 |   /// </summary>
 16 |   /// <param name="producer">Producer that creates a PopupMenu subclass.</param>
 17 |   /// <param name="description">Driver description.</param>
 18 |   public PopupMenuDriver(Func<T> producer, string description = "")
 19 |     : base(producer, description)
 20 |   {
 21 |   }
 22 | 
 23 |   /// <summary>
 24 |   /// Returns the amount of items in the popup menu.
 25 |   /// </summary>
 26 |   public int ItemCount => PresentRoot.ItemCount;
 27 | 
 28 |   /// <summary>
 29 |   /// Returns the text of the items in the popup menu.
 30 |   /// </summary>
 31 |   public IEnumerable<string> Items
 32 |   {
 33 |     get
 34 |     {
 35 |       for (var i = 0; i < ItemCount; i++)
 36 |       {
 37 |         yield return PresentRoot.GetItemText(i);
 38 |       }
 39 |     }
 40 |   }
 41 | 
 42 |   /// <summary>
 43 |   /// Returns the text of the items in the popup menu which are currently
 44 |   /// selectable (e.g. not disabled and no separator).
 45 |   /// </summary>
 46 |   public IEnumerable<string> SelectableItems
 47 |   {
 48 |     get
 49 |     {
 50 |       for (var i = 0; i < ItemCount; i++)
 51 |       {
 52 |         if (PresentRoot.IsItemDisabled(i) || PresentRoot.IsItemSeparator(i))
 53 |         {
 54 |           continue;
 55 |         }
 56 |         yield return PresentRoot.GetItemText(i);
 57 |       }
 58 |     }
 59 |   }
 60 | 
 61 |   /// <summary>
 62 |   /// Returns whether the item at the given index is checked.
 63 |   /// </summary>
 64 |   /// <param name="index">Menu item index.</param>
 65 |   public bool IsItemChecked(int index)
 66 |   {
 67 |     VerifyIndex(index);
 68 |     return PresentRoot.IsItemChecked(index);
 69 |   }
 70 | 
 71 |   /// <summary>
 72 |   /// Returns whether the item with the given text is checked.
 73 |   /// </summary>
 74 |   /// <param name="text">Menu item label.</param>
 75 |   /// <exception cref="InvalidOperationException"/>
 76 |   public bool IsItemChecked(string text)
 77 |   {
 78 |     var element = PresentRoot;
 79 | 
 80 |     for (var i = 0; i < element.ItemCount; i++)
 81 |     {
 82 |       if (element.GetItemText(i) == text)
 83 |       {
 84 |         return element.IsItemChecked(i);
 85 |       }
 86 |     }
 87 | 
 88 |     throw new InvalidOperationException($"Item with text '{text}' not found.");
 89 |   }
 90 | 
 91 |   /// <summary>
 92 |   /// Returns whether the item at the given index is disabled.
 93 |   /// </summary>
 94 |   /// <param name="index">Menu item index.</param>
 95 |   public bool IsItemDisabled(int index)
 96 |   {
 97 |     VerifyIndex(index);
 98 |     return PresentRoot.IsItemDisabled(index);
 99 |   }
100 | 
101 |   /// <summary>
102 |   /// Checks if the item with the given text is disabled.
103 |   /// </summary>
104 |   /// <param name="text">Menu item label.</param>
105 |   /// <exception cref="InvalidOperationException"/>
106 |   public bool IsItemDisabled(string text)
107 |   {
108 |     var element = PresentRoot;
109 | 
110 |     for (var i = 0; i < element.ItemCount; i++)
111 |     {
112 |       if (element.GetItemText(i) == text)
113 |       {
114 |         return element.IsItemDisabled(i);
115 |       }
116 |     }
117 | 
118 |     throw new InvalidOperationException($"Item with text '{text}' not found.");
119 |   }
120 | 
121 |   /// <summary>
122 |   /// Returns whether the item at the given index is a separator.
123 |   /// </summary>
124 |   /// <param name="index">Menu item index.</param>
125 |   public bool IsItemSeparator(int index)
126 |   {
127 |     VerifyIndex(index);
128 |     return PresentRoot.IsItemSeparator(index);
129 |   }
130 | 
131 |   /// <summary>
132 |   /// Returns whether the item with the given text is a separator.
133 |   /// </summary>
134 |   /// <param name="text">Menu item label.</param>
135 |   /// <exception cref="InvalidOperationException"/>
136 |   public bool IsItemSeparator(string text)
137 |   {
138 |     var element = PresentRoot;
139 | 
140 |     for (var i = 0; i < element.ItemCount; i++)
141 |     {
142 |       if (element.GetItemText(i) == text)
143 |       {
144 |         return element.IsItemSeparator(i);
145 |       }
146 |     }
147 | 
148 |     throw new InvalidOperationException($"Item with text {text} not found.");
149 |   }
150 | 
151 |   /// <summary>
152 |   /// Returns the ID of the item at the given index.
153 |   /// </summary>
154 |   /// <param name="index">Menu item index.</param>
155 |   public int GetItemId(int index)
156 |   {
157 |     VerifyIndex(index);
158 |     return PresentRoot.GetItemId(index);
159 |   }
160 | 
161 |   /// <summary>
162 |   /// Selects the item at the given index.
163 |   /// </summary>
164 |   /// <param name="index">Menu item index.</param>
165 |   /// <exception cref="InvalidOperationException"/>
166 |   public void SelectItemAtIndex(int index)
167 |   {
168 |     var popup = VisibleRoot;
169 |     VerifyIndex(index);
170 | 
171 |     // verify that item is not disabled
172 |     if (popup.IsItemDisabled(index))
173 |     {
174 |       throw new InvalidOperationException(
175 |           $"Item at index {index} is disabled and cannot be selected.");
176 |     }
177 | 
178 |     // verify that item is not a separator
179 |     if (popup.IsItemSeparator(index))
180 |     {
181 |       throw new InvalidOperationException(
182 |           $"Item at index {index} is a separator and cannot be selected.");
183 |     }
184 | 
185 |     // select item
186 |     // ideally we would use a mouse click here but since the API does not
187 |     // provide the position of each entry, we have to fake it.
188 |     popup.EmitSignal(PopupMenu.SignalName.IndexPressed, index);
189 |     popup.Hide();
190 |   }
191 | 
192 |   /// <summary>
193 |   /// Verifies that the given index is valid.
194 |   /// </summary>
195 |   /// <param name="index">Menu item index.</param>
196 |   /// <exception cref="IndexOutOfRangeException"/>
197 |   private void VerifyIndex(int index)
198 |   {
199 |     // verify index is in range
200 |     if (index < 0 || index >= ItemCount)
201 |     {
202 |       throw new ArgumentOutOfRangeException(
203 |         nameof(index),
204 |         $"Index {index} is out of range for popup menu with {ItemCount} items."
205 |       );
206 |     }
207 |   }
208 | 
209 |   /// <summary>
210 |   /// Selects the item with the given ID.
211 |   /// </summary>
212 |   /// <param name="id">Menu item id.</param>
213 |   /// <exception cref="InvalidOperationException" />
214 |   public void SelectItemWithId(int id)
215 |   {
216 |     var popup = PresentRoot;
217 |     for (var i = 0; i < ItemCount; i++)
218 |     {
219 |       if (popup.GetItemId(i) != id)
220 |       {
221 |         continue;
222 |       }
223 |       SelectItemAtIndex(i);
224 |       return;
225 |     }
226 | 
227 |     throw new InvalidOperationException(
228 |         $"No item with id {id} found in popup menu.");
229 |   }
230 | 
231 |   /// <summary>
232 |   /// Selects the item with the given text. If multiple items have the same
233 |   /// text, the first one is selected.
234 |   /// </summary>
235 |   /// <param name="text">Menu item label.</param>
236 |   /// <exception cref="InvalidOperationException"/>
237 |   public void SelectItemWithText(string text)
238 |   {
239 |     var popup = PresentRoot;
240 |     for (var i = 0; i < ItemCount; i++)
241 |     {
242 |       if (popup.GetItemText(i) != text)
243 |       {
244 |         continue;
245 |       }
246 |       SelectItemAtIndex(i);
247 |       return;
248 |     }
249 | 
250 |     throw new InvalidOperationException(
251 |         $"No item with text {text} found in popup menu.");
252 |   }
253 | }
254 | 
255 | /// <summary>
256 | /// Driver for a popup menu.
257 | /// </summary>
258 | public sealed class PopupMenuDriver : PopupMenuDriver<PopupMenu>
259 | {
260 |   /// <summary>
261 |   /// Creates a new generic PopupMenuDriver.
262 |   /// </summary>
263 |   /// <param name="producer">Producer that creates a PopupMenu subclass.</param>
264 |   /// <param name="description">Driver description.</param>
265 |   public PopupMenuDriver(Func<PopupMenu> producer, string description = "")
266 |     : base(producer, description)
267 |   {
268 |   }
269 | }
270 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver.Tests/test/src/Input/ControllerInputExtensionsTest.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Tests.Input;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Threading.Tasks;
  6 | using Chickensoft.GoDotTest;
  7 | using Chickensoft.GodotTestDriver.Input;
  8 | using Godot;
  9 | using Shouldly;
 10 | 
 11 | public partial class ControllerInputExtensionsTest : InputTest
 12 | {
 13 |   private sealed class TimedButtonEvent
 14 |   {
 15 |     public ulong ProcessFrame { get; set; }
 16 |     public DateTime DateTime { get; set; }
 17 |     public InputEventJoypadButton Event { get; set; }
 18 | 
 19 |     public TimedButtonEvent(ulong processFrame, DateTime dateTime, InputEventJoypadButton @event)
 20 |     {
 21 |       ProcessFrame = processFrame;
 22 |       DateTime = dateTime;
 23 |       Event = @event;
 24 |     }
 25 |   }
 26 | 
 27 |   private sealed partial class JoypadButtonInputEventTestNode : Node
 28 |   {
 29 |     public IList<TimedButtonEvent> Events { get; } = [];
 30 | 
 31 |     public override void _Input(InputEvent @event)
 32 |     {
 33 |       if (@event is InputEventJoypadButton buttonEvent)
 34 |       {
 35 |         var frame = Engine.GetProcessFrames();
 36 |         var time = DateTime.Now;
 37 |         Events.Add(new TimedButtonEvent(frame, time, buttonEvent));
 38 |       }
 39 |     }
 40 |   }
 41 | 
 42 |   private sealed class TimedMotionEvent
 43 |   {
 44 |     public DateTime DateTime { get; set; }
 45 |     public InputEventJoypadMotion Event { get; set; }
 46 | 
 47 |     public TimedMotionEvent(DateTime dateTime, InputEventJoypadMotion @event)
 48 |     {
 49 |       DateTime = dateTime;
 50 |       Event = @event;
 51 |     }
 52 |   }
 53 | 
 54 |   private sealed partial class JoypadMotionInputEventTestNode : Node
 55 |   {
 56 |     public IList<TimedMotionEvent> Events { get; } = [];
 57 | 
 58 |     public override void _Input(InputEvent @event)
 59 |     {
 60 |       if (@event is InputEventJoypadMotion buttonEvent)
 61 |       {
 62 |         var time = DateTime.Now;
 63 |         Events.Add(new TimedMotionEvent(time, buttonEvent));
 64 |       }
 65 |     }
 66 |   }
 67 | 
 68 |   public ControllerInputExtensionsTest(Node testScene) : base(testScene)
 69 |   {
 70 |   }
 71 | 
 72 |   [Test]
 73 |   public void PressJoypadButtonFiresInputEvent()
 74 |   {
 75 |     var testNode = new JoypadButtonInputEventTestNode();
 76 |     RootNode.AddChild(testNode);
 77 |     testNode.Events.Count.ShouldBe(0);
 78 |     // Press controller device 1's X button.
 79 |     var button = JoyButton.X;
 80 |     var deviceID = 1;
 81 |     testNode.PressJoypadButton(button, deviceID);
 82 |     testNode.Events.Count.ShouldBe(1);
 83 |     testNode.Events[0].Event.Pressed.ShouldBeTrue();
 84 |     testNode.Events[0].Event.ButtonIndex.ShouldBe(button);
 85 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
 86 |     // Remove immediately since we won't wait a frame for the free
 87 |     RootNode.RemoveChild(testNode);
 88 |     testNode.QueueFree();
 89 |   }
 90 | 
 91 |   [Test]
 92 |   public void ReleaseJoypadButtonFiresInputEvent()
 93 |   {
 94 |     var testNode = new JoypadButtonInputEventTestNode();
 95 |     RootNode.AddChild(testNode);
 96 |     testNode.Events.Count.ShouldBe(0);
 97 |     // Release controller device 1's X button.
 98 |     var button = JoyButton.X;
 99 |     var deviceID = 1;
100 |     testNode.ReleaseJoypadButton(button, deviceID);
101 |     testNode.Events.Count.ShouldBe(1);
102 |     testNode.Events[0].Event.Pressed.ShouldBeFalse();
103 |     testNode.Events[0].Event.ButtonIndex.ShouldBe(button);
104 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
105 |     // Remove immediately since we won't wait a frame for the free
106 |     RootNode.RemoveChild(testNode);
107 |     testNode.QueueFree();
108 |   }
109 | 
110 |   [Test]
111 |   public void TapJoypadButtonFiresInputEvents()
112 |   {
113 |     var testNode = new JoypadButtonInputEventTestNode();
114 |     RootNode.AddChild(testNode);
115 |     testNode.Events.Count.ShouldBe(0);
116 |     // Tap controller device 1's X button.
117 |     var button = JoyButton.X;
118 |     var deviceID = 1;
119 |     testNode.TapJoypadButton(button, deviceID);
120 |     testNode.Events.Count.ShouldBe(2);
121 |     testNode.Events[0].Event.Pressed.ShouldBeTrue();
122 |     testNode.Events[0].Event.ButtonIndex.ShouldBe(button);
123 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
124 |     testNode.Events[1].Event.Pressed.ShouldBeFalse();
125 |     testNode.Events[1].Event.ButtonIndex.ShouldBe(button);
126 |     testNode.Events[1].Event.Device.ShouldBe(deviceID);
127 |     testNode.Events[1].ProcessFrame.ShouldBe(testNode.Events[0].ProcessFrame);
128 |     // Remove immediately since we won't wait a frame for the free
129 |     RootNode.RemoveChild(testNode);
130 |     testNode.QueueFree();
131 |   }
132 | 
133 |   [Test]
134 |   public async Task HoldJoypadButtonFiresInputEvents()
135 |   {
136 |     var testNode = new JoypadButtonInputEventTestNode();
137 |     RootNode.AddChild(testNode);
138 |     testNode.Events.Count.ShouldBe(0);
139 |     // Hold controller device 1's X button for 2 seconds.
140 |     var button = JoyButton.X;
141 |     var deviceID = 1;
142 |     var seconds = 0.5f;
143 |     var timeTolerance = 0.1f;
144 |     await testNode.HoldJoypadButtonFor(seconds, button, deviceID);
145 |     testNode.Events.Count.ShouldBe(2);
146 |     testNode.Events[0].Event.Pressed.ShouldBeTrue();
147 |     testNode.Events[0].Event.ButtonIndex.ShouldBe(button);
148 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
149 |     testNode.Events[1].Event.Pressed.ShouldBeFalse();
150 |     testNode.Events[1].Event.ButtonIndex.ShouldBe(button);
151 |     testNode.Events[1].Event.Device.ShouldBe(deviceID);
152 |     var timeDiff = testNode.Events[1].DateTime - testNode.Events[0].DateTime;
153 |     timeDiff.TotalSeconds.ShouldBe(seconds, timeTolerance);
154 |     // Remove immediately since we won't wait a frame for the free
155 |     RootNode.RemoveChild(testNode);
156 |     testNode.QueueFree();
157 |   }
158 | 
159 |   [Test]
160 |   public void MoveJoypadAxisFiresInputEvent()
161 |   {
162 |     var testNode = new JoypadMotionInputEventTestNode();
163 |     RootNode.AddChild(testNode);
164 |     testNode.Events.Count.ShouldBe(0);
165 |     // Move controller device 1's right-thumbstick x-axis to the -0.3 position
166 |     // (about 1/3 left stick).
167 |     var axis = JoyAxis.RightX;
168 |     var deviceID = 1;
169 |     var position = -0.3f;
170 |     testNode.MoveJoypadAxisTo(axis, position, deviceID);
171 |     testNode.Events.Count.ShouldBe(1);
172 |     testNode.Events[0].Event.Axis.ShouldBe(axis);
173 |     testNode.Events[0].Event.AxisValue.ShouldBe(position);
174 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
175 |     RootNode.RemoveChild(testNode);
176 |     testNode.QueueFree();
177 |   }
178 | 
179 |   [Test]
180 |   public void ReleaseJoypadAxisFiresInputEvent()
181 |   {
182 |     var testNode = new JoypadMotionInputEventTestNode();
183 |     RootNode.AddChild(testNode);
184 |     testNode.Events.Count.ShouldBe(0);
185 |     // Move controller device 1's right-thumbstick x-axis to the rest position.
186 |     var axis = JoyAxis.RightX;
187 |     var deviceID = 1;
188 |     testNode.ReleaseJoypadAxis(axis, deviceID);
189 |     testNode.Events.Count.ShouldBe(1);
190 |     testNode.Events[0].Event.Axis.ShouldBe(axis);
191 |     testNode.Events[0].Event.AxisValue.ShouldBe(0.0f);
192 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
193 |     RootNode.RemoveChild(testNode);
194 |     testNode.QueueFree();
195 |   }
196 | 
197 |   [Test]
198 |   public async Task HoldJoypadAxisFiresInputEvents()
199 |   {
200 |     var testNode = new JoypadMotionInputEventTestNode();
201 |     RootNode.AddChild(testNode);
202 |     testNode.Events.Count.ShouldBe(0);
203 |     // Move controller device 1's right-thumbstick x-axis to the rest position.
204 |     var axis = JoyAxis.RightX;
205 |     var deviceID = 1;
206 |     var position = -0.3f;
207 |     var seconds = 0.5f;
208 |     var timeTolerance = 0.1f;
209 |     await testNode.HoldJoypadAxisFor(seconds, axis, position, deviceID);
210 |     testNode.Events.Count.ShouldBe(2);
211 |     testNode.Events[0].Event.Axis.ShouldBe(axis);
212 |     testNode.Events[0].Event.AxisValue.ShouldBe(position);
213 |     testNode.Events[0].Event.Device.ShouldBe(deviceID);
214 |     testNode.Events[1].Event.Axis.ShouldBe(axis);
215 |     testNode.Events[1].Event.AxisValue.ShouldBe(0.0f);
216 |     testNode.Events[1].Event.Device.ShouldBe(deviceID);
217 |     var timeDiff = testNode.Events[1].DateTime - testNode.Events[0].DateTime;
218 |     timeDiff.TotalSeconds.ShouldBe(seconds, timeTolerance);
219 |     RootNode.RemoveChild(testNode);
220 |     testNode.QueueFree();
221 |   }
222 | }
223 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/Fixture.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver;
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.IO;
  6 | using System.Reflection;
  7 | using System.Threading.Tasks;
  8 | using Godot;
  9 | using GodotTestDriver.Util;
 10 | using Object = Godot.GodotObject;
 11 | 
 12 | /// <summary>
 13 | /// This is a test fixture that can be use to manage nodes in the test scene. It
 14 | /// ensures that modifications to the scene are always executed in the main
 15 | /// thread. It also provides a simple means of cleaning up the scene after each
 16 | /// test.
 17 | /// </summary>
 18 | public class Fixture
 19 | {
 20 |   private readonly List<Func<Task>> _cleanupSteps = [];
 21 | 
 22 |   /// <summary>
 23 |   /// The <see cref="SceneTree"/> that this fixture is managing.
 24 |   /// </summary>
 25 |   public SceneTree Tree { get; }
 26 | 
 27 |   /// <summary>
 28 |   /// Create a new fixture for use with a scene tree.
 29 |   /// </summary>
 30 |   /// <param name="tree">Godot scene tree.</param>
 31 |   public Fixture(SceneTree tree)
 32 |   {
 33 |     Tree = tree;
 34 |   }
 35 | 
 36 |   /// <summary>
 37 |   /// Adds a node to the root of the tree. When this call returns the node will
 38 |   /// be in the scene and its <see cref="Node._Ready"/> function will have been
 39 |   /// called by Godot.
 40 |   /// </summary>
 41 |   /// <typeparam name="T">Scene's root node type.</typeparam>
 42 |   /// <param name="node">Node to be added to the tree root</param>
 43 |   /// <param name="autoRemoveFromRoot">
 44 |   /// If true, the node will be automatically removed from the root, when
 45 |   /// fixture's <see cref="Cleanup" /> method is called. Note that it will _not_
 46 |   /// be freed.
 47 |   /// </param>
 48 |   public async Task<T> AddToRoot<T>(T node, bool autoRemoveFromRoot = true)
 49 |     where T : Node
 50 |   {
 51 |     Tree.Root.AddChild(node);
 52 | 
 53 |     if (autoRemoveFromRoot)
 54 |     {
 55 |       AddCleanupStep(() =>
 56 |       {
 57 |         if
 58 |         (
 59 |           Object.IsInstanceValid(node) &&
 60 |           Object.IsInstanceValid(node.GetParent())
 61 |         )
 62 |         {
 63 |           node.GetParent().RemoveChild(node);
 64 |         }
 65 |       });
 66 |     }
 67 | 
 68 |     await Tree.NextFrame(); // make sure _Ready is called.
 69 |     return node;
 70 |   }
 71 | 
 72 |   /// <summary>
 73 |   /// Loads a scene from the given path and adds it to the root of the tree.
 74 |   /// </summary>
 75 |   /// <typeparam name="T">Scene's root node type.</typeparam>
 76 |   /// <param name="path">Path to the scene file that should be loaded</param>
 77 |   /// <param name="autoFree">
 78 |   /// If true, the instance will be automatically freed when the fixture's
 79 |   /// <see cref="Cleanup" /> method is called
 80 |   /// </param>
 81 |   /// <param name="autoRemoveFromRoot">
 82 |   /// If true, the scene  will be automatically removed from the root, when
 83 |   /// fixture's <see cref="Cleanup" /> method is called. Note that it will _not_
 84 |   /// be freed automatically unless <paramref name="autoFree"/> is also true.
 85 |   /// </param>
 86 |   public async Task<T> LoadAndAddScene<T>(
 87 |     string path,
 88 |     bool autoFree = true,
 89 |     bool autoRemoveFromRoot = true
 90 |   )
 91 |     where T : Node
 92 |   {
 93 |     var instance = LoadScene<T>(path, autoFree);
 94 |     return await AddToRoot(instance, !autoFree && autoRemoveFromRoot);
 95 |   }
 96 | 
 97 |   /// <summary>
 98 |   /// Loads and instantiates the scene that corresponds to the given script type
 99 |   /// ands adds it to the root of the tree.
100 |   /// </summary>
101 |   /// <typeparam name="T">Scene's root node type.</typeparam>
102 |   /// <param name="autoFree">
103 |   /// If true, the instance will be automatically freed when the fixture's
104 |   /// <see cref="Cleanup" /> method is called.
105 |   /// </param>
106 |   /// <param name="autoRemoveFromRoot">
107 |   /// If true, the scene  will be automatically removed from the root, when
108 |   /// fixture's <see cref="Cleanup" /> method is called. Note that it will _not_
109 |   /// be freed automatically unless <paramref name="autoFree"/> is also true.
110 |   /// </param>
111 |   public async Task<T> LoadAndAddScene<T>(
112 |     bool autoFree = true,
113 |     bool autoRemoveFromRoot = true
114 |   )
115 |     where T : Node
116 |   {
117 |     var instance = LoadScene<T>(autoFree);
118 |     return await AddToRoot(instance, !autoFree && autoRemoveFromRoot);
119 |   }
120 | 
121 |   /// <summary>
122 |   /// Loads and instantiates the scene that corresponds to the given script
123 |   /// type. The scene must be in the same directory, have the same name, and end
124 |   /// with ".tscn".
125 |   /// </summary>
126 |   /// <param name="autoFree">
127 |   /// If true, the instance will be automatically freed when the fixture's
128 |   /// <see cref="Cleanup" /> method is called.
129 |   /// </param>
130 |   /// <typeparam name="T">Script type attached to the scene.</typeparam>
131 |   /// <returns>Instantiated scene.</returns>
132 |   /// <exception cref="InvalidOperationException">
133 |   /// Thrown when type does not have a <see cref="ScriptPathAttribute" />.
134 |   /// </exception>
135 |   public T LoadScene<T>(bool autoFree = true) where T : Node
136 |   {
137 |     // get script path given to a class by the Godot source generators.
138 |     var attr = typeof(T).GetCustomAttribute<ScriptPathAttribute>()
139 |         ?? throw new InvalidOperationException(
140 |             $"Type '{typeof(T)}' does not have a ScriptPathAttribute"
141 |         );
142 |     var path = Path.ChangeExtension(attr.Path, ".tscn");
143 |     return LoadScene<T>(path, autoFree);
144 |   }
145 | 
146 |   /// <summary>
147 |   /// Loads a scene from the given path and instantiates it but does not add it
148 |   /// to the tree.
149 |   /// </summary>
150 |   /// <typeparam name="T">Scene's root node type.</typeparam>
151 |   /// <param name="path">Path to the .tscn scene file.</param>
152 |   /// <param name="autoFree">
153 |   /// If true, the instance will be automatically freed when the fixture's
154 |   /// <see cref="Cleanup" /> method is called.
155 |   /// </param>
156 |   /// <exception cref="ArgumentException"></exception>
157 |   public T LoadScene<T>(string path, bool autoFree = true) where T : Node
158 |   {
159 |     var scene = GD.Load<PackedScene>(path);
160 |     if (!Object.IsInstanceValid(scene))
161 |     {
162 |       throw new ArgumentException(
163 |         $"Could not load scene from path, it very likely does not exist: {path}"
164 |       );
165 |     }
166 | 
167 |     var node = scene.Instantiate();
168 | 
169 |     if (node is not T instance)
170 |     {
171 |       throw new ArgumentException(
172 |         $"The root node of the scene is not of the expected type: {typeof(T).FullName}"
173 |       );
174 |     }
175 | 
176 |     return autoFree ? AutoFree(instance) : instance;
177 |   }
178 | 
179 |   /// <summary>
180 |   /// Schedules the given object to be automatically freed when this fixture is
181 |   /// cleaned up. Returns the object that was given to it so this call can be
182 |   /// nicely chained.
183 |   /// </summary>
184 |   /// <typeparam name="T">Scene's root node type.</typeparam>
185 |   /// <param name="toFree">Godot object to automatically free.</param>
186 |   public T AutoFree<T>(T toFree) where T : Object
187 |   {
188 |     // References are automatically freed, so calling AutoFree on references is
189 |     // wrong.
190 |     if (toFree is RefCounted)
191 |     {
192 |       Log.Error(
193 |         "Trying to auto-free an object that extends RefCounted. I will ignore this but you should probably not do this."
194 |       );
195 |       return toFree;
196 |     }
197 | 
198 |     AddCleanupStep(() =>
199 |     {
200 |       // it can happen that a node is already freed when the auto-free is
201 |       // running because the test freed it, or a parent node was freed.
202 |       if (!Object.IsInstanceValid(toFree))
203 |       {
204 |         return;
205 |       }
206 | 
207 |       if (toFree is Node node)
208 |       {
209 |         // if the node has a valid parent, remove it from the parent first
210 |         if (Object.IsInstanceValid(node.GetParent()))
211 |         {
212 |           node.GetParent().RemoveChild(node);
213 |         }
214 |         // use QueueFree for nodes to ensure it is safe to free them.
215 |         node.QueueFree();
216 |       }
217 |       else
218 |       {
219 |         // normal objects can be freed directly.
220 |         toFree.Free();
221 |       }
222 |     });
223 |     return toFree;
224 |   }
225 | 
226 |   /// <summary>
227 |   /// Runs all accumulated cleanup steps. Cleanup steps are run in reverse order
228 |   /// in which they were added (i.e., last added is first run).
229 |   /// </summary>
230 |   public async Task Cleanup()
231 |   {
232 |     // ensure we run on the main thread.
233 |     await Tree.NextFrame();
234 | 
235 |     if (_cleanupSteps.Count > 0)
236 |     {
237 |       // run cleanup in reverse order, so inner cleanup is done first.
238 |       _cleanupSteps.Reverse();
239 | 
240 |       Log.Info($"Running {_cleanupSteps.Count} cleanup actions.");
241 |       // run all cleanup actions.
242 |       foreach (var action in _cleanupSteps)
243 |       {
244 |         await action();
245 |       }
246 | 
247 |       _cleanupSteps.Clear();
248 |     }
249 |   }
250 | 
251 |   /// <summary>
252 |   /// Allows to register an asynchronous cleanup action that runs when
253 |   /// <see cref="Cleanup"/> is called.
254 |   /// </summary>
255 |   /// <param name="action">Action to automatically execute.</param>
256 |   protected void AddCleanupStep(Func<Task> action) => _cleanupSteps.Add(action);
257 | 
258 |   /// <summary>
259 |   /// Allows to register a synchronous cleanup action that runs when
260 |   /// <see cref="Cleanup"/> is called
261 |   /// </summary>
262 |   /// <param name="action">Action to automatically execute.</param>
263 |   public void AddCleanupStep(Action action) =>
264 |     _cleanupSteps.Add(async () => action());
265 | }
266 | 


--------------------------------------------------------------------------------
/Chickensoft.GodotTestDriver/src/Drivers/GraphNodeDriver.cs:
--------------------------------------------------------------------------------
  1 | namespace Chickensoft.GodotTestDriver.Drivers;
  2 | 
  3 | using System;
  4 | using Godot;
  5 | using GodotTestDriver.Input;
  6 | 
  7 | /// <summary>
  8 | /// Driver for a <see cref="GraphNode"/>
  9 | /// </summary>
 10 | /// <typeparam name="T">GraphNode type.</typeparam>
 11 | public class GraphNodeDriver<T> : ControlDriver<T> where T : GraphNode
 12 | {
 13 |   /// <summary>
 14 |   /// Creates a new generic GraphNodeDriver.
 15 |   /// </summary>
 16 |   /// <param name="producer">Producer that creates a GraphNode subclass.</param>
 17 |   /// <param name="description">Driver description.</param>
 18 |   public GraphNodeDriver(Func<T> producer, string description = "")
 19 |     : base(producer, description)
 20 |   {
 21 |   }
 22 | 
 23 |   /// <summary>
 24 |   /// The title of the node.
 25 |   /// </summary>
 26 |   public string Title => PresentRoot.Title;
 27 | 
 28 |   /// <summary>
 29 |   /// The offset of the node inside the graph.
 30 |   /// </summary>
 31 |   public Vector2 Offset => PresentRoot.PositionOffset;
 32 | 
 33 |   /// <summary>
 34 |   /// The relative position and size of the node.
 35 |   /// </summary>
 36 |   public Rect2 Rect => PresentRoot.GetRect();
 37 | 
 38 |   /// <summary>
 39 |   /// Whether the node is currently selected.
 40 |   /// </summary>
 41 |   public bool Selected => PresentRoot.Selected;
 42 | 
 43 |   /// <summary>
 44 |   /// The amount of input ports the node has.
 45 |   /// </summary>
 46 |   public int InputPortCount => PresentRoot.GetInputPortCount();
 47 | 
 48 |   /// <summary>
 49 |   /// The amount of output ports the node has.
 50 |   /// </summary>
 51 |   public int OutputPortCount => PresentRoot.GetOutputPortCount();
 52 | 
 53 |   /// <summary>
 54 |   /// Returns the port type of the given port.
 55 |   /// </summary>
 56 |   /// <param name="port">Connection port.</param>
 57 |   /// <exception cref="ArgumentException" />
 58 |   public int GetPortType(Port port)
 59 |   {
 60 |     if (!port.IsDefined)
 61 |     {
 62 |       throw new ArgumentException("Port is not defined.");
 63 |     }
 64 | 
 65 |     if (port.IsInput)
 66 |     {
 67 |       if (InputPortCount < port.PortIndex)
 68 |       {
 69 |         throw new ArgumentException("Port index is out of range.");
 70 |       }
 71 |       return PresentRoot.GetInputPortType(port.PortIndex);
 72 |     }
 73 |     if (OutputPortCount < port.PortIndex)
 74 |     {
 75 |       throw new ArgumentException("Port index is out of range.");
 76 |     }
 77 | 
 78 |     return PresentRoot.GetOutputPortType(port.PortIndex);
 79 |   }
 80 | 
 81 |   /// <summary>
 82 |   /// Global position of a spot where the node can be safely clicked and
 83 |   /// dragged. Will fail if the node is not visible.
 84 |   /// </summary>
 85 |   protected virtual Vector2 SelectionSpot
 86 |   {
 87 |     get
 88 |     {
 89 |       var node = VisibleRoot;
 90 |       var rect = node.GetGlobalRect();
 91 |       // we assume a position 5 pixels below the top border, horizontally
 92 |       // centered, is a safe selection spot, as the node will have a title
 93 |       // there.
 94 |       return rect.Position + new Vector2(rect.Size.X / 2, 5);
 95 |     }
 96 |   }
 97 | 
 98 |   /// <summary>
 99 |   /// Drags the node by the given amount of pixels.
100 |   /// </summary>
101 |   /// <param name="delta">Change in distance.</param>
102 |   public void DragBy(Vector2 delta)
103 |   {
104 |     var dragStart = SelectionSpot;
105 |     var dragEnd = dragStart + delta;
106 | 
107 |     // drag it
108 |     Viewport.DragMouse(dragStart, dragEnd);
109 |   }
110 | 
111 |   /// <summary>
112 |   /// Drags the node by the given amount of pixels.
113 |   /// </summary>
114 |   /// <param name="x">Horizontal cartesian coordinate component.</param>
115 |   /// <param name="y">Vertical cartesian coordinate component.</param>
116 |   public void DragBy(float x, float y) => DragBy(new Vector2(x, y));
117 | 
118 |   /// <summary>
119 |   /// Drags the node by a multiple of its own size multiplied by the given
120 |   /// factor.
121 |   /// </summary>
122 |   /// <param name="delta">Change in distance.</param>
123 |   public void DragByOwnSize(Vector2 delta)
124 |   {
125 |     var node = VisibleRoot;
126 |     var rect = node.GetRect();
127 | 
128 |     DragBy(new Vector2(rect.Size.X * delta.X, rect.Size.X * delta.Y));
129 |   }
130 | 
131 |   /// <summary>
132 |   /// Drags the node by a multiple of its own size multiplied by the given
133 |   /// factor.
134 |   /// </summary>
135 |   /// <param name="x">Horizontal cartesian coordinate component.</param>
136 |   /// <param name="y">Vertical cartesian coordinate component.</param>
137 |   public void DragByOwnSize(float x, float y) =>
138 |     DragByOwnSize(new Vector2(x, y));
139 | 
140 |   /// <summary>
141 |   /// Selects the given node by clicking on it. Same as
142 |   /// <see cref="ClickAtSelectionSpot"/>.
143 |   /// </summary>
144 |   public void Select() => ClickAtSelectionSpot();
145 | 
146 |   /// <summary>
147 |   /// Clicks the mouse at the safe selection spot of this graph node.
148 |   /// </summary>
149 |   /// <param name="button">Button to use.</param>
150 |   public void ClickAtSelectionSpot(MouseButton button = MouseButton.Left) =>
151 |     Viewport.ClickMouseAt(SelectionSpot, button);
152 | 
153 |   /// <summary>
154 |   /// Drags a connection from the given source port of this node to the given
155 |   /// target port of the given target node.
156 |   /// </summary>
157 |   /// <param name="sourcePort">Source port.</param>
158 |   /// <param name="targetNode">Target node.</param>
159 |   /// <param name="targetPort">Target node connection port.</param>
160 |   /// <exception cref="ArgumentException"/>
161 |   public void DragConnection(
162 |     Port sourcePort,
163 |     GraphNodeDriver<T> targetNode,
164 |     Port targetPort
165 |   )
166 |   {
167 |     if (!sourcePort.IsDefined)
168 |     {
169 |       throw new ArgumentException("Source port is not defined.");
170 |     }
171 | 
172 |     if (!targetPort.IsDefined)
173 |     {
174 |       throw new ArgumentException("Target port is not defined.");
175 |     }
176 | 
177 |     var thisRoot = VisibleRoot;
178 |     var targetRoot = targetNode.VisibleRoot;
179 | 
180 |     if
181 |     (
182 |       sourcePort.IsInput &&
183 |       sourcePort.PortIndex >= thisRoot.GetInputPortCount()
184 |     )
185 |     {
186 |       throw new ArgumentException(
187 |         $"Node has no input port at the given index {sourcePort.PortIndex}."
188 |       );
189 |     }
190 | 
191 |     if
192 |     (
193 |       sourcePort.IsOutput &&
194 |       sourcePort.PortIndex >= thisRoot.GetOutputPortCount()
195 |     )
196 |     {
197 |       throw new ArgumentException(
198 |         $"Node has no output port at the given index {sourcePort.PortIndex}."
199 |       );
200 |     }
201 | 
202 |     if
203 |     (
204 |       targetPort.IsInput &&
205 |       targetPort.PortIndex >= targetRoot.GetInputPortCount()
206 |     )
207 |     {
208 |       throw new ArgumentException(
209 |         $"Target node has no input port at the given index {targetPort.PortIndex}."
210 |       );
211 |     }
212 | 
213 |     if
214 |     (
215 |       targetPort.IsOutput &&
216 |       targetPort.PortIndex >= targetRoot.GetOutputPortCount()
217 |     )
218 |     {
219 |       throw new ArgumentException(
220 |         $"Target node has no output port at the given index {targetPort.PortIndex}."
221 |       );
222 |     }
223 | 
224 |     var startPosition = sourcePort.IsInput
225 |       ? thisRoot.GetInputPortPosition(sourcePort.PortIndex)
226 |       : thisRoot.GetOutputPortPosition(sourcePort.PortIndex);
227 |     var endPosition = targetPort.IsInput
228 |       ? targetRoot.GetInputPortPosition(targetPort.PortIndex)
229 |       : targetRoot.GetOutputPortPosition(targetPort.PortIndex);
230 | 
231 |     Viewport.DragMouse(
232 |       startPosition + thisRoot.GlobalPosition,
233 |       endPosition + targetRoot.GlobalPosition
234 |     );
235 |   }
236 | 
237 |   /// <summary>
238 |   /// Drags a connection from the given source port of this node to a position
239 |   /// relative to this port.
240 |   /// </summary>
241 |   /// <param name="sourcePort">Source port.</param>
242 |   /// <param name="relativePosition">Position offset.</param>
243 |   /// <exception cref="ArgumentException"/>
244 |   public void DragConnection(Port sourcePort, Vector2 relativePosition)
245 |   {
246 |     if (!sourcePort.IsDefined)
247 |     {
248 |       throw new ArgumentException("Source port is not defined.");
249 |     }
250 | 
251 |     var thisRoot = VisibleRoot;
252 | 
253 |     if
254 |     (
255 |       sourcePort.IsInput &&
256 |       sourcePort.PortIndex >= thisRoot.GetInputPortCount()
257 |     )
258 |     {
259 |       throw new ArgumentException(
260 |         $"Node has no input port at the given index {sourcePort.PortIndex}."
261 |       );
262 |     }
263 | 
264 |     if
265 |     (
266 |       sourcePort.IsOutput &&
267 |       sourcePort.PortIndex >= thisRoot.GetOutputPortCount()
268 |     )
269 |     {
270 |       throw new ArgumentException(
271 |         $"Node has no output port at the given index {sourcePort.PortIndex}."
272 |       );
273 |     }
274 | 
275 |     var startPosition = sourcePort.IsInput
276 |         ? thisRoot.GetInputPortPosition(sourcePort.PortIndex)
277 |         : thisRoot.GetOutputPortPosition(sourcePort.PortIndex);
278 |     var endPosition = startPosition + relativePosition;
279 | 
280 |     Viewport.DragMouse(startPosition + thisRoot.GlobalPosition,
281 |         endPosition + thisRoot.GlobalPosition);
282 |   }
283 | }
284 | 
285 | /// <summary>
286 | /// Driver for a <see cref="GraphNode"/>
287 | /// </summary>
288 | public sealed class GraphNodeDriver : GraphNodeDriver<GraphNode>
289 | {
290 |   /// <summary>
291 |   /// Creates a new GraphNodeDriver.
292 |   /// </summary>
293 |   /// <param name="producer">Producer that creates a GraphNode subclass.</param>
294 |   /// <param name="description">Driver description.</param>
295 |   public GraphNodeDriver(Func<GraphNode> producer, string description = "")
296 |     : base(producer, description)
297 |   {
298 |   }
299 | }
300 | 


--------------------------------------------------------------------------------