From 10ac1adbf9fbeaca116d3fd356f85dd64c8c2bf8 Mon Sep 17 00:00:00 2001
From: Syndamia <kamen.d.mladenov@protonmail.com>
Date: Sun, 14 Mar 2021 12:02:14 +0200
Subject: Made all Returns(Task.FromResult) into ReturnsAsync in Service layer
 tests

---
 .../DevHive.Services.Tests/CommentService.Tests.cs | 40 ++++++++--------
 .../LanguageService.Tests.cs                       | 34 ++++++-------
 .../DevHive.Services.Tests/PostService.Tests.cs    | 40 ++++++++--------
 .../DevHive.Services.Tests/RoleService.Tests.cs    | 34 ++++++-------
 .../TechnologyServices.Tests.cs                    | 34 ++++++-------
 .../DevHive.Services.Tests/UserService.Tests.cs    | 56 +++++++++++-----------
 6 files changed, 119 insertions(+), 119 deletions(-)

(limited to 'src')

diff --git a/src/Services/DevHive.Services.Tests/CommentService.Tests.cs b/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
index 729e943..3d58bc6 100644
--- a/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/CommentService.Tests.cs
@@ -50,16 +50,16 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Comment>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._commentRepositoryMock
 				.Setup(p => p.GetCommentByIssuerAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>()))
-				.Returns(Task.FromResult(comment));
+				.ReturnsAsync(comment);
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(creator));
+				.ReturnsAsync(creator);
 			this._mapperMock
 				.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>()))
 				.Returns(comment);
@@ -83,10 +83,10 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Comment>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._mapperMock
 				.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>()))
 				.Returns(comment);
@@ -134,10 +134,10 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(comment));
+				.ReturnsAsync(comment);
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 			this._mapperMock
 				.Setup(p => p.Map<ReadCommentServiceModel>(It.IsAny<Comment>()))
 				.Returns(commentServiceModel);
@@ -161,7 +161,7 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(comment));
+				.ReturnsAsync(comment);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.GetCommentById(Guid.NewGuid()), "GetCommentById does not throw exception when the user does not exist");
 
@@ -183,7 +183,7 @@ namespace DevHive.Services.Tests
 				.Returns(Task.FromResult<Comment>(null));
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.GetCommentById(Guid.NewGuid()));
 
@@ -209,13 +209,13 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._commentRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._commentRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(comment));
+				.ReturnsAsync(comment);
 			this._mapperMock
 				.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>()))
 				.Returns(comment);
@@ -240,10 +240,10 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._commentRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._mapperMock
 				.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>()))
 				.Returns(comment);
@@ -263,7 +263,7 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._commentService.UpdateComment(updateCommentServiceModel));
 
@@ -282,13 +282,13 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._commentRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(comment));
+				.ReturnsAsync(comment);
 			this._commentRepositoryMock
 				.Setup(p => p.DeleteAsync(It.IsAny<Comment>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 
 			bool result = await this._commentService.DeleteComment(id);
 
@@ -303,7 +303,7 @@ namespace DevHive.Services.Tests
 
 			this._commentRepositoryMock
 				.Setup(p => p.DoesCommentExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(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 c1f4d54..c95c38e 100644
--- a/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/LanguageService.Tests.cs
@@ -46,13 +46,13 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._languageRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Language>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._languageRepositoryMock
 				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(language));
+				.ReturnsAsync(language);
 			this._mapperMock
 				.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>()))
 				.Returns(language);
@@ -78,10 +78,10 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._languageRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Language>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._mapperMock
 				.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>()))
 				.Returns(language);
@@ -109,7 +109,7 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.CreateLanguage(createLanguageServiceModel));
 
@@ -134,7 +134,7 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(language));
+				.ReturnsAsync(language);
 			this._mapperMock
 				.Setup(p => p.Map<ReadLanguageServiceModel>(It.IsAny<Language>()))
 				.Returns(readLanguageServiceModel);
@@ -217,13 +217,13 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._languageRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Language>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 			this._mapperMock
 				.Setup(p => p.Map<Language>(It.IsAny<UpdateLanguageServiceModel>()))
 				.Returns(language);
@@ -243,7 +243,7 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.UpdateLanguage(updateTechnologyServiceModel));
 
@@ -260,10 +260,10 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._languageService.UpdateLanguage(updateTechnologyServiceModel));
 
@@ -282,13 +282,13 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._languageRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(language));
+				.ReturnsAsync(language);
 			this._languageRepositoryMock
 				.Setup(p => p.DeleteAsync(It.IsAny<Language>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 
 			bool result = await this._languageService.DeleteLanguage(id);
 
@@ -303,7 +303,7 @@ namespace DevHive.Services.Tests
 
 			this._languageRepositoryMock
 				.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(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 5aea4a8..058485e 100644
--- a/src/Services/DevHive.Services.Tests/PostService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/PostService.Tests.cs
@@ -55,16 +55,16 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Post>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._postRepositoryMock
 				.Setup(p => p.GetPostByCreatorAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>()))
-				.Returns(Task.FromResult(post));
+				.ReturnsAsync(post);
 			this._userRepositoryMock
 				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(creator));
+				.ReturnsAsync(creator);
 			this._mapperMock
 				.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>()))
 				.Returns(post);
@@ -88,10 +88,10 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Post>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._userRepositoryMock
 				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._mapperMock
 				.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>()))
 				.Returns(post);
@@ -137,10 +137,10 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(post));
+				.ReturnsAsync(post);
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 			this._mapperMock
 				.Setup(p => p.Map<ReadPostServiceModel>(It.IsAny<Post>()))
 				.Returns(readPostServiceModel);
@@ -164,7 +164,7 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(post));
+				.ReturnsAsync(post);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.GetPostById(Guid.NewGuid()), "GetPostById does not throw exception when the user does not exist");
 
@@ -186,7 +186,7 @@ namespace DevHive.Services.Tests
 				.Returns(Task.FromResult<Post>(null));
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.GetPostById(Guid.NewGuid()));
 
@@ -213,13 +213,13 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._postRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._postRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(post));
+				.ReturnsAsync(post);
 			this._mapperMock
 				.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>()))
 				.Returns(post);
@@ -245,10 +245,10 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._postRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._mapperMock
 				.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>()))
 				.Returns(post);
@@ -268,7 +268,7 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._postService.UpdatePost(updatePostServiceModel));
 
@@ -287,13 +287,13 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._postRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(post));
+				.ReturnsAsync(post);
 			this._postRepositoryMock
 				.Setup(p => p.DeleteAsync(It.IsAny<Post>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 
 			bool result = await this._postService.DeletePost(id);
 
@@ -308,7 +308,7 @@ namespace DevHive.Services.Tests
 
 			this._postRepositoryMock
 				.Setup(p => p.DoesPostExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(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 4f1b1f6..83dabf9 100644
--- a/src/Services/DevHive.Services.Tests/RoleService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/RoleService.Tests.cs
@@ -45,13 +45,13 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._roleRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Role>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._roleRepositoryMock
 				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(role));
+				.ReturnsAsync(role);
 			this._mapperMock
 				.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>()))
 				.Returns(role);
@@ -77,10 +77,10 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._roleRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Role>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._mapperMock
 				.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>()))
 				.Returns(role);
@@ -103,7 +103,7 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.CreateRole(createRoleServiceModel));
 
@@ -128,7 +128,7 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(role));
+				.ReturnsAsync(role);
 			this._mapperMock
 				.Setup(p => p.Map<RoleServiceModel>(It.IsAny<Role>()))
 				.Returns(roleServiceModel);
@@ -173,13 +173,13 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._roleRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Role>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 			this._mapperMock
 				.Setup(p => p.Map<Role>(It.IsAny<UpdateRoleServiceModel>()))
 				.Returns(role);
@@ -199,7 +199,7 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.UpdateRole(updateRoleServiceModel));
 
@@ -216,10 +216,10 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._roleService.UpdateRole(updateRoleServiceModel));
 
@@ -238,13 +238,13 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._roleRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(role));
+				.ReturnsAsync(role);
 			this._roleRepositoryMock
 				.Setup(p => p.DeleteAsync(It.IsAny<Role>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 
 			bool result = await this._roleService.DeleteRole(id);
 
@@ -259,7 +259,7 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesRoleExist(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(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 6df26f1..f9c599c 100644
--- a/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/TechnologyServices.Tests.cs
@@ -46,13 +46,13 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._technologyRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Technology>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._technologyRepositoryMock
 				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(technology));
+				.ReturnsAsync(technology);
 			this._mapperMock
 				.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>()))
 				.Returns(technology);
@@ -78,10 +78,10 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._technologyRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<Technology>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._mapperMock
 				.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>()))
 				.Returns(technology);
@@ -104,7 +104,7 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.CreateTechnology(createTechnologyServiceModel));
 
@@ -129,7 +129,7 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(technology));
+				.ReturnsAsync(technology);
 			this._mapperMock
 				.Setup(p => p.Map<ReadTechnologyServiceModel>(It.IsAny<Technology>()))
 				.Returns(readTechnologyServiceModel);
@@ -212,13 +212,13 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._technologyRepositoryMock
 				.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Technology>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 			this._mapperMock
 				.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>()))
 				.Returns(technology);
@@ -238,7 +238,7 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.UpdateTechnology(updateTechnologyServiceModel));
 
@@ -255,10 +255,10 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._technologyService.UpdateTechnology(updateTechnologyServiceModel));
 
@@ -278,13 +278,13 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._technologyRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(technology));
+				.ReturnsAsync(technology);
 			this._technologyRepositoryMock
 				.Setup(p => p.DeleteAsync(It.IsAny<Technology>()))
-				.Returns(Task.FromResult(shouldPass));
+				.ReturnsAsync(shouldPass);
 
 			bool result = await this._technologyService.DeleteTechnology(id);
 
@@ -299,7 +299,7 @@ namespace DevHive.Services.Tests
 
 			this._technologyRepositoryMock
 				.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(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 809e83b..7990b32 100644
--- a/src/Services/DevHive.Services.Tests/UserService.Tests.cs
+++ b/src/Services/DevHive.Services.Tests/UserService.Tests.cs
@@ -67,13 +67,13 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 
 			string jwtSecurityToken = "akjdhfakndvlahdfkljahdlfkjhasldf";
 			this._jwtServiceMock
@@ -91,7 +91,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(
 				() => this._userService.LoginUser(loginServiceModel));
@@ -115,10 +115,10 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.LoginUser(loginServiceModel));
 
@@ -144,13 +144,13 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._userRepositoryMock
 				.Setup(p => p.VerifyPassword(It.IsAny<User>(), It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._userRepositoryMock
 				.Setup(p => p.AddAsync(It.IsAny<User>()))
 				.ReturnsAsync(true);
@@ -163,10 +163,10 @@ namespace DevHive.Services.Tests
 
 			this._roleRepositoryMock
 				.Setup(p => p.DoesNameExist(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._roleRepositoryMock
 				.Setup(p => p.GetByNameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(role));
+				.ReturnsAsync(role);
 
 			this._mapperMock
 				.Setup(p => p.Map<User>(It.IsAny<RegisterServiceModel>()))
@@ -189,7 +189,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(
 				() => this._userService.RegisterUser(registerServiceModel));
@@ -204,10 +204,10 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 			this._userRepositoryMock
 				.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.RegisterUser(registerServiceModel));
 
@@ -229,7 +229,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.GetByIdAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 			this._mapperMock
 				.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>()))
 				.Returns(userServiceModel);
@@ -266,7 +266,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.GetByUsernameAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(user));
+				.ReturnsAsync(user);
 			this._mapperMock
 				.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>()))
 				.Returns(userServiceModel);
@@ -316,19 +316,19 @@ namespace DevHive.Services.Tests
 		//
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.DoesUserExistAsync(It.IsAny<Guid>()))
-		// 	.Returns(Task.FromResult(true));
+		// 	.ReturnsAsync(true);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.DoesUsernameExistAsync(It.IsAny<string>()))
-		// 	.Returns(Task.FromResult(false));
+		// 	.ReturnsAsync(false);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.DoesUserHaveThisUsernameAsync(It.IsAny<Guid>(), It.IsAny<string>()))
 		// 	.Returns(true);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.EditAsync(It.IsAny<Guid>(), It.IsAny<User>()))
-		// 	.Returns(Task.FromResult(shouldPass));
+		// 	.ReturnsAsync(shouldPass);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.GetByIdAsync(It.IsAny<Guid>()))
-		// 	.Returns(Task.FromResult(user));
+		// 	.ReturnsAsync(user);
 		// 	this._mapperMock.Setup(p =>
 		// p.Map<User>(It.IsAny<UpdateUserServiceModel>()))
 		// 	.Returns(user);
@@ -346,7 +346,7 @@ namespace DevHive.Services.Tests
 		// 	{
 		// 		const string EXCEPTION_MESSAGE = "Unable to edit user!";
 		//
-		// 		Exception ex = Assert.ThrowsAsync<InvalidOperationException>(() => this._userService.UpdateUser(updateUserServiceModel));
+		// 		Exception ex = Assert.ThrowsAsync<InvalidOperationException>(() => this._userService.UpdateUser(updateUserServiceModel);
 		//
 		// 		Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorrect exception message");
 		// 	}
@@ -359,7 +359,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.UpdateUser(updateUserServiceModel));
 
@@ -373,10 +373,10 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 			this._userRepositoryMock
 				.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>()))
-				.Returns(Task.FromResult(true));
+				.ReturnsAsync(true);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.UpdateUser(updateUserServiceModel));
 
@@ -396,13 +396,13 @@ namespace DevHive.Services.Tests
 		//
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.DoesUserExistAsync(It.IsAny<Guid>()))
-		// 			.Returns(Task.FromResult(true));
+		// 			.ReturnsAsync(true);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.GetByIdAsync(It.IsAny<Guid>()))
-		// 	.Returns(Task.FromResult(user));
+		// 	.ReturnsAsync(user);
 		// 	this._userRepositoryMock.Setup(p =>
 		// p.DeleteAsync(It.IsAny<User>()))
-		// 			.Returns(Task.FromResult(shouldPass));
+		// 			.ReturnsAsync(shouldPass);
 		//
 		// 	bool result = await this._userService.DeleteUser(id);
 		//
@@ -417,7 +417,7 @@ namespace DevHive.Services.Tests
 
 			this._userRepositoryMock
 				.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>()))
-				.Returns(Task.FromResult(false));
+				.ReturnsAsync(false);
 
 			Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this._userService.DeleteUser(id));
 
-- 
cgit v1.2.3