#!/usr/bin/env python3
"""
Unit tests for Sigma API client
"""

import unittest
from unittest.mock import Mock, patch, MagicMock
from datetime import datetime, timedelta
import sys
import os

# Add parent directory to path to import modules
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

from sigma_api_client import SigmaAPIClient, SigmaConfig

class TestSigmaAPIClient(unittest.TestCase):
    """Test cases for SigmaAPIClient"""
    
    def setUp(self):
        """Set up test fixtures"""
        self.config = SigmaConfig(
            client_id="test_client_id",
            client_secret="test_client_secret",
            base_url="https://api.test.sigmacomputing.com"
        )
        self.client = SigmaAPIClient(self.config)
    
    def test_init(self):
        """Test client initialization"""
        self.assertEqual(self.client.config.client_id, "test_client_id")
        self.assertEqual(self.client.config.client_secret, "test_client_secret")
        self.assertEqual(self.client.config.base_url, "https://api.test.sigmacomputing.com")
        self.assertIsNone(self.client.access_token)
        self.assertIsNone(self.client.token_expires_at)
    
    def test_get_token_url(self):
        """Test token URL generation"""
        expected_url = "https://api.test.sigmacomputing.com/v2/auth/token"
        self.assertEqual(self.client._get_token_url(), expected_url)
    
    def test_is_token_expired_no_token(self):
        """Test token expiry check with no token"""
        self.assertTrue(self.client._is_token_expired())
    
    def test_is_token_expired_valid_token(self):
        """Test token expiry check with valid token"""
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() + timedelta(minutes=10)
        self.assertFalse(self.client._is_token_expired())
    
    def test_is_token_expired_expired_token(self):
        """Test token expiry check with expired token"""
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() - timedelta(minutes=1)
        self.assertTrue(self.client._is_token_expired())
    
    def test_is_token_expired_soon_to_expire(self):
        """Test token expiry check with soon-to-expire token"""
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() + timedelta(minutes=2)  # Less than 5 minutes
        self.assertTrue(self.client._is_token_expired())
    
    @patch('requests.Session.post')
    def test_authenticate_success(self, mock_post):
        """Test successful authentication"""
        # Mock successful response
        mock_response = Mock()
        mock_response.json.return_value = {
            'access_token': 'test_access_token',
            'expires_in': 3600
        }
        mock_response.raise_for_status.return_value = None
        mock_post.return_value = mock_response
        
        # Test authentication
        result = self.client.authenticate()
        
        # Assertions
        self.assertTrue(result)
        self.assertEqual(self.client.access_token, 'test_access_token')
        self.assertIsNotNone(self.client.token_expires_at)
        
        # Verify request was made correctly
        mock_post.assert_called_once()
        call_args = mock_post.call_args
        self.assertEqual(call_args[0][0], self.client._get_token_url())
        self.assertEqual(call_args[1]['data']['client_id'], 'test_client_id')
        self.assertEqual(call_args[1]['data']['client_secret'], 'test_client_secret')
    
    @patch('requests.Session.post')
    def test_authenticate_failure(self, mock_post):
        """Test authentication failure"""
        # Mock failed response
        mock_post.side_effect = Exception("Authentication failed")
        
        # Test authentication
        result = self.client.authenticate()
        
        # Assertions
        self.assertFalse(result)
        self.assertIsNone(self.client.access_token)
        self.assertIsNone(self.client.token_expires_at)
    
    @patch('requests.Session.request')
    def test_make_request_success(self, mock_request):
        """Test successful API request"""
        # Setup authenticated client
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() + timedelta(hours=1)
        
        # Mock successful response
        mock_response = Mock()
        mock_response.raise_for_status.return_value = None
        mock_request.return_value = mock_response
        
        # Test request
        response = self.client._make_request('GET', '/test')
        
        # Assertions
        self.assertEqual(response, mock_response)
        mock_request.assert_called_once_with('GET', 'https://api.test.sigmacomputing.com/test')
    
    @patch('requests.Session.request')
    def test_get_request(self, mock_request):
        """Test GET request method"""
        # Setup authenticated client
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() + timedelta(hours=1)
        
        # Mock response
        mock_response = Mock()
        mock_response.raise_for_status.return_value = None
        mock_response.json.return_value = {'data': 'test'}
        mock_request.return_value = mock_response
        
        # Test GET request
        result = self.client.get('/test')
        
        # Assertions
        self.assertEqual(result, {'data': 'test'})
        mock_request.assert_called_once()
    
    @patch('requests.Session.request')
    def test_post_request(self, mock_request):
        """Test POST request method"""
        # Setup authenticated client
        self.client.access_token = "test_token"
        self.client.token_expires_at = datetime.now() + timedelta(hours=1)
        
        # Mock response
        mock_response = Mock()
        mock_response.raise_for_status.return_value = None
        mock_response.json.return_value = {'success': True}
        mock_request.return_value = mock_response
        
        # Test POST request
        test_data = {'key': 'value'}
        result = self.client.post('/test', test_data)
        
        # Assertions
        self.assertEqual(result, {'success': True})
        mock_request.assert_called_once()
        call_args = mock_request.call_args
        self.assertEqual(call_args[1]['json'], test_data)

class TestSigmaConfig(unittest.TestCase):
    """Test cases for SigmaConfig"""
    
    def test_config_creation(self):
        """Test configuration object creation"""
        config = SigmaConfig(
            client_id="test_id",
            client_secret="test_secret",
            base_url="https://test.com"
        )
        
        self.assertEqual(config.client_id, "test_id")
        self.assertEqual(config.client_secret, "test_secret")
        self.assertEqual(config.base_url, "https://test.com")

if __name__ == '__main__':
    unittest.main()