chore: release 1.5.1

fix: s3 port type mismatch, add string_or_number_to_string deserializer (#42 )
Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>
2026-09-12 06:23:42 +00:00 · 2026-03-16 07:59:25 +00:00 · 2026-03-16 08:57:00 +01:00 · 2026-03-15 11:06:29 +00:00 · 2026-03-15 12:04:05 +01:00 · 2026-03-14 20:08:26 +01:00
31 changed files with 744 additions and 200 deletions
@@ -2,9 +2,9 @@ name: Codecov Rust

 on:
  push:
-    branches: [ "main" ]
+    branches: ["main"]
  pull_request:
-    branches: [ "main" ]
+    branches: ["main"]

 env:
  CARGO_TERM_COLOR: always
@@ -12,26 +12,47 @@ env:
 jobs:
  build:
    runs-on: ubuntu-latest
+
    steps:
      - uses: actions/checkout@v3
+
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly
+          toolchain: stable
          override: true
+          components: llvm-tools-preview
+
+      - name: Install grcov
+        run: cargo install grcov
+
+      - name: Install test requirements
+        run: bash scripts/tests/requirements.sh
+
      - name: Build
        run: cargo build --verbose
+
      - name: Run tests
+        env:
+          CARGO_INCREMENTAL: 0
+          RUSTFLAGS: "-C instrument-coverage"
+          LLVM_PROFILE_FILE: "cargo-test-%p-%m.profraw"
        run: cargo test --verbose
-        env:
-          CARGO_INCREMENTAL: '0'
-          RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Cpanic=abort -Zpanic_abort_tests'
-          RUSTDOCFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Cpanic=abort -Zpanic_abort_tests'
-      - name: rust-grcov
-        uses: actions-rs/grcov@v0.1
-      - name: Codecov
+
+      - name: Generate coverage
+        run: |
+          grcov . \
+            --binary-path ./target/debug/ \
+            -s . \
+            -t lcov \
+            --branch \
+            --ignore-not-existing \
+            -o lcov.info
+
+      - name: Upload to Codecov
        uses: codecov/codecov-action@v5
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_ORG_TOKEN }}
        with:
+          files: lcov.info
          verbose: true
-          fail_ci_if_error: true
+          fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -27,5 +27,5 @@ keywords:
  - self-hosted
  - portabase
 license: Apache-2.0
-version: 1.4.1
+version: 1.5.1
 date-released: '2026-02-24'
@@ -82,9 +82,9 @@ dependencies = [

 [[package]]
 name = "anstyle"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"

 [[package]]
 name = "anyhow"
@@ -275,9 +275,9 @@ dependencies = [

 [[package]]
 name = "aws-sdk-s3"
-version = "1.125.0"
+version = "1.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "223f5c95650d9557925a91f4c2db3def189e8f659452134a29e5cd2d37d708ed"
+checksum = "7878050a2321d215eec9db8be09f8db59418b53860ae86cc7042b4094d6cb2bb"
 dependencies = [
 "aws-credential-types",
 "aws-runtime",
@@ -744,9 +744,9 @@ dependencies = [

 [[package]]
 name = "bollard"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "227aa051deec8d16bd9c34605e7aaf153f240e35483dd42f6f78903847934738"
+checksum = "ee04c4c84f1f811b017f2fbb7dd8815c976e7ca98593de9c1e2afad0f636bff4"
 dependencies = [
 "async-stream",
 "base64 0.22.1",
@@ -869,9 +869,9 @@ dependencies = [

 [[package]]
 name = "cc"
-version = "1.2.56"
+version = "1.2.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
 dependencies = [
 "find-msvc-tools",
 "jobserver",
@@ -1199,9 +1199,9 @@ dependencies = [

 [[package]]
 name = "darling"
-version = "0.21.3"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
 dependencies = [
 "darling_core",
 "darling_macro",
@@ -1209,11 +1209,10 @@ dependencies = [

 [[package]]
 name = "darling_core"
-version = "0.21.3"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
 dependencies = [
- "fnv",
 "ident_case",
 "proc-macro2",
 "quote",
@@ -1223,9 +1222,9 @@ dependencies = [

 [[package]]
 name = "darling_macro"
-version = "0.21.3"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
 dependencies = [
 "darling_core",
 "quote",
@@ -1289,9 +1288,9 @@ dependencies = [

 [[package]]
 name = "derive-where"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef941ded77d15ca19b40374869ac6000af1c9f2a4c0f3d4c70926287e6364a8f"
+checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1957,9 +1956,9 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"

 [[package]]
 name = "hybrid-array"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b229d73f5803b562cc26e4da0396c8610a4ee209f4fac8fa4f8d709166dc45"
+checksum = "8655f91cd07f2b9d0c24137bd650fe69617773435ee5ec83022377777ce65ef1"
 dependencies = [
 "typenum",
 ]
@@ -2821,9 +2820,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 dependencies = [
 "critical-section",
 "portable-atomic",
@@ -2831,9 +2830,9 @@ dependencies = [

 [[package]]
 name = "openssl"
-version = "0.10.75"
+version = "0.10.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+checksum = "951c002c75e16ea2c65b8c7e4d3d51d5530d8dfa7d060b4776828c88cfb18ecf"
 dependencies = [
 "bitflags 2.11.0",
 "cfg-if",
@@ -2863,9 +2862,9 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"

 [[package]]
 name = "openssl-sys"
-version = "0.9.111"
+version = "0.9.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+checksum = "57d55af3b3e226502be1526dfdba67ab0e9c96fc293004e79576b2b9edb0dbdb"
 dependencies = [
 "cc",
 "libc",
@@ -3039,7 +3038,7 @@ dependencies = [

 [[package]]
 name = "portabase-agent"
-version = "1.4.1"
+version = "1.5.1"
 dependencies = [
 "aes",
 "aes-gcm",
@@ -3088,6 +3087,7 @@ dependencies = [
 "tracing-appender",
 "tracing-subscriber",
 "typenum",
+ "url",
 "uuid",
 "wiremock",
 ]
@@ -3264,9 +3264,9 @@ dependencies = [

 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
 "aws-lc-rs",
 "bytes",
@@ -3771,9 +3771,9 @@ dependencies = [

 [[package]]
 name = "schannel"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
 "windows-sys 0.61.2",
 ]
@@ -3960,9 +3960,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "3.17.0"
+version = "3.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+checksum = "dd5414fad8e6907dbdd5bc441a50ae8d6e26151a03b1de04d89a5576de61d01f"
 dependencies = [
 "base64 0.22.1",
 "chrono",
@@ -3979,9 +3979,9 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "3.17.0"
+version = "3.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+checksum = "d3db8978e608f1fe7357e211969fd9abdcae80bac1ba7a3369bb7eb6b404eb65"
 dependencies = [
 "darling",
 "proc-macro2",
@@ -4247,9 +4247,9 @@ dependencies = [

 [[package]]
 name = "tempfile"
-version = "3.26.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
 "fastrand",
 "getrandom 0.4.2",
@@ -4407,9 +4407,9 @@ dependencies = [

 [[package]]
 name = "tinyvec"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
 dependencies = [
 "tinyvec_macros",
 ]
@@ -4719,9 +4719,9 @@ dependencies = [

 [[package]]
 name = "tracing-subscriber"
-version = "0.3.22"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
 dependencies = [
 "chrono",
 "matchers",
@@ -5735,18 +5735,18 @@ dependencies = [

 [[package]]
 name = "zerocopy"
-version = "0.8.40"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+checksum = "f2578b716f8a7a858b7f02d5bd870c14bf4ddbbcf3a4c05414ba6503640505e3"
 dependencies = [
 "zerocopy-derive",
 ]

 [[package]]
 name = "zerocopy-derive"
-version = "0.8.40"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.4.1"
+version = "1.5.1"
 edition = "2024"

 [dependencies]
@@ -49,13 +49,15 @@ tokio-stream = "0.1.18"
 aes = "0.9.0-rc.4"
 typenum = "1.19.0"
 testcontainers = "0.27.1"
-testcontainers-modules = { version = "0.15.0", features = ["postgres"] }
+testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis"] }
 postgres = "0.19.12"
+url = "2.5.8"

 [dev-dependencies]
 tokio = { version = "1", features = ["full"] }
 mockall = "0.13"
 testcontainers = "0.27.1"
+testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis"] }
 wiremock = "0.6"


@@ -49,6 +49,22 @@
      "type": "sqlite",
      "path": "/sqlite-data-2/workspace/data/app.db",
      "generated_id": "16678179-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 8 - Redis",
+      "type": "redis",
+      "port": 6379,
+      "host": "db-redis",
+      "generated_id": "16678166-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 9 - Redis Auth",
+      "type": "redis",
+      "password": "m6o2L0Ukw3Og5RJUKh",
+      "port": 6379,
+      "username": "default",
+      "host": "db-redis-auth",
+      "generated_id": "16678160-ff7e-4c97-8c83-0adeff214681"
    }
  ]
 }
@@ -11,14 +11,14 @@ services:
      #      - ./databases.toml:/config/config.toml
      - cargo-registry:/usr/local/cargo/registry
      - cargo-git:/usr/local/cargo/git
-      - cargo-target:/app/target
-#      - sqlite-data:/sqlite-data/workspace/data
-#      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
+#      - cargo-target:/app/target
+    #      - sqlite-data:/sqlite-data/workspace/data
+    #      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
    environment:
      APP_ENV: development
      LOG: debug
      TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOGYwMmExZTAtNDY0NC00MWFmLWIzYjctYjZkYWNjNzQ4OWVhIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiZWE5OWE5ZjMtNDhkYy00MjMyLTkzMTAtNTc5YWVkY2IyZjhmIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
      #POOLING: 1
      #DATABASES_CONFIG_FILE: "config.toml"
    extra_hosts:
@@ -39,81 +39,106 @@ services:
      - POSTGRES_PASSWORD=changeme
    networks:
      - portabase
-#
-#  db-mariadb:
-#    container_name: db-mariadb
-#    image: mariadb:latest
-#    ports:
-#      - "3311:3306"
-#    environment:
-#      - MYSQL_DATABASE=mariadb
-#      - MYSQL_USER=mariadb
-#      - MYSQL_PASSWORD=changeme
-#      - MYSQL_RANDOM_ROOT_PASSWORD=yes
-#    volumes:
-#      - mariadb-data:/var/lib/mysql
-#    networks:
-#      - portabase
-#
-#
-#  db-mongodb-auth:
-#    container_name: db-mongodb-auth
-#    image: mongo:latest
-#    ports:
-#      - "27082:27017"
-#    environment:
-#      MONGO_INITDB_ROOT_USERNAME: root
-#      MONGO_INITDB_ROOT_PASSWORD: rootpassword
-#      MONGO_INITDB_DATABASE: testdbauth
-#    command: mongod --auth
-#    networks:
-#      - portabase
-#    volumes:
-#      - mongodb-data-auth:/data/db
-#    healthcheck:
-#      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
-#      interval: 5s
-#      timeout: 5s
-#      retries: 10
-#
-#  db-mongodb:
-#    container_name: db-mongodb
-#    image: mongo:latest
-#    ports:
-#      - "27083:27017"
-#    volumes:
-#      - mongodb-data:/data/db
-#    healthcheck:
-#      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
-#      interval: 5s
-#      timeout: 5s
-#      retries: 10
-#    environment:
-#      MONGO_INITDB_DATABASE: testdb
-#    networks:
-#      - portabase
+  #
+  #  db-mariadb:
+  #    container_name: db-mariadb
+  #    image: mariadb:latest
+  #    ports:
+  #      - "3311:3306"
+  #    environment:
+  #      - MYSQL_DATABASE=mariadb
+  #      - MYSQL_USER=mariadb
+  #      - MYSQL_PASSWORD=changeme
+  #      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+  #    volumes:
+  #      - mariadb-data:/var/lib/mysql
+  #    networks:
+  #      - portabase
+  #
+  #
+  #  db-mongodb-auth:
+  #    container_name: db-mongodb-auth
+  #    image: mongo:latest
+  #    ports:
+  #      - "27082:27017"
+  #    environment:
+  #      MONGO_INITDB_ROOT_USERNAME: root
+  #      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+  #      MONGO_INITDB_DATABASE: testdbauth
+  #    command: mongod --auth
+  #    networks:
+  #      - portabase
+  #    volumes:
+  #      - mongodb-data-auth:/data/db
+  #    healthcheck:
+  #      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
+  #      interval: 5s
+  #      timeout: 5s
+  #      retries: 10
+  #
+  #  db-mongodb:
+  #    container_name: db-mongodb
+  #    image: mongo:latest
+  #    ports:
+  #      - "27083:27017"
+  #    volumes:
+  #      - mongodb-data:/data/db
+  #    healthcheck:
+  #      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
+  #      interval: 5s
+  #      timeout: 5s
+  #      retries: 10
+  #    environment:
+  #      MONGO_INITDB_DATABASE: testdb
+  #    networks:
+  #      - portabase

-#  sqlite:
-#    container_name: db-sqlite
-#    image: keinos/sqlite3
-#    volumes:
-#      - sqlite-data:/workspace/data
-#    working_dir: /workspace
-#    command: tail -f /dev/null
-#    stdin_open: true
-#    tty: true
+  #  sqlite:
+  #    container_name: db-sqlite
+  #    image: keinos/sqlite3
+  #    volumes:
+  #      - sqlite-data:/workspace/data
+  #    working_dir: /workspace
+  #    command: tail -f /dev/null
+  #    stdin_open: true
+  #    tty: true

+  db-redis:
+    image: redis:latest
+    container_name: db-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    command: [ "redis-server", "--appendonly", "yes" ]
+    networks:
+      - portabase
+
+  db-redis-auth:
+    image: redis:latest
+    container_name: db-redis-auth
+    ports:
+      - "6380:6379"
+    volumes:
+      - redis-data-auth:/data
+    environment:
+      - REDIS_PASSWORD=m6o2L0Ukw3Og5RJUKh
+    command: [ "redis-server", "--requirepass", "m6o2L0Ukw3Og5RJUKh", "--appendonly", "yes" ]
+    networks:
+      - portabase

 volumes:
  cargo-registry:
  cargo-git:
-  cargo-target:
+#  cargo-target:

  postgres-data:
-#  mariadb-data:
-#  mongodb-data:
-#  mongodb-data-auth:
-#  sqlite-data:
+  #  mariadb-data:
+  #  mongodb-data:
+  #  mongodb-data-auth:
+  #  sqlite-data:
+  redis-data:
+  redis-data-auth:

 networks:
  portabase:
@@ -1,7 +1,7 @@
 # =========================
 # Base image (shared)
 # =========================
-FROM rust:1.92.0 AS base
+FROM rust:1.94.0 AS base

 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    pkg-config \
@@ -16,6 +16,7 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    curl \
    mariadb-client \
    sqlite3 \
+    redis-tools \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

@@ -94,6 +95,7 @@ RUN apt-get update && apt-get install -y \
    zlib1g \
    mariadb-client \
    sqlite3 \
+    redis-tools \
    && rm -rf /var/lib/apt/lists/*


@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -e
+
+POSTGRES_BASE="/usr/local/postgresql"
+echo "Detecting OS and architecture..."
+OS_TYPE="$(uname -s)"
+ARCH="$(uname -m)"
+
+install_pg_binaries() {
+    echo "Installing PostgreSQL binaries for versions 12-18..."
+
+    for v in 12 13 14 15 16 17 18; do
+        TARGET_DIR="$POSTGRES_BASE/$v/bin"
+        sudo mkdir -p "$TARGET_DIR"
+
+        if [[ "$OS_TYPE" == "Linux" ]]; then
+            if [[ "$ARCH" == "x86_64" ]]; then
+                SRC_DIR="./assets/tools/amd64/postgresql/postgresql-$v/bin"
+            elif [[ "$ARCH" == "aarch64" ]]; then
+                SRC_DIR="./assets/tools/arm64/postgresql/postgresql-$v/bin"
+            else
+                echo "Unsupported architecture: $ARCH"
+                continue
+            fi
+
+            if [[ -d "$SRC_DIR" ]]; then
+                echo "Copying PostgreSQL $v binaries from $SRC_DIR to $TARGET_DIR"
+                sudo cp -r "$SRC_DIR"/* "$TARGET_DIR/"
+            else
+                echo "Binaries for PostgreSQL $v not found for Linux, skipping..."
+                continue
+            fi
+
+        elif [[ "$OS_TYPE" == "Darwin" ]]; then
+            PG_SRC="$(brew --prefix postgresql@$v)/bin" 2>/dev/null || true
+
+            if [[ ! -d "$PG_SRC" ]]; then
+                echo "PostgreSQL $v not installed via Homebrew. Trying to install..."
+                if ! brew install postgresql@$v; then
+                    echo "PostgreSQL $v not available, skipping..."
+                    continue
+                fi
+                PG_SRC="$(brew --prefix postgresql@$v)/bin"
+            fi
+
+            echo "Copying PostgreSQL $v binaries from $PG_SRC to $TARGET_DIR"
+            sudo cp -r "$PG_SRC"/* "$TARGET_DIR/"
+        fi
+
+        sudo chown -R "$(whoami)" "$TARGET_DIR"
+        chmod +x "$TARGET_DIR"/*
+    done
+
+    echo "PostgreSQL binaries installed under $POSTGRES_BASE"
+}
+
+if [[ "$OS_TYPE" == "Linux" ]]; then
+    if command -v apt >/dev/null 2>&1; then
+        echo "Linux detected with apt. Installing prerequisites..."
+        sudo apt update
+        sudo apt install -y wget gnupg lsb-release redis-tools
+        install_pg_binaries
+    else
+        echo "Unsupported Linux distribution. Only apt-based distros are supported."
+        exit 1
+    fi
+
+elif [[ "$OS_TYPE" == "Darwin" ]]; then
+    if command -v brew >/dev/null 2>&1; then
+        echo "macOS detected. Installing prerequisites..."
+        brew install redis
+
+        sudo mkdir -p "$POSTGRES_BASE"
+        sudo chown -R "$(whoami)" "$POSTGRES_BASE"
+
+        install_pg_binaries
+    else
+        echo "Homebrew not found. Please install Homebrew first: https://brew.sh/"
+        exit 1
+    fi
+
+else
+    echo "Unsupported OS: $OS_TYPE"
+    exit 1
+fi
+
+echo "Tools installation completed successfully."
@@ -43,9 +43,10 @@ impl Agent {
        let ping_result = self.status_service.ping(&config.databases).await?;

        for db in ping_result.databases.iter() {
+            let database = config.databases.iter().find(|cfg_db|cfg_db.generated_id == db.generated_id).unwrap();
            info!(
-                "Generated Id: {} | backup action: {} | restore action: {}",
-                db.generated_id, db.data.backup.action, db.data.restore.action
+                "Generated Id: {} | backup action: {} | restore action: {} | Database Name: {}",
+                 db.generated_id, db.data.backup.action, db.data.restore.action, database.name,
            );
            let _ = self.cron_service.sync(db).await;

@@ -2,18 +2,19 @@ use crate::domain::mongodb::database::MongoDatabase;
 use crate::domain::mysql::database::MySQLDatabase;
 use crate::domain::postgres::database::PostgresDatabase;
 use crate::domain::postgres::{detect_format_from_file, detect_format_from_size};
+use crate::domain::redis::database::RedisDatabase;
+use crate::domain::sqlite::database::SqliteDatabase;
 use crate::services::config::{DatabaseConfig, DbType};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use crate::domain::sqlite::database::SqliteDatabase;

 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
    fn file_extension(&self) -> &'static str;
    async fn ping(&self) -> Result<bool>;
-    async fn backup(&self, backup_dir: &Path) -> Result<PathBuf>;
-    async fn restore(&self, restore_file: &Path) -> Result<()>;
+    async fn backup(&self, backup_dir: &Path, is_test: Option<bool>) -> Result<PathBuf>;
+    async fn restore(&self, restore_file: &Path, is_test: Option<bool>) -> Result<()>;
 }

 pub struct DatabaseFactory;
@@ -29,6 +30,7 @@ impl DatabaseFactory {
            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
            DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
+            DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
        }
    }

@@ -42,6 +44,7 @@ impl DatabaseFactory {
            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
            DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
+            DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
        }
    }
 }
@@ -3,4 +3,5 @@ pub mod postgres;
 pub mod mysql;
 mod mongodb;
 mod sqlite;
+mod redis;

@@ -27,22 +27,27 @@ impl Database for MongoDatabase {
        ping::run(self.cfg.clone()).await
    }

-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
-        let res = backup::run(
-            self.cfg.clone(),
-            dir.to_path_buf(),
-            self.file_extension(),
-        )
-            .await;
-        FileLock::release(&self.cfg.generated_id).await?;
+    async fn backup(&self, dir: &Path, is_test: Option<bool>) -> Result<PathBuf> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        }
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }

-    async fn restore(&self, file: &Path) -> Result<()> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+    async fn restore(&self, file: &Path,  is_test: Option<bool>) -> Result<()> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        }
        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }
 }
@@ -36,17 +36,28 @@ impl Database for MySQLDatabase {
        ping::run(self.cfg.clone(), self.build_env().clone()).await
    }

-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+
+    async fn backup(&self, dir: &Path, is_test: Option<bool>) -> Result<PathBuf> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        }
        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.build_env().clone(), self.file_extension()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }

-    async fn restore(&self, file: &Path) -> Result<()> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+    async fn restore(&self, file: &Path, is_test: Option<bool>) -> Result<()> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        }
        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }
 }
@@ -11,6 +11,7 @@ pub async fn run(
    cfg: DatabaseConfig,
    format: PostgresDumpFormat,
    backup_dir: PathBuf,
+    is_test: Option<bool>
 ) -> Result<PathBuf> {
    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
        debug!("Starting backup for database {}", cfg.name);
@@ -26,7 +27,8 @@ pub async fn run(
            }
        };

-        let pg_dump = select_pg_path(&version).join("pg_dump");
+        let pg_dump = select_pg_path(&version, is_test).join("pg_dump");
+        
        debug!("Using pg_dump at {:?}", pg_dump);

        match format {
@@ -28,9 +28,14 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
    Ok(version)
 }

-pub fn select_pg_path(version: &str) -> std::path::PathBuf {
+pub fn select_pg_path(version: &str, is_test: Option<bool>) -> std::path::PathBuf {
    let major = version.split('.').next().unwrap_or("17");
-    format!("/usr/lib/postgresql/{}/bin", major).into()
+
+    if is_test.unwrap_or(false) {
+        format!("/usr/local/postgresql/{}/bin", major).into()
+    } else {
+        format!("/usr/lib/postgresql/{}/bin", major).into()
+    }
 }

 pub async fn terminate_connections(cfg: &DatabaseConfig) -> Result<()> {
@@ -2,11 +2,7 @@ use anyhow::Result;
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};

-use super::{
-    backup,
-    format::PostgresDumpFormat,
-    ping, restore,
-};
+use super::{backup, format::PostgresDumpFormat, ping, restore};
 use crate::domain::factory::Database;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
@@ -35,17 +31,27 @@ impl Database for PostgresDatabase {
        ping::run(self.cfg.clone()).await
    }

-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
-        let res = backup::run(self.cfg.clone(), self.format, dir.to_path_buf()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+    async fn backup(&self, dir: &Path, is_test: Option<bool>) -> Result<PathBuf> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        }
+        let res = backup::run(self.cfg.clone(), self.format, dir.to_path_buf(), is_test).await;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }

-    async fn restore(&self, file: &Path) -> Result<()> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), self.format, file.to_path_buf()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+    async fn restore(&self, file: &Path, is_test: Option<bool>) -> Result<()> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        }
+        let res = restore::run(self.cfg.clone(), self.format, file.to_path_buf(), is_test).await;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }
 }
@@ -11,6 +11,7 @@ pub async fn run(
    cfg: DatabaseConfig,
    format: PostgresDumpFormat,
    restore_file: PathBuf,
+    is_test: Option<bool>,
 ) -> Result<()> {
    tokio::task::spawn_blocking(move || -> Result<()> {
        debug!("Starting restore for database {}", cfg.name);
@@ -26,7 +27,8 @@ pub async fn run(
            }
        };

-        let pg_restore = select_pg_path(&version).join("pg_restore");
+        let pg_restore = select_pg_path(&version, is_test).join("pg_restore");
+
        debug!("Using pg_restore at {:?}", pg_restore);

        if let Err(e) = futures::executor::block_on(terminate_connections(&cfg)) {
@@ -0,0 +1,65 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting Redis backup for database {}", cfg.name);
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let mut cmd = Command::new("redis-cli");
+
+        cmd.arg("-h")
+            .arg(&cfg.host)
+            .arg("-p")
+            .arg(cfg.port.to_string());
+
+        if !cfg.username.is_empty() {
+            cmd.arg("--user").arg(&cfg.username);
+        }
+
+        if !cfg.password.is_empty() {
+            cmd.arg("-a").arg(&cfg.password);
+        }
+
+        cmd.arg("--rdb").arg(&file_path);
+
+        debug!("Command Backup: {:?}", cmd);
+
+        let output = cmd.output().context("Redis backup command failed")?;
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+
+        if !output.status.success() {
+            if stderr.contains("NOAUTH") {
+                error!(
+                    "Redis backup failed for {}: Authentication required (NOAUTH)",
+                    cfg.name
+                );
+                anyhow::bail!(
+                    "Redis backup failed for {}: Authentication required",
+                    cfg.name
+                );
+            } else {
+                error!("Redis backup failed for {}: {}", cfg.name, stderr);
+                anyhow::bail!("Redis backup failed for {}: {}", cfg.name, stderr);
+            }
+        }
+
+        info!(
+            "Redis backup completed for {}. Output: {}",
+            cfg.name, stdout
+        );
+
+        Ok(file_path)
+    })
+    .await?
+}
@@ -0,0 +1,45 @@
+use anyhow::{Result, bail};
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+use crate::domain::factory::Database;
+use crate::domain::redis::{backup, ping};
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct RedisDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl RedisDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for RedisDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".rdb"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    async fn backup(&self, dir: &Path, is_test: Option<bool>) -> Result<PathBuf> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        }
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
+        res
+    }
+
+    async fn restore(&self, _file: &Path, _is_test: Option<bool>) -> Result<()> {
+        bail!("Restore not supported for Redis databases")
+    }
+}
@@ -0,0 +1,3 @@
+mod backup;
+pub mod database;
+mod ping;
@@ -0,0 +1,55 @@
+use tracing::{debug, info};
+use crate::services::config::DatabaseConfig;
+use tokio::process::Command;
+use tokio::time::{timeout, Duration};
+use anyhow::{Result, Context};
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    let mut cmd = Command::new("redis-cli");
+    cmd.arg("-h")
+        .arg(&cfg.host)
+        .arg("-p")
+        .arg(cfg.port.to_string());
+
+    if !cfg.username.is_empty() {
+        cmd.arg("--user").arg(&cfg.username);
+    }
+
+    if !cfg.password.is_empty() {
+        cmd.arg("-a").arg(&cfg.password);
+    }
+
+    cmd.arg("PING");
+
+    debug!("Command Ping: {:?}", cmd);
+
+
+    let result = timeout(Duration::from_secs(10), cmd.output()).await;
+
+    match result {
+        Ok(output) => {
+            let output = output.context("Failed to execute redis-cli")?;
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            let stderr = String::from_utf8_lossy(&output.stderr);
+
+            info!("Redis stdout: {}", stdout);
+            info!("Redis stderr: {}", stderr);
+
+            if stderr.contains("NOAUTH") {
+                info!("Redis authentication failed (NOAUTH required)");
+                return Ok(false);
+            }
+
+            if !output.status.success() {
+                info!("Redis command failed with status: {:?}", output.status);
+                return Ok(false);
+            }
+
+            Ok(stdout.contains("PONG"))
+        }
+        Err(_) => {
+            info!("Timeout connecting to Redis at {}:{}", cfg.host, cfg.port);
+            Ok(false)
+        }
+    }
+}
@@ -27,17 +27,26 @@ impl Database for SqliteDatabase {
        ping::run(self.cfg.clone()).await
    }

-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+    async fn backup(&self, dir: &Path, is_test: Option<bool>) -> Result<PathBuf> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        }
        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }
-
-    async fn restore(&self, file: &Path) -> Result<()> {
-        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+    async fn restore(&self, file: &Path, is_test: Option<bool>) -> Result<()> {
+        let test_mode = is_test.unwrap_or(false);
+        if !test_mode {
+            FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        }
        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
-        FileLock::release(&self.cfg.generated_id).await?;
+        if !test_mode {
+            FileLock::release(&self.cfg.generated_id).await?;
+        }
        res
    }
 }
@@ -40,7 +40,7 @@ impl BackupService {
            });
        }

-        match db.backup(tmp_path).await {
+        match db.backup(tmp_path, Some(false)).await {

            Ok(file) => Ok(BackupResult {
                generated_id,
@@ -19,6 +19,7 @@ pub enum DbType {
    Postgresql,
    MongoDB,
    Sqlite,
+    Redis
    // Add other DB types if needed
 }

@@ -30,6 +31,7 @@ impl DbType {
            DbType::Postgresql => "postgresql",
            DbType::MongoDB => "mongodb",
            DbType::Sqlite => "sqlite",
+            DbType::Redis => "redis",
        }
    }
 }
@@ -162,17 +164,17 @@ impl ConfigService {
            };

            let host = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.host, &db.name, "host")?,
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB | DbType::Redis => required(&db.host, &db.name, "host")?,
                DbType::Sqlite => optional(&db.host),
            };

            let port = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.port, &db.name, "port")?,
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB | DbType::Redis => required(&db.port, &db.name, "port")?,
                DbType::Sqlite => db.port.unwrap_or(0),
            };

            let database_name = match db.db_type {
-                DbType::Sqlite => optional(&db.database),
+                DbType::Sqlite | DbType::Redis => optional(&db.database),
                _ => required(&db.database, &db.name, "database")?
            };

@@ -31,7 +31,7 @@ impl RestoreService {
            });
        }

-        match db.restore(&backup_file).await {
+        match db.restore(&backup_file, Some(false)).await {

            Ok(_) => Ok(RestoreResult {
                generated_id,
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use crate::utils::deserializer::string_or_number_to_string;

 #[derive(Debug, Deserialize, Serialize)]
 pub struct S3ProviderConfig {
@@ -8,5 +9,7 @@ pub struct S3ProviderConfig {
    pub end_point_url: String,
    pub ssl: bool,
    pub region: Option<String>,
+    #[serde(default, deserialize_with = "string_or_number_to_string")]
    pub port: Option<String>,
 }
+
@@ -1 +1,2 @@
-mod postgres;
+mod postgres;
+mod redis;
@@ -1,35 +1,109 @@
-use oauth2::url;
-use testcontainers::runners::AsyncRunner;
-use testcontainers_modules::postgres::Postgres;
-use crate::services::config::{DatabaseConfig, DbType};
-use url::Host;
 use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use crate::tests::init_tracing_for_test;
+use crate::utils::compress::{compress_to_tar_gz_large, decompress_large_tar_gz};
+use oauth2::url;
+use std::path::PathBuf;
+use tempfile::TempDir;
+use testcontainers::runners::AsyncRunner;
+use testcontainers::{ContainerAsync, ImageExt};
+use testcontainers_modules::postgres::Postgres;
+use tracing::{error, info};
+use url::Host;

-#[tokio::test]
-async fn postgres_ping_test() {
-
+async fn create_config() -> (ContainerAsync<Postgres>, DatabaseConfig) {
    let container = Postgres::default()
+        .with_env_var("POSTGRES_DB", "testdb")
+        .with_env_var("POSTGRES_USER", "testuser")
+        .with_env_var("POSTGRES_PASSWORD", "changeme")
+        .with_tag("17")
        .start()
        .await
        .unwrap();

-    let host = container.get_host().await.unwrap_or(Host::parse("127.0.0.1").unwrap());
-    let port = container.get_host_port_ipv4(5432).await.unwrap_or(5432) ;
+    let host = container
+        .get_host()
+        .await
+        .unwrap_or(Host::parse("127.0.0.1").unwrap());
+
+    let port = container.get_host_port_ipv4(5432).await.unwrap_or(5432);

    let config = DatabaseConfig {
        name: "My test Postgres Database".to_string(),
-        database: "postgres".to_string(),
+        database: "testdb".to_string(),
        db_type: DbType::Postgresql,
-        username: "postgres".to_string(),
-        password: "postgres".to_string(),
+        username: "testuser".to_string(),
+        password: "changeme".to_string(),
        port,
        host: host.to_string(),
        generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
        path: "".to_string(),
    };

+    (container, config)
+}
+
+#[tokio::test]
+async fn postgres_ping_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
    let db = DatabaseFactory::create_for_backup(config.clone()).await;
    let reachable = db.ping().await.unwrap_or_else(|_| false);

    assert_eq!(reachable, true);
-}
+}
+
+#[tokio::test]
+async fn postgres_backup_restore_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
+    let temp_dir = TempDir::new().unwrap();
+    let backup_path = temp_dir.path();
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+
+    let file_path = db.backup(backup_path, Some(true)).await.unwrap();
+
+    assert!(file_path.is_file());
+
+    let compression = compress_to_tar_gz_large(&file_path).await.unwrap();
+
+    assert!(compression.compressed_path.is_file());
+
+    let files = decompress_large_tar_gz(compression.compressed_path.as_path(), temp_dir.path())
+        .await
+        .unwrap();
+
+    let backup_file: PathBuf;
+
+    if files.len() == 1 {
+        backup_file = files[0].clone()
+    } else {
+        backup_file = "".into()
+    }
+
+    let db = DatabaseFactory::create_for_restore(config.clone(), &backup_file).await;
+
+    let reachable = db.ping().await.unwrap_or(false);
+
+    info!("Reachable: {}", reachable);
+
+    assert_eq!(reachable, true);
+
+    info!("Running pg_restore: {:?}", backup_file);
+
+    match db.restore(&backup_file, Some(true)).await {
+        Ok(_) => {
+            info!("Restore succeeded for {}", config.generated_id);
+            assert!(true)
+        }
+        Err(e) => {
+            error!("Restore failed for {}: {:?}", config.generated_id, e);
+            assert!(false)
+        }
+    }
+}
@@ -0,0 +1,65 @@
+use tempfile::TempDir;
+use testcontainers::runners::AsyncRunner;
+use testcontainers::ContainerAsync;
+use testcontainers_modules::redis::Redis;
+use url::Host;
+
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use crate::tests::init_tracing_for_test;
+
+async fn create_config() -> (ContainerAsync<Redis>, DatabaseConfig) {
+    let container = Redis::default().start().await.unwrap();
+
+    let host = container
+        .get_host()
+        .await
+        .unwrap_or(Host::parse("127.0.0.1").unwrap());
+
+    let port = container
+        .get_host_port_ipv4(6379)
+        .await
+        .unwrap_or(6379);
+
+    let config = DatabaseConfig {
+        name: "Test Redis".to_string(),
+        database: "redis".to_string(),
+        username: "".to_string(),
+        password: "".to_string(),
+        db_type: DbType::Redis,
+        port,
+        host: host.to_string(),
+        generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
+        path: "".to_string(),
+    };
+
+    (container, config)
+}
+
+#[tokio::test]
+async fn redis_ping_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+    let reachable = db.ping().await.unwrap_or(false);
+
+    assert!(reachable);
+}
+
+#[tokio::test]
+async fn redis_backup_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
+    let temp_dir = TempDir::new().unwrap();
+    let backup_path = temp_dir.path();
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+
+    let file_path = db.backup(backup_path, Some(true)).await.unwrap();
+
+    assert!(file_path.is_file());
+}
@@ -1,2 +1,18 @@
 mod utils;
-mod domain;
+mod domain;
+
+
+
+use once_cell::sync::Lazy;
+use tracing_subscriber;
+
+static TRACING: Lazy<()> = Lazy::new(|| {
+    let _ = tracing_subscriber::fmt()
+        .with_test_writer()
+        .with_env_filter("debug")
+        .try_init();
+});
+
+fn init_tracing_for_test() -> () {
+    Lazy::force(&TRACING);
+}
@@ -1,5 +1,7 @@
 use serde::{Deserialize, Deserializer};
 use toml::Value;
+use serde_json::{Value as ValueJson, };
+

 pub fn deserialize_snake_case<'de, D>(deserializer: D) -> Result<Value, D::Error>
 where
@@ -36,3 +38,18 @@ pub fn camel_to_snake(s: &str) -> String {
    }
    out
 }
+
+
+pub fn string_or_number_to_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = Option::<ValueJson>::deserialize(deserializer)?;
+
+    match value {
+        Some(ValueJson::String(s)) => Ok(Some(s)),
+        Some(ValueJson::Number(n)) => Ok(Some(n.to_string())),
+        Some(_) => Err(serde::de::Error::custom("port must be string or number")),
+        None => Ok(None),
+    }
+}
Author	SHA1	Message	Date
github-actions[bot]	987c630c73	chore: release 1.5.1	2026-03-16 07:59:25 +00:00
Charles GTE	e9147d6c60	fix: s3 port type mismatch, add string_or_number_to_string deserializer (#42 ) Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-16 08:57:00 +01:00
github-actions[bot]	174ead72a3	chore: release 1.5.0	2026-03-15 11:06:29 +00:00
Charles GTE	f2a67b3490	feat: add-redis #39 feat: add-redis	2026-03-15 12:04:05 +01:00
charlesgauthereau	d4afefbc1e	fix: requirements.sh for tests tools	2026-03-14 20:08:26 +01:00
charlesgauthereau	be6e147df2	fix: requirements.sh for tests tools	2026-03-14 19:54:15 +01:00
charlesgauthereau	91b6658852	fix: requirements.sh for tests tools	2026-03-14 19:40:01 +01:00
charlesgauthereau	f7dcb6b2bb	fix: requirements.sh for tests tools	2026-03-14 18:26:26 +01:00
charlesgauthereau	ab14f0dcf0	fix: requirements.sh for tests tools	2026-03-14 18:17:43 +01:00
charlesgauthereau	58a0b92710	fix: pipeline codecov.yml	2026-03-14 18:05:29 +01:00
charlesgauthereau	2f24291c0e	fix: pipeline codecov.yml	2026-03-14 18:02:06 +01:00
charlesgauthereau	1fdea31430	fix: postgres and redis tests	2026-03-14 17:59:44 +01:00
charlesgauthereau	d1d633fd00	feat: add redis database support for backup.	2026-03-13 22:44:46 +01:00
Charles GTE	b1c14f098b	fix: codecov.yml (#38 ) * feat: add codecov.yml * fix: add codecov.yml * fix: codecov.yml --------- Co-authored-by: charles-gauthereau <charles.gauthereau@soluce-technologies.com>	2026-03-13 16:58:51 +01:00