More testing and linting fixes

ddd999 · ddd999 · commit aa95364457e1 · 2025-06-14T15:29:13.000-07:00
diff --git a/server/index.test.js b/server/index.test.js
@@ -8,22 +8,23 @@ const app = require('./index');
 
 let server;
 
-// Start the server before all tests
-before(function(done) {
-  // The app should export the Express app, not start the server directly
-  server = app.listen(3001, () => {
-    console.log('Test server started on port 3001');
-    done();
+describe('Express server', function () {
+  // Start the server before all tests
+  before(function(done) {
+    // The app should export the Express app, not start the server directly
+    server = app.listen(3001, () => {
+      console.log('Test server started on port 3001');
+      done();
+    });
   });
-});
 
-// Close the server after all tests
-after(function(done) {
-  server.close(() => {
-    console.log('Test server closed');
-    done();
+  // Close the server after all tests
+  after(function(done) {
+    server.close(() => {
+      console.log('Test server closed');
+      done();
+    });
   });
-});
 
 // Helper function to make requests using Node's built-in http
 function request(method, path, body, headers = {}) {
@@ -38,19 +39,19 @@ function request(method, path, body, headers = {}) {
         ...headers
       }
     };
-    
+
     if (body) {
       const bodyData = JSON.stringify(body);
       options.headers['Content-Type'] = 'application/json';
       options.headers['Content-Length'] = Buffer.byteLength(bodyData);
     }
-    
+
     const req = http.request(options, (res) => {
       let data = '';
       res.on('data', (chunk) => {
         data += chunk;
       });
-      
+
       res.on('end', () => {
         res.body = data;
         try {
@@ -61,43 +62,79 @@ function request(method, path, body, headers = {}) {
         resolve(res);
       });
     });
-    
+
     req.on('error', (error) => {
       reject(error);
     });
-    
+
     if (body) {
       req.write(JSON.stringify(body));
     }
     req.end();
   });
 }
 
-describe('Express server', function () {
   // Test the GET / endpoint
   describe('GET /', function () {
     it('should return a 200 status code', async function () {
       const response = await request('GET', '/');
-      assert.equal(response.statusCode, 200);  // Changed from status to statusCode
+      assert.equal(response.statusCode, 200);
     });
   });
 
   // Test that unauthorized users cannot access the /users endpoint
   describe('GET /users nonauth', function () {
     it('should return a 401 status code', async function () {
       const response = await request('GET', '/api/users');
-      assert.equal(response.statusCode, 401);  // Changed from status to statusCode
+      assert.equal(response.statusCode, 401);
     });
   });
 
   // Test that login works
   describe('POST /login', function () {
     it('should return a 200 status code', async function () {
-      const response = await request('POST', '/api/login', { 
-        username: 'admin', 
-        password: 'admin' 
+      const response = await request('POST', '/api/login', {
+        username: 'admin',
+        password: 'admin'
       });
-      assert.equal(response.statusCode, 200);  // Changed from status to statusCode
+      assert.equal(response.statusCode, 200);
+    });
+  });
+
+  // Test /api/capturestillphoto for camera not active or not photo mode
+  describe('POST /api/capturestillphoto', function () {
+    it('should return a 400 if camera is not active or not in photo mode', async function () {
+      // No auth token provided, will be rejected as 401
+      const response = await request('POST', '/api/capturestillphoto');
+      // Accept either 400 or 401 (depends if middleware or logic triggers first)
+      assert([400, 401].includes(response.statusCode));
+    });
+  });
+
+  // Test /api/camera/start validation error=
+  describe('POST /api/camera/start validation', function () {
+    it('should return 422 for missing required fields', async function () {
+      const loginRes = await request('POST', '/api/login', {
+        username: 'admin',
+        password: 'admin'
+      });
+      const token = (loginRes.json && loginRes.json.token) || '';
+
+      const response = await request(
+        'POST',
+        '/api/camera/start',
+        { cameraMode: 'streaming' },
+        { Authorization: 'Bearer ' + token }
+      );
+      assert.equal(response.statusCode, 422);
+    });
+  });
+
+  // Test that /api/camera/stop returns 401 without authorization
+  describe('POST /api/camera/stop', function () {
+    it('should return 401 without authentication', async function () {
+      const response = await request('POST', '/api/camera/stop');
+      assert.equal(response.statusCode, 401);
     });
   });
 });
diff --git a/server/videostream.js b/server/videostream.js
@@ -152,15 +152,12 @@ class videoStream {
 
 // video streaming
 getVideoDevices(callback) {
-
-  process.stdout.write('\n--- TRACE: getVideoDevices called ---\n');
   this.winston.info("Retrieving video devices");
 
   const networkInterfaces = this.scanInterfaces();
 
   exec('python3 ./python/gstcaps.py', (error, stdout, stderr) => {
     // Initialize a safe, default response object at the beginning to ensure all callbacks receive a valid object.
-     process.stdout.write('--- TRACE: exec callback entered ---\n');
     const responseData = {
       devices: [],
       networkInterfaces: networkInterfaces,
@@ -186,18 +183,13 @@ getVideoDevices(callback) {
     const warnstrings = ['DeprecationWarning', 'gst_element_message_full_with_details', 'camera_manager.cpp', 'Unsupported V4L2 pixel format'];
     if (stderr && !warnstrings.some(wrn => stderr.includes(wrn))) {
       this.winston.info('Error in getVideoDevices() ', { message: stderr });
-      process.stdout.write('--- TRACE: exec had script error, calling back ---\n');
       return callback(stderr, responseData);
     }
 
     try {
-      process.stdout.write('--- TRACE: ENTERING TRY BLOCK ---\n');
       const devices = JSON.parse(stdout);
 
-      process.stdout.write('--- TRACE: JSON parsed successfully ---\n');
-
       if (!Array.isArray(devices) || devices.length === 0) {
-        process.stdout.write('--- TRACE: No devices found, calling back ---\n');
         return callback('No video devices found', responseData);
       }
       this.videoDevices = devices;
@@ -227,7 +219,6 @@ getVideoDevices(callback) {
       }
 
       if (!selectedDevice || !selectedCap) {
-        process.stdout.write('--- TRACE: No valid caps found, calling back ---\n');
         return callback('No valid video capabilities found on any device', responseData);
       }
 
@@ -260,20 +251,15 @@ getVideoDevices(callback) {
          responseData.selectedFps = fpsMax > 0 ? fpsMax : (fpsOpts[0]?.value ?? 30);
       }
 
-      process.stdout.write('--- TRACE: Success! Calling final callback. ---\n');
       return callback(null, responseData);
 
     } catch (e) {
-      process.stdout.write('\n--- !!! TRACE: CRITICAL ERROR IN CATCH BLOCK !!! ---\n');
-      process.stdout.write('Error Message: ' + e.message + '\n');
-      process.stdout.write('Error Stack: ' + e.stack + '\n');
       this.winston.info('Error processing video devices:', { message: e.message, stack: e.stack });
       return callback('Failed to process video device information', responseData);
     }
   });
 }
 
-// ... the rest of the file ...
   resetAndReturnDefaults(callback, defaultDevice, defaultCap, defaultFps) {
     this.resetCamera()
     return callback(null, this.videoDevices, false, defaultDevice, defaultCap,
@@ -497,7 +483,7 @@ startCamera(callback) {
     }
 
     const args = ['./python/photomode.py', '--mode=photo']
-    // Don't add a capture device path  unless there actually is one.
+    // Don't add a capture device path unless there actually is one.
     // Device path only used for V4L2 devices.
     if (this.stillSettings.device) {
       args.push('--device=' + this.stillSettings.device);
@@ -721,7 +707,6 @@ startCamera(callback) {
     this.deviceStream.kill('SIGUSR1')
 
     //TODO: add MAVLink control option
-
   }
 
   sendCameraInformation (senderSysId, senderCompId, targetComponent) {
@@ -798,7 +783,6 @@ startCamera(callback) {
       msg.uri = this.deviceAddresses.find(addr => addr.includes(`://${this.videoSettings.mavStreamSelected}:`)
         );
     }
-    //msg.uri='rtsp://uri'
 
     // 1 = VIDEO_STREAM_STATUS_FLAGS_RUNNING
     // 2 = VIDEO_STREAM_STATUS_FLAGS_THERMAL
diff --git a/server/videostream.test.js b/server/videostream.test.js
@@ -146,7 +146,7 @@ describe('Video Functions (CI Safe)', function () {
     });
   });
 
-  describe('startCamera() routing', function () {
+  describe('#startCamera()', function () {
     it('should call startVideoStreaming for "streaming" mode', function () {
       const vManager = new VideoStream(settings, winston);
       vManager.cameraMode = 'streaming';
@@ -302,5 +302,43 @@ describe('Video Functions (CI Safe)', function () {
       const isNotUbuntu = await vManager.isUbuntu();
       assert.strictEqual(isNotUbuntu, false);
     });
+
+    it('should reset all camera settings (resetCamera)', function () {
+      settings.setValue('camera.active', true)
+      settings.setValue('camera.mode', 'photo')
+      settings.setValue('camera.videoSettings', { foo: 'bar' })
+      settings.setValue('camera.stillSettings', { foo: 'bar' })
+      settings.setValue('camera.useHeartbeat', true)
+      const vManager = new VideoStream(settings, winston)
+      vManager.active = true
+      vManager.stillSettings = { foo: 'bar' }
+      vManager.videoSettings = { foo: 'bar' }
+      vManager.resetCamera()
+      assert.equal(vManager.active, false)
+      assert.equal(vManager.videoSettings, null)
+      assert.equal(vManager.stillSettings, null)
+    })
+
+    it('should populate RTSP addresses', function () {
+      const vManager = new VideoStream(settings, winston)
+      sandbox.stub(vManager, 'scanInterfaces').returns(['192.168.1.1', '10.0.0.1'])
+      vManager.populateAddresses('testfactory')
+      assert.ok(vManager.deviceAddresses.some(addr => addr.includes('rtsp://')))
+    })
+
+    it('scanInterfaces returns an array', function () {
+      const vManager = new VideoStream(settings, winston)
+      const ifaces = vManager.scanInterfaces()
+      assert.ok(Array.isArray(ifaces))
+    })
+
+    it('startHeartbeatInterval emits cameraheartbeat', function (done) {
+      const vManager = new VideoStream(settings, winston)
+      vManager.eventEmitter.on('cameraheartbeat', () => {
+        clearInterval(vManager.intervalObj)
+        done()
+      })
+      vManager.startHeartbeatInterval()
+    })
   });
 });
