📊 DEVASC Topics 1.1-1.3

# JSON Parsing in Python
import json

# Parse JSON string to Python dictionary
json_string = '{"name": "Alice", "age": 25, "skills": ["Python", "APIs"]}'
data = json.loads(json_string)
print(data['name'])  # Output: Alice
print(data['skills'][0])  # Output: Python

# Parse JSON file
with open('data.json', 'r') as file:
    data = json.load(file)

# Convert Python to JSON
python_dict = {"status": "success", "code": 200}
json_output = json.dumps(python_dict, indent=2)
print(json_output)

# XML Parsing in Python
import xml.etree.ElementTree as ET

# Parse XML string
xml_string = '''
<?xml version="1.0"?>
<devices>
    <device>
        <name>Router1</name>
        <ip>192.168.1.1</ip>
    </device>
</devices>
'''

root = ET.fromstring(xml_string)

# Access elements
for device in root.findall('device'):
    name = device.find('name').text
    ip = device.find('ip').text
    print(f"{name}: {ip}")

# Parse XML file
tree = ET.parse('devices.xml')
root = tree.getroot()

# Access with XPath-like syntax
devices = root.findall('.//device')
for device in devices:
    print(device.attrib)  # Get attributes

# YAML Parsing in Python
import yaml

# Parse YAML string
yaml_string = '''
server:
  host: localhost
  port: 8080
  databases:
    - name: users_db
      type: postgresql
    - name: cache_db
      type: redis
'''

data = yaml.safe_load(yaml_string)
print(data['server']['host'])  # Output: localhost
print(data['server']['databases'][0]['name'])  # Output: users_db

# Parse YAML file
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

# Convert Python to YAML
python_dict = {
    'version': '1.0',
    'services': ['web', 'api', 'database']
}
yaml_output = yaml.dump(python_dict, default_flow_style=False)
print(yaml_output)

# Step 1: Write the test first (RED phase)
import unittest

class TestCalculator(unittest.TestCase):
    def test_add_two_numbers(self):
        calc = Calculator()
        result = calc.add(2, 3)
        self.assertEqual(result, 5)
    
    def test_add_negative_numbers(self):
        calc = Calculator()
        result = calc.add(-1, -1)
        self.assertEqual(result, -2)

# Running this test will FAIL because Calculator doesn't exist yet

# Step 2: Write minimal code to pass (GREEN phase)
class Calculator:
    def add(self, a, b):
        return a + b

# Now the tests PASS!

# Step 3: Refactor (REFACTOR phase)
class Calculator:
    """A simple calculator with basic operations."""
    
    def add(self, a: float, b: float) -> float:
        """Add two numbers and return the result."""
        if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
            raise TypeError("Both arguments must be numbers")
        return a + b

# Tests still PASS after refactoring!

# test_api_client.py - Write tests first!
import unittest
from unittest.mock import patch, Mock

class TestAPIClient(unittest.TestCase):
    def setUp(self):
        self.client = APIClient("https://api.example.com")
    
    @patch('requests.get')
    def test_get_user_returns_user_data(self, mock_get):
        # Arrange
        mock_response = Mock()
        mock_response.json.return_value = {"id": 1, "name": "Alice"}
        mock_response.status_code = 200
        mock_get.return_value = mock_response
        
        # Act
        result = self.client.get_user(1)
        
        # Assert
        self.assertEqual(result['name'], "Alice")
        mock_get.assert_called_once_with("https://api.example.com/users/1")
    
    @patch('requests.get')
    def test_get_user_handles_404(self, mock_get):
        # Arrange
        mock_response = Mock()
        mock_response.status_code = 404
        mock_get.return_value = mock_response
        
        # Act & Assert
        with self.assertRaises(UserNotFoundException):
            self.client.get_user(999)

# api_client.py - Now implement the code
import requests

class UserNotFoundException(Exception):
    pass

class APIClient:
    def __init__(self, base_url):
        self.base_url = base_url
    
    def get_user(self, user_id):
        response = requests.get(f"{self.base_url}/users/{user_id}")
        
        if response.status_code == 404:
            raise UserNotFoundException(f"User {user_id} not found")
        
        response.raise_for_status()
        return response.json()

# Run tests: python -m unittest test_api_client.py