Add unit tests #1

Author: ziagham

tests/FlowSynx.Plugins.Amazon.S3.UnitTests/Extensions/ConverterExtensionsTests.cs

@@ -0,0 +1,149 @@
+using Amazon.S3.Model;
+using Amazon.S3;
+using Moq;
+using System.Text;
+using Amazon;
+using FlowSynx.Plugins.Amazon.S3.Extensions;
+
+namespace FlowSynx.Plugins.Amazon.S3.UnitTests.Extensions;
+
+public class ConverterExtensionsTests
+{
+    [Fact]
+    public async Task ToContext_TextFile_ReturnsContent()
+    {
+        // Arrange
+        var bucketName = "test-bucket";
+        var key = "text-file.txt";
+        var textContent = "Hello, this is a test!";
+        var contentBytes = Encoding.UTF8.GetBytes(textContent);
+
+        var mockClient = new Mock<AmazonS3Client>("accessKey", "secretKey", RegionEndpoint.USEast1);
+        var mockResponseStream = new MemoryStream(contentBytes);
+
+        var mockGetObjectResponse = new GetObjectResponse
+        {
+            BucketName = bucketName,
+            Key = key,
+            ResponseStream = mockResponseStream,
+            ContentLength = contentBytes.Length,
+            LastModified = DateTime.UtcNow,
+            ETag = "\"etagvalue\"",
+            StorageClass = S3StorageClass.Standard
+        };
+
+        mockClient.Setup(c => c.GetObjectAsync(
+                It.Is<GetObjectRequest>(r => r.BucketName == bucketName && r.Key == key),
+                It.IsAny<CancellationToken>()
+            ))
+            .ReturnsAsync(mockGetObjectResponse);
+
+        mockClient.Setup(c => c.GetObjectMetadataAsync(
+                bucketName,
+                key,
+                It.IsAny<CancellationToken>()
+            ))
+            .ReturnsAsync(new GetObjectMetadataResponse
+            {
+                Headers = { ContentType = "text/plain" },
+            });
+
+        // Act
+        var result = await mockClient.Object.ToContext(bucketName, key, includeMetadata: true, CancellationToken.None);
+
+        // Assert
+        Assert.Equal(key, result.Id);
+        Assert.Equal("File", result.SourceType);
+        Assert.Null(result.RawData);
+        Assert.Equal(textContent, result.Content);
+        Assert.Equal("text/plain", result.Format);
+    }
+
+    [Fact]
+    public async Task ToContext_BinaryFile_ReturnsRawData()
+    {
+        // Arrange
+        var bucketName = "test-bucket";
+        var key = "binary.dat";
+        var binaryData = new byte[] { 0x00, 0xFF, 0x10, 0x20, 0x30, 0x40 };
+
+        var mockClient = new Mock<AmazonS3Client>("accessKey", "secretKey", RegionEndpoint.USEast1);
+        var mockResponseStream = new MemoryStream(binaryData);
+
+        var mockGetObjectResponse = new GetObjectResponse
+        {
+            BucketName = bucketName,
+            Key = key,
+            ResponseStream = mockResponseStream,
+            ContentLength = binaryData.Length,
+            LastModified = DateTime.UtcNow,
+            ETag = "\"etagvalue\"",
+            StorageClass = S3StorageClass.Standard
+        };
+
+        mockClient.Setup(c => c.GetObjectAsync(
+                It.Is<GetObjectRequest>(r => r.BucketName == bucketName && r.Key == key),
+                It.IsAny<CancellationToken>()
+            ))
+            .ReturnsAsync(mockGetObjectResponse);
+
+        mockClient.Setup(c => c.GetObjectMetadataAsync(
+                bucketName,
+                key,
+                It.IsAny<CancellationToken>()
+            ))
+            .ReturnsAsync(new GetObjectMetadataResponse
+            {
+                Headers = { ContentType = "application/octet-stream" }
+            });
+
+        // Act
+        var result = await mockClient.Object.ToContext(bucketName, key, includeMetadata: true, CancellationToken.None);
+
+        // Assert
+        Assert.Equal(key, result.Id);
+        Assert.Equal("File", result.SourceType);
+        Assert.NotNull(result.RawData);
+        Assert.Null(result.Content);
+        Assert.Equal("application/octet-stream", result.Format);
+    }
+
+    [Fact]
+    public async Task ToContext_WithoutMetadata_DoesNotAddMetadata()
+    {
+        // Arrange
+        var bucketName = "test-bucket";
+        var key = "file.txt";
+        var contentBytes = Encoding.UTF8.GetBytes("Some content");
+
+        var mockClient = new Mock<AmazonS3Client>("accessKey", "secretKey", RegionEndpoint.USEast1);
+        var mockResponseStream = new MemoryStream(contentBytes);
+
+        var mockGetObjectResponse = new GetObjectResponse
+        {
+            BucketName = bucketName,
+            Key = key,
+            ResponseStream = mockResponseStream,
+            ContentLength = contentBytes.Length,
+            LastModified = DateTime.UtcNow,
+            ETag = "\"etagvalue\"",
+            StorageClass = S3StorageClass.Standard
+        };
+
+        mockClient.Setup(c => c.GetObjectAsync(
+                It.Is<GetObjectRequest>(r => r.BucketName == bucketName && r.Key == key),
+                It.IsAny<CancellationToken>()
+            ))
+            .ReturnsAsync(mockGetObjectResponse);
+
+        // Act
+        var result = await mockClient.Object.ToContext(bucketName, key, includeMetadata: false, CancellationToken.None);
+
+        // Assert
+        Assert.Equal(key, result.Id);
+        Assert.Equal("File", result.SourceType);
+        Assert.Null(result.RawData);
+        Assert.NotNull(result.Content);
+        Assert.Empty(result.Metadata); // Metadata should be empty
+    }
+}

tests/FlowSynx.Plugins.Amazon.S3.UnitTests/Extensions/StringExtensionsTests.cs

@@ -0,0 +1,55 @@
+using System.Text;
+using FlowSynx.Plugins.Amazon.S3.Extensions;
+
+namespace FlowSynx.Plugins.Amazon.S3.UnitTests.Extensions;
+
+public class StringExtensionsTests
+{
+    [Theory]
+    [InlineData("SGVsbG8gV29ybGQ=", true)] // "Hello World"
+    [InlineData("U29tZSBkYXRhIHdpdGggcGFkZGluZw==", true)]
+    [InlineData("", false)]
+    [InlineData("NotBase64!!", false)]
+    [InlineData("SGVsbG8gV29ybGQ", false)] // Invalid length (not divisible by 4)
+    [InlineData("SG VsbG8=", false)] // Contains space
+    [InlineData("SG\tVsbG8=", false)] // Contains tab
+    [InlineData("SG\rVsbG8=", false)] // Contains carriage return
+    [InlineData("SG\nVsbG8=", false)] // Contains line feed
+    [InlineData("SGVsbG8=", true)] // Valid short base64
+    [InlineData("c3RyaW5nLXdpdGgtc3ltYm9sLXMh", true)] // includes "-" and "!" -> not valid base64
+    public void IsBase64String_Should_ReturnExpectedResult(string input, bool expected)
+    {
+        var result = input.IsBase64String();
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void ToByteArray_Should_ConvertCorrectly()
+    {
+        var input = "Hello World!";
+        var expected = Encoding.UTF8.GetBytes(input);
+
+        var result = input.ToByteArray();
+
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Base64ToByteArray_Should_DecodeCorrectly()
+    {
+        var original = "TestString";
+        var base64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(original));
+
+        var result = base64.Base64ToByteArray();
+
+        Assert.Equal(original, Encoding.UTF8.GetString(result));
+    }
+
+    [Fact]
+    public void Base64ToByteArray_InvalidInput_ShouldThrowFormatException()
+    {
+        var invalidBase64 = "ThisIsNotBase64!!";
+
+        Assert.Throws<FormatException>(() => invalidBase64.Base64ToByteArray());
+    }
+}

tests/FlowSynx.Plugins.Amazon.S3.UnitTests/FlowSynx.Plugins.Amazon.S3.UnitTests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\FlowSynx.Plugins.Amazon.S3.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

tests/FlowSynx.Plugins.Amazon.S3.UnitTests/PathHelperTests.cs

@@ -0,0 +1,139 @@
+namespace FlowSynx.Plugins.Amazon.S3.UnitTests;
+
+public class PathHelperTests
+{
+    [Fact]
+    public void IsDirectory_ShouldReturnTrue_WhenEndsWithSlash()
+    {
+        Assert.True(PathHelper.IsDirectory("folder/"));
+    }
+
+    [Fact]
+    public void IsDirectory_ShouldReturnFalse_WhenNotEndsWithSlash()
+    {
+        Assert.False(PathHelper.IsDirectory("file.txt"));
+    }
+
+    [Fact]
+    public void IsFile_ShouldReturnTrue_WhenNotEndsWithSlash()
+    {
+        Assert.True(PathHelper.IsFile("file.txt"));
+    }
+
+    [Fact]
+    public void IsFile_ShouldReturnFalse_WhenEndsWithSlash()
+    {
+        Assert.False(PathHelper.IsFile("folder/"));
+    }
+
+    [Fact]
+    public void AddTrailingPathSeparator_ShouldAdd_WhenNotPresent()
+    {
+        Assert.Equal("folder/", PathHelper.AddTrailingPathSeparator("folder"));
+    }
+
+    [Fact]
+    public void AddTrailingPathSeparator_ShouldNotAdd_WhenAlreadyPresent()
+    {
+        Assert.Equal("folder/", PathHelper.AddTrailingPathSeparator("folder/"));
+    }
+
+    [Fact]
+    public void AddPathSeparator_ShouldInsertAtIndex_WhenMissing()
+    {
+        Assert.Equal("folder/", PathHelper.AddPathSeparator("folder", 6));
+    }
+
+    [Fact]
+    public void AddPathSeparator_ShouldDoNothing_WhenAlreadyEndsWithSeparator()
+    {
+        Assert.Equal("folder/", PathHelper.AddPathSeparator("folder/", 7));
+    }
+
+    [Fact]
+    public void Combine_ShouldJoinParts_Correctly()
+    {
+        var combined = PathHelper.Combine("folder", "subfolder", "file.txt");
+        Assert.Equal("folder/subfolder/file.txt", combined);
+    }
+
+    [Fact]
+    public void Combine_ShouldHandleNulls_AndEmptyStrings()
+    {
+        var combined = PathHelper.Combine("folder", null, "", "file.txt");
+        Assert.Equal("folder/file.txt", combined);
+    }
+
+    [Theory]
+    [InlineData("folder/subfolder/file.txt", "folder/subfolder/")]
+    [InlineData("file.txt", "/")]
+    [InlineData("/", "")]
+    [InlineData("", "")]
+    public void GetParent_ShouldReturnCorrectParent(string input, string expected)
+    {
+        Assert.Equal(expected, PathHelper.GetParent(input));
+    }
+
+    [Theory]
+    [InlineData("folder/../subfolder", "subfolder")]
+    [InlineData("a/b/../c", "a/c")]
+    [InlineData(null, "/")]
+    [InlineData("", "/")]
+    public void Normalize_ShouldResolvePathsCorrectly(string input, string expected)
+    {
+        Assert.Equal(expected, PathHelper.Normalize(input));
+    }
+
+    [Fact]
+    public void NormalizePart_ShouldTrimSlashes()
+    {
+        Assert.Equal("folder", PathHelper.NormalizePart("/folder/"));
+    }
+
+    [Fact]
+    public void NormalizePart_ShouldThrow_WhenNull()
+    {
+        Assert.Throws<ArgumentNullException>(() => PathHelper.NormalizePart(null));
+    }
+
+    [Fact]
+    public void Split_ShouldReturnParts()
+    {
+        var result = PathHelper.Split("/a/b/c/");
+        Assert.Equal(new[] { "a", "b", "c" }, result);
+    }
+
+    [Fact]
+    public void Split_ShouldReturnEmptyArray_WhenNullOrEmpty()
+    {
+        Assert.Empty(PathHelper.Split(null));
+        Assert.Empty(PathHelper.Split(""));
+    }
+
+    [Theory]
+    [InlineData(null, true)]
+    [InlineData("", true)]
+    [InlineData("/", true)]
+    [InlineData("folder", false)]
+    public void IsRootPath_ShouldIdentifyRootCorrectly(string input, bool expected)
+    {
+        Assert.Equal(expected, PathHelper.IsRootPath(input));
+    }
+
+    [Theory]
+    [InlineData("folder/../file.txt", "file.txt", true)]
+    [InlineData("folder/file.txt", "folder/file.txt", true)]
+    [InlineData("folder/file.txt", "folder2/file.txt", false)]
+    public void ComparePath_ShouldReturnTrueForEquivalentPaths(string p1, string p2, bool expected)
+    {
+        Assert.Equal(expected, PathHelper.ComparePath(p1, p2));
+    }
+
+    [Theory]
+    [InlineData(null, "")]
+    [InlineData(@"folder\subfolder\file.txt", "folder/subfolder/file.txt")]
+    public void ToUnixPath_ShouldConvertBackslashesToForwardSlashes(string input, string expected)
+    {
+        Assert.Equal(expected, PathHelper.ToUnixPath(input));
+    }
+}