public void Setup()
{
var claim = new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", _userId.ToString());
Thread.CurrentPrincipal = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim> {
claim
}));
var connectionString = ConfigurationManager.ConnectionStrings["DataContext"].ConnectionString;
_context = new DataContext(connectionString);
_facade = new ParameterFacade(_context);
ODataHelper oDataHelper = new ODataHelper();
_controller = new ParametersController(oDataHelper, _facade);
_controller.Request = new HttpRequestMessage();
_controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
// Setting the URI of the request here is needed for the API POST method to work
_controller.Request.RequestUri = new Uri("http://tempuri.com");
/*
* TODO: akrone - Taking on some Techincal Debt doing this, but pulling the Seeder into it's own project would need to
* be merged into other development work going on for sprint 60
*/
Seeder.SeedWithTestData(_context);
}
private void SetCommonData(Transform trans, string parentPath, string path, ParametersController controller, ObjectData data)
{
data.name = trans.name;
data.parentPath = parentPath == "" ? "" : parentPath.Substring(1);
data.path = path.Substring(1);
data.tag = trans.gameObject.tag;
data.visible = true;
MeshRenderer mesh = trans.GetComponent <MeshRenderer>();
if (null != mesh && !mesh.enabled)
{
data.visible = false;
}
if (trans.gameObject.activeSelf == false)
{
data.visible = false;
}
// Transform
data.position = trans.localPosition;
data.rotation = trans.localRotation;
data.scale = trans.localScale;
if (null != controller)
{
data.lockPosition = controller.lockPosition;
data.lockRotation = controller.lockRotation;
data.lockScale = controller.lockScale;
}
}
public async Task ParametersControllerTerminalTest_GetAnException()
{
// Arrange
MockParametersRepository repository = new MockParametersRepository();
var expectedResult = repository.GetMockData();
IParametersRepository mockRepo = FakeRepository();
IDistributedCache _cache = FakeCache();
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
IStringLocalizer <ParametersController> localizer
= Substitute.For <IStringLocalizer <ParametersController> >();
string key = "GenericError";
string value = "Error occured";
var localizedString = new LocalizedString(key, value);
localizer[Arg.Any <string>()].ReturnsForAnyArgs(localizedString);
IOperation fakeOperation = FakeOperation(_cache);
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IParametersApi dAPI = new ParametersApi(appSettings, mockRepo);
dAPI.GetParameters(null).ThrowsForAnyArgs(new System.Exception());
ParametersController controller = FakeController(_cache, dAPI, localizer, fakeOperation, FakeLogger());
// Act
var dinfo = await controller.GetParameters(null);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo);
// Assert
Assert.Equal(actualRecord.StatusCode, 500);
Assert.Equal(actualRecord.Value, "Error occured");
}
private void BindData()
{
List <ParametersInfo> parameters = (List <ParametersInfo>)ParametersController.GetParameters(ModuleId);
if ((parameters == null) || (parameters.Count == 0))
{
ParametersMessage.Visible = true;
ParametersGrid.Visible = false;
}
else
{
ParametersMessage.Visible = false;
ParametersGrid.Visible = true;
ParametersGrid.DataSource = parameters;
ParametersGrid.DataBind();
ParametersMessage.Visible = false;
HashParameterSet = false;
foreach (ParametersInfo p in parameters)
{
if (p.UseAsHash)
{
HashParameterSet = true;
break;
}
}
}
}
public static void ConfigureMobileApp(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
new MobileAppConfiguration()
.UseDefaultConfiguration()
.ApplyTo(config);
// Use Entity Framework Code First to create database tables based on your DbContext
Database.SetInitializer(new MobileServiceInitializer());
MobileAppSettingsDictionary settings = config.GetMobileAppSettingsProvider().GetMobileAppSettings();
if (string.IsNullOrEmpty(settings.HostName))
{
app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions
{
// This middleware is intended to be used locally for debugging. By default, HostName will
// only have a value when running in an App Service application.
SigningKey = ConfigurationManager.AppSettings["SigningKey"],
ValidAudiences = new[] { ConfigurationManager.AppSettings["ValidAudience"] },
ValidIssuers = new[] { ConfigurationManager.AppSettings["ValidIssuer"] },
TokenHandler = config.GetAppServiceTokenHandler()
});
}
app.UseWebApi(config);
controller = new ParametersController();
}
public void TestInitialize()
{
townRepository.Setup(x => x.GetAll()).Returns(towns.AsQueryable());
eNodebRepository.SetupGet(x => x.GetAll()).Returns(eNodebs.AsQueryable());
controller = new ParametersController(townRepository.Object, eNodebRepository.Object, null, null, null,
regionRepository.Object, null);
helper = new QueryTestHelper(controller, towns, eNodebs);
}
public QueryTestHelper(ParametersController controller, IEnumerable <Town> towns, IEnumerable <ENodeb> eNodebs)
{
this.controller = controller;
this.towns = towns;
this.eNodebs = eNodebs;
ENodebId = 0;
AddressId = 0;
}
private void InitializeControllers()
{
_benchmarksController = new BenchmarksController(this, _view.BenchmarksView);
_parametersController = new ParametersController(this, _view.ParametersView);
_executionController = new ExecutionController(this, _view.ExecutionView);
_resultsController = new ResultsController(this, _view.ResultsView);
_environmentController = new EnvironmentController(this, _view.EnvironmentView);
_asyncWaitController = new AsyncWaitController(this);
_errorHandlingController = new ErrorHandlingController(this);
}
public void TestInitialize()
{
mockTownRepository.Setup(x => x.GetAll()).Returns(towns.AsQueryable());
mockTownRepository.Setup(x => x.GetAllList()).Returns(mockTownRepository.Object.GetAll().ToList());
mockTownRepository.Setup(x => x.Count()).Returns(mockTownRepository.Object.GetAll().Count());
eNodebRepository.SetupGet(x => x.GetAll()).Returns(lotsOfENodebs.AsQueryable());
controller = new ParametersController(mockTownRepository.Object, eNodebRepository.Object, null, null, null,
mockRegionRepository.Object, null);
helper = new ENodebListTestHelper(controller);
}
public void TestInitialize()
{
Mock <ITownRepository> townRepository = new Mock <ITownRepository>();
Mock <IENodebRepository> eNodebRepository = new Mock <IENodebRepository>();
Mock <IRegionRepository> regionRepository = new Mock <IRegionRepository>();
townRepository.Setup(x => x.GetAll()).Returns(towns.AsQueryable());
eNodebRepository.Setup(x => x.GetAll()).Returns(eNodebs.AsQueryable());
controller = new ParametersController(townRepository.Object, eNodebRepository.Object, null, null, null,
regionRepository.Object, null);
}
protected void DeleteButton_Click(object sender, ImageClickEventArgs e)
{
try
{
ImageButton deleteButton = (ImageButton)sender;
if (deleteButton != null)
{
ParametersInfo parameter = ParametersController.GetParameter(Convert.ToInt32(deleteButton.CommandArgument));
ParametersController.DropParameter(parameter);
BindData();
}
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
protected void EditButton_Click(object sender, ImageClickEventArgs e)
{
try
{
ImageButton editButton = (ImageButton)sender;
ParametersInfo parameter = ParametersController.GetParameter(Convert.ToInt32(editButton.CommandArgument));
ParameterTypeDropDownList.SelectedValue = Convert.ToString(Convert.ToInt32(parameter.Type));
ParameterNameTextBox.Text = parameter.Name;
ParameterValueTextBox.Text = parameter.Argument;
UseAsHashCheckBox.Checked = parameter.UseAsHash;
UpdateParameterButton.Text = Localization.GetString("UpdateParameter", LocalResourceFile);
UpdateParameterButton.CommandArgument = editButton.CommandArgument;
DisplayOrHideParameterFormPanels();
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
public void TestGetValueOrDefault()
{
var value = ConfigurationManager.AppSettings["speed"];
Assert.IsNotNull(value);
string result = ParametersController.GetValueOrDefault("test", "TestValue");
Assert.AreEqual("TestValue", result);
result = ParametersController.GetValueOrDefault("speed", "10");
Assert.AreEqual("1", result);
result = ParametersController.GetValueOrDefault("MAP_NUMBER", "16", numericalValue: true);
var numericalResult = Int32.Parse(result);
Assert.AreEqual(40, numericalResult);
result = ParametersController.GetValueOrDefault("SALLE_CLIENT_LOCAL_IP", "10", true);
Assert.AreEqual("10", result);
}
public void Test_Get()
{
//arrange
HttpRequestMessage request = GetRequest("aql.eco/Test/all_objects/odata/Parameters");
ParametersController controller = new ParametersController(_mock.Object)
{
Request = request,
User = GetPrincipal()
};
ODataQueryOptions opts = new ODataQueryOptions <DscQParameter>(new ODataQueryContext(GetEdmModel(), typeof(DscQParameter), new ODataPath()), request);
//act
IQueryable <DscQParameter> result = controller.Get(DataSource, Path);
//assert
Assert.IsNotNull(result);
Assert.AreEqual(result.Count(), 2);
_mock.Verify(d => d.Dispatch <DscQParameterQuery, DscQParameterQueryResult>(It.IsAny <DscQParameterQuery>()), Times.Once());
}
private void SetObjectData(Transform trans, ParametersController controller, ObjectData data)
{
// Mesh for non-imported objects
if (null == controller || !controller.isImported)
{
MeshRenderer meshRenderer = trans.GetComponent <MeshRenderer>();
MeshFilter meshFilter = trans.GetComponent <MeshFilter>();
if (null != meshFilter && null != meshRenderer)
{
// Materials
foreach (Material material in meshRenderer.materials)
{
string materialId = trans.name + "_" + material.name;
GetMaterialPath(currentProjectName, materialId, out string materialAbsolutePath, out string materialRelativePath);
MaterialInfo materialInfo = new MaterialInfo {
relativePath = materialRelativePath, absolutePath = materialAbsolutePath, material = material
};
if (!materials.ContainsKey(materialId))
{
materials.Add(materialId, materialInfo);
}
data.materialsData.Add(new MaterialData(materialInfo));
}
// Mesh
GetMeshPath(currentProjectName, meshFilter.sharedMesh.name, out string meshAbsolutePath, out string meshRelativePath);
meshes[meshRelativePath] = new MeshInfo {
relativePath = meshRelativePath, absolutePath = meshAbsolutePath, mesh = meshFilter.sharedMesh
};
data.meshPath = meshRelativePath;
}
data.isImported = false;
}
else if (null != controller && controller.isImported)
{
data.meshPath = controller.importPath;
data.isImported = true;
}
}
public async Task ParametersControllerTest_TerminalSuccess()
{
// Arrange
int lid = 589547;
MockParametersRepository repository = new MockParametersRepository();
var expectedResult = repository.GetMockData();
IParametersRepository mockRepo = FakeRepository();
IDistributedCache _cache = FakeCache();
IOperation fakeOperation = FakeOperation(_cache);
IParametersApi dAPI = Substitute.For <IParametersApi>();
dAPI.GetParameters(lid).ReturnsForAnyArgs(expectedResult);
ParametersController controller = FakeController(_cache, dAPI, null, fakeOperation, FakeLogger());
// Act
var dinfo = await controller.GetParameters(lid);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo).Value;
// Assert
Assert.Equal(actualRecord, expectedResult.Result);
}
public void ParametersControllerTest_ModelState_Invalid()
{
//Arrange
int lid = 589547;
MockParametersRepository repository = new MockParametersRepository();
var expectedResult = repository.GetMockData();
IParametersRepository mockRepo = FakeRepository();
IDistributedCache _cache = FakeCache();
IOperation fakeOperation = FakeOperation(_cache);
IParametersApi dAPI = Substitute.For <IParametersApi>();
dAPI.GetParameters(lid).ReturnsForAnyArgs(expectedResult);
ParametersController controller = FakeController(_cache, dAPI, null, fakeOperation, FakeLogger());
//Act
controller.ModelState.AddModelError("key", "error message");
var dinfo = controller.GetParameters(lid).Result;
//Assert
Assert.Equal(((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo).StatusCode.ToString(), "400");
}
private void LoadCommonData(GameObject gobject, ObjectData data)
{
if (null != data.tag && data.tag.Length > 0)
{
gobject.tag = data.tag;
}
gobject.transform.localPosition = data.position;
gobject.transform.localRotation = data.rotation;
gobject.transform.localScale = data.scale;
gobject.name = data.name;
if (data.lockPosition || data.lockRotation || data.lockScale)
{
ParametersController controller = gobject.GetComponent <ParametersController>();
if (null == controller)
{
controller = gobject.AddComponent <ParametersController>();
}
controller.lockPosition = data.lockPosition;
controller.lockRotation = data.lockRotation;
controller.lockScale = data.lockScale;
}
}
protected void UpdateParameterButton_Click(object sender, EventArgs e)
{
try
{
LinkButton updateParameterButton = (LinkButton)sender;
ParametersInfo parameter;
if (updateParameterButton.CommandArgument == "-1")
{
parameter = new ParametersInfo();
}
else
{
parameter = ParametersController.GetParameter(Convert.ToInt32(updateParameterButton.CommandArgument));
}
parameter.ModuleID = ModuleId;
parameter.Type = (ParameterType)Convert.ToInt32(ParameterTypeDropDownList.SelectedValue);
parameter.Name = ParameterNameTextBox.Text;
parameter.Argument = (ParameterValuePanel.Visible ? ParameterValueTextBox.Text : null);
parameter.UseAsHash = UseAsHashCheckBox.Checked;
if (updateParameterButton.CommandArgument == "-1")
{
ParametersController.AddParameter(parameter);
}
else
{
ParametersController.ChangeParameter(parameter);
}
ResetParametersForm(true);
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
private void TraverseScene(Transform root, string parentPath)
{
foreach (Transform currentTransform in root)
{
if (currentTransform == SceneManager.BoundingBox)
{
continue;
}
string path = parentPath;
path += "/" + currentTransform.name;
// Depending on its type (which controller we can find on it) create data objects to be serialized
LightController lightController = currentTransform.GetComponent <LightController>();
if (null != lightController)
{
LightData lightData = new LightData();
SetCommonData(currentTransform, parentPath, path, lightController, lightData);
SetLightData(lightController, lightData);
SceneData.Current.lights.Add(lightData);
continue;
}
CameraController cameraController = currentTransform.GetComponent <CameraController>();
if (null != cameraController)
{
CameraData cameraData = new CameraData();
SetCommonData(currentTransform, parentPath, path, cameraController, cameraData);
SetCameraData(cameraController, cameraData);
SceneData.Current.cameras.Add(cameraData);
continue;
}
ColimatorController colimatorController = currentTransform.GetComponent <ColimatorController>();
if (null != colimatorController)
{
// Nothing to do here, ignore the object
continue;
}
// Do this one at the end, because other controllers inherits from ParametersController
ParametersController controller = currentTransform.GetComponent <ParametersController>();
ObjectData data = new ObjectData();
SetCommonData(currentTransform, parentPath, path, controller, data);
try
{
SetObjectData(currentTransform, controller, data);
SceneData.Current.objects.Add(data);
}
catch (Exception e)
{
Debug.Log("Failed to set object data: " + e.Message);
}
// Serialize children
if (!data.isImported)
{
TraverseScene(currentTransform, path);
}
}
}
public ENodebListTestHelper(ParametersController controller)
{
this.controller = controller;
}
private void LoadObject(ObjectData data)
{
GameObject gobject;
string absoluteMeshPath;
Transform importedParent = null;
// Check for import
if (data.isImported)
{
try
{
importedParent = new GameObject("__VRtist_tmp_load__").transform;
absoluteMeshPath = data.meshPath;
// Don't use async import since we may reference the game object for animations or constraints
// and the object must be loaded before we do so
GlobalState.GeometryImporter.ImportObject(absoluteMeshPath, importedParent, true);
if (importedParent.childCount == 0)
{
return;
}
gobject = importedParent.GetChild(0).gameObject;
}
catch (System.Exception e)
{
Debug.LogError("Failed to load external object: " + e.Message);
return;
}
}
else
{
absoluteMeshPath = GetSaveFolderPath(currentProjectName) + data.meshPath;
gobject = new GameObject(data.name);
}
LoadCommonData(gobject, data);
gobject.name = data.name;
// Mesh
if (null != data.meshPath && data.meshPath.Length > 0)
{
if (!data.isImported)
{
if (!loadedMeshes.TryGetValue(absoluteMeshPath, out Mesh mesh))
{
MeshData meshData = new MeshData();
SerializationManager.Load(absoluteMeshPath, meshData);
mesh = meshData.CreateMesh();
loadedMeshes.Add(absoluteMeshPath, mesh);
}
gobject.AddComponent <MeshFilter>().sharedMesh = mesh;
gobject.AddComponent <MeshRenderer>().materials = LoadMaterials(data);
gobject.AddComponent <MeshCollider>();
}
if (!data.visible)
{
foreach (Component component in gobject.GetComponents <Component>())
{
Type componentType = component.GetType();
var prop = componentType.GetProperty("enabled");
if (null != prop)
{
prop.SetValue(component, data.visible);
}
}
}
}
SceneManager.AddObject(gobject);
if (data.parentPath.Length > 0)
{
SceneManager.SetObjectParent(gobject, rootTransform.Find(data.parentPath).gameObject);
}
if (data.isImported)
{
ParametersController controller = gobject.AddComponent <ParametersController>();
controller.isImported = true;
controller.importPath = data.meshPath;
if (null != importedParent)
{
Destroy(importedParent.gameObject);
}
}
}
