/// <summary>
/// コントローラの初期化
/// </summary>
private void initGorillaController()
{
gameManager = GameObject.FindObjectOfType <GameManager>();
playerMoveController = GameObject.Find(PathMaster.DOG_MOVE_CONTROLLER).GetComponent <PlayerMoveController>();
attackController = GameObject.Find(PathMaster.ATTACK_CONTROLLER).GetComponent <AttackController>();
sweetController = GameObject.Find(PathMaster.SWEET_CONTROLLER).GetComponent <SweetController>();
sensorController = GameObject.Find(PathMaster.SENSOR_CONTROLLER).GetComponent <SensorController>();
skillController = GameObject.Find(PathMaster.SKILL_CONTROLLER).GetComponent <SkillController>();
mainCamera = Camera.main;
CameraController cameraController = mainCamera.GetComponent <CameraController>();
cameraController.Player = this.gameObject;
cameraController.InitCameraController();
cameraAnimator = mainCamera.GetComponent <Animator>();
this.FixedUpdateAsObservable()
.Where(_ => isInBattleState())
.Subscribe(x => playerBehavior());
this.FixedUpdateAsObservable()
.Where(x => attackController.GetAttackable() && isInBattleState())
.Subscribe(_ => gorillaAttack());
this.FixedUpdateAsObservable()
.Where(x => sweetController.GetUsable() && isInBattleState())
.Subscribe(_ => useSweet());
this.FixedUpdateAsObservable()
.Where(x => sensorController.GetUsable() && isInBattleState())
.Subscribe(_ => useSensor());
this.FixedUpdateAsObservable()
.Where(x => skillController.GetSkillUsable() && isInBattleState())
.Subscribe(_ => useSkill());
}
public async Task ReturnCorrectViewModel_WhenCalled()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validId = string.Empty;
UserSensor validUserSensorResult = new UserSensor();
Sensor validSensor = new Sensor
{
IsState = false
};
validUserSensorResult.Sensor = validSensor;
validUserSensorResult.Latitude = "0";
validUserSensorResult.Longitude = "0";
userSensorServiceMock.Setup(mock => mock.GetSensorByIdAsync(validId))
.Returns(Task.FromResult(validUserSensorResult));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
var result = await SUT.Modify(validId) as ViewResult;
// Assert
Assert.IsInstanceOfType(result.Model, typeof(ModifyViewModel));
}
public void NotAddNewMeasurementsIntoTheDatabase_IfGetAllSensorsLastValuesFromSensorDbServiceReturnsEmptyCollection()
{
// Arrange
// arrange controller
Mock <ApplicationDbContext> mockApplicationDbContext = new Mock <ApplicationDbContext>();
Mock <SensorDbService> mockSensorDbService = new Mock <SensorDbService>(mockApplicationDbContext.Object);
Mock <HttpClient> mockHttpClient = new Mock <HttpClient>();
Mock <SensorApiService> mockSensorApiService = new Mock <SensorApiService>(mockHttpClient.Object);
SensorController sensorController = new SensorController(mockSensorDbService.Object, mockSensorApiService.Object);
// arrange GetAllSensorsLastValues in mockSensorDbService
IEnumerable <LastValueReadFromDbcs> expected = new List <LastValueReadFromDbcs>();
mockSensorDbService.Setup(x => x.GetAllSensorsLastValues())
.Returns(expected);
// act
var test = sensorController.UpdateSensorsValues();
//assert
mockSensorDbService.Verify(x => x.AddNewMeasurementsToDb(It.IsAny <ICollection <Measurement> >()), Times.Never);
}
/// <summary>
/// Initializes a new instance of the <see cref="CCS811IoT"/> class.
/// </summary>
/// <param name="controller">The sensor controller.</param>
/// <param name="deviceId">Override the default device id.</param>
public CCS811IoT(SensorController controller, byte deviceId)
{
this.Controller = controller;
this.DeviceId = deviceId;
this.Messages = new List <string>();
this.SensorName = "CCS811_IoTDriver";
}
public async Task <bool> Connect()
{
bool returnValue = false;
try
{
// ***
// *** Get the device at the default address
// ***
this.Device = await SensorController.GetI2CDevice <IMcp9808>(Mcp9808Address.Default, I2cBusSpeed.FastMode);
if (this.Device != null)
{
if (await this.Device.Initialize() == InitializationResult.Successful)
{
this.Device.AlertEnabled = true;
this.Device.AlertOutputPolarity = Mcp9808AlertOutputPolarity.ActiveHigh;
this.Device.AlertOutputSelect = Mcp9808AlertOutputSelect.All;
this.Device.AlertOutputMode = Mcp9808AlertOutputMode.ComparatorMode;
this.Device.LowerTemperatureThreshold = this.ApplicationSettingsRepository.LowerTemperatureThreshold;
this.Device.UpperTemperatureThreshold = this.ApplicationSettingsRepository.UpperTemperatureThreshold;
this.Device.CriticalTemperatureThreshold = this.ApplicationSettingsRepository.CriticalTemperatureThreshold;
this.Device.ClearInterrupt();
returnValue = true;
}
}
}
catch (Exception ex)
{
this.EventAggregator.GetEvent <Events.DebugEvent>().Publish(new DebugEventArgs(ex));
}
return(returnValue);
}
public async Task CallFilterSensorsAsync_WhenInvoked()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <UserSensor> userSensors = new PagedList <UserSensor>(new List <UserSensor>().AsQueryable(), validPageNumber, validPageSize);
userSensorServiceMock.Setup(mock => mock.FilterUserSensorsAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(Task.FromResult(userSensors));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
await SUT.Filter(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>());
// Assert
userSensorServiceMock
.Verify(mock => mock.FilterUserSensorsAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()),
Times.Once);
}
public async Task CallGetSensorByIdAsync_WhenInvoked()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validId = string.Empty;
UserSensor validUserSensorResult = new UserSensor();
Sensor validSensor = new Sensor
{
IsState = false
};
validUserSensorResult.Sensor = validSensor;
validUserSensorResult.Latitude = "0";
validUserSensorResult.Longitude = "0";
userSensorServiceMock.Setup(mock => mock.GetSensorByIdAsync(validId))
.Returns(Task.FromResult(validUserSensorResult));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
await SUT.Modify(validId);
// Assert
userSensorServiceMock.Verify(mock => mock.GetSensorByIdAsync(validId), Times.Once);
}
public IList <AttachmentController> DiscoverNearbyAttachable(float distance)
{
SensorController sensors = GetComponent <SensorController>();
if (!sensors)
{
return(EmptyAttachments);
}
float dist2 = distance * distance;
List <AttachmentController> result = new List <AttachmentController>();
IDictionary <int, SensorController.Entry> sensorEntries = sensors.GetEntries();
foreach (KeyValuePair <int, SensorController.Entry> pair in sensorEntries)
{
if (!pair.Value.Visible)
{
continue;
}
AttachmentController attachment = pair.Value.Object;
Vector4 pos = attachment.transform.position;
if (Vector4.Dot(pos, pos) > dist2)
{
continue;
}
result.Add(attachment);
}
return(result);
}
public void ReturnEditSensorView_WhenSensorByIdIsValid()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
var httpClientMock = new Mock <HttpClientProvider>();
var controller = new SensorController(sensorServiceMock.Object,
httpClientMock.Object);
controller.UserMocking("test");
var sensor = new SensorDataModel()
{
OwnerId = It.IsAny <string>()
};
sensorServiceMock.Setup(s => s.GetUserSensorById(It.IsAny <int>()))
.Returns(sensor);
// Act
controller.EditSensor(It.IsAny <int>());
// Assert
controller.WithCallTo(c => c.EditSensor(It.IsAny <int>()))
.ShouldRenderView("EditSensor");
}
public async Task CallLisNontStateSensorsAsync_WhenInvoked()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validUserId = Guid.NewGuid().ToString();
IEnumerable <Sensor> stateSensors = new List <Sensor>();
IEnumerable <Sensor> nonStateSensors = new List <Sensor>();
sensorServiceMock.Setup(mock => mock.ListStateSensorsAsync())
.Returns(Task.FromResult(stateSensors));
sensorServiceMock.Setup(mock => mock.ListStateSensorsAsync())
.Returns(Task.FromResult(nonStateSensors));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
await SUT.Register(validUserId);
// Assert
sensorServiceMock.Verify(mock => mock.ListNonStateSensorsAsync(), Times.Once);
}
protected override void CheckPullingObjects()
{
SensorController sensors = GetComponent <SensorController>();
if (sensors == null)
{
return;
}
IDictionary <int, SensorController.Entry> entries = sensors.GetEntries();
for (int i = PullingTogether.Count - 1; i >= 0; i--)
{
PullTogether pull = PullingTogether[i];
int id = pull.Attachment.gameObject.GetInstanceID();
if (!entries.ContainsKey(id))
{
PullingTogether.RemoveAt(i);
continue;
}
SensorController.Entry entry = entries[id];
if (!entry.Visible)
{
PullingTogether.RemoveAt(i);
continue;
}
}
base.CheckPullingObjects();
}
public async Task ReturnCorrectViewModel_WhenInvoked()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <UserSensor> userSensors = new PagedList <UserSensor>(new List <UserSensor>().AsQueryable(), validPageNumber, validPageSize);
userSensorServiceMock.Setup(mock => mock.FilterUserSensorsAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(Task.FromResult(userSensors));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
var result = await SUT.Filter(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()) as PartialViewResult;
// Assert
Assert.IsInstanceOfType(result.Model, typeof(TableViewModel <SensorTableViewModel>));
}
public async Task ThrowApplicationException_WhenPassedUserSensorIsNull()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validId = string.Empty;
UserSensor validUserSensorResult = null;
userSensorServiceMock.Setup(mock => mock.GetSensorByIdAsync(validId))
.Returns(Task.FromResult(validUserSensorResult));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <ApplicationException>(() =>
SUT.Modify(validId));
}
public void ReturnRedirectResult_WhenModelStateIsValid()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
var controller = new SensorController(userSensorServiceMock.Object,
sensorServiceMock.Object, memoryCacheMock.Object, sensorDataServiceMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal()
}
},
TempData = new Mock <ITempDataDictionary>().Object
};
var viewModel = new ModifyViewModel()
{
Name = "Name",
Description = "Description",
PollingInterval = 10,
Latitude = 0,
Longitude = 0,
IsPublic = true,
AlarmTriggered = true,
AlarmMin = 0,
AlarmMax = 0,
Id = "Description",
IsState = true,
};
string validId = viewModel.Id;
UserSensor validUserSensorResult = new UserSensor();
Sensor validSensor = new Sensor
{
IsState = false
};
validUserSensorResult.Sensor = validSensor;
validUserSensorResult.Latitude = "0";
validUserSensorResult.Longitude = "0";
userSensorServiceMock.Setup(mock => mock.GetSensorByIdAsync(validId))
.Returns(Task.FromResult(validUserSensorResult));
// Act
var result = controller.Modify(viewModel);
//Assert
Assert.IsInstanceOfType(result.Result, typeof(RedirectToActionResult));
var redirectResult = (RedirectToActionResult)result.Result;
Assert.AreEqual("Modify", redirectResult.ActionName);
Assert.IsNull(redirectResult.RouteValues);
}
void Start()
{
isDogWin = false;
isCatWin = false;
catJewelCount = 0;
initObtainedObjectCounts();
popupMessage = GameObject.FindObjectOfType <GamePopupMessage>();
if (PhotonManager.Instance.NowPlayerType == PlayerType.Cat)
{
dogMoveController.SetActive(false);
catMoveCotroller.SetActive(true);
jewelImages = catJewelImages;
}
else
{
dogMoveController.SetActive(true);
catMoveCotroller.SetActive(false);
jewelImages = dogJewelImages;
}
sweetController = GameObject.FindObjectOfType <SweetController>();
sensorController = GameObject.FindObjectOfType <SensorController>();
// 攻撃したオブジェクトを購読
attackedObserve();
// 獲得したオブジェクトを購読
obtainedObserve();
//とりあえず即座にゲーム始まる
startBattle();
}
static void Main(string[] args)
{
#region Instanciamento Singletons e Menus
//Nota:A razão de instancionamento de singletons aqui é muito simples, não as proteji de multithreading, e program bootup so existe uma thread, aka, nunca instancia 2 vezes
MQTTHandler mqtt = MQTTHandler.Instance;
UserController sqlUser = UserController.Instance;
SQLAssistant sqlAss = SQLAssistant.Instance;
SensorController sqlSensor = SensorController.Instance;
LocationController sqlLocation = LocationController.Instance;
LoginController sqlLogin = LoginController.Instance;
AlertController sqlAlert = AlertController.Instance;
Menus menu = new Menus();
DataController sqlData = DataController.Instance;
#endregion
SQLAssistant.Instance.ReseedTable("t_generated_alerts");
SQLAssistant.Instance.ReseedTable("t_alerts");
while (true)
{
if (sqlLogin.isLogged)
{
menu.MainMenu();
}
else
{
menu.LoginMenu();
}
}
}
public void ReturnGetValueModel()
{
var sensorId = Guid.Parse(SENSOR_ONE_ID);
var nameValueType = "NAMEVALUETYPE1";
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetAll()).Returns(GetSensorsValueTypes);
var valueType = GetSensorsValueTypes()
.FirstOrDefault(r => r.SensorId == sensorId && r.Name == nameValueType.ToUpper());
Assert.NotNull(valueType);
var sensorValuesRepo = new Mock <IValuesRepository>();
sensorValuesRepo.Setup(s => s.GetValues(valueType.Id))
.Returns(GetValues().Where(v => v.ValueTypeId == valueType.Id).ToArray);
var _sensorsManager = new SensorsManager(null, sensorValueTypeRepo.Object, sensorValuesRepo.Object);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.GetValue(sensorId, nameValueType).Result;
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <SensorValuesList>(viewResult.ViewData.Model);
Assert.Equal(valueType.SensorId, model.SensorId);
Assert.Equal(valueType.Name, model.ValueName);
Assert.Equal(valueType.Type, model.ValueType);
Assert.Equal(valueType.Values.Count(), model.Values.Count());
}
public void ReturnInfoModel(string id)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(sensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == sensorId));
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetValueTypesForSensor(sensorId))
.Returns(GetSensorsValueTypes().Where(v => v.SensorId == sensorId).ToArray);
var _sensorsManager = new SensorsManager(sensorRepo.Object, sensorValueTypeRepo.Object, null);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.Info(sensorId).Result;
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <SensorInfoViewModel>(viewResult.ViewData.Model);
var expectedSensorInfo = GetSensors().FirstOrDefault(s => s.Id == sensorId);
Assert.NotNull(expectedSensorInfo);
Assert.Equal(expectedSensorInfo.Id, model.Id);
Assert.Equal(expectedSensorInfo.Description, model.Description);
Assert.Equal(expectedSensorInfo.Name, model.Name);
Assert.Equal(expectedSensorInfo.Values.Count(), model.Values.Count());
}
public void RedisplayView_WhenPassedInvalidModelState()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
var controller = new SensorController(userSensorServiceMock.Object,
sensorServiceMock.Object, memoryCacheMock.Object, sensorDataServiceMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal()
}
},
TempData = new Mock <ITempDataDictionary>().Object
};
controller.ModelState.AddModelError("error", "error");
var viewModel = new RegisterViewModel();
// Act
var result = controller.Register(viewModel);
// Assert
Assert.IsInstanceOfType(result.Result, typeof(ViewResult));
var viewResult = (ViewResult)result.Result;
Assert.IsInstanceOfType(viewResult.Model, typeof(RegisterViewModel));
Assert.IsNull(viewResult.ViewName); // should not return any other view
}
public void ReturnDefaultViewWithCorrectViewModel()
{
// Arrange
// arrange controller
Mock <ApplicationDbContext> mockApplicationDbContext = new Mock <ApplicationDbContext>();
Mock <SensorDbService> mockSensorDbService = new Mock <SensorDbService>(mockApplicationDbContext.Object);
Mock <HttpClient> mockHttpClient = new Mock <HttpClient>();
Mock <SensorApiService> mockSensorApiService = new Mock <SensorApiService>(mockHttpClient.Object);
// arrange publicSensors
SensorDisplayData sensorDisplayData1 = new SensorDisplayData();
SensorDisplayData sensorDisplayData2 = new SensorDisplayData();
List <SensorDisplayData> expected = new List <SensorDisplayData>();
expected.Add(sensorDisplayData1);
expected.Add(sensorDisplayData2);
// arrange mockSensorDbService
mockSensorDbService.Setup(x => x.ListPublicSensorsFromDB())
.Returns(expected);
SensorController sensorController = new SensorController(mockSensorDbService.Object, mockSensorApiService.Object);
// act and assert
sensorController.WithCallTo(c => c.ListAllPublicSensors())
.ShouldRenderDefaultView()
.WithModel <List <SensorDisplayData> >(actual =>
{
Assert.IsNotNull(actual);
CollectionAssert.AreEquivalent(expected, actual);
});
}
public async Task ReturnViewResult_WhenInvoked()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validUserId = Guid.NewGuid().ToString();
IEnumerable <Sensor> stateSensors = new List <Sensor>();
IEnumerable <Sensor> nonStateSensors = new List <Sensor>();
sensorServiceMock.Setup(mock => mock.ListStateSensorsAsync())
.Returns(Task.FromResult(stateSensors));
sensorServiceMock.Setup(mock => mock.ListStateSensorsAsync())
.Returns(Task.FromResult(nonStateSensors));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act
var result = await SUT.Register(validUserId);
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
public async Task GetAll_WithDeviceId_ReturnsCollectionOfSensors()
{
// Arrange
var testSensors = GetSensors();
var dbContext = Setup.GetDbContext();
dbContext.Sensors.AddRange(testSensors);
dbContext.SaveChanges();
var controller = new SensorController(dbContext);
// Act
var result = await controller.GetAllInDevice(1);
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var sensors = Assert.IsAssignableFrom <IEnumerable <SensorViewModel> >(okObjectResult.Value);
Assert.All(testSensors, testSensor =>
{
var sensor = sensors.SingleOrDefault(s => s.Id == testSensor.Id);
Assert.NotNull(sensor);
Assert.Equal(testSensor.DeviceId, sensor.DeviceId);
Assert.Equal(testSensor.Name, sensor.Name);
});
}
public async Task Create_WithValidSensor_ReturnsCreatedSensor()
{
// Arrange
var testSensor = new SensorViewModel()
{
DeviceId = 1,
Name = "TestSensor",
Properties = new List <SensorPropertyViewModel>()
{
new SensorPropertyViewModel()
{
Name = "Property",
Value = "JSDH6H"
}
}
};
var dbContext = Setup.GetDbContext();
var controller = new SensorController(dbContext);
// Act
var result = await controller.Create(testSensor);
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var sensor = Assert.IsAssignableFrom <SensorViewModel>(okObjectResult.Value);
Assert.Equal(1, sensor.Id);
Assert.Equal(testSensor.Name, sensor.Name);
Assert.All(testSensor.Properties, testSensorProperty =>
{
var sensorProperty = sensor.Properties.SingleOrDefault(sp => sp.Name.Equals(testSensorProperty.Name));
Assert.NotNull(sensorProperty);
Assert.Equal(testSensorProperty.Value, sensorProperty.Value);
});
}
public async Task ReturnCorrectViewModel_WhenCalled()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
IMemoryCache memoryCacheMock = new MemoryCache(new MemoryCacheOptions());
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <UserSensor> userSensors = new PagedList <UserSensor>(new List <UserSensor>().AsQueryable(), validPageNumber, validPageSize);
userSensorServiceMock.Setup(mock => mock.FilterUserSensorsAsync(validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(userSensors));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock,
sensorDataServiceMock.Object);
// Act
var result = await SUT.Index() as ViewResult;
// Assert
Assert.IsInstanceOfType(result.Model, typeof(SensorIndexViewModel));
}
public async Task ThrowApplicationException_WhenPassedUserSensorCollectionIsEmpty()
{
// Arrange
Mock <IUserSensorService> userSensorServiceMock = new Mock <IUserSensorService>();
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
Mock <ISensorDataService> sensorDataServiceMock = new Mock <ISensorDataService>();
string validId = "testGuid";
int validPageNumber = 1;
int validPageSize = 10;
List <UserSensor> emptyList = new List <UserSensor>();
IPagedList <UserSensor> validCollection = new PagedList <UserSensor>(emptyList.AsQueryable(), validPageNumber, validPageSize);
userSensorServiceMock.Setup(mock => mock.GetSensorsByUserId(validId, validPageNumber, validPageSize))
.Returns(Task.FromResult(validCollection));
SensorController SUT = new SensorController(
userSensorServiceMock.Object,
sensorServiceMock.Object,
memoryCacheMock.Object,
sensorDataServiceMock.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <ApplicationException>(() =>
SUT.Index(validId, validPageNumber, validPageSize));
}
/// <summary>
/// Initializes a new instance of the <see cref="BME280IoT"/> class.
/// </summary>
/// <param name="controller">The sensor controller.</param>
/// <param name="calibrationOffset">The overheating correction to use.</param>
/// <param name="altitudeInMeters">Altitude of location in meters. Used for corrections and calculating metrics.</param>
/// <param name="deviceId">Override the default device id.</param>
public BME280IoT(SensorController controller, double calibrationOffset, int altitudeInMeters, byte deviceId)
{
this.DeviceId = deviceId;
this.SensorName = "BME280_IoTDriver";
this.Controller = controller;
this.calibrationOffset = calibrationOffset;
this.altitudeInMeters = altitudeInMeters;
}
/// <summary>
/// Initializes a new instance of the <see cref="CCS811"/> class.
/// </summary>
/// <param name="controller">The sensor controller.</param>
/// <param name="warmupCount">number of warmup reading to do.</param>
public CCS811(SensorController controller, int warmupCount)
{
this.DeviceId = DEVICEID;
this.Messages = new List <string>();
this.warmupCount = warmupCount;
this.SensorName = "CCS811_HMDriver";
this.Controller = controller;
}
public async Task Update_WithValidSensor_ReturnsUpdatedSensor()
{
// Arrange
var testSensor = new SensorViewModel()
{
DeviceId = 1,
Name = "TestSensor",
Properties = new List <SensorPropertyViewModel>()
{
new SensorPropertyViewModel()
{
Name = "Property",
Value = "JSDH6H"
}
}
};
var dbContext = Setup.GetDbContext();
var sensorEntry = dbContext.Sensors.Add(new Sensor()
{
Id = 10,
DeviceId = 1,
Name = "SensorName"
});
var sensorProperty1 = dbContext.SensorProperties.Add(new SensorProperty()
{
SensorId = 10,
Name = "Property",
Value = "KDU8J"
});
var sensorProperty2 = dbContext.SensorProperties.Add(new SensorProperty()
{
SensorId = 10,
Name = "Key",
Value = "12DE83"
});
await dbContext.SaveChangesAsync();
sensorEntry.State = EntityState.Detached;
sensorProperty1.State = EntityState.Detached;
sensorProperty2.State = EntityState.Detached;
var controller = new SensorController(dbContext);
// Act
var result = await controller.Update(10, testSensor);
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var sensor = Assert.IsAssignableFrom <SensorViewModel>(okObjectResult.Value);
Assert.Equal(10, sensor.Id);
Assert.Equal(testSensor.Name, sensor.Name);
Assert.All(testSensor.Properties, testSensorProperty =>
{
var sensorProperty = sensor.Properties.SingleOrDefault(sp => sp.Name.Equals(testSensorProperty.Name));
Assert.NotNull(sensorProperty);
Assert.Equal(testSensorProperty.Value, sensorProperty.Value);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Windvane"/> class.
/// </summary>
/// <param name="controller">The sensor controller.</param>
/// <param name="busId">Bus Id of the MCP3008 chip.</param>
/// <param name="vIn">The input voltage. For Pi, this is 3.3.</param>
/// <param name="vDivide">Voltage divider resistor in ohms.</param>
public Windvane(SensorController controller, int busId, double vIn, int vDivide)
{
this.Controller = controller;
this.spiConnectionSettings = new SpiConnectionSettings(busId);
this.spiDevice = SpiDevice.Create(this.spiConnectionSettings);
this.SensorName = "MCP3800_Windvane";
this.busId = busId;
this.vIn = vIn;
this.vDivide = vDivide;
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
}
