DD.WellWorkover.Cloud/AsbCloudWebApi.Tests/ServicesTests/CrudServiceTest.cs

using AsbCloudApp.Data;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using AsbCloudInfrastructure.Services;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;

namespace AsbCloudWebApi.Tests.ServicesTests
{
    public class DepositCrudServiceTest : CrudServiceTestAbstract<DepositDto>
    {
        protected override DepositDto MakeNewItem()
        {
            var item = new DepositDto
            {
                Caption = "test deposit",
                Latitude = 1,
                Longitude = 2,
                Timezone = new SimpleTimezoneDto { Hours = 5, TimezoneId = "test Never-land"}
            };
            return item;
        }

        protected override ICrudService<DepositDto> MakeService()
        {
            var dbContext = TestHelpter.MakeTestContext();
            return new CrudCacheServiceBase<DepositDto, Deposit>(dbContext);
        }
    }

    public abstract class CrudServiceTestAbstract<TDto>
        where TDto: AsbCloudApp.Data.IId
    {
        private readonly ICrudService<TDto> service;

        public CrudServiceTestAbstract()
        {
            service = MakeService();
        }

        protected abstract ICrudService<TDto> MakeService();
        protected abstract TDto MakeNewItem();

        [Fact]
        public async Task Insert()
        {
            var newItem = MakeNewItem();
            var id = await service.InsertAsync(newItem, CancellationToken.None);
            Assert.True(id > 0);
        }

        [Fact]
        public async Task InsertRange()
        {
            var items = new TDto[2];
            items[0] = MakeNewItem();
            items[1] = MakeNewItem();
            var count = await service.InsertRangeAsync(items, CancellationToken.None);
            Assert.Equal(2, count);
        }

        [Fact]
        public async Task GetById()
        {
            var newItem = MakeNewItem();
            var id = await service.InsertAsync(newItem, CancellationToken.None);
            var gotItem = await service.GetAsync(id, CancellationToken.None);
            Assert.True(id > 0);
            Assert.Equal(id, gotItem.Id);
        }

        [Fact]
        public async Task GetAll()
        {
            var items = await service.GetAllAsync(CancellationToken.None);
            var count = items.Count();
            await Insert();
            var newItems = await service.GetAllAsync(CancellationToken.None);
            var newCount = newItems.Count();
            Assert.True(newCount > 0);
            Assert.Equal(count + 1, newCount);
        }

        [Fact]
        public async Task UpdateAsync()
        {
            var newItem = MakeNewItem();
            var id = await service.InsertAsync(newItem, CancellationToken.None);
            var updatedId = await service.UpdateAsync(newItem, CancellationToken.None);
            Assert.True(id > 0);
            Assert.Equal(id, updatedId);
        }

        [Fact]
        public async Task DeleteAsync()
        {
            var newItem = MakeNewItem();
            var id = await service.InsertAsync(newItem, CancellationToken.None);
            var deletedId = await service.DeleteAsync(id, CancellationToken.None);
            Assert.True(id > 0);
            Assert.Equal(id, deletedId);
        }
    }
}