using Microsoft.Extensions.Logging;
using Moq;
using SmallSoftwareBusinessLogic.Implementations;
using SmallSoftwareContracts.DataModels;
using SmallSoftwareContracts.Enums;
using SmallSoftwareContracts.Exceptions;
using SmallSoftwareContracts.StoragesContracts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static NUnit.Framework.Internal.OSPlatform;

namespace SmallSoftwareTests.BusinessLogicsContractsTests;

[TestFixture]
internal class SoftwareBusinessLogicContractTests
{
    private SoftwareBusinessLogicContract _softwareBusinessLogicContract;
    private Mock<ISoftwareStorageContract> _softwareStorageContract;
    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        _softwareStorageContract = new Mock<ISoftwareStorageContract>();
        _softwareBusinessLogicContract = new
        SoftwareBusinessLogicContract(_softwareStorageContract.Object, new
        Mock<ILogger>().Object);
    }
    [SetUp]
    public void SetUp()
    {
        _softwareStorageContract.Reset();
    } 
    [Test]
    public void GetAllSoftwares_ReturnListOfRecords_Test()
    {
        //Arrange
        var listOriginal = new List<SoftwareDataModel>()
        {
            new(Guid.NewGuid().ToString(), "name 1", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false),
            new(Guid.NewGuid().ToString(), "name 2", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, true),
            new(Guid.NewGuid().ToString(), "name 3", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false),
        };
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Returns(listOriginal);
        //Act
        var listOnlyActive =
        _softwareBusinessLogicContract.GetAllSoftwares(true);
        var list = _softwareBusinessLogicContract.GetAllSoftwares(false);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(listOnlyActive, Is.Not.Null);
            Assert.That(list, Is.Not.Null);
            Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
            Assert.That(list, Is.EquivalentTo(listOriginal));
        });
        _softwareStorageContract.Verify(x => x.GetList(true, null),
        Times.Once);
        _softwareStorageContract.Verify(x => x.GetList(false, null),
        Times.Once);
    }
    [Test]
    public void GetAllSoftwares_ReturnEmptyList_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Returns([]);
        //Act
        var listOnlyActive =
        _softwareBusinessLogicContract.GetAllSoftwares(true);
        var list = _softwareBusinessLogicContract.GetAllSoftwares(false);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(listOnlyActive, Is.Not.Null);
            Assert.That(list, Is.Not.Null);
            Assert.That(listOnlyActive, Has.Count.EqualTo(0));
            Assert.That(list, Has.Count.EqualTo(0));
        });
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        null), Times.Exactly(2));
    }
    [Test]
    public void GetAllSoftwares_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwares(It.IsAny<bool>()),
        Throws.TypeOf<NullListException>()); 
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetAllSoftwares_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwares(It.IsAny<bool>()),
        Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetAllSoftwaresByManufacturer_ReturnListOfRecords_Test()
    {
        //Arrange
        var manufacturerId = Guid.NewGuid().ToString();
        var listOriginal = new List<SoftwareDataModel>()
        {
        new(Guid.NewGuid().ToString(), "name 1",SoftwareType.Windows,
        Guid.NewGuid().ToString(), 10, false),
        new(Guid.NewGuid().ToString(), "name 2",
        SoftwareType.Windows, Guid.NewGuid().ToString(), 10, true),
        new(Guid.NewGuid().ToString(), "name 3",
        SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false),
        };
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Returns(listOriginal);
        //Act
        var listOnlyActive =
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(manufacturerId, true);
        var list =
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(manufacturerId,
        false);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(listOnlyActive, Is.Not.Null);
            Assert.That(list, Is.Not.Null);
            Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
            Assert.That(list, Is.EquivalentTo(listOriginal));
        });
        _softwareStorageContract.Verify(x => x.GetList(true, manufacturerId),
        Times.Once);
        _softwareStorageContract.Verify(x => x.GetList(false, manufacturerId),
        Times.Once);
    }
    [Test]
    public void GetAllSoftwaresByManufacturer_ReturnEmptyList_Test()
    {
        //Arrange
        var manufacturerId = Guid.NewGuid().ToString();
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Returns([]);
        //Act 
        var listOnlyActive =
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(manufacturerId, true);
        var list =
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(manufacturerId,
        false);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(listOnlyActive, Is.Not.Null);
            Assert.That(list, Is.Not.Null);
            Assert.That(listOnlyActive, Has.Count.EqualTo(0));
            Assert.That(list, Has.Count.EqualTo(0));
        });
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        manufacturerId), Times.Exactly(2));
    }
    [Test]
    public void
    GetAllSoftwaresByManufacturer_ManufacturerIdIsNullOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(null,
        It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(string.Empty,
        It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Never);
    }
    [Test]
    public void
    GetAllSoftwaresByManufacturer_ManufacturerIdIsNotGuid_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer("manufacturerId",
        It.IsAny<bool>()), Throws.TypeOf<ValidationException>());
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Never);
    }
    [Test]
    public void GetAllSoftwaresByManufacturer_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void
    GetAllSoftwaresByManufacturer_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert 
    Assert.That(() =>
    _softwareBusinessLogicContract.GetAllSoftwaresByManufacturer(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x => x.GetList(It.IsAny<bool>(),
        It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareHistoryBySoftware_ReturnListOfRecords_Test()
    {
        //Arrange
        var softwareId = Guid.NewGuid().ToString();
        var listOriginal = new List<SoftwareHistoryDataModel>()
{
new(Guid.NewGuid().ToString(), 10),
new(Guid.NewGuid().ToString(), 15),
new(Guid.NewGuid().ToString(), 10),
};
        _softwareStorageContract.Setup(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>())).Returns(listOriginal);
        //Act
        var list =
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(softwareId);
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.EquivalentTo(listOriginal));
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(softwareId), Times.Once);
    }
    [Test]
    public void GetSoftwareHistoryBySoftware_ReturnEmptyList_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>())).Returns([]);
        //Act
        var list =
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(Guid.NewGuid().ToString(
        ));
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void
    GetSoftwareHistoryBySoftware_SoftwareIdIsNullOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(null),
        Throws.TypeOf<ArgumentNullException>());
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(string.Empty),
        Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>()), Times.Never);
    }
    [Test] 
    public void
    GetSoftwareHistoryBySoftware_SoftwareIdIsNotGuid_ThrowException_Test()
        {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware("softwareId"),
        Throws.TypeOf<ValidationException>());
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>()), Times.Never);
    }
    [Test]
    public void GetSoftwareHistoryBySoftware_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(Guid.NewGuid().ToString(
        )), Throws.TypeOf<NullListException>());
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void
    GetSoftwareHistoryBySoftware_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareHistoryBySoftware(Guid.NewGuid().ToString(
        )), Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x =>
        x.GetHistoryBySoftwareId(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareByData_GetById_ReturnRecord_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        var record = new SoftwareDataModel(id, "name", SoftwareType.Windows,
        Guid.NewGuid().ToString(), 10, false);
        _softwareStorageContract.Setup(x =>
        x.GetElementById(id)).Returns(record);
        //Act
        var element = _softwareBusinessLogicContract.GetSoftwareByData(id);
        //Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.Id, Is.EqualTo(id));
        _softwareStorageContract.Verify(x =>
        x.GetElementById(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareByData_GetByName_ReturnRecord_Test()
    {
        //Arrange
        var name = "name";
        var record = new SoftwareDataModel(Guid.NewGuid().ToString(), name,
        SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false); 
        _softwareStorageContract.Setup(x =>
        x.GetElementByName(name)).Returns(record);
        //Act
        var element = _softwareBusinessLogicContract.GetSoftwareByData(name);
        //Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.SoftwareName, Is.EqualTo(name));
        _softwareStorageContract.Verify(x =>
        x.GetElementByName(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareByData_EmptyData_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData(null),
        Throws.TypeOf<ArgumentNullException>());
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData(string.Empty),
        Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x =>
        x.GetElementByName(It.IsAny<string>()), Times.Never);
        _softwareStorageContract.Verify(x =>
        x.GetElementByName(It.IsAny<string>()), Times.Never);
    }
    [Test]
    public void GetSoftwareByData_GetById_NotFoundRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData(Guid.NewGuid().ToString()),
        Throws.TypeOf<ElementNotFoundException>());
        _softwareStorageContract.Verify(x =>
        x.GetElementById(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareByData_GetByName_NotFoundRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData("name"),
        Throws.TypeOf<ElementNotFoundException>());
        _softwareStorageContract.Verify(x =>
        x.GetElementByName(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void GetSoftwareByData_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        _softwareStorageContract.Setup(x =>
        x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData(Guid.NewGuid().ToString()),
        Throws.TypeOf<StorageException>()); 
        Assert.That(() =>
        _softwareBusinessLogicContract.GetSoftwareByData("name"),
        Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x =>
        x.GetElementById(It.IsAny<string>()), Times.Once);
        _softwareStorageContract.Verify(x =>
        x.GetElementByName(It.IsAny<string>()), Times.Once);
    }
    [Test]
    public void InsertSoftware_CorrectRecord_Test()
    {
        //Arrange
        var flag = false;
        var record = new SoftwareDataModel(Guid.NewGuid().ToString(), "name",
        SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false);
        _softwareStorageContract.Setup(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()))
        .Callback((SoftwareDataModel x) =>
        {
            flag = x.Id == record.Id && x.SoftwareName ==
    record.SoftwareName && x.SoftwareType == record.SoftwareType &&
    x.ManufacturerId == record.ManufacturerId && x.Price ==
    record.Price && x.IsDeleted == record.IsDeleted;
        });
        //Act
        _softwareBusinessLogicContract.InsertSoftware(record);
        //Assert
        _softwareStorageContract.Verify(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()), Times.Once);
        Assert.That(flag);
    }
    [Test]
    public void InsertSoftware_RecordWithExistsData_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>())).Throws(new
        ElementExistsException("Data", "Data"));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.InsertSoftware(new(Guid.NewGuid().ToString(),
        "name", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false)),
        Throws.TypeOf<ElementExistsException>());
        _softwareStorageContract.Verify(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()), Times.Once);
    }
    [Test]
    public void InsertSoftware_NullRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _softwareBusinessLogicContract.InsertSoftware(null),
        Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()), Times.Never);
    }
    [Test]
    public void InsertSoftware_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert 
        Assert.That(() => _softwareBusinessLogicContract.InsertSoftware(new
        SoftwareDataModel("id", "name", SoftwareType.Windows, Guid.NewGuid().ToString(),
        10, false)), Throws.TypeOf<ValidationException>());
        _softwareStorageContract.Verify(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()), Times.Never);
    }
    [Test]
    public void InsertSoftware_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.InsertSoftware(new(Guid.NewGuid().ToString(),
        "name", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false)),
        Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x =>
        x.AddElement(It.IsAny<SoftwareDataModel>()), Times.Once);
    }
    [Test]
    public void UpdateSoftware_CorrectRecord_Test()
    {
        //Arrange
        var flag = false;
        var record = new SoftwareDataModel(Guid.NewGuid().ToString(), "name",
        SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false);
        _softwareStorageContract.Setup(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()))
        .Callback((SoftwareDataModel x) =>
        {
            flag = x.Id == record.Id && x.SoftwareName ==
    record.SoftwareName && x.SoftwareType == record.SoftwareType &&
    x.ManufacturerId == record.ManufacturerId && x.Price ==
    record.Price && x.IsDeleted == record.IsDeleted;
        });
        //Act
        _softwareBusinessLogicContract.UpdateSoftware(record);
        //Assert
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Once);
        Assert.That(flag);
    }
    [Test]
    public void UpdateSoftware_RecordWithIncorrectData_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>())).Throws(new
        ElementNotFoundException(""));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.UpdateSoftware(new(Guid.NewGuid().ToString(),
        "name", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false)),
        Throws.TypeOf<ElementNotFoundException>());
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Once);
    }
    [Test]
 
    public void UpdateSoftware_RecordWithExistsData_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>())).Throws(new
        ElementExistsException("Data", "Data"));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.UpdateSoftware(new(Guid.NewGuid().ToString(),
        "anme", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false)),
        Throws.TypeOf<ElementExistsException>());
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Once);
    }
    [Test]
    public void UpdateSoftware_NullRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _softwareBusinessLogicContract.UpdateSoftware(null),
        Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Never);
    }
    [Test]
    public void UpdateSoftware_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _softwareBusinessLogicContract.UpdateSoftware(new
        SoftwareDataModel("id", "name", SoftwareType.Windows, Guid.NewGuid().ToString(),
        10, false)), Throws.TypeOf<ValidationException>());
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Never);
    }
    [Test]
    public void UpdateSoftware_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.UpdateSoftware(new(Guid.NewGuid().ToString(),
        "name", SoftwareType.Windows, Guid.NewGuid().ToString(), 10, false)),
        Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x =>
        x.UpdElement(It.IsAny<SoftwareDataModel>()), Times.Once);
    }
    [Test]
    public void DeleteSoftware_CorrectRecord_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        var flag = false;
        _softwareStorageContract.Setup(x => x.DelElement(It.Is((string x) => x
        == id))).Callback(() => { flag = true; });
        //Act
        _softwareBusinessLogicContract.DeleteSoftware(id);
        //Assert 
        _softwareStorageContract.Verify(x => x.DelElement(It.IsAny<string>()),
        Times.Once);
        Assert.That(flag);
    }
    [Test]
    public void DeleteSoftware_RecordWithIncorrectId_ThrowException_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        _softwareStorageContract.Setup(x =>
        x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.DeleteSoftware(Guid.NewGuid().ToString()),
        Throws.TypeOf<ElementNotFoundException>());
        _softwareStorageContract.Verify(x => x.DelElement(It.IsAny<string>()),
        Times.Once);
    }
    [Test]
    public void DeleteSoftware_IdIsNullOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _softwareBusinessLogicContract.DeleteSoftware(null),
        Throws.TypeOf<ArgumentNullException>());
        Assert.That(() =>
        _softwareBusinessLogicContract.DeleteSoftware(string.Empty),
        Throws.TypeOf<ArgumentNullException>());
        _softwareStorageContract.Verify(x => x.DelElement(It.IsAny<string>()),
        Times.Never);
    }
    [Test]
    public void DeleteSoftware_IdIsNotGuid_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _softwareBusinessLogicContract.DeleteSoftware("id"),
        Throws.TypeOf<ValidationException>());
        _softwareStorageContract.Verify(x => x.DelElement(It.IsAny<string>()),
        Times.Never);
    }
    [Test]
    public void DeleteSoftware_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _softwareStorageContract.Setup(x =>
        x.DelElement(It.IsAny<string>())).Throws(new StorageException(new
        InvalidOperationException()));
        //Act&Assert
        Assert.That(() =>
        _softwareBusinessLogicContract.DeleteSoftware(Guid.NewGuid().ToString()),
        Throws.TypeOf<StorageException>());
        _softwareStorageContract.Verify(x => x.DelElement(It.IsAny<string>()),
        Times.Once);
    }
}