bonsaif 1.10.39 → 1.10.40

package/tests/README.md

@@ -1,245 +0,0 @@
-# Pruebas de Conexiones Bonsaif
-
-Carpeta con pruebas estándar para validar el correcto funcionamiento de las conexiones a bases de datos.
-
-## 📋 Requisitos Previos
-
-### Opción 1: Docker (Recomendado - Rápido)
-
-```bash
-# Iniciar todos los servicios
-cd tests
-./docker-start.sh
-
-# Detener todos los servicios
-./docker-stop.sh
-
-# Reiniciar todos los servicios
-./docker-restart.sh
-```
-
-El script automáticamente:
-- ✓ Levanta Redis en puerto 6379
-- ✓ Levanta MongoDB en puerto 27017
-- ✓ Levanta MariaDB en puerto 3306 (con base de datos y tabla)
-- ✓ Levanta PostgreSQL en puerto 5432 (con base de datos y tabla)
-
-### Opción 2: Instalación Manual
-
-#### Redis
-```bash
-# Docker
-docker run -d -p 6379:6379 redis:latest
-
-# Homebrew (macOS)
-brew install redis
-redis-server
-```
-
-#### MongoDB
-```bash
-# Docker
-docker run -d -p 27017:27017 mongo:latest
-
-# Homebrew (macOS)
-brew tap mongodb/brew
-brew install mongodb-community
-mongod --config /usr/local/etc/mongod.conf
-```
-
-#### MariaDB/MySQL
-```bash
-# Docker
-docker run -d -p 3306:3306 -e MYSQL_ALLOW_EMPTY_PASSWORD=yes mariadb:latest
-
-# Homebrew (macOS)
-brew install mariadb
-mysql.server start
-
-# Crear tabla de prueba
-mysql -u root
-CREATE DATABASE IF NOT EXISTS test;
-USE test;
-CREATE TABLE IF NOT EXISTS test_users (
-  id INT AUTO_INCREMENT PRIMARY KEY,
-  name VARCHAR(100),
-  email VARCHAR(100),
-  created TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-```
-
-#### PostgreSQL
-```bash
-# Docker
-docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=postgres postgres:latest
-
-# Homebrew (macOS)
-brew install postgresql
-brew services start postgresql
-
-# Crear tabla de prueba
-psql -U postgres
-CREATE DATABASE test;
-\c test
-CREATE TABLE IF NOT EXISTS test_users (
-  id SERIAL PRIMARY KEY,
-  name VARCHAR(100),
-  email VARCHAR(100),
-  created TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-```
-
-## ⚙️ Configuración
-
-1. Copiar el archivo de ejemplo:
-```bash
-cp tests/config.example.js tests/config.js
-```
-
-2. Editar `tests/config.js` con tus credenciales locales
-
-## 🚀 Ejecutar Pruebas
-
-### Pruebas Individuales
-```bash
-# Redis
-node tests/test-redis.js
-
-# MongoDB
-node tests/test-mongodb.js
-
-# Mongoose (ORM para MongoDB)
-node tests/test-mongoose.js
-
-# MariaDB
-node tests/test-mariadb.js
-
-# PostgreSQL
-node tests/test-postgres.js
-```
-
-### Todas las Pruebas
-```bash
-node tests/run-all-tests.js
-```
-
-## 📝 Estructura de Pruebas
-
-Cada archivo de prueba valida:
-
-### Redis
-- ✓ SET (con expiración)
-- ✓ GET
-- ✓ SCAN
-- ✓ SADD / SMEMBERS
-- ✓ HSET / HGETALL
-- ✓ DBSIZE
-- ✓ KEYS
-- ✓ DEL
-
-### MongoDB
-- ✓ INSERT
-- ✓ FIND
-- ✓ UPDATE
-- ✓ COUNT
-- ✓ COMMAND
-- ✓ UPSERT
-- ✓ DBS
-- ✓ COLLECTIONS
-- ✓ DELETEMANY
-
-### Mongoose (ORM para MongoDB)
-- ✓ INSERT (con y sin schemas)
-- ✓ INSERTMANY
-- ✓ FIND (con filtros, sort, limit)
-- ✓ FINDONE
-- ✓ COUNT
-- ✓ UPDATE / UPDATEMANY
-- ✓ UPSERT
-- ✓ DELETE / DELETEMANY
-- ✓ AGGREGATE (pipelines)
-- ✓ DISTINCT
-- ✓ Schema validaciones dinámicas
-- ✓ Populate (referencias)
-
-### MariaDB
-- ✓ INSERT
-- ✓ SELECT
-- ✓ UPDATE
-- ✓ DELETE
-- ✓ COUNT
-- ✓ WHERE queries
-
-### PostgreSQL
-- ✓ INSERT (con RETURNING)
-- ✓ SELECT
-- ✓ UPDATE
-- ✓ DELETE
-- ✓ COUNT
-- ✓ WHERE queries
-
-## 🔍 Validación de Cierre de Conexiones
-
-Las pruebas validan que:
-1. Las conexiones se cierren correctamente después de cada operación
-2. No haya fugas de memoria en operaciones múltiples
-3. Los errores se manejen adecuadamente
-4. El tiempo de respuesta sea razonable
-
-## 📊 Salida Esperada
-
-```
-=== INICIANDO PRUEBAS REDIS ===
-
-1. Probando SET...
-   ✓ SET exitoso: { set: 'test:bonsaif:key', expire: 60, ... }
-
-2. Probando GET...
-   ✓ GET exitoso: { get: 'test:bonsaif:key', res: 'test-value-...' }
-
-...
-
-=== ✓ TODAS LAS PRUEBAS REDIS EXITOSAS ===
-```
-
-## 🐛 Troubleshooting
-
-### Error de conexión
-- Verifica que el servidor esté corriendo
-- Revisa las credenciales en `config.js`
-- Comprueba los puertos
-
-### Timeout
-- Aumenta el timeout en la configuración del servidor
-- Verifica la carga del servidor
-
-### Tabla no existe (MariaDB/PostgreSQL)
-- Ejecuta los scripts SQL de creación de tablas
-- O usa `./docker-start.sh` que las crea automáticamente
-
-### Docker no inicia
-```bash
-# Verificar que Docker esté corriendo
-docker ps
-
-# Ver logs de contenedor
-docker logs bonsaif-redis
-docker logs bonsaif-mongodb
-docker logs bonsaif-mariadb
-docker logs bonsaif-postgres
-
-# Limpiar y reiniciar
-./docker-stop.sh
-./docker-start.sh
-```
-
-### Puerto ya en uso
-```bash
-# Verificar qué está usando el puerto
-lsof -i :6379   # Redis
-lsof -i :27017  # MongoDB
-lsof -i :3306   # MariaDB
-lsof -i :5432   # PostgreSQL
-
-# Detener proceso o cambiar puerto en config.js
-```

package/tests/config.example.js

@@ -1,61 +0,0 @@
-/**
- * Configuración de ejemplo para pruebas locales
- * Copia este archivo a config.js y ajusta los valores según tu entorno
- */
-
-module.exports = {
-  redis: {
-    endpoint: {
-      uri: 'redis://localhost:6379',
-      port: 6379,
-      debug: true
-    },
-    options: {}
-  },
-  
-  mariadb: {
-    endpoint: {
-      uri: 'localhost',
-      port: 3306,
-      user: 'root',
-      password: '',
-      debug: true
-    },
-    options: {
-      db: 'test'
-    }
-  },
-  
-  mongodb: {
-    endpoint: {
-      uri: 'mongodb://localhost:27017',
-      port: 27017,
-      poolSize: 10,
-      debug: true
-    },
-    options: {}
-  },
-    mongoose: {
-    endpoint: {
-      uri: 'mongodb://localhost:27017',
-      port: 27017,
-      poolSize: 10,
-      debug: false,
-      local: true,
-      client: 'mongoose'
-    },
-    options: {}
-  },
-    postgres: {
-    endpoint: {
-      uri: 'localhost',
-      port: 5432,
-      user: 'postgres',
-      password: '',
-      debug: true
-    },
-    options: {
-      db: 'test'
-    }
-  }
-};

package/tests/docker-restart.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Script para reiniciar todos los contenedores Docker de pruebas
-# Ejecutar: chmod +x docker-restart.sh && ./docker-restart.sh
-
-echo "╔════════════════════════════════════════════╗"
-echo "║  REINICIANDO CONTENEDORES DOCKER BONSAIF   ║"
-echo "╚════════════════════════════════════════════╝"
-echo ""
-
-# Detener contenedores
-./docker-stop.sh
-
-echo ""
-echo "Esperando 3 segundos..."
-sleep 3
-echo ""
-
-# Iniciar contenedores
-./docker-start.sh

package/tests/docker-start.sh

@@ -1,192 +0,0 @@
-#!/bin/bash
-
-# Script para levantar todos los contenedores Docker necesarios para pruebas
-# Ejecutar: chmod +x docker-start.sh && ./docker-start.sh
-
-echo "╔════════════════════════════════════════════╗"
-echo "║   INICIANDO CONTENEDORES DOCKER BONSAIF    ║"
-echo "╚════════════════════════════════════════════╝"
-echo ""
-
-# Colores
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Función para verificar si Docker está corriendo
-check_docker() {
-    if ! docker info > /dev/null 2>&1; then
-        echo -e "${RED}✗ Error: Docker no está corriendo${NC}"
-        echo "  Por favor inicia Docker Desktop primero"
-        exit 1
-    fi
-    echo -e "${GREEN}✓ Docker está corriendo${NC}"
-}
-
-# Función para esperar a que un contenedor esté listo
-wait_for_container() {
-    local container=$1
-    local max_attempts=30
-    local attempt=1
-    
-    echo -n "  Esperando a que $container esté listo..."
-    
-    while [ $attempt -le $max_attempts ]; do
-        if docker ps --filter "name=$container" --filter "status=running" | grep -q $container; then
-            echo -e " ${GREEN}✓${NC}"
-            return 0
-        fi
-        echo -n "."
-        sleep 1
-        attempt=$((attempt + 1))
-    done
-    
-    echo -e " ${RED}✗ Timeout${NC}"
-    return 1
-}
-
-# Verificar Docker
-check_docker
-echo ""
-
-# 1. Redis
-echo "▶ Iniciando Redis..."
-docker run -d \
-    --name bonsaif-redis \
-    -p 6379:6379 \
-    --restart unless-stopped \
-    redis:latest > /dev/null 2>&1
-
-if [ $? -eq 0 ]; then
-    wait_for_container bonsaif-redis
-else
-    if docker ps -a --filter "name=bonsaif-redis" | grep -q bonsaif-redis; then
-        echo -e "  ${YELLOW}⚠ Contenedor ya existe, iniciando...${NC}"
-        docker start bonsaif-redis > /dev/null 2>&1
-        wait_for_container bonsaif-redis
-    else
-        echo -e "  ${RED}✗ Error al crear contenedor${NC}"
-    fi
-fi
-
-# 2. MongoDB
-echo "▶ Iniciando MongoDB..."
-docker run -d \
-    --name bonsaif-mongodb \
-    -p 27017:27017 \
-    --restart unless-stopped \
-    mongo:latest > /dev/null 2>&1
-
-if [ $? -eq 0 ]; then
-    wait_for_container bonsaif-mongodb
-else
-    if docker ps -a --filter "name=bonsaif-mongodb" | grep -q bonsaif-mongodb; then
-        echo -e "  ${YELLOW}⚠ Contenedor ya existe, iniciando...${NC}"
-        docker start bonsaif-mongodb > /dev/null 2>&1
-        wait_for_container bonsaif-mongodb
-    else
-        echo -e "  ${RED}✗ Error al crear contenedor${NC}"
-    fi
-fi
-
-# 3. MariaDB
-echo "▶ Iniciando MariaDB..."
-docker run -d \
-    --name bonsaif-mariadb \
-    -p 3306:3306 \
-    -e MYSQL_ALLOW_EMPTY_PASSWORD=yes \
-    -e MYSQL_DATABASE=test \
-    --restart unless-stopped \
-    mariadb:latest > /dev/null 2>&1
-
-if [ $? -eq 0 ]; then
-    wait_for_container bonsaif-mariadb
-    echo "  Esperando inicialización de MariaDB..."
-    sleep 5
-    
-    # Crear tabla de prueba
-    echo "  Creando tabla test_users..."
-    docker exec -i bonsaif-mariadb mariadb -u root test << EOF > /dev/null 2>&1
-CREATE TABLE IF NOT EXISTS test_users (
-  id INT AUTO_INCREMENT PRIMARY KEY,
-  name VARCHAR(100),
-  email VARCHAR(100),
-  created TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-EOF
-    if [ $? -eq 0 ]; then
-        echo -e "  ${GREEN}✓ Tabla creada${NC}"
-    else
-        echo -e "  ${YELLOW}⚠ No se pudo crear la tabla (puede que ya exista)${NC}"
-    fi
-else
-    if docker ps -a --filter "name=bonsaif-mariadb" | grep -q bonsaif-mariadb; then
-        echo -e "  ${YELLOW}⚠ Contenedor ya existe, iniciando...${NC}"
-        docker start bonsaif-mariadb > /dev/null 2>&1
-        wait_for_container bonsaif-mariadb
-    else
-        echo -e "  ${RED}✗ Error al crear contenedor${NC}"
-    fi
-fi
-
-# 4. PostgreSQL
-echo "▶ Iniciando PostgreSQL..."
-docker run -d \
-    --name bonsaif-postgres \
-    -p 5432:5432 \
-    -e POSTGRES_PASSWORD=postgres \
-    -e POSTGRES_DB=test \
-    --restart unless-stopped \
-    postgres:latest > /dev/null 2>&1
-
-if [ $? -eq 0 ]; then
-    wait_for_container bonsaif-postgres
-    echo "  Esperando inicialización de PostgreSQL..."
-    sleep 5
-    
-    # Crear tabla de prueba
-    echo "  Creando tabla test_users..."
-    docker exec -i bonsaif-postgres psql -U postgres -d test << EOF > /dev/null 2>&1
-CREATE TABLE IF NOT EXISTS test_users (
-  id SERIAL PRIMARY KEY,
-  name VARCHAR(100),
-  email VARCHAR(100),
-  created TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-EOF
-    if [ $? -eq 0 ]; then
-        echo -e "  ${GREEN}✓ Tabla creada${NC}"
-    else
-        echo -e "  ${YELLOW}⚠ No se pudo crear la tabla (puede que ya exista)${NC}"
-    fi
-else
-    if docker ps -a --filter "name=bonsaif-postgres" | grep -q bonsaif-postgres; then
-        echo -e "  ${YELLOW}⚠ Contenedor ya existe, iniciando...${NC}"
-        docker start bonsaif-postgres > /dev/null 2>&1
-        wait_for_container bonsaif-postgres
-    else
-        echo -e "  ${RED}✗ Error al crear contenedor${NC}"
-    fi
-fi
-
-# Mostrar estado final
-echo ""
-echo "╔════════════════════════════════════════════╗"
-echo "║           ESTADO DE CONTENEDORES           ║"
-echo "╚════════════════════════════════════════════╝"
-echo ""
-
-docker ps --filter "name=bonsaif-" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
-
-echo ""
-echo -e "${GREEN}✓ Todos los contenedores están listos${NC}"
-echo ""
-echo "Credenciales de conexión:"
-echo "  Redis:      localhost:6379"
-echo "  MongoDB:    mongodb://localhost:27017"
-echo "  MariaDB:    localhost:3306 (user: root, password: vacío)"
-echo "  PostgreSQL: localhost:5432 (user: postgres, password: postgres)"
-echo ""
-echo "Para detener: ./docker-stop.sh"
-echo "Para ver logs: docker logs <nombre-contenedor>"

package/tests/docker-stop.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-
-# Script para detener y eliminar todos los contenedores Docker de pruebas
-# Ejecutar: chmod +x docker-stop.sh && ./docker-stop.sh
-
-echo "╔════════════════════════════════════════════╗"
-echo "║   DETENIENDO CONTENEDORES DOCKER BONSAIF   ║"
-echo "╚════════════════════════════════════════════╝"
-echo ""
-
-# Colores
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-CONTAINERS=(
-    "bonsaif-redis"
-    "bonsaif-mongodb"
-    "bonsaif-mariadb"
-    "bonsaif-postgres"
-)
-
-echo "Deteniendo y eliminando contenedores..."
-echo ""
-
-for container in "${CONTAINERS[@]}"; do
-    if docker ps -a --filter "name=$container" | grep -q $container; then
-        echo -n "▶ $container..."
-        docker stop $container > /dev/null 2>&1
-        docker rm $container > /dev/null 2>&1
-        echo -e " ${GREEN}✓ eliminado${NC}"
-    else
-        echo -e "▶ $container... ${YELLOW}no existe${NC}"
-    fi
-done
-
-echo ""
-echo -e "${GREEN}✓ Limpieza completada${NC}"
-echo ""
-echo "Para volver a iniciar: ./docker-start.sh"

package/tests/run-all-tests.js

@@ -1,76 +0,0 @@
-/**
- * Script para ejecutar todas las pruebas de conexiones
- * Ejecutar: node tests/run-all-tests.js (desde raíz)
- * O también: node run-all-tests.js (desde tests/)
- */
-
-const { exec } = require('child_process');
-const util = require('util');
-const path = require('path');
-const execPromise = util.promisify(exec);
-
-// Directorio donde está este script
-const testsDir = __dirname;
-
-const tests = [
-  { name: 'Redis', file: 'test-redis.js' },
-  { name: 'MongoDB', file: 'test-mongodb.js' },
-  { name: 'Mongoose', file: 'test-mongoose.js' },
-  { name: 'MariaDB', file: 'test-mariadb.js' },
-  { name: 'PostgreSQL', file: 'test-postgres.js' }
-];
-
-async function runAllTests() {
-  console.log('╔════════════════════════════════════════════╗');
-  console.log('║   EJECUTANDO TODAS LAS PRUEBAS BONSAIF     ║');
-  console.log('╚════════════════════════════════════════════╝\n');
-  
-  const results = [];
-  
-  for (const test of tests) {
-    console.log(`\n${'='.repeat(50)}`);
-    console.log(`▶ ${test.name.toUpperCase()}`);
-    console.log('='.repeat(50) + '\n');
-    
-    try {
-      // Construir ruta completa al archivo de test
-      const testPath = path.join(testsDir, test.file);
-      const { stdout, stderr } = await execPromise(`node "${testPath}"`);
-      console.log(stdout);
-      if (stderr && stderr.trim()) {
-        console.error('STDERR:', stderr);
-      }
-      results.push({ name: test.name, status: '✓ EXITOSO', error: null });
-    } catch (error) {
-      console.error(error.stdout || error.message);
-      if (error.stderr) {
-        console.error('STDERR:', error.stderr);
-      }
-      results.push({ name: test.name, status: '✗ FALLIDO', error: error.message });
-    }
-  }
-  
-  // Resumen
-  console.log('\n╔════════════════════════════════════════════╗');
-  console.log('║            RESUMEN DE PRUEBAS              ║');
-  console.log('╚════════════════════════════════════════════╝\n');
-  
-  results.forEach(result => {
-    const status = result.status.includes('✓') ? '✓' : '✗';
-    console.log(`${status} ${result.name.padEnd(20)} ${result.status}`);
-    if (result.error) {
-      console.log(`  Error: ${result.error.split('\n')[0]}`);
-    }
-  });
-  
-  const failed = results.filter(r => r.status.includes('✗'));
-  const passed = results.filter(r => r.status.includes('✓'));
-  
-  console.log(`\nTotal: ${results.length} | Exitosas: ${passed.length} | Fallidas: ${failed.length}\n`);
-  
-  if (failed.length > 0) {
-    process.exit(1);
-  }
-}
-
-runAllTests();