Pyro/PIbd-24_Ivleev_D.A._TwoFromTheCase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Тесты

Browse Source
This commit is contained in:
Pyro
2025-04-24 16:06:10 +04:00
parent aad3477ef8
commit ef48e78e60
21 changed files with 1548 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
TwoFromTheCaseProject/TwoFromTheCaseContracts/DataModels/PostDataModel.cs
View File

@@ -5,9 +5,9 @@ using TwoFromTheCaseContracts.Infrastructure;
namespace TwoFromTheCaseContracts.DataModels;
public class PostDataModel(string id, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation
public class PostDataModel(string postId, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation
{
public string Id { get; private set; } = id;
public string Id { get; private set; } = postId;
public string PostName { get; private set; } = postName;

4
TwoFromTheCaseProject/TwoFromTheCaseContracts/DataModels/WorkDataModel.cs
View File

@@ -4,7 +4,7 @@ using TwoFromTheCaseContracts.Infrastructure;
namespace TwoFromTheCaseContracts.DataModels;
public class WorkDataModel(string id, string premisesId, double price, bool isCancel, List<WorkerWorkDataModel> workers) : IValidation
public class WorkDataModel(string id, string premisesId, double price, bool isCancel, List<WorkerWorkDataModel> workerWorks) : IValidation
{
public string Id { get; private set; } = id;
@@ -18,7 +18,7 @@ public class WorkDataModel(string id, string premisesId, double price, bool isCa
public bool IsCancel { get; private set; } = isCancel;
public List<WorkerWorkDataModel> Workers { get; private set; } = workers;
public List<WorkerWorkDataModel> Workers { get; private set; } = workerWorks;
public void Validate()
{

5
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Implementations/CustomerStrorageContract.cs
View File

@@ -18,8 +18,7 @@ class CustomerStrorageContract : ICustomerStrorageContract
_dbContext = twoFromTheCaseDbContext;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Customer, CustomerDataModel>();
cfg.CreateMap<CustomerDataModel, Customer>();
cfg.AddMaps(typeof(Customer));
});
_mapper = new Mapper(config);
}
@@ -113,7 +112,7 @@ class CustomerStrorageContract : ICustomerStrorageContract
_dbContext.ChangeTracker.Clear();
throw;
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Buyers_PhoneNumber" })
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Customers_PhoneNumber" })
{
_dbContext.ChangeTracker.Clear();
throw new ElementExistsException("PhoneNumber", customerDataModel.PhoneNumber);

36
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Implementations/PremisesStorageContract.cs
View File

@@ -19,7 +19,8 @@ class PremisesStorageContract : IPremisesStorageContract
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Premises, PremisesDataModel>();
cfg.CreateMap<PremisesDataModel, Premises>();
cfg.CreateMap<PremisesDataModel, Premises>()
.ForMember(x => x.IsDeleted, x => x.MapFrom(src => false));
});
_mapper = new Mapper(config);
}
@@ -28,7 +29,16 @@ class PremisesStorageContract : IPremisesStorageContract
{
try
{
return [.. _dbContext.Premises.Select(x => _mapper.Map<PremisesDataModel>(x))];
var query = _dbContext.Premises.AsQueryable();
if (onlyActive)
{
query = query.Where(x => !x.IsDeleted);
}
if (customerId is not null)
{
query = query.Where(x => x.CustomerId == customerId);
}
return [.. query.Select(x => _mapper.Map<PremisesDataModel>(x))];
}
catch (Exception ex)
{
@@ -73,11 +83,21 @@ class PremisesStorageContract : IPremisesStorageContract
{
try
{
var element = GetPremisesById(premisesDataModel.Id) ?? throw new ElementNotFoundException(premisesDataModel.Id);
_dbContext.Premises.Update(_mapper.Map(premisesDataModel, element));
_dbContext.SaveChanges();
var transaction = _dbContext.Database.BeginTransaction();
try
{
var element = GetPremisesById(premisesDataModel.Id) ?? throw new ElementNotFoundException(premisesDataModel.Id);
_dbContext.Premises.Update(_mapper.Map(premisesDataModel, element));
_dbContext.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
catch (ElementNotFoundException)
catch (Exception ex) when (ex is ElementDeletedException || ex is ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
@@ -94,7 +114,7 @@ class PremisesStorageContract : IPremisesStorageContract
try
{
var element = GetPremisesById(id) ?? throw new ElementNotFoundException(id);
_dbContext.Premises.Remove(element);
element.IsDeleted = true;
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
@@ -109,5 +129,5 @@ class PremisesStorageContract : IPremisesStorageContract
}
}
private Premises? GetPremisesById(string id) => _dbContext.Premises.FirstOrDefault(x => x.Id == id);
private Premises? GetPremisesById(string id) => _dbContext.Premises.FirstOrDefault(x => x.Id == id && !x.IsDeleted);
}

3
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Implementations/WorkerStorageContract.cs
View File

@@ -16,8 +16,7 @@ class WorkerStorageContract : IWorkerStorageContract
_dbContext = dbContext;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Worker, WorkerDataModel>();
cfg.CreateMap<WorkerDataModel, Worker>();
cfg.AddMaps(typeof(Worker));
});
_mapper = new Mapper(config);
}

5
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Models/Customer.cs
View File

@@ -1,7 +1,10 @@
using System.ComponentModel.DataAnnotations.Schema;
using AutoMapper;
using System.ComponentModel.DataAnnotations.Schema;
using TwoFromTheCaseContracts.DataModels;
namespace TwoFromTheCaseDatabase.Models;
[AutoMap(typeof(CustomerDataModel), ReverseMap = true)]
class Customer
{
public required string Id { get; set; }

2
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Models/Post.cs
View File

@@ -4,7 +4,7 @@ namespace TwoFromTheCaseDatabase.Models;
class Post
{
public required string Id { get; set; }
public required string Id { get; set; } = Guid.NewGuid().ToString();
public required string PostId { get; set; }

2
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Models/Work.cs
View File

@@ -4,7 +4,7 @@ namespace TwoFromTheCaseDatabase.Models;
class Work
{
public required string Id { get; set; }
public string Id { get; set; } = Guid.NewGuid().ToString();
public required string PremisesId { get; set; }

5
TwoFromTheCaseProject/TwoFromTheCaseDatabase/Models/Worker.cs
View File

@@ -1,7 +1,10 @@
using System.ComponentModel.DataAnnotations.Schema;
using AutoMapper;
using System.ComponentModel.DataAnnotations.Schema;
using TwoFromTheCaseContracts.DataModels;
namespace TwoFromTheCaseDatabase.Models;
[AutoMap(typeof(WorkerDataModel), ReverseMap = true)]
class Worker
{
public required string Id { get; set; }

5
TwoFromTheCaseProject/TwoFromTheCaseDatabase/TwoFromTheCaseDatabase.csproj
View File

@@ -16,4 +16,9 @@
<ProjectReference Include="..\TwoFromTheCaseContracts\TwoFromTheCaseContracts.csproj" />
</ItemGroup>
<ItemGroup>
<InternalsVisibleTo Include="TwoFromTheCaseTests" />
<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
</ItemGroup>
</Project>

2
TwoFromTheCaseProject/TwoFromTheCaseDatabase/TwoFromTheCaseDbContext.cs
View File

@@ -32,7 +32,7 @@ class TwoFromTheCaseDbContext(IConfigurationDatabase configurationDatabase) : Db
.HasFilter($"\"{nameof(Post.IsActual)}\" = TRUE");
modelBuilder.Entity<Work>()
.HasIndex(x => new { x.Premises, x.IsCancel })
.HasIndex(x => new { x.PremisesId, x.IsCancel })
.IsUnique()
.HasFilter($"\"{nameof(Work.IsCancel)}\" = FALSE");

4
TwoFromTheCaseProject/TwoFromTheCaseTests/BusinessLogicContractsTests/WorkBusinessLogicContractTests.cs
View File

@@ -136,7 +136,7 @@ internal class WorkBusinessLogicContractTests
}
[Test]
public void GetAllWorksByPremisesByPeriod_PremisesIdIsNullOrEmpty_ThrowException_Test()
public void GetAllWorksByPremisesByPeriod_premisesIdIsNullOrEmpty_ThrowException_Test()
{
//Act&Assert
Assert.That(() => _workBusinessLogicContract.GetAllWorksByPremisesByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
@@ -145,7 +145,7 @@ internal class WorkBusinessLogicContractTests
}
[Test]
public void GetAllWorksByPremisesByPeriod_PremisesIdIsNotGuid_ThrowException_Test()
public void GetAllWorksByPremisesByPeriod_premisesIdIsNotGuid_ThrowException_Test()
{
//Act&Assert
Assert.That(() => _workBusinessLogicContract.GetAllWorksByPremisesByPeriod("productId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());

8
TwoFromTheCaseProject/TwoFromTheCaseTests/Infrastructure/ConfigurationDatabaseTest.cs Normal file
View File

@@ -0,0 +1,8 @@
using TwoFromTheCaseContracts.Infrastructure;
namespace TwoFromTheCaseTests.Infrastructure;
class ConfigurationDatabaseTest : IConfigurationDatabase
{
public string ConnectionString => "Host=127.0.0.1;Port=5432;Database=TwoFromTheCaseTest;Username=postgres;Password=postgres;";
}

25
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/BaseStorageContractTest.cs Normal file
View File

@@ -0,0 +1,25 @@
using TwoFromTheCaseDatabase;
using TwoFromTheCaseTests.Infrastructure;
namespace TwoFromTheCaseTests.StoragesContracts;
abstract class BaseStorageContractTest
{
protected TwoFromTheCaseDbContext TwoFromTheCaseDbContext { get; private set; }
[OneTimeSetUp]
public void OneTimeSetUp()
{
TwoFromTheCaseDbContext = new TwoFromTheCaseDbContext(new ConfigurationDatabaseTest());
TwoFromTheCaseDbContext.Database.EnsureDeleted();
TwoFromTheCaseDbContext.Database.EnsureCreated();
}
[OneTimeTearDown]
public void OneTimeTearDown()
{
TwoFromTheCaseDbContext.Database.EnsureDeleted();
TwoFromTheCaseDbContext.Dispose();
}
}

208
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/CustomerStorageContractTests.cs Normal file
View File

@@ -0,0 +1,208 @@
using Microsoft.EntityFrameworkCore;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseContracts.Enums;
using TwoFromTheCaseContracts.Exceptions;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
class CustomerStorageContractTests : BaseStorageContractTest
{
private CustomerStrorageContract _customerStorageContract;
[SetUp]
public void SetUp()
{
_customerStorageContract = new CustomerStrorageContract(TwoFromTheCaseDbContext);
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Premises\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Customers\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString(), phoneNumber: "+5-555-555-55-55");
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString(), phoneNumber: "+6-666-666-66-66");
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString(), phoneNumber: "+7-777-777-77-77");
var list = _customerStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
AssertElement(list.First(x => x.Id == customer.Id), customer);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var list = _customerStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
AssertElement(_customerStorageContract.GetElementById(customer.Id), customer);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
Assert.That(() => _customerStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
}
[Test]
public void Try_GetElementByName_WhenHaveRecord_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
AssertElement(_customerStorageContract.GetElementByName(customer.Name), customer);
}
[Test]
public void Try_GetElementByName_WhenNoRecord_Test()
{
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
Assert.That(() => _customerStorageContract.GetElementByName("New Name"), Is.Null);
}
[Test]
public void Try_GetElementByPhoneNumber_WhenHaveRecord_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
AssertElement(_customerStorageContract.GetElementByPhoneNumber(customer.PhoneNumber), customer);
}
[Test]
public void Try_GetElementByPhoneNumber_WhenNoRecord_Test()
{
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
Assert.That(() => _customerStorageContract.GetElementByPhoneNumber("+8-888-888-88-88"), Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var customer = CreateModel(Guid.NewGuid().ToString());
_customerStorageContract.AddElement(customer);
AssertElement(GetCustomerFromDatabase(customer.Id), customer);
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSameId_Test()
{
var customer = CreateModel(Guid.NewGuid().ToString(), "New Name", "+5-555-555-55-55");
InsertCustomerToDatabaseAndReturn(customer.Id);
Assert.That(() => _customerStorageContract.AddElement(customer), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSamePhoneNumber_Test()
{
var customer = CreateModel(Guid.NewGuid().ToString(), "New Name", "+5-555-555-55-55");
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString(), phoneNumber: customer.PhoneNumber);
Assert.That(() => _customerStorageContract.AddElement(customer), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_UpdElement_Test()
{
var customer = CreateModel(Guid.NewGuid().ToString(), "New Name", "+5-555-555-55-55");
InsertCustomerToDatabaseAndReturn(customer.Id);
_customerStorageContract.UpdElement(customer);
AssertElement(GetCustomerFromDatabase(customer.Id), customer);
}
[Test]
public void Try_UpdElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _customerStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_UpdElement_WhenHaveRecordWithSamePhoneNumber_Test()
{
var customer = CreateModel(Guid.NewGuid().ToString(), "New Name", "+5-555-555-55-55");
InsertCustomerToDatabaseAndReturn(customer.Id, phoneNumber: "+7-777-777-77-77");
InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString(), phoneNumber: customer.PhoneNumber);
Assert.That(() => _customerStorageContract.UpdElement(customer), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_DelElement_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
_customerStorageContract.DelElement(customer.Id);
var element = GetCustomerFromDatabase(customer.Id);
Assert.That(element, Is.Null);
}
[Test]
public void Try_DelElement_WhenHavePremisesByThisCustomer_Test()
{
var customer = InsertCustomerToDatabaseAndReturn(Guid.NewGuid().ToString());
TwoFromTheCaseDbContext.Premises.Add(new Premises() { Id = Guid.NewGuid().ToString(), CustomerId = customer.Id, PremisesType = PremisesType.None, IsDeleted = false });
TwoFromTheCaseDbContext.Premises.Add(new Premises() { Id = Guid.NewGuid().ToString(), CustomerId = customer.Id, PremisesType = PremisesType.None, IsDeleted = false });
TwoFromTheCaseDbContext.SaveChanges();
var PremisesBeforeDelete = TwoFromTheCaseDbContext.Premises.Where(x => x.CustomerId == customer.Id).ToArray();
_customerStorageContract.DelElement(customer.Id);
var element = GetCustomerFromDatabase(customer.Id);
var PremisesAfterDelete = TwoFromTheCaseDbContext.Premises.Where(x => x.CustomerId == customer.Id).ToArray();
Assert.Multiple(() =>
{
Assert.That(element, Is.Null);
Assert.That(PremisesBeforeDelete, Has.Length.EqualTo(2));
Assert.That(PremisesAfterDelete, Is.Empty);
Assert.That(TwoFromTheCaseDbContext.Premises.Count(), Is.EqualTo(0));
});
}
[Test]
public void Try_DelElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _customerStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
}
private Customer InsertCustomerToDatabaseAndReturn(string id, string name = "test", string phoneNumber = "+7-777-777-77-77")
{
var customer = new Customer() { Id = id, Name = name, PhoneNumber = phoneNumber };
TwoFromTheCaseDbContext.Customers.Add(customer);
TwoFromTheCaseDbContext.SaveChanges();
return customer;
}
private static void AssertElement(CustomerDataModel? actual, Customer expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.Name, Is.EqualTo(expected.Name));
Assert.That(actual.PhoneNumber, Is.EqualTo(expected.PhoneNumber));
});
}
private static CustomerDataModel CreateModel(string id, string name = "test", string phoneNumber = "+7-777-777-77-77")
=> new(id, name, phoneNumber);
private Customer? GetCustomerFromDatabase(string id) => TwoFromTheCaseDbContext.Customers.FirstOrDefault(x => x.Id == id);
private static void AssertElement(Customer? actual, CustomerDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.Name, Is.EqualTo(expected.Name));
Assert.That(actual.PhoneNumber, Is.EqualTo(expected.PhoneNumber));
});
}
}

317
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/PostStorageContractTests.cs Normal file
View File

@@ -0,0 +1,317 @@
using Microsoft.EntityFrameworkCore;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseContracts.Enums;
using TwoFromTheCaseContracts.Exceptions;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
internal class PostStorageContractTests : BaseStorageContractTest
{
private PostStorageContract _postStorageContract;
[SetUp]
public void SetUp()
{
_postStorageContract = new PostStorageContract(TwoFromTheCaseDbContext);
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.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_GetList_OnlyActual_Test()
{
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isActual: true);
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isActual: false);
var list = _postStorageContract.GetList(onlyActual: true);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(!list.Any(x => !x.IsActual));
});
}
[Test]
public void Try_GetList_IncludeNoActual_Test()
{
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isActual: true);
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isActual: false);
var list = _postStorageContract.GetList(onlyActual: false);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(3));
Assert.That(list.Count(x => x.IsActual), Is.EqualTo(2));
Assert.That(list.Count(x => !x.IsActual), Is.EqualTo(1));
});
}
[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(), isActual: true);
_postStorageContract.AddElement(post);
AssertElement(GetPostFromDatabaseByPostId(post.Id), post);
}
[Test]
public void Try_AddElement_WhenActualIsFalse_Test()
{
var post = CreateModel(Guid.NewGuid().ToString(), isActual: false);
Assert.That(() => _postStorageContract.AddElement(post), Throws.Nothing);
AssertElement(GetPostFromDatabaseByPostId(post.Id), CreateModel(post.Id, isActual: true));
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSameName_Test()
{
var post = CreateModel(Guid.NewGuid().ToString(), "name unique", isActual: true);
InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), postName: post.PostName, isActual: true);
Assert.That(() => _postStorageContract.AddElement(post), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSamePostIdAndActualIsTrue_Test()
{
var post = CreateModel(Guid.NewGuid().ToString(), isActual: true);
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 = TwoFromTheCaseDbContext.Posts.Where(x => x.PostId == post.Id).OrderByDescending(x => x.ChangeDate);
Assert.That(posts.Count(), Is.EqualTo(2));
AssertElement(posts.First(), CreateModel(post.Id, isActual: true));
AssertElement(posts.Last(), CreateModel(post.Id, isActual: false));
}
[Test]
public void Try_UpdElement_WhenActualIsFalse_Test()
{
var post = CreateModel(Guid.NewGuid().ToString(), isActual: false);
InsertPostToDatabaseAndReturn(post.Id, isActual: true);
_postStorageContract.UpdElement(post);
AssertElement(GetPostFromDatabaseByPostId(post.Id), CreateModel(post.Id, isActual: true));
}
[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.Carpenter, double salary = 10, bool isActual = true, DateTime? changeDate = null)
{
var post = new Post() { Id = Guid.NewGuid().ToString(), PostId = id, PostName = postName, PostType = postType, Salary = salary, IsActual = isActual, ChangeDate = changeDate ?? DateTime.UtcNow };
TwoFromTheCaseDbContext.Posts.Add(post);
TwoFromTheCaseDbContext.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));
Assert.That(actual.Salary, Is.EqualTo(expected.Salary));
Assert.That(actual.IsActual, Is.EqualTo(expected.IsActual));
});
}
private static PostDataModel CreateModel(string postId, string postName = "test", PostType postType = PostType.Carpenter, double salary = 10, bool isActual = false, DateTime? changeDate = null)
=> new(postId, postName, postType, salary, isActual, changeDate ?? DateTime.UtcNow);
private Post? GetPostFromDatabaseByPostId(string id) => TwoFromTheCaseDbContext.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));
Assert.That(actual.Salary, Is.EqualTo(expected.Salary));
Assert.That(actual.IsActual, Is.EqualTo(expected.IsActual));
});
}
}

261
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/PremisesStorageContractTests.cs Normal file
View File

@@ -0,0 +1,261 @@
using Microsoft.EntityFrameworkCore;
using NUnit.Framework.Constraints;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseContracts.Enums;
using TwoFromTheCaseContracts.Exceptions;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
internal class PremisesStorageContractTests : BaseStorageContractTest
{
private PremisesStorageContract _premisesStorageContract;
private Customer _customer;
[SetUp]
public void SetUp()
{
_premisesStorageContract = new PremisesStorageContract(TwoFromTheCaseDbContext);
_customer = InsertCustomerToDatabaseAndReturn();
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Premises\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Customers\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var premises = InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id);
var list = _premisesStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
AssertElement(list.First(x => x.Id == premises.Id), premises);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var list = _premisesStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetList_OnlyActual_Test()
{
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
var list = _premisesStorageContract.GetList(onlyActive: true);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(!list.Any(x => x.IsDeleted));
});
}
[Test]
public void Try_GetList_IncludeNoActual_Test()
{
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
var list = _premisesStorageContract.GetList(onlyActive: false);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(3));
Assert.That(list.Count(x => x.IsDeleted), Is.EqualTo(2));
Assert.That(list.Count(x => !x.IsDeleted), Is.EqualTo(1));
});
}
[Test]
public void Try_GetList_ByCustomer_Test()
{
var customer = InsertCustomerToDatabaseAndReturn("name 2", phoneNumber: "+7-777-777-77-78");
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), customer.Id, isDeleted: false);
var list = _premisesStorageContract.GetList(customerId: _customer.Id, onlyActive: false);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list.All(x => x.CustomerId == _customer.Id));
});
}
[Test]
public void Try_GetList_ByCustomerOnlyActual_Test()
{
var customer = InsertCustomerToDatabaseAndReturn("name 2", phoneNumber: "+7-777-777-77-78");
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), customer.Id, isDeleted: false);
var list = _premisesStorageContract.GetList(customerId: _customer.Id, onlyActive: true);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(1));
Assert.That(list.All(x => x.CustomerId == _customer.Id && !x.IsDeleted));
});
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var premises = InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id);
AssertElement(_premisesStorageContract.GetElementById(premises.Id), premises);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id);
Assert.That(() => _premisesStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
}
[Test]
public void Try_GetElementById_WhenRecordHasDeleted_Test()
{
var premises = InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
Assert.That(() => _premisesStorageContract.GetElementById(premises.Id), Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
_premisesStorageContract.AddElement(premises);
AssertElement(GetPremisesFromDatabaseById(premises.Id), premises);
}
[Test]
public void Try_AddElement_WhenIsDeletedIsTrue_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
Assert.That(() => _premisesStorageContract.AddElement(premises), Throws.Nothing);
AssertElement(GetPremisesFromDatabaseById(premises.Id), CreateModel(premises.Id, _customer.Id, isDeleted: false));
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSameId_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id);
InsertPremisesToDatabaseAndReturn(premises.Id, _customer.Id);
Assert.That(() => _premisesStorageContract.AddElement(premises), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_UpdElement_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
InsertPremisesToDatabaseAndReturn(premises.Id, _customer.Id, isDeleted: false);
_premisesStorageContract.UpdElement(premises);
AssertElement(GetPremisesFromDatabaseById(premises.Id), premises);
}
[Test]
public void Try_UpdElement_WhenIsDeletedIsTrue_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
InsertPremisesToDatabaseAndReturn(premises.Id, _customer.Id, isDeleted: false);
_premisesStorageContract.UpdElement(premises);
AssertElement(GetPremisesFromDatabaseById(premises.Id), CreateModel(premises.Id, _customer.Id, isDeleted: false));
}
[Test]
public void Try_UpdElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _premisesStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString(), _customer.Id)), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_UpdElement_WhenRecordWasDeleted_Test()
{
var premises = CreateModel(Guid.NewGuid().ToString(), _customer.Id);
InsertPremisesToDatabaseAndReturn(premises.Id, _customer.Id, isDeleted: true);
Assert.That(() => _premisesStorageContract.UpdElement(premises), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_DelElement_Test()
{
var premises = InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: false);
_premisesStorageContract.DelElement(premises.Id);
var element = GetPremisesFromDatabaseById(premises.Id);
Assert.Multiple(() =>
{
Assert.That(element, Is.Not.Null);
Assert.That(element!.IsDeleted);
});
}
[Test]
public void Try_DelElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _premisesStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_DelElement_WhenRecordWasDeleted_Test()
{
var premises = InsertPremisesToDatabaseAndReturn(Guid.NewGuid().ToString(), _customer.Id, isDeleted: true);
Assert.That(() => _premisesStorageContract.DelElement(premises.Id), Throws.TypeOf<ElementNotFoundException>());
}
private Customer InsertCustomerToDatabaseAndReturn(string customerName = "name", string phoneNumber = "+7-777-777-77-77")
{
var customer = new Customer() { Id = Guid.NewGuid().ToString(), Name = customerName, PhoneNumber = phoneNumber };
TwoFromTheCaseDbContext.Customers.Add(customer);
TwoFromTheCaseDbContext.SaveChanges();
return customer;
}
private Premises InsertPremisesToDatabaseAndReturn(string id, string customerId, PremisesType premisesType = PremisesType.Commercial, bool isDeleted = false)
{
var premises = new Premises() { Id = id, CustomerId = customerId, PremisesType = premisesType, IsDeleted = isDeleted };
TwoFromTheCaseDbContext.Premises.Add(premises);
TwoFromTheCaseDbContext.SaveChanges();
return premises;
}
private static void AssertElement(PremisesDataModel? actual, Premises expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.CustomerId, Is.EqualTo(expected.CustomerId));
Assert.That(actual.PremisesType, Is.EqualTo(expected.PremisesType));
Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
});
}
private static PremisesDataModel CreateModel(string id, string customerId, PremisesType premisesType = PremisesType.Commercial, bool isDeleted = false)
=> new(id, premisesType, customerId, isDeleted);
private Premises? GetPremisesFromDatabaseById(string id) => TwoFromTheCaseDbContext.Premises.FirstOrDefault(x => x.Id == id);
private static void AssertElement(Premises? actual, PremisesDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.CustomerId, Is.EqualTo(expected.CustomerId));
Assert.That(actual.PremisesType, Is.EqualTo(expected.PremisesType));
Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
});
}
}

149
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/SalaryStorageContractTests.cs Normal file
View File

@@ -0,0 +1,149 @@
using Microsoft.EntityFrameworkCore;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
using TwoFromTheCaseTests.StoragesContracts;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
internal class SalaryStorageContractTests : BaseStorageContractTest
{
private SalaryStorageContract _salaryStorageContract;
private Worker _worker;
[SetUp]
public void SetUp()
{
_salaryStorageContract = new SalaryStorageContract(TwoFromTheCaseDbContext);
_worker = InsertWorkerToDatabaseAndReturn();
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Salaries\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var salary = InsertSalaryToDatabaseAndReturn(_worker.Id, workerSalary: 100);
InsertSalaryToDatabaseAndReturn(_worker.Id);
InsertSalaryToDatabaseAndReturn(_worker.Id);
var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
AssertElement(list.First(), salary);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetList_OnlyInDatePeriod_Test()
{
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1));
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
});
}
[Test]
public void Try_GetList_ByWorker_Test()
{
var worker = InsertWorkerToDatabaseAndReturn("name 2");
InsertSalaryToDatabaseAndReturn(_worker.Id);
InsertSalaryToDatabaseAndReturn(_worker.Id);
InsertSalaryToDatabaseAndReturn(worker.Id);
var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list.All(x => x.WorkerId == _worker.Id));
});
}
[Test]
public void Try_GetList_ByWorkerOnlyInDatePeriod_Test()
{
var worker = InsertWorkerToDatabaseAndReturn("name 2");
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
Assert.That(list, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list.All(x => x.WorkerId == _worker.Id));
});
}
[Test]
public void Try_AddElement_Test()
{
var salary = CreateModel(_worker.Id);
_salaryStorageContract.AddElement(salary);
AssertElement(GetSalaryFromDatabaseByWorkerId(_worker.Id), salary);
}
private Worker InsertWorkerToDatabaseAndReturn(string workerFIO = "fio")
{
var worker = new Worker() { Id = Guid.NewGuid().ToString(), PostId = Guid.NewGuid().ToString(), FIO = workerFIO, IsDeleted = false };
TwoFromTheCaseDbContext.Workers.Add(worker);
TwoFromTheCaseDbContext.SaveChanges();
return worker;
}
private Salary InsertSalaryToDatabaseAndReturn(string workerId, double workerSalary = 1, DateTime? salaryDate = null)
{
var salary = new Salary() { WorkerId = workerId, WorkerSalary = workerSalary, SalaryDate = salaryDate ?? DateTime.UtcNow };
TwoFromTheCaseDbContext.Salaries.Add(salary);
TwoFromTheCaseDbContext.SaveChanges();
return salary;
}
private static void AssertElement(SalaryDataModel? actual, Salary expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
Assert.That(actual.Salary, Is.EqualTo(expected.WorkerSalary));
});
}
private static SalaryDataModel CreateModel(string workerId, double workerSalary = 1, DateTime? salaryDate = null)
=> new(workerId, salaryDate ?? DateTime.UtcNow, workerSalary);
private Salary? GetSalaryFromDatabaseByWorkerId(string id) => TwoFromTheCaseDbContext.Salaries.FirstOrDefault(x => x.WorkerId == id);
private static void AssertElement(Salary? actual, SalaryDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
Assert.That(actual.WorkerSalary, Is.EqualTo(expected.Salary));
});
}
}

300
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/WorkStorageContractTests.cs Normal file
View File

@@ -0,0 +1,300 @@
using Microsoft.EntityFrameworkCore;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseContracts.Exceptions;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
internal class WorkStorageContractTests : BaseStorageContractTest
{
private WorkStorageContract _workStorageContract;
private Worker _worker;
private Customer _customer;
private Premises _premises;
[SetUp]
public void SetUp()
{
_workStorageContract = new WorkStorageContract(TwoFromTheCaseDbContext);
_worker = InsertWorkerToDatabaseAndReturn();
_customer = InsertCustomerToDatabaseAndReturn();
_premises = InsertPremisesToDatabaseAndReturn();
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Customers\" CASCADE;");
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Premises\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id, workers: [(_worker.Id, 1)]);
_premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, workers: [(_worker.Id, 5)]);
var list = _workStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
AssertElement(list.First(x => x.Id == work.Id), work);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var list = _workStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetList_ByPeriod_Test()
{
InsertWorkToDatabaseAndReturn(_premises.Id, startDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), workers: [(_worker.Id, 1)]);
_premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, startDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), workers: [(_worker.Id, 1)]);
_premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, startDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), workers: [(_worker.Id, 1)]);
_premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, startDate: DateTime.UtcNow.AddDays(1).AddMinutes(3), workers: [(_worker.Id, 1)]);
var list = _workStorageContract.GetList(startDate: DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1));
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
}
[Test]
public void Try_GetList_ByWorkerId_Test()
{
var worker = InsertWorkerToDatabaseAndReturn("Other worker");
InsertWorkToDatabaseAndReturn(_premises.Id, workers: [(_worker.Id, 1)]);
_premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, workers: [(_worker.Id, 1)]);
var list = _workStorageContract.GetList(workerId: _worker.Id);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list.All(x => x.Workers.Any(y => y.WorkerId == _worker.Id)));
}
[Test]
public void Try_GetList_ByAllParameters_Test()
{
var worker = InsertWorkerToDatabaseAndReturn("Other worker");
var premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(_premises.Id, startDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), workers: [(_worker.Id, 1)]);
InsertWorkToDatabaseAndReturn(premises.Id, startDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), workers: [(worker.Id, 1)]);
premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(premises.Id, startDate: DateTime.UtcNow.AddDays(1).AddMinutes(3), workers: [(worker.Id, 1)]);
premises = InsertPremisesToDatabaseAndReturn();
InsertWorkToDatabaseAndReturn(premises.Id, startDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), workers: [(_worker.Id, 1)]);
var list = _workStorageContract.GetList(startDate: DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1), workerId: _worker.Id, premisesId: _premises.Id);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(1));
}
[Test]
public void Try_GetHistoryByWorkId_WhenHaveRecords_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id);
InsertWorkHistoryToDatabaseAndReturn(work.Id, 20, DateTime.UtcNow.AddDays(-1));
InsertWorkHistoryToDatabaseAndReturn(work.Id, 30, DateTime.UtcNow.AddMinutes(-10));
InsertWorkHistoryToDatabaseAndReturn(work.Id, 40, DateTime.UtcNow.AddDays(1));
var list = _workStorageContract.GetHistoryByWorkId(work.Id);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
}
[Test]
public void Try_GetHistoryByWorkId_WhenNoRecords_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id);
InsertWorkHistoryToDatabaseAndReturn(work.Id, 20, DateTime.UtcNow.AddDays(-1));
InsertWorkHistoryToDatabaseAndReturn(work.Id, 30, DateTime.UtcNow.AddMinutes(-10));
InsertWorkHistoryToDatabaseAndReturn(work.Id, 40, DateTime.UtcNow.AddDays(1));
var list = _workStorageContract.GetHistoryByWorkId(Guid.NewGuid().ToString());
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id);
AssertElement(_workStorageContract.GetElementById(work.Id), work);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
InsertWorkToDatabaseAndReturn(_premises.Id);
Assert.That(() => _workStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
}
[Test]
public void Try_GetElementById_WhenRecordHasDeleted_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id, isCancel: true);
Assert.That(() => _workStorageContract.GetElementById(work.Id), Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var work = CreateModel(Guid.NewGuid().ToString(), [_worker.Id], _premises.Id, isCancel: false);
_workStorageContract.AddElement(work);
AssertElement(GetWorkFromDatabaseById(work.Id), work);
}
[Test]
public void Try_AddElement_WhenIsCancelIsTrue_Test()
{
var work = CreateModel(Guid.NewGuid().ToString(), [_worker.Id], _premises.Id, isCancel: true);
Assert.That(() => _workStorageContract.AddElement(work), Throws.Nothing);
AssertElement(GetWorkFromDatabaseById(work.Id), CreateModel(work.Id, [_worker.Id], _premises.Id, isCancel: false));
}
[Test]
public void Try_DelElement_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id, isCancel: false);
_workStorageContract.DelElement(work.Id);
var element = GetWorkFromDatabaseById(work.Id);
Assert.Multiple(() =>
{
Assert.That(element, Is.Not.Null);
Assert.That(element!.IsCancel);
});
}
[Test]
public void Try_DelElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _workStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_DelElement_WhenRecordWasDeleted_Test()
{
var work = InsertWorkToDatabaseAndReturn(_premises.Id, isCancel: true);
Assert.That(() => _workStorageContract.DelElement(work.Id), Throws.TypeOf<ElementNotFoundException>());
}
private Worker InsertWorkerToDatabaseAndReturn(string fio = "test")
{
var worker = new Worker() { Id = Guid.NewGuid().ToString(), FIO = fio, PostId = Guid.NewGuid().ToString() };
TwoFromTheCaseDbContext.Workers.Add(worker);
TwoFromTheCaseDbContext.SaveChanges();
return worker;
}
private Customer InsertCustomerToDatabaseAndReturn()
{
var customer = new Customer() { Id = Guid.NewGuid().ToString(), Name = "name", PhoneNumber = "+7-777-777-77-78" };
TwoFromTheCaseDbContext.Customers.Add(customer);
TwoFromTheCaseDbContext.SaveChanges();
return customer;
}
private Premises InsertPremisesToDatabaseAndReturn()
{
var premises = new Premises() { Id = Guid.NewGuid().ToString(), CustomerId = _customer.Id };
TwoFromTheCaseDbContext.Premises.Add(premises);
TwoFromTheCaseDbContext.SaveChanges();
return premises;
}
private Work InsertWorkToDatabaseAndReturn(string premisesId, double price = 1, DateTime? startDate = null, bool isCancel = false, List<(string, int)>? workers = null)
{
var work = new Work() { PremisesId = premisesId, Price = price, StartDate = startDate ?? DateTime.UtcNow, IsCancel = isCancel, WorkerWorks = [] };
if (workers is not null)
{
foreach (var elem in workers)
{
work.WorkerWorks.Add(new WorkerWork { WorkerId = elem.Item1, WorkId = work.Id, Hours = elem.Item2 });
}
}
TwoFromTheCaseDbContext.Works.Add(work);
TwoFromTheCaseDbContext.SaveChanges();
return work;
}
private WorkHistory InsertWorkHistoryToDatabaseAndReturn(string workId, double price, DateTime changeDate)
{
var workHistory = new WorkHistory() { Id = Guid.NewGuid().ToString(), WorkId = workId, OldPrice = price, ChangeDate = changeDate };
TwoFromTheCaseDbContext.WorkHistories.Add(workHistory);
TwoFromTheCaseDbContext.SaveChanges();
return workHistory;
}
private static void AssertElement(WorkDataModel? actual, Work expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.PremisesId, Is.EqualTo(expected.PremisesId));
Assert.That(actual.Price, Is.EqualTo(expected.Price));
Assert.That(actual.IsCancel, Is.EqualTo(expected.IsCancel));
});
if (expected.WorkerWorks is not null)
{
Assert.That(actual.Workers, Is.Not.Null);
Assert.That(actual.Workers, Has.Count.EqualTo(expected.WorkerWorks.Count));
for (int i = 0; i < actual.Workers.Count; ++i)
{
Assert.Multiple(() =>
{
Assert.That(actual.Workers[i].WorkId, Is.EqualTo(expected.WorkerWorks[i].WorkId));
Assert.That(actual.Workers[i].Hours, Is.EqualTo(expected.WorkerWorks[i].Hours));
});
}
}
else
{
Assert.That(actual.Workers, Is.Null);
}
}
private static WorkDataModel CreateModel(string id, List<string> workerIds, string PremisesId, double price = 1, bool isCancel = false)
{
var workers = workerIds.Select(x => new WorkerWorkDataModel(x, id, 1)).ToList();
return new(id, PremisesId, price, isCancel, workers);
}
private Work? GetWorkFromDatabaseById(string id) => TwoFromTheCaseDbContext.Works.FirstOrDefault(x => x.Id == id);
private static void AssertElement(Work? actual, WorkDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.PremisesId, Is.EqualTo(expected.PremisesId));
Assert.That(actual.Price, Is.EqualTo(expected.Price));
Assert.That(actual.IsCancel, Is.EqualTo(expected.IsCancel));
});
if (expected.Workers is not null)
{
Assert.That(actual.WorkerWorks, Is.Not.Null);
Assert.That(actual.WorkerWorks, Has.Count.EqualTo(expected.Workers.Count));
for (int i = 0; i < actual.WorkerWorks.Count; ++i)
{
Assert.Multiple(() =>
{
Assert.That(actual.WorkerWorks[i].WorkId, Is.EqualTo(expected.Workers[i].WorkId));
Assert.That(actual.WorkerWorks[i].Hours, Is.EqualTo(expected.Workers[i].Hours));
});
}
}
else
{
Assert.That(actual.WorkerWorks, Is.Null);
}
}
}

226
TwoFromTheCaseProject/TwoFromTheCaseTests/StoragesContracts/WorkerStorageContractTests.cs Normal file
View File

@@ -0,0 +1,226 @@
using Microsoft.EntityFrameworkCore;
using TwoFromTheCaseContracts.DataModels;
using TwoFromTheCaseContracts.Exceptions;
using TwoFromTheCaseDatabase.Implementations;
using TwoFromTheCaseDatabase.Models;
using TwoFromTheCaseTests.StoragesContracts;
namespace TwoFromTheCaseTests.StoragesContracts;
[TestFixture]
internal class WorkerStorageContractTests : BaseStorageContractTest
{
private WorkerStorageContract _workerStorageContract;
[SetUp]
public void SetUp()
{
_workerStorageContract = new WorkerStorageContract(TwoFromTheCaseDbContext);
}
[TearDown]
public void TearDown()
{
TwoFromTheCaseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1");
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2");
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3");
var list = _workerStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(3));
AssertElement(list.First(), worker);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var list = _workerStorageContract.GetList();
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetList_ByPostId_Test()
{
var postId = Guid.NewGuid().ToString();
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", postId);
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", postId);
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3");
var list = _workerStorageContract.GetList(postId: postId);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list.All(x => x.PostId == postId));
}
[Test]
public void Try_GetList_ByBirthDate_Test()
{
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", birthDate: DateTime.UtcNow.AddYears(-25));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", birthDate: DateTime.UtcNow.AddYears(-21));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", birthDate: DateTime.UtcNow.AddYears(-20));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-19));
var list = _workerStorageContract.GetList(fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1), toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1));
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
}
[Test]
public void Try_GetList_ByEmploymentDate_Test()
{
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", employmentDate: DateTime.UtcNow.AddDays(-2));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", employmentDate: DateTime.UtcNow.AddDays(-1));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", employmentDate: DateTime.UtcNow.AddDays(1));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", employmentDate: DateTime.UtcNow.AddDays(2));
var list = _workerStorageContract.GetList(fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
}
[Test]
public void Try_GetList_ByAllParameters_Test()
{
var postId = Guid.NewGuid().ToString();
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", postId, birthDate: DateTime.UtcNow.AddYears(-25), employmentDate: DateTime.UtcNow.AddDays(-2));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", postId, birthDate: DateTime.UtcNow.AddYears(-22), employmentDate: DateTime.UtcNow.AddDays(-1));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", postId, birthDate: DateTime.UtcNow.AddYears(-21), employmentDate: DateTime.UtcNow.AddDays(-1));
InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-20), employmentDate: DateTime.UtcNow.AddDays(1));
var list = _workerStorageContract.GetList(postId: postId, fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1), toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1), fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(1));
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
AssertElement(_workerStorageContract.GetElementById(worker.Id), worker);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
Assert.That(() => _workerStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
}
[Test]
public void Try_GetElementByFIO_WhenHaveRecord_Test()
{
var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
AssertElement(_workerStorageContract.GetElementByFIO(worker.FIO), worker);
}
[Test]
public void Try_GetElementByFIO_WhenNoRecord_Test()
{
Assert.That(() => _workerStorageContract.GetElementByFIO("New Fio"), Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var worker = CreateModel(Guid.NewGuid().ToString());
_workerStorageContract.AddElement(worker);
AssertElement(GetWorkerFromDatabase(worker.Id), worker);
}
[Test]
public void Try_AddElement_WhenHaveRecordWithSameId_Test()
{
var worker = CreateModel(Guid.NewGuid().ToString());
InsertWorkerToDatabaseAndReturn(worker.Id);
Assert.That(() => _workerStorageContract.AddElement(worker), Throws.TypeOf<ElementExistsException>());
}
[Test]
public void Try_UpdElement_Test()
{
var worker = CreateModel(Guid.NewGuid().ToString(), "New Fio");
InsertWorkerToDatabaseAndReturn(worker.Id);
_workerStorageContract.UpdElement(worker);
AssertElement(GetWorkerFromDatabase(worker.Id), worker);
}
[Test]
public void Try_UpdElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _workerStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_UpdElement_WhenNoRecordWasDeleted_Test()
{
var worker = CreateModel(Guid.NewGuid().ToString());
InsertWorkerToDatabaseAndReturn(worker.Id, isDeleted: true);
Assert.That(() => _workerStorageContract.UpdElement(worker), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_DelElement_Test()
{
var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
_workerStorageContract.DelElement(worker.Id);
var element = GetWorkerFromDatabase(worker.Id);
Assert.That(element, Is.Not.Null);
Assert.That(element.IsDeleted);
}
[Test]
public void Try_DelElement_WhenNoRecordWithThisId_Test()
{
Assert.That(() => _workerStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
}
[Test]
public void Try_DelElement_WhenNoRecordWasDeleted_Test()
{
var worker = CreateModel(Guid.NewGuid().ToString());
InsertWorkerToDatabaseAndReturn(worker.Id, isDeleted: true);
Assert.That(() => _workerStorageContract.DelElement(worker.Id), Throws.TypeOf<ElementNotFoundException>());
}
private Worker InsertWorkerToDatabaseAndReturn(string id, string fio = "test", string? postId = null, DateTime? birthDate = null, DateTime? employmentDate = null, bool isDeleted = false)
{
var worker = new Worker() { Id = id, FIO = fio, PostId = postId ?? Guid.NewGuid().ToString(), BirthDate = birthDate ?? DateTime.UtcNow.AddYears(-20), EmploymentDate = employmentDate ?? DateTime.UtcNow, IsDeleted = isDeleted };
TwoFromTheCaseDbContext.Workers.Add(worker);
TwoFromTheCaseDbContext.SaveChanges();
return worker;
}
private static void AssertElement(WorkerDataModel? actual, Worker expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
});
}
private static WorkerDataModel CreateModel(string id, string fio = "fio", string? postId = null, DateTime? birthDate = null, DateTime? employmentDate = null, bool isDeleted = false) =>
new(id, fio, postId ?? Guid.NewGuid().ToString(), birthDate ?? DateTime.UtcNow.AddYears(-20), employmentDate ?? DateTime.UtcNow, isDeleted);
private Worker? GetWorkerFromDatabase(string id) => TwoFromTheCaseDbContext.Workers.FirstOrDefault(x => x.Id == id);
private static void AssertElement(Worker? actual, WorkerDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
});
}
}

1
TwoFromTheCaseProject/TwoFromTheCaseTests/TwoFromTheCaseTests.csproj
View File

@@ -20,6 +20,7 @@
<ItemGroup>
<ProjectReference Include="..\TwoFromTheCaseBusinessLogic\TwoFromTheCaseBusinessLogic.csproj" />
<ProjectReference Include="..\TwoFromTheCaseContracts\TwoFromTheCaseContracts.csproj" />
<ProjectReference Include="..\TwoFromTheCaseDatabase\TwoFromTheCaseDatabase.csproj" />
</ItemGroup>
<ItemGroup>