MarketAlly.AIPlugin.Extensions/MarketAlly.AIPlugin.Tests/BasicTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MarketAlly.AIPlugin.Security;
using MarketAlly.AIPlugin.Validation;
using System;
using System.Collections.Generic;
using System.IO;

namespace MarketAlly.AIPlugin.Tests
{
	[TestClass]
	public class BasicTests
	{
		private string _testDirectory;

		[TestInitialize]
		public void Setup()
		{
			_testDirectory = Path.Combine(Path.GetTempPath(), "AIPlugin_BasicTests", Guid.NewGuid().ToString());
			Directory.CreateDirectory(_testDirectory);
		}

		[TestCleanup]
		public void Cleanup()
		{
			if (Directory.Exists(_testDirectory))
			{
				Directory.Delete(_testDirectory, true);
			}
		}

		[TestMethod]
		public void SecurityConfiguration_CreateDefault_ReturnsValidConfiguration()
		{
			// Act
			var config = SecurityConfiguration.CreateDefault();

			// Assert
			Assert.IsNotNull(config);
			Assert.IsNotNull(config.AllowedDirectories);
			Assert.IsNotNull(config.AllowedFileExtensions);
			Assert.IsTrue(config.MaxFileSizeBytes > 0);
		}

		[TestMethod]
		public void SecurityConfiguration_CreateRestrictive_ReturnsRestrictiveConfiguration()
		{
			// Act
			var config = SecurityConfiguration.CreateRestrictive();

			// Assert
			Assert.IsNotNull(config);
			Assert.IsFalse(config.AllowSystemInfoDisclosure);
			Assert.IsTrue(config.StrictSslValidation);
			Assert.AreEqual(1024 * 1024, config.MaxFileSizeBytes); // 1MB
		}

		[TestMethod]
		public void SecurityValidator_SanitizeInput_RemovesControlCharacters()
		{
			// Arrange
			var inputWithControlChars = "Test\x00\x01string\x1F";

			// Act
			var result = SecurityValidator.SanitizeInput(inputWithControlChars);

			// Assert
			Assert.AreEqual("Teststring", result);
		}

		[TestMethod]
		public void SecurityValidator_SanitizeInput_NormalString_ReturnsUnchanged()
		{
			// Arrange
			var normalString = "This is a normal string";

			// Act
			var result = SecurityValidator.SanitizeInput(normalString);

			// Assert
			Assert.AreEqual(normalString, result);
		}

		[TestMethod]
		public void SecurityValidator_ValidateContentSize_ValidSize_DoesNotThrow()
		{
			// Arrange
			var config = new SecurityConfiguration { MaxFileSizeBytes = 1024 };
			var content = "This is a test content";

			// Act & Assert - Should not throw
			SecurityValidator.ValidateContentSize(content, config);
		}

		[TestMethod]
		[ExpectedException(typeof(UnauthorizedAccessException))]
		public void SecurityValidator_ValidateContentSize_TooLarge_ThrowsException()
		{
			// Arrange
			var config = new SecurityConfiguration { MaxFileSizeBytes = 10 };
			var largeContent = new string('A', 20);

			// Act
			SecurityValidator.ValidateContentSize(largeContent, config);

			// Assert - Exception expected
		}

		[TestMethod]
		public void ValidationResult_NoErrors_IsValid()
		{
			// Arrange
			var result = new ValidationResult();

			// Act & Assert
			Assert.IsTrue(result.IsValid);
			Assert.AreEqual(0, result.Errors.Count);
		}

		[TestMethod]
		public void ValidationResult_WithErrors_IsNotValid()
		{
			// Arrange
			var result = new ValidationResult();

			// Act
			result.AddError("testParam", "Test error message", "TEST_ERROR");

			// Assert
			Assert.IsFalse(result.IsValid);
			Assert.AreEqual(1, result.Errors.Count);
			Assert.AreEqual("TEST_ERROR", result.Errors[0].ErrorCode);
		}

		[TestMethod]
		public void ValidationResult_WithWarnings_StillValid()
		{
			// Arrange
			var result = new ValidationResult();

			// Act
			result.AddWarning("testParam", "Test warning message", "TEST_WARNING");

			// Assert
			Assert.IsTrue(result.IsValid);
			Assert.AreEqual(0, result.Errors.Count);
			Assert.AreEqual(1, result.Warnings.Count);
		}
	}
}