> ## Documentation Index
> Fetch the complete documentation index at: https://docs.yabetoopay.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Environnement de développement

> Configurez votre environnement pour développer et tester votre intégration Yabetoo

## Mode Sandbox vs Production

Yabetoo fournit deux environnements distincts pour vous permettre de développer et tester en toute sécurité.

<CardGroup cols={2}>
  <Card title="Sandbox (Test)" icon="flask">
    Environnement de test pour le développement. Aucune transaction réelle n'est effectuée.

    **Préfixe des clés** : `sk_test_`
  </Card>

  <Card title="Production (Live)" icon="rocket">
    Environnement de production pour les transactions réelles.

    **Préfixe des clés** : `sk_live_`
  </Card>
</CardGroup>

## Configuration des clés API

<Warning>
  Ne partagez jamais vos clés API secrètes. Utilisez des variables d'environnement pour les stocker.
</Warning>

### Variables d'environnement recommandées

Créez un fichier `.env` à la racine de votre projet :

```bash .env theme={null}
# Environnement de test
YABETOO_SECRET_KEY=sk_test_XXXXXXXXXXXXXXXXXXXXXXXX
YABETOO_ACCOUNT_ID=acct_xxxxxxxx

# URLs de callback
YABETOO_SUCCESS_URL=http://localhost:3000/checkout/success
YABETOO_CANCEL_URL=http://localhost:3000/checkout/cancel
YABETOO_WEBHOOK_URL=http://localhost:3000/webhooks/yabetoo
```

### Utilisation dans votre code

<CodeGroup>
  ```javascript JavaScript theme={null}
  import Yabetoo from "@yabetoo/sdk-js";

  const yabetoo = new Yabetoo(process.env.YABETOO_SECRET_KEY);
  ```

  ```python Python theme={null}
  import os
  from yabetoo import Yabetoo

  yabetoo = Yabetoo(os.environ.get("YABETOO_SECRET_KEY"))
  ```

  ```php PHP theme={null}
  <?php
  $yabetoo = new Yabetoo\Yabetoo($_ENV['YABETOO_SECRET_KEY']);
  ```

  ```java Java theme={null}
  import com.yabetoo.Yabetoo;

  Yabetoo yabetoo = new Yabetoo(System.getenv("YABETOO_SECRET_KEY"));
  ```
</CodeGroup>

## Numéros de test

En mode sandbox, utilisez ces numéros de téléphone pour simuler différents scénarios :

| Numéro         | Opérateur | Comportement                |
| -------------- | --------- | --------------------------- |
| `242000000001` | MTN       | Paiement réussi             |
| `242000000002` | MTN       | Échec (fonds insuffisants)  |
| `242000000003` | MTN       | En attente 30s, puis réussi |
| `242000000004` | Airtel    | Paiement réussi             |
| `242000000005` | Airtel    | Échec (numéro invalide)     |

<Tip>
  Les transactions en mode test n'impliquent aucun argent réel. Vous pouvez tester autant que nécessaire.
</Tip>

## Tester les webhooks localement

Pour recevoir les webhooks en local, utilisez un outil de tunnel comme ngrok :

<Steps>
  <Step title="Installez ngrok">
    ```bash theme={null}
    # macOS
    brew install ngrok

    # ou téléchargez depuis https://ngrok.com
    ```
  </Step>

  <Step title="Exposez votre serveur local">
    ```bash theme={null}
    ngrok http 3000
    ```

    Vous obtiendrez une URL comme `https://abc123.ngrok.io`
  </Step>

  <Step title="Configurez le webhook dans le Dashboard">
    Allez dans **Paramètres** > **Webhooks** et ajoutez votre URL ngrok :

    ```
    https://abc123.ngrok.io/webhooks/yabetoo
    ```
  </Step>
</Steps>

## Vérifier la signature des webhooks

Toujours vérifier la signature des webhooks pour vous assurer qu'ils proviennent de Yabetoo :

<CodeGroup>
  ```javascript JavaScript theme={null}
  import crypto from 'crypto';

  function verifyWebhookSignature(payload, signature, secret) {
    const expectedSignature = crypto
      .createHmac('sha256', secret)
      .update(payload)
      .digest('hex');

    return crypto.timingSafeEqual(
      Buffer.from(signature),
      Buffer.from(expectedSignature)
    );
  }
  ```

  ```python Python theme={null}
  import hmac
  import hashlib

  def verify_webhook_signature(payload: str, signature: str, secret: str) -> bool:
      expected_signature = hmac.new(
          secret.encode(),
          payload.encode(),
          hashlib.sha256
      ).hexdigest()

      return hmac.compare_digest(signature, expected_signature)
  ```

  ```java Java theme={null}
  import javax.crypto.Mac;
  import javax.crypto.spec.SecretKeySpec;
  import java.security.MessageDigest;

  public boolean verifyWebhookSignature(String payload, String signature, String secret) {
      try {
          Mac mac = Mac.getInstance("HmacSHA256");
          SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(), "HmacSHA256");
          mac.init(secretKeySpec);
          byte[] hash = mac.doFinal(payload.getBytes());
          String expectedSignature = bytesToHex(hash);
          return MessageDigest.isEqual(
              signature.getBytes(),
              expectedSignature.getBytes()
          );
      } catch (Exception e) {
          return false;
      }
  }
  ```
</CodeGroup>

## Bonnes pratiques

<AccordionGroup>
  <Accordion title="Gestion des erreurs">
    Implémentez toujours une gestion d'erreurs robuste :

    ```python theme={null}
    from yabetoo import Yabetoo, YabetooError
    from yabetoo.errors import ValidationError, APIError

    try:
        payment = yabetoo.payments.create(data)
    except ValidationError as e:
        # Données invalides
        print(f"Erreur de validation: {e.errors}")
    except APIError as e:
        # Erreur API
        print(f"Erreur API: {e.message}")
    except YabetooError as e:
        # Autre erreur Yabetoo
        print(f"Erreur: {e}")
    ```
  </Accordion>

  <Accordion title="Idempotence">
    Utilisez des clés d'idempotence pour éviter les doublons en cas de retry :

    ```python theme={null}
    payment = yabetoo.payments.create(
        data,
        idempotency_key="order_12345_payment"
    )
    ```
  </Accordion>

  <Accordion title="Logs et monitoring">
    Loggez toutes les transactions pour le débogage :

    ```python theme={null}
    import logging

    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger("yabetoo")

    # Les SDKs Yabetoo loggent automatiquement
    ```
  </Accordion>
</AccordionGroup>

## Checklist avant production

Avant de passer en production, vérifiez :

<Steps>
  <Step title="Tests complets">
    * [ ] Testez tous les scénarios de paiement (succès, échec, en attente)
    * [ ] Testez la réception et le traitement des webhooks
    * [ ] Testez les remboursements et annulations
  </Step>

  <Step title="Sécurité">
    * [ ] Clés API stockées en variables d'environnement
    * [ ] Vérification des signatures webhook implémentée
    * [ ] HTTPS activé sur tous les endpoints
  </Step>

  <Step title="Configuration">
    * [ ] URLs de callback en production configurées
    * [ ] Webhooks pointant vers le serveur de production
    * [ ] Clés de production (`sk_live_`) en place
  </Step>
</Steps>

## Ressources utiles

<CardGroup cols={2}>
  <Card title="Collection Postman" icon="rocket" href="/fr/developer-tools/postman">
    Testez l'API rapidement avec notre collection Postman
  </Card>

  <Card title="Référence API" icon="book" href="/fr/api-reference/introduction">
    Documentation complète de l'API
  </Card>

  <Card title="Gestion des erreurs" icon="triangle-exclamation" href="/fr/api-reference/errors">
    Liste des codes d'erreur et solutions
  </Card>

  <Card title="Webhooks" icon="bell" href="/fr/developer-tools/webhook/overview">
    Configuration et gestion des webhooks
  </Card>
</CardGroup>