PIbd-24_Galtsova_E.I_PuferFish/PuferFishContracts/PuferFishTests/StoragesContracts/PostStorageContractTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using PuferFishContracts.DataModels;
using PuferFishContracts.Enums;
using PuferFishContracts.Exceptions;
using PuferFishDataBase.Implementations;
using PuferFishDataBase.Models;

namespace PuferFishTests.StoragesContracts
{
    [TestFixture]
    internal class PostStorageContractTests : BaseStorageContractTest
    {
        private PostStorageContract _postStorageContract;
        [SetUp]
        public void SetUp()
        {
            _postStorageContract = new PostStorageContract(PuferFishDbContext);
        }
        [TearDown]
        public void TearDown()
        {
            PuferFishDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Posts\"CASCADE; ");
        }
        [Test]
        public void Try_GetList_WhenHaveRecords_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2");
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3");
            var list = _postStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
            AssertElement(list.First(x => x.Id == post.PostId), post);
        }
        [Test]
        public void Try_GetList_WhenNoRecords_Test()
        {
            var list = _postStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.Empty);
        }
        [Test]
        public void Try_GetPostWithHistory_WhenHaveRecords_Test()
        {
            var postId = Guid.NewGuid().ToString();
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1",
            isActual: true);
            InsertPostToDatabaseAndReturn(postId, "name 2", isActual: true);
            InsertPostToDatabaseAndReturn(postId, "name 2", isActual: false);
            var list = _postStorageContract.GetPostWithHistory(postId);
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(2));
        }
        [Test]
        public void Try_GetPostWithHistory_WhenNoRecords_Test()
        {
            var postId = Guid.NewGuid().ToString();
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1",
            isActual: true);
            InsertPostToDatabaseAndReturn(postId, "name 2", isActual: true);
            InsertPostToDatabaseAndReturn(postId, "name 2", isActual: false);
            var list =
            _postStorageContract.GetPostWithHistory(Guid.NewGuid().ToString());
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(0));
        }
        [Test]
        public void Try_GetElementById_WhenHaveRecord_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_postStorageContract.GetElementById(post.PostId),post);
        }
        [Test]
        public void Try_GetElementById_WhenNoRecord_Test()
        {
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() =>
            _postStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
        }
        [Test]
        public void Try_GetElementById_WhenRecordHasDeleted_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: false);
            Assert.That(() => _postStorageContract.GetElementById(post.PostId),
            Is.Null);
        }
        [Test]
        public void Try_GetElementById_WhenTrySearchById_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() => _postStorageContract.GetElementById(post.Id),
            Is.Null);
        }
        [Test]
        public void Try_GetElementByName_WhenHaveRecord_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_postStorageContract.GetElementByName(post.PostName), post);
        }
        [Test]
        public void Try_GetElementByName_WhenNoRecord_Test()
        {
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() => _postStorageContract.GetElementByName("name"),
            Is.Null);
        }
        [Test]
        public void Try_GetElementByName_WhenRecordHasDeleted_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: false);
            Assert.That(() => _postStorageContract.GetElementById(post.PostName),
            Is.Null);
        }
        [Test]
        public void Try_AddElement_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString());
            _postStorageContract.AddElement(post);
            AssertElement(GetPostFromDatabaseByPostId(post.Id), post);
        }
        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameName_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString(), "name unique");
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), postName:
            post.PostName, isActual: true);
            Assert.That(() => _postStorageContract.AddElement(post),
            Throws.TypeOf<ElementExistsException>());
        }
        [Test]
        public void Try_AddElement_WhenHaveRecordWithSamePostId_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString());
            InsertPostToDatabaseAndReturn(post.Id, isActual: true);
            Assert.That(() => _postStorageContract.AddElement(post),
            Throws.TypeOf<ElementExistsException>());
        }
        [Test]
        public void Try_UpdElement_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString());
            InsertPostToDatabaseAndReturn(post.Id, isActual: true);
            _postStorageContract.UpdElement(post);
            var posts = PuferFishDbContext.Posts.Where(x => x.PostId ==
            post.Id).OrderByDescending(x => x.ChangeDate);
            Assert.That(posts.Count(), Is.EqualTo(2));
            AssertElement(posts.First(), CreateModel(post.Id));
            AssertElement(posts.Last(), CreateModel(post.Id));
        }
        [Test]
        public void Try_UpdElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() =>
            _postStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())),
            Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString(), "New Name");
            InsertPostToDatabaseAndReturn(post.Id, postName: "name");
            InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), postName:
            post.PostName);
            Assert.That(() => _postStorageContract.UpdElement(post),
            Throws.TypeOf<ElementExistsException>());
        }
        [Test]
        public void Try_UpdElement_WhenRecordWasDeleted_Test()
        {
            var post = CreateModel(Guid.NewGuid().ToString());
            InsertPostToDatabaseAndReturn(post.Id, isActual: false);
            Assert.That(() => _postStorageContract.UpdElement(post),
            Throws.TypeOf<ElementDeletedException>());
        }
        [Test]
        public void Try_DelElement_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: true);
            _postStorageContract.DelElement(post.PostId);
            var element = GetPostFromDatabaseByPostId(post.PostId);
            Assert.Multiple(() =>
            {
                Assert.That(element, Is.Not.Null);
                Assert.That(!element!.IsActual);
            });
        }
        [Test]
        public void Try_DelElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() =>
            _postStorageContract.DelElement(Guid.NewGuid().ToString()),
            Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_DelElement_WhenRecordWasDeleted_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: false);
            Assert.That(() => _postStorageContract.DelElement(post.PostId),
            Throws.TypeOf<ElementDeletedException>());
        }
        [Test]
        public void Try_ResElement_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: false);
            _postStorageContract.ResElement(post.PostId);
            var element = GetPostFromDatabaseByPostId(post.PostId);
            Assert.Multiple(() =>
            {
                Assert.That(element, Is.Not.Null);
                Assert.That(element!.IsActual);
            });
        }
        [Test]
        public void Try_ResElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() =>
            _postStorageContract.ResElement(Guid.NewGuid().ToString()),
            Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_ResElement_WhenRecordNotWasDeleted_Test()
        {
            var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(),
            isActual: true);
            Assert.That(() => _postStorageContract.ResElement(post.PostId),
            Throws.Nothing);
        }
        private Post InsertPostToDatabaseAndReturn(string id, string postName =
        "test", PostType postType = PostType.chef, bool isActual = true, DateTime? changeDate = null)
        {
            var post = new Post()
            {
                Id = Guid.NewGuid().ToString(),
                PostId = id,
                PostName = postName,
                PostType = postType,
                IsActual = isActual,
                ChangeDate = changeDate ?? DateTime.UtcNow
            };
            PuferFishDbContext.Posts.Add(post);
            PuferFishDbContext.SaveChanges();
            return post;
        }
        private static void AssertElement(PostDataModel? actual, Post expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.PostId));
                Assert.That(actual.PostName, Is.EqualTo(expected.PostName));
                Assert.That(actual.PostType, Is.EqualTo(expected.PostType));
            });
        }
        private static PostDataModel CreateModel(string postId, string postName = "test", PostType postType = PostType.chef) => new(postId, postName, postType);

        private Post? GetPostFromDatabaseByPostId(string id) =>
        PuferFishDbContext.Posts.Where(x => x.PostId == id).OrderByDescending(x =>
        x.ChangeDate).FirstOrDefault();
        private static void AssertElement(Post? actual, PostDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.PostId, Is.EqualTo(expected.Id));
                Assert.That(actual.PostName, Is.EqualTo(expected.PostName));
                Assert.That(actual.PostType, Is.EqualTo(expected.PostType));
            });
        }
    }
}