Add unit tests for the mappers

OF DL.Tests/Models/Mappers/ArchivedMapperTests.cs

@@ -0,0 +1,80 @@
+using OF_DL.Models.Dtos.Archived;
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Entities.Archived;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class ArchivedMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Archived result = ArchivedMapper.FromDto(null);
+
+        Assert.False(result.HasMore);
+        Assert.Null(result.TailMarker);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        DateTime postedAt = new(2024, 1, 2, 3, 4, 5, DateTimeKind.Utc);
+
+        ArchivedDto dto = new()
+        {
+            HasMore = true,
+            TailMarker = "tail",
+            List =
+            [
+                new ListItemDto
+                {
+                    Id = 123,
+                    PostedAt = postedAt,
+                    Author = new AuthorDto { Id = 7 },
+                    Text = "hello",
+                    Price = "9.99",
+                    IsOpened = true,
+                    IsArchived = true,
+                    Preview = ["preview"],
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 456,
+                            Type = "photo",
+                            CanView = true,
+                            Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.jpg" } }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        Archived result = ArchivedMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Equal("tail", result.TailMarker);
+        Assert.Single(result.List);
+
+        ListItem item = result.List[0];
+        Assert.Equal(123, item.Id);
+        Assert.Equal(postedAt, item.PostedAt);
+        Assert.NotNull(item.Author);
+        Assert.Equal(7, item.Author.Id);
+        Assert.Equal("hello", item.Text);
+        Assert.Equal("9.99", item.Price);
+        Assert.True(item.IsOpened);
+        Assert.True(item.IsArchived);
+        Assert.NotNull(item.Media);
+        Assert.Single(item.Media);
+
+        Medium media = item.Media[0];
+        Assert.Equal(456, media.Id);
+        Assert.Equal("photo", media.Type);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.jpg", media.Files.Full.Url);
+    }
+}

OF DL.Tests/Models/Mappers/CommonMapperTests.cs

@@ -0,0 +1,173 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Entities.Common;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class CommonMapperTests
+{
+    [Fact]
+    public void MapAuthor_ReturnsNull_WhenDtoNull() => Assert.Null(CommonMapper.MapAuthor(null));
+
+    [Fact]
+    public void MapAuthor_ReturnsNull_WhenIdZero()
+    {
+        AuthorDto dto = new() { Id = 0 };
+
+        Assert.Null(CommonMapper.MapAuthor(dto));
+    }
+
+    [Fact]
+    public void MapAuthor_MapsId_WhenValid()
+    {
+        AuthorDto dto = new() { Id = 42 };
+
+        Author? result = CommonMapper.MapAuthor(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal(42, result.Id);
+    }
+
+    [Fact]
+    public void MapFull_ReturnsNull_WhenUrlEmpty()
+    {
+        FullDto dto = new() { Url = "" };
+
+        Assert.Null(CommonMapper.MapFull(dto));
+    }
+
+    [Fact]
+    public void MapFull_MapsUrl_WhenPresent()
+    {
+        FullDto dto = new() { Url = "https://example.com/full.jpg" };
+
+        Full? result = CommonMapper.MapFull(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal(dto.Url, result.Url);
+    }
+
+    [Fact]
+    public void MapPreview_ReturnsNull_WhenUrlEmpty()
+    {
+        PreviewDto dto = new() { Url = "" };
+
+        Assert.Null(CommonMapper.MapPreview(dto));
+    }
+
+    [Fact]
+    public void MapPreview_MapsUrl_WhenPresent()
+    {
+        PreviewDto dto = new() { Url = "https://example.com/preview.jpg" };
+
+        Preview? result = CommonMapper.MapPreview(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal(dto.Url, result.Url);
+    }
+
+    [Fact]
+    public void MapManifest_ReturnsNull_WhenDashEmpty()
+    {
+        ManifestDto dto = new() { Dash = "" };
+
+        Assert.Null(CommonMapper.MapManifest(dto));
+    }
+
+    [Fact]
+    public void MapManifest_MapsDash_WhenPresent()
+    {
+        ManifestDto dto = new() { Dash = "dash.mpd" };
+
+        Manifest? result = CommonMapper.MapManifest(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal(dto.Dash, result.Dash);
+    }
+
+    [Fact]
+    public void MapSignature_ReturnsNull_WhenDashEmpty()
+    {
+        SignatureDto dto = new() { Dash = new DashDto() };
+
+        Assert.Null(CommonMapper.MapSignature(dto));
+    }
+
+    [Fact]
+    public void MapSignature_MapsDash_WhenAnyDashFieldPresent()
+    {
+        SignatureDto dto = new() { Dash = new DashDto { CloudFrontPolicy = "policy" } };
+
+        Signature? result = CommonMapper.MapSignature(dto);
+
+        Assert.NotNull(result);
+        Assert.NotNull(result.Dash);
+        Assert.Equal("policy", result.Dash.CloudFrontPolicy);
+    }
+
+    [Fact]
+    public void MapDrm_ReturnsNull_WhenDtoNull() => Assert.Null(CommonMapper.MapDrm(null));
+
+    [Fact]
+    public void MapDrm_MapsManifestAndSignature_WhenPresent()
+    {
+        DrmDto dto = new()
+        {
+            Manifest = new ManifestDto { Dash = "dash.mpd" },
+            Signature = new SignatureDto { Dash = new DashDto { CloudFrontSignature = "signature" } }
+        };
+
+        Drm? result = CommonMapper.MapDrm(dto);
+
+        Assert.NotNull(result);
+        Assert.NotNull(result.Manifest);
+        Assert.NotNull(result.Signature);
+        Assert.Equal("dash.mpd", result.Manifest.Dash);
+        Assert.Equal("signature", result.Signature.Dash?.CloudFrontSignature);
+    }
+
+    [Fact]
+    public void MapFiles_ReturnsNull_WhenAllPartsNull()
+    {
+        FilesDto dto = new() { Full = { Url = "" }, Preview = { Url = "" }, Drm = null };
+
+        Assert.Null(CommonMapper.MapFiles(dto));
+    }
+
+    [Fact]
+    public void MapFiles_MapsParts_WhenPresent()
+    {
+        FilesDto dto = new()
+        {
+            Full = { Url = "https://example.com/full.jpg" }, Preview = { Url = "https://example.com/preview.jpg" }
+        };
+
+        Files? result = CommonMapper.MapFiles(dto);
+
+        Assert.NotNull(result);
+        Assert.NotNull(result.Full);
+        Assert.NotNull(result.Preview);
+        Assert.Equal(dto.Full.Url, result.Full.Url);
+        Assert.Equal(dto.Preview.Url, result.Preview.Url);
+    }
+
+    [Fact]
+    public void MapVideoSources_ReturnsNull_WhenAllEmpty()
+    {
+        VideoSourcesDto dto = new() { _240 = "", _720 = "" };
+
+        Assert.Null(CommonMapper.MapVideoSources(dto));
+    }
+
+    [Fact]
+    public void MapVideoSources_MapsFields_WhenPresent()
+    {
+        VideoSourcesDto dto = new() { _240 = "240.mp4", _720 = "720.mp4" };
+
+        VideoSources? result = CommonMapper.MapVideoSources(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal("240.mp4", result._240);
+        Assert.Equal("720.mp4", result._720);
+    }
+}

OF DL.Tests/Models/Mappers/HighlightsMapperTests.cs

@@ -0,0 +1,75 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Highlights;
+using OF_DL.Models.Entities.Highlights;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class HighlightsMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Highlights result = HighlightsMapper.FromDto((HighlightsDto?)null);
+
+        Assert.False(result.HasMore);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        HighlightsDto dto = new() { HasMore = true, List = [new ListItemDto { Id = 99 }] };
+
+        Highlights result = HighlightsMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Single(result.List);
+        Assert.Equal(99, result.List[0].Id);
+    }
+
+    [Fact]
+    public void FromDto_MapsHighlightMediaStories()
+    {
+        DateTime createdAt = new(2024, 2, 3, 4, 5, 6, DateTimeKind.Utc);
+
+        HighlightMediaDto dto = new()
+        {
+            Stories =
+            [
+                new StoryDto
+                {
+                    Id = 5,
+                    CreatedAt = createdAt,
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 8,
+                            Type = "video",
+                            CanView = true,
+                            CreatedAt = createdAt,
+                            Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.mp4" } }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        HighlightMedia result = HighlightsMapper.FromDto(dto);
+
+        Assert.Single(result.Stories);
+
+        Story story = result.Stories[0];
+        Assert.Equal(5, story.Id);
+        Assert.Equal(createdAt, story.CreatedAt);
+        Assert.NotNull(story.Media);
+        Assert.Single(story.Media);
+
+        Medium media = story.Media[0];
+        Assert.Equal(8, media.Id);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.mp4", media.Files.Full.Url);
+    }
+}

OF DL.Tests/Models/Mappers/MessagesMapperTests.cs

@@ -0,0 +1,113 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Messages;
+using OF_DL.Models.Entities.Messages;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class MessagesMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Messages result = MessagesMapper.FromDto(null as MessagesDto);
+
+        Assert.False(result.HasMore);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        DateTime createdAt = new(2024, 3, 4, 5, 6, 7, DateTimeKind.Utc);
+
+        MessagesDto dto = new()
+        {
+            HasMore = true,
+            List =
+            [
+                new ListItemDto
+                {
+                    Id = 11,
+                    Text = "message",
+                    Price = "4.99",
+                    CreatedAt = createdAt,
+                    FromUser = new FromUserDto { Id = 77 },
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 22,
+                            Type = "photo",
+                            CanView = true,
+                            Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.jpg" } }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        Messages result = MessagesMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Single(result.List);
+
+        ListItem item = result.List[0];
+        Assert.Equal(11, item.Id);
+        Assert.Equal("message", item.Text);
+        Assert.Equal("4.99", item.Price);
+        Assert.Equal(createdAt, item.CreatedAt);
+        Assert.NotNull(item.FromUser);
+        Assert.Equal(77, item.FromUser.Id);
+        Assert.NotNull(item.Media);
+        Assert.Single(item.Media);
+        Assert.Equal(22, item.Media[0].Id);
+    }
+
+    [Fact]
+    public void FromDto_MapsSingleMessage()
+    {
+        DateTime createdAt = new(2024, 4, 5, 6, 7, 8, DateTimeKind.Utc);
+
+        SingleMessageDto dto = new()
+        {
+            Id = 99,
+            Text = "single",
+            Price = 1.23,
+            CreatedAt = createdAt,
+            FromUser = new FromUserDto { Id = 55 },
+            Media =
+            [
+                new MediumDto
+                {
+                    Id = 33,
+                    Type = "video",
+                    CanView = true,
+                    Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.mp4" } }
+                }
+            ]
+        };
+
+        SingleMessage result = MessagesMapper.FromDto(dto);
+
+        Assert.Equal(99, result.Id);
+        Assert.Equal("single", result.Text);
+        Assert.Equal(1.23, result.Price);
+        Assert.Equal(createdAt, result.CreatedAt);
+        Assert.NotNull(result.FromUser);
+        Assert.Equal(55, result.FromUser.Id);
+        Assert.NotNull(result.Media);
+        Assert.Single(result.Media);
+        Assert.Equal(33, result.Media[0].Id);
+    }
+
+    [Fact]
+    public void FromDto_SingleMessage_ReturnsNullFromUser_WhenIdMissing()
+    {
+        SingleMessageDto dto = new() { Id = 1, FromUser = new FromUserDto { Id = null } };
+
+        SingleMessage result = MessagesMapper.FromDto(dto);
+
+        Assert.Null(result.FromUser);
+    }
+}

OF DL.Tests/Models/Mappers/PostMapperTests.cs

@@ -0,0 +1,136 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Posts;
+using OF_DL.Models.Entities.Posts;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class PostMapperTests
+{
+    [Fact]
+    public void PostFromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Post result = PostMapper.FromDto((PostDto?)null);
+
+        Assert.False(result.HasMore);
+        Assert.Null(result.TailMarker);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        DateTime postedAt = new(2024, 5, 6, 7, 8, 9, DateTimeKind.Utc);
+
+        PostDto dto = new()
+        {
+            HasMore = true,
+            TailMarker = "tail",
+            List =
+            [
+                new ListItemDto
+                {
+                    Id = 10,
+                    PostedAt = postedAt,
+                    Author = new AuthorDto { Id = 3 },
+                    Text = "post",
+                    RawText = "post",
+                    IsOpened = true,
+                    Price = "2.50",
+                    IsArchived = true,
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 20,
+                            Type = "photo",
+                            CanView = true,
+                            Preview = "preview",
+                            Files = new FilesDto
+                            {
+                                Full = new FullDto { Url = "https://example.com/full.jpg" },
+                                Preview = new PreviewDto { Url = "https://example.com/preview.jpg" }
+                            }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        Post result = PostMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Equal("tail", result.TailMarker);
+        Assert.Single(result.List);
+
+        ListItem item = result.List[0];
+        Assert.Equal(10, item.Id);
+        Assert.Equal(postedAt, item.PostedAt);
+        Assert.NotNull(item.Author);
+        Assert.Equal(3, item.Author.Id);
+        Assert.Equal("post", item.Text);
+        Assert.True(item.IsOpened);
+        Assert.NotNull(item.Media);
+        Assert.Single(item.Media);
+
+        Medium media = item.Media[0];
+        Assert.Equal(20, media.Id);
+        Assert.Equal("photo", media.Type);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.jpg", media.Files.Full.Url);
+        Assert.NotNull(media.Files.Preview);
+        Assert.Equal("https://example.com/preview.jpg", media.Files.Preview.Url);
+    }
+
+    [Fact]
+    public void FromDto_MapsSinglePost()
+    {
+        DateTime postedAt = new(2024, 6, 7, 8, 9, 10, DateTimeKind.Utc);
+
+        SinglePostDto dto = new()
+        {
+            Id = 77,
+            PostedAt = postedAt,
+            Author = new AuthorDto { Id = 8 },
+            Text = "single",
+            RawText = "single",
+            IsOpened = true,
+            Price = "4.00",
+            IsArchived = false,
+            Preview = ["preview"],
+            Media =
+            [
+                new MediumDto
+                {
+                    Id = 88,
+                    Type = "video",
+                    CanView = true,
+                    Preview = "preview",
+                    Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.mp4" } },
+                    VideoSources = new VideoSourcesDto { _240 = "240.mp4", _720 = "720.mp4" }
+                }
+            ]
+        };
+
+        SinglePost result = PostMapper.FromDto(dto);
+
+        Assert.Equal(77, result.Id);
+        Assert.Equal(postedAt, result.PostedAt);
+        Assert.NotNull(result.Author);
+        Assert.Equal(8, result.Author.Id);
+        Assert.Equal("single", result.Text);
+        Assert.True(result.IsOpened);
+        Assert.NotNull(result.Media);
+        Assert.Single(result.Media);
+
+        Medium media = result.Media[0];
+        Assert.Equal(88, media.Id);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.mp4", media.Files.Full.Url);
+        Assert.NotNull(media.VideoSources);
+        Assert.Equal("240.mp4", media.VideoSources._240);
+        Assert.Equal("720.mp4", media.VideoSources._720);
+    }
+}

OF DL.Tests/Models/Mappers/PurchasedMapperTests.cs

@@ -0,0 +1,77 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Messages;
+using OF_DL.Models.Dtos.Purchased;
+using OF_DL.Models.Entities.Purchased;
+using OF_DL.Models.Mappers;
+using FromUserDto = OF_DL.Models.Dtos.Purchased.FromUserDto;
+using ListItemDto = OF_DL.Models.Dtos.Purchased.ListItemDto;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class PurchasedMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Purchased result = PurchasedMapper.FromDto(null);
+
+        Assert.False(result.HasMore);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        DateTime createdAt = new(2024, 7, 8, 9, 10, 11, DateTimeKind.Utc);
+
+        PurchasedDto dto = new()
+        {
+            HasMore = true,
+            List =
+            [
+                new ListItemDto
+                {
+                    Id = 111,
+                    Text = "purchased",
+                    Price = "12.34",
+                    IsOpened = true,
+                    IsArchived = true,
+                    CreatedAt = createdAt,
+                    PostedAt = createdAt,
+                    FromUser = new FromUserDto { Id = 0 },
+                    Author = new AuthorDto { Id = 5 },
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 222,
+                            Type = "video",
+                            CanView = true,
+                            Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.mp4" } }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        Purchased result = PurchasedMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Single(result.List);
+
+        ListItem item = result.List[0];
+        Assert.Equal(111, item.Id);
+        Assert.Equal("purchased", item.Text);
+        Assert.Equal("12.34", item.Price);
+        Assert.True(item.IsOpened);
+        Assert.True(item.IsArchived);
+        Assert.Equal(createdAt, item.CreatedAt);
+        Assert.Equal(createdAt, item.PostedAt);
+        Assert.NotNull(item.Author);
+        Assert.Equal(5, item.Author.Id);
+        Assert.Null(item.FromUser);
+        Assert.NotNull(item.Media);
+        Assert.Single(item.Media);
+        Assert.Equal(222, item.Media[0].Id);
+    }
+}

OF DL.Tests/Models/Mappers/StoriesMapperTests.cs

@@ -0,0 +1,58 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Stories;
+using OF_DL.Models.Entities.Stories;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class StoriesMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsEmptyList_WhenDtoNull()
+    {
+        List<Stories> result = StoriesMapper.FromDto(null);
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void FromDto_MapsStories()
+    {
+        DateTime createdAt = new(2024, 9, 10, 11, 12, 13, DateTimeKind.Utc);
+
+        List<StoryDto> dto =
+        [
+            new()
+            {
+                Id = 12,
+                CreatedAt = createdAt,
+                Media =
+                [
+                    new MediumDto
+                    {
+                        Id = 34,
+                        Type = "photo",
+                        CanView = true,
+                        CreatedAt = createdAt,
+                        Files = new FilesDto { Full = new FullDto { Url = "https://example.com/full.jpg" } }
+                    }
+                ]
+            }
+        ];
+
+        List<Stories> result = StoriesMapper.FromDto(dto);
+
+        Assert.Single(result);
+
+        Stories story = result[0];
+        Assert.Equal(12, story.Id);
+        Assert.Equal(createdAt, story.CreatedAt);
+        Assert.Single(story.Media);
+
+        Medium media = story.Media[0];
+        Assert.Equal(34, media.Id);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.jpg", media.Files.Full.Url);
+    }
+}

OF DL.Tests/Models/Mappers/StreamsMapperTests.cs

@@ -0,0 +1,91 @@
+using OF_DL.Models.Dtos.Common;
+using OF_DL.Models.Dtos.Streams;
+using OF_DL.Models.Entities.Streams;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class StreamsMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Streams result = StreamsMapper.FromDto(null);
+
+        Assert.False(result.HasMore);
+        Assert.Null(result.TailMarker);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        DateTime postedAt = new(2024, 8, 9, 10, 11, 12, DateTimeKind.Utc);
+
+        StreamsDto dto = new()
+        {
+            HasMore = true,
+            TailMarker = "tail",
+            List =
+            [
+                new ListItemDto
+                {
+                    Id = 333,
+                    PostedAt = postedAt,
+                    Author = new AuthorDto { Id = 9 },
+                    Text = "stream",
+                    RawText = "stream",
+                    Price = "1.00",
+                    IsOpened = null,
+                    IsArchived = null,
+                    Media =
+                    [
+                        new MediumDto
+                        {
+                            Id = 444,
+                            Type = "video",
+                            CanView = true,
+                            Files = new FilesDto
+                            {
+                                Full = new FullDto { Url = "https://example.com/full.mp4" },
+                                Drm = new DrmDto
+                                {
+                                    Manifest = new ManifestDto { Dash = "dash.mpd" },
+                                    Signature = new SignatureDto
+                                    {
+                                        Dash = new DashDto { CloudFrontPolicy = "policy" }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            ]
+        };
+
+        Streams result = StreamsMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Equal("tail", result.TailMarker);
+        Assert.Single(result.List);
+
+        ListItem item = result.List[0];
+        Assert.Equal(333, item.Id);
+        Assert.Equal(postedAt, item.PostedAt);
+        Assert.NotNull(item.Author);
+        Assert.Equal(9, item.Author.Id);
+        Assert.Equal("stream", item.Text);
+        Assert.False(item.IsOpened);
+        Assert.False(item.IsArchived);
+        Assert.NotNull(item.Media);
+        Assert.Single(item.Media);
+
+        Medium media = item.Media[0];
+        Assert.Equal(444, media.Id);
+        Assert.NotNull(media.Files);
+        Assert.NotNull(media.Files.Full);
+        Assert.Equal("https://example.com/full.mp4", media.Files.Full.Url);
+        Assert.NotNull(media.Files.Drm?.Manifest);
+        Assert.Equal("dash.mpd", media.Files.Drm.Manifest.Dash);
+    }
+}

OF DL.Tests/Models/Mappers/SubscriptionsMapperTests.cs

@@ -0,0 +1,34 @@
+using OF_DL.Models.Dtos.Subscriptions;
+using OF_DL.Models.Entities.Subscriptions;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class SubscriptionsMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        Subscriptions result = SubscriptionsMapper.FromDto(null);
+
+        Assert.False(result.HasMore);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsListItems()
+    {
+        SubscriptionsDto dto = new()
+        {
+            HasMore = true, List = [new ListItemDto { Id = 55, Username = null, IsRestricted = true }]
+        };
+
+        Subscriptions result = SubscriptionsMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Single(result.List);
+        Assert.Equal(55, result.List[0].Id);
+        Assert.Equal(string.Empty, result.List[0].Username);
+        Assert.True(result.List[0].IsRestricted);
+    }
+}

OF DL.Tests/Models/Mappers/UserListsMapperTests.cs

@@ -0,0 +1,49 @@
+using OF_DL.Models.Dtos.Lists;
+using OF_DL.Models.Entities.Lists;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class UserListsMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsDefaults_WhenDtoNull()
+    {
+        UserList result = UserListsMapper.FromDto(null as UserListDto);
+
+        Assert.False(result.HasMore);
+        Assert.Empty(result.List);
+    }
+
+    [Fact]
+    public void FromDto_MapsUserListItems()
+    {
+        UserListDto dto = new() { HasMore = true, List = [new UserListItemDto { Id = "1", Name = "Favorites" }] };
+
+        UserList result = UserListsMapper.FromDto(dto);
+
+        Assert.True(result.HasMore);
+        Assert.Single(result.List);
+        Assert.Equal("1", result.List[0].Id);
+        Assert.Equal("Favorites", result.List[0].Name);
+    }
+
+    [Fact]
+    public void FromDto_UsersList_ReturnsEmptyList_WhenDtoNull()
+    {
+        List<UsersList> result = UserListsMapper.FromDto((List<UsersListDto>?)null);
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void FromDto_UsersList_MapsItems()
+    {
+        List<UsersListDto> dto = [new() { Username = "creator" }];
+
+        List<UsersList> result = UserListsMapper.FromDto(dto);
+
+        Assert.Single(result);
+        Assert.Equal("creator", result[0].Username);
+    }
+}

OF DL.Tests/Models/Mappers/UserMapperTests.cs

@@ -0,0 +1,25 @@
+using OF_DL.Models.Dtos.Users;
+using OF_DL.Models.Entities.Users;
+using OF_DL.Models.Mappers;
+
+namespace OF_DL.Tests.Models.Mappers;
+
+public class UserMapperTests
+{
+    [Fact]
+    public void FromDto_ReturnsNull_WhenDtoNull() => Assert.Null(UserMapper.FromDto(null));
+
+    [Fact]
+    public void FromDto_MapsFields()
+    {
+        UserDto dto = new() { Avatar = "avatar", Header = "header", Name = "Name", Username = "user" };
+
+        User? result = UserMapper.FromDto(dto);
+
+        Assert.NotNull(result);
+        Assert.Equal("avatar", result.Avatar);
+        Assert.Equal("header", result.Header);
+        Assert.Equal("Name", result.Name);
+        Assert.Equal("user", result.Username);
+    }
+}

OF DL.Tests/OF DL.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>OF_DL.Tests</RootNamespace>
+    <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="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\OF DL.Core\OF DL.Core.csproj" />
+  </ItemGroup>
+
+</Project>

OF DL.sln

@@ -7,6 +7,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OF DL", "OF DL\OF DL.csproj
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OF DL.Core", "OF DL.Core\OF DL.Core.csproj", "{7B8B6A26-6732-4B3A-AE62-1CE589DFF8F2}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OF DL.Tests", "OF DL.Tests\OF DL.Tests.csproj", "{FF5EC4D7-6369-4A78-8C02-E370343E797C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{7B8B6A26-6732-4B3A-AE62-1CE589DFF8F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7B8B6A26-6732-4B3A-AE62-1CE589DFF8F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7B8B6A26-6732-4B3A-AE62-1CE589DFF8F2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FF5EC4D7-6369-4A78-8C02-E370343E797C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FF5EC4D7-6369-4A78-8C02-E370343E797C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FF5EC4D7-6369-4A78-8C02-E370343E797C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FF5EC4D7-6369-4A78-8C02-E370343E797C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE