Updated code style of mock setups in Service layer tests

6 files changed, 470 insertions, 214 deletions

diff --git a/src/Services/DevHive.Services.Tests/CommentService.Tests.cs b/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
index a73cf90..729e943 100644
--- a/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
@@ -48,11 +48,21 @@ namespace DevHive.Services.Tests
 				Id = id,
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Comment>())).Returns(Task.FromResult(true));
-			_ = this._commentRepositoryMock.Setup(p => p.GetCommentByIssuerAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>())).Returns(Task.FromResult(comment));
-			_ = this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			_ = this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(creator));
-			_ = this._mapperMock.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>())).Returns(comment);
+			this._commentRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Comment>()))
+				.Returns(Task.FromResult(true));
+			this._commentRepositoryMock
+				.Setup(p => p.GetCommentByIssuerAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>()))
+				.Returns(Task.FromResult(comment));
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(creator));
+			this._mapperMock
+				.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>()))
+				.Returns(comment);
 
 			Guid result = await this._commentService.AddComment(createCommentServiceModel);
 
@@ -71,9 +81,15 @@ namespace DevHive.Services.Tests
 				Message = MESSAGE,
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Comment>())).Returns(Task.FromResult(false));
-			_ = this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			_ = this._mapperMock.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>())).Returns(comment);
+			this._commentRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Comment>()))
+				.Returns(Task.FromResult(false));
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._mapperMock
+				.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>()))
+				.Returns(comment);
 
 			Guid result = await this._commentService.AddComment(createCommentServiceModel);
 
@@ -116,9 +132,15 @@ namespace DevHive.Services.Tests
 				Id = creatorId,
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment));
-			_ = this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user));
-			_ = this._mapperMock.Setup(p => p.Map<ReadCommentServiceModel>(It.IsAny<Comment>())).Returns(commentServiceModel);
+			this._commentRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(comment));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(user));
+			this._mapperMock
+				.Setup(p => p.Map<ReadCommentServiceModel>(It.IsAny<Comment>()))
+				.Returns(commentServiceModel);
 
 			ReadCommentServiceModel result = await this._commentService.GetCommentById(Guid.NewGuid());
 
@@ -137,7 +159,9 @@ namespace DevHive.Services.Tests
 				Creator = creator
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment));
+			this._commentRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(comment));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.GetCommentById(Guid.NewGuid()), "GetCommentById does not throw exception when the user does not exist");
 
@@ -154,8 +178,12 @@ namespace DevHive.Services.Tests
 				Id = creatorId,
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Comment>(null));
-			_ = this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user));
+			this._commentRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<Comment>(null));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(user));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.GetCommentById(Guid.NewGuid()));
 
@@ -179,10 +207,18 @@ namespace DevHive.Services.Tests
 				NewMessage = MESSAGE
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			_ = this._commentRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>())).Returns(Task.FromResult(true));
-			_ = this._commentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment));
-			_ = this._mapperMock.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>())).Returns(comment);
+			this._commentRepositoryMock
+				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._commentRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>()))
+				.Returns(Task.FromResult(true));
+			this._commentRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(comment));
+			this._mapperMock
+				.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>()))
+				.Returns(comment);
 
 			Guid result = await this._commentService.UpdateComment(updateCommentServiceModel);
 
@@ -202,9 +238,15 @@ namespace DevHive.Services.Tests
 				NewMessage = MESSAGE
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			_ = this._commentRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>())).Returns(Task.FromResult(false));
-			_ = this._mapperMock.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>())).Returns(comment);
+			this._commentRepositoryMock
+				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._commentRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>()))
+				.Returns(Task.FromResult(false));
+			this._mapperMock
+				.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>()))
+				.Returns(comment);
 
 			Guid result = await this._commentService.UpdateComment(updateCommentServiceModel);
 
@@ -219,7 +261,9 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			_ = this._commentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._commentRepositoryMock
+				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.UpdateComment(updateCommentServiceModel));
 
@@ -236,9 +280,15 @@ namespace DevHive.Services.Tests
 			Guid id = new();
 			Comment comment = new();
 
-			_ = this._commentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			_ = this._commentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment));
-			_ = this._commentRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Comment>())).Returns(Task.FromResult(shouldPass));
+			this._commentRepositoryMock
+				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._commentRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(comment));
+			this._commentRepositoryMock
+				.Setup(p => p.DeleteAsync(It.IsAny<Comment>()))
+				.Returns(Task.FromResult(shouldPass));
 
 			bool result = await this._commentService.DeleteComment(id);
 
@@ -251,7 +301,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "Comment does not exist!";
 			Guid id = new();
 
-			_ = this._commentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._commentRepositoryMock
+				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.DeleteComment(id));
 
diff --git a/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs b/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs
index 0b5f198..c1f4d54 100644
--- a/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs
@@ -44,10 +44,18 @@ namespace DevHive.Services.Tests
 				Id = id
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._languageRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Language>())).Returns(Task.FromResult(true));
-			this._languageRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(language));
-			this._mapperMock.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>())).Returns(language);
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._languageRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Language>()))
+				.Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(language));
+			this._mapperMock
+				.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>()))
+				.Returns(language);
 
 			Guid result = await this._languageService.CreateLanguage(createLanguageServiceModel);
 
@@ -68,9 +76,15 @@ namespace DevHive.Services.Tests
 				Name = languageName
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._languageRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Language>())).Returns(Task.FromResult(false));
-			this._mapperMock.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>())).Returns(language);
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._languageRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Language>()))
+				.Returns(Task.FromResult(false));
+			this._mapperMock
+				.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>()))
+				.Returns(language);
 
 			Guid result = await this._languageService.CreateLanguage(createLanguageServiceModel);
 
@@ -93,7 +107,9 @@ namespace DevHive.Services.Tests
 				Name = languageName
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.CreateLanguage(createLanguageServiceModel));
 
@@ -116,8 +132,12 @@ namespace DevHive.Services.Tests
 				Name = name
 			};
 
-			this._languageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(language));
-			this._mapperMock.Setup(p => p.Map<ReadLanguageServiceModel>(It.IsAny<Language>())).Returns(readLanguageServiceModel);
+			this._languageRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(language));
+			this._mapperMock
+				.Setup(p => p.Map<ReadLanguageServiceModel>(It.IsAny<Language>()))
+				.Returns(readLanguageServiceModel);
 
 			ReadLanguageServiceModel result = await this._languageService.GetLanguageById(id);
 
@@ -129,7 +149,9 @@ namespace DevHive.Services.Tests
 		{
 			string exceptionMessage = "The language does not exist";
 			Guid id = Guid.NewGuid();
-			this._languageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Language>(null));
+			this._languageRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<Language>(null));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.GetLanguageById(id));
 
@@ -147,8 +169,12 @@ namespace DevHive.Services.Tests
 			languges.Add(firstLanguage);
 			languges.Add(secondLanguage);
 
-			this._languageRepositoryMock.Setup(p => p.GetLanguages()).Returns(new HashSet<Language>());
-			this._mapperMock.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>())).Returns(languges);
+			this._languageRepositoryMock
+				.Setup(p => p.GetLanguages())
+				.Returns(new HashSet<Language>());
+			this._mapperMock
+				.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>()))
+				.Returns(languges);
 
 			HashSet<ReadLanguageServiceModel> result = this._languageService.GetLanguages();
 
@@ -158,8 +184,12 @@ namespace DevHive.Services.Tests
 		[Test]
 		public void GetLanguages_ReturnsEmptyHashSet_IfNoLanguagesExist()
 		{
-			this._languageRepositoryMock.Setup(p => p.GetLanguages()).Returns(new HashSet<Language>());
-			this._mapperMock.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>())).Returns(new HashSet<ReadLanguageServiceModel>());
+			this._languageRepositoryMock
+				.Setup(p => p.GetLanguages())
+				.Returns(new HashSet<Language>());
+			this._mapperMock
+				.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>()))
+				.Returns(new HashSet<ReadLanguageServiceModel>());
 
 			HashSet<ReadLanguageServiceModel> result = this._languageService.GetLanguages();
 
@@ -185,10 +215,18 @@ namespace DevHive.Services.Tests
 				Name = name,
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._languageRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Language>())).Returns(Task.FromResult(shouldPass));
-			this._mapperMock.Setup(p => p.Map<Language>(It.IsAny<UpdateLanguageServiceModel>())).Returns(language);
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._languageRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Language>()))
+				.Returns(Task.FromResult(shouldPass));
+			this._mapperMock
+				.Setup(p => p.Map<Language>(It.IsAny<UpdateLanguageServiceModel>()))
+				.Returns(language);
 
 			bool result = await this._languageService.UpdateLanguage(updateLanguageServiceModel);
 
@@ -203,7 +241,9 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.UpdateLanguage(updateTechnologyServiceModel));
 
@@ -218,8 +258,12 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.UpdateLanguage(updateTechnologyServiceModel));
 
@@ -236,9 +280,15 @@ namespace DevHive.Services.Tests
 			Guid id = Guid.NewGuid();
 			Language language = new Language();
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._languageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(language));
-			this._languageRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Language>())).Returns(Task.FromResult(shouldPass));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._languageRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(language));
+			this._languageRepositoryMock
+				.Setup(p => p.DeleteAsync(It.IsAny<Language>()))
+				.Returns(Task.FromResult(shouldPass));
 
 			bool result = await this._languageService.DeleteLanguage(id);
 
@@ -251,7 +301,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "Language does not exist!";
 			Guid id = Guid.NewGuid();
 
-			this._languageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._languageRepositoryMock
+				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.DeleteLanguage(id));
 
diff --git a/src/Services/DevHive.Services.Tests/PostService.Tests.cs b/src/Services/DevHive.Services.Tests/PostService.Tests.cs
index e51f250..5aea4a8 100644
--- a/src/Services/DevHive.Services.Tests/PostService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/PostService.Tests.cs
@@ -53,11 +53,21 @@ namespace DevHive.Services.Tests
 				Id = postId,
 			};
 
-			this._postRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(true));
-			this._postRepositoryMock.Setup(p => p.GetPostByCreatorAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>())).Returns(Task.FromResult(post));
-			this._userRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(creator));
-			this._mapperMock.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>())).Returns(post);
+			this._postRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Post>()))
+				.Returns(Task.FromResult(true));
+			this._postRepositoryMock
+				.Setup(p => p.GetPostByCreatorAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>()))
+				.Returns(Task.FromResult(post));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(creator));
+			this._mapperMock
+				.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>()))
+				.Returns(post);
 
 			Guid result = await this._postService.CreatePost(createPostServiceModel);
 
@@ -76,9 +86,15 @@ namespace DevHive.Services.Tests
 				Message = MESSAGE,
 			};
 
-			this._postRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(false));
-			this._userRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._mapperMock.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>())).Returns(post);
+			this._postRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Post>()))
+				.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._mapperMock
+				.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>()))
+				.Returns(post);
 
 			Guid result = await this._postService.CreatePost(createPostServiceModel);
 
@@ -119,9 +135,15 @@ namespace DevHive.Services.Tests
 				Id = creatorId,
 			};
 
-			this._postRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post));
-			this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user));
-			this._mapperMock.Setup(p => p.Map<ReadPostServiceModel>(It.IsAny<Post>())).Returns(readPostServiceModel);
+			this._postRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(post));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(user));
+			this._mapperMock
+				.Setup(p => p.Map<ReadPostServiceModel>(It.IsAny<Post>()))
+				.Returns(readPostServiceModel);
 
 			ReadPostServiceModel result = await this._postService.GetPostById(Guid.NewGuid());
 
@@ -140,7 +162,9 @@ namespace DevHive.Services.Tests
 				Creator = creator
 			};
 
-			this._postRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post));
+			this._postRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(post));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.GetPostById(Guid.NewGuid()), "GetPostById does not throw exception when the user does not exist");
 
@@ -157,8 +181,12 @@ namespace DevHive.Services.Tests
 				Id = creatorId,
 			};
 
-			this._postRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Post>(null));
-			this._userRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user));
+			this._postRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<Post>(null));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(user));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.GetPostById(Guid.NewGuid()));
 
@@ -183,10 +211,18 @@ namespace DevHive.Services.Tests
 				Files = new List<IFormFile>()
 			};
 
-			this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._postRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>())).Returns(Task.FromResult(true));
-			this._postRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post));
-			this._mapperMock.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>())).Returns(post);
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._postRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>()))
+				.Returns(Task.FromResult(true));
+			this._postRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(post));
+			this._mapperMock
+				.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>()))
+				.Returns(post);
 
 			Guid result = await this._postService.UpdatePost(updatePostServiceModel);
 
@@ -207,9 +243,15 @@ namespace DevHive.Services.Tests
 				Files = new List<IFormFile>()
 			};
 
-			this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._postRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>())).Returns(Task.FromResult(false));
-			this._mapperMock.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>())).Returns(post);
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._postRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>()))
+				.Returns(Task.FromResult(false));
+			this._mapperMock
+				.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>()))
+				.Returns(post);
 
 			Guid result = await this._postService.UpdatePost(updatePostServiceModel);
 
@@ -224,7 +266,9 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.UpdatePost(updatePostServiceModel));
 
@@ -241,9 +285,15 @@ namespace DevHive.Services.Tests
 			Guid id = Guid.NewGuid();
 			Post post = new Post();
 
-			this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._postRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post));
-			this._postRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Post>())).Returns(Task.FromResult(shouldPass));
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._postRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(post));
+			this._postRepositoryMock
+				.Setup(p => p.DeleteAsync(It.IsAny<Post>()))
+				.Returns(Task.FromResult(shouldPass));
 
 			bool result = await this._postService.DeletePost(id);
 
@@ -256,7 +306,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "Post does not exist!";
 			Guid id = Guid.NewGuid();
 
-			this._postRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._postRepositoryMock
+				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.DeletePost(id));
 
diff --git a/src/Services/DevHive.Services.Tests/RoleService.Tests.cs b/src/Services/DevHive.Services.Tests/RoleService.Tests.cs
index 6d5a333..4f1b1f6 100644
--- a/src/Services/DevHive.Services.Tests/RoleService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/RoleService.Tests.cs
@@ -43,10 +43,18 @@ namespace DevHive.Services.Tests
 				Id = id
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._roleRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Role>())).Returns(Task.FromResult(true));
-			this._roleRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(role));
-			this._mapperMock.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>())).Returns(role);
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._roleRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Role>()))
+				.Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(role));
+			this._mapperMock
+				.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>()))
+				.Returns(role);
 
 			Guid result = await this._roleService.CreateRole(createRoleServiceModel);
 
@@ -67,9 +75,15 @@ namespace DevHive.Services.Tests
 				Name = roleName
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._roleRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Role>())).Returns(Task.FromResult(false));
-			this._mapperMock.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>())).Returns(role);
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._roleRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Role>()))
+				.Returns(Task.FromResult(false));
+			this._mapperMock
+				.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>()))
+				.Returns(role);
 
 			Guid result = await this._roleService.CreateRole(createRoleServiceModel);
 
@@ -87,7 +101,9 @@ namespace DevHive.Services.Tests
 				Name = roleName
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.CreateRole(createRoleServiceModel));
 
@@ -110,8 +126,12 @@ namespace DevHive.Services.Tests
 				Name = name
 			};
 
-			this._roleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(role));
-			this._mapperMock.Setup(p => p.Map<RoleServiceModel>(It.IsAny<Role>())).Returns(roleServiceModel);
+			this._roleRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(role));
+			this._mapperMock
+				.Setup(p => p.Map<RoleServiceModel>(It.IsAny<Role>()))
+				.Returns(roleServiceModel);
 
 			RoleServiceModel result = await this._roleService.GetRoleById(id);
 
@@ -123,7 +143,9 @@ namespace DevHive.Services.Tests
 		{
 			string exceptionMessage = "Role does not exist!";
 			Guid id = Guid.NewGuid();
-			this._roleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Role>(null));
+			this._roleRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<Role>(null));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.GetRoleById(id));
 
@@ -149,10 +171,18 @@ namespace DevHive.Services.Tests
 				Name = name,
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._roleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._roleRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Role>())).Returns(Task.FromResult(shouldPass));
-			this._mapperMock.Setup(p => p.Map<Role>(It.IsAny<UpdateRoleServiceModel>())).Returns(role);
+			this._roleRepositoryMock
+				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._roleRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Role>()))
+				.Returns(Task.FromResult(shouldPass));
+			this._mapperMock
+				.Setup(p => p.Map<Role>(It.IsAny<UpdateRoleServiceModel>()))
+				.Returns(role);
 
 			bool result = await this._roleService.UpdateRole(updateRoleServiceModel);
 
@@ -167,7 +197,9 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.UpdateRole(updateRoleServiceModel));
 
@@ -182,8 +214,12 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._roleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._roleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.UpdateRole(updateRoleServiceModel));
 
@@ -200,9 +236,15 @@ namespace DevHive.Services.Tests
 			Guid id = Guid.NewGuid();
 			Role role = new Role();
 
-			this._roleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._roleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(role));
-			this._roleRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Role>())).Returns(Task.FromResult(shouldPass));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(role));
+			this._roleRepositoryMock
+				.Setup(p => p.DeleteAsync(It.IsAny<Role>()))
+				.Returns(Task.FromResult(shouldPass));
 
 			bool result = await this._roleService.DeleteRole(id);
 
@@ -215,7 +257,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "Role does not exist!";
 			Guid id = Guid.NewGuid();
 
-			this._roleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._roleRepositoryMock
+				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.DeleteRole(id));
 
diff --git a/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs b/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs
index 8cc78f1..6df26f1 100644
--- a/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs
@@ -44,10 +44,18 @@ namespace DevHive.Services.Tests
 				Id = id
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._technologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Technology>())).Returns(Task.FromResult(true));
-			this._technologyRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(technology));
-			this._mapperMock.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>())).Returns(technology);
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._technologyRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Technology>()))
+				.Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(technology));
+			this._mapperMock
+				.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>()))
+				.Returns(technology);
 
 			Guid result = await this._technologyService.CreateTechnology(createTechnologyServiceModel);
 
@@ -68,9 +76,15 @@ namespace DevHive.Services.Tests
 				Name = technologyName
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._technologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Technology>())).Returns(Task.FromResult(false));
-			this._mapperMock.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>())).Returns(technology);
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._technologyRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<Technology>()))
+				.Returns(Task.FromResult(false));
+			this._mapperMock
+				.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>()))
+				.Returns(technology);
 
 			Guid result = await this._technologyService.CreateTechnology(createTechnologyServiceModel);
 
@@ -88,7 +102,9 @@ namespace DevHive.Services.Tests
 				Name = technologyName
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.CreateTechnology(createTechnologyServiceModel));
 
@@ -111,8 +127,12 @@ namespace DevHive.Services.Tests
 				Name = name
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(technology));
-			this._mapperMock.Setup(p => p.Map<ReadTechnologyServiceModel>(It.IsAny<Technology>())).Returns(readTechnologyServiceModel);
+			this._technologyRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(technology));
+			this._mapperMock
+				.Setup(p => p.Map<ReadTechnologyServiceModel>(It.IsAny<Technology>()))
+				.Returns(readTechnologyServiceModel);
 
 			ReadTechnologyServiceModel result = await this._technologyService.GetTechnologyById(id);
 
@@ -124,7 +144,9 @@ namespace DevHive.Services.Tests
 		{
 			string exceptionMessage = "The technology does not exist";
 			Guid id = Guid.NewGuid();
-			this._technologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Technology>(null));
+			this._technologyRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<Technology>(null));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.GetTechnologyById(id));
 
@@ -142,8 +164,12 @@ namespace DevHive.Services.Tests
 			technologies.Add(firstTechnology);
 			technologies.Add(secondTechnology);
 
-			this._technologyRepositoryMock.Setup(p => p.GetTechnologies()).Returns(new HashSet<Technology>());
-			this._mapperMock.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>())).Returns(technologies);
+			this._technologyRepositoryMock
+				.Setup(p => p.GetTechnologies())
+				.Returns(new HashSet<Technology>());
+			this._mapperMock
+				.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>()))
+				.Returns(technologies);
 
 			HashSet<ReadTechnologyServiceModel> result = this._technologyService.GetTechnologies();
 
@@ -153,8 +179,12 @@ namespace DevHive.Services.Tests
 		[Test]
 		public void GetLanguages_ReturnsEmptyHashSet_IfNoLanguagesExist()
 		{
-			this._technologyRepositoryMock.Setup(p => p.GetTechnologies()).Returns(new HashSet<Technology>());
-			this._mapperMock.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>())).Returns(new HashSet<ReadTechnologyServiceModel>());
+			this._technologyRepositoryMock
+				.Setup(p => p.GetTechnologies())
+				.Returns(new HashSet<Technology>());
+			this._mapperMock
+				.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>()))
+				.Returns(new HashSet<ReadTechnologyServiceModel>());
 
 			HashSet<ReadTechnologyServiceModel> result = this._technologyService.GetTechnologies();
 
@@ -180,10 +210,18 @@ namespace DevHive.Services.Tests
 				Name = name,
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false));
-			this._technologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Technology>())).Returns(Task.FromResult(shouldPass));
-			this._mapperMock.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>())).Returns(technology);
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._technologyRepositoryMock
+				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Technology>()))
+				.Returns(Task.FromResult(shouldPass));
+			this._mapperMock
+				.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>()))
+				.Returns(technology);
 
 			bool result = await this._technologyService.UpdateTechnology(updatetechnologyServiceModel);
 
@@ -198,7 +236,9 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.UpdateTechnology(updateTechnologyServiceModel));
 
@@ -213,8 +253,12 @@ namespace DevHive.Services.Tests
 			{
 			};
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.UpdateTechnology(updateTechnologyServiceModel));
 
@@ -232,9 +276,15 @@ namespace DevHive.Services.Tests
 			Guid id = Guid.NewGuid();
 			Technology technology = new Technology();
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true));
-			this._technologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(technology));
-			this._technologyRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Technology>())).Returns(Task.FromResult(shouldPass));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._technologyRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(technology));
+			this._technologyRepositoryMock
+				.Setup(p => p.DeleteAsync(It.IsAny<Technology>()))
+				.Returns(Task.FromResult(shouldPass));
 
 			bool result = await this._technologyService.DeleteTechnology(id);
 
@@ -247,7 +297,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "Technology does not exist!";
 			Guid id = Guid.NewGuid();
 
-			this._technologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+			this._technologyRepositoryMock
+				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.DeleteTechnology(id));
 
diff --git a/src/Services/DevHive.Services.Tests/UserService.Tests.cs b/src/Services/DevHive.Services.Tests/UserService.Tests.cs
index 58ee223..809e83b 100644
--- a/src/Services/DevHive.Services.Tests/UserService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/UserService.Tests.cs
@@ -65,18 +65,20 @@ namespace DevHive.Services.Tests
 				UserName = "g_trapov"
 			};
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p =>
-				p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p =>
-				p.GetByUsernameAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(user));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(user));
 
 			string jwtSecurityToken = "akjdhfakndvlahdfkljahdlfkjhasldf";
-			this._jwtServiceMock.Setup(p => p.GenerateJwtToken(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<List<string>>())).Returns(jwtSecurityToken);
+			this._jwtServiceMock
+				.Setup(p => p.GenerateJwtToken(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<List<string>>()))
+				.Returns(jwtSecurityToken);
 			TokenModel tokenModel = await this._userService.LoginUser(loginServiceModel);
 
 			Assert.AreEqual(jwtSecurityToken, tokenModel.Token, "LoginUser does not return the correct token");
@@ -87,9 +89,9 @@ namespace DevHive.Services.Tests
 		{
 			LoginServiceModel loginServiceModel = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(
 				() => this._userService.LoginUser(loginServiceModel));
@@ -111,12 +113,12 @@ namespace DevHive.Services.Tests
 				Id = Guid.NewGuid(),
 			};
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p =>
-				p.GetByUsernameAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(user));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(user));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.LoginUser(loginServiceModel));
 
@@ -140,38 +142,40 @@ namespace DevHive.Services.Tests
 			};
 			Role role = new() { Name = Role.DefaultRole };
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(false));
-			this._userRepositoryMock.Setup(p =>
-				p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p =>
-				p.DoesEmailExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(false));
-			this._userRepositoryMock.Setup(p =>
-				p.AddAsync(It.IsAny<User>()))
-					.ReturnsAsync(true);
-			this._userRepositoryMock.Setup(p =>
-				p.AddRoleToUser(It.IsAny<User>(), It.IsAny<string>()))
-					.ReturnsAsync(true);
-			this._userRepositoryMock.Setup(p =>
-				p.GetByUsernameAsync(It.IsAny<string>()))
-					.ReturnsAsync(user);
-
-			this._roleRepositoryMock.Setup(p =>
-				p.DoesNameExist(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
-			this._roleRepositoryMock.Setup(p =>
-				p.GetByNameAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(role));
-
-			this._mapperMock.Setup(p =>
-				p.Map<User>(It.IsAny<RegisterServiceModel>()))
-					.Returns(user);
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.AddAsync(It.IsAny<User>()))
+				.ReturnsAsync(true);
+			this._userRepositoryMock
+				.Setup(p => p.AddRoleToUser(It.IsAny<User>(), It.IsAny<string>()))
+				.ReturnsAsync(true);
+			this._userRepositoryMock
+				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
+				.ReturnsAsync(user);
+
+			this._roleRepositoryMock
+				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
+			this._roleRepositoryMock
+				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(role));
+
+			this._mapperMock
+				.Setup(p => p.Map<User>(It.IsAny<RegisterServiceModel>()))
+				.Returns(user);
 
 			string jwtSecurityToken = "akjdhfakndvlahdfkljahdlfkjhasldf";
-			this._jwtServiceMock.Setup(p => p.GenerateJwtToken(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<List<string>>())).Returns(jwtSecurityToken);
+			this._jwtServiceMock
+				.Setup(p => p.GenerateJwtToken(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<List<string>>()))
+				.Returns(jwtSecurityToken);
 			TokenModel tokenModel = await this._userService.RegisterUser(registerServiceModel);
 
 			Assert.AreEqual(jwtSecurityToken, tokenModel.Token, "RegisterUser does not return the correct token");
@@ -183,9 +187,9 @@ namespace DevHive.Services.Tests
 			const string EXCEPTION_MESSAGE = "Username already exists!";
 			RegisterServiceModel registerServiceModel = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(
 				() => this._userService.RegisterUser(registerServiceModel));
@@ -198,12 +202,12 @@ namespace DevHive.Services.Tests
 		{
 			RegisterServiceModel registerServiceModel = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(false));
-			this._userRepositoryMock.Setup(p =>
-				p.DoesEmailExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.RegisterUser(registerServiceModel));
 
@@ -223,12 +227,12 @@ namespace DevHive.Services.Tests
 				UserName = username
 			};
 
-			this._userRepositoryMock.Setup(p =>
-				p.GetByIdAsync(It.IsAny<Guid>()))
-					.Returns(Task.FromResult(user));
-			this._mapperMock.Setup(p =>
-				p.Map<UserServiceModel>(It.IsAny<User>()))
-					.Returns(userServiceModel);
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(user));
+			this._mapperMock
+				.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>()))
+				.Returns(userServiceModel);
 
 			UserServiceModel result = await this._userService.GetUserById(id);
 
@@ -239,9 +243,9 @@ namespace DevHive.Services.Tests
 		public void GetTechnologyById_ThrowsException_WhenTechnologyDoesNotExist()
 		{
 			Guid id = new();
-			this._userRepositoryMock.Setup(p =>
-				p.GetByIdAsync(It.IsAny<Guid>()))
-					.Returns(Task.FromResult<User>(null));
+			this._userRepositoryMock
+				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult<User>(null));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.GetUserById(id));
 
@@ -260,12 +264,12 @@ namespace DevHive.Services.Tests
 				UserName = username
 			};
 
-			this._userRepositoryMock.Setup(p =>
-				p.GetByUsernameAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(user));
-			this._mapperMock.Setup(p =>
-				p.Map<UserServiceModel>(It.IsAny<User>()))
-					.Returns(userServiceModel);
+			this._userRepositoryMock
+				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(user));
+			this._mapperMock
+				.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>()))
+				.Returns(userServiceModel);
 
 			UserServiceModel result = await this._userService.GetUserByUsername(username);
 
@@ -277,9 +281,9 @@ namespace DevHive.Services.Tests
 		{
 			string username = "g_trapov";
 
-			this._userRepositoryMock.Setup(p =>
-				p.GetByUsernameAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult<User>(null));
+			this._userRepositoryMock
+				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult<User>(null));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.GetUserByUsername(username));
 
@@ -353,9 +357,9 @@ namespace DevHive.Services.Tests
 		{
 			UpdateUserServiceModel updateUserServiceModel = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUserExistAsync(It.IsAny<Guid>()))
-					.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.UpdateUser(updateUserServiceModel));
 
@@ -367,12 +371,12 @@ namespace DevHive.Services.Tests
 		{
 			UpdateUserServiceModel updateUserServiceModel = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUserExistAsync(It.IsAny<Guid>()))
-					.Returns(Task.FromResult(true));
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUsernameExistAsync(It.IsAny<string>()))
-					.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(true));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
+				.Returns(Task.FromResult(true));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.UpdateUser(updateUserServiceModel));
 
@@ -411,9 +415,9 @@ namespace DevHive.Services.Tests
 			string exceptionMessage = "User does not exist!";
 			Guid id = new();
 
-			this._userRepositoryMock.Setup(p =>
-				p.DoesUserExistAsync(It.IsAny<Guid>()))
-					.Returns(Task.FromResult(false));
+			this._userRepositoryMock
+				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
+				.Returns(Task.FromResult(false));
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.DeleteUser(id));