public void ModelRepositoryGetAllTest()
{
//Arrange
IncludeAllMappings.include();
var vModel = new VehicleModelDomain()
{
Name = "ModelRepositoryUpdateTest", Abrv = "ModelRepositoryUpdateTest", VehicleModelId = Guid.NewGuid(), VehicleMakeId = Guid.Parse("03f3a155-c7a2-e611-9c16-b88687075332")
};
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new ModelRepository(repository);
Task.Run(async() =>
{
var response = await testRepository.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Act
Task.Run(async() =>
{
var result = await testRepository.Add(vModel);
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public void PlaylistsPanelLoad_ShouldCreateOneAssociationControlPerAvailablePlaylist()
{
List<Playlist> playlists = BuildListOfDummyPlaylists(2);
ModelRepository model = new ModelRepository();
model.Add("devices", new DeviceCollection());
MockMediaSoftwareService mockMediaSoftwareService = new MockMediaSoftwareService();
mockMediaSoftwareService.SetPlaylists(playlists);
PlaylistsPanel playlistsPanel = new PlaylistsPanel();
playlistsPanel.MediaSoftwareService = mockMediaSoftwareService;
playlistsPanel.Model = model;
playlistsPanel.PlaylistsPanel_Load(this, null);
int numberOfAssociationControlsCreated = 0;
foreach (Control panelControl in playlistsPanel.FlowPlaylistAssociations.Controls)
{
Console.WriteLine(String.Format("Control type: {0}", panelControl.GetType().ToString()));
if (panelControl is PlaylistAssociationControl)
{
numberOfAssociationControlsCreated++;
}
}
Assert.AreEqual(playlists.Count(), numberOfAssociationControlsCreated);
}
public void Test_method_Add()
{
DbContextMock dbContextMock = new DbContextMock("testAdd");
ModelRepository <ModelTest> modelRepository = new ModelRepository <ModelTest>(dbContextMock as IDbContext);
ModelTest response = modelRepository.Add(Register());
Assert.AreEqual(Register().Id, response.Id);
}
public void GetAllIncludesAllRelationsOfModel()
{
var brand = new Brand();
var model = new Model
{
Brand = brand
};
_sut.Add(model);
var models = _sut.GetAll();
Assert.That(models, Is.Not.Null);
var modelFromDatabase = models.FirstOrDefault(m => m.Id == model.Id);
Assert.That(modelFromDatabase.Brand, Is.EqualTo(brand));
}
public HttpResponseMessage Add(HttpRequestMessage request, Model Model)
{
try
{
using (ModelRepository rep = new ModelRepository())
{
rep.Add(Model);
rep.SaveAll();
}
return(request.CreateResponse <Model>(HttpStatusCode.OK, Model));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não foi possível inserir usuário [" + e.Message + "]"));
}
}
public async Task <JsonResult> Add([FromBody] Model.Model input)
{
await CheckPermission();
if (string.IsNullOrEmpty(input.Name) || string.IsNullOrEmpty(input.ModelType.ToString()))
{
throw new Exception("Some input parameters NULL");
}
var sqlR = new ModelRepository(_logger);
if (input.Id != 0)
{
await sqlR.Update(input);
return(Json(new { message = "Update OK" }));
}
return(Json(await sqlR.Add(input)));
}
private void ModelAddButton_Click(object sender, System.EventArgs e)
{
pictureBox1.Visible = false;
pictureBox2.Visible = false;
bool error = false;
if (modelTextBox.Text.Length == 0)
{
pictureBox1.Visible = true;
error = true;
}
if (brandsDropdown.SelectedIndex == -1)
{
pictureBox2.Visible = true;
error = true;
}
if (error)
{
return;
}
string name = modelTextBox.Text;
Brand b = this.brands[brandsDropdown.SelectedIndex];
if (this.id != 0)
{
ModelRepository.Update(new Model(this.id, name, b));
}
else
{
ModelRepository.Add(new Model(0, name, b));
}
this.Close();
}
/// <summary>
/// Клонирует модель с эквипментмоделями и с чеклистами в новую.
/// </summary>
/// <param name="model"></param>
/// <returns>Тупо данные новой модели без доп сущнастей</returns>
public async Task <Model.Model> CloneModelWithChild(Model.Model model)
{
using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
{
//Создаем ебучую модельку;
var sqlRModel = new ModelRepository(_logger);
var sqlREquipmentModel = new EquipmentModelsRepository(_logger);
var sqlRCheckListEquipment = new CheckListEquipmentsRepository(_logger);
var oldModelId = model.Id;
var newModel = await sqlRModel.Add(model);
//Получим все эквипментымордели для этой хуйни.
var equipmentsModels = await sqlREquipmentModel.ByModelId(oldModelId);
var oldEquipmentsModel = new List <EquipmentModelsWithOldIds>();
foreach (var equipmentsModel in equipmentsModels)
{
var toAdd = new EquipmentModelsWithOldIds();
var oldId = equipmentsModel.Id;
var oldParentId = equipmentsModel.ParentId;
equipmentsModel.ParentId = null;
equipmentsModel.ModelId = newModel.Id;
var cloned = await sqlREquipmentModel.Add(equipmentsModel);
//Мапим эту хуету
toAdd = _mapper.Map <EquipmentModel, EquipmentModelsWithOldIds>(cloned);
toAdd.OldId = oldId;
toAdd.OldParentId = oldParentId;
oldEquipmentsModel.Add(toAdd);
}
foreach (var oldEquipmentModel in oldEquipmentsModel)
{
if (oldEquipmentModel.OldParentId != null)
{
var oldParentElement =
oldEquipmentsModel.FirstOrDefault(e => e.OldId == oldEquipmentModel.OldParentId);
var toUpdate = new EquipmentModel
{
Id = oldEquipmentModel.Id,
EquipmentId = oldEquipmentModel.EquipmentId,
ModelId = newModel.Id,
ParentId = oldParentElement?.Id,
IsMark = oldEquipmentModel.IsMark
};
await sqlREquipmentModel.Update(toUpdate);
}
}
//Терь клонируем нахуй чеклисты.
var checkListsToClone = await sqlRCheckListEquipment.ByEquipmentModelId(oldModelId);
foreach (var checkListToClone in checkListsToClone)
{
checkListToClone.EquipmentModelId = model.Id;
await sqlRCheckListEquipment.Add(checkListToClone);
}
transaction.Complete();
return(newModel);
}
}
public void InsercionBusquedaPersonaTest()
{
// Contexto
DbContext dbContext = BuildTestModelContext();
// Repositorio de personas
IRepository <Persona> repo = new ModelRepository <Persona>(dbContext);
// Creacion
{
Persona persona = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
// Insert into the backend
repo.Add(persona);
}
// Busqueda (exitosa)
{
Persona persona = repo.GetAll(p => p.Rut.Equals("130144918")).FirstOrDefault();
Assert.NotNull(persona);
}
// Busqueda (no exitosa)
{
// Persona persona = repo.GetAll(null).FirstOrDefault();
// Assert.Null(persona);
}
// Busqueda (no exitosa)
{
Persona persona = repo.GetAll(p => p.Rut.Equals("132204810")).FirstOrDefault();
Assert.Null(persona);
}
// Todos
{
IList <Persona> personas = repo.GetAll();
Assert.NotEmpty(personas);
}
// Busqueda por nombre (exito)
{
IList <Persona> personas = repo.GetAll(p => p.Nombre.Equals("Diego"));
Assert.NotEmpty(personas);
}
// Busqueda por nombre (no exito)
{
IList <Persona> personas = repo.GetAll(p => p.Nombre.Equals("Francisco"));
Assert.Empty(personas);
}
// Busqueda por email
{
Assert.NotEmpty(repo.GetAll(p => p.Email.Equals("*****@*****.**")));
}
// Busqueda por rut y email
{
Assert.NotNull(repo.GetAll(p => p.Rut.Equals("130144918")).FirstOrDefault());
Assert.NotNull(repo.GetAll(p => p.Email.Equals("*****@*****.**")).FirstOrDefault());
}
// Eliminacion
{
Persona persona = repo.GetById(1);
Assert.NotNull(persona);
repo.Remove(persona);
}
// Busqueda no exitosa
{
Persona persona = repo.GetById(1);
Assert.Null(persona);
}
}
public void InsercionBusquedaEntidadTest()
{
_output.WriteLine("Starting test ..");
DbContext dbContext = BuildTestModelContext();
IRepository <Entidad> repo = new ModelRepository <Entidad>(dbContext);
// Test add
{
// Entidad de prueba
Entidad entidad = new Entidad()
{
Cortito = 12,
Largo = 120000000,
Valor = 123000,
FechaDeAniversario = DateTime.Now,
NombreDeLaEntidad = "Este es mi nombre"
};
// Debug to output
_output.WriteLine(Utils.ToJson(entidad));
// El id tiene que ser 0
Assert.True(entidad.Id == 0, "Id es != de 0");
// Agrego la entidad
repo.Add(entidad);
// El id tiene que ser 1 (autoincrease)
Assert.True(entidad.Id == 1, "Id es != 1");
}
// Busqueda de las entidades
{
IList <Entidad> entidades = repo.GetAll();
// DEBE existir el elemento que se ingreso.
Assert.Equal(1, entidades.Count);
// El id de la entidad en la base de datos debe ser igual a 1
Assert.True(entidades[0].Id == 1, "Id es != 1");
// Ciclo para obtener todos los elementos en el repositorio
foreach (Entidad e in entidades)
{
Console.WriteLine(Utils.ToJson(e));
}
}
// Get by id (found)
{
Entidad entidad = repo.GetById(1);
Assert.NotNull(entidad);
}
// Get by id (not found)
{
Entidad entidad = repo.GetById(-1);
Assert.Null(entidad);
}
// GetAll with expression
{
IList <Entidad> entidades = repo.GetAll(e => e.Cortito == 12);
Assert.Equal(1, entidades.Count);
}
//Eliminar entidad (exitosa)
{
Entidad entidad = repo.GetById(1);
Assert.NotNull(entidad);
repo.Remove(entidad);
}
//Eliminar entidad (no exitosa)
{
Assert.Throws <ArgumentNullException>(() => repo.Remove(null));
}
_output.WriteLine("Test ended!");
}
public void ModelRepositoryGetTest()
{
//Arrange
//Init repo
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new ModelRepository(repository);
var makeRepository = new MakeRepository(repository);
//Create maker
var vMake = new VehicleMakeDomain()
{
Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest"
};
Task.Run(async() =>
{
var response = await makeRepository.Add(vMake);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Get maker
IEnumerable <IVehicleMakeDomain> getAllMakers = null;
IVehicleMakeDomain targetMaker = null;
Task.Run(async() =>
{
getAllMakers = await makeRepository.GetAll();
Assert.IsNotNull(getAllMakers);
foreach (var item in getAllMakers)
{
targetMaker = item;
}
}).GetAwaiter().GetResult();
//Create model
var vModel = new VehicleModelDomain()
{
Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest", VehicleMakeId = targetMaker.VehicleMakeId
};
//Add model
Task.Run(async() =>
{
var response = await testRepository.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Get model
IEnumerable <IVehicleModelDomain> getAll;
IVehicleModelDomain targetModel = null;
Task.Run(async() =>
{
getAll = await testRepository.GetAll();
Assert.IsNotNull(getAll);
foreach (var item in getAll)
{
targetModel = item;
}
var result = await testRepository.Get(targetModel.VehicleModelId);
//Assert
Assert.AreEqual(targetModel.VehicleModelId, result.VehicleModelId);
}).GetAwaiter().GetResult();
}
