public void Update_computer_name()
{
ComputersController computersController = new ComputersController();
_managementController.AddComputer(new AddComputerDto
{
Name = "TestComputer",
Description = "New computer",
Price = 1500,
ImageFilename = "test.png"
});
ComputerInfoDto computerInfoDto = computersController.FindComputerByName("TestComputer");
UpdateComputerDto updateComputerDto = new UpdateComputerDto
{
Name = "Amstrad CPC",
Description = "New Amstrad with 128Kb",
Price = 1000,
ImageFilename = "amstrad.png"
};
_managementController.UpdateComputer(computerInfoDto.Id, updateComputerDto);
ComputerInfoDto updatedComputer = computersController.GetComputerInfo(computerInfoDto.Id);
Assert.AreEqual(computerInfoDto.Id, updatedComputer.Id);
Assert.AreEqual(updateComputerDto.Name, updatedComputer.Name);
Assert.AreEqual(updateComputerDto.Description, updatedComputer.Description);
Assert.AreEqual(updateComputerDto.Price, updatedComputer.Price);
Assert.AreEqual(updateComputerDto.ImageFilename, updatedComputer.ImageFilename);
}
public void Raise_an_error_when_adding_a_computer_to_existing_order_with_negative_quantity()
{
ComputersController computersController = new ComputersController();
ComputerInfoDto computerInfoDto = computersController.FindComputerByName("MacBook Pro 15");
NewOrderDto newOrderDto = new NewOrderDto
{
OrderLines = new List <NewOrderLineDto> {
new NewOrderLineDto {
ComputerId = computerInfoDto.Id, Quantity = 1
}
},
};
NewOrderIdDto newOrderIdDto = ordersController.CreateNewOrder(newOrderDto);
Assert.IsNotNull(newOrderIdDto);
Exception exception = Assert.Throws <Exception>(() =>
ordersController.AddComputerToOrder(newOrderIdDto.Id, new AddComputersToOrderDto
{
OrderLines = new List <AddOrderLineDto> {
new AddOrderLineDto {
ComputerId = computerInfoDto.Id, Quantity = -1
}
},
}));
Assert.AreEqual("Computer quantity cannot be negative", exception.Message);
}
public void Raise_an_error_when_searching_image_info_of_non_existing_computer()
{
ComputersController computersController = new ComputersController();
Exception exception = Assert.Throws <Exception>(() => computersController.GetComputerImage("unknown_guid"));
Assert.AreEqual("Computer not found, guid: unknown_guid", exception.Message);
}
public void Create_new_order_with_one_computer()
{
ComputersController computersController = new ComputersController();
ComputerInfoDto computerInfoDto = computersController.FindComputerByName("MacBook Pro 15");
int computerQuantity = 1;
Decimal expectedPrice = computerInfoDto.Price;
List <OrderInformationDto> orders = ordersController.All();
int previousNumberOfItems = orders.Count;
NewOrderDto newOrderDto = new NewOrderDto
{
OrderLines = new List <NewOrderLineDto> {
new NewOrderLineDto {
ComputerId = computerInfoDto.Id, Quantity = computerQuantity
}
}
};
NewOrderIdDto newOrderIdDto = ordersController.CreateNewOrder(newOrderDto);
Assert.IsNotNull(newOrderIdDto);
orders = ordersController.All();
OrderInformationDto order = ordersController.All().First(ord => ord.OrderId == newOrderIdDto.Id);
Assert.AreEqual(previousNumberOfItems + 1, orders.Count);
List <OrderLineInfoDto> newOrderOrderLinesInfo = order.OrderLinesInfo;
Assert.AreEqual(1, newOrderOrderLinesInfo.Count);
Assert.AreEqual(computerInfoDto.Id, newOrderOrderLinesInfo.First().ComputerId);
Assert.AreEqual(computerQuantity, newOrderOrderLinesInfo.First().Quantity);
Assert.AreEqual(expectedPrice, order.Price);
}
public void Add_second_computer_to_existing_order()
{
ComputersController computersController = new ComputersController();
ComputerInfoDto computerInfoDto = computersController.FindComputerByName("MacBook Pro 15");
Decimal expectedPrice = computerInfoDto.Price;
NewOrderDto newOrderDto = new NewOrderDto
{
OrderLines = new List <NewOrderLineDto> {
new NewOrderLineDto {
ComputerId = computerInfoDto.Id, Quantity = 1
}
}
};
NewOrderIdDto newOrderIdDto = ordersController.CreateNewOrder(newOrderDto);
Assert.IsNotNull(newOrderIdDto);
ComputerInfoDto secondComputerInfoDto = computersController.FindComputerByName("iMac 27");
expectedPrice += secondComputerInfoDto.Price * 2;
ordersController.AddComputerToOrder(newOrderIdDto.Id, new AddComputersToOrderDto
{
OrderLines = new List <AddOrderLineDto> {
new AddOrderLineDto {
ComputerId = secondComputerInfoDto.Id, Quantity = 2
}
}
});
OrderInformationDto orderInformationDto = ordersController.GetOrderInformation(newOrderIdDto.Id);
Assert.AreEqual(2, orderInformationDto.OrderLinesInfo.Count);
Assert.AreEqual(computerInfoDto.Id, orderInformationDto.OrderLinesInfo[0].ComputerId);
Assert.AreEqual(secondComputerInfoDto.Id, orderInformationDto.OrderLinesInfo[1].ComputerId);
Assert.AreEqual(expectedPrice, orderInformationDto.Price);
}
public void Delete_NonExistingCAProd_ShouldReturnErrorAndResult()
{
// Arrange.
var controller = new ComputersController();
controller.Request = HttpRequestHandler.GenerateHttpRequestMessage();
string serverName = TestConstants.NonExistingComputerAccountToDeleteProd;
string environment = TestConstants.ProductionEnvironment;
string projectName = TestConstants.ExistingOrganizationalUnitProd;
string siteName = TestConstants.SitePrimary;
var caRequest = new ComputerAccountRequest()
{
serverName = serverName,
environment = environment,
projectName = projectName,
siteName = siteName
};
var expected = ComputerAccountResultGenerator.GenerateResultForNonExistingCADeleteProd(siteName);
// Act.
var result =
controller.Delete(serverName, TestConstants.checkpointAdminAcccessToken);
// Assert.
Assert.IsNotNull(result);
var caResult = result.Content.ReadAsAsync <ComputerAccountResult>().Result;
Assert.AreEqual(expected.action, caResult.action);
Assert.AreEqual(expected.message, caResult.message);
Assert.AreEqual(expected.objectADPath, caResult.objectADPath);
Assert.AreEqual(expected.serverName, caResult.serverName);
}
public void Delete_existing_order()
{
ComputersController computersController = new ComputersController();
string macBookId = computersController.FindComputerByName("MacBook Pro 15").Id;
string imacId = computersController.FindComputerByName("iMac 27").Id;
NewOrderDto newOrderDto = new NewOrderDto
{
OrderLines = new List <NewOrderLineDto>
{
new NewOrderLineDto {
ComputerId = macBookId, Quantity = 2
},
new NewOrderLineDto {
ComputerId = imacId, Quantity = 2
}
}
};
OrdersController ordersController = new OrdersController("emilybeck", "password1");
NewOrderIdDto orderIdDto = ordersController.CreateNewOrder(newOrderDto);
Assert.IsTrue(ordersController.All().Exists(order => order.OrderId.Equals(orderIdDto.Id)));
_managementController.DeleteOrder(orderIdDto.Id);
List <OrderInformationDto> allOrders = ordersController.All();
Assert.IsFalse(allOrders.Exists(order => order.OrderId.Equals(orderIdDto.Id)));
}
public void Get_GetComputer_ValidateReturn(Computer computer)
{
//Given
using (var context = new HardwareContext(_options))
{
context.Computers.Add(computer);
context.SaveChanges();
}
//When
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Computers.Count());
}
ActionResult <Computer> result;
//Then
using (var context = new HardwareContext(_options))
{
var computersController = new ComputersController(context);
result = computersController.Get(computer.Id);
}
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var value = Assert.IsType <Computer>(okResult.Value);
Assert.Equal(computer, value, new ModelEqualityComparer <Computer>());
}
public ComputersControllerTests()
{
_mapperMock = new Mock <IMapper>();
_computersServiceMock = new Mock <IComputersService>();
_graphicsCardsServiceMock = new Mock <IGraphicsCardsService>();
_urlHelperMock = new Mock <IUrlHelper>();
_controller = new ComputersController(_computersServiceMock.Object, _graphicsCardsServiceMock.Object, _urlHelperMock.Object, _mapperMock.Object);
}
public void GetComputersByUser_ShouldOnlyReturnComputersOfTheUser()
{
var context = GetDemoContext();
var controller = new ComputersController(context);
var result = controller.GetComputers("686990B4-3263-4566-9713-27666E894AF3") as IQueryable <Computer>;
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count());
}
public void Get_a_list_of_all_computers()
{
ComputersController computersController = new ComputersController();
string expectedComputerName = "MacBook Pro 15";
List <ComputerInfoDto> computers = computersController.All();
Assert.AreEqual(5, computers.Count);
Assert.AreEqual(expectedComputerName, computers.First().Name);
}
public void GetComputers_ShouldReturnAllComputers()
{
var context = GetDemoContext();
var controller = new ComputersController(context);
var result = controller.GetComputers() as TestComputerDbSet;
Assert.IsNotNull(result);
Assert.AreEqual(context.Computers.Local.Count, result.Local.Count);
}
public void Get_computer_detailed_information_by_guid()
{
ComputersController computersController = new ComputersController();
string computerName = "MacBook Pro 15";
ComputerInfoDto computer = computersController.FindComputerByName(computerName);
Assert.AreEqual(computerName, computer.Name);
Assert.AreEqual("Macbook pro 15' Description", computer.Description);
Assert.AreEqual(1500, computer.Price);
}
public void Raise_an_error_when_searching_a_non_existing_computer()
{
ComputersController computersController = new ComputersController();
string computerName = "Unknown";
Exception exception = Assert.Throws <Exception>(() => computersController.FindComputerByName(computerName));
Assert.AreEqual("Computer not found, name: Unknown", exception.Message);
exception = Assert.Throws <Exception>(() => computersController.GetComputerInfo("unknownid"));
Assert.AreEqual("Computer not found, Id: unknownid", exception.Message);
}
public void Get_ShouldReturnWelcomeMessage()
{
// Arrange.
var controller = new ComputersController();
controller.Request = HttpRequestHandler.GenerateHttpRequestMessage();
var expected = "Welcome to Wind API! - ComputersController";
// Act.
var result = controller.Get();
// Assert.
Assert.IsNotNull(result);
var getResult = result.Content.ReadAsAsync <string>().Result;
Assert.AreEqual(expected, getResult);
}
public void RunCommand_InvalidTokenServerCommand_ShouldReturnForbidden()
{
// Arrange.
var controller = new ComputersController();
controller.Request = HttpRequestHandler.GenerateHttpRequestMessage();
var expected = ExecutionResultGenerator.GenerateExecutionResultForInvalidTokenServerCommand();
// Act.
var result = controller.RunCommand(TestConstants.invalidServerName, TestConstants.checkpointNonAdminAcccessToken, CommandRequestGenerator.GenerateValidCommandRequest_InvalidServerAndCommand());
// Assert.
Assert.IsNotNull(result);
var executionResult = result.Content.ReadAsAsync <ExecutionResult>().Result;
Assert.AreEqual(expected.commandExitCode, executionResult.commandExitCode);
Assert.AreEqual(expected.resultMessage, executionResult.resultMessage);
Assert.AreEqual(expected.resultError, executionResult.resultError);
}
public void Create_new_computer()
{
ComputersController computersController = new ComputersController();
int numberOfComputers = computersController.All().Count;
_managementController.AddComputer(new AddComputerDto
{
Name = "TestComputer",
Description = "New computer",
Price = 1500,
ImageFilename = "test.png"
});
var allComputers = computersController.All();
int currentNumberOfComputers = allComputers.Count;
Assert.AreEqual(numberOfComputers + 1, currentNumberOfComputers);
Assert.IsNotNull(allComputers.First(comp => comp.Name == "TestComputer"));
}
public void Delete_computer()
{
ComputersController computersController = new ComputersController();
_managementController.AddComputer(new AddComputerDto
{
Name = "TestComputer",
Description = "New computer",
Price = 1500,
ImageFilename = "test.png"
});
ComputerInfoDto computerInfoDto = computersController.FindComputerByName("TestComputer");
_managementController.DeleteComputer(computerInfoDto.Id);
Exception exception = Assert.Throws <Exception>(() => computersController.GetComputerInfo("TestComputer"));
Assert.AreEqual("Computer not found, Id: TestComputer", exception.Message);
}
public void TestGetComputerById()
{
var mockRepo = new Mock <IComputer>();
mockRepo.Setup(repo => repo.GetComputerByID("AAA")).Returns(Startup.gettestsession("AAA"));
//var mockRepo = new Mock<IUser>();
//mockRepo.Setup(repo => repo.GetUserByID(1)).Returns(Startup.gettestsession(1));
var controller = new ComputersController(mockRepo.Object);
string expectedName = "computer AAA";
var result = controller.GetComputer("AAA");
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var com = Assert.IsType <Computer>(okResult.Value);
Assert.Equal(expectedName, com.Cpuname);
}
public void Post_InsertComputer_ValidateExists(Computer computer)
{
using (var context = new HardwareContext(_options))
{
var computersController = new ComputersController(context);
computersController.PostBody(computer);
}
using (var context = new HardwareContext(_options))
{
Assert.Equal(1, context.Computers.Count());
Assert.Equal(computer, context.Computers.Include(c => c.Disks)
.Include(c => c.Gpus)
.ThenInclude(g => g.Memory)
.Include(c => c.Memories)
.Include(c => c.MotherBoard)
.Include(c => c.Processor)
.Single(), new ModelEqualityComparer <Computer>());
}
}
public void Get_computer_image()
{
ComputersController computersController = new ComputersController();
string computerName = "iMac 27";
string [] expectedResult =
{
" ",
" * * * **** ****** ",
" ** ** *** *** * * * ",
" ** * ** * * * * * ",
" * * * **** * **** * ",
" * * * * * * * * ",
" *** * * **** *** ****** * ",
" "
};
ComputerInfoDto computerInfo = computersController.FindComputerByName(computerName);
ComputerImageInfoDto imageInfo = computersController.GetComputerImage(computerInfo.Id);
imageInfo.Content.ForEach(Console.WriteLine);
Assert.AreEqual(expectedResult, imageInfo.Content);
}
public void Post_NewCAInNewOUProd_ShouldReturnSuccessAndResult()
{
// Arrange.
var controller = new ComputersController();
controller.Request = HttpRequestHandler.GenerateHttpRequestMessage();
string serverName = TestConstants.NewComputerAccountProd;
string environment = TestConstants.ProductionEnvironment;
string projectName = TestConstants.NewOrganizationalUnitProd;
string siteName = TestConstants.SitePrimary;
var caRequest = new ComputerAccountRequest()
{
serverName = serverName,
environment = environment,
projectName = projectName,
siteName = siteName
};
var expected = ComputerAccountResultGenerator.GenerateResultForNewCAInProd(true, siteName);
// Act.
var result = controller.Post(TestConstants.checkpointAdminAcccessToken, caRequest);
// Cleanup.
ActiveDirectory.DeleteOrganizationalUnitTreeVoid(environment, projectName);
// Assert.
Assert.IsNotNull(result);
var caResult = result.Content.ReadAsAsync <ComputerAccountResult>().Result;
Assert.AreEqual(expected.action, caResult.action);
Assert.AreEqual(expected.message, caResult.message);
Assert.AreEqual(expected.objectADPath, caResult.objectADPath);
Assert.AreEqual(expected.serverName, caResult.serverName);
}
