Added and updated tests

RaptorSheets.Core.Tests/Helpers/MessageHelperTests.cs

@@ -1,4 +1,5 @@
 using FluentAssertions;
+using RaptorSheets.Core.Entities;
 using RaptorSheets.Core.Enums;
 using RaptorSheets.Core.Extensions;
 using RaptorSheets.Core.Helpers;
@@ -9,35 +10,67 @@ namespace RaptorSheets.Core.Tests.Helpers;
 public class MessageHelperTests
 {
     [Fact]
-    public void GivenCreateError_ThenReturnErrorMessage()
+    public void CreateMessage_ShouldSetDefaultType_WhenTypeIsNullOrEmpty()
     {
-        var messageText = "This is an error message.";
-        var message = MessageHelpers.CreateErrorMessage(messageText, MessageTypeEnum.GENERAL);
+        // Arrange
+        var message = new MessageEntity { Message = "Test message", Level = "INFO" };
 
-        message.Level.Should().Be(MessageLevelEnum.ERROR.UpperName());
-        message.Message.Should().Be(messageText);
-        message.Time.Should().BeGreaterThan(0);
+        // Act
+        var result = MessageHelpers.CreateMessage(message);
+
+        // Assert
+        Assert.Equal(MessageTypeEnum.GENERAL.GetDescription(), result.Type);
+        Assert.True(result.Time > 0);
     }
 
     [Fact]
-    public void GivenCreateWarning_ThenReturnWarningMessage()
+    public void CreateErrorMessage_ShouldSetCorrectProperties()
     {
-        var messageText = "This is a warning message.";
-        var message = MessageHelpers.CreateWarningMessage(messageText, MessageTypeEnum.GENERAL);
+        // Arrange
+        var message = "Error occurred";
+        var type = MessageTypeEnum.ADD_DATA;
+
+        // Act
+        var result = MessageHelpers.CreateErrorMessage(message, type);
 
-        message.Level.Should().Be(MessageLevelEnum.WARNING.UpperName());
-        message.Message.Should().Be(messageText);
-        message.Time.Should().BeGreaterThan(0);
+        // Assert
+        Assert.Equal(message, result.Message);
+        Assert.Equal(MessageLevelEnum.ERROR.UpperName(), result.Level);
+        Assert.Equal(type.GetDescription(), result.Type);
+        Assert.True(result.Time > 0);
     }
 
     [Fact]
-    public void GivenCreateInfo_ThenReturnInfoMessage()
+    public void CreateWarningMessage_ShouldSetCorrectProperties()
     {
-        var messageText = "This is an info message.";
-        var message = MessageHelpers.CreateInfoMessage(messageText, MessageTypeEnum.GENERAL);
+        // Arrange
+        var message = "Warning issued";
+        var type = MessageTypeEnum.CHECK_SHEET;
+
+        // Act
+        var result = MessageHelpers.CreateWarningMessage(message, type);
+
+        // Assert
+        Assert.Equal(message, result.Message);
+        Assert.Equal(MessageLevelEnum.WARNING.UpperName(), result.Level);
+        Assert.Equal(type.GetDescription(), result.Type);
+        Assert.True(result.Time > 0);
+    }
+
+    [Fact]
+    public void CreateInfoMessage_ShouldSetCorrectProperties()
+    {
+        // Arrange
+        var message = "Information message";
+        var type = MessageTypeEnum.GET_SHEETS;
+
+        // Act
+        var result = MessageHelpers.CreateInfoMessage(message, type);
 
-        message.Level.Should().Be(MessageLevelEnum.INFO.UpperName());
-        message.Message.Should().Be(messageText);
-        message.Time.Should().BeGreaterThan(0);
+        // Assert
+        Assert.Equal(message, result.Message);
+        Assert.Equal(MessageLevelEnum.INFO.UpperName(), result.Level);
+        Assert.Equal(type.GetDescription(), result.Type);
+        Assert.True(result.Time > 0);
     }
 }

RaptorSheets.Stock.Tests/Helpers/StockSheetHelpersTests.cs

@@ -0,0 +1,93 @@
+using Google.Apis.Sheets.v4.Data;
+using Moq;
+using RaptorSheets.Core.Models.Google;
+using RaptorSheets.Stock.Enums;
+using RaptorSheets.Stock.Helpers;
+using RaptorSheets.Stock.Entities;
+using RaptorSheets.Stock.Constants;
+using Xunit;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace RaptorSheets.Tests.Helpers
+{
+    public class StockSheetHelpersTests
+    {
+        [Fact]
+        public void GetSheets_ShouldReturnAllSheets()
+        {
+            // Act
+            var result = StockSheetHelpers.GetSheets();
+
+            // Assert
+            Assert.Contains(result, sheet => sheet.Name == "Accounts");
+            Assert.Contains(result, sheet => sheet.Name == "Stocks");
+            Assert.Contains(result, sheet => sheet.Name == "Tickers");
+        }
+
+        [Fact]
+        public void GetMissingSheets_ShouldReturnMissingSheets()
+        {
+            // Arrange
+            var spreadsheet = new Spreadsheet
+            {
+                Sheets = new List<Sheet>
+                {
+                    new Sheet { Properties = new SheetProperties { Title = "Accounts" } }
+                }
+            };
+
+            // Act
+            var result = StockSheetHelpers.GetMissingSheets(spreadsheet);
+
+            // Assert
+            Assert.Contains(result, sheet => sheet.Name == "Stocks");
+            Assert.Contains(result, sheet => sheet.Name == "Tickers");
+        }
+
+        [Fact]
+        public void GetDataValidation_ShouldReturnBooleanValidation()
+        {
+            // Act
+            var result = StockSheetHelpers.GetDataValidation(ValidationEnum.BOOLEAN);
+
+            // Assert
+            Assert.Equal("BOOLEAN", result.Condition.Type);
+        }
+
+        [Fact]
+        public void GetDataValidation_ShouldReturnRangeValidation()
+        {
+            // Act
+            var result = StockSheetHelpers.GetDataValidation(ValidationEnum.RANGE_ACCOUNT);
+
+            // Assert
+            Assert.Equal("ONE_OF_RANGE", result.Condition.Type);
+            Assert.Contains(result.Condition.Values, v => v.UserEnteredValue == "=Accounts!A2:A");
+        }
+
+        [Fact]
+        public void MapData_ShouldReturnSheetEntity()
+        {
+            // Arrange
+            var response = new BatchGetValuesByDataFilterResponse
+            {
+                ValueRanges = new List<MatchedValueRange>
+                {
+                    new MatchedValueRange
+                    {
+                        DataFilters = new List<DataFilter> { new DataFilter { A1Range = "Accounts" } },
+                        ValueRange = new ValueRange { Values = new List<IList<object>> { new List<object> { "Header1", "Header2" } } }
+                    }
+                }
+            };
+
+            // Act
+            var result = StockSheetHelpers.MapData(response);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.NotNull(result.Accounts);
+        }
+    }
+}