public async Task CanAccess_ApiKey_SingleCollection_ById_AndView_SinggleMetadataField()
{
using (var client = new M2XClient(_masterKey))
{
var collectionParameters = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Collection {DateTime.UtcNow.Ticks}\", \"metadata\": {{ \"{Constants.TestMetadataDefaultFieldName}\": \"{Constants.TestMetadataDefaultFieldValue}\" }} }}";
var createCollectionResult = await client.CreateCollection(collectionParameters);
Assert.IsNotNull(createCollectionResult);
Assert.IsFalse(createCollectionResult.Error);
Assert.IsFalse(createCollectionResult.ServerError);
Assert.IsNull(createCollectionResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(createCollectionResult.Raw));
var collectionData = JsonConvert.DeserializeObject <Collection>(createCollectionResult.Raw);
var collection = client.Collection(collectionData.id);
var result = await collection.MetadataField(Constants.TestMetadataDefaultFieldName);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.IsTrue(result.Raw.Length > 6);
var deleteCollectionResult = await collection.Delete();
RequestWasProcessedAndReturnedExpectedValue(deleteCollectionResult);
}
}
public async Task CanAccess_MasterApiKey_AndSendCommands()
{
try
{
using (var client = new M2XClient(_masterKey))
{
var sendCommandParms = new StringBuilder($"{{ ");
sendCommandParms.Append($"\"name\": \"PHONE_HOME\"");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"data\": {{ \"server_url\": \"https://m2x.att.com\" }}");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"targets\": {{ \"devices\": [\"{_testDevice.id}\"] }}");
sendCommandParms.Append($" }}");
var result = await client.SendCommand(sendCommandParms.ToString());
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.AreEqual(Constants.M2X_Response_Success_Accepted, result.Raw);
}
}
catch (Exception)
{
DestroyTestDevice();
throw;
}
}
public static void InitializeTestSpecs(TestContext testContext)
{
_devices = new Dictionary <string, Device>();
_testDeviceSerial = $"td-{DateTime.UtcNow.Ticks}";
using (var client = new M2XClient(_masterKey))
{
var createDeviceParms = $"{{ \"base_device\": \"d781ab7460136af9db496c97172a6e6c\", \"name\": \"{Constants.TestDeviceNamePrefix} {DateTime.UtcNow.Ticks}\", \"description\": \"{Constants.TestDeviceDescription}\", \"serial\": \"{_testDeviceSerial}\", \"visibility\": \"private\" }}";
var createDeviceResult = client.CreateDevice(createDeviceParms).Result;
var device = JsonConvert.DeserializeObject <Device>(createDeviceResult.Raw);
_devices.Add("primary", device);
_testDeviceId = device.id;
var testDevice = client.Device(device.id);
var updateTagsParms = "{ \"tags\": \"test only\" }";
var resultTags = testDevice.Update(updateTagsParms).Result;
var updateLocationParms = $"{{ \"name\": \"Test Device Location\", \"latitude\": {Constants.TestDeviceLatitude}, \"longitude\": {Constants.TestDeviceLongitude} }}";
var resultLocation = testDevice.UpdateLocation(updateLocationParms).Result;
var updateMetadataParms = "{ \"owner\": \"The Testing Guy\" } ";
var resultMetadata = testDevice.UpdateMetadata(updateMetadataParms);
var stream01UpdateParms = $"{{ \"values\": [ {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-10).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": 98.6 }}, {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-5).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": 98.7 }} ] }}";
var stream01 = testDevice.Stream(Constants.TestStreamName001);
var resultStream01Post = stream01.PostValues(stream01UpdateParms).Result;
System.Threading.Thread.Sleep(500);
var stream02UpdateParms = $"{{ \"values\": [ {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-10).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": \"normal\" }}, {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-5).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": \"normal\" }} ] }}";
var stream02 = testDevice.Stream(Constants.TestStreamName002);
var resultStream02Post = stream02.PostValues(stream02UpdateParms).Result;
System.Threading.Thread.Sleep(500);
}
}
private static void DestroyTestResources()
{
if ((_devices != null && _devices.Any()) || (_distributions != null && _distributions.Any()))
{
using (var client = new M2XClient(_masterKey))
{
if (_distributions != null && _distributions.Any())
{
for (var i = _distributions.Count(); i > 0; i--)
{
var _distribution = _distributions.ElementAt(i - 1);
var distribution = client.Distribution(_distribution.Value.id);
var result = distribution.Delete().Result;
System.Threading.Thread.Sleep(250);
_distributions.Remove(_distribution.Key);
}
}
if (_devices != null && _devices.Any())
{
for (var i = _devices.Count(); i > 0; i--)
{
var _device = _devices.ElementAt(i - 1);
var device = client.Device(_device.Value.id);
var result = device.Delete().Result;
System.Threading.Thread.Sleep(250);
_devices.Remove(_device.Key);
}
}
}
}
}
public String getData()
{
stream = device.Stream("hasFallen");
string a = "";
response = stream.Values(new ATTM2X.Classes.StreamValuesFilter {
start = M2XClient.DateTimeToString(DateTime.UtcNow.AddMinutes(-3))
}, M2XStreamValuesFormat.Json).Result;
var data = response.Json <StreamValues>();
if (DateTime.Compare(limit, Convert.ToDateTime(data.end)) < 0)
{
if (data.values.Length != 0)
{
TimeSpan span = (Convert.ToDateTime(data.values[0].timestamp) - lastFall);
if (span.Seconds > 30)
{
a = data.values[0].value;
if (a == "fall")
{
lastFall = Convert.ToDateTime(data.values[0].timestamp);
}
System.Console.WriteLine("FALLLL---------------------------------/////////");
}
}
}
else
{
a = "";
}
limit = Convert.ToDateTime(data.end);
return(a);
}
public async Task CanCreate_AndDelete_Collection_WithAll_RequiredParameters()
{
using (var client = new M2XClient(_masterKey))
{
var collectionParameters = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Collection {DateTime.UtcNow.Ticks}\" }}";
var result = await client.CreateCollection(collectionParameters);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var collection = JsonConvert.DeserializeObject <Collection>(result.Raw);
Assert.IsNotNull(collection);
var collectionWrapper = client.Collection(collection.id);
Assert.IsNotNull(collectionWrapper);
await collectionWrapper.Delete();
var collectionCheck = client.Collection(collection.id);
var collectionCheckResult = await collectionCheck.Details();
Assert.IsNotNull(collectionCheck);
Assert.IsTrue(collectionCheckResult.Error);
Assert.IsFalse(collectionCheckResult.ServerError);
Assert.IsNull(collectionCheckResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(collectionCheckResult.Raw));
ProcessCollectionsSearchResult(collectionCheckResult.Raw, false);
}
}
public void Init()
{
this.TestId = Guid.NewGuid().ToString("N");
this.UtcNow = DateTime.UtcNow;
this.m2x = new M2XClient(MasterKey);
}
public async Task CanAccess_ApiKey_SingleDistribution_ById_AndUpdate_DistributionMetadata_SingleField()
{
if (_accountIsNotPro)
{
Assert.Inconclusive("The API key used for this test run is not enabled for Full Access. Please upgrade the account or use an API key that has the necessary permissions.");
return;
}
using (var client = new M2XClient(_masterKey))
{
var distribution = client.Distribution(_distributions["primary"].id);
var updateMetaDataValue = "The man sitting next to the man...";
var updateMetaDataParams = $"{{ \"value\": \"{updateMetaDataValue}\" }}";
var result = await distribution.UpdateMetadataField(Constants.TestMetadataDefaultFieldName, updateMetaDataParams);
RequestWasProcessedAndReturnedExpectedValue(result);
var verifyUpdateResult = await distribution.Metadata();
Assert.IsNotNull(verifyUpdateResult);
Assert.IsFalse(verifyUpdateResult.Error);
Assert.IsFalse(verifyUpdateResult.ServerError);
Assert.IsNull(verifyUpdateResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(verifyUpdateResult.Raw));
Assert.IsTrue(verifyUpdateResult.Raw.Length > 6);
Assert.IsTrue(verifyUpdateResult.Raw.ToLowerInvariant().Contains(updateMetaDataValue.ToLowerInvariant()));
}
}
public void Cleanup()
{
if (this.key != null)
{
Delete(this.key);
this.key = null;
}
if (this.stream != null)
{
Delete(this.stream);
this.stream = null;
}
if (this.device != null)
{
Delete(this.device);
this.device = null;
}
if (this.distribution != null)
{
Delete(this.distribution);
this.distribution = null;
}
if (this.collection != null)
{
Delete(this.collection);
this.collection = null;
}
if (this.m2x != null)
{
this.m2x.Dispose();
this.m2x = null;
}
}
public static void InitializeTestSpecs(TestContext testContext)
{
using (var client = new M2XClient(_masterKey))
{
var createDeviceParms = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Device {DateTime.UtcNow.Ticks}\", \"visibility\": \"private\" }}";
var createDeviceResult = client.CreateDevice(createDeviceParms).Result;
_testDevice = JsonConvert.DeserializeObject <Device>(createDeviceResult.Raw);
_testDeviceExists = _testDevice != null;
}
}
public static void InitializeTestSpecs(TestContext testContext)
{
_devices = new Dictionary <string, Device>();
_distributions = new Dictionary <string, Distribution>();
_testDeviceSerial = $"td-{DateTime.UtcNow.Ticks}";
using (var client = new M2XClient(_masterKey))
{
var createDeviceParms = $"{{ \"base_device\": \"d781ab7460136af9db496c97172a6e6c\", \"name\": \"{Constants.TestDeviceNamePrefix} {DateTime.UtcNow.Ticks}\", \"description\": \"{Constants.TestDeviceDescription}\", \"serial\": \"{_testDeviceSerial}\", \"visibility\": \"private\" }}";
var createDeviceResult = client.CreateDevice(createDeviceParms).Result;
var device = JsonConvert.DeserializeObject <Device>(createDeviceResult.Raw);
_devices.Add("primary", device);
_testDeviceId = device.id;
var testDevice = client.Device(device.id);
var updateTagsParms = "{ \"tags\": \"test only\" }";
var resultTags = testDevice.Update(updateTagsParms).Result;
for (var i = 0; i < 5; i++)
{
var updateLocationParms = $"{{ \"name\": \"Test Device Location{i + 1}\", \"latitude\": {(Constants.TestDeviceLatitude + i)}, \"longitude\": {(Constants.TestDeviceLongitude + i)} }}";
var resultLocation = testDevice.UpdateLocation(updateLocationParms).Result;
}
var updateMetadataParms = $"{{ \"{Constants.TestMetadataDefaultFieldName}\": \"{Constants.TestMetadataDefaultFieldValue}\" }} ";
var resultMetadata = testDevice.UpdateMetadata(updateMetadataParms);
var stream01UpdateParms = $"{{ \"values\": [ {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-10).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": 98.6 }}, {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-5).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": 98.7 }} ] }}";
var stream01 = testDevice.Stream(Constants.TestStreamName001);
var resultStream01Post = stream01.PostValues(stream01UpdateParms).Result;
System.Threading.Thread.Sleep(250);
var stream02UpdateParms = $"{{ \"values\": [ {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-10).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": \"normal\" }}, {{ \"timestamp\": \"{DateTime.Now.AddSeconds(-5).ToString("yyyy-MM-ddTHH:mm:ssZ")}\", \"value\": \"normal\" }} ] }}";
var stream02 = testDevice.Stream(Constants.TestStreamName002);
var resultStream02Post = stream02.PostValues(stream02UpdateParms).Result;
System.Threading.Thread.Sleep(250);
var testDistributionCreateParms = $"{{ \"name\": \"Test Distribution {DateTime.Now.Ticks}\", \"description\": \"This is just a test!\", \"visibility\": \"private\", \"base_device\": \"{_testDeviceId}\", \"metadata\": {{ \"{Constants.TestMetadataDefaultFieldName}\": \"{Constants.TestMetadataDefaultFieldValue}\" }} }}";
var testDistributionCreateResult = client.CreateDistribution(testDistributionCreateParms).Result;
_accountIsNotPro = testDistributionCreateResult.Error;
if (_accountIsNotPro)
{
return;
}
var testDistribution = JsonConvert.DeserializeObject <Distribution>(testDistributionCreateResult.Raw);
var distributionAddDeviceParms = $"{{ \"serial\": \"td-{(DateTime.UtcNow.Ticks + 50)}\" }}";
var distributionDeviceData = client.Distribution(testDistribution.id).AddDevice(distributionAddDeviceParms).Result;
var distributionDevice = JsonConvert.DeserializeObject <Device>(distributionDeviceData.Raw);
_devices.Add(distributionDevice.serial, distributionDevice);
_distributions.Add("primary", testDistribution);
System.Threading.Thread.Sleep(250);
}
}
public async Task CanList_CanAccess_ApiKey_Collections_List()
{
using (var client = new M2XClient(_masterKey))
{
var result = await client.Collections();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessCollectionsSearchResult(result.Raw, false);
}
}
private static void DestroyTestDevice()
{
if (_testDeviceExists)
{
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
device.Delete();
System.Threading.Thread.Sleep(500);
_testDevice = null;
_testDeviceExists = false;
}
}
}
public async Task CanAccess_MasterApiKey_ListOf_CommandsSent_TakeOne_AndView_Details()
{
try
{
var targetCommandId = string.Empty;
using (var client = new M2XClient(_masterKey))
{
var retrieveCommandsResult = await client.Commands();
Assert.IsNotNull(retrieveCommandsResult);
Assert.IsFalse(retrieveCommandsResult.Error);
Assert.IsFalse(retrieveCommandsResult.ServerError);
Assert.IsNull(retrieveCommandsResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(retrieveCommandsResult.Raw));
var commandData = JsonConvert.DeserializeObject <ApiResponseForCommandSearch>(retrieveCommandsResult.Raw);
if (!commandData.commands.Any())
{
Assert.Fail("There are no commands to view. Please send one using the appropriate test or create one manually before trying again.");
}
targetCommandId = commandData.commands.First().id;
}
using (var client = new M2XClient(_masterKey))
{
var result = await client.CommandDetails(targetCommandId);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var commandDetail = JsonConvert.DeserializeObject <ApiResponseForCommandDetail>(result.Raw);
Assert.IsNotNull(commandDetail);
Assert.IsNotNull(commandDetail.data);
Assert.IsNotNull(commandDetail.deliveries);
Assert.AreNotEqual(default(DateTime), commandDetail.sent_at);
}
}
catch (Exception)
{
DestroyTestDevice();
throw;
}
}
private static void DestroyTestDevices()
{
if (_devices != null && _devices.Any())
{
for (var i = _devices.Count(); i > 0; i--)
{
var _device = _devices.ElementAt(i - 1);
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_device.Value.id);
device.Delete();
System.Threading.Thread.Sleep(500);
_devices.Remove(_device.Key);
}
}
}
}
public async Task CanAccess_ApiKey_Distributions()
{
if (_accountIsNotPro)
{
Assert.Inconclusive("The API key used for this test run is not enabled for Full Access. Please upgrade the account or use an API key that has the necessary permissions.");
return;
}
using (var client = new M2XClient(_masterKey))
{
var result = await client.Distributions();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessDistributionSearchResult(result.Raw);
}
}
public async Task CanAccess_ApiKey_SingleDistribution_ById_AndUpdate_DistributionMetadata()
{
if (_accountIsNotPro)
{
Assert.Inconclusive("The API key used for this test run is not enabled for Full Access. Please upgrade the account or use an API key that has the necessary permissions.");
return;
}
using (var client = new M2XClient(_masterKey))
{
var distributionName = $"*** PLEASE DELETE ME *** Test Auto Created Distribution {DateTime.UtcNow.Ticks}";
var distributionParameters = $"{{ \"name\": \"{distributionName}\", \"visibility\": \"private\", \"metadata\": {{ \"{Constants.TestMetadataDefaultFieldName}\": \"{Constants.TestMetadataDefaultFieldValue}\" }} }}";
var createDistributionResult = await client.CreateDistribution(distributionParameters);
Assert.IsNotNull(createDistributionResult);
Assert.IsFalse(createDistributionResult.Error);
Assert.IsFalse(createDistributionResult.ServerError);
Assert.IsNull(createDistributionResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(createDistributionResult.Raw));
var distributionData = JsonConvert.DeserializeObject <Distribution>(createDistributionResult.Raw);
var distribution = client.Distribution(distributionData.id);
_distributions.Add(distributionName, distributionData);
var updateMetaDataValue = "The man sitting next to the man...";
var updateMetaDataParams = $"{{ \"owner\": \"{updateMetaDataValue}\" }}";
var result = await distribution.UpdateMetadata(updateMetaDataParams);
RequestWasProcessedAndReturnedExpectedValue(result);
var verifyUpdateResult = await distribution.Metadata();
Assert.IsNotNull(verifyUpdateResult);
Assert.IsFalse(verifyUpdateResult.Error);
Assert.IsFalse(verifyUpdateResult.ServerError);
Assert.IsNull(verifyUpdateResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(verifyUpdateResult.Raw));
Assert.IsTrue(verifyUpdateResult.Raw.Length > 6);
Assert.IsTrue(verifyUpdateResult.Raw.ToLowerInvariant().Contains(updateMetaDataValue.ToLowerInvariant()));
}
}
public async Task CanAccess_MasterApiKey_ListOf_CommandsSent_NoFilters()
{
try
{
using (var client = new M2XClient(_masterKey))
{
var result = await client.Commands();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessCommandSearchResult(result.Raw, null);
}
}
catch (Exception)
{
DestroyTestDevice();
throw;
}
}
public async Task CanAccess_ApiKey_SingleDistribution_ById_AndView_SingleMetadataField()
{
if (_accountIsNotPro)
{
Assert.Inconclusive("The API key used for this test run is not enabled for Full Access. Please upgrade the account or use an API key that has the necessary permissions.");
return;
}
using (var client = new M2XClient(_masterKey))
{
var distribution = client.Distribution(_distributions["primary"].id);
var result = await distribution.MetadataField(Constants.TestMetadataDefaultFieldName);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.IsTrue(result.Raw.Length > 6);
}
}
public async Task CanAccess_ApiKey_SingleCollection_ById_AndUpdate_CollectionMetadata()
{
using (var client = new M2XClient(_masterKey))
{
var collectionParameters = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Collection {DateTime.UtcNow.Ticks}\", \"metadata\": {{ \"{Constants.TestMetadataDefaultFieldName}\": \"{Constants.TestMetadataDefaultFieldValue}\" }} }}";
var createCollectionResult = await client.CreateCollection(collectionParameters);
Assert.IsNotNull(createCollectionResult);
Assert.IsFalse(createCollectionResult.Error);
Assert.IsFalse(createCollectionResult.ServerError);
Assert.IsNull(createCollectionResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(createCollectionResult.Raw));
var collectionData = JsonConvert.DeserializeObject <Collection>(createCollectionResult.Raw);
var collection = client.Collection(collectionData.id);
var updateMetaDataValue = "The man sitting next to the man...";
var updateMetaDataParams = $"{{ \"owner\": \"{updateMetaDataValue}\" }}";
var result = await collection.UpdateMetadata(updateMetaDataParams);
RequestWasProcessedAndReturnedExpectedValue(result);
var verifyUpdateResult = await collection.Metadata();
Assert.IsNotNull(verifyUpdateResult);
Assert.IsFalse(verifyUpdateResult.Error);
Assert.IsFalse(verifyUpdateResult.ServerError);
Assert.IsNull(verifyUpdateResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(verifyUpdateResult.Raw));
Assert.IsTrue(verifyUpdateResult.Raw.Length > 6);
Assert.IsTrue(verifyUpdateResult.Raw.ToLowerInvariant().Contains(updateMetaDataValue.ToLowerInvariant()));
var deleteCollectionResult = await collection.Delete();
RequestWasProcessedAndReturnedExpectedValue(deleteCollectionResult);
}
}
public void CommandsApiTest()
{
response = m2x.CreateDevice(new DeviceParams
{
name = "TestDevice-" + this.TestId,
visibility = M2XVisibility.Private,
}).Result;
Assert.AreEqual(HttpStatusCode.Created, response.Status, response.Raw);
var deviceDetails = response.Json <DeviceDetails>();
Assert.IsNotNull(deviceDetails.id);
this.device = m2x.Device(deviceDetails.id);
Thread.Sleep(1000);
string commandName = "TestCommand-" + this.TestId;
response = m2x.SendCommand(new SendCommandParams
{
name = commandName,
targets = new CommandTargets {
devices = new string[] { deviceDetails.id }
},
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(1000);
response = m2x.Commands(new CommandParams {
name = commandName
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var commands = response.Json <CommandList <CommandDetails> >();
Assert.IsNotNull(commands, response.Raw);
Assert.IsNotNull(commands.commands, response.Raw);
Assert.AreEqual(1, commands.commands.Length, response.Raw);
Assert.AreEqual(commandName, commands.commands[0].name, response.Raw);
string commandId = commands.commands[0].id;
Assert.IsNotNull(commandId, response.Raw);
response = m2x.CommandDetails(commandId).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var command = response.Json <CommandDetails>();
Assert.IsNotNull(command, response.Raw);
Assert.AreEqual(commandName, command.name, response.Raw);
response = m2x.Keys(new KeyListParams {
device = deviceDetails.id
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var keys = response.Json <KeyList>();
Assert.IsNotNull(keys, response.Raw);
Assert.IsNotNull(keys.keys, response.Raw);
Assert.AreEqual(1, keys.keys.Length, response.Raw);
Assert.IsTrue(keys.keys[0].device.Contains(deviceDetails.id), response.Raw);
string key = keys.keys[0].key;
Assert.AreEqual(deviceDetails.key, key, response.Raw);
Assert.IsNotNull(key, response.Raw);
using (var deviceClient = new M2XClient(deviceDetails.key))
{
var device_ = deviceClient.Device(deviceDetails.id);
response = device_.Commands(new CommandParams {
status = M2XCommandStatus.Sent
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
commands = response.Json <CommandList <CommandDetails> >();
Assert.IsNotNull(commands, response.Raw);
Assert.IsNotNull(commands.commands, response.Raw);
Assert.AreEqual(1, commands.commands.Length, response.Raw);
Assert.AreEqual(commandName, commands.commands[0].name, response.Raw);
Assert.AreEqual(commandId, commands.commands[0].id, response.Raw);
Assert.AreEqual(M2XCommandStatus.Sent, commands.commands[0].status, response.Raw);
response = device_.CommandDetails(commandId).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
command = response.Json <CommandDetails>();
Assert.IsNotNull(command, response.Raw);
Assert.AreEqual(commandName, command.name, response.Raw);
Assert.AreEqual(M2XCommandStatus.Sent, command.status, response.Raw);
response = device_.ProcessCommand(commandId).Result;
Assert.AreEqual(HttpStatusCode.NoContent, response.Status, response.Raw);
Thread.Sleep(1000);
response = device_.CommandDetails(commandId).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
command = response.Json <CommandDetails>();
Assert.IsNotNull(command, response.Raw);
Assert.AreEqual(commandName, command.name, response.Raw);
Assert.AreEqual(M2XCommandStatus.Processed, command.status, response.Raw);
commandName = "TestCommand2-" + this.TestId;
response = m2x.SendCommand(new SendCommandParams
{
name = commandName,
targets = new CommandTargets {
devices = new string[] { deviceDetails.id }
},
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(1000);
response = device_.Commands(new CommandParams {
status = M2XCommandStatus.Sent
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
commands = response.Json <CommandList <CommandDetails> >();
Assert.IsNotNull(commands, response.Raw);
Assert.IsNotNull(commands.commands, response.Raw);
Assert.AreEqual(1, commands.commands.Length, response.Raw);
Assert.AreEqual(commandName, commands.commands[0].name, response.Raw);
commandId = commands.commands[0].id;
response = device_.RejectCommand(commandId).Result;
Assert.AreEqual(HttpStatusCode.NoContent, response.Status, response.Raw);
Thread.Sleep(1000);
response = device_.CommandDetails(commandId).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
command = response.Json <CommandDetails>();
Assert.IsNotNull(command, response.Raw);
Assert.AreEqual(commandName, command.name, response.Raw);
Assert.AreEqual(M2XCommandStatus.Rejected, command.status, response.Raw);
}
}
public void DeviceAPITest()
{
// device
response = m2x.DeviceTags().Result;
Assert.IsNotNull(m2x.LastResponse);
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.Error);
Assert.IsNotNull(response.Raw);
response = m2x.DeviceCatalog(new DeviceListParams {
page = 1, limit = 10, sort = M2XDeviceSortOrder.Name, dir = M2XSortDirection.Asc
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var deviceList = response.Json <DeviceList>();
Assert.IsNotNull(deviceList.devices);
Assert.IsTrue(deviceList.devices.Length > 0);
DeviceDetails deviceDetails = deviceList.devices.FirstOrDefault(d => d.location != null && d.location.latitude.HasValue && d.location.longitude.HasValue);
Assert.IsNotNull(deviceDetails);
response = m2x.DeviceCatalogSearch(null, new DeviceSearchBodyParamsBase
{
location = new LocationFilter
{
within_circle = new WithinCircleFilter
{
center = new LocationPointParams
{
latitude = deviceDetails.location.latitude.Value,
longitude = deviceDetails.location.longitude.Value,
},
radius = new RadiusParams {
km = 10
},
},
},
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
deviceList = response.Json <DeviceList>();
Assert.IsNotNull(deviceList.devices);
// TODO: Assert.IsTrue(deviceList.devices.Length > 0);
response = m2x.CreateDevice(new DeviceParams
{
name = "TestDevice-" + this.TestId,
visibility = M2XVisibility.Private,
}).Result;
Assert.AreEqual(HttpStatusCode.Created, response.Status, response.Raw);
deviceDetails = response.Json <DeviceDetails>();
Assert.IsNotNull(deviceDetails.id);
this.device = m2x.Device(deviceDetails.id);
Assert.AreEqual(M2XVisibility.Private, deviceDetails.visibility);
Thread.Sleep(1000);
response = device.Details().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
deviceDetails = response.Json <DeviceDetails>();
Assert.AreEqual(M2XStatus.Enabled, deviceDetails.status);
response = device.Update(new DeviceParams
{
name = "TestDevice-" + this.TestId,
visibility = M2XVisibility.Private,
description = "test",
}).Result;
Assert.AreEqual(HttpStatusCode.NoContent, response.Status, response.Raw);
response = device.Details().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
deviceDetails = response.Json <DeviceDetails>();
Assert.AreEqual("test", deviceDetails.description);
response = device.UpdateLocation(new LocationParams
{
name = "Test Location",
latitude = 12,
longitude = -34,
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(2000);
response = device.Location().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var location = response.Json <LocationDetails>();
Assert.AreEqual("Test Location", location.name);
response = m2x.Devices(new { visibility = M2XVisibility.Private }).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
deviceList = response.Json <DeviceList>();
Assert.IsNotNull(deviceList.devices);
Assert.IsTrue(deviceList.devices.Length > 0);
response = m2x.SearchDevices(new DeviceSearchParams {
visibility = M2XVisibility.Private
}, new DeviceSearchBodyParamsBase
{
location = new LocationFilter
{
within_circle = new WithinCircleFilter
{
center = new LocationPointParams
{
latitude = location.latitude.Value,
longitude = location.longitude.Value,
},
radius = new RadiusParams {
km = 10
},
},
},
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
deviceList = response.Json <DeviceList>();
Assert.IsNotNull(deviceList.devices);
Assert.IsTrue(deviceList.devices.Length > 0);
response = device.Log().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var requestList = response.Json <RequestList>();
Assert.IsNotNull(requestList.requests);
Assert.IsTrue(requestList.requests.Length > 0);
// stream
this.stream = device.Stream("testdevicestream");
response = stream.Update(new StreamParams
{
type = M2XStreamType.Numeric,
unit = new StreamUnit {
label = "points", symbol = "pt"
},
}).Result;
Assert.AreEqual(HttpStatusCode.Created, response.Status, response.Raw);
Thread.Sleep(1000);
response = device.Streams().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var streamList = response.Json <StreamList>();
Assert.IsNotNull(streamList.streams);
Assert.AreEqual(1, streamList.streams.Length);
Assert.AreEqual(stream.StreamName, streamList.streams[0].name);
response = stream.UpdateValue(new StreamValue {
value = "10"
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(1000);
response = stream.Details().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var streamDetails = response.Json <StreamDetails>();
Assert.AreEqual("10", streamDetails.value);
response = stream.Values(new StreamValuesFilter {
start = M2XClient.DateTimeToString(this.UtcNow.AddHours(-1))
}, M2XStreamValuesFormat.Json).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var streamValues = response.Json <StreamValues>();
Assert.IsNotNull(streamValues.values);
Assert.AreEqual(1, streamValues.values.Length);
response = stream.UpdateValue(new StreamValue {
value = "20"
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(1500);
response = stream.Sampling(new StreamSamplingParams {
type = M2XSamplingType.Sum, interval = 100
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
streamValues = response.Json <StreamValues>();
Assert.IsNotNull(streamValues.values);
Assert.AreEqual(1, streamValues.values.Length);
Assert.AreEqual("30.0", streamValues.values[0].value);
response = stream.Stats().Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var streamStats = response.Json <StreamStatsInfo>();
Assert.IsNotNull(streamStats.stats);
Assert.AreEqual(2, streamStats.stats.count);
Assert.AreEqual(15.0, streamStats.stats.avg);
string from = M2XClient.DateTimeToString(this.UtcNow.AddMinutes(-2));
string end = M2XClient.DateTimeToString(this.UtcNow.AddMinutes(-1));
response = stream.PostValues(new StreamValues
{
values = new StreamValue[]
{
new StreamValue {
timestamp = from, value = "1",
},
new StreamValue {
timestamp = end, value = "2",
},
}
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
response = stream.DeleteValues(new DeleteValuesParams {
from = from, end = end
}).Result;
Assert.AreEqual(HttpStatusCode.NoContent, response.Status, response.Raw);
// values
response = device.PostUpdate(new TestDeviceValue
{
timestamp = M2XClient.DateTimeToString(this.UtcNow.AddMinutes(-3)),
values = new TestDeviceStreamValue {
testdevicestream = 3
},
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
response = device.PostUpdates(new TestDeviceValues
{
values = new TestDeviceStreamValues
{
testdevicestream = new StreamValue[]
{
new StreamValue {
timestamp = from, value = "1",
},
new StreamValue {
timestamp = end, value = "2",
},
},
},
}).Result;
Assert.AreEqual(HttpStatusCode.Accepted, response.Status, response.Raw);
Thread.Sleep(1000);
response = device.Values(new DeviceValuesFilter {
streams = "testdevicestream"
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
var values = response.Json <DeviceValueList <TestDeviceValue> >();
Assert.IsNotNull(values);
Assert.IsNotNull(values.values);
Assert.IsTrue(values.values.Length >= 3);
int count = values.values.Length;
response = device.SearchValues(new DeviceValuesSearchParams <TestDeviceConditions>
{
start = values.values.Min(v => v.timestamp),
end = values.values.Max(v => v.timestamp),
streams = new string[] { "testdevicestream" },
conditions = new TestDeviceConditions {
testdevicestream = new ValueCondition {
gt = 1
}
},
}).Result;
Assert.AreEqual(HttpStatusCode.OK, response.Status, response.Raw);
values = response.Json <DeviceValueList <TestDeviceValue> >();
Assert.IsNotNull(values);
Assert.IsNotNull(values.values);
Assert.IsTrue(values.values.Length > 0);
Assert.IsTrue(values.values.Length < count);
}
public async Task CanAccess_MasterApiKey_AndSendCommands_ToSingleDevice_AndDevice_MarksCommand_AsRejected()
{
try
{
var commandName = "PHONE_HOME";
using (var client = new M2XClient(_masterKey))
{
var sendCommandParms = new StringBuilder($"{{ ");
sendCommandParms.Append($"\"name\": \"{commandName}\"");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"data\": {{ \"server_url\": \"https://m2x.att.com\" }}");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"targets\": {{ \"devices\": [\"{_testDevice.id}\"] }}");
sendCommandParms.Append($" }}");
var result = await client.SendCommand(sendCommandParms.ToString());
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.AreEqual(Constants.M2X_Response_Success_Accepted, result.Raw);
}
System.Threading.Thread.Sleep(1000);
var targetCommandId = string.Empty;
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
var result = await device.Commands();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var commandData = JsonConvert.DeserializeObject <ApiResponseForCommandSearch>(result.Raw);
Assert.IsNotNull(commandData);
targetCommandId = commandData.commands.All(a => a.status_counts == null)
? commandData.commands.First().id
: commandData.commands.First(f => f.status_counts.processed == 0 && f.status_counts.rejected == 0 && f.status_counts.pending > 0).id;
}
System.Threading.Thread.Sleep(500);
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
var processParms = $"{{ \"reason\": \"Because I Can!\" }}";
var result = await device.RejectCommand(targetCommandId, processParms);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsTrue(string.IsNullOrWhiteSpace(result.Raw));
}
System.Threading.Thread.Sleep(500);
using (var client = new M2XClient(_masterKey))
{
var result = await client.Commands();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessCommandSearchResultFindTargetCommandAndCheckStatus(result.Raw, _testDevice.id, targetCommandId, "rejected");
}
}
catch (Exception ex)
{
DestroyTestDevice();
throw;
}
}
public async Task CanAccess_MasterApiKey_AndSendCommand_ToSingleDevice_ThenList_CommandsSent_WithFilters()
{
try
{
var commandName = "PHONE_HOME";
using (var client = new M2XClient(_masterKey))
{
var sendCommandParms = new StringBuilder($"{{ ");
sendCommandParms.Append($"\"name\": \"{commandName}\"");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"data\": {{ \"server_url\": \"https://m2x.att.com\" }}");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"targets\": {{ \"devices\": [\"{_testDevice.id}\"] }}");
sendCommandParms.Append($" }}");
var result = await client.SendCommand(sendCommandParms.ToString());
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.AreEqual(Constants.M2X_Response_Success_Accepted, result.Raw);
}
System.Threading.Thread.Sleep(1000);
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
foreach (var filter in new[] { "limit", "page", "dir|desc", "dir|asc", "start", "end", "name", "status|pending", "status|processed", "status|rejected" })
{
M2XResponse result = null;
switch (filter)
{
case "limit":
result = await device.Commands(new { limit = 2 });
break;
case "page":
result = await device.Commands(new { page = 1 });
break;
case "dir|desc":
result = await device.Commands(new { dir = "desc" });
break;
case "dir|asc":
result = await device.Commands(new { dir = "asc" });
break;
case "start":
result = await device.Commands(new { start = DateTime.UtcNow.AddMinutes(-60).ToString(Constants.ISO8601_DateStartFormat) });
break;
case "end":
result = await device.Commands(new { end = DateTime.UtcNow.AddMinutes(-10).ToString(Constants.ISO8601_DateStartFormat) });
break;
case "name":
result = await device.Commands(new { name = "PHONE_HOME" });
break;
case "status|pending":
result = await device.Commands(new { status = "pending" });
break;
case "status|processed":
result = await device.Commands(new { status = "processed" });
break;
case "status|rejected":
result = await device.Commands(new { status = "rejected" });
break;
}
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessCommandSearchResult(result.Raw, null);
}
}
}
catch (Exception ex)
{
DestroyTestDevice();
throw;
}
}
public async Task CanSearch_ApiKey_Distributions_ByAllowed_GETParameters()
{
if (_accountIsNotPro)
{
Assert.Inconclusive("The API key used for this test run is not enabled for Full Access. Please upgrade the account or use an API key that has the necessary permissions.");
return;
}
using (var client = new M2XClient(_masterKey))
{
foreach (var searchType in new object[] { null, "q1", "q2", "page", "limit", "tags", "modified_since", "unmodified_since", "visibility" })
{
object searchParams = null;
if (searchType != null)
{
switch (searchType.ToString())
{
case "q1":
searchParams = new { q = Constants.TestDeviceNamePrefix };
break;
case "q2":
searchParams = new { q = Constants.TestDeviceDescription };
break;
case "page":
searchParams = new { page = 1 };
break;
case "limit":
searchParams = new { limit = 2 };
break;
case "tags":
searchParams = new { tags = "test only" };
break;
case "modified_since":
searchParams = new { modified_since = $"{DateTime.Now.AddHours(-1).ToString(Constants.ISO8601_DateStartFormat)}" };
break;
case "unmodified_since":
searchParams = new { unmodified_since = $"{DateTime.Now.AddHours(-1).ToString(Constants.ISO8601_DateStartFormat)}" };
break;
case "visibility":
searchParams = new { visibility = "private" };
break;
}
}
var result = await client.SearchDistributions(searchParams);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessDistributionSearchResult(result.Raw, true);
}
}
}
public async Task CanAccess_MasterApiKey_ListOf_CommandsSent_WithFilters()
{
try
{
using (var client = new M2XClient(_masterKey))
{
foreach (var filter in new[] { "limit", "page", "dir|desc", "dir|asc", "start", "end", "name" })
{
M2XResponse result = null;
switch (filter)
{
case "limit":
result = await client.Commands(new { limit = 2 });
break;
case "page":
result = await client.Commands(new { page = 1 });
break;
case "dir|desc":
result = await client.Commands(new { dir = "desc" });
break;
case "dir|asc":
result = await client.Commands(new { dir = "asc" });
break;
case "start":
result = await client.Commands(new { start = DateTime.UtcNow.AddMinutes(-60).ToString(Constants.ISO8601_DateStartFormat) });
break;
case "end":
result = await client.Commands(new { end = DateTime.UtcNow.AddMinutes(-10).ToString(Constants.ISO8601_DateStartFormat) });
break;
case "name":
result = await client.Commands(new { name = "PHONE_HOME" });
break;
}
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
ProcessCommandSearchResult(result.Raw, null);
}
}
}
catch (Exception)
{
DestroyTestDevice();
throw;
}
}
public async Task CanCreate_Collection_And_PrivateDevice_ThenAdd_DeviceToCollection_TheRemove_DeviceFromCollection_AndDelete_Both()
{
using (var client = new M2XClient(_masterKey))
{
var collectionParameters = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Collection {DateTime.UtcNow.Ticks}\" }}";
var createCollectionResult = await client.CreateCollection(collectionParameters);
Assert.IsNotNull(createCollectionResult);
Assert.IsFalse(createCollectionResult.Error);
Assert.IsFalse(createCollectionResult.ServerError);
Assert.IsNull(createCollectionResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(createCollectionResult.Raw));
var collection = JsonConvert.DeserializeObject <Collection>(createCollectionResult.Raw);
Assert.IsNotNull(collection);
var collectionWrapper = client.Collection(collection.id);
Assert.IsNotNull(collectionWrapper);
var deviceParameters = $"{{ \"name\": \"*** PLEASE DELETE ME *** Test Auto Created Device {DateTime.UtcNow.Ticks}\", \"visibility\": \"private\" }}";
var result = await client.CreateDevice(deviceParameters);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var device = JsonConvert.DeserializeObject <Device>(result.Raw);
Assert.IsNotNull(device);
var addCollectionDeviceResult = await collectionWrapper.AddDevice(device.id);
Assert.IsNotNull(addCollectionDeviceResult);
Assert.IsTrue(string.IsNullOrWhiteSpace(addCollectionDeviceResult.Raw));
var checkCollectionDevices0 = await collectionWrapper.Details();
Assert.IsNotNull(checkCollectionDevices0);
Assert.IsFalse(string.IsNullOrWhiteSpace(checkCollectionDevices0.Raw));
var checkCollection0 = JsonConvert.DeserializeObject <Collection>(checkCollectionDevices0.Raw);
Assert.IsNotNull(checkCollection0);
Assert.IsTrue(checkCollection0.devices > 0);
var removeCollectionDeviceResult = await collectionWrapper.RemoveDevice(device.id);
Assert.IsNotNull(removeCollectionDeviceResult);
Assert.IsTrue(string.IsNullOrWhiteSpace(removeCollectionDeviceResult.Raw));
var checkCollectionDevices1 = await collectionWrapper.Details();
Assert.IsNotNull(checkCollectionDevices1);
Assert.IsFalse(string.IsNullOrWhiteSpace(checkCollectionDevices1.Raw));
var checkCollection1 = JsonConvert.DeserializeObject <Collection>(checkCollectionDevices1.Raw);
Assert.IsNotNull(checkCollection1);
Assert.IsTrue(checkCollection1.devices == 0);
var deviceWrapper = client.Device(device.id, device.serial != null ? device.serial.ToString() : null);
Assert.IsNotNull(deviceWrapper);
await deviceWrapper.Delete();
var devicesCheck = await client.SearchDevices(new { ids = device.id });
Assert.IsNotNull(devicesCheck);
Assert.IsFalse(devicesCheck.Error);
Assert.IsFalse(devicesCheck.ServerError);
Assert.IsNull(devicesCheck.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(devicesCheck.Raw));
ProcessDeviceSearchResult(devicesCheck.Raw, false);
await collectionWrapper.Delete();
var collectionCheck = client.Collection(collection.id);
var collectionCheckResult = await collectionCheck.Details();
Assert.IsNotNull(collectionCheck);
Assert.IsTrue(collectionCheckResult.Error);
Assert.IsFalse(collectionCheckResult.ServerError);
Assert.IsNull(collectionCheckResult.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(collectionCheckResult.Raw));
ProcessCollectionsSearchResult(collectionCheckResult.Raw, false);
}
}
public async Task CanAccess_MasterApiKey_AndSendCommands_ToSingleDevice_AndView_Single_DeviceCommand()
{
try
{
var commandName = "PHONE_HOME";
using (var client = new M2XClient(_masterKey))
{
var sendCommandParms = new StringBuilder($"{{ ");
sendCommandParms.Append($"\"name\": \"{commandName}\"");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"data\": {{ \"server_url\": \"https://m2x.att.com\" }}");
sendCommandParms.Append($", ");
sendCommandParms.Append($"\"targets\": {{ \"devices\": [\"{_testDevice.id}\"] }}");
sendCommandParms.Append($" }}");
var result = await client.SendCommand(sendCommandParms.ToString());
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
Assert.AreEqual(Constants.M2X_Response_Success_Accepted, result.Raw);
}
System.Threading.Thread.Sleep(500);
var targetCommandId = string.Empty;
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
var result = await device.Commands();
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var commandData = JsonConvert.DeserializeObject <ApiResponseForCommandSearch>(result.Raw);
Assert.IsNotNull(commandData);
targetCommandId = commandData.commands.First().id;
}
System.Threading.Thread.Sleep(500);
using (var client = new M2XClient(_masterKey))
{
var device = client.Device(_testDevice.id);
var result = await device.CommandDetails(targetCommandId);
Assert.IsNotNull(result);
Assert.IsFalse(result.Error);
Assert.IsFalse(result.ServerError);
Assert.IsNull(result.WebError);
Assert.IsFalse(string.IsNullOrWhiteSpace(result.Raw));
var commandDetail = JsonConvert.DeserializeObject <ApiResponseForCommandDetail>(result.Raw);
Assert.IsNotNull(commandDetail);
Assert.IsNotNull(commandDetail.data);
Assert.AreNotEqual(default(DateTime), commandDetail.sent_at);
Assert.AreEqual(commandName, commandDetail.name);
}
}
catch (Exception ex)
{
DestroyTestDevice();
throw;
}
}
