Testing Your Story

Overview

Thorough testing ensures your Living Story works correctly and provides the experience you intend. This guide covers strategies for testing all aspects of your story systematically.

Why Test Your Story

Catch Issues Early

Common problems testing reveals:

• Broken connections between scenes
• Missing interaction options
• Incorrect conditional logic
• Typos and formatting issues
• Unclear instructions or confusing flow

Benefits of testing:

• Find and fix problems before sharing
• Ensure all paths work correctly
• Verify story makes sense
• Improve overall quality

Verify User Experience

Testing helps confirm:

• Story flows naturally
• Choices are clear and meaningful
• Conditional content appears correctly
• Navigation works smoothly
• Story reaches satisfying conclusions

Testing Strategy

Three-Phase Approach

Phase 1: Quick Flow Test

• Run through the main path
• Verify basic functionality
• Check for obvious issues
• Takes 5-10 minutes

Phase 2: Branch Testing

• Test all interaction branches
• Verify each path works
• Check conditional content
• Takes 20-30 minutes

Phase 3: Edge Case Testing

• Test unusual combinations
• Verify boundary conditions
• Stress test complex logic
• Takes 30-60 minutes

When to use each phase:

• Phase 1: After every editing session
• Phase 2: After structural changes or before sharing
• Phase 3: Before final deployment or publication

Testing Story Flow

Linear Flow Testing

For stories without branching:

What to check:

1. Sequences connect - Each sequence leads to the next
2. Scenes appear in order - Scene numbering is correct
3. Story completes - Reaches a proper ending
4. No gaps - No missing scenes or broken connections

How to test:

1. Enter Preview Mode
2. Read through from start to finish
3. Verify smooth progression
4. Check that ending appears

Branching Flow Testing

For stories with choices:

What to check:

1. All branches are reachable - Every path can be accessed
2. Choices are clear - Options make sense in context
3. Paths diverge correctly - Different choices lead to different outcomes
4. Paths converge correctly - Multiple routes can reach same scenes (if designed)
5. No dead ends - All paths lead somewhere meaningful

How to test:

Method 1: Depth-First (follow one path fully, then backtrack)

1. Start from beginning
2. Make first choice at each interaction
3. Follow to an ending
4. Go back to first interaction
5. Try second choice, follow to ending
6. Repeat for all branches

Method 2: Breadth-First (test one level at a time)

1. Test all choices at first interaction
2. Note where each leads
3. Test all choices at second level interactions
4. Continue through all levels
5. Verify all paths to endings

Method 3: Path Mapping (visual approach)

1. Draw or document your story structure
2. Mark each path as you test it
3. Ensure all paths are tested
4. Visual confirmation of coverage

Testing Interactions

Testing Poll Interactions

What to verify:

• All poll options appear correctly
• Option text is clear and readable
• Selecting each option works
• Each option leads to correct next sequence
• No option is unreachable or broken

Testing steps:

1. Reach the poll interaction in preview
2. Note how many options should appear
3. Verify all options are visible
4. Select first option and note where it leads
5. Go back and test each other option
6. Verify each leads to different paths (if designed that way)

Common issues:

• Missing option text
• Options leading to wrong sequences
• Duplicate options
• Options that don't work when clicked

Testing Text Interactions

What to verify:

• Input field appears and accepts text
• Instructions are clear
• Text is processed correctly
• Different inputs lead to intended paths
• Edge cases are handled (empty input, very long input, special characters)

Testing steps:

1. Reach the text interaction in preview
2. Read the prompt/instructions
3. Try expected keywords or phrases
4. Verify correct path is taken
5. Go back and try unexpected inputs
6. Test edge cases

Test cases to try:

• Correct keyword
• Misspelled keyword
• Empty/no input
• Very long text
• Special characters
• Different capitalization
• Partial matches

Testing Touch/Movement Interactions

What to verify:

• Interaction loads and is responsive
• Instructions are clear
• Touch or movement is detected
• Different actions lead to intended outcomes
• Works on intended devices

Testing steps:

1. Test in preview mode on desktop
2. Test on actual mobile device if possible
3. Try different gesture speeds and intensities
4. Verify different outcomes based on input
5. Check edge cases (very fast, very slow, minimal input)

Testing Audio Interactions

What to verify:

• Audio input is requested/permitted
• Recording works correctly
• Audio is processed as intended
• Different audio inputs lead to correct paths
• Permissions are handled gracefully

Testing steps:

1. Allow audio permissions when prompted
2. Test with clear speech
3. Test with unclear speech
4. Test with background noise
5. Verify fallback behavior

Note: Audio interactions may require specific testing environments and real devices.

Testing Conditional Logic

Understanding Conditional Scenes

Conditional scenes appear or disappear based on influence values:

In Preview Mode:

• Conditional scenes have highlighted borders
• Scenes only appear if their condition is true
• Scenes are skipped if their condition is false
• This visual indicator helps you identify conditional content

See What Are Influences for background.

Testing Conditional Scenes

What to verify:

• Scene appears when condition is met
• Scene is hidden when condition is not met
• Condition logic is correct (AND, OR, NOT)
• Boundary values work correctly
• Multiple conditions work together

Testing steps:

Positive test (should appear):

1. Note the condition required (e.g., "courage > 5")
2. Make choices that satisfy the condition
3. Reach the sequence with the conditional scene
4. Verify scene appears with highlighted border
5. Verify content makes sense in context

Negative test (should not appear):

1. Restart preview or go back
2. Make choices that don't satisfy condition
3. Reach the same sequence
4. Verify scene does not appear
5. Verify story flows correctly without it

Boundary test (test edge values):

1. If condition is "courage > 5", test with:
   • courage = 4 (should not appear)
   • courage = 5 (should not appear, > is "greater than")
   • courage = 6 (should appear)
2. Verify boundary is exactly where you intended

Testing Conditional Text

Conditional text within scenes changes based on influences:

What to verify:

• Correct text variant appears for each condition
• Fallback text appears when no condition is met
• Text changes make sense in context
• Multiple conditional texts don't conflict

Testing steps:

1. Identify scenes with conditional text
2. Note what conditions control the text
3. Set influences to trigger first variant
4. Read scene and verify correct text appears
5. Change influence values
6. Verify text updates to correct variant

See Conditional Text for details.

Testing Complex Conditions

For conditions with AND, OR, NOT operators:

What to verify:

• AND conditions require all parts to be true
• OR conditions require at least one part to be true
• NOT conditions reverse the logic
• Grouped conditions evaluate correctly
• Order of operations is correct

Testing approach:

For AND conditions (e.g., "courage > 5 AND trust > 3"):

• Test with both true: Should pass
• Test with first true, second false: Should fail
• Test with first false, second true: Should fail
• Test with both false: Should fail

For OR conditions (e.g., "courage > 5 OR trust > 3"):

• Test with both true: Should pass
• Test with first true, second false: Should pass
• Test with first false, second true: Should pass
• Test with both false: Should fail

For NOT conditions (e.g., "NOT hasKey"):

• Test with hasKey = true: Should fail
• Test with hasKey = false: Should pass

Testing Different Story Paths

Path Coverage

Goal: Test every unique path through your story.

How to track coverage:

Option 1: Checklist

# Path Testing Checklist

## First Interaction Branches

- [ ] Choice A → Path to Scene 5
- [ ] Choice B → Path to Scene 6
- [ ] Choice C → Path to Scene 7

## Second Interaction Branches (from Path A)

- [ ] Choice A1 → Ending 1
- [ ] Choice A2 → Ending 2

## Second Interaction Branches (from Path B)

- [ ] Choice B1 → Ending 1
- [ ] Choice B2 → Ending 3

Option 2: Path Matrix

First Choice	Second Choice	Third Choice	Ending
Cautious	Trust	Reveal	Happy
Cautious	Trust	Hide	Neutral
Cautious	Doubt	Reveal	Bad
Bold	Trust	Reveal	Heroic
... (etc.)

Option 3: Visual Map

• Use the story canvas
• Mark tested paths with notes
• Track coverage visually

Testing All Endings

What to verify:

• All endings are reachable
• Endings make sense based on path taken
• Endings feel satisfying
• No ending is accidentally unreachable

How to test:

1. List all intended endings
2. For each ending, trace back what path leads to it
3. Test that path in preview
4. Verify ending appears
5. Check that ending feels appropriate for the choices made

Creating a Test Plan

Before You Start Testing

Document your story structure:

1. List all interactions and their options
2. List all conditional scenes and their conditions
3. List all endings
4. Note any complex logic

Create testing checklist:

• Test main/happy path
• Test all interaction branches
• Test all conditional scenes (positive cases)
• Test conditional scenes don't appear when they shouldn't (negative cases)
• Test all endings are reachable
• Test edge cases and unusual combinations
• Test on different devices (if applicable)

During Testing

Document as you go using the Notebook:

# Test Session - [Date]

## Tested Today

- Main path: Working correctly
- Alternative choice at Scene 3: Leads to Scene 8 ✓
- Conditional Scene 10: Appears when trust > 5 ✓
- Conditional Scene 10: Correctly hidden when trust < 5 ✓

## Issues Found

1. Scene 7: Typo in dialogue ("teh" should be "the")
2. Interaction at Scene 9: Third option text is blank
3. Conditional Scene 12: Appears even when condition is false - check logic

## To Retest After Fixes

- [ ] Scene 7 typo
- [ ] Scene 9 third option
- [ ] Scene 12 conditional logic

After Testing

Review findings:

• Prioritize issues (critical bugs vs. minor improvements)
• Fix issues in order of importance
• Retest after each fix
• Document that fixes work

Final verification:

• Run through complete test plan again
• Verify all issues are resolved
• Get fresh perspective (someone else tests)
• Approve for sharing/deployment

Testing Best Practices

Test Regularly

When to test:

• After creating each new sequence
• After adding interactions
• After setting up conditional logic
• Before sharing with collaborators
• Before making story public
• After any structural changes

Why test often:

• Easier to identify what caused issues
• Less overwhelming than testing everything at once
• Maintains quality throughout development
• Prevents accumulation of problems

Test Systematically

Don't test randomly:

• Follow a plan
• Check items off as you test
• Document what you've tested
• Don't rely on memory

Benefits:

• Ensures complete coverage
• Nothing gets missed
• Easy to resume testing later
• Clear record of what works

Get Others to Test

Why external testing helps:

• Fresh perspective
• Different choices than you'd make
• May find issues you missed
• Experience as actual users

How to get testers:

• Share with "Preview Only" permission (see Sharing Stories)
• Ask for specific feedback
• Provide testing guidance if needed
• Gather and incorporate feedback

Keep Testing Notes

Use the Notebook (see Notebook Feature):

• Document test results
• Track issues found
• Note what's been fixed
• Keep testing checklists
• Record testing dates and findings

Benefits:

• Don't lose track of issues
• Can review testing history
• Easy to see what still needs testing
• Documentation for future updates

Common Issues and Solutions

"Scene doesn't appear"

Possible causes:

• Connection is broken
• Scene is in a sequence that's not connected
• Conditional scene's condition is not met

How to fix:

1. Check canvas connections
2. Verify sequence is connected to interaction points
3. Check conditional logic if scene is conditional
4. Test influence values in preview

"Interaction doesn't work"

Possible causes:

• Interaction points not configured
• Missing option text
• Connection to next sequence is broken

How to fix:

1. Open interaction settings
2. Verify all points are configured
3. Check that each point has text and a connected sequence
4. Test in preview again

"Conditional scene appears when it shouldn't"

Possible causes:

• Condition logic is reversed
• Condition is using wrong operator (< vs >, AND vs OR)
• Influence value is different than expected

How to fix:

1. Review the condition in scene settings
2. Check operator
3. Verify which influence is being checked
4. Test with known influence values
5. Adjust condition as needed

"Story has dead end"

Possible causes:

• Sequence doesn't have an end connection
• Interaction doesn't have all points configured
• Last sequence doesn't mark story completion

How to fix:

1. Find where story stops in preview
2. Check that sequence/interaction in editor
3. Add missing connections
4. Verify path continues to ending

Next Steps

• Review Preview Mode for details on using the preview interface
• See Interactions Overview to understand what you're testing
• Learn about Influences for conditional logic testing
• Use Notebook to document your testing process