test_code_sample_syntax.py

#!/usr/bin/env python3
"""
test_code_sample_syntax.py - Test for Code Sample Syntax Bug

This test validates that the code samples generated by add_code_samples.py
are syntactically valid and can be executed without errors.

Bug Description:
    File: add_code_samples.py
    Affected logic: Code generation for cURL and JavaScript samples
    Issue 1: cURL samples are missing line continuation backslash after
             Authorization header for POST/PUT/PATCH operations
    Issue 2: JavaScript samples are missing comma after Authorization
             header in the headers object
    Impact: Generated code samples for POST/PUT/PATCH operations have syntax errors:
             - cURL samples cannot be executed due to missing line continuation
             - JavaScript samples cannot be parsed due to invalid object literal syntax

Fix Strategy:
    1. Ensure a trailing backslash is added to the Authorization header line in cURL samples for POST/PUT/PATCH.
    2. Ensure a trailing comma is added to the Authorization header line in JavaScript samples for POST/PUT/PATCH.

Test Approach:
    This test generates code samples for POST/PUT/PATCH operations and
    validates that:
    - cURL samples have proper line continuation (all lines end with \\ except last)
    - JavaScript samples have valid object literal syntax (commas between properties)
    - Generated code can be parsed/validated successfully

Author: Venice.ai API Reference Team
"""

import unittest
import yaml
import os
import tempfile
from add_code_samples import add_code_samples


class TestCodeSampleSyntax(unittest.TestCase):
    """Test suite for validating syntax of generated code samples."""
    
    def setUp(self):
        """Set up temporary test files."""
        self.test_dir = tempfile.mkdtemp()
        self.test_spec_path = os.path.join(self.test_dir, "test_spec.yaml")
        
    def tearDown(self):
        """Clean up temporary test files."""
        if os.path.exists(self.test_spec_path):
            os.remove(self.test_spec_path)
        if os.path.exists(self.test_dir):
            os.rmdir(self.test_dir)
    
    def create_test_spec(self, method='post'):
        """
        Create a minimal OpenAPI spec for testing.
        
        Args:
            method (str): HTTP method to test (post, put, patch, get, delete)
        """
        spec = {
            'openapi': '3.0.0',
            'info': {'title': 'Test API', 'version': '1.0.0'},
            'paths': {
                '/test-endpoint': {
                    method: {
                        'summary': f'Test {method.upper()} endpoint',
                        'responses': {
                            '200': {'description': 'Success'}
                        }
                    }
                }
            }
        }
        
        with open(self.test_spec_path, 'w') as f:
            yaml.dump(spec, f)
    
    def load_generated_samples(self, method='post'):
        """
        Load the generated code samples from the test spec.
        
        Args:
            method (str): HTTP method to retrieve samples for
            
        Returns:
            tuple: (curl_sample, python_sample, js_sample)
        """
        with open(self.test_spec_path, 'r') as f:
            spec = yaml.safe_load(f)
        
        samples = spec['paths']['/test-endpoint'][method]['x-codeSamples']
        
        curl_sample = None
        python_sample = None
        js_sample = None
        
        for sample in samples:
            if sample['lang'] == 'cURL':
                curl_sample = sample['source']
            elif sample['lang'] == 'Python':
                python_sample = sample['source']
            elif sample['lang'] == 'JavaScript':
                js_sample = sample['source']
        
        return curl_sample, python_sample, js_sample
    
    def test_post_curl_line_continuation(self):
        """
        Test that cURL samples for POST have proper line continuation.
        
        This test specifically validates Bug #1: cURL samples should have
        a backslash at the end of every line except the last one.
        """
        self.create_test_spec('post')
        add_code_samples(self.test_spec_path)
        
        curl_sample, _, _ = self.load_generated_samples('post')
        
        lines = curl_sample.split('\n')
        
        # All lines except the last should end with a backslash
        for i, line in enumerate(lines[:-1]):
            self.assertTrue(
                line.rstrip().endswith('\\'),
                f"Line {i+1} should end with backslash for continuation:\n{line}"
            )
        
        # Last line should NOT end with a backslash
        self.assertFalse(
            lines[-1].rstrip().endswith('\\'),
            f"Last line should not end with backslash:\n{lines[-1]}"
        )
    
    def test_put_curl_line_continuation(self):
        """Test that cURL samples for PUT have proper line continuation."""
        self.create_test_spec('put')
        add_code_samples(self.test_spec_path)
        
        curl_sample, _, _ = self.load_generated_samples('put')
        lines = curl_sample.split('\n')
        
        for i, line in enumerate(lines[:-1]):
            self.assertTrue(
                line.rstrip().endswith('\\'),
                f"PUT: Line {i+1} should end with backslash:\n{line}"
            )
    
    def test_patch_curl_line_continuation(self):
        """Test that cURL samples for PATCH have proper line continuation."""
        self.create_test_spec('patch')
        add_code_samples(self.test_spec_path)
        
        curl_sample, _, _ = self.load_generated_samples('patch')
        lines = curl_sample.split('\n')
        
        for i, line in enumerate(lines[:-1]):
            self.assertTrue(
                line.rstrip().endswith('\\'),
                f"PATCH: Line {i+1} should end with backslash:\n{line}"
            )
    
    def test_get_curl_line_continuation(self):
        """
        Test that cURL samples for GET have proper line continuation.
        
        GET requests don't have request bodies, so they should have fewer lines,
        but still maintain proper continuation.
        """
        self.create_test_spec('get')
        add_code_samples(self.test_spec_path)
        
        curl_sample, _, _ = self.load_generated_samples('get')
        lines = curl_sample.split('\n')
        
        # GET should only have 2 lines (curl command + auth header)
        self.assertEqual(len(lines), 2, "GET request should have 2 lines")
        
        # First line should end with backslash
        self.assertTrue(
            lines[0].rstrip().endswith('\\'),
            f"First line should end with backslash:\n{lines[0]}"
        )
        
        # Second line should NOT end with backslash
        self.assertFalse(
            lines[1].rstrip().endswith('\\'),
            f"Last line should not end with backslash:\n{lines[1]}"
        )
    
    def test_post_javascript_object_syntax(self):
        """
        Test that JavaScript samples for POST have valid object syntax.
        
        This test specifically validates Bug #2: JavaScript object literals
        should have commas between all properties.
        """
        self.create_test_spec('post')
        add_code_samples(self.test_spec_path)
        
        _, _, js_sample = self.load_generated_samples('post')
        
        # Check that the headers object has proper comma after Authorization
        lines = js_sample.split('\n')
        
        # Find the line with Authorization header
        auth_line_idx = None
        for i, line in enumerate(lines):
            if "'Authorization':" in line or '"Authorization":' in line:
                auth_line_idx = i
                break
        
        self.assertIsNotNone(auth_line_idx, "Authorization header not found")
        
        # The Authorization line should end with a comma (after the value)
        auth_line = lines[auth_line_idx].rstrip()
        
        # It should end with a comma (not just whitespace)
        self.assertTrue(
            auth_line.endswith(','),
            f"Authorization header line should end with comma:\n{auth_line}"
        )
    
    def test_put_javascript_object_syntax(self):
        """Test that JavaScript samples for PUT have valid object syntax."""
        self.create_test_spec('put')
        add_code_samples(self.test_spec_path)
        
        _, _, js_sample = self.load_generated_samples('put')
        
        lines = js_sample.split('\n')
        auth_line_idx = None
        for i, line in enumerate(lines):
            if "'Authorization':" in line or '"Authorization":' in line:
                auth_line_idx = i
                break
        
        self.assertIsNotNone(auth_line_idx, "Authorization header not found")
        auth_line = lines[auth_line_idx].rstrip()
        
        self.assertTrue(
            auth_line.endswith(','),
            f"PUT: Authorization header line should end with comma:\n{auth_line}"
        )
    
    def test_patch_javascript_object_syntax(self):
        """Test that JavaScript samples for PATCH have valid object syntax."""
        self.create_test_spec('patch')
        add_code_samples(self.test_spec_path)
        
        _, _, js_sample = self.load_generated_samples('patch')
        
        lines = js_sample.split('\n')
        auth_line_idx = None
        for i, line in enumerate(lines):
            if "'Authorization':" in line or '"Authorization":' in line:
                auth_line_idx = i
                break
        
        self.assertIsNotNone(auth_line_idx, "Authorization header not found")
        auth_line = lines[auth_line_idx].rstrip()
        
        self.assertTrue(
            auth_line.endswith(','),
            f"PATCH: Authorization header line should end with comma:\n{auth_line}"
        )
    
    def test_get_javascript_no_extra_comma(self):
        """
        Test that JavaScript samples for GET don't have extra commas.
        
        GET requests don't have Content-Type or body, so the Authorization
        header should NOT have a trailing comma.
        """
        self.create_test_spec('get')
        add_code_samples(self.test_spec_path)
        
        _, _, js_sample = self.load_generated_samples('get')
        
        lines = js_sample.split('\n')
        auth_line_idx = None
        for i, line in enumerate(lines):
            if "'Authorization':" in line or '"Authorization":' in line:
                auth_line_idx = i
                break
        
        self.assertIsNotNone(auth_line_idx, "Authorization header not found")
        auth_line = lines[auth_line_idx].rstrip()
        
        # For GET, Authorization is the only header, so no trailing comma
        self.assertFalse(
            auth_line.endswith(','),
            f"GET: Authorization header should NOT end with comma:\n{auth_line}"
        )
    
    def test_all_samples_have_required_languages(self):
        """Test that all three language samples are generated."""
        self.create_test_spec('post')
        add_code_samples(self.test_spec_path)
        
        curl_sample, python_sample, js_sample = self.load_generated_samples('post')
        
        self.assertIsNotNone(curl_sample, "cURL sample should be generated")
        self.assertIsNotNone(python_sample, "Python sample should be generated")
        self.assertIsNotNone(js_sample, "JavaScript sample should be generated")
        
        self.assertTrue(len(curl_sample) > 0, "cURL sample should not be empty")
        self.assertTrue(len(python_sample) > 0, "Python sample should not be empty")
        self.assertTrue(len(js_sample) > 0, "JavaScript sample should not be empty")
    
    def test_samples_contain_api_key_placeholder(self):
        """Test that all samples use the correct API key placeholder."""
        self.create_test_spec('post')
        add_code_samples(self.test_spec_path)
        
        curl_sample, python_sample, js_sample = self.load_generated_samples('post')
        
        placeholder = 'YOUR_API_KEY'
        
        self.assertIn(placeholder, curl_sample, "cURL sample should contain API key placeholder")
        self.assertIn(placeholder, python_sample, "Python sample should contain API key placeholder")
        self.assertIn(placeholder, js_sample, "JavaScript sample should contain API key placeholder")


def main():
    """
    Main entry point for running the test suite.
    
    Runs all syntax validation tests and reports results.
    """
    # Run tests
    unittest.main(verbosity=2)


if __name__ == "__main__":
    main()