MarketAlly.AIPlugin.Extensions/MarketAlly.AIPlugin.Learning.Tests/Exceptions/ExceptionTests.cs

using MarketAlly.AIPlugin.Learning.Exceptions;

namespace MarketAlly.AIPlugin.Learning.Tests.Exceptions
{
    [TestClass]
    public class ExceptionTests
    {
        [TestMethod]
        public void CompilationException_WithErrorDetails_CorrectlyInitialized()
        {
            // Arrange
            var errorCount = 5;
            var warningCount = 3;
            var errors = new string[] { "Error 1", "Error 2", "Error 3", "Error 4", "Error 5" };

            // Act
            var exception = new CompilationException(errorCount, warningCount, errors);

            // Assert
            Assert.AreEqual(errorCount, exception.ErrorCount);
            Assert.AreEqual(warningCount, exception.WarningCount);
            Assert.AreEqual(errors.Length, exception.Errors.Length);
            Assert.IsTrue(exception.Message.Contains("5 errors"));
            Assert.IsTrue(exception.Message.Contains("3 warnings"));
        }

        [TestMethod]
        public void CompilationException_EmptyErrorList_HandledCorrectly()
        {
            // Arrange
            var errorCount = 0;
            var warningCount = 2;
            var errors = new string[0];

            // Act
            var exception = new CompilationException(errorCount, warningCount, errors);

            // Assert
            Assert.AreEqual(0, exception.ErrorCount);
            Assert.AreEqual(2, exception.WarningCount);
            Assert.AreEqual(0, exception.Errors.Length);
            Assert.IsTrue(exception.Message.Contains("0 errors"));
        }

        [TestMethod]
        public void CompilationException_AlternativeConstructor_CorrectlyInitialized()
        {
            // Arrange
            var message = "Custom compilation error";
            var errorCount = 3;
            var warningCount = 1;
            var innerException = new InvalidOperationException("Inner exception");

            // Act
            var exception = new CompilationException(message, errorCount, warningCount, innerException);

            // Assert
            Assert.AreEqual(errorCount, exception.ErrorCount);
            Assert.AreEqual(warningCount, exception.WarningCount);
            Assert.AreEqual(message, exception.Message);
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void RefactorIQException_WithOperation_CorrectlyInitialized()
        {
            // Arrange
            var operation = "IndexSolution";
            var message = "Failed to index solution";

            // Act
            var exception = new RefactorIQException(operation, message);

            // Assert
            Assert.AreEqual(operation, exception.Operation);
            Assert.IsTrue(exception.Message.Contains(operation));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void RefactorIQException_WithInnerException_CorrectlyInitialized()
        {
            // Arrange
            var operation = "SearchSymbols";
            var message = "Search operation failed";
            var innerException = new FileNotFoundException("Config file not found");

            // Act
            var exception = new RefactorIQException(operation, message, innerException);

            // Assert
            Assert.AreEqual(operation, exception.Operation);
            Assert.IsTrue(exception.Message.Contains(operation));
            Assert.IsTrue(exception.Message.Contains(message));
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void SecurityException_CorrectlyInitialized()
        {
            // Arrange
            var operation = "PathValidation";
            var resource = @"C:\Windows\System32\..\..\malicious.exe";
            var message = "Path traversal detected";

            // Act
            var exception = new SecurityException(operation, resource, message);

            // Assert
            Assert.AreEqual(operation, exception.Operation);
            Assert.AreEqual(resource, exception.Resource);
            Assert.IsTrue(exception.Message.Contains(operation));
            Assert.IsTrue(exception.Message.Contains(resource));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void ConfigurationException_CorrectlyInitialized()
        {
            // Arrange
            var configurationKey = "Learning:Git:CommitterEmail";
            var message = "Invalid email format";

            // Act
            var exception = new ConfigurationException(configurationKey, message);

            // Assert
            Assert.AreEqual(configurationKey, exception.ConfigurationKey);
            Assert.IsTrue(exception.Message.Contains(configurationKey));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void ConfigurationException_WithInnerException_CorrectlyInitialized()
        {
            // Arrange
            var configurationKey = "Learning:Security:MaxFileSize";
            var message = "Invalid file size configuration";
            var innerException = new FormatException("Invalid number format");

            // Act
            var exception = new ConfigurationException(configurationKey, message, innerException);

            // Assert
            Assert.AreEqual(configurationKey, exception.ConfigurationKey);
            Assert.IsTrue(exception.Message.Contains(configurationKey));
            Assert.IsTrue(exception.Message.Contains(message));
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void GitOperationException_CorrectlyInitialized()
        {
            // Arrange
            var operation = "CreateBranch";
            var repositoryPath = @"C:\MyProject\.git";
            var message = "Failed to create branch";

            // Act
            var exception = new GitOperationException(operation, repositoryPath, message);

            // Assert
            Assert.AreEqual(operation, exception.Operation);
            Assert.AreEqual(repositoryPath, exception.RepositoryPath);
            Assert.IsTrue(exception.Message.Contains(operation));
            Assert.IsTrue(exception.Message.Contains(repositoryPath));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void GitOperationException_WithInnerException_CorrectlyInitialized()
        {
            // Arrange
            var operation = "CommitChanges";
            var repositoryPath = @"C:\MyProject";
            var message = "Failed to commit changes";
            var innerException = new UnauthorizedAccessException("Access denied");

            // Act
            var exception = new GitOperationException(operation, repositoryPath, message, innerException);

            // Assert
            Assert.AreEqual(operation, exception.Operation);
            Assert.AreEqual(repositoryPath, exception.RepositoryPath);
            Assert.IsTrue(exception.Message.Contains(operation));
            Assert.IsTrue(exception.Message.Contains(repositoryPath));
            Assert.IsTrue(exception.Message.Contains(message));
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void AIServiceException_WithRetryableFlag_CorrectlyInitialized()
        {
            // Arrange
            var serviceName = "OpenAIEmbeddings";
            var message = "Rate limit exceeded";
            var isRetryable = true;

            // Act
            var exception = new AIServiceException(serviceName, message, isRetryable);

            // Assert
            Assert.AreEqual(serviceName, exception.ServiceName);
            Assert.IsTrue(exception.IsRetryable);
            Assert.IsTrue(exception.Message.Contains(serviceName));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void AIServiceException_WithInnerException_CorrectlyInitialized()
        {
            // Arrange
            var serviceName = "VectorSearch";
            var message = "Search operation failed";
            var innerException = new HttpRequestException("429 Too Many Requests");
            var isRetryable = false;

            // Act
            var exception = new AIServiceException(serviceName, message, innerException, isRetryable);

            // Assert
            Assert.AreEqual(serviceName, exception.ServiceName);
            Assert.IsFalse(exception.IsRetryable);
            Assert.IsTrue(exception.Message.Contains(serviceName));
            Assert.IsTrue(exception.Message.Contains(message));
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void LearningIterationException_CorrectlyInitialized()
        {
            // Arrange
            var iterationNumber = 5;
            var phase = "Analysis";
            var message = "Iteration processing failed";

            // Act
            var exception = new LearningIterationException(iterationNumber, phase, message);

            // Assert
            Assert.AreEqual(iterationNumber, exception.IterationNumber);
            Assert.AreEqual(phase, exception.Phase);
            Assert.IsTrue(exception.Message.Contains(iterationNumber.ToString()));
            Assert.IsTrue(exception.Message.Contains(phase));
            Assert.IsTrue(exception.Message.Contains(message));
        }

        [TestMethod]
        public void LearningIterationException_WithInnerException_CorrectlyInitialized()
        {
            // Arrange
            var iterationNumber = 3;
            var phase = "Refactoring";
            var message = "Refactoring phase failed";
            var innerException = new IOException("File access denied");

            // Act
            var exception = new LearningIterationException(iterationNumber, phase, message, innerException);

            // Assert
            Assert.AreEqual(iterationNumber, exception.IterationNumber);
            Assert.AreEqual(phase, exception.Phase);
            Assert.IsTrue(exception.Message.Contains(iterationNumber.ToString()));
            Assert.IsTrue(exception.Message.Contains(phase));
            Assert.IsTrue(exception.Message.Contains(message));
            Assert.AreEqual(innerException, exception.InnerException);
        }

        [TestMethod]
        public void AllExceptions_InheritFromLearningException()
        {
            // Arrange & Act
            var compilationEx = new CompilationException(1, 0, new[] { "error" });
            var refactorIqEx = new RefactorIQException("op", "message");
            var securityEx = new SecurityException("op", "resource", "message");
            var configEx = new ConfigurationException("key", "message");
            var gitEx = new GitOperationException("op", "path", "message");
            var aiEx = new AIServiceException("service", "message");
            var iterationEx = new LearningIterationException(1, "phase", "message");

            // Assert
            Assert.IsInstanceOfType(compilationEx, typeof(LearningException));
            Assert.IsInstanceOfType(refactorIqEx, typeof(LearningException));
            Assert.IsInstanceOfType(securityEx, typeof(LearningException));
            Assert.IsInstanceOfType(configEx, typeof(LearningException));
            Assert.IsInstanceOfType(gitEx, typeof(LearningException));
            Assert.IsInstanceOfType(aiEx, typeof(LearningException));
            Assert.IsInstanceOfType(iterationEx, typeof(LearningException));
        }

        [TestMethod]
        public void CompilationException_NullErrorArray_HandledCorrectly()
        {
            // Arrange
            var errorCount = 2;
            var warningCount = 1;
            string[]? errors = null;

            // Act
            var exception = new CompilationException(errorCount, warningCount, errors);

            // Assert
            Assert.AreEqual(errorCount, exception.ErrorCount);
            Assert.AreEqual(warningCount, exception.WarningCount);
            Assert.IsNotNull(exception.Errors);
            Assert.AreEqual(0, exception.Errors.Length);
        }

        [TestMethod]
        public void AIServiceException_DefaultRetryable_IsTrue()
        {
            // Arrange
            var serviceName = "TestService";
            var message = "Test message";

            // Act
            var exception = new AIServiceException(serviceName, message);

            // Assert
            Assert.IsTrue(exception.IsRetryable);
        }
    }
}