public async void DeleteDeviceRuleAsyncTest()
{
var newRule = fixture.Create <DeviceRule>();
DeviceRuleTableEntity tableEntity = null;
var resp = new TableStorageResponse <DeviceRule>
{
Entity = newRule,
Status = TableStorageResponseStatus.Successful
};
_tableStorageClientMock.Setup(
x =>
x.DoDeleteAsync(It.IsNotNull <DeviceRuleTableEntity>(),
It.IsNotNull <Func <DeviceRuleTableEntity, DeviceRule> >()))
.Callback <DeviceRuleTableEntity, Func <DeviceRuleTableEntity, DeviceRule> >(
(entity, func) => tableEntity = entity)
.ReturnsAsync(resp);
var tableEntities = fixture.Create <List <DeviceRuleTableEntity> >();
_tableStorageClientMock.Setup(x => x.ExecuteQueryAsync(It.IsNotNull <TableQuery <DeviceRuleTableEntity> >()))
.ReturnsAsync(tableEntities);
string blobEntititesStr = null;
_blobClientMock.Setup(x => x.UploadTextAsync(It.IsNotNull <string>(), It.IsNotNull <string>()))
.Callback <string, string>((name, blob) => blobEntititesStr = blob)
.Returns(Task.FromResult(true));
var ret = await deviceRulesRepository.DeleteDeviceRuleAsync(newRule);
Assert.NotNull(ret);
Assert.Equal(resp, ret);
Assert.NotNull(tableEntity);
Assert.Equal(newRule.DeviceID, tableEntity.DeviceId);
Assert.NotNull(blobEntititesStr);
}
/// <summary>
/// Save a Device Rule to the server. This may be either a new rule or an update to an existing rule.
/// </summary>
/// <param name="updateContainer"></param>
/// <returns></returns>
public async Task <TableStorageResponse <DeviceRule> > SaveDeviceRuleAsync(DeviceRule updatedRule)
{
DeviceRuleTableEntity incomingEntity =
new DeviceRuleTableEntity(updatedRule.DeviceID, updatedRule.RuleId)
{
DataField = updatedRule.DataField,
Threshold = (double)updatedRule.Threshold,
Enabled = updatedRule.EnabledState,
RuleOutput = updatedRule.RuleOutput
};
if (!string.IsNullOrWhiteSpace(updatedRule.Etag))
{
incomingEntity.ETag = updatedRule.Etag;
}
TableStorageResponse <DeviceRule> result =
await AzureTableStorageHelper.DoTableInsertOrReplace <DeviceRule, DeviceRuleTableEntity>(incomingEntity, BuildRuleFromTableEntity,
_storageAccountConnectionString, _deviceRulesNormalizedTableName);
// Build up a new blob to push up
List <DeviceRuleBlobEntity> blobList = await BuildBlobEntityListFromTableRows();
await PersistRulesToBlobStorageAsync(blobList);
return(result);
}
public async Task <TableStorageResponse <DeviceRule> > DeleteDeviceRuleAsync(DeviceRule ruleToDelete)
{
DeviceRuleTableEntity incomingEntity = BuildTableEntityFromRule(ruleToDelete);
TableStorageResponse <DeviceRule> result =
await _azureTableStorageClient.DoDeleteAsync <DeviceRule, DeviceRuleTableEntity>(incomingEntity, BuildRuleFromTableEntity);
if (result.Status == TableStorageResponseStatus.Successful)
{
// Build up a new blob to push up for ASA job ref data
List <DeviceRuleBlobEntity> blobList = await BuildBlobEntityListFromTableRows();
await PersistRulesToBlobStorageAsync(blobList);
}
return(result);
}
public async Task <TableStorageResponse <DeviceRule> > DeleteDeviceRuleAsync(DeviceRule ruleToDelete)
{
DeviceRuleTableEntity incomingEntity = BuildTableEntityFromRule(ruleToDelete);
TableStorageResponse <DeviceRule> result =
await AzureTableStorageHelper.DoDeleteAsync <DeviceRule, DeviceRuleTableEntity>(incomingEntity, BuildRuleFromTableEntity,
_storageAccountConnectionString, _deviceRulesNormalizedTableName);
if (result.Status == TableStorageResponseStatus.Successful)
{
// Build up a new blob to push up for ASA job ref data
List <DeviceRuleBlobEntity> blobList = await BuildBlobEntityListFromTableRows();
await PersistRulesToBlobStorageAsync(blobList);
}
return(result);
}
private DeviceRuleTableEntity BuildTableEntityFromRule(DeviceRule incomingRule)
{
DeviceRuleTableEntity tableEntity =
new DeviceRuleTableEntity(incomingRule.DeviceID, incomingRule.RuleId)
{
DataField = incomingRule.DataField,
Threshold = (double)incomingRule.Threshold,
Enabled = incomingRule.EnabledState,
RuleOutput = incomingRule.RuleOutput
};
if (!string.IsNullOrWhiteSpace(incomingRule.Etag))
{
tableEntity.ETag = incomingRule.Etag;
}
return(tableEntity);
}
private DeviceRule BuildRuleFromTableEntity(DeviceRuleTableEntity tableEntity)
{
if (tableEntity == null)
{
return(null);
}
var updatedRule = new DeviceRule(tableEntity.RuleId)
{
DeviceID = tableEntity.DeviceId,
DataField = tableEntity.DataField,
Threshold = tableEntity.Threshold,
EnabledState = tableEntity.Enabled,
Operator = ">",
RuleOutput = tableEntity.RuleOutput,
Etag = tableEntity.ETag
};
return(updatedRule);
}
