public RecetasPruebaController(DataContext context, IUserHelper userHelper, ICombosHelper combosHelper, IRecetaRepository recetaRepository)
{
_context = context;
_userHelper = userHelper;
_combosHelper = combosHelper;
_recetaRepository = recetaRepository;
}
//public static IMapper Mapper {get; private set;}
#endregion
#region Constructor
/// <summary>
/// Create a new instance of Receta application service
/// </summary>
/// <param name="repository">Repository dependency</param>
public RecetaAppService(IRecetaRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository", ApplicationResources.exception_WithoutRepository);
}
_repositoryReceta = repository;
}
public void Init()
{
IUnityContainer container = new UnityContainer();
container.RegisterType <IRecetaService, RecetaService>();
container.RegisterType <IRecetaRepository, RecetaRepository>();
sut = container.Resolve <IRecetaService>();
recetaRepository = container.Resolve <IRecetaRepository>();
}
public RecetasController(DataContext context,
IRecetaRepository recetaRepository,
ICombosHelper combosHelper,
IConverterHelper converterHelper)
{
_context = context;
_recetaRepository = recetaRepository;
_combosHelper = combosHelper;
_converterHelper = converterHelper;
}
public void init()
{
container = new UnityContainer();
container.RegisterType <IRecetaService, RecetaService>();
container.RegisterType <IRecetaRepository, RecetaRepository>();
container.RegisterType <ITurbomixService, TurbomixService>();
container.RegisterType <IBasculaService, BasculaService>();
container.RegisterType <ICocinaService, CocinaService>();
sut = container.Resolve <IRecetaRepository>();
}
/// <summary>
/// Create a new instance of Receta application service
/// </summary>
/// <param name="repository">Repository dependency</param>
/// <param name="uow">IUnitOfWorkAsync dependency</param>
public RecetaAppService(IRecetaRepository repository, IUnitOfWorkAsync uow)
{
if (repository == null)
{
throw new ArgumentNullException("repository", ApplicationResources.exception_WithoutRepository);
}
_repositoryReceta = repository;
if (uow == null)
{
throw new ArgumentNullException("uow", ApplicationResources.exception_WithoutRepository);
}
_unitOfWorkAsync = uow;
}
public ArtículoService(
IntegraDbContext context,
ILogger <Artículo> logger,
IArtículoRepository artículoRepository,
IInventarioRepository inventarioRepository,
IRecetaRepository recetaRepository,
IAcciónDeInventarioRepository acciónDeInventarioRepository
)
{
_context = context;
_logger = logger;
_artículoRepository = artículoRepository;
_recetaRepository = recetaRepository;
_inventarioRepository = inventarioRepository;
_acciónDeInventarioRepository = acciónDeInventarioRepository;
}
public void AddRecetaCategoriaNoExisteMockTest()
{
var mockRecetaRepository = new Mock <IRecetaRepository>();
IRecetaRepository recetaRepository = mockRecetaRepository.Object;
var mockCategoriaService = new Mock <ICategoriaService>();
ICategoriaService categoriaService = mockCategoriaService.Object;
mockRecetaRepository.Setup(receta => receta.listRecetas()).Returns(() => new List <Receta> {
receta
});
mockCategoriaService.Setup(categoria => categoria.categoria(It.IsAny <String>()))
.Returns((Categoria)null);
sut = new RecetaService(recetaRepository, categoriaService);
sut.addReceta(receta2);
}
public void TestPrepararPlato2()
{
var mockBasculaService = new Mock <IBasculaService>();
var mockCocinaService = new Mock <ICocinaService>();
var mockRecetaRepository = new Mock <IRecetaRepository>();
mockBasculaService.Setup(bascula => bascula.Pesar(It.IsAny <Alimento>())).Returns((Alimento p) => p.Peso);
//mockBasculaService.Setup(bascula => bascula.Pesar(It.IsAny<Alimento>())).Returns(1.5F);
mockCocinaService.Setup(cocina => cocina.Calentar(It.IsAny <Alimento>(), It.IsAny <Alimento>())).
Callback((Alimento p1, Alimento p2) =>
{
p1.Calentado = true;
p2.Calentado = false;
});
IBasculaService basculaService = mockBasculaService.Object;
ICocinaService cocinaService = mockCocinaService.Object;
IRecetaRepository recetaRepository = mockRecetaRepository.Object;
TurbomixService sut = new TurbomixService(basculaService, cocinaService);
Alimento mAlimento1 = new Alimento();
mAlimento1.Nombre = "Curry";
mAlimento1.Peso = 1.5F;
Alimento mAlimento2 = new Alimento();
mAlimento2.Nombre = "Queso";
mAlimento2.Peso = 5F;
Plato resultado = sut.PrepararPlato(mAlimento1, mAlimento2);
mockBasculaService.Verify(bascula => bascula.Pesar(It.IsAny <Alimento>()), Times.AtLeast(2));
mockCocinaService.Verify(cocina => cocina.Calentar(It.IsAny <Alimento>(), It.IsAny <Alimento>()), Times.AtLeast(1));
Plato mPlato = new Plato(mAlimento1, mAlimento2);
Assert.AreEqual(mPlato, resultado);
}
public void Init()
{
//IBasculaService basculaService = new BasculaService();
//ICocinaService cocinaService = new CocinaService();
//IRecetaRepository Recetario = new RecetaRepository();
IUnityContainer container = new UnityContainer();
container.RegisterType <ITurbomixService, TurbomixService>();
container.RegisterType <IRecetaService, RecetaService>();
container.RegisterType <IRecetaRepository, RecetaRepository>();
container.RegisterType <IBasculaService, BasculaService>();
container.RegisterType <ICocinaService, CocinaService>();
ITurbomixService sut = container.Resolve <ITurbomixService>();
IRecetaService recetaService = container.Resolve <IRecetaService>();
IRecetaRepository repo = container.Resolve <IRecetaRepository>();
IBasculaService basculaService = container.Resolve <IBasculaService>();
ICocinaService cocinaService = container.Resolve <ICocinaService>();
//sut = new TurbomixService(basculaService, cocinaService, null);
mAlimento1 = new Alimento();
mAlimento1.Nombre = "Curry";
mAlimento1.Peso = 1.5F;
mAlimento2 = new Alimento();
mAlimento2.Nombre = "Queso";
mAlimento2.Peso = 5F;
mAlimentoReceta1 = new Alimento();
mAlimentoReceta1.Nombre = "Curry";
mAlimentoReceta1.Peso = 1.4F;
mAlimentoReceta1.Calentado = true;
mAlimentoReceta2 = new Alimento();
mAlimentoReceta2.Nombre = "Queso";
mAlimentoReceta2.Peso = 3F;
mAlimentoReceta2.Calentado = true;
receta = new Receta(mAlimentoReceta1, mAlimentoReceta2);
}
public void AddRecetaMockTest()
{
var mockRecetaRepository = new Mock <IRecetaRepository>();
IRecetaRepository recetaRepository = mockRecetaRepository.Object;
var mockCategoriaService = new Mock <ICategoriaService>();
ICategoriaService categoriaService = mockCategoriaService.Object;
mockRecetaRepository.Setup(receta => receta.listRecetas()).Returns(() => new List <Receta> {
receta
});
mockCategoriaService.Setup(categoria => categoria.categoria(It.IsAny <String>()))
.Returns(categoria1);
mockRecetaRepository.Setup(receta => receta.addReceta(receta2));
sut = new RecetaService(recetaRepository, categoriaService);
sut.addReceta(receta2);
mockRecetaRepository.Verify(receta => receta.listRecetas(), Times.Exactly(1));
mockRecetaRepository.Verify(receta => receta.addReceta(It.IsAny <Receta>()), Times.Exactly(1));
}
public RecetaService(IRecetaRepository _recetaRepository)
{
this.recetaRepository = _recetaRepository;
}
public RecetaService(IRecetaRepository recetaRepository, ICategoriaService categoriaService)
{
this.recetaRepository = recetaRepository;
this.categoriaService = categoriaService;
}
public RecetasController(IRecetaRepository recetaRepository, IUserHelper userHelper)
{
this.recetaRepository = recetaRepository;
this.userHelper = userHelper;
}
public RecetaService(IRecetaRepository _Recetario)
{
this.Recetario = _Recetario;
}
public TurbomixService(IBasculaService _Bascula, ICocinaService _Cocina, IRecetaRepository _Recetario)
{
this.Bascula = _Bascula;
this.Cocina = _Cocina;
this.Recetario = _Recetario;
}
public TurboMixService(IBasculaService _Bascula, ICocinaService _Cocina, IRecetaRepository _RecetaRepository)
{
this.basculaService = _Bascula;
this.cocinaService = _Cocina;
this.recetaRepository = _RecetaRepository;
}
public RecetaService(IRecetaRepository _RecetaRepo, ICategoriaService _CategoriaService)
{
this.RecetaRepo = _RecetaRepo;
this.CategoriaService = _CategoriaService;
}
