theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/skills/tdd-springboot/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: tdd-springboot
+description: Desarrollo guiado por pruebas (TDD) para Spring Boot con JUnit 5, Mockito, MockMvc, Testcontainers y JaCoCo. Úsala al añadir funcionalidades, corregir bugs o refactorizar servicios Java.
+---
+
+# Flujo TDD para Spring Boot
+
+Guía de TDD para servicios Spring Boot con cobertura de 80 %+ (unitaria + integración).
+
+## Cuándo usarla
+
+- Nuevas funcionalidades o endpoints
+- Correcciones de bugs o refactorizaciones
+- Añadir lógica de acceso a datos o reglas de seguridad
+
+## Flujo de trabajo
+
+1) Escribe primero las pruebas (deben fallar)
+2) Implementa el código mínimo para que pasen
+3) Refactoriza con las pruebas en verde
+4) Exige la cobertura (JaCoCo)
+
+## Pruebas unitarias (JUnit 5 + Mockito)
+
+```java
+@ExtendWith(MockitoExtension.class)
+class MarketServiceTest {
+  @Mock MarketRepository repo;
+  @InjectMocks MarketService service;
+
+  @Test
+  void createsMarket() {
+    CreateMarketRequest req = new CreateMarketRequest("name", "desc", Instant.now(), List.of("cat"));
+    when(repo.save(any())).thenAnswer(inv -> inv.getArgument(0));
+
+    Market result = service.create(req);
+
+    assertThat(result.name()).isEqualTo("name");
+    verify(repo).save(any());
+  }
+}
+```
+
+Patrones:
+- Arrange-Act-Assert (preparar, actuar, verificar)
+- Evita mocks parciales; prefiere stubbing explícito
+- Usa `@ParameterizedTest` para las variantes
+
+## Pruebas de la capa web (MockMvc)
+
+```java
+@WebMvcTest(MarketController.class)
+class MarketControllerTest {
+  @Autowired MockMvc mockMvc;
+  @MockBean MarketService marketService;
+
+  @Test
+  void returnsMarkets() throws Exception {
+    when(marketService.list(any())).thenReturn(Page.empty());
+
+    mockMvc.perform(get("/api/markets"))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.content").isArray());
+  }
+}
+```
+
+## Pruebas de integración (SpringBootTest)
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+class MarketIntegrationTest {
+  @Autowired MockMvc mockMvc;
+
+  @Test
+  void createsMarket() throws Exception {
+    mockMvc.perform(post("/api/markets")
+        .contentType(MediaType.APPLICATION_JSON)
+        .content("""
+          {"name":"Test","description":"Desc","endDate":"2030-01-01T00:00:00Z","categories":["general"]}
+        """))
+      .andExpect(status().isCreated());
+  }
+}
+```
+
+## Pruebas de persistencia (DataJpaTest)
+
+```java
+@DataJpaTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+@Import(TestContainersConfig.class)
+class MarketRepositoryTest {
+  @Autowired MarketRepository repo;
+
+  @Test
+  void savesAndFinds() {
+    MarketEntity entity = new MarketEntity();
+    entity.setName("Test");
+    repo.save(entity);
+
+    Optional<MarketEntity> found = repo.findByName("Test");
+    assertThat(found).isPresent();
+  }
+}
+```
+
+## Testcontainers
+
+- Usa contenedores reutilizables para Postgres/Redis y así replicar producción
+- Conéctalos vía `@DynamicPropertySource` para inyectar las URL JDBC en el contexto de Spring
+
+## Cobertura (JaCoCo)
+
+Fragmento de Maven:
+```xml
+<plugin>
+  <groupId>org.jacoco</groupId>
+  <artifactId>jacoco-maven-plugin</artifactId>
+  <version>0.8.14</version>
+  <executions>
+    <execution>
+      <goals><goal>prepare-agent</goal></goals>
+    </execution>
+    <execution>
+      <id>report</id>
+      <phase>verify</phase>
+      <goals><goal>report</goal></goals>
+    </execution>
+  </executions>
+</plugin>
+```
+
+## Aserciones
+
+- Prefiere AssertJ (`assertThat`) por legibilidad
+- Para respuestas JSON, usa `jsonPath`
+- Para excepciones: `assertThatThrownBy(...)`
+
+## Builders de datos de prueba
+
+```java
+class MarketBuilder {
+  private String name = "Test";
+  MarketBuilder withName(String name) { this.name = name; return this; }
+  Market build() { return new Market(null, name, MarketStatus.ACTIVE); }
+}
+```
+
+## Comandos de CI
+
+- Maven: `mvn -T 4 test` o `mvn verify`
+- Gradle: `./gradlew test jacocoTestReport`
+
+**Recuerda**: mantén las pruebas rápidas, aisladas y deterministas. Prueba el comportamiento, no los detalles de implementación.
+
+## Skills relacionadas
+
+- `patrones-springboot`
+- `seguridad-springboot`
+- `verificacion-springboot`
+- `patrones-jpa`
+- `flujo-tdd`

package/vendor/theus-arsenal/skills/testing-cpp/SKILL.md

@@ -0,0 +1,328 @@
+---
+name: testing-cpp
+description: Úsala solo al escribir, actualizar o corregir tests de C++, configurar GoogleTest/CTest,
+  diagnosticar tests fallidos o inestables, o añadir cobertura y sanitizers.
+---
+
+# Testing en C++
+
+Flujo de pruebas orientado al agente para C++ moderno (C++17/20) usando GoogleTest/GoogleMock con CMake/CTest.
+
+## Cuándo usarla
+
+- Al escribir tests de C++ nuevos o corregir tests existentes.
+- Al diseñar cobertura de tests unitarios/de integración para componentes C++.
+- Al añadir cobertura, gating de CI o protección contra regresiones.
+- Al configurar flujos de CMake/CTest para una ejecución consistente.
+- Al investigar fallos de tests o comportamiento inestable (flaky).
+- Al habilitar sanitizers para diagnóstico de memoria o carreras.
+
+### Cuándo NO usarla
+
+- Implementar funcionalidades nuevas de producto sin cambios en tests.
+- Refactorizaciones a gran escala no relacionadas con cobertura o fallos de tests.
+- Ajuste de rendimiento sin regresiones de tests que validar.
+- Proyectos que no son C++ o tareas ajenas a los tests.
+
+## Conceptos clave
+
+- **Bucle TDD**: rojo → verde → refactor (tests primero, arreglo mínimo, luego limpieza).
+- **Aislamiento**: prefiere inyección de dependencias y fakes sobre estado global.
+- **Layout de tests**: `tests/unit`, `tests/integration`, `tests/testdata`.
+- **Mocks vs fakes**: mock para interacciones, fake para comportamiento con estado.
+- **Descubrimiento en CTest**: usa `gtest_discover_tests()` para un descubrimiento estable.
+- **Señal de CI**: ejecuta primero un subconjunto, luego la suite completa con `--output-on-failure`.
+
+## Flujo TDD
+
+Sigue el bucle ROJO → VERDE → REFACTOR:
+
+1. **ROJO**: escribe un test que falle y capture el nuevo comportamiento.
+2. **VERDE**: implementa el cambio más pequeño que lo haga pasar.
+3. **REFACTOR**: limpia mientras los tests siguen en verde.
+
+```cpp
+// tests/add_test.cpp
+#include <gtest/gtest.h>
+
+int Add(int a, int b); // Provisto por el código de producción.
+
+TEST(AddTest, SumaDosNumeros) { // ROJO
+  EXPECT_EQ(Add(2, 3), 5);
+}
+
+// src/add.cpp
+int Add(int a, int b) { // VERDE
+  return a + b;
+}
+
+// REFACTOR: simplificar/renombrar una vez que los tests pasan
+```
+
+## Ejemplos de código
+
+### Test unitario básico (gtest)
+
+```cpp
+// tests/calculator_test.cpp
+#include <gtest/gtest.h>
+
+int Add(int a, int b); // Provisto por el código de producción.
+
+TEST(CalculatorTest, SumaDosNumeros) {
+    EXPECT_EQ(Add(2, 3), 5);
+}
+```
+
+### Fixture (gtest)
+
+```cpp
+// tests/user_store_test.cpp
+// Stub de pseudocódigo: reemplaza UserStore/User por los tipos del proyecto.
+#include <gtest/gtest.h>
+#include <memory>
+#include <optional>
+#include <string>
+
+struct User { std::string name; };
+class UserStore {
+public:
+    explicit UserStore(std::string /*path*/) {}
+    void Seed(std::initializer_list<User> /*users*/) {}
+    std::optional<User> Find(const std::string &/*name*/) { return User{"alice"}; }
+};
+
+class UserStoreTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        store = std::make_unique<UserStore>(":memory:");
+        store->Seed({{"alice"}, {"bob"}});
+    }
+
+    std::unique_ptr<UserStore> store;
+};
+
+TEST_F(UserStoreTest, EncuentraUsuarioExistente) {
+    auto user = store->Find("alice");
+    ASSERT_TRUE(user.has_value());
+    EXPECT_EQ(user->name, "alice");
+}
+```
+
+### Mock (gmock)
+
+```cpp
+// tests/notifier_test.cpp
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <string>
+
+class Notifier {
+public:
+    virtual ~Notifier() = default;
+    virtual void Send(const std::string &message) = 0;
+};
+
+class MockNotifier : public Notifier {
+public:
+    MOCK_METHOD(void, Send, (const std::string &message), (override));
+};
+
+class Service {
+public:
+    explicit Service(Notifier &notifier) : notifier_(notifier) {}
+    void Publish(const std::string &message) { notifier_.Send(message); }
+
+private:
+    Notifier &notifier_;
+};
+
+TEST(ServiceTest, EnviaNotificaciones) {
+    MockNotifier notifier;
+    Service service(notifier);
+
+    EXPECT_CALL(notifier, Send("hola")).Times(1);
+    service.Publish("hola");
+}
+```
+
+### Inicio rápido con CMake/CTest
+
+```cmake
+# CMakeLists.txt (extracto)
+cmake_minimum_required(VERSION 3.20)
+project(example LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+# Prefiere versiones fijadas por el proyecto. Si usas un tag, fíjalo según la política del proyecto.
+set(GTEST_VERSION v1.17.0) # Ajustar a la política del proyecto.
+FetchContent_Declare(
+  googletest
+  # Framework Google Test (repositorio oficial)
+  URL https://github.com/google/googletest/archive/refs/tags/${GTEST_VERSION}.zip
+)
+FetchContent_MakeAvailable(googletest)
+
+add_executable(example_tests
+  tests/calculator_test.cpp
+  src/calculator.cpp
+)
+target_link_libraries(example_tests GTest::gtest GTest::gmock GTest::gtest_main)
+
+enable_testing()
+include(GoogleTest)
+gtest_discover_tests(example_tests)
+```
+
+```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
+cmake --build build -j
+ctest --test-dir build --output-on-failure
+```
+
+## Ejecutar tests
+
+```bash
+ctest --test-dir build --output-on-failure
+ctest --test-dir build -R ClampTest
+ctest --test-dir build -R "UserStoreTest.*" --output-on-failure
+```
+
+```bash
+./build/example_tests --gtest_filter=ClampTest.*
+./build/example_tests --gtest_filter=UserStoreTest.EncuentraUsuarioExistente
+```
+
+## Depurar fallos
+
+1. Reejecuta el único test que falla con el filtro de gtest.
+2. Añade logging acotado alrededor de la aserción que falla.
+3. Reejecuta con los sanitizers habilitados.
+4. Amplía a la suite completa una vez corregida la causa raíz.
+
+## Cobertura
+
+Prefiere configuración a nivel de target en lugar de flags globales.
+
+```cmake
+option(ENABLE_COVERAGE "Habilitar flags de cobertura" OFF)
+
+if(ENABLE_COVERAGE)
+  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+    target_compile_options(example_tests PRIVATE --coverage)
+    target_link_options(example_tests PRIVATE --coverage)
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_compile_options(example_tests PRIVATE -fprofile-instr-generate -fcoverage-mapping)
+    target_link_options(example_tests PRIVATE -fprofile-instr-generate)
+  endif()
+endif()
+```
+
+GCC + gcov + lcov:
+
+```bash
+cmake -S . -B build-cov -DENABLE_COVERAGE=ON
+cmake --build build-cov -j
+ctest --test-dir build-cov
+lcov --capture --directory build-cov --output-file coverage.info
+lcov --remove coverage.info '/usr/*' --output-file coverage.info
+genhtml coverage.info --output-directory coverage
+```
+
+Clang + llvm-cov:
+
+```bash
+cmake -S . -B build-llvm -DENABLE_COVERAGE=ON -DCMAKE_CXX_COMPILER=clang++
+cmake --build build-llvm -j
+LLVM_PROFILE_FILE="build-llvm/default.profraw" ctest --test-dir build-llvm
+llvm-profdata merge -sparse build-llvm/default.profraw -o build-llvm/default.profdata
+llvm-cov report build-llvm/example_tests -instr-profile=build-llvm/default.profdata
+```
+
+## Sanitizers
+
+```cmake
+option(ENABLE_ASAN "Habilitar AddressSanitizer" OFF)
+option(ENABLE_UBSAN "Habilitar UndefinedBehaviorSanitizer" OFF)
+option(ENABLE_TSAN "Habilitar ThreadSanitizer" OFF)
+
+if(ENABLE_ASAN)
+  add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
+  add_link_options(-fsanitize=address)
+endif()
+if(ENABLE_UBSAN)
+  add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
+  add_link_options(-fsanitize=undefined)
+endif()
+if(ENABLE_TSAN)
+  add_compile_options(-fsanitize=thread)
+  add_link_options(-fsanitize=thread)
+endif()
+```
+
+## Barandillas contra tests inestables
+
+- Nunca uses `sleep` para sincronizar; usa variables de condición o latches.
+- Haz los directorios temporales únicos por test y límpialos siempre.
+- Evita dependencias de tiempo real, red o sistema de archivos en tests unitarios.
+- Usa semillas deterministas para entradas aleatorizadas.
+
+## Buenas prácticas
+
+### SÍ
+
+- Mantén los tests deterministas y aislados.
+- Prefiere inyección de dependencias sobre globales.
+- Usa `ASSERT_*` para precondiciones, `EXPECT_*` para verificaciones múltiples.
+- Separa tests unitarios y de integración con etiquetas de CTest o directorios.
+- Ejecuta sanitizers en CI para detección de memoria y carreras.
+
+### NO
+
+- No dependas de tiempo real ni de red en tests unitarios.
+- No uses sleeps como sincronización cuando puede usarse una variable de condición.
+- No hagas mocks excesivos de objetos de valor simples.
+- No uses coincidencias de cadenas frágiles para logs no críticos.
+
+### Errores comunes
+
+- **Rutas temporales fijas** → genera directorios temporales únicos por test y límpialos.
+- **Depender del reloj de pared** → inyecta un reloj o usa fuentes de tiempo falsas.
+- **Tests de concurrencia inestables** → usa variables de condición/latches y esperas acotadas.
+- **Estado global oculto** → resetea el estado global en fixtures o elimina los globales.
+- **Mocks excesivos** → prefiere fakes para comportamiento con estado y mockea solo interacciones.
+- **Sin ejecuciones con sanitizers** → añade builds ASan/UBSan/TSan en CI.
+- **Cobertura solo en builds de debug** → asegura que los targets de cobertura usen flags consistentes.
+
+## Apéndice opcional: fuzzing / testing de propiedades
+
+Úsalo solo si el proyecto ya soporta LLVM/libFuzzer o una biblioteca de testing de propiedades.
+
+- **libFuzzer**: ideal para funciones puras con E/S mínima.
+- **RapidCheck**: tests basados en propiedades para validar invariantes.
+
+Harness mínimo de libFuzzer (pseudocódigo: reemplaza ParseConfig):
+
+```cpp
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    std::string input(reinterpret_cast<const char *>(data), size);
+    // ParseConfig(input); // función del proyecto
+    return 0;
+}
+```
+
+## Alternativas a GoogleTest
+
+- **Catch2**: header-only, matchers expresivos.
+- **doctest**: ligero, sobrecarga de compilación mínima.
+
+## Skills relacionadas
+
+- `estandares-cpp` para los estándares de codificación de C++ moderno.