UnitTests

test/GCode.receiveGCode.test.js

@@ -90,7 +90,7 @@ describe('GCode.receiveGCode', () => {
     expect(robot.sendCommand).toHaveBeenCalled()
   })
 
-  test('G28 setzt Home-Position', () => {
+  test('G28 setzt Home-Position und löst Bewegung aus', () => {
     const robot = createDummyRobot()
 
     GCode.receiveGCode(robot, 'G28')
@@ -100,6 +100,8 @@ describe('GCode.receiveGCode', () => {
     expect(robot.y).toBe(robot.l1 + robot.l2 + robot.l3)
     expect(robot.phi).toBeCloseTo(-Math.PI / 2)
     expect(robot.theta).toBeCloseTo(Math.PI / 2)
+    expect(robot.calculateAngles3D).toHaveBeenCalledTimes(1)
+    expect(robot.sendCommand).toHaveBeenCalledTimes(1)
   })
 
   test('Sende falsches Format', () =>{

test/InfoServer.test.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const https = require('https');
+const createInfoServer = require('../server/InfoServer');
+const GCode = require('../robot/GCode');
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && address.port) {
+        resolve(address.port);
+      } else {
+        reject(new Error('Failed to get server port'));
+      }
+    });
+    server.on('error', reject);
+  });
+}
+
+function request(url) {
+  return new Promise((resolve, reject) => {
+    const agent = new https.Agent({ rejectUnauthorized: false });
+    https.get(url, { agent }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk.toString();
+      });
+      res.on('end', () => {
+        resolve({ statusCode: res.statusCode, body: data });
+      });
+    }).on('error', reject);
+  });
+}
+
+describe('InfoServer', () => {
+  let server;
+  let port;
+
+  afterEach(async () => {
+    if (server) {
+      await new Promise((resolve) => server.close(resolve));
+      server = null;
+    }
+  });
+
+  test('returns status JSON with sender and shared state information', async () => {
+    const key = fs.readFileSync('https/localhost.key');
+    const cert = fs.readFileSync('https/localhost.pem');
+    const httpsOptions = { key, cert, passphrase: 'abcd' };
+
+    const sharedState = {
+      connectedClients: ['127.0.0.1'],
+      lastCommands: ['G1 X10 Y10'],
+      lastPings: ['Ping']
+    };
+
+    const robot = {
+      x: 1,
+      y: 2,
+      z: 3,
+      phi: 0,
+      theta: 0,
+      psi: 0
+    };
+
+    const senders = [
+      { name: 'Base', instance: { tSocket: {} } },
+      { name: 'Hand', instance: null }
+    ];
+
+    server = createInfoServer(httpsOptions, sharedState, robot, GCode, senders);
+    port = await listen(server);
+
+    const { statusCode, body } = await request(`https://127.0.0.1:${port}/api/status`);
+    expect(statusCode).toBe(200);
+
+    const status = JSON.parse(body);
+    expect(status.clients).toEqual(['127.0.0.1']);
+    expect(status.lastCommands).toEqual(['G1 X10 Y10']);
+    expect(status.lastPings).toEqual(['Ping']);
+    expect(status.senders).toEqual([
+      { name: 'Base', status: 'connected' },
+      { name: 'Hand', status: 'disconnected' }
+    ]);
+  });
+
+  test('returns position JSON from GCode.getM114', async () => {
+    const key = fs.readFileSync('https/localhost.key');
+    const cert = fs.readFileSync('https/localhost.pem');
+    const httpsOptions = { key, cert, passphrase: 'abcd' };
+
+    const sharedState = { connectedClients: [], lastCommands: [], lastPings: [] };
+    const robot = { x: 10, y: 20, z: 30, phi: 0.1, theta: 0.2, psi: 0.3, xMotor: 0, alpha: 0, beta: 0, a: 0, b: 0, c: 0 };
+    const senders = [];
+
+    server = createInfoServer(httpsOptions, sharedState, robot, GCode, senders);
+    port = await listen(server);
+
+    const { statusCode, body } = await request(`https://127.0.0.1:${port}/api/position`);
+    expect(statusCode).toBe(200);
+
+    const json = JSON.parse(body);
+    expect(json.position).toEqual({ x: 10, y: 20, z: 30, a: 0.1, b: 0.2, c: 0.3 });
+  });
+
+  test('returns 404 for unknown endpoints', async () => {
+    const key = fs.readFileSync('https/localhost.key');
+    const cert = fs.readFileSync('https/localhost.pem');
+    const httpsOptions = { key, cert, passphrase: 'abcd' };
+
+    const sharedState = { connectedClients: [], lastCommands: [], lastPings: [] };
+    const robot = { x: 0, y: 0, z: 0, phi: 0, theta: 0, psi: 0, xMotor: 0, alpha: 0, beta: 0, a: 0, b: 0, c: 0 };
+    const senders = [];
+
+    server = createInfoServer(httpsOptions, sharedState, robot, GCode, senders);
+    port = await listen(server);
+
+    const { statusCode } = await request(`https://127.0.0.1:${port}/api/unknown`);
+    expect(statusCode).toBe(404);
+  });
+});

test/InputWS.test.js

@@ -0,0 +1,96 @@
+const http = require('http');
+const WebSocket = require('ws');
+const initInputWS = require('../server/InputWS');
+const GCode = require('../robot/GCode');
+const createDummyRobot = require('./helpers/createDummyRobot');
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && address.port) {
+        resolve(address.port);
+      } else {
+        reject(new Error('Failed to get server port'));
+      }
+    });
+    server.on('error', reject);
+  });
+}
+
+function connectWebSocket(port) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+    ws.on('open', () => resolve(ws));
+    ws.on('error', reject);
+  });
+}
+
+function waitForMessage(ws) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Timeout waiting for message')), 2000);
+    ws.on('message', (data) => {
+      clearTimeout(timer);
+      resolve(data.toString());
+    });
+  });
+}
+
+describe('InputWS', () => {
+  let server;
+  let port;
+  let wss;
+
+  afterEach(async () => {
+    if (server) {
+      await new Promise((resolve) => server.close(resolve));
+      server = null;
+    }
+  });
+
+  test('responds to Ping and updates sharedState', async () => {
+    server = http.createServer();
+    const sharedState = { connectedClients: [], lastCommands: [], lastPings: [] };
+    const robot = createDummyRobot();
+    wss = initInputWS(server, robot, GCode, sharedState);
+
+    port = await listen(server);
+    const client = await connectWebSocket(port);
+
+    const messagePromise = waitForMessage(client);
+    client.send('Ping');
+
+    const message = await messagePromise;
+    expect(message).toBe('Ping');
+    expect(sharedState.lastPings.length).toBe(1);
+    expect(sharedState.connectedClients.length).toBe(1);
+
+    client.close();
+  });
+
+  test('responds to M114 with current robot position JSON', async () => {
+    server = http.createServer();
+    const sharedState = { connectedClients: [], lastCommands: [], lastPings: [] };
+    const robot = createDummyRobot();
+    robot.x = 12;
+    robot.y = 34;
+    robot.z = 56;
+    robot.phi = 1;
+    robot.theta = 2;
+    robot.psi = 3;
+
+    wss = initInputWS(server, robot, GCode, sharedState);
+    port = await listen(server);
+    const client = await connectWebSocket(port);
+
+    const messagePromise = waitForMessage(client);
+    client.send('M114');
+
+    const message = await messagePromise;
+    const parsed = JSON.parse(message);
+    expect(parsed.position).toEqual({ x: 12, y: 34, z: 56, a: 1, b: 2, c: 3 });
+    expect(parsed.motorCounts).toBeDefined();
+
+    client.close();
+  });
+});