public async Task CallFunctionAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("POST", a);
Assert.AreEqual("devices/3/led", b);
Assert.AreEqual(1, c.Count());
var first = c.FirstOrDefault();
Assert.IsNotNull(first);
Assert.AreEqual("arg", first.Key);
Assert.AreEqual("on", first.Value);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'id': '3',
'name': 'led',
'last_app': '',
'connected': true,
'return_value': 1
}")
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'functions':['led']}"));
var exc = Assert.Throws <ArgumentNullException>(() => { p.CallFunctionAsync(null, "").GetAwaiter().GetResult(); });
Assert.AreEqual("functionName", exc.ParamName);
var result = await p.CallFunctionAsync("led", "on");
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.Data);
}
}
public async Task RefreshAsyncTest()
{
ParticleCloudMock cloud = new ParticleCloudMock();
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3", b);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'id': '3',
'name': 'Work',
'last_app': 'cheese',
'last_ip_address': '192.168.0.1',
'last_heard': '2015-05-25T01:15:36.034Z',
'product_id': 0,
'connected': true,
'variables':{
temp: 'double',
temp2: 'int',
temp3: 'string'
},
'functions':[
'led',
'led2'
]}" )
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.RefreshAsync();
Assert.IsTrue(result.Success);
Assert.AreEqual("3", p.Id);
Assert.AreEqual("Work", p.Name);
Assert.AreEqual("cheese", p.LastApp);
Assert.AreEqual("192.168.0.1", p.LastIPAddress);
Assert.AreEqual(JToken.Parse("'2015-05-25T01:15:36.034Z'").Value <DateTime>().ToLocalTime(), p.LastHeard);
Assert.AreEqual(ParticleDeviceType.Core, p.DeviceType);
Assert.IsTrue(p.Connected);
Assert.AreEqual(3, p.Variables.Count);
var variable = p.Variables[0];
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual(VariableType.Double, variable.Type);
variable = p.Variables[1];
Assert.AreEqual("temp2", variable.Name);
Assert.AreEqual(VariableType.Int, variable.Type);
variable = p.Variables[2];
Assert.AreEqual("temp3", variable.Name);
Assert.AreEqual(VariableType.String, variable.Type);
var functions = p.Functions;
Assert.AreEqual(2, functions.Count);
Assert.AreEqual("led", functions[0]);
Assert.AreEqual("led2", functions[1]);
}
public async Task GetDevicesAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"[
{
""id"": ""1"",
""name"": ""Work"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-05-25T01:15:36.034Z"",
""product_id"": 0,
""connected"": false
},
{
""id"": ""2"",
""name"": ""Home"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-05-25T01:15:59.188Z"",
""product_id"": 0,
""connected"": false
},
{
""id"": ""3"",
""name"": ""Proto"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-07-24T00:37:07.820Z"",
""product_id"": 6,
""connected"": true
}
]")
});
};
var result = await cloud.GetDevicesAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Data);
var devices = result.Data;
Assert.AreEqual(3, devices.Count);
var device = devices[0];
Assert.AreEqual("1", device.Id);
Assert.AreEqual("Work", device.Name);
device = devices[1];
Assert.AreEqual("2", device.Id);
Assert.AreEqual("Home", device.Name);
device = devices[2];
Assert.AreEqual("3", device.Id);
Assert.AreEqual("Proto", device.Name);
}
}
public async Task RenameAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("name", p1.Key);
Assert.AreEqual("newTest", p1.Value);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'error': 'Nothing to do?'
}" )
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var exc = Assert.Throws <ArgumentNullException>(() => { p.RenameAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("newName", exc.ParamName);
var result = await p.RenameAsync("newTest");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Nothing to do?", result.Error);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("name", p1.Key);
Assert.AreEqual("newTest", p1.Value);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
name: 'newTest',
id: '1234'
}" )
});
};
result = await p.RenameAsync("newTest");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task ClaimDeviceAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
ok: false,
errors: ['device does not exist']
}")
});
};
var ex = Assert.Throws <ArgumentNullException>(() => { cloud.ClaimDeviceAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("deviceId", ex.ParamName);
var result = await cloud.ClaimDeviceAsync("123");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("device does not exist", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
'user_id': '111111111111111111111111',
'id': '222222222222222222222222',
'connected': true,
'ok': true
}")
});
};
result = await cloud.ClaimDeviceAsync("222222222222222222222222");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task SignupWithUserAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
ok: false,
errors:[""username must be an email address""]
}")
});
};
ArgumentNullException e = Assert.Throws <ArgumentNullException>(() => { cloud.SignupWithUserAsync(null, "test").GetAwaiter().GetResult(); });
Assert.AreEqual("username", e.ParamName);
e = Assert.Throws <ArgumentNullException>(() => { cloud.SignupWithUserAsync("test", null).GetAwaiter().GetResult(); });
Assert.AreEqual("password", e.ParamName);
var result = await cloud.SignupWithUserAsync("test", "test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("username must be an email address", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
ok: true
}")
});
};
result = await cloud.SignupWithUserAsync("*****@*****.**", "test");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task RequestPasswordResetAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
'ok': false,
'error': 'User not found.'
}")
});
};
var ex = Assert.Throws <ArgumentNullException>(() => { cloud.RequestPasswordResetAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("email", ex.ParamName);
var result = await cloud.RequestPasswordResetAsync("test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("User not found.", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return(new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
'ok': true,
'message': 'Password reset email sent.'
}")
});
};
result = await cloud.RequestPasswordResetAsync("*****@*****.**");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual("Password reset email sent.", result.Message);
}
}
public async Task RequestPasswordResetAsyncHttpRequestExceptionTest()
{
using (var cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Error connecting to server");
cloud.RequestCallBack = (t, m, p) =>
{
throw ex;
};
var result = await cloud.RequestPasswordResetAsync("test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task CallFunctionAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to Resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'functions':['led']}"));
Assert.IsNotNull(p);
var cf = await p.CallFunctionAsync("LED", "cheese");
Assert.IsNotNull(cf);
Assert.AreEqual(ex.Message, cf.Error);
Assert.AreEqual(ex, cf.Exception);
}
}
public async Task UnclaimAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("DELETE", a);
Assert.AreEqual("devices/3", b);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.Forbidden,
Response = JToken.Parse(@"{
'error': 'Permission Denied',
'info': 'I didn\'t recognize that device name or ID, try opening https://api.particle.io/v1/devices?access_token=...'
}" )
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.UnclaimAsync();
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Permission Denied", result.Error);
Assert.AreEqual("I didn\'t recognize that device name or ID, try opening https://api.particle.io/v1/devices?access_token=...", result.Message);
cloud.RequestCallBack = (a, b, c) =>
{
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'ok': true
}" )
});
};
result = await p.UnclaimAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task FlashKnownAppAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.FlashKnownAppAsync("tinker");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task ClaimDeviceAsyncHttpRequestExceptionTest()
{
using (var cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Text HttpClient Request Exception");
cloud.RequestCallBack = (t, m, p) =>
{
throw ex;
//return new RequestResponse();
};
var result = await cloud.ClaimDeviceAsync("123");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task GetVariableValueAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'variables':{'temp':'int'}}"));
Assert.IsNotNull(p);
var vv = await p.GetVariableValueAsync("Test");
Assert.IsNotNull(vv);
Assert.IsFalse(vv.Success);
Assert.AreEqual(ex.Message, vv.Error);
Assert.AreEqual(ex, vv.Exception);
}
}
public async Task CallFunctionAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to Resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'functions':['led']}"));
Assert.IsNotNull(p);
var cf = await p.CallFunctionAsync("LED", "cheese");
Assert.IsNotNull(cf);
Assert.AreEqual(ex.Message, cf.Error);
Assert.AreEqual(ex, cf.Exception);
}
}
public async Task CallFunctionAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("POST", a);
Assert.AreEqual("devices/3/led", b);
Assert.AreEqual(1, c.Count());
var first = c.FirstOrDefault();
Assert.IsNotNull(first);
Assert.AreEqual("arg", first.Key);
Assert.AreEqual("on", first.Value);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'id': '3',
'name': 'led',
'last_app': '',
'connected': true,
'return_value': 1
}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'functions':['led']}"));
var exc = Assert.Throws<ArgumentNullException>(() => { p.CallFunctionAsync(null, "").GetAwaiter().GetResult(); });
Assert.AreEqual("functionName", exc.ParamName);
var result = await p.CallFunctionAsync("led", "on");
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.Data);
}
}
public async Task GetVariableValueAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'variables':{'temp':'int'}}"));
Assert.IsNotNull(p);
var vv = await p.GetVariableValueAsync("Test");
Assert.IsNotNull(vv);
Assert.IsFalse(vv.Success);
Assert.AreEqual(ex.Message, vv.Error);
Assert.AreEqual(ex, vv.Exception);
}
}
public async Task GetVariableValueAsyncTest()
{
ParticleCloudMock cloud = new ParticleCloudMock();
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3/temp", b);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'name': 'temp',
'result': 300,
'coreInfo': {
'name': 'weatherman',
'deviceID': '0123456789abcdef01234567',
'connected': true,
'last_handshake_at': '2015-07-17T22:28:40.907Z',
'last_app': ''
}}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'variables':{'temp':'int'}}"));
var ex = Assert.Throws<ArgumentNullException>(() => { p.GetVariableValueAsync((String)null).GetAwaiter().GetResult(); });
Assert.AreEqual("variable", ex.ParamName);
ex = Assert.Throws<ArgumentNullException>(() => { p.GetVariableValueAsync((Variable)null).GetAwaiter().GetResult(); });
Assert.AreEqual("variable", ex.ParamName);
var results = await p.GetVariableValueAsync("temp");
Assert.IsTrue(results.Success);
Assert.IsNotNull(results.Data);
var variable = results.Data;
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual("300", variable.Value);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3/temp", b);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'name': 'temp',
'result': 23,
'coreInfo': {
'name': 'weatherman',
'deviceID': '0123456789abcdef01234567',
'connected': true,
'last_handshake_at': '2015-07-17T22:28:40.907Z',
'last_app': ''
}}")
};
};
results = await p.GetVariableValueAsync(variable);
Assert.IsTrue(results.Success);
Assert.IsNotNull(results.Data);
variable = results.Data;
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual("23", variable.Value);
}
public async Task RefreshAsyncTest()
{
ParticleCloudMock cloud = new ParticleCloudMock();
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3", b);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'id': '3',
'name': 'Work',
'last_app': 'cheese',
'last_ip_address': '192.168.0.1',
'last_heard': '2015-05-25T01:15:36.034Z',
'product_id': 0,
'connected': true,
'variables':{
temp: 'double',
temp2: 'int',
temp3: 'string'
},
'functions':[
'led',
'led2'
]}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.RefreshAsync();
Assert.IsTrue(result.Success);
Assert.AreEqual("3", p.Id);
Assert.AreEqual("Work", p.Name);
Assert.AreEqual("cheese", p.LastApp);
Assert.AreEqual("192.168.0.1", p.LastIPAddress);
Assert.AreEqual(JToken.Parse("'2015-05-25T01:15:36.034Z'").Value<DateTime>().ToLocalTime(), p.LastHeard);
Assert.AreEqual(ParticleDeviceType.Core, p.DeviceType);
Assert.IsTrue(p.Connected);
Assert.AreEqual(3, p.Variables.Count);
var variable = p.Variables[0];
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual(VariableType.Double, variable.Type);
variable = p.Variables[1];
Assert.AreEqual("temp2", variable.Name);
Assert.AreEqual(VariableType.Int, variable.Type);
variable = p.Variables[2];
Assert.AreEqual("temp3", variable.Name);
Assert.AreEqual(VariableType.String, variable.Type);
var functions = p.Functions;
Assert.AreEqual(2, functions.Count);
Assert.AreEqual("led", functions[0]);
Assert.AreEqual("led2", functions[1]);
}
public async Task GetVariableValueAsyncTest()
{
ParticleCloudMock cloud = new ParticleCloudMock();
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3/temp", b);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'name': 'temp',
'result': 300,
'coreInfo': {
'name': 'weatherman',
'deviceID': '0123456789abcdef01234567',
'connected': true,
'last_handshake_at': '2015-07-17T22:28:40.907Z',
'last_app': ''
}}" )
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test', 'variables':{'temp':'int'}}"));
var ex = Assert.Throws <ArgumentNullException>(() => { p.GetVariableValueAsync((String)null).GetAwaiter().GetResult(); });
Assert.AreEqual("variable", ex.ParamName);
ex = Assert.Throws <ArgumentNullException>(() => { p.GetVariableValueAsync((Variable)null).GetAwaiter().GetResult(); });
Assert.AreEqual("variable", ex.ParamName);
var results = await p.GetVariableValueAsync("temp");
Assert.IsTrue(results.Success);
Assert.IsNotNull(results.Data);
var variable = results.Data;
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual("300", variable.Value);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("GET", a);
Assert.AreEqual("devices/3/temp", b);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{'name': 'temp',
'result': 23,
'coreInfo': {
'name': 'weatherman',
'deviceID': '0123456789abcdef01234567',
'connected': true,
'last_handshake_at': '2015-07-17T22:28:40.907Z',
'last_app': ''
}}" )
});
};
results = await p.GetVariableValueAsync(variable);
Assert.IsTrue(results.Success);
Assert.IsNotNull(results.Data);
variable = results.Data;
Assert.AreEqual("temp", variable.Name);
Assert.AreEqual("23", variable.Value);
}
public async Task RequestPasswordResetAsyncHttpRequestExceptionTest()
{
using (var cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Error connecting to server");
cloud.RequestCallBack = (t, m, p) =>
{
throw ex;
};
var result = await cloud.RequestPasswordResetAsync("test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task ClaimDeviceAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
ok: false,
errors: ['device does not exist']
}")
};
};
var ex = Assert.Throws<ArgumentNullException>(() => { cloud.ClaimDeviceAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("deviceId", ex.ParamName);
var result = await cloud.ClaimDeviceAsync("123");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("device does not exist", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
'user_id': '111111111111111111111111',
'id': '222222222222222222222222',
'connected': true,
'ok': true
}")
};
};
result = await cloud.ClaimDeviceAsync("222222222222222222222222");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task ClaimDeviceAsyncHttpRequestExceptionTest()
{
using (var cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Text HttpClient Request Exception");
cloud.RequestCallBack = (t, m, p) =>
{
throw ex;
//return new RequestResponse();
};
var result = await cloud.ClaimDeviceAsync("123");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task SignupWithUserAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
ok: false,
errors:[""username must be an email address""]
}")
};
};
ArgumentNullException e = Assert.Throws<ArgumentNullException>(() => { cloud.SignupWithUserAsync(null, "test").GetAwaiter().GetResult(); });
Assert.AreEqual("username", e.ParamName);
e = Assert.Throws<ArgumentNullException>(() => { cloud.SignupWithUserAsync("test", null).GetAwaiter().GetResult(); });
Assert.AreEqual("password", e.ParamName);
var result = await cloud.SignupWithUserAsync("test", "test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("username must be an email address", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
ok: true
}")
};
};
result = await cloud.SignupWithUserAsync("*****@*****.**", "test");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task FlashExampleAppAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("app_example_id", p1.Key);
Assert.AreEqual("56214d636666d9ece3000001", p1.Value);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'ok': false,
'code': 500,
'errors': [
'Can\'t flash unknown app newTest'
]
}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var exc = Assert.Throws<ArgumentNullException>(() => { p.FlashExampleAppAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("exampleId", exc.ParamName);
var result = await p.FlashExampleAppAsync("56214d636666d9ece3000001");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Can't flash unknown app newTest", result.Error);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("app_example_id", p1.Key);
Assert.AreEqual("56214d636666d9ece3000006", p1.Value);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'id': '3',
'status': 'Update started'
}")
};
};
result = await p.FlashExampleAppAsync("56214d636666d9ece3000006");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual("Update started", result.Message);
}
}
public async Task FlashExampleAppAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("app_example_id", p1.Key);
Assert.AreEqual("56214d636666d9ece3000001", p1.Value);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'ok': false,
'code': 500,
'errors': [
'Can\'t flash unknown app newTest'
]
}" )
});
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var exc = Assert.Throws <ArgumentNullException>(() => { p.FlashExampleAppAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("exampleId", exc.ParamName);
var result = await p.FlashExampleAppAsync("56214d636666d9ece3000001");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Can't flash unknown app newTest", result.Error);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("app_example_id", p1.Key);
Assert.AreEqual("56214d636666d9ece3000006", p1.Value);
return(new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'id': '3',
'status': 'Update started'
}")
});
};
result = await p.FlashExampleAppAsync("56214d636666d9ece3000006");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual("Update started", result.Message);
}
}
public async Task UnclaimAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("DELETE", a);
Assert.AreEqual("devices/3", b);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.Forbidden,
Response = JToken.Parse(@"{
'error': 'Permission Denied',
'info': 'I didn\'t recognize that device name or ID, try opening https://api.particle.io/v1/devices?access_token=...'
}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.UnclaimAsync();
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Permission Denied", result.Error);
Assert.AreEqual("I didn\'t recognize that device name or ID, try opening https://api.particle.io/v1/devices?access_token=...", result.Message);
cloud.RequestCallBack = (a, b, c) =>
{
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'ok': true
}")
};
};
result = await p.UnclaimAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task RenameAsyncTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("name", p1.Key);
Assert.AreEqual("newTest", p1.Value);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
'error': 'Nothing to do?'
}")
};
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var exc = Assert.Throws<ArgumentNullException>(() => { p.RenameAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("newName", exc.ParamName);
var result = await p.RenameAsync("newTest");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("Nothing to do?", result.Error);
cloud.RequestCallBack = (a, b, c) =>
{
Assert.AreEqual("PUT", a);
Assert.AreEqual("devices/3", b);
Assert.AreEqual(1, c.Length);
var p1 = c[0];
Assert.AreEqual("name", p1.Key);
Assert.AreEqual("newTest", p1.Value);
return new RequestResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Response = JToken.Parse(@"{
name: 'newTest',
id: '1234'
}")
};
};
result = await p.RenameAsync("newTest");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
}
}
public async Task RequestPasswordResetAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.NotFound,
Response = JToken.Parse(@"
{
'ok': false,
'error': 'User not found.'
}")
};
};
var ex = Assert.Throws<ArgumentNullException>(() => { cloud.RequestPasswordResetAsync(null).GetAwaiter().GetResult(); });
Assert.AreEqual("email", ex.ParamName);
var result = await cloud.RequestPasswordResetAsync("test");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual("User not found.", result.Error);
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"
{
'ok': true,
'message': 'Password reset email sent.'
}")
};
};
result = await cloud.RequestPasswordResetAsync("*****@*****.**");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual("Password reset email sent.", result.Message);
}
}
public async Task FlashKnownAppAsyncHttpRequestExceptionTest()
{
using (ParticleCloudMock cloud = new ParticleCloudMock())
{
var ex = new HttpRequestException("Unable to resolve");
cloud.RequestCallBack = (a, b, c) =>
{
throw ex;
};
var p = new ParticleDeviceMock(cloud, JObject.Parse("{'id':'3', 'name': 'test'}"));
var result = await p.FlashKnownAppAsync("tinker");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(ex.Message, result.Error);
Assert.AreEqual(ex, result.Exception);
}
}
public async Task GetDevicesAsyncTest()
{
using (var cloud = new ParticleCloudMock())
{
cloud.RequestCallBack = (t, m, p) =>
{
return new RequestResponse
{
StatusCode = HttpStatusCode.OK,
Response = JToken.Parse(@"[
{
""id"": ""1"",
""name"": ""Work"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-05-25T01:15:36.034Z"",
""product_id"": 0,
""connected"": false
},
{
""id"": ""2"",
""name"": ""Home"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-05-25T01:15:59.188Z"",
""product_id"": 0,
""connected"": false
},
{
""id"": ""3"",
""name"": ""Proto"",
""last_app"": null,
""last_ip_address"": ""192.168.0.1"",
""last_heard"": ""2015-07-24T00:37:07.820Z"",
""product_id"": 6,
""connected"": true
}
]")
};
};
var result = await cloud.GetDevicesAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Data);
var devices = result.Data;
Assert.AreEqual(3, devices.Count);
var device = devices[0];
Assert.AreEqual("1", device.Id);
Assert.AreEqual("Work", device.Name);
device = devices[1];
Assert.AreEqual("2", device.Id);
Assert.AreEqual("Home", device.Name);
device = devices[2];
Assert.AreEqual("3", device.Id);
Assert.AreEqual("Proto", device.Name);
}
}
