espid2sensor/tests/server.test.js

const express = require('express');
const bodyParser = require('body-parser');
const request = require('supertest');

// ...existing code...
// tests/server.test.js
describe('Server.js API', () => {
  let app;
  let entries = [];
  let users = [];

  beforeEach(() => {
    app = express();
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: true }));

    // Mock session middleware
    app.use((req, res, next) => { req.session = {}; next(); });

    // /api/check-email
    app.get('/api/check-email', (req, res) => {
      const email = (req.query.email || '').toLowerCase().trim();
      if (!email) return res.json({ exists: false });
      const existingUser = users.find(u => u.email === email);
      res.json({ exists: !!existingUser });
    });

    // /api/save
    app.post('/api/save', (req, res) => {
      let { espId, sensorNumber, name, description, address } = req.body;
      if (!espId || !sensorNumber) {
        return res.json({ error: 'ESP-ID und Sensornummer sind Pflichtfelder' });
      }
      sensorNumber = parseInt(sensorNumber, 10);
      const doc = { espId, sensorNumber, name, description, address, lastUpdatedAt: new Date(), _id: String(entries.length + 1) };
      entries.push(doc);
      res.json({ success: true });
    });

    // /api/update/:id
    app.put('/api/update/:id', (req, res) => {
      const { id } = req.params;
      let { espId, sensorNumber, name, description, address } = req.body;
      if (!espId || !sensorNumber) {
        return res.json({ error: 'ESP-ID und Sensornummer sind Pflichtfelder' });
      }
      sensorNumber = parseInt(sensorNumber, 10);
      const idx = entries.findIndex(e => e._id === id);
      if (idx === -1) return res.status(404).json({ error: 'Not found' });
      entries[idx] = { ...entries[idx], espId, sensorNumber, name, description, address };
      res.json({ success: true });
    });

    // /api/list
    app.get('/api/list', (req, res) => {
      const { id } = req.query;
      if (id) {
        const item = entries.find(e => e._id === id);
        return res.json(item ? [item] : []);
      }
      const page = parseInt(req.query.page) || 1;
      const limit = parseInt(req.query.limit) || 10;
      const skip = (page - 1) * limit;
      res.json(entries.slice(skip, skip + limit));
    });

    // /api/delete/:id
    app.delete('/api/delete/:id', (req, res) => {
      const { id } = req.params;
      entries = entries.filter(e => e._id !== id);
      res.json({ success: true });
    });

    // /api/address/:sensorNumber
    app.get('/api/address/:sensorNumber', (req, res) => {
      const sensorNumber = parseInt(req.params.sensorNumber, 10);
      if (isNaN(sensorNumber)) {
        return res.status(400).json({ error: 'Ungültige Sensornummer' });
      }
      // Dummy logic
      if (sensorNumber === 1001) {
        return res.json({ address: 'Musterstraße 1, 12345 Musterstadt', parts: { street: 'Musterstraße 1', plz: '12345', city: 'Musterstadt' } });
      }
      return res.status(404).json({ error: 'Sensor unbekannt' });
    });
  });

  beforeEach(() => {
    entries = [];
    users = [{ email: 'test@example.com', passwordHash: 'hash' }];
  });

  test('GET /api/check-email returns exists: true for known user', async () => {
    const res = await request(app).get('/api/check-email?email=test@example.com');
    expect(res.statusCode).toBe(200);
    expect(res.body).toHaveProperty('exists', true);
  });

  test('GET /api/check-email returns exists: false for unknown user', async () => {
    const res = await request(app).get('/api/check-email?email=unknown@example.com');
    expect(res.statusCode).toBe(200);
    expect(res.body).toHaveProperty('exists', false);
  });

  test('POST /api/save creates entry', async () => {
    const res = await request(app).post('/api/save').send({ espId: 'esp1', sensorNumber: '1001', name: 'Test', description: 'Desc', address: 'Addr' });
    expect(res.statusCode).toBe(200);
    expect(res.body).toHaveProperty('success', true);
    expect(entries.length).toBe(1);
  });

  test('POST /api/save fails without espId', async () => {
    const res = await request(app).post('/api/save').send({ sensorNumber: '1001' });
    expect(res.body).toHaveProperty('error');
  });

  test('PUT /api/update/:id updates entry', async () => {
    entries.push({ _id: '1', espId: 'esp1', sensorNumber: 1001, name: '', description: '', address: '', lastUpdatedAt: new Date() });
    const res = await request(app).put('/api/update/1').send({ espId: 'esp2', sensorNumber: '1002', name: 'Neu', description: 'Neu', address: 'Neu' });
    expect(res.body).toHaveProperty('success', true);
    expect(entries[0].espId).toBe('esp2');
  });

  test('PUT /api/update/:id fails for unknown id', async () => {
    const res = await request(app).put('/api/update/999').send({ espId: 'esp2', sensorNumber: '1002', name: 'Neu', description: 'Neu', address: 'Neu' });
    expect(res.statusCode).toBe(404);
  });

  test('GET /api/list returns all entries', async () => {
    entries.push({ _id: '1', espId: 'esp1', sensorNumber: 1001, name: '', description: '', address: '', lastUpdatedAt: new Date() });
    const res = await request(app).get('/api/list');
    expect(res.body.length).toBe(1);
  });

  test('GET /api/list?id returns specific entry', async () => {
    entries.push({ _id: '1', espId: 'esp1', sensorNumber: 1001, name: '', description: '', address: '', lastUpdatedAt: new Date() });
    const res = await request(app).get('/api/list?id=1');
    expect(res.body.length).toBe(1);
    expect(res.body[0]._id).toBe('1');
  });

  test('DELETE /api/delete/:id deletes entry', async () => {
    entries.push({ _id: '1', espId: 'esp1', sensorNumber: 1001, name: '', description: '', address: '', lastUpdatedAt: new Date() });
    const res = await request(app).delete('/api/delete/1');
    expect(res.body).toHaveProperty('success', true);
    expect(entries.length).toBe(0);
  });

  test('GET /api/address/:sensorNumber returns address for known sensor', async () => {
    const res = await request(app).get('/api/address/1001');
    expect(res.body).toHaveProperty('address', 'Musterstraße 1, 12345 Musterstadt');
  });

  test('GET /api/address/:sensorNumber returns error for unknown sensor', async () => {
    const res = await request(app).get('/api/address/9999');
    expect(res.statusCode).toBe(404);
    expect(res.body).toHaveProperty('error', 'Sensor unbekannt');
  });

  test('GET /api/address/:sensorNumber returns error for invalid sensor', async () => {
    const res = await request(app).get('/api/address/abc');
    expect(res.statusCode).toBe(400);
    expect(res.body).toHaveProperty('error', 'Ungültige Sensornummer');
  });
});