diff --git a/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetAllTextsHandlerTests.cs b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetAllTextsHandlerTests.cs
new file mode 100644
index 0000000..753b913
--- /dev/null
+++ b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetAllTextsHandlerTests.cs
@@ -0,0 +1,149 @@
+// <copyright file="GetAllTextsHandlerTests.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace Streetcode.XUnitTest.BLL.MediatR.StreetCode.Text
+{
+    using System.Linq.Expressions;
+    using AutoMapper;
+    using FluentAssertions;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Moq;
+    using Streetcode.BLL.DTO.Streetcode.TextContent.Text;
+    using Streetcode.BLL.Interfaces.Logging;
+    using Streetcode.BLL.Mapping.Streetcode.TextContent;
+    using Streetcode.BLL.MediatR.Streetcode.Text.GetAll;
+    using Streetcode.DAL.Repositories.Interfaces.Base;
+    using Streetcode.DAL.Repositories.Interfaces.Streetcode.TextContent;
+    using Xunit;
+    using TextEntity = Streetcode.DAL.Entities.Streetcode.TextContent.Text;
+
+    /// <summary>
+    /// Unit tests for <see cref="GetAllTextsHandler"/>.
+    /// </summary>
+    public class GetAllTextsHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> repositoryWrapperMock;
+        private readonly Mock<ITextRepository> textRepositoryMock;
+        private readonly IMapper mapper;
+        private readonly Mock<ILoggerService> loggerMock;
+        private readonly GetAllTextsHandler handler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetAllTextsHandlerTests"/> class.
+        /// </summary>
+        public GetAllTextsHandlerTests()
+        {
+            this.repositoryWrapperMock = new Mock<IRepositoryWrapper>();
+            this.textRepositoryMock = new Mock<ITextRepository>();
+            this.mapper = new MapperConfiguration(cfg => cfg.AddProfile<TextProfile>()).CreateMapper();
+            this.loggerMock = new Mock<ILoggerService>();
+
+            this.repositoryWrapperMock
+                .Setup(w => w.TextRepository)
+                .Returns(this.textRepositoryMock.Object);
+
+            this.handler = new GetAllTextsHandler(
+                this.repositoryWrapperMock.Object,
+                this.mapper,
+                this.loggerMock.Object);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns all texts when they exist in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsAllTexts_WhenTextsExist()
+        {
+            // Arrange
+            var query = new GetAllTextsQuery();
+
+            var texts = new List<TextEntity>
+            {
+                new TextEntity { Id = 1, Title = "Title 1", TextContent = "Content 1", StreetcodeId = 1 },
+                new TextEntity { Id = 2, Title = "Title 2", TextContent = "Content 2", StreetcodeId = 2 },
+            };
+
+            var textDtos = new List<TextDTO>
+            {
+                new TextDTO { Id = 1, Title = "Title 1", TextContent = "Content 1", StreetcodeId = 1 },
+                new TextDTO { Id = 2, Title = "Title 2", TextContent = "Content 2", StreetcodeId = 2 },
+            };
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetAllAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync(texts);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().BeEquivalentTo(textDtos);
+
+            this.loggerMock.Verify(
+                l => l.LogError(It.IsAny<object>(), It.IsAny<string>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns an error when the repository returns null.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsError_WhenRepositoryReturnsNull()
+        {
+            // Arrange
+            var query = new GetAllTextsQuery();
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetAllAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync((IEnumerable<TextEntity>)null!);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsFailed.Should().BeTrue();
+            result.Errors[0].Message.Should().Be("Cannot find any text");
+
+            this.loggerMock.Verify(
+                l => l.LogError(query, "Cannot find any text"),
+                Times.Once);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method calls the mapper with the correct entity when texts are retrieved from the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_CallsMapper_WithCorrectEntity()
+        {
+            // Arrange
+            var query = new GetAllTextsQuery();
+
+            var texts = new List<TextEntity>
+            {
+                new TextEntity { Id = 1, Title = "Title 1", TextContent = "Content 1", StreetcodeId = 1 },
+            };
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetAllAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync(texts);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().ContainSingle(dto => dto.Id == 1 && dto.Title == "Title 1");
+        }
+    }
+}
diff --git a/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetParsedTextAdminPreviewHandlerTests.cs b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetParsedTextAdminPreviewHandlerTests.cs
new file mode 100644
index 0000000..607543f
--- /dev/null
+++ b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetParsedTextAdminPreviewHandlerTests.cs
@@ -0,0 +1,99 @@
+// <copyright file="GetParsedTextAdminPreviewHandlerTests.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace Streetcode.XUnitTest.BLL.MediatR.StreetCode.Text
+{
+    using FluentAssertions;
+    using Moq;
+    using Streetcode.BLL.Interfaces.Text;
+    using Streetcode.BLL.MediatR.Streetcode.Text.GetParsed;
+    using Xunit;
+
+    /// <summary>
+    /// Unit tests for <see cref="GetParsedTextAdminPreviewHandler"/>.
+    /// </summary>
+    public class GetParsedTextAdminPreviewHandlerTests
+    {
+        private readonly Mock<ITextService> textServiceMock;
+        private readonly GetParsedTextAdminPreviewHandler handler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetParsedTextAdminPreviewHandlerTests"/> class.
+        /// </summary>
+        public GetParsedTextAdminPreviewHandlerTests()
+        {
+            this.textServiceMock = new Mock<ITextService>();
+            this.handler = new GetParsedTextAdminPreviewHandler(this.textServiceMock.Object);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns an error when the text service returns null, indicating that parsing was unsuccessful.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsError_WhenServiceReturnsNull()
+        {
+            // Arrange
+            var command = new GetParsedTextForAdminPreviewCommand(textToParse: "some text");
+
+            this.textServiceMock
+                .Setup(s => s.AddTermsTag(command.textToParse))
+                .ReturnsAsync((string?)null);
+
+            // Act
+            var result = await this.handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            result.IsFailed.Should().BeTrue();
+            result.Errors.Should().ContainSingle(e => e.Message == "text was not parsed successfully");
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns the processed text when the text service successfully parses the input text.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsProcessedText_WhenServiceSucceeds()
+        {
+            // Arrange
+            const string parsedText = "<Popover><Term>Майдан</Term><Desc>Центральна площа</Desc></Popover>";
+            var command = new GetParsedTextForAdminPreviewCommand(textToParse: "some text");
+
+            this.textServiceMock
+                .Setup(s => s.AddTermsTag(command.textToParse))
+                .ReturnsAsync(parsedText);
+
+            // Act
+            var result = await this.handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().Be(parsedText);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method calls the text service with the original input text, ensuring that the correct data is passed for processing.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_PassesOriginalText_ToService()
+        {
+            // Arrange
+            const string originalText = "raw input text";
+            var command = new GetParsedTextForAdminPreviewCommand(textToParse: originalText);
+
+            this.textServiceMock
+                .Setup(s => s.AddTermsTag(originalText))
+                .ReturnsAsync("processed");
+
+            // Act
+            await this.handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            this.textServiceMock.Verify(
+                s => s.AddTermsTag(originalText),
+                Times.Once);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByIdHandlerTests.cs b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByIdHandlerTests.cs
new file mode 100644
index 0000000..824f353
--- /dev/null
+++ b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByIdHandlerTests.cs
@@ -0,0 +1,126 @@
+// <copyright file="GetTextByIdHandlerTests.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace Streetcode.XUnitTest.BLL.MediatR.StreetCode.Text
+{
+    using System.Linq.Expressions;
+    using AutoMapper;
+    using FluentAssertions;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Moq;
+    using Streetcode.BLL.DTO.Streetcode.TextContent.Text;
+    using Streetcode.BLL.Interfaces.Logging;
+    using Streetcode.BLL.Mapping.Streetcode.TextContent;
+    using Streetcode.BLL.MediatR.Streetcode.Text.GetById;
+    using Streetcode.DAL.Repositories.Interfaces.Base;
+    using Streetcode.DAL.Repositories.Interfaces.Streetcode.TextContent;
+    using Xunit;
+    using TextEntity = Streetcode.DAL.Entities.Streetcode.TextContent.Text;
+
+    /// <summary>
+    /// Unit tests for <see cref="GetTextByIdHandler"/>.
+    /// </summary>
+    public class GetTextByIdHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> repositoryWrapperMock;
+        private readonly Mock<ITextRepository> textRepositoryMock;
+        private readonly IMapper mapper;
+        private readonly Mock<ILoggerService> loggerMock;
+        private readonly GetTextByIdHandler handler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetTextByIdHandlerTests"/> class.
+        /// </summary>
+        public GetTextByIdHandlerTests()
+        {
+            this.repositoryWrapperMock = new Mock<IRepositoryWrapper>();
+            this.textRepositoryMock = new Mock<ITextRepository>();
+            this.mapper = new MapperConfiguration(cfg => cfg.AddProfile<TextProfile>()).CreateMapper();
+            this.loggerMock = new Mock<ILoggerService>();
+
+            this.repositoryWrapperMock
+                .Setup(w => w.TextRepository)
+                .Returns(this.textRepositoryMock.Object);
+
+            this.handler = new GetTextByIdHandler(
+                this.repositoryWrapperMock.Object,
+                this.mapper,
+                this.loggerMock.Object);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns a TextDTO when a text with the specified ID exists in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsTextDTO_WhenTextExists()
+        {
+            // Arrange
+            const int textId = 1;
+            var query = new GetTextByIdQuery(Id: textId);
+
+            var textEntity = new TextEntity
+            {
+                Id = textId,
+                Title = "Test Title",
+                TextContent = "Test Content",
+                StreetcodeId = 1,
+            };
+
+            var textDto = new TextDTO
+            {
+                Id = textId,
+                Title = "Test Title",
+                TextContent = "Test Content",
+                StreetcodeId = 1,
+            };
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync(textEntity);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().BeEquivalentTo(textDto);
+
+            this.loggerMock.Verify(
+                l => l.LogError(It.IsAny<object>(), It.IsAny<string>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns an error when no text with the specified ID exists in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsError_WhenTextNotFound()
+        {
+            // Arrange
+            const int textId = 42;
+            var query = new GetTextByIdQuery(Id: textId);
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync((TextEntity?)null);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsFailed.Should().BeTrue();
+            result.Errors[0].Message.Should().Be($"Cannot find any text with corresponding id: {textId}");
+
+            this.loggerMock.Verify(
+                l => l.LogError(query, $"Cannot find any text with corresponding id: {textId}"),
+                Times.Once);
+        }
+    }
+}
diff --git a/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByStreetcodeIdHandlerTests.cs b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByStreetcodeIdHandlerTests.cs
new file mode 100644
index 0000000..e8bf149
--- /dev/null
+++ b/Streetcode/Streetcode.XUnitTest/BLL/MediatR/StreetCode/Text/GetTextByStreetcodeIdHandlerTests.cs
@@ -0,0 +1,221 @@
+// <copyright file="GetTextByStreetcodeIdHandlerTests.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace Streetcode.XUnitTest.BLL.MediatR.StreetCode.Text
+{
+    using System.Linq.Expressions;
+    using AutoMapper;
+    using FluentAssertions;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Moq;
+    using Streetcode.BLL.DTO.Streetcode.TextContent.Text;
+    using Streetcode.BLL.Interfaces.Logging;
+    using Streetcode.BLL.Interfaces.Text;
+    using Streetcode.BLL.Mapping.Streetcode.TextContent;
+    using Streetcode.BLL.MediatR.Streetcode.Text.GetByStreetcodeId;
+    using Streetcode.DAL.Entities.Streetcode;
+    using Streetcode.DAL.Repositories.Interfaces.Base;
+    using Streetcode.DAL.Repositories.Interfaces.Streetcode;
+    using Streetcode.DAL.Repositories.Interfaces.Streetcode.TextContent;
+    using Xunit;
+    using TextEntity = Streetcode.DAL.Entities.Streetcode.TextContent.Text;
+
+    /// <summary>
+    /// Unit tests for <see cref="GetTextByStreetcodeIdHandler"/>.
+    /// </summary>
+    public class GetTextByStreetcodeIdHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> repositoryWrapperMock;
+        private readonly Mock<ITextRepository> textRepositoryMock;
+        private readonly Mock<IStreetcodeRepository> streetcodeRepositoryMock;
+        private readonly IMapper mapper;
+        private readonly Mock<ITextService> textServiceMock;
+        private readonly Mock<ILoggerService> loggerMock;
+        private readonly GetTextByStreetcodeIdHandler handler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetTextByStreetcodeIdHandlerTests"/> class.
+        /// </summary>
+        public GetTextByStreetcodeIdHandlerTests()
+        {
+            this.repositoryWrapperMock = new Mock<IRepositoryWrapper>();
+            this.textRepositoryMock = new Mock<ITextRepository>();
+            this.streetcodeRepositoryMock = new Mock<IStreetcodeRepository>();
+            this.mapper = new MapperConfiguration(cfg => cfg.AddProfile<TextProfile>()).CreateMapper();
+            this.textServiceMock = new Mock<ITextService>();
+            this.loggerMock = new Mock<ILoggerService>();
+
+            this.repositoryWrapperMock
+                .Setup(w => w.TextRepository)
+                .Returns(this.textRepositoryMock.Object);
+
+            this.repositoryWrapperMock
+                .Setup(w => w.StreetcodeRepository)
+                .Returns(this.streetcodeRepositoryMock.Object);
+
+            this.handler = new GetTextByStreetcodeIdHandler(
+                this.repositoryWrapperMock.Object,
+                this.mapper,
+                this.textServiceMock.Object,
+                this.loggerMock.Object);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns a TextDTO with processed text content when a text associated with the specified streetcode ID exists in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsProcessedText_WhenTextExists()
+        {
+            // Arrange
+            const string originalContent = "Text about Maidan";
+            const string taggedContent = "<Popover><Term>Maidan</Term><Desc>Central square</Desc></Popover>";
+            var query = new GetTextByStreetcodeIdQuery(StreetcodeId: 1);
+
+            var textEntity = new TextEntity
+            {
+                Id = 1,
+                StreetcodeId = 1,
+                TextContent = originalContent,
+            };
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync(textEntity);
+
+            this.textServiceMock
+                .Setup(s => s.AddTermsTag(originalContent))
+                .ReturnsAsync(taggedContent);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().NotBeNull();
+            result.Value!.TextContent.Should().Be(taggedContent);
+
+            this.textServiceMock.Verify(
+                s => s.AddTermsTag(originalContent),
+                Times.Once);
+
+            this.loggerMock.Verify(
+                l => l.LogError(It.IsAny<object>(), It.IsAny<string>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns a successful result with a null value when no text is found for the specified streetcode ID, but the streetcode itself exists in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsNullResult_WhenTextNotFoundButStreetcodeExists()
+        {
+            // Arrange
+            var query = new GetTextByStreetcodeIdQuery(StreetcodeId: 1);
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync((TextEntity?)null);
+
+            this.streetcodeRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<StreetcodeContent, bool>>>(),
+                    It.IsAny<Func<IQueryable<StreetcodeContent>, IIncludableQueryable<StreetcodeContent, object>>?>()))
+                .ReturnsAsync(new StreetcodeContent { Id = 1 });
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().BeNull();
+
+            this.loggerMock.Verify(
+                l => l.LogError(It.IsAny<object>(), It.IsAny<string>()),
+                Times.Never);
+
+            this.textServiceMock.Verify(
+                s => s.AddTermsTag(It.IsAny<string>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method returns an error when no streetcode is found for the specified streetcode ID, regardless of whether a text exists or not.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_ReturnsError_WhenStreetcodeDoesNotExist()
+        {
+            // Arrange
+            var query = new GetTextByStreetcodeIdQuery(StreetcodeId: 1);
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync((TextEntity?)null);
+
+            this.streetcodeRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<StreetcodeContent, bool>>>(),
+                    It.IsAny<Func<IQueryable<StreetcodeContent>, IIncludableQueryable<StreetcodeContent, object>>?>()))
+                .ReturnsAsync((StreetcodeContent?)null);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsFailed.Should().BeTrue();
+
+            this.loggerMock.Verify(
+                l => l.LogError(query, It.Is<string>(msg => msg.Contains("1"))),
+                Times.Once);
+
+            this.textServiceMock.Verify(
+                s => s.AddTermsTag(It.IsAny<string>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Tests that the Handle method processes the text content using the text service and updates the TextDTO with the processed content before returning it in the result when a text is found for the specified streetcode ID.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task Handle_UsesAddTermsTagResult_AsTextContent()
+        {
+            // Arrange
+            const string originalContent = "Text about streetcode";
+            const string taggedContent = "<Popover><Term>streetcode</Term><Desc>description</Desc></Popover>";
+            var query = new GetTextByStreetcodeIdQuery(StreetcodeId: 1);
+            var textEntity = new TextEntity
+            {
+                Id = 1,
+                StreetcodeId = 1,
+                TextContent = originalContent,
+            };
+
+            this.textRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<TextEntity, bool>>>(),
+                    It.IsAny<Func<IQueryable<TextEntity>, IIncludableQueryable<TextEntity, object>>?>()))
+                .ReturnsAsync(textEntity);
+
+            this.textServiceMock
+                .Setup(s => s.AddTermsTag(originalContent))
+                .ReturnsAsync(taggedContent);
+
+            // Act
+            var result = await this.handler.Handle(query, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value!.TextContent.Should().Be(taggedContent);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Streetcode/Streetcode.XUnitTest/BLL/Services/Text/AddTermsToTextServiceTests.cs b/Streetcode/Streetcode.XUnitTest/BLL/Services/Text/AddTermsToTextServiceTests.cs
new file mode 100644
index 0000000..fc5001b
--- /dev/null
+++ b/Streetcode/Streetcode.XUnitTest/BLL/Services/Text/AddTermsToTextServiceTests.cs
@@ -0,0 +1,138 @@
+// <copyright file="AddTermsToTextServiceTests.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace Streetcode.XUnitTest.BLL.Services.Text
+{
+    using System.Linq.Expressions;
+    using FluentAssertions;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Moq;
+    using Streetcode.BLL.Services.Text;
+    using Streetcode.DAL.Entities.Streetcode.TextContent;
+    using Streetcode.DAL.Repositories.Interfaces.Base;
+    using Streetcode.DAL.Repositories.Interfaces.Streetcode.TextContent;
+    using Xunit;
+
+    /// <summary>
+    /// Unit tests for <see cref="AddTermsToTextService"/>.
+    /// </summary>
+    public class AddTermsToTextServiceTests
+    {
+        private readonly Mock<IRepositoryWrapper> repositoryWrapperMock;
+        private readonly Mock<ITermRepository> termRepositoryMock;
+        private readonly AddTermsToTextService service;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AddTermsToTextServiceTests"/> class.
+        /// </summary>
+        public AddTermsToTextServiceTests()
+        {
+            this.repositoryWrapperMock = new Mock<IRepositoryWrapper>();
+            this.termRepositoryMock = new Mock<ITermRepository>();
+
+            this.repositoryWrapperMock
+                .Setup(w => w.TermRepository)
+                .Returns(this.termRepositoryMock.Object);
+
+            this.service = new AddTermsToTextService(this.repositoryWrapperMock.Object);
+        }
+
+        /// <summary>
+        /// Tests that the AddTermsTag method throws an ArgumentNullException when the input string is null.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task AddTermsTag_ThrowArgumentNullException_WhenInputIsNull()
+        {
+            // Arrange
+            string? input = null;
+
+            // Act
+            var result = async () => await this.service.AddTermsTag(input!);
+
+            // Assert
+            await result.Should().ThrowAsync<ArgumentNullException>();
+        }
+
+        /// <summary>
+        /// Tests that the AddTermsTag method wraps a word with a Popover tag when a direct term match is found in the repository.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task AddTermsTag_WrapsWord_WhenDirectTermMatchFound()
+        {
+            // Arrange
+            const string input = "hello";
+            var term = new Term { Id = 1, Title = "hello", Description = "test description" };
+
+            this.termRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<Term, bool>>>(),
+                    It.IsAny<Func<IQueryable<Term>, IIncludableQueryable<Term, object>>?>()))
+                .ReturnsAsync(term);
+
+            // Act
+            var result = await this.service.AddTermsTag(input);
+
+            // Assert
+            result.Should().Contain("<Popover><Term>hello</Term><Desc>test description</Desc></Popover>");
+        }
+
+        /// <summary>
+        /// Tests that the AddTermsTag method wraps only the first occurrence of a word with a Popover tag when multiple occurrences of the same word are present in the input string, and skips subsequent occurrences.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task AddTermsTag_WrapsFirstOccurrence_AndSkipsSubsequent()
+        {
+            // Arrange
+            const string input = "hello hello";
+            const string expectedTag = "<Popover><Term>hello</Term><Desc>test description</Desc></Popover>";
+            var term = new Term { Id = 1, Title = "hello", Description = "test description" };
+
+            this.termRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<Term, bool>>>(),
+                    It.IsAny<Func<IQueryable<Term>, IIncludableQueryable<Term, object>>?>()))
+                .ReturnsAsync(term);
+
+            // Act
+            var result = await this.service.AddTermsTag(input);
+
+            // Assert
+            result.Should().Contain(expectedTag);
+            result.Split("<Popover>").Should().HaveCount(2);
+        }
+
+        /// <summary>
+        /// Tests that the AddTermsTag method does not wrap words that are part of HTML tags and does not query the repository for terms that are HTML tags, ensuring that HTML tags are skipped when splitting words.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        [Fact]
+        public async Task AddTermsTag_SkipsHTMLTags_WhenSplittingWords()
+        {
+            // Arrange
+            const string input = "<strong>hello</strong>";
+            var term = new Term { Id = 1, Title = "strong", Description = "HTML element" };
+
+            this.termRepositoryMock
+                .Setup(repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<Term, bool>>>(),
+                    It.IsAny<Func<IQueryable<Term>, IIncludableQueryable<Term, object>>?>()))
+                .ReturnsAsync(term);
+
+            // Act
+            var result = await this.service.AddTermsTag(input);
+
+            // Assert
+            result.Should().NotContain("<Popover><Term>strong</Term>");
+
+            this.termRepositoryMock.Verify(
+                repo => repo.GetFirstOrDefaultAsync(
+                    It.IsAny<Expression<Func<Term, bool>>>(),
+                    It.IsAny<Func<IQueryable<Term>, IIncludableQueryable<Term, object>>?>()),
+                Times.Once);
+        }
+    }
+}