Game Testing

• You can test your game locally using a local HTTPS server.
• You can upload test builds to the App Dashboard without affecting your live game.
• You can use debug and logging tools to inspect behavior.
• Your game is only accessible to the app’s administrators, developers, and testers.

• The production build replaces the previously live version for all players.
• The production build goes through any applicable review processes.
• Debug logging should be minimized or removed.
• All assets should be optimized for performance.

1. Generate a self-signed SSL certificate. You can use OpenSSL:

   openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes
   
   When prompted, you can enter any values for the certificate fields. The certificate does not need to be valid for local testing.
2. Start a local HTTPS server. You can use any tool that supports HTTPS. Here are some options:
   Using Node.js (with the http-server package):

   npx http-server -S -C cert.pem -K key.pem -p 8080
   
   Using Python:

   import http.server
   import ssl
   
   server_address = ('', 8080)
   httpd = http.server.HTTPServer(server_address, http.server.SimpleHTTPRequestHandler)
   httpd.socket = ssl.wrap_socket(httpd.socket, certfile='cert.pem', keyfile='key.pem', server_side=True)
   httpd.serve_forever()
3. Open the game in your browser. Navigate to https://localhost:8080. Your browser will warn you about the self-signed certificate. Accept the warning and proceed.

• Create a mock SDK. Write a simple mock object that implements the FBInstant APIs your game uses. This allows your game code to run without modification. For example:

  if (typeof FBInstant === 'undefined') {
    window.FBInstant = {
      initializeAsync: function() { return Promise.resolve(); },
      setLoadingProgress: function(progress) { console.log('Loading: ' + progress + '%'); },
      startGameAsync: function() { return Promise.resolve(); },
      player: {
        getID: function() { return 'test_player_123'; },
        getName: function() { return 'Test Player'; },
        getPhoto: function() { return 'https://placekitten.com/100/100'; },
        getDataAsync: function(keys) { return Promise.resolve({}); },
        setDataAsync: function(data) { return Promise.resolve(); },
        getConnectedPlayersAsync: function() { return Promise.resolve([]); },
        getSignedPlayerInfoAsync: function() {
          return Promise.resolve({ getSignature: function() { return 'mock_signature'; } });
        }
      },
      context: {
        getID: function() { return null; },
        getType: function() { return 'SOLO'; }
      },
      getLocale: function() { return 'en_US'; },
      getPlatform: function() { return 'WEB'; },
      quit: function() { console.log('Game quit.'); }
    };
  }
• Test game logic independently. Use your mock to verify that game mechanics, animations, scoring, and UI work correctly. Platform-specific features (social, monetization) will need to be tested on the actual platform.

1. Package your game as a ZIP file. Ensure that index.html is at the root level of the ZIP (not inside a subdirectory).
2. Go to the App Dashboard and select your app.
3. Navigate to Instant Games > Web Hosting.
4. Click Upload Version and select your ZIP file.
5. Wait for the upload and processing to complete. The dashboard will show the status of the build.
6. Once processed, you can push the build to Development (accessible only to app team members) without affecting the live production build.

• On web: Go to https://www.facebook.com/embed/instantgames/YOUR_APP_ID/player in your browser. Replace YOUR_APP_ID with your app’s ID.
• On mobile: Open the Facebook app on your iOS or Android device. Search for your game by name (if discoverable), or use a direct link shared from the App Dashboard.
• Via Messenger: Send a link to your game in a Messenger conversation to yourself, then open it.

1. In the App Dashboard, navigate to Roles > Test Users.
2. Click Create Test Users and specify how many you need.
3. Each test user has a name, email, and password that you can use to log in.

• Social features: Make test users friends with each other, then verify that getConnectedPlayersAsync() returns the expected players.
• Sharing and updates: Test shareAsync() and updateAsync() between test users to verify that posts appear correctly.
• Contexts: Use test users to test multiplayer contexts, challenges, and group play.
• Monetization: Use test users to test the IAP flow. See Testing monetization.

• Test users cannot interact with real Facebook accounts.
• Some platform features may behave differently for test users than for real users.
• Test users cannot access certain Facebook features, such as Groups and Pages.

• Open the Facebook app on an iPhone or iPad.
• Navigate to your game and launch it.
• Pay attention to:
  • Performance: iOS WebView performance can differ from desktop browsers.
  • Touch controls: Verify that all interactive elements respond correctly to touch input.
  • Screen sizes: Test on different iPhone and iPad models, including devices with notches and rounded corners.
  • Audio: iOS has specific restrictions on auto-playing audio. Audio typically must be triggered by a user interaction.
  • Safe areas: Ensure your game UI does not overlap with the status bar, home indicator, or notch.

• Open the Facebook app on an Android device.
• Test on both high-end and low-end devices. Low-end Android devices are common in many markets and may have limited memory, slower CPUs, and lower screen resolutions.
• Pay attention to:
  • Performance on low-end devices: Games that run smoothly on high-end devices may lag or crash on older hardware.
  • Screen sizes and densities: Android devices come in a wide variety of screen sizes and pixel densities.
  • Back button behavior: Android has a hardware/software back button. Test how your game handles it.
  • Memory constraints: Monitor memory usage, especially if your game loads many assets.

• Open your game at https://www.facebook.com/embed/instantgames/YOUR_APP_ID/player.
• Test in multiple browsers (Chrome, Firefox, Safari, Edge).
• Test with keyboard and mouse input if your game supports them.
• Test at different window sizes to ensure responsive layout.

1. Create at least two test users and make them friends.
2. Have both test users play your game (this registers them as connected players).
3. Verify that FBInstant.player.getConnectedPlayersAsync() returns the expected list.
4. Test your game’s UI for displaying friends, such as leaderboards and friend lists.

1. Trigger a share in your game using FBInstant.shareAsync().
2. Verify that the share dialog appears with the correct image and text.
3. Complete the share and verify that the post appears on the player’s timeline or in the conversation.
4. Open the shared post from another test user’s perspective and verify that clicking it launches the game.

1. Use FBInstant.context.chooseAsync() to select a friend or group.
2. Verify that the context switches correctly and that FBInstant.context.getID() returns the new context ID.
3. Send an update using FBInstant.updateAsync() and verify it appears to the other participants.

1. Create a tournament using the SDK or App Dashboard.
2. Have test users join and submit scores.
3. Verify that the tournament leaderboard displays correctly.
4. Test the full lifecycle: creation, joining, score submission, completion, and reward distribution.

1. Set up test products. In the App Dashboard, navigate to Instant Games > In-App Purchases and create test products.
2. Use test users or developer accounts. Purchases made by app administrators, developers, and testers are not charged real money on most platforms.
3. Test the complete flow:
   • Load the product catalog with FBInstant.payments.getCatalogAsync().
   • Verify that products display with correct names, descriptions, and prices.
   • Initiate a purchase with FBInstant.payments.purchaseAsync().
   • Verify that the purchase dialog appears correctly.
   • Complete the purchase and verify that the purchase receipt is returned.
   • If using server-side verification, verify that the receipt validates correctly on your server.
   • For consumable products, test FBInstant.payments.consumePurchaseAsync() and verify that the item is granted.
4. Test error cases:
   • Cancel a purchase mid-flow and verify that your game handles the cancellation gracefully.
   • Test what happens if the network is interrupted during a purchase.
   • Verify that FBInstant.payments.getPurchasesAsync() correctly returns unconsumed purchases (useful for restoring purchases after a game restart).

1. Set up ad placement IDs. Create ad placements in the Monetization Manager⁠. You will need separate placement IDs for rewarded videos, interstitials, and banners.
2. Test ad loading:
   • Call FBInstant.getRewardedVideoAsync() or FBInstant.getInterstitialAdAsync() with your placement ID.
   • Call loadAsync() on the returned ad instance.
   • Verify that the ad loads successfully (the promise resolves).
3. Test ad display:
   • Call showAsync() to display the ad.
   • For rewarded videos, verify that the reward is granted after the video completes.
   • For interstitials, verify that the game resumes correctly after the ad is dismissed.
4. Test ad failures:
   • Test what happens when no ad fill is available (the loadAsync() promise rejects with a NO_FILL error). Ensure your game handles this gracefully — for example, by hiding the “Watch Ad” button rather than showing an error.
   • Test with rate limiting in mind. Interstitial ads have a minimum interval between displays (typically 30 seconds). Verify that your game respects this.
5. Test banners:
   • Call FBInstant.getBannerAdAsync() to load a banner.
   • Verify that the banner appears in the correct position and does not overlap critical game UI.

• Console: View console.log() output, errors, and warnings. Use the console to inspect FBInstant API responses.
• Network tab: Monitor network requests to verify that your game is loading assets correctly and that any external server calls (if using Zero Permissions) are succeeding.
• Performance tab: Profile your game’s rendering and JavaScript execution to identify performance bottlenecks.
• Application tab: Inspect local storage, session storage, and indexed DB to debug data persistence issues.

// Log a custom event
FBInstant.logEvent(
  'level_completed',    // Event name
  42,                   // Numeric value (e.g., score)
  { level: '5' }       // Optional parameters (up to 25)
);

• Level completions, with the level number and score.
• Tutorial completion rate.
• Ad impressions and rewarded ad completions.
• Purchase events.
• Error events (catch blocks in your game logic).

• Android: Connect your device to your computer via USB, enable USB debugging, and use Chrome’s chrome://inspect page to attach to the WebView running your game. This gives you full access to Chrome DevTools for the mobile session.
• iOS: Connect your device to a Mac via USB, open Safari, and use Develop > [Device Name] to inspect the WebView. You will need to enable Web Inspector in your iOS device’s Safari settings.

• Use console.log(), console.warn(), and console.error() liberally during development to track game state and debug issues.
• Wrap SDK calls in try/catch blocks and log errors:

  try {
    var data = await FBInstant.player.getDataAsync(['level', 'score']);
    console.log('Player data loaded:', data);
  } catch (error) {
    console.error('Failed to load player data:', error);
  }
• Before pushing to production, reduce or remove verbose logging to avoid leaking implementation details and to improve performance.

• Loading progress is reported correctly.
• The game handles network timeouts gracefully.
• External API calls (if using Zero Permissions) have appropriate retry logic.

• USER_INPUT: The player cancelled an action (share, purchase, context selection).
• NETWORK_FAILURE: A network request failed.
• INVALID_PARAM: An API was called with invalid arguments.
• CLIENT_UNSUPPORTED: The API is not available on the current platform or SDK version.

FBInstant.shareAsync({
  intent: 'SHARE',
  image: base64Image,
  text: 'Check out my score!'
}).then(function() {
  console.log('Share completed');
}).catch(function(error) {
  // Player may have cancelled the share. Handle gracefully.
  console.log('Share did not complete:', error.code);
});

my-game.zip
  index.html
  fbapp-config.json
  game.js
  assets/
    sprite.png
    sound.mp3

my-game.zip
  my-game/
    index.html
    fbapp-config.json
    game.js
    assets/
      sprite.png
      sound.mp3

• Game loads in under 5 seconds on a mid-range device with an average network connection.
• Loading progress bar advances smoothly (using setLoadingProgress()).
• Game plays correctly on iOS, Android, and desktop web.
• Tutorial is clear, functional, and completable in under 30 seconds.
• All social features work (connected players, sharing, challenges, tournaments).
• In-app purchases complete successfully and items are delivered.
• Ads load and display at natural break points without disrupting gameplay.
• The game handles ad load failures gracefully (e.g., hides ad buttons when no fill is available).
• Player data saves and loads correctly across sessions.
• The game handles network interruptions gracefully.
• No console errors or unhandled promise rejections.
• The game respects orientation settings configured in fbapp-config.json.
• All game assets are optimized (compressed images, minified JavaScript).
• No verbose debug logging in the production build.

• Bundle Configuration — Configure platform behaviors with fbapp-config.json.
• Game Performance — Optimize your game’s loading time and runtime performance.
• Quality Guidelines — Review the requirements your game must meet before going live.
• SDK Reference — Full API documentation for the Instant Games SDK.