cli_test.yaml

name: CLI Test

on: [push, workflow_call, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        app_type: ["Blank", "SyncORM", "AsyncORM", "MongoDB", "PostgresSync", "PostgresAsync", "MySQLSync", "MySQLAsync"]

    steps:
      - name: Check out repository code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.10"

      - name: Install uv
        uses: astral-sh/setup-uv@v7
        with:
          version: "0.9.7"
          enable-cache: true

      - name: Install dependencies
        run: uv sync --no-dev --group test

      - name: Test CLI Commands
        run: |
          app_name="${{ matrix.app_type }}App"
          case "${{ matrix.app_type }}" in
            "Blank")
              uv run pynest generate application -n "$app_name"
              ;;
            "SyncORM")
              uv run pynest generate application -n "$app_name" -db sqlite
              ;;
            "AsyncORM")
              uv run pynest generate application -n "$app_name" -db sqlite --is-async
              ;;
            "MongoDB")
              uv run pynest generate application -n "$app_name" -db mongodb
              ;;
            "PostgresSync")
              uv run pynest generate application -n "$app_name" -db postgresql
              ;;
            "PostgresAsync")
              uv run pynest generate application -n "$app_name" -db postgresql --is-async
              ;;
            "MySQLSync")
              uv run pynest generate application -n "$app_name" -db mysql
              ;;
            "MySQLAsync")
              uv run pynest generate application -n "$app_name" -db mysql --is-async
              ;;
          esac

          cd "$app_name"
          uv run pynest generate resource -n user
          uv run pynest generate gateway -n chat -p src

      - name: Verify Boilerplate
        run: |
          app_name="${{ matrix.app_type }}App"
          if [ -d "$app_name" ]; then
            echo "Directory $app_name exists."
          else
            echo "Directory $app_name does not exist."
            exit 1
          fi

          if [ -d "$app_name/src/user" ]; then
            echo "Directory $app_name/src/user exists."
          else
            echo "Directory $app_name does not exist."
            exit 1
          fi

          declare -a files=("main.py" "requirements.txt" "README.md")
          declare -a src_level_files=("app_module.py" "app_service.py" "app_controller.py")
          declare -a module_files=("user_controller.py" "user_service.py" "user_module.py" "user_model.py")

          for file in "${files[@]}"; do
            if [ -f "$app_name/$file" ]; then
              echo "$file exists in $app_name."
            else
              echo "$file does not exist in $app_name."
              exit 1
            fi
          done

          for file in "${src_level_files[@]}"; do
            if [ -f "$app_name/src/$file" ]; then
              echo "$file exists in $app_name."
            else
              echo "$file does not exist in $app_name."
              exit 1
            fi
          done

          for file in "${module_files[@]}"; do
            if [ -f "$app_name/src/user/$file" ]; then
              echo "$file exists in $app_name."
            else
              echo "$file does not exist in $app_name."
              exit 1
            fi
          done

          gateway_file="$app_name/src/chat_gateway.py"
          if [ -f "$gateway_file" ]; then
            echo "$gateway_file exists."
          else
            echo "$gateway_file does not exist."
            exit 1
          fi
          if ! grep -q '@WebSocketGateway(namespace="/chat")' "$gateway_file"; then
            echo "$gateway_file is missing the expected @WebSocketGateway decorator."
            exit 1
          fi

          echo "Boilerplate for ${{ matrix.app_type }} generated successfully."

      - name: Ping generated WebSocket app
        if: matrix.app_type == 'Blank'
        run: |
          cd "${{ matrix.app_type }}App"
          uv run python - <<'PY'
          import asyncio
          import importlib.util
          import json
          import socket

          import uvicorn
          import websockets

          from nest.core import Module, PyNestContainer, PyNestFactory

          spec = importlib.util.spec_from_file_location(
              "chat_gateway", "src/chat_gateway.py"
          )
          mod = importlib.util.module_from_spec(spec)
          spec.loader.exec_module(mod)
          ChatGateway = mod.ChatGateway

          @Module(providers=[ChatGateway])
          class App:
              pass

          def free_port():
              with socket.socket() as sock:
                  sock.bind(("127.0.0.1", 0))
                  return sock.getsockname()[1]

          async def main():
              PyNestContainer._instance = None
              app = PyNestFactory.create(App).get_server()
              port = free_port()
              config = uvicorn.Config(
                  app, host="127.0.0.1", port=port,
                  log_level="critical", lifespan="off",
              )
              server = uvicorn.Server(config)
              task = asyncio.create_task(server.serve())
              for _ in range(200):
                  if server.started:
                      break
                  await asyncio.sleep(0.05)
              try:
                  async with websockets.connect(
                      f"ws://127.0.0.1:{port}/chat"
                  ) as ws:
                      await ws.send(json.dumps(
                          {"event": "ping", "data": {"hello": "world"}}
                      ))
                      response = json.loads(await ws.recv())
                  assert response == {
                      "event": "pong", "data": {"hello": "world"},
                  }, response
                  print("WEBSOCKET_PING_OK")
              finally:
                  server.should_exit = True
                  await task

          asyncio.run(main())
          PY