621 lines
24 KiB
C#
621 lines
24 KiB
C#
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);
|
|
}
|
|
}
|
|
|