@devscholar/node-ps1-dotnet 0.0.1 → 0.0.2

package/README.md

@@ -16,18 +16,9 @@ This is a project that mimics the [Node API for .NET](https://github.com/microso
 
 Please visit the [node-ps1-dotnet-examples](https://github.com/devscholar/node-ps1-dotnet-examples) repository for working examples.
 
-## Quick Start with Examples
+# Testing
 
-Clone the examples repository alongside this project:
-
-```bash
-git clone https://github.com/devscholar/node-ps1-dotnet-examples.git
-cd node-ps1-dotnet-examples
-npm install
-npm run winforms-counter
-```
-
-For more examples and details, see the [node-ps1-dotnet-examples README](https://github.com/devscholar/node-ps1-dotnet-examples).
+Please visit the [testing.md](docs/testing.md) file for testing instructions.
 
 # License
 

package/__tests__/basic.test.ts

@@ -0,0 +1,24 @@
+import { jest } from '@jest/globals';
+
+describe('node-ps1-dotnet', () => {
+  describe('utils', () => {
+    it('should export getPowerShellPath', async () => {
+      const { getPowerShellPath } = await import('../src/utils.js');
+      expect(typeof getPowerShellPath).toBe('function');
+    });
+  });
+
+  describe('ipc', () => {
+    it('should export IpcSync class', async () => {
+      const { IpcSync } = await import('../src/ipc.js');
+      expect(IpcSync).toBeDefined();
+    });
+  });
+
+  describe('types', () => {
+    it('should export ProtocolResponse type', async () => {
+      const types = await import('../src/types.js');
+      expect(types).toBeDefined();
+    });
+  });
+});

package/__tests__/dotnet-console.test.ts

@@ -0,0 +1,30 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('Console Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Console: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+      Console = System.Console;
+    } catch (e) {
+      console.log('Skipping console tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access Console class', () => {
+    expect(Console).toBeDefined();
+    expect(Console.WriteLine).toBeDefined();
+  });
+});

package/__tests__/dotnet-enums.test.ts

@@ -0,0 +1,55 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('Enum Tests', () => {
+  let dotnet: any;
+  let System: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+    } catch (e) {
+      console.log('Skipping enum tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should load System namespace', () => {
+    expect(System).toBeDefined();
+  });
+
+  it('should access StringComparison enum', () => {
+    const StringComparison = System.StringComparison;
+    expect(StringComparison).toBeDefined();
+    expect(StringComparison.Ordinal).toBeDefined();
+    expect(StringComparison.OrdinalIgnoreCase).toBeDefined();
+  });
+
+  it('should access DateTimeKind enum', () => {
+    const DateTimeKind = System.DateTimeKind;
+    expect(DateTimeKind).toBeDefined();
+    expect(DateTimeKind.Unspecified).toBeDefined();
+    expect(DateTimeKind.Utc).toBeDefined();
+    expect(DateTimeKind.Local).toBeDefined();
+  });
+
+  it('should access DayOfWeek enum', () => {
+    const DayOfWeek = System.DayOfWeek;
+    expect(DayOfWeek).toBeDefined();
+    expect(DayOfWeek.Sunday).toBeDefined();
+    expect(DayOfWeek.Monday).toBeDefined();
+  });
+
+  it('should access StringComparison enum values', () => {
+    const StringComparison = System.StringComparison;
+    expect(StringComparison.Ordinal).toBeDefined();
+    expect(StringComparison.OrdinalIgnoreCase).toBeDefined();
+  });
+});

package/__tests__/dotnet-io.test.ts

@@ -0,0 +1,57 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('IO Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let IO: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+      IO = System.IO;
+    } catch (e) {
+      console.log('Skipping IO tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access Path class', () => {
+    const Path = IO.Path;
+    expect(Path).toBeDefined();
+    expect(Path.Combine).toBeDefined();
+  });
+
+  it('should use Path.Combine', () => {
+    const Path = IO.Path;
+    const result = Path.Combine('folder', 'file.txt');
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  it('should access File class', () => {
+    const File = IO.File;
+    expect(File).toBeDefined();
+    expect(File.Exists).toBeDefined();
+  });
+
+  it('should access Directory class', () => {
+    const Directory = IO.Directory;
+    expect(Directory).toBeDefined();
+    expect(Directory.Exists).toBeDefined();
+  });
+
+  it('should get current directory', () => {
+    const Directory = IO.Directory;
+    const cwd = Directory.GetCurrentDirectory();
+    expect(cwd).toBeDefined();
+    expect(typeof cwd).toBe('string');
+  });
+});

package/__tests__/dotnet-misc.test.ts

@@ -0,0 +1,95 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('String Tests', () => {
+  let dotnet: any;
+  let System: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+    } catch (e) {
+      console.log('Skipping string tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access String class', () => {
+    const String = System.String;
+    expect(String).toBeDefined();
+  });
+});
+
+(isWindows ? describe : describe.skip)('Array Tests', () => {
+  let dotnet: any;
+  let System: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+    } catch (e) {
+      console.log('Skipping array tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access Array class', () => {
+    const Array = System.Array;
+    expect(Array).toBeDefined();
+    expect(Array.Reverse).toBeDefined();
+  });
+});
+
+(isWindows ? describe : describe.skip)('Environment Tests', () => {
+  let dotnet: any;
+  let System: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+    } catch (e) {
+      console.log('Skipping environment tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access Environment class', () => {
+    const Environment = System.Environment;
+    expect(Environment).toBeDefined();
+    expect(Environment.ProcessorCount).toBeDefined();
+    expect(Environment.CurrentDirectory).toBeDefined();
+  });
+
+  it('should get processor count', () => {
+    const Environment = System.Environment;
+    const processorCount = Environment.ProcessorCount;
+    expect(processorCount).toBeDefined();
+    expect(processorCount).toBeGreaterThan(0);
+  });
+
+  it('should get current directory', () => {
+    const Environment = System.Environment;
+    const cwd = Environment.CurrentDirectory;
+    expect(cwd).toBeDefined();
+    expect(typeof cwd).toBe('string');
+  });
+});

package/__tests__/dotnet-runtime.test.ts

@@ -0,0 +1,99 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('Runtime Info Tests', () => {
+  let dotnet: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+    } catch (e) {
+      console.log('Skipping runtime info tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should get runtime version', () => {
+    const version = dotnet.default.runtimeVersion;
+    expect(version).toBeDefined();
+    expect(typeof version).toBe('string');
+  });
+
+  it('should get framework moniker', () => {
+    const moniker = dotnet.default.frameworkMoniker;
+    expect(moniker).toBeDefined();
+    expect(typeof moniker).toBe('string');
+  });
+
+  it('should access _getRuntimeInfo', () => {
+    const info = dotnet.node_ps1_dotnet._getRuntimeInfo();
+    expect(info).toBeDefined();
+    expect(info.frameworkMoniker).toBeDefined();
+    expect(info.runtimeVersion).toBeDefined();
+  });
+});
+
+(isWindows ? describe : describe.skip)('Type Loading Tests', () => {
+  let dotnet: any;
+  let System: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+    } catch (e) {
+      console.log('Skipping type loading tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should load System namespace', () => {
+    expect(System).toBeDefined();
+  });
+
+  it('should access basic types', () => {
+    expect(System.Int32).toBeDefined();
+    expect(System.String).toBeDefined();
+    expect(System.Boolean).toBeDefined();
+    expect(System.Object).toBeDefined();
+  });
+});
+
+(isWindows ? describe : describe.skip)('Assembly Tests', () => {
+  let dotnet: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+    } catch (e) {
+      console.log('Skipping assembly tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should have default export with load method', () => {
+    expect(dotnet.default).toBeDefined();
+    expect(typeof dotnet.default.load).toBe('function');
+  });
+
+  it('should have node_ps1_dotnet object', () => {
+    expect(dotnet.node_ps1_dotnet).toBeDefined();
+    expect(typeof dotnet.node_ps1_dotnet._load).toBe('function');
+  });
+});

package/__tests__/dotnet-task.test.ts

@@ -0,0 +1,35 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('Task Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Task: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      System = dotnet.System;
+      Task = System.Threading.Tasks.Task;
+    } catch (e) {
+      console.log('Skipping task tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should access Task class', () => {
+    expect(Task).toBeDefined();
+    expect(Task.Delay).toBeDefined();
+  });
+
+  it('should access Task.CompletedTask', () => {
+    const completedTask = Task.CompletedTask;
+    expect(completedTask).toBeDefined();
+  });
+});

package/__tests__/gui-events.test.ts

@@ -0,0 +1,147 @@
+import { jest } from '@jest/globals';
+
+const isWindows = process.platform === 'win32';
+
+(isWindows ? describe : describe.skip)('GUI Event Handler Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Forms: any;
+  let Drawing: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      dotnet.default.load('System.Windows.Forms');
+      dotnet.default.load('System.Drawing');
+      System = dotnet.System;
+      Forms = System.Windows.Forms;
+      Drawing = System.Drawing;
+    } catch (e) {
+      console.log('Skipping event handler tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should handle MouseDown event on Panel', () => {
+    const panel = new Forms.Panel();
+    
+    let mouseDownTriggered = false;
+    
+    panel.add_MouseDown((sender: any, e: any) => {
+      mouseDownTriggered = true;
+    });
+    
+    expect(panel).toBeDefined();
+  });
+
+  it('should handle MouseUp event on Panel', () => {
+    const panel = new Forms.Panel();
+    
+    panel.add_MouseUp((sender: any, e: any) => {
+      console.log('Mouse up');
+    });
+    
+    expect(panel).toBeDefined();
+  });
+
+  it('should handle MouseMove event on Panel', () => {
+    const panel = new Forms.Panel();
+    
+    panel.add_MouseMove((sender: any, e: any) => {
+      console.log('Mouse move');
+    });
+    
+    expect(panel).toBeDefined();
+  });
+
+  it('should handle multiple events on same control', () => {
+    const button = new Forms.Button();
+    
+    let clickCount = 0;
+    
+    button.add_Click(() => {
+      clickCount++;
+    });
+    
+    button.add_Click(() => {
+      clickCount++;
+    });
+    
+    expect(button).toBeDefined();
+  });
+});
+
+(isWindows ? describe : describe.skip)('GUI Property Binding Tests', () => {
+  let dotnet: any;
+  let System: any;
+  let Forms: any;
+  let Drawing: any;
+
+  beforeAll(async () => {
+    try {
+      dotnet = await import('../src/index.js');
+      dotnet.default.load('System.Windows.Forms');
+      dotnet.default.load('System.Drawing');
+      System = dotnet.System;
+      Forms = System.Windows.Forms;
+      Drawing = System.Drawing;
+    } catch (e) {
+      console.log('Skipping property binding tests - load failed:', e);
+    }
+  });
+
+  afterAll(() => {
+    try {
+      dotnet?.node_ps1_dotnet?._close();
+    } catch {}
+  });
+
+  it('should update label text from button click', () => {
+    const label = new Forms.Label();
+    const button = new Forms.Button();
+    
+    label.Text = 'Initial';
+    button.Text = 'Click';
+    
+    button.add_Click(() => {
+      label.Text = 'Updated';
+    });
+    
+    expect(label.Text).toBe('Initial');
+  });
+
+  it('should set location using Point', () => {
+    const label = new Forms.Label();
+    const location = new Drawing.Point(100, 50);
+    
+    label.Location = location;
+    
+    expect(label.Location.X).toBe(100);
+    expect(label.Location.Y).toBe(50);
+  });
+
+  it('should update control visibility', () => {
+    const button = new Forms.Button();
+    
+    button.Visible = false;
+    expect(button.Visible).toBe(false);
+    
+    button.Visible = true;
+    expect(button.Visible).toBe(true);
+  });
+
+  it('should update control enabled state', () => {
+    const button = new Forms.Button();
+    
+    button.Enabled = false;
+    expect(button.Enabled).toBe(false);
+    
+    button.Enabled = true;
+    expect(button.Enabled).toBe(true);
+  });
+});

package/__tests__/ipc.test.ts

@@ -0,0 +1,43 @@
+import { jest } from '@jest/globals';
+
+describe('IpcSync', () => {
+  let IpcSync: any;
+  let mockFs: any;
+
+  beforeAll(async () => {
+    const ipcModule = await import('../src/ipc.js');
+    IpcSync = ipcModule.IpcSync;
+  });
+
+  beforeEach(() => {
+    mockFs = {
+      openSync: jest.fn(),
+      readSync: jest.fn(),
+      closeSync: jest.fn(),
+    };
+  });
+
+  it('should create an instance with pipe name and callback', () => {
+    const onEvent = jest.fn();
+    const ipc = new IpcSync('test_pipe', onEvent);
+    
+    expect(ipc).toBeDefined();
+    expect(ipc).toHaveProperty('pipeName', 'test_pipe');
+  });
+
+  it('should have connect, send, and close methods', () => {
+    const onEvent = jest.fn();
+    const ipc = new IpcSync('test_pipe', onEvent);
+    
+    expect(typeof ipc.connect).toBe('function');
+    expect(typeof ipc.send).toBe('function');
+    expect(typeof ipc.close).toBe('function');
+  });
+
+  it('should throw error when connecting to nonexistent pipe', () => {
+    const onEvent = jest.fn();
+    const ipc = new IpcSync('nonexistent_pipe_12345', onEvent);
+    
+    expect(() => ipc.connect()).toThrow();
+  });
+});