Fix for #274 - NPE if no editor can be created for a given mimetype (#275)

* cleanup
* handling a race condition in JeddictBrain with no proper content returned from the LLM
* fixing bug #274 - NPE if no editor can be created for a given mimetype
* content to reproduce #374
* Added copyright to DummyChatModelListener
* cleanup

Author: stefanofornari

src/main/java/io/github/jeddict/ai/agent/AbstractTool.java

@@ -62,6 +62,13 @@ public void addListener(final JeddictBrainListener listener) {
         listeners.add(listener);
     }
 
+    public void removeListener(final JeddictBrainListener listener) {
+        if (listener == null) {
+            throw new IllegalArgumentException("listener can not be null");
+        }
+        listeners.remove(listener);
+    }
+
     public void checkPath(final String path) throws ToolExecutionException {
         //
         // NOTE: we can not use toRealPath here because we want to check even
@@ -78,14 +85,7 @@ public void checkPath(final String path) throws ToolExecutionException {
                 "trying to reach a file outside the project folder");
         }
     }
-
-    public void removeListener(final JeddictBrainListener listener) {
-        if (listener == null) {
-            throw new IllegalArgumentException("listener can not be null");
-        }
-        listeners.remove(listener);
-    }
-
+    
     public Path fullPath(final String path) {
         return basepath.resolve(path).normalize();
     }

src/main/java/io/github/jeddict/ai/lang/JeddictBrain.java

@@ -368,15 +368,19 @@ public void onEvent(AiServiceCompletedEvent e) {
                     // the toString() of the object so that the listener can
                     // rely on receive always the same object
                     //
-                    final Object obj = e.result().get();
-
-                    final ChatResponse result = (obj instanceof ChatResponse)
-                                              ? (ChatResponse)obj
-                                              : ChatResponse.builder().aiMessage(AiMessage.from(String.valueOf(obj))).build();
-                    LOG.finest(() ->
-                        "%s\n%s".formatted(String.valueOf(e.eventClass()), String.valueOf(result))
-                    );
-                    on(listeners).loop((l) -> l.onChatCompleted(result));
+                    e.result().ifPresentOrElse(obj -> {
+                        final ChatResponse result = (obj instanceof ChatResponse)
+                                                  ? (ChatResponse)obj
+                                                  : ChatResponse.builder().aiMessage(AiMessage.from(String.valueOf(obj))).build();
+                        LOG.finest(() ->
+                            "%s\n%s".formatted(String.valueOf(e.eventClass()), String.valueOf(result))
+                        );
+                        on(listeners).loop((l) -> l.onChatCompleted(result));
+                    }, () -> {
+                        LOG.finest(() ->
+                            "no result from the model..."
+                        );
+                    });
                 }
             },
             new AiServiceErrorListener() {

src/main/java/io/github/jeddict/ai/util/EditorUtil.java

@@ -119,7 +119,7 @@ public static String updateEditors(
         if (firstPane != null) {
             firstPane.scrollRectToVisible(firstPane.getBounds());
         }
-        
+
         assistantChat.revalidate();
         assistantChat.repaint();
         List<FileObject> context = new ArrayList<>();
@@ -642,14 +642,32 @@ public static NbEditorKit createEditorKit(String mimeType) {
     public static JEditorPane createInMemoryEditorCopy(String mimeType) {
         JEditorPane mirrorEditor;
         try {
-            String ext = getExtension(mimeType);
+            final String ext = getExtension(mimeType);
+            final FileObject root =
+                org.openide.filesystems.FileUtil.createMemoryFileSystem().getRoot();
 
-            FileObject fo = org.openide.filesystems.FileUtil.createMemoryFileSystem()
-                    .getRoot()
-                    .createData("code-preview." + ext);
+            FileObject fo = root.createData("code-preview." + ext);
 
             EditorCookie ec = fo.getLookup().lookup(EditorCookie.class);
 
+            if (ec == null) {
+                LOG.info(() -> "no editor to display '" + ext + "', falling back to txt");
+                fo.delete();
+                fo = root.createData("code-previre.txt");
+                ec = fo.getLookup().lookup(EditorCookie.class);
+            }
+
+            //
+            // if here ec is still null (potentially it may happen if there is
+            // no editor associated to .txt, although unlikely) there is nothing
+            // we can do more...
+            //
+            if (ec == null) {
+                final String msg = "no editors to display '" + ext + "' content have been found in NetBeans";
+                LOG.severe(msg);
+                throw new IllegalStateException(msg);
+            }
+
             try {
                 ec.open();
 

src/test/java/io/github/jeddict/ai/agent/AbstractToolTest.java

@@ -5,13 +5,11 @@
 import io.github.jeddict.ai.test.DummyTool;
 import io.github.jeddict.ai.lang.DummyJeddictBrainListener;
 import java.io.IOException;
-import java.nio.file.Paths;
 import java.util.function.UnaryOperator;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.BDDAssertions.then;
 import static org.assertj.core.api.BDDAssertions.thenThrownBy;
-import org.junit.jupiter.api.BeforeEach;
 
 public class AbstractToolTest extends TestBase {
 
@@ -57,10 +55,10 @@ public void set_and_get_humanInTheMiddle() throws IOException  {
     public void fires_onProgress_events() throws IOException {
         //
         // When a tool send an onProgress event, we want to start a new thread.
-        // This is because when stremaing, content does not necessarily ends with 
+        // This is because when stremaing, content does not necessarily ends with
         // a \n and the output of the tool may not go to a new line.
         //
-        
+
         // given
         final DummyTool tool = new DummyTool(projectDir);
         final DummyJeddictBrainListener listener = new DummyJeddictBrainListener();
@@ -72,8 +70,8 @@ public void fires_onProgress_events() throws IOException {
         // then
         then(listener.collector).hasSize(1);
         then(listener.collector.get(0)).asString().isEqualTo("(onProgress,\na message)");
-        
-        
+
+
     }
 
     @Test

src/test/java/io/github/jeddict/ai/lang/JeddictBrainTest.java

@@ -360,7 +360,7 @@ public void get_new_pair_programmer() {
      * non interactive. Both must receive events.
      */
     @Test
-    public void interactive_and_not_interactove_agents_receive_events() {
+    public void interactive_and_not_interactive_agents_receive_events() {
         final DummyJeddictBrainListener listener = new DummyJeddictBrainListener();
         final JeddictBrain brain = new JeddictBrain(false);
 

src/test/java/io/github/jeddict/ai/test/DummyChatModelListener.java

@@ -1,3 +1,18 @@
+/**
+ * Copyright 2025 the original author or authors from the Jeddict project (https://jeddict.github.io/).
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
 package io.github.jeddict.ai.test;
 
 import dev.langchain4j.model.chat.listener.ChatModelListener;

src/test/resources/mocks/javafx unit test.txt

@@ -0,0 +1,196 @@
+
+To write a JUnit test for your JavaFX application using **TestFX** (which provides `FxRobot`), you'll need to:
+1. **Load the FXML file** into a `Parent` node.
+2. **Inject the controller** (if needed).
+3. **Use `FxRobot`** to interact with UI controls (e.g., setting text in `TextArea`).
+
+---
+
+### **Step 1: Add TestFX to Your Project**
+Ensure you have **TestFX** in your dependencies (Maven/Gradle):
+
+#### **Maven (`pom.xml`)**
+```xml
+<dependency>
+    <groupId>org.testfx</groupId>
+    <artifactId>testfx-core</artifactId>
+    <version>4.0.20</version>
+    <scope>test</scope>
+</dependency>
+```
+
+#### **Gradle (`build.gradle`)**
+```groovy
+testImplementation 'org.testfx:testfx-core:4.0.20'
+```
+
+---
+
+### **Step 2: Write the JUnit Test**
+Here's a complete example using **TestFX** to set text in `userPromptTextArea`:
+
+```java
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.testfx.api.FxRobot;
+import org.testfx.framework.junit5.ApplicationTest;
+import org.testfx.util.WaitForAsyncUtils;
+
+import java.io.IOException;
+
+import static org.testfx.api.FxAssert.verifyThat;
+import static org.testfx.matcher.control.TextAreaMatcher.hasText;
+
+public class MainControllerTest extends ApplicationTest {
+
+    private Parent root;
+
+    @Override
+    public void start(Stage stage) throws Exception {
+        // Load the FXML file
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("/ste/ai/toolify/MainView.fxml"));
+        root = loader.load();
+        stage.setScene(new Scene(root));
+        stage.show();
+    }
+
+    @BeforeEach
+    public void setUp() {
+        // Load the FXML before each test
+        try {
+            FXMLLoader loader = new FXMLLoader(getClass().getResource("/ste/ai/toolify/MainView.fxml"));
+            root = loader.load();
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to load FXML", e);
+        }
+    }
+
+    @Test
+    public void testSetUserPromptTextAreaText(FxRobot robot) {
+        // Wait for the UI to load
+        WaitForAsyncUtils.waitForFxRobot(() -> {
+            // Find the TextArea by FXML ID
+            robot.clickOn("#userPromptTextArea");
+
+            // Wait for focus (optional, but ensures the TextArea is ready)
+            WaitForAsyncUtils.waitForFxRobot(() -> {
+                // Set text in the TextArea
+                robot.write("Hello, this is a test prompt!");
+            });
+
+            // Verify the text was set
+            verifyThat("#userPromptTextArea", hasText("Hello, this is a test prompt!"));
+        });
+    }
+}
+```
+
+---
+
+### **Key Points**
+1. **`FxRobot`** is used to interact with UI controls.
+2. **`robot.clickOn("#userPromptTextArea")`** ensures the `TextArea` is focused.
+3. **`robot.write("...")`** sets the text.
+4. **`verifyThat("#userPromptTextArea", hasText("..."))`** checks if the text was set correctly.
+
+---
+
+### **Alternative: Directly Setting Text (Without Clicking)**
+If you don't need to simulate user interaction, you can directly set the text using `FxRobot`'s `write()` method:
+
+```java
+@Test
+public void testSetUserPromptTextAreaTextDirectly(FxRobot robot) {
+    robot.write("#userPromptTextArea", "Hello, this is a test prompt!");
+    verifyThat("#userPromptTextArea", hasText("Hello, this is a test prompt!"));
+}
+```
+
+---
+
+### **Handling Controllers (If Needed)**
+If your `MainController` has logic that modifies the `TextArea` after loading, you may need to **inject the controller** into the `FXMLLoader`:
+
+```java
+@BeforeEach
+public void setUp() {
+    FXMLLoader loader = new FXMLLoader(getClass().getResource("/ste/ai/toolify/MainView.fxml"));
+    loader.setController(new MainController()); // Inject controller if needed
+    try {
+        root = loader.load();
+    } catch (IOException e) {
+        throw new RuntimeException("Failed to load FXML", e);
+    }
+}
+```
+
+---
+
+### **Full Example with Error Handling**
+```java
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.testfx.api.FxRobot;
+import org.testfx.framework.junit5.ApplicationTest;
+import org.testfx.util.WaitForAsyncUtils;
+
+import java.io.IOException;
+
+import static org.testfx.api.FxAssert.verifyThat;
+import static org.testfx.matcher.control.TextAreaMatcher.hasText;
+
+public class MainControllerTest extends ApplicationTest {
+
+    private Parent root;
+
+    @Override
+    public void start(Stage stage) throws Exception {
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("/ste/ai/toolify/MainView.fxml"));
+        root = loader.load();
+        stage.setScene(new Scene(root));
+        stage.show();
+    }
+
+    @BeforeEach
+    public void setUp() {
+        try {
+            FXMLLoader loader = new FXMLLoader(getClass().getResource("/ste/ai/toolify/MainView.fxml"));
+            root = loader.load();
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to load FXML", e);
+        }
+    }
+
+    @Test
+    public void testSetUserPromptTextAreaText(FxRobot robot) {
+        WaitForAsyncUtils.waitForFxRobot(() -> {
+            robot.write("#userPromptTextArea", "Hello, this is a test prompt!");
+            verifyThat("#userPromptTextArea", hasText("Hello, this is a test prompt!"));
+        });
+    }
+}
+```
+
+---
+
+### **Troubleshooting**
+1. **If the `TextArea` is not found**, ensure:
+   - The FXML path is correct (`/ste/ai/toolify/MainView.fxml`).
+   - The `fx:id` (`userPromptTextArea`) matches the FXML.
+2. **If the test hangs**, use `WaitForAsyncUtils` to ensure the UI loads.
+3. **If the test fails with `NoSuchElementException`**, verify that the `TextArea` is visible and interactive.
+
+---
+
+### **Final Notes**
+- **TestFX** is the standard way to test JavaFX UI interactions.
+- **`FxRobot`** provides methods like `clickOn()`, `write()`, and `verifyThat()` for easy UI testing.
+- Always ensure the FXML is loaded before interacting with controls.