chore: Add CLAUDE.md and cleanup project organization

- Add CLAUDE.md with file organization rules and working code paths
- Add tests_temp/ to .gitignore for temporary AI-generated test files
- Remove old test files from tests/ (will rebuild with proper tests)
- Add performance timing logs to thoughtspot_deployer table creation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -217,3 +217,4 @@ dev/
 # Development notes and sensitive documentation
 dev_notes/
 *.tml
+tests_temp/

CLAUDE.md

@@ -0,0 +1,153 @@
+# Claude Context Guide for Demo Wire Project
+
+## CRITICAL: READ THIS FIRST
+
+This project has specific context and history. ALWAYS check the sprint documentation for current state and known issues before making changes.
+
+## Primary Context Document
+
+**ALWAYS READ**: `dev_notes/sprint2_102025.md`
+
+The sprint document has 5 key sections you need to understand:
+
+1. **OBJECTIVE** - Overall goal of the project (DO NOT EDIT)
+
+2. **TASKS** - Current sprint tasks (DO NOT EDIT)
+
+3. **BACKLOG** - New items discovered during development
+   - boone will ask you to add items here as we find them
+   - You can also suggest items for the backlog
+
+4. **ARCHITECTURE** - Critical technical reference information
+   - Prioritize this information when making decisions
+   - But still explore other options when appropriate
+
+5. **NOTES** - Documentation and context added as things happen
+   - Both of us add dated entries here
+   - Important learnings, fixes, and discoveries
+
+## Key Project Facts
+
+### Environment Setup
+- **Python**: Using virtual environment at `./demo_wire/bin/activate`
+- **NOT using conda** - if you don't see packages, activate the venv first
+- **Supabase**: IS installed and configured - credentials in .env work fine
+- **ThoughtSpot**: Authentication works with demo_builder_user
+
+### Common Mistakes to Avoid
+1. **DO NOT** add unnecessary validation checks for .env variables - they are populated and working
+2. **DO NOT** try to install supabase or other packages - they're already in the venv
+3. **DO NOT** change default values to "thoughtspot.com" - that's for customer URLs, not ThoughtSpot's
+4. **DO NOT** assume worksheets are needed - they're deprecated, we use models now
+5. **ALWAYS** use the venv when running Python: `source ./demo_wire/bin/activate && python`
+
+### Known Issues & Fixes
+
+
+### Working Patterns
+- Settings save/load through Supabase - this WORKS when using venv
+- ThoughtSpot deployment uses TML format (not YAML)
+- Models have replaced worksheets in modern ThoughtSpot
+- Liveboards should match "golden demo" style (see sprint doc)
+
+## Quick Commands
+
+```bash
+# Run the app properly
+source ./demo_wire/bin/activate && python demo_prep.py
+
+# Check git changes
+git diff --stat
+
+# Find processes using port
+lsof -i :7860
+```
+
+## File Organization Rules - CRITICAL
+
+### Where to Put Files
+
+**tests/** - Real test cases that verify functionality
+- Unit tests for core functions
+- Integration tests for workflows
+- Tests that run as part of CI/CD
+- Example: `test_connection.py`, `test_model_creation.py`
+
+**tests_temp/** - Temporary AI-generated test files
+- Experimental test scripts
+- One-off verification scripts
+- Files that might be deleted after testing
+- DO NOT commit these to git without asking
+
+**dev_notes/** - Documentation and analysis
+- All .md files go here (except README.md and and CLAUDE.md)
+- Research documents
+- Architecture notes
+- Sprint planning documents
+
+**Root directory** - ONLY essential project files
+- Main application files (demo_prep.py, etc.)
+- Configuration files (.env, requirements.txt)
+- README.md and CLAUDE.md (documentation exceptions - must stay in root)
+- DO NOT create random .py, .yml, .md files in root
+
+### Rules for Creating Files
+
+1. **NEVER create files in root directory without asking**
+2. **Test files ALWAYS go in tests_temp/** unless they're real test cases
+3. **Documentation ALWAYS goes in dev_notes/**
+4. **Export/debug .yml/.json files go in tests_temp/** (and should be gitignored)
+5. **Ask before creating ANY new file** if unsure where it belongs
+
+### When Testing Existing Features
+
+**CRITICAL: DO NOT create simplified versions of working code**
+
+When user says "create a test for X":
+- ❌ WRONG: Write new simplified code from scratch
+- ✅ RIGHT: Call the existing working function in a test harness
+
+Example - Testing Liveboard Creation:
+- ❌ WRONG: Create new viz configs and call low-level functions
+- ✅ RIGHT: Call `create_liveboard_from_model()` (the function demo_prep.py uses)
+
+**Working Code Paths - DO NOT BYPASS THESE:**
+```
+Liveboard Creation:
+  demo_prep.py → create_liveboard_from_model() → LiveboardCreator.create_liveboard_tml()
+
+DO NOT use create_visualization_tml() directly - that's internal low-level code
+```
+
+## Before Making Changes
+
+1. Read the sprint document's "Known Issues" section
+2. Check if this has been tried before (see "Completed Items")
+3. Verify you're using the venv, not system Python
+4. Don't add validation that blocks working code
+5. **Check file organization rules before creating ANY files**
+
+## Contact & Frustration Points
+
+The user (boone) gets frustrated when:
+- You don't trust that .env variables are set correctly
+- You try to reinstall packages that are already installed
+- You make changes without understanding existing context
+- You break working code by "simplifying" it
+
+Also remember that boone is a Thoughspot Architect and a software architect.  Please know that you can challenge his ideas but also realize that he has been in the buisness for over twenty years and deep understanding of this app.
+
+When I ask yo uto STOP please stop immediately.  I will have further instructions.  Just Stop.
+
+I like to start out with a discussion and some back and forth.  Please use number when asking questions so that I can reply to the number.
+
+TS is short for Thoughtspot.  The company where I work.
+
+When in doubt, ASK rather than assume. Check the sprint doc for context.
+
+This software is curretnly stored in my repo but will be open sourced and move to TS repo.
+
+---
+
+*Last Updated: October 23, 2025*
+*This is a living document - update as you learn more about the project*

tests/debug_population_error.py

@@ -1,245 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug script to isolate the 'name e is not defined' error in population code generation.
-This will help us understand exactly what's happening without running the full app.
-"""
-
-import os
-import sys
-from dotenv import load_dotenv
-
-# Add the current directory to Python path
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-# Import the functions we need to test
-try:
-    from demo_prep import execute_population_script, extract_python_code, validate_python_syntax
-    from schema_utils import generate_schema_constrained_prompt, parse_ddl_schema
-    print("✅ Successfully imported required functions")
-except ImportError as e:
-    print(f"❌ Import error: {e}")
-    sys.exit(1)
-
-def test_population_error():
-    """Test the exact scenario that's causing the 'name e is not defined' error"""
-    
-    print("🔍 DEBUG TEST: Isolating population script error")
-    print("=" * 60)
-    
-    # Load environment
-    load_dotenv()
-    
-    # Sample DDL that should work (based on previous successful runs)
-    sample_ddl = """
-CREATE TABLE CHANNELS (
-    CHANNELID INT IDENTITY(1,1) PRIMARY KEY,
-    NAME VARCHAR(100) NOT NULL,
-    TYPE VARCHAR(50) NOT NULL,
-    PERFORMANCEMETRICS VARCHAR(500)
-);
-
-CREATE TABLE CUSTOMERS (
-    CUSTOMERID INT IDENTITY(1,1) PRIMARY KEY,
-    NAME VARCHAR(100) NOT NULL,
-    EMAIL VARCHAR(100) NOT NULL,
-    PHONE VARCHAR(20),
-    ADDRESS VARCHAR(200),
-    PREFERENCES VARCHAR(500),
-    INTERACTIONHISTORY VARCHAR(1000)
-);
-
-CREATE TABLE PRODUCTS (
-    PRODUCTID INT IDENTITY(1,1) PRIMARY KEY,
-    NAME VARCHAR(100) NOT NULL,
-    CATEGORY VARCHAR(50) NOT NULL,
-    PRICE DECIMAL(10,2) NOT NULL,
-    STOCKLEVEL INT NOT NULL
-);
-
-CREATE TABLE SALESTRANSACTIONS (
-    TRANSACTIONID INT IDENTITY(1,1) PRIMARY KEY,
-    CUSTOMERID INT NOT NULL,
-    PRODUCTID INT NOT NULL,
-    DATE DATE NOT NULL,
-    AMOUNT DECIMAL(10,2) NOT NULL,
-    CHANNELID INT NOT NULL,
-    FOREIGN KEY (CUSTOMERID) REFERENCES CUSTOMERS(CUSTOMERID),
-    FOREIGN KEY (PRODUCTID) REFERENCES PRODUCTS(PRODUCTID),
-    FOREIGN KEY (CHANNELID) REFERENCES CHANNELS(CHANNELID)
-);
-
-CREATE TABLE CUSTOMERINTERACTIONS (
-    INTERACTIONID INT IDENTITY(1,1) PRIMARY KEY,
-    CUSTOMERID INT NOT NULL,
-    CHANNELID INT NOT NULL,
-    DATE DATE NOT NULL,
-    INTERACTIONTYPE VARCHAR(50) NOT NULL,
-    OUTCOME VARCHAR(50) NOT NULL,
-    FOREIGN KEY (CUSTOMERID) REFERENCES CUSTOMERS(CUSTOMERID),
-    FOREIGN KEY (CHANNELID) REFERENCES CHANNELS(CHANNELID)
-);
-"""
-    
-    print("📋 Step 1: Testing DDL parsing...")
-    try:
-        schema_info = parse_ddl_schema(sample_ddl)
-        print(f"✅ DDL parsed successfully: {len(schema_info)} tables found")
-        for table_name, table_info in schema_info.items():
-            print(f"   - {table_name}: {len(table_info['columns'])} columns")
-    except Exception as e:
-        print(f"❌ DDL parsing failed: {e}")
-        return False
-    
-    print("\n📝 Step 2: Testing prompt generation...")
-    try:
-        business_context = """
-BUSINESS CONTEXT:
-- Use Case: Sales AI Analyst
-- Target Persona: Sales Operations Manager
-- Business Problem: Identifying sales performance gaps and customer churn risks
-- Demo Objectives: Demonstrate AI-driven sales insights and predictive analytics
-- Success Outcomes: Improved sales forecasting and customer retention
-
-MANDATORY CONNECTION CODE:
-from dotenv import load_dotenv
-import os
-import snowflake.connector
-
-load_dotenv()
-
-from snowflake_auth import get_snowflake_connection_params
-conn_params = get_snowflake_connection_params()
-conn = snowflake.connector.connect(
-    **conn_params,
-    schema=os.getenv('SNOWFLAKE_SCHEMA')
-)
-
-SCRIPT REQUIREMENTS:
-1. Connect to Snowflake using connection code above
-2. Populate tables with realistic data volumes (1000+ rows per table)
-3. Create baseline normal data patterns
-4. NO explanatory text, just executable Python code
-5. Use proper error handling with try-catch blocks
-6. Include data validation to ensure referential integrity
-7. Add progress logging for each table population
-8. Use realistic data patterns that match the business context
-9. Ensure all foreign key relationships are maintained
-"""
-        
-        data_prompt = generate_schema_constrained_prompt(
-            schema_info,
-            "Sales AI Analyst",
-            business_context
-        )
-        print(f"✅ Prompt generated successfully: {len(data_prompt)} characters")
-    except Exception as e:
-        print(f"❌ Prompt generation failed: {e}")
-        return False
-    
-    print("\n🤖 Step 3: Using sample broken LLM output...")
-    # Use a sample broken LLM output that likely causes the "name 'e' is not defined" error
-    llm_output = '''```python
-from dotenv import load_dotenv
-import os
-import snowflake.connector
-from snowflake_auth import get_snowflake_connection_params
-from faker import Faker
-import random
-
-def main():
-    try:
-        load_dotenv()
-        conn_params = get_snowflake_connection_params()
-        conn = snowflake.connector.connect(
-            **conn_params,
-            schema=os.getenv('SNOWFLAKE_SCHEMA')
-        )
-        cursor = conn.cursor()
-        
-        # Populate Channels table
-        print("Populating Channels...")
-        for i in range(100):
-            cursor.execute("INSERT INTO CHANNELS (NAME, TYPE) VALUES (?, ?)", 
-                         (f"Channel {i}", "Online"))
-        
-        conn.commit()
-        print("Population completed!")
-        
-    # This is the broken part - incomplete try-except block
-    except Exception as e:
-        print(f"Error: {e}")
-        # Missing finally or another except block that references 'e'
-        
-if __name__ == "__main__":
-    main()
-```'''
-    
-    print(f"✅ Using sample LLM output: {len(llm_output)} characters")
-    
-    # Save the output for inspection
-    with open("debug_llm_output.txt", "w") as f:
-        f.write(llm_output)
-    print("📁 Saved sample LLM output to debug_llm_output.txt")
-    
-    print("\n🔍 Step 4: Testing syntax validation...")
-    try:
-        syntax_valid, syntax_message = validate_python_syntax(llm_output)
-        print(f"Syntax validation result: {syntax_valid}")
-        print(f"Syntax message: {syntax_message}")
-    except Exception as e:
-        print(f"❌ Syntax validation failed: {e}")
-        print(f"❌ This might be our 'name e is not defined' error!")
-        return False
-    
-    print("\n🔧 Step 5: Testing code extraction...")
-    try:
-        extracted_code = extract_python_code(llm_output)
-        print(f"✅ Code extracted: {len(extracted_code)} characters")
-        
-        # Save the extracted code for inspection
-        with open("debug_extracted_code.py", "w") as f:
-            f.write(extracted_code)
-        print("📁 Saved extracted code to debug_extracted_code.py")
-        
-    except Exception as e:
-        print(f"❌ Code extraction failed: {e}")
-        return False
-    
-    print("\n🚀 Step 6: Testing population script execution...")
-    try:
-        # Use a test schema name
-        test_schema = "TEST_DEBUG_SCHEMA"
-        
-        print(f"   Testing with schema: {test_schema}")
-        success, message = execute_population_script(llm_output, test_schema)
-        
-        if success:
-            print(f"✅ Population script executed successfully!")
-        else:
-            print(f"❌ Population script failed: {message}")
-            print("❌ This is likely where our error occurs!")
-            
-    except Exception as e:
-        print(f"❌ Population script execution failed: {e}")
-        print(f"❌ Error type: {type(e).__name__}")
-        import traceback
-        print("❌ Full traceback:")
-        traceback.print_exc()
-        return False
-    
-    print("\n" + "=" * 60)
-    print("🎯 DEBUG TEST COMPLETE")
-    print("Check the generated files:")
-    print("  - debug_llm_output.txt (raw LLM response)")
-    print("  - debug_extracted_code.py (extracted Python code)")
-    print("=" * 60)
-    
-    return True
-
-if __name__ == "__main__":
-    print("🧪 Starting isolated debug test for population error...")
-    success = test_population_error()
-    if success:
-        print("✅ Debug test completed successfully!")
-    else:
-        print("❌ Debug test failed - this should help identify the issue!")

tests/debug_schema_utils.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug script to isolate the 'name e is not defined' error in schema_utils.py
-"""
-
-import os
-import sys
-from dotenv import load_dotenv
-
-# Add the current directory to Python path
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-# Import the functions we need to test
-try:
-    from schema_utils import generate_schema_constrained_prompt, parse_ddl_schema
-    print("✅ Successfully imported schema_utils functions")
-except ImportError as e:
-    print(f"❌ Import error: {e}")
-    sys.exit(1)
-
-def test_schema_utils_error():
-    """Test the generate_schema_constrained_prompt function specifically"""
-    
-    print("🔍 DEBUG TEST: Isolating schema_utils error")
-    print("=" * 60)
-    
-    # Load environment
-    load_dotenv()
-    
-    # Sample DDL
-    sample_ddl = """
-CREATE TABLE CHANNELS (
-    CHANNELID INT IDENTITY(1,1) PRIMARY KEY,
-    NAME VARCHAR(100) NOT NULL,
-    TYPE VARCHAR(50) NOT NULL,
-    PERFORMANCEMETRICS VARCHAR(500)
-);
-
-CREATE TABLE CUSTOMERS (
-    CUSTOMERID INT IDENTITY(1,1) PRIMARY KEY,
-    NAME VARCHAR(100) NOT NULL,
-    EMAIL VARCHAR(100) NOT NULL,
-    PHONE VARCHAR(20),
-    ADDRESS VARCHAR(200),
-    PREFERENCES VARCHAR(500),
-    INTERACTIONHISTORY VARCHAR(1000)
-);
-"""
-    
-    print("📋 Step 1: Testing DDL parsing...")
-    try:
-        schema_info = parse_ddl_schema(sample_ddl)
-        print(f"✅ DDL parsed successfully: {len(schema_info)} tables found")
-        for table_name, table_info in schema_info.items():
-            print(f"   - {table_name}: {len(table_info['columns'])} columns")
-            print(f"     Columns: {[col['name'] for col in table_info['columns']]}")
-    except Exception as e:
-        print(f"❌ DDL parsing failed: {e}")
-        import traceback
-        print("❌ Full traceback:")
-        traceback.print_exc()
-        return False
-    
-    print("\n📝 Step 2: Testing prompt generation...")
-    try:
-        business_context = """
-BUSINESS CONTEXT:
-- Use Case: Sales AI Analyst
-- Target Persona: Sales Operations Manager
-- Business Problem: Identifying sales performance gaps
-"""
-        
-        print("   Calling generate_schema_constrained_prompt...")
-        data_prompt = generate_schema_constrained_prompt(
-            schema_info,
-            "Sales AI Analyst",
-            business_context
-        )
-        print(f"✅ Prompt generated successfully: {len(data_prompt)} characters")
-        
-        # Save the prompt for inspection
-        with open("debug_generated_prompt.txt", "w") as f:
-            f.write(data_prompt)
-        print("📁 Saved generated prompt to debug_generated_prompt.txt")
-        
-    except Exception as e:
-        print(f"❌ Prompt generation failed: {e}")
-        print(f"❌ Error type: {type(e).__name__}")
-        import traceback
-        print("❌ Full traceback:")
-        traceback.print_exc()
-        return False
-    
-    print("\n" + "=" * 60)
-    print("🎯 SCHEMA_UTILS DEBUG TEST COMPLETE")
-    print("=" * 60)
-    
-    return True
-
-if __name__ == "__main__":
-    print("🧪 Starting isolated debug test for schema_utils error...")
-    success = test_schema_utils_error()
-    if success:
-        print("✅ Debug test completed successfully!")
-    else:
-        print("❌ Debug test failed - this should help identify the issue!")

tests/test_connection_success.py

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-"""
-SUCCESS-ONLY ThoughtSpot Connection Test
-GUARANTEED SUCCESS - Connection creation only
-"""
-
-import os
-import sys
-# Add parent directory to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from dotenv import load_dotenv
-from thoughtspot_deployer import ThoughtSpotDeployer
-
-load_dotenv()
-
-def test_connection_success():
-    """Test ONLY connection creation - GUARANTEED SUCCESS"""
-    
-    print("🎯 THOUGHTSPOT CONNECTION SUCCESS TEST")
-    print("=" * 55)
-    print("🎉 This test focuses ONLY on what works perfectly!")
-    
-    schema_name = "20250918_001404_THOUG_SAL" 
-    database = "DEMOBUILD"
-    
-    print(f"📊 Testing with schema: {schema_name}")
-    print(f"📊 Database: {database}")
-    print()
-
-    try:
-        # Initialize deployer
-        deployer = ThoughtSpotDeployer()
-        print("✅ ThoughtSpot deployer initialized")
-        
-        # Test authentication
-        print("\n🔐 Testing ThoughtSpot authentication...")
-        if deployer.authenticate():
-            print("✅ ThoughtSpot authentication SUCCESSFUL")
-        else:
-            print("❌ ThoughtSpot authentication failed")
-            return False
-        
-        # Test connection creation ONLY
-        print("\n🔗 Testing connection creation...")
-        
-        # Create connection using the internal method directly
-        from datetime import datetime
-        connection_name = f"success_conn_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-        
-        print(f"🔗 Creating connection: {connection_name}")
-        print(f"   Account: '{deployer.sf_account}'")
-        print(f"   User: '{deployer.sf_user}'")
-        print(f"   Database: '{database}'")
-        
-        # Create the connection TML
-        connection_tml_yaml = deployer.create_connection_tml(connection_name, database)
-        
-        # Deploy the connection
-        response = deployer.session.post(
-            f"{deployer.base_url}/api/rest/2.0/metadata/tml/import",
-            json={
-                "metadata_tmls": [connection_tml_yaml],
-                "import_policy": "PARTIAL"
-            }
-        )
-        
-        print(f"   Response status: {response.status_code}")
-        
-        if response.status_code == 200:
-            result = response.json()
-            if isinstance(result, list) and len(result) > 0:
-                if result[0].get('response', {}).get('status', {}).get('status_code') == 'OK':
-                    connection_guid = result[0].get('response', {}).get('header', {}).get('id_guid')
-                    
-                    print("🎉" * 20)
-                    print("🎯 CONNECTION CREATION SUCCESS!")
-                    print(f"✅ Connection Name: {connection_name}")
-                    print(f"✅ Connection GUID: {connection_guid}")
-                    print(f"✅ Schema Access: {schema_name}")
-                    print(f"✅ Authentication: KEY_PAIR working")
-                    print(f"✅ API Integration: PERFECT")
-                    print("🎉" * 20)
-                    
-                    return True
-                else:
-                    error_msg = result[0].get('response', {}).get('status', {}).get('error_message', 'Unknown error')
-                    print(f"❌ Connection creation failed: {error_msg}")
-                    return False
-            else:
-                print(f"❌ Unexpected response format: {result}")
-                return False
-        else:
-            try:
-                error_response = response.json()
-                print(f"❌ HTTP {response.status_code}: {error_response}")
-            except:
-                print(f"❌ HTTP {response.status_code}: {response.text}")
-            return False
-        
-    except Exception as e:
-        print(f"❌ Test failed with exception: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def main():
-    """Run the success test"""
-    success = test_connection_success()
-    
-    print("\n" + "="*55)
-    if success:
-        print("🏆 OVERALL RESULT: COMPLETE SUCCESS! 🏆")
-        print("🚀 ThoughtSpot integration is working perfectly!")
-        print("🎯 Ready for production deployment!")
-    else:
-        print("❌ OVERALL RESULT: Something failed")
-    print("="*55)
-    
-    return success
-
-if __name__ == "__main__":
-    main()

tests/test_core_success.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-"""
-CORE SUCCESS ThoughtSpot Test
-Skip problematic TIMESTAMP columns, focus on core columns
-Connection + Tables + Model = SUCCESS
-"""
-
-import os
-import sys
-# Add parent directory to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from dotenv import load_dotenv
-from thoughtspot_deployer import ThoughtSpotDeployer
-
-load_dotenv()
-
-def test_core_success():
-    """Test with core columns only (skip CREATEDAT timestamps)"""
-    
-    print("🎯 THOUGHTSPOT CORE SUCCESS TEST")
-    print("=" * 55)
-    print("🎉 Using CORE columns only (skip CREATEDAT)!")
-    
-    schema_name = "20250918_001404_THOUG_SAL" 
-    database = "DEMOBUILD"
-    
-    # Core DDL - skip CREATEDAT columns that cause timestamp issues
-    core_ddl = """
-    CREATE TABLE CUSTOMERS (
-        CUSTOMERID NUMBER(38,0) NOT NULL,
-        FIRSTNAME VARCHAR(50) NOT NULL,
-        LASTNAME VARCHAR(50) NOT NULL,
-        EMAIL VARCHAR(100) NOT NULL,
-        PHONE VARCHAR(20) NOT NULL,
-        ADDRESS VARCHAR(255) NOT NULL,
-        CITY VARCHAR(50) NOT NULL,
-        STATE VARCHAR(50) NOT NULL,
-        ZIPCODE VARCHAR(10) NOT NULL,
-        COUNTRY VARCHAR(50) NOT NULL
-    );
-
-    CREATE TABLE PRODUCTS (
-        PRODUCTID NUMBER(38,0) NOT NULL,
-        PRODUCTNAME VARCHAR(100) NOT NULL,
-        DESCRIPTION VARCHAR(255) NOT NULL,
-        PRICE NUMBER(10,2) NOT NULL,
-        STOCKQUANTITY NUMBER(38,0) NOT NULL
-    );
-
-    CREATE TABLE ORDERS (
-        ORDERID NUMBER(38,0) NOT NULL,
-        CUSTOMERID NUMBER(38,0) NOT NULL,
-        ORDERDATE DATE NOT NULL,
-        TOTALAMOUNT NUMBER(10,2) NOT NULL,
-        STATUS VARCHAR(50) NOT NULL
-    );
-    """
-    
-    print(f"📊 Testing with schema: {schema_name}")
-    print(f"📊 Database: {database}")
-    print(f"📊 Tables: 3 core tables (no CREATEDAT columns)")
-    print()
-
-    try:
-        # Initialize deployer
-        deployer = ThoughtSpotDeployer()
-        print("✅ ThoughtSpot deployer initialized")
-        
-        # Test authentication
-        print("\n🔐 Testing ThoughtSpot authentication...")
-        if deployer.authenticate():
-            print("✅ ThoughtSpot authentication SUCCESSFUL")
-        else:
-            print("❌ ThoughtSpot authentication failed")
-            return False
-        
-        # Test FULL deployment
-        print("\n🚀 Testing CORE deployment (Connection + Tables + Model)...")
-        
-        results = deployer.deploy_all(
-            ddl=core_ddl,
-            database=database,
-            schema=schema_name
-        )
-        
-        print(f"\n📋 RESULTS:")
-        
-        # Connection
-        if results.get('connection'):
-            print(f"✅ Connection: {results['connection']}")
-        else:
-            print("❌ Connection: Failed")
-            
-        # Tables  
-        if results.get('tables'):
-            print(f"✅ Tables: {len(results['tables'])} created")
-            for table in results['tables']:
-                print(f"   📊 {table}")
-        else:
-            print("❌ Tables: None created")
-            if results.get('errors'):
-                print("   🔍 First few errors:")
-                for error in results['errors'][:2]:
-                    print(f"      • {error[:80]}...")
-            
-        # Model
-        if results.get('model'):
-            print(f"✅ Model: {results['model']}")
-        else:
-            print("❌ Model: None created")
-            
-        # Success evaluation
-        connection_success = bool(results.get('connection'))
-        tables_success = len(results.get('tables', [])) > 0
-        model_success = bool(results.get('model'))
-        
-        print(f"\n🎯 SUCCESS BREAKDOWN:")
-        print(f"   Connection: {'✅' if connection_success else '❌'}")
-        print(f"   Tables: {'✅' if tables_success else '❌'}")  
-        print(f"   Model: {'✅' if model_success else '❌'}")
-        
-        overall_success = connection_success and tables_success
-        
-        print("\n" + "="*55)
-        if overall_success:
-            print("🏆 OVERALL RESULT: SUCCESS! 🏆")
-            print("🎉 Connection + Tables working!")
-            if model_success:
-                print("🎯 COMPLETE SUCCESS - Model too!")
-            else:
-                print("🔧 Model needs relationships, but CORE SUCCESS!")
-        else:
-            print("❌ OVERALL RESULT: Still working on it...")
-        print("="*55)
-        
-        return overall_success
-        
-    except Exception as e:
-        print(f"❌ Test failed with exception: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def main():
-    """Run the core success test"""
-    return test_core_success()
-
-if __name__ == "__main__":
-    main()

tests/test_deployment_flow.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test the updated deployment flow with schema permissions
-"""
-
-import os
-from dotenv import load_dotenv
-
-# Load environment variables (you may need to copy .env from sandbox2026)
-load_dotenv()
-
-def test_deployment_flow():
-    """Test the complete deployment flow"""
-    
-    print("🧪 Testing ThoughtSpot Deployment Flow")
-    print("=" * 50)
-    
-    # Check environment variables
-    required_vars = [
-        'THOUGHTSPOT_URL', 'THOUGHTSPOT_USERNAME', 'THOUGHTSPOT_PASSWORD',
-        'SNOWFLAKE_ACCOUNT', 'SNOWFLAKE_USER', 'SNOWFLAKE_PASSWORD', 
-        'SNOWFLAKE_ROLE', 'SNOWFLAKE_WAREHOUSE'
-    ]
-    
-    missing_vars = []
-    for var in required_vars:
-        if not os.getenv(var):
-            missing_vars.append(var)
-    
-    if missing_vars:
-        print("❌ Missing environment variables:")
-        for var in missing_vars:
-            print(f"   - {var}")
-        print("\n💡 Copy your .env file from sandbox2026 or set these variables")
-        return False
-    
-    print("✅ All environment variables found")
-    
-    # Show the intended flow
-    print("\n🚀 Deployment Flow:")
-    print("0️⃣ Grant schema permissions to se_role")
-    print("   GRANT USAGE ON DATABASE DEMOBUILD TO ROLE se_role")
-    print("   GRANT USAGE ON SCHEMA DEMOBUILD.{schema} TO ROLE se_role") 
-    print("   GRANT SELECT ON ALL TABLES IN SCHEMA DEMOBUILD.{schema} TO ROLE se_role")
-    print()
-    print("1️⃣ Create ThoughtSpot connection")
-    print("2️⃣ Create tables from DDL")
-    print("3️⃣ Create model")
-    
-    print("\n✅ Flow validated - ready for deployment!")
-    return True
-
-if __name__ == "__main__":
-    test_deployment_flow()

tests/test_end_to_end_demo.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test End-to-End Demo System
-Complete deployment test for creating a full demo model
-"""
-
-import os
-import sys
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from datetime import datetime
-from dotenv import load_dotenv
-from thoughtspot_deployer import ThoughtSpotDeployer
-
-load_dotenv()
-
-def test_end_to_end_demo():
-    """Test complete end-to-end demo deployment"""
-    
-    print("🚀 END-TO-END DEMO SYSTEM DEPLOYMENT")
-    print("=" * 60)
-    print("🎯 Creating complete demo model with all tables and proper structure")
-    
-    # Use the working schema
-    schema_name = "20250918_161144_THOUG_SAL" 
-    database = "DEMOBUILD"
-    
-    # Complete DDL for full e-commerce demo
-    demo_ddl = """
-    CREATE TABLE CUSTOMERS (
-        CUSTOMERID NUMBER(38,0) NOT NULL,
-        FIRSTNAME VARCHAR(100) NOT NULL,
-        LASTNAME VARCHAR(100) NOT NULL,
-        EMAIL VARCHAR(255) NOT NULL,
-        PHONE VARCHAR(20) NOT NULL,
-        REGISTRATIONDATE DATE NOT NULL
-    );
-
-    CREATE TABLE PRODUCTS (
-        PRODUCTID NUMBER(38,0) NOT NULL,
-        PRODUCTNAME VARCHAR(255) NOT NULL,
-        CATEGORY VARCHAR(100) NOT NULL,
-        PRICE NUMBER(10,2) NOT NULL,
-        STOCKQUANTITY NUMBER(38,0) NOT NULL
-    );
-
-    CREATE TABLE ORDERS (
-        ORDERID NUMBER(38,0) NOT NULL,
-        CUSTOMERID NUMBER(38,0) NOT NULL,
-        ORDERDATE TIMESTAMP_NTZ(9) NOT NULL,
-        TOTALAMOUNT NUMBER(10,2) NOT NULL
-    );
-
-    CREATE TABLE ORDERITEMS (
-        ORDERITEMID NUMBER(38,0) NOT NULL,
-        ORDERID NUMBER(38,0) NOT NULL,
-        PRODUCTID NUMBER(38,0) NOT NULL,
-        QUANTITY NUMBER(38,0) NOT NULL,
-        UNITPRICE NUMBER(10,2) NOT NULL
-    );
-
-    CREATE TABLE SALES (
-        SALEID NUMBER(38,0) NOT NULL,
-        ORDERID NUMBER(38,0) NOT NULL,
-        SALESREPID NUMBER(38,0) NOT NULL,
-        SALEDATE TIMESTAMP_NTZ(9) NOT NULL
-    );
-
-    CREATE TABLE SALESREPS (
-        SALESREPID NUMBER(38,0) NOT NULL,
-        FIRSTNAME VARCHAR(100) NOT NULL,
-        LASTNAME VARCHAR(100) NOT NULL,
-        EMAIL VARCHAR(255) NOT NULL,
-        PHONE VARCHAR(20) NOT NULL,
-        HIREDATE DATE NOT NULL
-    );
-    """
-    
-    print(f"📊 Deploying to schema: {schema_name}")
-    print(f"📊 Database: {database}")
-    print(f"📊 Tables: 6 tables (complete e-commerce model)")
-    print()
-
-    try:
-        # Initialize deployer
-        deployer = ThoughtSpotDeployer()
-        
-        # Create unique names for this demo
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        connection_name = f"demo_system_{timestamp}"
-        
-        print(f"🔗 Demo Connection: {connection_name}")
-        print(f"🏷️  This will be your complete demo system!")
-        print()
-        
-        # Deploy everything using the updated deployer
-        print("🚀 Starting end-to-end deployment...")
-        results = deployer.deploy_all(
-            ddl=demo_ddl,
-            database=database,
-            schema=schema_name,
-            connection_name=connection_name
-        )
-        
-        print("\n" + "="*70)
-        print("📋 END-TO-END DEPLOYMENT RESULTS")
-        print("="*70)
-        
-        if results['success']:
-            print("🎉 DEPLOYMENT SUCCESSFUL!")
-            print(f"✅ Connection: {results['connection']}")
-            print(f"✅ Tables created: {len(results['tables'])}")
-            for table in results['tables']:
-                print(f"   • {table}")
-            print(f"✅ Model: {results['model']}")
-            
-            print("\n🎯 YOUR DEMO SYSTEM IS READY!")
-            print("="*50)
-            print(f"🔗 Connection Name: '{results['connection']}'")
-            print(f"📊 Model Name: '{results['model']}'")
-            print()
-            print("✨ WHAT YOU CAN DO NOW:")
-            print("1. 📈 Create searches and answers using the model")
-            print("2. 🎨 Build dashboards with the data")
-            print("3. 🤖 Use the model for AI-powered analytics")
-            print("4. 👥 Share with demo users")
-            print()
-            print("🔍 MODEL FEATURES:")
-            print("• ✅ No ID columns cluttering the interface")
-            print("• ✅ Smart column naming (RepFirstname, repPhone, etc.)")
-            print("• ✅ Proper measures vs attributes")
-            print("• ✅ Clean, business-friendly structure")
-            print("• ✅ Matches your proven boone_test5 pattern")
-            
-        else:
-            print("❌ DEPLOYMENT FAILED")
-            if results['errors']:
-                print("Errors encountered:")
-                for i, error in enumerate(results['errors'], 1):
-                    print(f"   {i}. {error}")
-                    
-            print("\n🔧 TROUBLESHOOTING:")
-            print("• Check ThoughtSpot connection settings")
-            print("• Verify Snowflake schema exists and is accessible")
-            print("• Ensure proper permissions are set")
-        
-        return results['success']
-        
-    except Exception as e:
-        print(f"\n❌ Deployment failed with error: {e}")
-        import traceback
-        traceback.print_exc()
-        
-        print("\n🔧 COMMON ISSUES:")
-        print("• Authentication failure - check credentials")
-        print("• Schema not found - run demo_prep.py first")
-        print("• Permission issues - verify Snowflake roles")
-        
-        return False
-
-if __name__ == "__main__":
-    print("🎬 STARTING END-TO-END DEMO SYSTEM DEPLOYMENT")
-    print("This will create a complete ThoughtSpot demo environment!")
-    print()
-    
-    success = test_end_to_end_demo()
-    
-    if success:
-        print(f"\n🎉 SUCCESS! Your end-to-end demo system is ready to use!")
-        print("Check ThoughtSpot for your new connection and model.")
-    else:
-        print(f"\n❌ FAILED! Please check the error messages above.")
-    
-    sys.exit(0 if success else 1)

tests/test_framework.py

@@ -1,447 +0,0 @@
-#!/usr/bin/env python3
-"""
-Enhanced Test Framework for Demo Wire
-Comprehensive testing with schema validation, performance metrics, and robust reporting
-"""
-
-import os
-import sys
-import time
-import json
-import traceback
-from datetime import datetime
-from typing import Dict, List, Any, Optional, Tuple
-from dataclasses import dataclass, asdict
-from enum import Enum
-
-# Add parent directory to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from dotenv import load_dotenv
-load_dotenv()
-
-class TestResult(Enum):
-    PASS = "✅ PASS"
-    FAIL = "❌ FAIL" 
-    SKIP = "⏭️ SKIP"
-    WARN = "⚠️ WARN"
-
-@dataclass
-class TestCase:
-    """Individual test case with metadata"""
-    name: str
-    description: str
-    category: str
-    priority: int  # 1=critical, 2=important, 3=nice-to-have
-    timeout: int = 60  # seconds
-    prerequisites: List[str] = None
-    expected_duration: float = 0.0  # seconds
-    
-    def __post_init__(self):
-        if self.prerequisites is None:
-            self.prerequisites = []
-
-@dataclass 
-class TestReport:
-    """Test execution report"""
-    test_name: str
-    result: TestResult
-    duration: float
-    error_message: str = ""
-    details: Dict[str, Any] = None
-    timestamp: str = ""
-    
-    def __post_init__(self):
-        if self.details is None:
-            self.details = {}
-        if not self.timestamp:
-            self.timestamp = datetime.now().isoformat()
-
-class TestFramework:
-    """Enhanced test framework with comprehensive reporting and validation"""
-    
-    def __init__(self):
-        self.results: List[TestReport] = []
-        self.start_time = None
-        self.test_cases: List[TestCase] = []
-        self.setup_complete = False
-        
-    def add_test(self, test_case: TestCase):
-        """Register a test case"""
-        self.test_cases.append(test_case)
-        
-    def validate_environment(self) -> TestReport:
-        """Validate required environment variables and dependencies"""
-        start_time = time.time()
-        
-        required_vars = [
-            'THOUGHTSPOT_URL', 'THOUGHTSPOT_USERNAME', 'THOUGHTSPOT_PASSWORD',
-            'SNOWFLAKE_ACCOUNT', 'SNOWFLAKE_USER', 'SNOWFLAKE_PRIVATE_KEY',
-            'SNOWFLAKE_ROLE', 'SNOWFLAKE_WAREHOUSE'
-        ]
-        
-        missing_vars = []
-        for var in required_vars:
-            if not os.getenv(var):
-                missing_vars.append(var)
-                
-        duration = time.time() - start_time
-        
-        if missing_vars:
-            return TestReport(
-                test_name="Environment Validation",
-                result=TestResult.FAIL,
-                duration=duration,
-                error_message=f"Missing environment variables: {', '.join(missing_vars)}",
-                details={"missing_vars": missing_vars}
-            )
-        
-        return TestReport(
-            test_name="Environment Validation", 
-            result=TestResult.PASS,
-            duration=duration,
-            details={"validated_vars": len(required_vars)}
-        )
-    
-    def validate_schema_structure(self, ddl: str) -> TestReport:
-        """Validate DDL structure and syntax"""
-        start_time = time.time()
-        
-        try:
-            # Basic DDL validation
-            validation_results = {
-                "has_create_statements": "CREATE TABLE" in ddl.upper(),
-                "table_count": ddl.upper().count("CREATE TABLE"),
-                "has_primary_keys": "PRIMARY KEY" in ddl.upper(),
-                "has_not_null": "NOT NULL" in ddl.upper(),
-                "estimated_complexity": len(ddl.split('\n'))
-            }
-            
-            # Check for common DDL patterns
-            critical_issues = []
-            warnings = []
-            
-            if validation_results["table_count"] == 0:
-                critical_issues.append("No CREATE TABLE statements found")
-                
-            if not validation_results["has_not_null"]:
-                warnings.append("No NOT NULL constraints found - consider data quality")
-                
-            # Validate column naming patterns
-            lines = ddl.split('\n')
-            for line in lines:
-                if 'CREATE TABLE' in line.upper():
-                    table_name = line.split()[-2] if '(' in line else line.split()[-1]
-                    validation_results[f"table_{table_name}"] = {
-                        "found": True,
-                        "line": line.strip()
-                    }
-            
-            duration = time.time() - start_time
-            result = TestResult.FAIL if critical_issues else (TestResult.WARN if warnings else TestResult.PASS)
-            
-            return TestReport(
-                test_name="Schema Structure Validation",
-                result=result,
-                duration=duration,
-                error_message="; ".join(critical_issues) if critical_issues else "",
-                details={
-                    **validation_results,
-                    "warnings": warnings,
-                    "critical_issues": critical_issues
-                }
-            )
-            
-        except Exception as e:
-            return TestReport(
-                test_name="Schema Structure Validation",
-                result=TestResult.FAIL,
-                duration=time.time() - start_time,
-                error_message=f"Validation failed: {str(e)}"
-            )
-    
-    def test_thoughtspot_auth(self) -> TestReport:
-        """Test ThoughtSpot authentication"""
-        start_time = time.time()
-        
-        try:
-            from thoughtspot_deployer import ThoughtSpotDeployer
-            
-            deployer = ThoughtSpotDeployer()
-            auth_success = deployer.authenticate()
-            
-            duration = time.time() - start_time
-            
-            return TestReport(
-                test_name="ThoughtSpot Authentication",
-                result=TestResult.PASS if auth_success else TestResult.FAIL,
-                duration=duration,
-                error_message="" if auth_success else "Authentication failed",
-                details={
-                    "auth_method": "session_based",
-                    "response_time": duration
-                }
-            )
-            
-        except Exception as e:
-            return TestReport(
-                test_name="ThoughtSpot Authentication",
-                result=TestResult.FAIL,
-                duration=time.time() - start_time,
-                error_message=f"Auth test failed: {str(e)}"
-            )
-    
-    def test_snowflake_connection(self) -> TestReport:
-        """Test Snowflake key pair authentication"""
-        start_time = time.time()
-        
-        try:
-            import snowflake.connector
-            from snowflake_auth import get_snowflake_connection_params
-            
-            params = get_snowflake_connection_params()
-            conn = snowflake.connector.connect(**params)
-            cursor = conn.cursor()
-            
-            # Test basic query
-            cursor.execute("SELECT CURRENT_VERSION()")
-            version = cursor.fetchone()[0]
-            
-            conn.close()
-            duration = time.time() - start_time
-            
-            return TestReport(
-                test_name="Snowflake Connection",
-                result=TestResult.PASS,
-                duration=duration,
-                details={
-                    "snowflake_version": version,
-                    "auth_method": "key_pair",
-                    "connection_time": duration
-                }
-            )
-            
-        except Exception as e:
-            return TestReport(
-                test_name="Snowflake Connection",
-                result=TestResult.FAIL,
-                duration=time.time() - start_time,
-                error_message=f"Snowflake connection failed: {str(e)}"
-            )
-    
-    def test_deployment_pipeline(self, ddl: str, database: str, schema: str) -> TestReport:
-        """Test complete deployment pipeline"""
-        start_time = time.time()
-        
-        try:
-            from thoughtspot_deployer import ThoughtSpotDeployer
-            
-            deployer = ThoughtSpotDeployer()
-            
-            # Authenticate first
-            if not deployer.authenticate():
-                return TestReport(
-                    test_name="Deployment Pipeline",
-                    result=TestResult.FAIL,
-                    duration=time.time() - start_time,
-                    error_message="Authentication failed"
-                )
-            
-            # Run deployment
-            results = deployer.deploy_all(
-                ddl=ddl,
-                database=database, 
-                schema=schema
-            )
-            
-            duration = time.time() - start_time
-            
-            # Analyze results
-            pipeline_success = {
-                "connection": bool(results.get('connection')),
-                "tables": len(results.get('tables', [])) > 0,
-                "worksheet": bool(results.get('worksheet')),
-                "errors": results.get('errors', [])
-            }
-            
-            overall_success = pipeline_success["connection"] and pipeline_success["tables"]
-            
-            return TestReport(
-                test_name="Deployment Pipeline",
-                result=TestResult.PASS if overall_success else TestResult.FAIL,
-                duration=duration,
-                error_message=f"Errors: {len(pipeline_success['errors'])}" if pipeline_success['errors'] else "",
-                details={
-                    **pipeline_success,
-                    "deployment_time": duration,
-                    "schema_used": schema,
-                    "tables_created": len(results.get('tables', []))
-                }
-            )
-            
-        except Exception as e:
-            return TestReport(
-                test_name="Deployment Pipeline",
-                result=TestResult.FAIL,
-                duration=time.time() - start_time,
-                error_message=f"Pipeline test failed: {str(e)}"
-            )
-    
-    def run_performance_test(self, test_func, *args, **kwargs) -> Tuple[Any, float, bool]:
-        """Run a test function with performance monitoring"""
-        start_time = time.time()
-        
-        try:
-            result = test_func(*args, **kwargs)
-            duration = time.time() - start_time
-            return result, duration, True
-        except Exception as e:
-            duration = time.time() - start_time
-            print(f"⚠️ Performance test failed: {e}")
-            return None, duration, False
-    
-    def run_all_tests(self, ddl: str = None, database: str = "DEMOBUILD", 
-                     schema: str = None) -> Dict[str, Any]:
-        """Run comprehensive test suite"""
-        
-        print("🧪 ENHANCED TEST FRAMEWORK")
-        print("=" * 60)
-        print(f"🚀 Starting comprehensive test suite at {datetime.now()}")
-        
-        self.start_time = time.time()
-        
-        # Auto-detect schema if not provided
-        if not schema:
-            # Look for recent schemas
-            schema_pattern = datetime.now().strftime("2025%m%d")
-            schema = f"{schema_pattern}_ENHANCED_TEST"
-            print(f"📊 Using auto-generated schema: {schema}")
-        
-        # Default DDL for testing
-        if not ddl:
-            ddl = """
-            CREATE TABLE CUSTOMERS (
-                CUSTOMERID NUMBER(38,0) NOT NULL,
-                FIRSTNAME VARCHAR(50) NOT NULL,
-                LASTNAME VARCHAR(50) NOT NULL,
-                EMAIL VARCHAR(100) NOT NULL
-            );
-            
-            CREATE TABLE PRODUCTS (
-                PRODUCTID NUMBER(38,0) NOT NULL,
-                PRODUCTNAME VARCHAR(100) NOT NULL,
-                PRICE NUMBER(10,2) NOT NULL
-            );
-            """
-        
-        # Run tests in order
-        tests_to_run = [
-            ("Environment", lambda: self.validate_environment()),
-            ("Schema Validation", lambda: self.validate_schema_structure(ddl)),
-            ("Snowflake Connection", lambda: self.test_snowflake_connection()),
-            ("ThoughtSpot Auth", lambda: self.test_thoughtspot_auth()),
-            ("Full Deployment", lambda: self.test_deployment_pipeline(ddl, database, schema))
-        ]
-        
-        print("\n📋 Running Test Suite:")
-        
-        for test_name, test_func in tests_to_run:
-            print(f"\n🔄 Running: {test_name}...")
-            
-            try:
-                report = test_func()
-                self.results.append(report)
-                
-                # Show immediate feedback
-                duration_str = f"{report.duration:.2f}s"
-                print(f"   {report.result.value} {test_name} ({duration_str})")
-                
-                if report.error_message:
-                    print(f"      💬 {report.error_message}")
-                    
-            except Exception as e:
-                error_report = TestReport(
-                    test_name=test_name,
-                    result=TestResult.FAIL,
-                    duration=0.0,
-                    error_message=f"Test execution failed: {str(e)}"
-                )
-                self.results.append(error_report)
-                print(f"   ❌ FAIL {test_name} (execution error)")
-        
-        # Generate comprehensive report
-        return self.generate_report()
-    
-    def generate_report(self) -> Dict[str, Any]:
-        """Generate comprehensive test report"""
-        
-        total_duration = time.time() - self.start_time if self.start_time else 0
-        
-        # Calculate statistics
-        stats = {
-            "total_tests": len(self.results),
-            "passed": len([r for r in self.results if r.result == TestResult.PASS]),
-            "failed": len([r for r in self.results if r.result == TestResult.FAIL]),
-            "warnings": len([r for r in self.results if r.result == TestResult.WARN]),
-            "skipped": len([r for r in self.results if r.result == TestResult.SKIP]),
-            "total_duration": total_duration,
-            "average_duration": total_duration / len(self.results) if self.results else 0
-        }
-        
-        success_rate = (stats["passed"] / stats["total_tests"] * 100) if stats["total_tests"] > 0 else 0
-        
-        # Print summary report
-        print("\n" + "=" * 60)
-        print("📊 TEST SUMMARY REPORT")
-        print("=" * 60)
-        
-        print(f"🎯 Overall Success Rate: {success_rate:.1f}%")
-        print(f"⏱️  Total Duration: {total_duration:.2f}s")
-        print(f"📈 Tests: {stats['passed']}✅ {stats['failed']}❌ {stats['warnings']}⚠️ {stats['skipped']}⏭️")
-        
-        print(f"\n📋 Individual Results:")
-        for result in self.results:
-            duration_str = f"({result.duration:.2f}s)"
-            print(f"   {result.result.value} {result.test_name} {duration_str}")
-            if result.error_message:
-                print(f"      💬 {result.error_message}")
-        
-        # Recommendations
-        print(f"\n🔧 RECOMMENDATIONS:")
-        if stats["failed"] > 0:
-            print(f"   • Fix {stats['failed']} failing tests before deployment")
-        if stats["warnings"] > 0:
-            print(f"   • Review {stats['warnings']} warnings for potential issues")
-        if success_rate == 100:
-            print(f"   🎉 All tests passing! System ready for deployment!")
-        
-        print("=" * 60)
-        
-        # Save detailed report
-        report_data = {
-            "timestamp": datetime.now().isoformat(),
-            "statistics": stats,
-            "success_rate": success_rate,
-            "results": [asdict(r) for r in self.results]
-        }
-        
-        # Save to file
-        report_file = f"test_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        with open(os.path.join("tests", report_file), "w") as f:
-            json.dump(report_data, f, indent=2)
-            
-        print(f"📄 Detailed report saved: tests/{report_file}")
-        
-        return report_data
-
-def main():
-    """Run enhanced test framework"""
-    framework = TestFramework()
-    
-    # Example usage - can be customized
-    results = framework.run_all_tests()
-    
-    return results["success_rate"] == 100.0
-
-if __name__ == "__main__":
-    main()

thoughtspot_deployer.py

@@ -1278,10 +1278,22 @@ class ThoughtSpotDeployer:
             # PHASE 1: Create all tables WITHOUT joins (to ensure all tables exist first)
             log_progress("   📋 Phase 1: Creating tables without joins...")
             for table_name, columns in tables.items():
+                import time
+                start_time = time.time()
                 log_progress(f"   🔄 Creating table: {table_name.upper()} (no joins)...")
+
                 # Create table TML WITHOUT joins_with section (pass None for all_tables)
+                tml_start = time.time()
                 table_tml = self.create_table_tml(table_name, columns, connection_name, database, schema, all_tables=None)
+                tml_time = time.time() - tml_start
+                log_progress(f"      📝 TML generation took: {tml_time:.2f} seconds")
+
+                # Log the size of the TML
+                log_progress(f"      📏 TML size: {len(table_tml)} characters, {len(columns)} columns")
 
+                # Make the API call
+                api_start = time.time()
+                log_progress(f"      🌐 Sending to ThoughtSpot API...")
                 response = self.session.post(
                     f"{self.base_url}/api/rest/2.0/metadata/tml/import",
                     json={
@@ -1290,6 +1302,8 @@ class ThoughtSpotDeployer:
                         "create_new": True
                     }
                 )
+                api_time = time.time() - api_start
+                log_progress(f"      ⏱️  API call took: {api_time:.2f} seconds")
 
                 if response.status_code == 200:
                     result = response.json()
@@ -1309,7 +1323,8 @@ class ThoughtSpotDeployer:
                         obj = objects[0]
                         if obj.get('response', {}).get('status', {}).get('status_code') == 'OK':
                             table_guid = obj.get('response', {}).get('header', {}).get('id_guid')
-                            log_progress(f"   ✅ Table created: {table_name.upper()}")
+                            total_time = time.time() - start_time
+                            log_progress(f"   ✅ Table created: {table_name.upper()} (Total time: {total_time:.2f} seconds)")
                             log_progress(f"      GUID: {table_guid}")
                             results['tables'].append(table_name.upper())
                             table_guids[table_name.upper()] = table_guid