Fix jwt-token

server/tests/setup.js

@@ -0,0 +1,248 @@
+const { createTestDatabase, destroyTestDatabase } = require('./test-database');
+const { Sequelize } = require('sequelize');
+const path = require('path');
+
+// Test database configuration
+const testDatabase = {
+  dialect: 'sqlite',
+  storage: ':memory:', // In-memory database for fast tests
+  logging: false, // Disable SQL logging in tests
+  sync: { force: true } // Always recreate tables for tests
+};
+
+let sequelize;
+let models;
+
+/**
+ * Setup test environment before all tests
+ */
+async function setupTestEnvironment() {
+  // Create test database connection
+  sequelize = new Sequelize(testDatabase);
+  
+  // Import models
+  models = require('../models')(sequelize);
+  
+  // Sync database
+  await sequelize.sync({ force: true });
+  
+  // Return test context
+  return { sequelize, models };
+}
+
+/**
+ * Cleanup test environment after all tests
+ */
+async function teardownTestEnvironment() {
+  if (sequelize) {
+    await sequelize.close();
+  }
+}
+
+/**
+ * Clean database between tests
+ */
+async function cleanDatabase() {
+  if (sequelize) {
+    await sequelize.sync({ force: true });
+  }
+}
+
+/**
+ * Create test user with specified role and tenant
+ */
+async function createTestUser(userData = {}) {
+  const { User, Tenant } = models;
+  
+  // Create default tenant if not exists
+  let tenant = await Tenant.findOne({ where: { slug: 'test-tenant' } });
+  if (!tenant) {
+    tenant = await Tenant.create({
+      name: 'Test Tenant',
+      slug: 'test-tenant',
+      domain: 'test.example.com',
+      is_active: true
+    });
+  }
+  
+  const defaultUserData = {
+    username: 'testuser',
+    email: 'test@example.com',
+    password: 'password123',
+    role: 'admin',
+    tenant_id: tenant.id,
+    is_active: true,
+    ...userData
+  };
+  
+  return await User.create(defaultUserData);
+}
+
+/**
+ * Create test device with specified tenant
+ */
+async function createTestDevice(deviceData = {}) {
+  const { Device, Tenant } = models;
+  
+  // Create default tenant if not exists
+  let tenant = await Tenant.findOne({ where: { slug: 'test-tenant' } });
+  if (!tenant) {
+    tenant = await Tenant.create({
+      name: 'Test Tenant',
+      slug: 'test-tenant',
+      domain: 'test.example.com',
+      is_active: true
+    });
+  }
+  
+  const defaultDeviceData = {
+    id: Math.floor(Math.random() * 1000000000),
+    name: 'Test Device',
+    geo_lat: 59.3293,
+    geo_lon: 18.0686,
+    location_description: 'Test Location',
+    tenant_id: tenant.id,
+    is_active: true,
+    is_approved: true,
+    ...deviceData
+  };
+  
+  return await Device.create(defaultDeviceData);
+}
+
+/**
+ * Create test detection data
+ */
+async function createTestDetection(detectionData = {}) {
+  const { DroneDetection, Device } = models;
+  
+  // Create device if not provided
+  let device;
+  if (detectionData.device_id) {
+    device = await Device.findByPk(detectionData.device_id);
+  }
+  if (!device) {
+    device = await createTestDevice();
+  }
+  
+  const defaultDetectionData = {
+    device_id: device.id,
+    geo_lat: device.geo_lat,
+    geo_lon: device.geo_lon,
+    device_timestamp: Date.now(),
+    server_timestamp: new Date(),
+    drone_type: 2,
+    rssi: -65,
+    freq: 2400,
+    drone_id: Math.floor(Math.random() * 10000),
+    ...detectionData
+  };
+  
+  return await DroneDetection.create(defaultDetectionData);
+}
+
+/**
+ * Create test tenant
+ */
+async function createTestTenant(tenantData = {}) {
+  const { Tenant } = models;
+  
+  const defaultTenantData = {
+    name: 'Test Tenant',
+    slug: 'test-tenant-' + Date.now(),
+    domain: 'test.example.com',
+    is_active: true,
+    ...tenantData
+  };
+  
+  return await Tenant.create(defaultTenantData);
+}
+
+/**
+ * Generate JWT token for test user
+ */
+function generateTestToken(user, tenant = null) {
+  const jwt = require('jsonwebtoken');
+  const payload = {
+    userId: user.id,
+    username: user.username,
+    role: user.role,
+    email: user.email
+  };
+  
+  if (tenant) {
+    payload.tenantId = tenant.slug;
+  }
+  
+  return jwt.sign(payload, process.env.JWT_SECRET || 'test-secret', { expiresIn: '1h' });
+}
+
+/**
+ * Mock Express request object
+ */
+function mockRequest(overrides = {}) {
+  return {
+    body: {},
+    params: {},
+    query: {},
+    headers: {},
+    get: function(header) {
+      return this.headers[header.toLowerCase()];
+    },
+    ...overrides
+  };
+}
+
+/**
+ * Mock Express response object
+ */
+function mockResponse() {
+  const res = {
+    statusCode: 200,
+    data: null,
+    status: function(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json: function(data) {
+      this.data = data;
+      return this;
+    },
+    send: function(data) {
+      this.data = data;
+      return this;
+    },
+    setHeader: function(name, value) {
+      this.headers = this.headers || {};
+      this.headers[name] = value;
+      return this;
+    }
+  };
+  return res;
+}
+
+/**
+ * Mock Express next function
+ */
+function mockNext() {
+  const errors = [];
+  const next = function(error) {
+    if (error) errors.push(error);
+  };
+  next.errors = errors;
+  return next;
+}
+
+module.exports = {
+  setupTestEnvironment,
+  teardownTestEnvironment,
+  cleanDatabase,
+  createTestUser,
+  createTestDevice,
+  createTestDetection,
+  createTestTenant,
+  generateTestToken,
+  mockRequest,
+  mockResponse,
+  mockNext
+};