From 433e18f94712d03c0756376aa704c96a41f4fd61 Mon Sep 17 00:00:00 2001
From: DCay <atriumandvintrigol@gmail.com>
Date: Sun, 14 Apr 2024 14:02:08 +0300
Subject: [PATCH] MT-00 Added 3 Unit Tests and CI workflow

---
 .github/workflows/ci.yml                      |  28 ++++
 .github/workflows/docker-image.yml            |   2 +-
 .../MeTube.Data/Repository/BaseRepository.cs  |   2 +-
 .../Repository/Channels/ChannelRepository.cs  |   2 +-
 .../Repository/Channels/IChannelRepository.cs |   7 +
 .../MeTube.Data/Repository/IBaseRepository.cs |  14 ++
 .../Reactions/IReactionTypeRepository.cs      |   7 +
 .../Reactions/IVideoReactionRepository.cs     |   7 +
 .../Reactions/ReactionTypeRepository.cs       |   2 +-
 .../Reactions/VideoReactionRepository.cs      |   2 +-
 .../Repository/Videos/IVideoRepository.cs     |   7 +
 .../Repository/Videos/VideoRepository.cs      |   4 +-
 src/MeTube.sln                                |   7 +
 .../MeTube.Service.Tests.csproj               |  33 +++++
 .../Mocks/TaskAsyncEnumerable.cs              |  29 ++++
 .../Mocks/TestAsyncEnumerator.cs              |  40 ++++++
 .../Mocks/TestAsyncQueryProvider.cs           |  49 +++++++
 .../Utilities/MoqExtensions.cs                |  55 +++++++
 .../Videos/VideoServiceTests.cs               | 134 ++++++++++++++++++
 .../Playlist/PlaylistService.cs               |   5 +-
 .../MeTube.Service/Videos/VideoService.cs     |  27 ++--
 src/Web/MeTube.Web/Program.cs                 |   5 +-
 22 files changed, 446 insertions(+), 22 deletions(-)
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 src/Data/MeTube.Data/Repository/Channels/IChannelRepository.cs
 create mode 100644 src/Data/MeTube.Data/Repository/IBaseRepository.cs
 create mode 100644 src/Data/MeTube.Data/Repository/Reactions/IReactionTypeRepository.cs
 create mode 100644 src/Data/MeTube.Data/Repository/Reactions/IVideoReactionRepository.cs
 create mode 100644 src/Data/MeTube.Data/Repository/Videos/IVideoRepository.cs
 create mode 100644 src/Service/MeTube.Service.Tests/MeTube.Service.Tests.csproj
 create mode 100644 src/Service/MeTube.Service.Tests/Mocks/TaskAsyncEnumerable.cs
 create mode 100644 src/Service/MeTube.Service.Tests/Mocks/TestAsyncEnumerator.cs
 create mode 100644 src/Service/MeTube.Service.Tests/Mocks/TestAsyncQueryProvider.cs
 create mode 100644 src/Service/MeTube.Service.Tests/Utilities/MoqExtensions.cs
 create mode 100644 src/Service/MeTube.Service.Tests/Videos/VideoServiceTests.cs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..8f620cd
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:    
+  pull_request:
+    branches: [ main ]
+env:
+  DOTNET_VERSION: '8.0.x'
+jobs:
+  ci:
+    name: ci-${{matrix.os}}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    steps:
+    - name: Check out the repo
+      uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+    - name: Install dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --configuration Release --no-restore
+    - name: Test
+      run: dotnet test --no-restore --verbosity normal
\ No newline at end of file
diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml
index e90f18a..2d366a6 100644
--- a/.github/workflows/docker-image.yml
+++ b/.github/workflows/docker-image.yml
@@ -1,4 +1,4 @@
-name: Docker Image CI
+name: Docker Image CD
 
 on:
   push:
diff --git a/src/Data/MeTube.Data/Repository/BaseRepository.cs b/src/Data/MeTube.Data/Repository/BaseRepository.cs
index e29dd18..5fd7092 100644
--- a/src/Data/MeTube.Data/Repository/BaseRepository.cs
+++ b/src/Data/MeTube.Data/Repository/BaseRepository.cs
@@ -3,7 +3,7 @@
 
 namespace MeTube.Data.Repository;
 
-public class BaseRepository<TEntity> where TEntity : BaseEntity
+public class BaseRepository<TEntity> : IBaseRepository<TEntity> where TEntity : BaseEntity
 {
     protected readonly MeTubeDbContext _dbContext;
 
diff --git a/src/Data/MeTube.Data/Repository/Channels/ChannelRepository.cs b/src/Data/MeTube.Data/Repository/Channels/ChannelRepository.cs
index 1bd3901..519b0a3 100644
--- a/src/Data/MeTube.Data/Repository/Channels/ChannelRepository.cs
+++ b/src/Data/MeTube.Data/Repository/Channels/ChannelRepository.cs
@@ -2,7 +2,7 @@
 
 namespace MeTube.Data.Repository.Channels;
 
-public class ChannelRepository : BaseRepository<Channel>
+public class ChannelRepository : BaseRepository<Channel>, IChannelRepository
 {
     public ChannelRepository(MeTubeDbContext dbContext) : base(dbContext)
     {
diff --git a/src/Data/MeTube.Data/Repository/Channels/IChannelRepository.cs b/src/Data/MeTube.Data/Repository/Channels/IChannelRepository.cs
new file mode 100644
index 0000000..59a6a80
--- /dev/null
+++ b/src/Data/MeTube.Data/Repository/Channels/IChannelRepository.cs
@@ -0,0 +1,7 @@
+using MeTube.Data.Models.Channels;
+
+namespace MeTube.Data.Repository.Channels;
+
+public interface IChannelRepository : IBaseRepository<Channel>
+{
+}
diff --git a/src/Data/MeTube.Data/Repository/IBaseRepository.cs b/src/Data/MeTube.Data/Repository/IBaseRepository.cs
new file mode 100644
index 0000000..c0516fd
--- /dev/null
+++ b/src/Data/MeTube.Data/Repository/IBaseRepository.cs
@@ -0,0 +1,14 @@
+namespace MeTube.Data.Repository;
+
+public interface IBaseRepository<TEntity>
+{
+    Task<TEntity> CreateAsync(TEntity entity);
+
+    IQueryable<TEntity> GetAll();
+
+    IQueryable<TEntity> GetAllAsNoTracking();
+
+    Task<TEntity> EditAsync(TEntity entity);
+
+    Task<TEntity> DeleteAsync(TEntity entity);
+}
diff --git a/src/Data/MeTube.Data/Repository/Reactions/IReactionTypeRepository.cs b/src/Data/MeTube.Data/Repository/Reactions/IReactionTypeRepository.cs
new file mode 100644
index 0000000..73704c6
--- /dev/null
+++ b/src/Data/MeTube.Data/Repository/Reactions/IReactionTypeRepository.cs
@@ -0,0 +1,7 @@
+using MeTube.Data.Models.Reactions;
+
+namespace MeTube.Data.Repository.Reactions;
+
+public interface IReactionTypeRepository : IBaseRepository<ReactionType>
+{
+}
diff --git a/src/Data/MeTube.Data/Repository/Reactions/IVideoReactionRepository.cs b/src/Data/MeTube.Data/Repository/Reactions/IVideoReactionRepository.cs
new file mode 100644
index 0000000..8822409
--- /dev/null
+++ b/src/Data/MeTube.Data/Repository/Reactions/IVideoReactionRepository.cs
@@ -0,0 +1,7 @@
+using MeTube.Data.Models.Reactions;
+
+namespace MeTube.Data.Repository.Reactions;
+
+public interface IVideoReactionRepository : IBaseRepository<VideoReaction>
+{
+}
diff --git a/src/Data/MeTube.Data/Repository/Reactions/ReactionTypeRepository.cs b/src/Data/MeTube.Data/Repository/Reactions/ReactionTypeRepository.cs
index 0322543..69043e5 100644
--- a/src/Data/MeTube.Data/Repository/Reactions/ReactionTypeRepository.cs
+++ b/src/Data/MeTube.Data/Repository/Reactions/ReactionTypeRepository.cs
@@ -2,7 +2,7 @@
 
 namespace MeTube.Data.Repository.Reactions;
 
-public class ReactionTypeRepository : BaseRepository<ReactionType>
+public class ReactionTypeRepository : BaseRepository<ReactionType>, IReactionTypeRepository
 {
     public ReactionTypeRepository(MeTubeDbContext dbContext)
         : base(dbContext)
diff --git a/src/Data/MeTube.Data/Repository/Reactions/VideoReactionRepository.cs b/src/Data/MeTube.Data/Repository/Reactions/VideoReactionRepository.cs
index b555941..de2a31a 100644
--- a/src/Data/MeTube.Data/Repository/Reactions/VideoReactionRepository.cs
+++ b/src/Data/MeTube.Data/Repository/Reactions/VideoReactionRepository.cs
@@ -2,7 +2,7 @@
 
 namespace MeTube.Data.Repository.Reactions;
 
-public class VideoReactionRepository : BaseRepository<VideoReaction>
+public class VideoReactionRepository : BaseRepository<VideoReaction>, IVideoReactionRepository
 {
     public VideoReactionRepository(MeTubeDbContext dbContext)
         : base(dbContext)
diff --git a/src/Data/MeTube.Data/Repository/Videos/IVideoRepository.cs b/src/Data/MeTube.Data/Repository/Videos/IVideoRepository.cs
new file mode 100644
index 0000000..1716cc7
--- /dev/null
+++ b/src/Data/MeTube.Data/Repository/Videos/IVideoRepository.cs
@@ -0,0 +1,7 @@
+using MeTube.Data.Models.Videos;
+
+namespace MeTube.Data.Repository.Videos;
+
+public interface IVideoRepository : IBaseRepository<Video>
+{
+}
diff --git a/src/Data/MeTube.Data/Repository/Videos/VideoRepository.cs b/src/Data/MeTube.Data/Repository/Videos/VideoRepository.cs
index a08a520..e082c5a 100644
--- a/src/Data/MeTube.Data/Repository/Videos/VideoRepository.cs
+++ b/src/Data/MeTube.Data/Repository/Videos/VideoRepository.cs
@@ -1,10 +1,8 @@
-using MeTube.Data.Models.Playlists;
 using MeTube.Data.Models.Videos;
-using Microsoft.EntityFrameworkCore;
 
 namespace MeTube.Data.Repository.Videos;
 
-public class VideoRepository : MetadataBaseRepository<Video>
+public class VideoRepository : MetadataBaseRepository<Video>, IVideoRepository
 {
     public VideoRepository(MeTubeDbContext dbContext)
         : base(dbContext)
diff --git a/src/MeTube.sln b/src/MeTube.sln
index b6f9cfb..60e0819 100644
--- a/src/MeTube.sln
+++ b/src/MeTube.sln
@@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MeTube.Web.Models", "Web\Me
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MeTube.Service.Mappings", "Service\MeTube.Service.Mappings\MeTube.Service.Mappings.csproj", "{E7C74408-E954-4733-A7B5-9151A1F8ADB6}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MeTube.Service.Tests", "Service\MeTube.Service.Tests\MeTube.Service.Tests.csproj", "{885B44A5-04D4-4B46-9E6B-523EF48A9346}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -57,6 +59,10 @@ Global
 		{E7C74408-E954-4733-A7B5-9151A1F8ADB6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E7C74408-E954-4733-A7B5-9151A1F8ADB6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E7C74408-E954-4733-A7B5-9151A1F8ADB6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{885B44A5-04D4-4B46-9E6B-523EF48A9346}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{885B44A5-04D4-4B46-9E6B-523EF48A9346}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{885B44A5-04D4-4B46-9E6B-523EF48A9346}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{885B44A5-04D4-4B46-9E6B-523EF48A9346}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -69,6 +75,7 @@ Global
 		{04732F2E-F73E-43A3-8783-0F42E0E57388} = {313E313D-7DE2-4FFA-801E-4A3A6E7D876D}
 		{AAC0C0F6-1E2C-4017-825F-56457DC82E16} = {2A3AEA9D-8F77-4E2E-8E3D-DBE167E082EB}
 		{E7C74408-E954-4733-A7B5-9151A1F8ADB6} = {313E313D-7DE2-4FFA-801E-4A3A6E7D876D}
+		{885B44A5-04D4-4B46-9E6B-523EF48A9346} = {313E313D-7DE2-4FFA-801E-4A3A6E7D876D}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {A7605E11-F2EC-4116-B2D1-323DAAA88E62}
diff --git a/src/Service/MeTube.Service.Tests/MeTube.Service.Tests.csproj b/src/Service/MeTube.Service.Tests/MeTube.Service.Tests.csproj
new file mode 100644
index 0000000..5e78735
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/MeTube.Service.Tests.csproj
@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.70" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Data\MeTube.Data.Models\MeTube.Data.Models.csproj" />
+    <ProjectReference Include="..\..\Data\MeTube.Data\MeTube.Data.csproj" />
+    <ProjectReference Include="..\MeTube.Service.Mappings\MeTube.Service.Mappings.csproj" />
+    <ProjectReference Include="..\MeTube.Service.Models\MeTube.Service.Models.csproj" />
+    <ProjectReference Include="..\MeTube.Service\MeTube.Service.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Service/MeTube.Service.Tests/Mocks/TaskAsyncEnumerable.cs b/src/Service/MeTube.Service.Tests/Mocks/TaskAsyncEnumerable.cs
new file mode 100644
index 0000000..0a74d68
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/Mocks/TaskAsyncEnumerable.cs
@@ -0,0 +1,29 @@
+using System.Linq.Expressions;
+
+namespace MeTube.Service.Tests.Mocks;
+
+public class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T>
+{
+    public TestAsyncEnumerable(IEnumerable<T> enumerable)
+        : base(enumerable)
+    { }
+
+    public TestAsyncEnumerable(Expression expression)
+        : base(expression)
+    { }
+
+    public IAsyncEnumerator<T> GetEnumerator()
+    {
+        return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
+    }
+
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+    {
+        return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
+    }
+
+    IQueryProvider IQueryable.Provider
+    {
+        get { return new TestAsyncQueryProvider<T>(this); }
+    }
+}
diff --git a/src/Service/MeTube.Service.Tests/Mocks/TestAsyncEnumerator.cs b/src/Service/MeTube.Service.Tests/Mocks/TestAsyncEnumerator.cs
new file mode 100644
index 0000000..2ea2336
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/Mocks/TestAsyncEnumerator.cs
@@ -0,0 +1,40 @@
+namespace MeTube.Service.Tests.Mocks;
+
+public class TestAsyncEnumerator<T> : IAsyncEnumerator<T>
+{
+    private readonly IEnumerator<T> _inner;
+
+    public TestAsyncEnumerator(IEnumerator<T> inner)
+    {
+        _inner = inner;
+    }
+
+    public void Dispose()
+    {
+        _inner.Dispose();
+    }
+
+    public T Current
+    {
+        get
+        {
+            return _inner.Current;
+        }
+    }
+
+    public Task<bool> MoveNext(CancellationToken cancellationToken)
+    {
+        return Task.FromResult(_inner.MoveNext());
+    }
+
+    public ValueTask<bool> MoveNextAsync()
+    {
+        return ValueTask.FromResult(_inner.MoveNext());
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        _inner.Dispose();
+        return ValueTask.CompletedTask;
+    }
+}
diff --git a/src/Service/MeTube.Service.Tests/Mocks/TestAsyncQueryProvider.cs b/src/Service/MeTube.Service.Tests/Mocks/TestAsyncQueryProvider.cs
new file mode 100644
index 0000000..2164157
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/Mocks/TestAsyncQueryProvider.cs
@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Query;
+using System.Linq.Expressions;
+
+namespace MeTube.Service.Tests.Mocks;
+
+public class TestAsyncQueryProvider<TEntity> : IAsyncQueryProvider
+{
+    private readonly IQueryProvider _inner;
+
+    internal TestAsyncQueryProvider(IQueryProvider inner)
+    {
+        _inner = inner;
+    }
+
+    public IQueryable CreateQuery(Expression expression)
+    {
+        return new TestAsyncEnumerable<TEntity>(expression);
+    }
+
+    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
+    {
+        return new TestAsyncEnumerable<TElement>(expression);
+    }
+
+    public object Execute(Expression expression)
+    {
+        return _inner.Execute(expression);
+    }
+
+    public TResult Execute<TResult>(Expression expression)
+    {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
+    {
+        return new TestAsyncEnumerable<TResult>(expression);
+    }
+
+    public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(Execute<TResult>(expression));
+    }
+
+    TResult IAsyncQueryProvider.ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
+    {
+        return (TResult)(object)Task.FromResult(Execute<TEntity>(expression));
+    }
+}
\ No newline at end of file
diff --git a/src/Service/MeTube.Service.Tests/Utilities/MoqExtensions.cs b/src/Service/MeTube.Service.Tests/Utilities/MoqExtensions.cs
new file mode 100644
index 0000000..9614083
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/Utilities/MoqExtensions.cs
@@ -0,0 +1,55 @@
+using MeTube.Service.Tests.Mocks;
+using Moq;
+
+namespace MeTube.Service.Tests.Utilities;
+
+public static class MoqExtensions
+{
+    public static Mock<IQueryable<TEntity>> MockQueryable<TEntity>(IQueryable<TEntity> mockCollection)
+    {
+        var mockQueryable = new Mock<IQueryable<TEntity>>();
+
+        mockQueryable.As<IAsyncEnumerable<TEntity>>()
+            .Setup(m => m.GetAsyncEnumerator(It.IsAny<CancellationToken>()))
+            .Returns(new TestAsyncEnumerator<TEntity>(mockCollection.GetEnumerator()));
+
+        mockQueryable.As<IQueryable<TEntity>>()
+            .Setup(m => m.Provider)
+            .Returns(new TestAsyncQueryProvider<TEntity>(mockCollection.Provider));
+
+        mockQueryable.As<IQueryable<TEntity>>().Setup(m => m.Expression).Returns(mockCollection.Expression);
+        mockQueryable.As<IQueryable<TEntity>>().Setup(m => m.ElementType).Returns(mockCollection.ElementType);
+        mockQueryable.As<IQueryable<TEntity>>().Setup(m => m.GetEnumerator()).Returns(() => mockCollection.GetEnumerator());
+
+        return mockQueryable;
+    }
+
+    public static bool CompareCollections<TEntity>(
+        IEnumerable<TEntity> firstCollection, 
+        IEnumerable<TEntity> secondCollection, 
+        Func<TEntity, TEntity, bool> comparer)
+    {
+        if (firstCollection.Count() != secondCollection.Count()) return false;
+
+        foreach (var expectedItem in firstCollection)
+        {
+            bool isPresent = false;
+
+            foreach (var actualItem in secondCollection)
+            {
+                if(comparer.Invoke(actualItem, expectedItem))
+                {
+                    isPresent = true;
+                    break;
+                }
+            }
+
+            if (!isPresent)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/Service/MeTube.Service.Tests/Videos/VideoServiceTests.cs b/src/Service/MeTube.Service.Tests/Videos/VideoServiceTests.cs
new file mode 100644
index 0000000..6cdf2d7
--- /dev/null
+++ b/src/Service/MeTube.Service.Tests/Videos/VideoServiceTests.cs
@@ -0,0 +1,134 @@
+using MeTube.Data.Models.Videos;
+using MeTube.Data.Repository.Channels;
+using MeTube.Data.Repository.Reactions;
+using MeTube.Data.Repository.Videos;
+using MeTube.Service.Playlists;
+using MeTube.Service.Videos;
+using MeTube.Service.Tests.Utilities;
+using Moq;
+using MeTube.Service.Mappings.Videos;
+
+namespace MeTube.Service.Tests.Videos;
+
+public class VideoServiceTests
+{
+    private Mock<IVideoRepository> videoRepositoryMock;
+
+    private Mock<IChannelRepository> channelRepositoryMock;
+
+    private Mock<IVideoReactionRepository> videoReactionRepositoryMock;
+
+    private Mock<IReactionTypeRepository> reactionTypeRepositoryMock;
+
+    private Mock<IPlaylistService> playlistServiceMock;
+
+    private IVideoService videoService;
+
+    private List<Video> GetTestVideoData()
+    {
+        return new List<Video>()
+        {
+            new Video()
+            {
+                Id = "1",
+                Title = "Video-1"
+            },
+            new Video()
+            {
+                Id = "2",
+                Title = "Video-2"
+            },
+            new Video()
+            {
+                Id = "3",
+                Title = "Video-3"
+            }
+        };
+    }
+
+    [SetUp]
+    public void BeforeEach()
+    {
+        this.videoRepositoryMock = new Mock<IVideoRepository>();
+        this.channelRepositoryMock = new Mock<IChannelRepository>();
+        this.videoReactionRepositoryMock = new Mock<IVideoReactionRepository>();
+        this.reactionTypeRepositoryMock = new Mock<IReactionTypeRepository>();
+        this.playlistServiceMock = new Mock<IPlaylistService>();
+
+        this.videoService = new VideoService(
+            videoRepositoryMock.Object,
+            channelRepositoryMock.Object,
+            playlistServiceMock.Object,
+            videoReactionRepositoryMock.Object,
+            reactionTypeRepositoryMock.Object
+        );
+    }
+
+    [Test]
+    public async Task TestGetByIdAsync_WithExistingId_ShouldCorrectlyReturnVideo()
+    {
+        // Arrange
+        var testVideoDataQueryable = this.GetTestVideoData().AsQueryable();
+        var mockSet = MoqExtensions.MockQueryable(testVideoDataQueryable);
+        mockSet.As<IQueryable<Video>>().Setup(m => m.GetEnumerator()).Returns(() => testVideoDataQueryable.GetEnumerator());
+
+        videoRepositoryMock.Setup(vr => vr.GetAll())
+            .Returns(mockSet.Object);
+
+        var expectedVideoId = "2";
+        var expectedVideoTitle = "Video-2";
+
+        // Act
+        var actualVideo = await videoService.GetByIdAsync("2");
+
+        var actualVideoId = actualVideo.Id;
+        var actualVideoTitle = actualVideo.Title;
+
+        // Assert
+        Assert.That(actualVideoId, Is.EqualTo(expectedVideoId), "Video Ids differ.");
+        Assert.That(actualVideoTitle, Is.EqualTo(expectedVideoTitle), "Video Titles differ.");
+    }
+
+    [Test]
+    public async Task TestGetByIdAsync_WithNonExistingId_ShouldReturnNull()
+    {
+        // Arrange
+        var testVideoDataQueryable = this.GetTestVideoData().AsQueryable();
+        var mockSet = MoqExtensions.MockQueryable(testVideoDataQueryable);
+        mockSet.As<IQueryable<Video>>().Setup(m => m.GetEnumerator()).Returns(() => testVideoDataQueryable.GetEnumerator());
+
+        videoRepositoryMock.Setup(vr => vr.GetAll())
+            .Returns(mockSet.Object);
+
+        // Act & Assert
+        Assert.That(
+            async () => await this.videoService.GetByIdAsync("5"),
+            Throws.Exception.TypeOf<ArgumentException>(),
+            "Video Service does not throw exception for non existing video");
+    }
+
+    [Test]
+    public async Task TestGetAll_WithTrackedAndExistingVideos_ShouldReturnCollectionOfVideos()
+    {
+        // Arrange
+        var testVideoDataQueryable = this.GetTestVideoData().AsQueryable();
+        var mockSet = MoqExtensions.MockQueryable(testVideoDataQueryable);
+        mockSet.As<IQueryable<Video>>().Setup(m => m.GetEnumerator()).Returns(() => testVideoDataQueryable.GetEnumerator());
+
+        videoRepositoryMock.Setup(vr => vr.GetAll())
+            .Returns(mockSet.Object);
+
+        var expectedCollection = this.GetTestVideoData().Select(video => video.ToVideoDto(true, true, true)).AsQueryable();
+
+        // Act
+        var actualQueryable = this.videoService.GetAll(true);
+
+        // Assert
+        var areEqual = MoqExtensions.CompareCollections(expectedCollection, actualQueryable, (firstVideo, secondVideo) =>
+        {
+            return firstVideo.Id == secondVideo.Id && firstVideo.Title == secondVideo.Title;
+        });
+
+        Assert.That(areEqual, Is.True);
+    }
+}
diff --git a/src/Service/MeTube.Service/Playlist/PlaylistService.cs b/src/Service/MeTube.Service/Playlist/PlaylistService.cs
index f0447ca..b8607cf 100644
--- a/src/Service/MeTube.Service/Playlist/PlaylistService.cs
+++ b/src/Service/MeTube.Service/Playlist/PlaylistService.cs
@@ -1,6 +1,5 @@
 using MeTube.Data.Models.Channels;
 using MeTube.Data.Models.Playlists;
-using MeTube.Data.Models.Videos;
 using MeTube.Data.Repository.Channels;
 using MeTube.Data.Repository.Playlists;
 using MeTube.Data.Repository.Videos;
@@ -14,11 +13,11 @@ public class PlaylistService : IPlaylistService
 {
     private readonly PlaylistRepository _playlistRepository;
 
-    private readonly VideoRepository _videoRepository;
+    private readonly IVideoRepository _videoRepository;
 
     private readonly ChannelRepository _channelRepository;
 
-    public PlaylistService(PlaylistRepository playlistRepository, VideoRepository videoRepository, ChannelRepository channelRepository)
+    public PlaylistService(PlaylistRepository playlistRepository, IVideoRepository videoRepository, ChannelRepository channelRepository)
     {
         this._playlistRepository = playlistRepository;
         this._videoRepository = videoRepository;
diff --git a/src/Service/MeTube.Service/Videos/VideoService.cs b/src/Service/MeTube.Service/Videos/VideoService.cs
index 5e4f1ee..fccbb2d 100644
--- a/src/Service/MeTube.Service/Videos/VideoService.cs
+++ b/src/Service/MeTube.Service/Videos/VideoService.cs
@@ -14,22 +14,22 @@ namespace MeTube.Service.Videos;
 
 public class VideoService : IVideoService
 {
-    private readonly VideoRepository _videoRepository;
+    private readonly IVideoRepository _videoRepository;
 
-    private readonly ChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-    private readonly VideoReactionRepository _videoReactionRepository;
+    private readonly IVideoReactionRepository _videoReactionRepository;
 
-    private readonly ReactionTypeRepository _reactionTypeRepository;
+    private readonly IReactionTypeRepository _reactionTypeRepository;
 
     private readonly IPlaylistService _playlistService;
 
     public VideoService(
-        VideoRepository videoRepository, 
-        ChannelRepository channelRepository, 
-        IPlaylistService playlistService, 
-        VideoReactionRepository videoReactionRepository, 
-        ReactionTypeRepository reactionTypeRepository)
+        IVideoRepository videoRepository, 
+        IChannelRepository channelRepository, 
+        IPlaylistService playlistService,   
+        IVideoReactionRepository videoReactionRepository, 
+        IReactionTypeRepository reactionTypeRepository)
     {
         this._videoRepository = videoRepository;
         this._channelRepository = channelRepository;
@@ -154,7 +154,14 @@ public async Task<VideoDto> Comment(string videoId, string content, string userI
 
     private async Task<Video> GetByIdInternalAsync(string id)
     {
-        return await this.GetAllTracked().SingleOrDefaultAsync(video => video.Id == id);
+        var video = await this.GetAllTracked().SingleOrDefaultAsync(video => video.Id == id);
+        
+        if(video == null)
+        {
+            throw new ArgumentException($"Video with Id: {id} is non existent."); // TODO: This should be in a constant
+        }
+
+        return video;
     }
 
     private IQueryable<Video> GetAllAsNoTracking()
diff --git a/src/Web/MeTube.Web/Program.cs b/src/Web/MeTube.Web/Program.cs
index 3ac1bff..e840ef4 100644
--- a/src/Web/MeTube.Web/Program.cs
+++ b/src/Web/MeTube.Web/Program.cs
@@ -33,12 +33,15 @@ public static void ConfigureServices(WebApplicationBuilder builder)
 
             builder.Services.AddTransient<AttachmentRepository, AttachmentRepository>();
             builder.Services.AddTransient<ReactionTypeRepository, ReactionTypeRepository>();
+            builder.Services.AddTransient<IReactionTypeRepository, ReactionTypeRepository>();
             builder.Services.AddTransient<ChannelRepository, ChannelRepository>();
+            builder.Services.AddTransient<IChannelRepository, ChannelRepository>();
             builder.Services.AddTransient<ChannelSubscriptionMappingRepository, ChannelSubscriptionMappingRepository>();
-            builder.Services.AddTransient<VideoRepository, VideoRepository>();
+            builder.Services.AddTransient<IVideoRepository, VideoRepository>();
             builder.Services.AddTransient<PlaylistRepository, PlaylistRepository>();
             builder.Services.AddTransient<VideoCommentRepository, VideoCommentRepository>();
             builder.Services.AddTransient<VideoReactionRepository, VideoReactionRepository>();
+            builder.Services.AddTransient<IVideoReactionRepository, VideoReactionRepository>();
             builder.Services.AddTransient<PlaylistCommentRepository, PlaylistCommentRepository>();
             builder.Services.AddTransient<PlaylistReactionRepository, PlaylistReactionRepository>();