// Use this for initialization
void Start () {
_materialsController = GameObject.Find ("MaterialsCanvas").GetComponent<MaterialsController> ();
Debug.Assert (_materialsController != null);
GetComponent<Outline> ().enabled = false;
}
public void DeleteMaterial_Deleted_NotFail_Test()
{
bool called = false;
var expectedmaterial = new Material()
{
MaterialId = 1, SessionId = 1
};
int organizerId = 10;
ISessionRepository sessionRepository = new StubISessionRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository()
{
DeleteInt32 = materialId =>
{
Assert.AreEqual(expectedmaterial.MaterialId, materialId);
called = true;
},
GetOrganizerIdInt32 = materialId =>
{
return(organizerId);
}
};
using (ShimsContext.Create())
{
MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
myeventToken.RegisteredUserIdGet = () => { return(organizerId); };
ShimMyEventsToken.GetTokenFromHeader = () => { return(myeventToken); };
var target = new MaterialsController(materialRepository, sessionRepository);
target.Delete(expectedmaterial.MaterialId);
Assert.IsTrue(called);
}
}
public void GetMaterials_NotFail_Test()
{
bool called = false;
var expected = new Material()
{
MaterialId = 10
};
ISessionRepository sessionRepository = new StubISessionRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository()
{
GetInt32 = materialId =>
{
Assert.AreEqual(expected.MaterialId, materialId);
called = true;
return(expected);
}
};
var target = new MaterialsController(materialRepository, sessionRepository);
Material actual = target.Get(expected.MaterialId);
Assert.IsTrue(called);
}
void Start()
{
_brushController = GameObject.Find("Brush").GetComponent <BrushController> ();
_segments = new Dictionary <IntVector3, GameObject> (new IntVector3.EqualityComparer());
_marchingCubesEngine = GameObject.Find("MarchingCubesEngine").GetComponent <MarchingCubesEngine> ();
Debug.Assert(_marchingCubesEngine != null);
_colorPicker = GameObject.Find("ColorPicker").GetComponent <ColorPicker> ();
_runtimeTranslation = GameObject.Find("RuntimeTranslation").GetComponent <RuntimeTranslation> ();
_editorState = GameObject.Find("UICanvas").GetComponent <EditorState> ();
_materialsController = GameObject.Find("MaterialsCanvas").GetComponent <MaterialsController> ();
Debug.Assert(_materialsController != null);
int width = 2 * EDITOR_SPACE_HALF_WIDTH + 1;
_editSpace = new int[width, width, width];
if (use_lerp_color)
{
GenNearestVoxelPointForEdgePointTable();
}
else
{
GenNearestVoxelPointTable();
}
_meshRenderer = GetComponent <MeshRenderer> ();
}
public void DeleteMaterial_UnauthorizedException_Test()
{
var expectedmaterial = new Material()
{
MaterialId = 1, SessionId = 1
};
int organizerId = 10;
ISessionRepository sessionRepository = new StubISessionRepository()
{
GetOrganizerIdInt32 = (sessionId) =>
{
return(organizerId);
}
};
IMaterialRepository materialRepository = new StubIMaterialRepository()
{
GetInt32 = materialId =>
{
return(expectedmaterial);
}
};
using (ShimsContext.Create())
{
MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
myeventToken.RegisteredUserIdGet = () => { return(100000); };
ShimMyEventsToken.GetTokenFromHeader = () => { return(myeventToken); };
var target = new MaterialsController(materialRepository, sessionRepository);
target.Delete(expectedmaterial.MaterialId);
}
}
public void GetAllMaterials_GetResults_NotFail_Test()
{
int expectedSessionId = 10;
bool called = false;
var expected = new List <Material>()
{
new Material()
};
ISessionRepository sessionRepository = new StubISessionRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository()
{
GetAllInt32 = sessionId =>
{
Assert.AreEqual(expectedSessionId, sessionId);
called = true;
return(expected);
}
};
var target = new MaterialsController(materialRepository, sessionRepository);
IEnumerable <Material> actual = target.GetAllMaterials(expectedSessionId);
Assert.IsTrue(called);
Assert.AreEqual(expected.Count, actual.Count());
}
public void GetAllSubcategoriesTest_Success()
{
var meterials = new List <Material> {
new Material(), new Material()
};
var materialRepository = new Mock <IMaterialRepository>();
materialRepository.Setup(mr => mr.GetAllMaterialsForSubcategoryAsync(1))
.Returns(Task.FromResult(meterials));
var mapper = new Mock <IMapper>();
mapper.Setup(m => m.Map <List <Material>, List <MaterialResource> >(It.IsAny <List <Material> >()))
.Returns(new List <MaterialResource> {
new MaterialResource(), new MaterialResource()
});
var materialsController = new MaterialsController(materialRepository.Object, mapper.Object);
var materialsResult = materialsController.GetAllMaterials(1).Result;
materialRepository.Verify(mr => mr.GetAllMaterialsForSubcategoryAsync(1));
mapper.Verify(m => m.Map <List <Material>, List <MaterialResource> >(meterials));
CollectionAssert.IsNotEmpty(materialsResult);
}
void Start()
{
GenNearestVoxelPointForEdgePointTable();
_materialsController = GameObject.Find("MaterialsCanvas").GetComponent <MaterialsController> ();
Debug.Log("init MarchingCubesEngine");
}
public ToysListForm(ToyFactoryContext toyFactoryContext)
{
_toysController = new ToysController(toyFactoryContext);
_materialController = new MaterialsController(toyFactoryContext);
InitializeComponent();
InitToys();
}
public Form1()
{
InitializeComponent();
_context = new ToyFactoryContext();
_materialsController = new MaterialsController(_context);
backgroundWorker1.WorkerReportsProgress = true;
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
public MaterialsForm(MaterialsController materialsController)
{
_materialsController = materialsController;
InitializeComponent();
// InitHeaders();
SettupEvents();
InsertDataFromRepository();
}
public void PostMaterial_ArgumentNullException_Test()
{
ICommentRepository commentRepository = new StubICommentRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository();
IEventDefinitionRepository eventRepository = new StubIEventDefinitionRepository();
ISessionRepository sessionRepository = new StubISessionRepository();
var target = new MaterialsController(materialRepository, sessionRepository);
target.Post(null);
}
public void BeforeTest()
{
var builder = new DbContextOptionsBuilder <MaterialContext>();
builder.EnableSensitiveDataLogging();
builder.UseInMemoryDatabase("testmaterial");
var context = new MaterialContext(builder.Options);
var repository = new MaterialRepository(context);
this.controller = new(
Mock.Of <ILogger <MaterialsController> >(),
repository);
Assert.IsNotNull(this.controller);
}
void Start ()
{
_editorState = GameObject.Find ("UICanvas").GetComponent<EditorState> ();
_materialsController = GameObject.Find ("MaterialsCanvas").GetComponent<MaterialsController> ();
int width = 2 * EDITOR_SPACE_HALF_WIDTH + 1;
_editSpace = new int[width, width, width];
if (use_lerp_color) {
GenNearestVoxelPointForEdgePointTable ();
} else {
GenNearestVoxelPointTable ();
}
}
public async Task PostMaterial_Success()
{
var dbContext = _fixture.Context;
var material = new MaterialCreateRequest {
Name = "Test material"
};
var controller = new MaterialsController(dbContext);
var result = await controller.PostMaterial(material);
var createdActionResult = Assert.IsType <CreatedAtActionResult>(result.Result);
var returnValue = Assert.IsType <MaterialVm>(createdActionResult.Value);
Assert.Equal("Tests material", returnValue.Name);
}
public async Task GetMaterial_Success()
{
var dbContext = _fixture.Context;
dbContext.Materials.Add(new Material {
Name = "Test material"
});
await dbContext.SaveChangesAsync();
var controller = new MaterialsController(dbContext);
var result = await controller.GetMaterials();
var actionResult = Assert.IsType <ActionResult <IEnumerable <MaterialVm> > >(result);
Assert.NotEmpty(actionResult.Value);
}
public async Task <IActionResult> CreateDocFromRecTrans(int id)
{
if (id <= 0)
{
return(BadRequest(error: new { Message = "Id must be grater than 0" }));
}
var recDef = await _context.RecurringTransDocs
.Include(p => p.DocLines)
.SingleOrDefaultAsync(p => p.Id == id);
if (recDef == null)
{
return(NotFound(
new
{
Message = "Recurring transaction definition not found"
}));
}
IActionResult actionResult;
switch (recDef.RecurringDocType)
{
case RecurringDocTypeEnum.BuyType:
var buyDocDto = _mapper.Map <BuyDocCreateAjaxDto>(recDef);
var buyUpdController = new MaterialsController(_context, _mapper);
actionResult = await CreateBuyDocFromRecTrans(buyDocDto, recDef);
break;
case RecurringDocTypeEnum.SellType:
var sellDocDto = _mapper.Map <SellDocCreateAjaxDto>(recDef);
var sellUpdController = new MaterialsController(_context, _mapper);
actionResult = await CreateSellDocFromRecTrans(sellDocDto, recDef);
break;
default:
throw new ArgumentOutOfRangeException();
}
var rsJson = actionResult.ToJson();
return(Ok(actionResult));
}
void Start()
{
_editorState = GameObject.Find("UICanvas").GetComponent <EditorState> ();
_materialsController = GameObject.Find("MaterialsCanvas").GetComponent <MaterialsController> ();
int width = 2 * EDITOR_SPACE_HALF_WIDTH + 1;
_editSpace = new int[width, width, width];
if (use_lerp_color)
{
GenNearestVoxelPointForEdgePointTable();
}
else
{
GenNearestVoxelPointTable();
}
}
public async Task UpdateMaterialValidModelWithOkResult()
{
// Arrange & Act
var mockRepo = new Mock <IRepository>();
var controller = new MaterialsController(mockRepo.Object, _logger);
var fiberCementMaterial = new Material {
MaterialId = 181818, Name = "Fiber / Cement"
};
mockRepo.Setup(repo => repo.Update(fiberCementMaterial)).Returns(Task.FromResult(181818));
// Act
var fiberCementModel = JobAssistantMapper.Map <MaterialModel>(fiberCementMaterial);
var result = await controller.UpdateMaterial(181818, fiberCementModel);
// Assert
Assert.IsType <OkResult>(result);
_logger.Log(LogLevel.Debug, 0, "Logging exeution of method UpdateMaterialValidModelWithOkResult", null,
null);
}
public async Task UpdateMaterial_Success()
{
var dbContext = _fixture.Context;
Material oldMaterial = new Material {
Name = "Test material"
};
await dbContext.Materials.AddAsync(oldMaterial);
await dbContext.SaveChangesAsync();
MaterialUpdateRequest newMaterial = new MaterialUpdateRequest {
Name = "Test1 material"
};
var controller = new MaterialsController(dbContext);
var result = await controller.PutMaterial(1, newMaterial);
var updatAtActionResult = Assert.IsType <OkObjectResult>(result.Result);
var resultValue = Assert.IsType <MaterialUpdateRequest>(updatAtActionResult.Value);
Assert.Equal(oldMaterial.Name, resultValue.Name);
Assert.Equal(oldMaterial.Name, newMaterial.Name);
}
public async Task CreateMaterialValidModelWithBadResult()
{
// Arrange & Act
var mockRepo = new Mock <IRepository>();
var controller = new MaterialsController(mockRepo.Object, _logger);
var woodAndWoodComposities = new Material {
Name = "Wood / Wood Composites"
};
mockRepo.Setup(repo => repo.Create(woodAndWoodComposities))
.Returns(Task.FromResult(woodAndWoodComposities));
// Act
var materialModel = JobAssistantMapper.Map <MaterialModel>(woodAndWoodComposities);
var result = await controller.CreateMaterial(materialModel);
// Assert
Assert.IsType <OkResult>(result);
_logger.Log(LogLevel.Debug, 0, "Logging exeution of method CreateMaterialValidModelWithBadResult", null,
null);
}
public async Task DeleteMaterial_Success()
{
var dbContext = _fixture.Context;
Material material = new Material {
Name = "Test material"
};
await dbContext.Materials.AddAsync(material);
await dbContext.SaveChangesAsync();
var materialsController = new MaterialsController(dbContext);
// Act
var result = await materialsController.DeleteMaterial(material.ID);
// Assert
var deleteAtActionResult = Assert.IsType <NoContentResult>(result.Result);
await Assert.ThrowsAsync <Exception>(async() =>
{
await materialsController.GetMaterial(material.ID);
});
}
public void MaterialsController_Contructor_SessionArgumentNullException_Test()
{
ISessionRepository sessionRepository = new StubISessionRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository();
var target = new MaterialsController(materialRepository, null);
}
// Use this for initialization
void Start()
{
inst = this;
}
public void MaterialsController_Contructor_NotFail_Test()
{
ISessionRepository sessionRepository = new StubISessionRepository();
IMaterialRepository materialRepository = new StubIMaterialRepository();
var target = new MaterialsController(materialRepository, sessionRepository);
}
// Use this for initialization
void Start()
{
_materialsController = GameObject.Find("MaterialsCanvas").GetComponent <MaterialsController> ();
Debug.Assert(_materialsController != null);
GetComponent <Outline> ().enabled = false;
}
