public void ProcessSleepData_MinuteDataTomorrow()
{
var client = new FitbitClient("key", "secret", "token", "secret");
var sleep = new SleepData
{
Sleep = new List <SleepLog>
{
new SleepLog
{
StartTime = new DateTime(2014, 10, 10, 22, 0, 0),
MinuteData = new List <MinuteData>
{
new MinuteData
{
DateTime = new DateTime(1900, 1, 1, 4, 0, 0) // the date part is derived
}
}
}
}
};
client.ProcessSleepData(sleep);
Assert.AreEqual(new DateTime(2014, 10, 11, 4, 0, 0), sleep.Sleep[0].MinuteData[0].DateTime);
}
public void TestInstantiation()
{
FitbitClient client = null;
try
{
client = new FitbitClient(null);
// Should throw an ArgumentNullException for missing identity.
Assert.Fail("ArgumentNullException should have been thrown.");
}
catch (ArgumentNullException)
{
}
try
{
client = new FitbitClient(new ClaimsIdentity());
// Should throw an ArgumentException for missing properies.
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
client = this.CreateFitbitClientInstance();
// Everything should be fine.
Assert.IsInstanceOfType(
client,
typeof(FitbitClient),
"The FitbitClient was not instantiated."
);
}
public void Can_Handle_Failed_Refresh_Operation()
{
const int EXPECT_TWO_COUNT_STALE_AND_RETRY = 2;
var originalToken = new OAuth2AccessToken()
{
Token = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0MzAzNDM3MzUsInNjb3BlcyI6Indwcm8gd2xvYyB3bnV0IHdzbGUgd3NldCB3aHIgd3dlaSB3YWN0IHdzb2MiLCJzdWIiOiJBQkNERUYiLCJhdWQiOiJJSktMTU4iLCJpc3MiOiJGaXRiaXQiLCJ0eXAiOiJhY2Nlc3NfdG9rZW4iLCJpYXQiOjE0MzAzNDAxMzV9.z0VHrIEzjsBnjiNMBey6wtu26yHTnSWz_qlqoEpUlpc"
};
var refreshedToken = new OAuth2AccessToken()
{
Token = "Refreshed"
};
//mocking our implementation of token manager. This test is concerned with ensuring the wiring is done correctly. Not the actual refresh process.
var fakeManager = new Mock <ITokenManager>();
fakeManager.Setup(m => m.RefreshTokenAsync(It.IsAny <FitbitClient>())).Returns(() => Task.Run(() => refreshedToken));
//simulate failed refresh token.
var fakeServer = new StaleTokenFaker(10);
var sut = new FitbitClient(dummyCredentials, originalToken, fakeServer, fakeManager.Object);
//Act
var r = sut.HttpClient.GetAsync("https://dev.fitbit.com/");
Assert.Throws <System.AggregateException>(() => r.Wait());
}
/*
* public string TestTimeSeries()
* {
* FitbitClient client = GetFitbitClient();
*
* var results = client.GetTimeSeries(TimeSeriesResourceType.DistanceTracker, DateTime.UtcNow.AddDays(-7), DateTime.UtcNow);
*
* string sOutput = "";
* foreach (var result in results.DataList)
* {
* sOutput += result.DateTime.ToString() + " - " + result.Value.ToString();
* }
*
* return sOutput;
*
* }
*
* public ActionResult LastWeekDistance()
* {
* FitbitClient client = GetFitbitClient();
*
* TimeSeriesDataList results = client.GetTimeSeries(TimeSeriesResourceType.Distance, DateTime.UtcNow.AddDays(-7), DateTime.UtcNow);
*
* return View(results);
* }
*/
public async Task <ActionResult> LastWeekSteps()
{
FitbitClient client = GetFitbitClient();
var response = await client.GetTimeSeriesIntAsync(TimeSeriesResourceType.Steps, DateTime.UtcNow.AddDays(-7), DateTime.UtcNow);
return(View(response));
}
public void Start()
{
DailyLogClient logClient = new DailyLogClient();
FitbitClient fitbitClient = new FitbitClient(ConsumerKey, ConsumerSecret, AccessTokenKey, AccessTokenSecret);
//for (DateTime dt = fitbitClient.GetActivityTrackerFirstDay().Value; dt <= DateTime.Today; dt = dt.AddDays(1))
//{
DateTime queryDate = DateTime.Today;
var day = fitbitClient.GetDayActivity(queryDate).Summary;
var sleep = fitbitClient.GetSleep(queryDate).Summary;
DailyLog log = logClient.Get(queryDate);
log.Distance = day.Distances.FirstOrDefault(x => x.Activity == "total").Distance;
log.CaloriesOut = day.CaloriesOut;
log.FairlyActiveMinutes = day.FairlyActiveMinutes;
log.LightlyActiveMinutes = day.LightlyActiveMinutes;
log.SedentaryMinutes = day.SedentaryMinutes;
log.Steps = day.Steps;
log.VeryActiveMinutes = day.VeryActiveMinutes;
log.TimeInBadMinutes = sleep.TotalTimeInBed;
log.SleepMinutes = sleep.TotalMinutesAsleep;
logClient.InsertOrReplace(log);
//}
}
public async Task Disable_Automatic_Token_Refresh()
{
var originalToken = new OAuth2AccessToken()
{
Token = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0MzAzNDM3MzUsInNjb3BlcyI6Indwcm8gd2xvYyB3bnV0IHdzbGUgd3NldCB3aHIgd3dlaSB3YWN0IHdzb2MiLCJzdWIiOiJBQkNERUYiLCJhdWQiOiJJSktMTU4iLCJpc3MiOiJGaXRiaXQiLCJ0eXAiOiJhY2Nlc3NfdG9rZW4iLCJpYXQiOjE0MzAzNDAxMzV9.z0VHrIEzjsBnjiNMBey6wtu26yHTnSWz_qlqoEpUlpc"
};
var refreshedToken = new OAuth2AccessToken()
{
Token = "Refreshed"
};
//mocking our implementation of token manager. This test is concerned with ensuring the wiring is done correctly. Not the actual refresh process.
var fakeManager = new Mock <ITokenManager>();
fakeManager.Setup(m => m.RefreshTokenAsync(It.IsAny <FitbitClient>())).Returns(() => Task.Run(() => refreshedToken));
//we shortcircuit the request to return a stale token and ensure that the client lets the stale token response through
var fakeServer = new StaleTokenFaker();
var sut = new FitbitClient(dummyCredentials, originalToken, fakeServer, false, fakeManager.Object);
//Act
var actualResponse = await sut.HttpClient.GetAsync("https://dev.fitbit.com/");
//Assert
Assert.AreEqual(fakeServer.staleTokenresponse, actualResponse);
}
private static async Task <IntradayData> GetIntraDayTimeSeriesAsync(FitbitClient client, DateTime date)
{
TimeSpan timeSpan = date.AddDays(1) - date;
IntradayData x = await client.GetIntraDayTimeSeriesAsync(IntradayResourceType.Steps, date, timeSpan);
return(x);
}
public async Task Correctly_Detects_Stale_Token_Refreshes_And_Retries_Original_Request()
{
var originalToken = new OAuth2AccessToken()
{
Token = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0MzAzNDM3MzUsInNjb3BlcyI6Indwcm8gd2xvYyB3bnV0IHdzbGUgd3NldCB3aHIgd3dlaSB3YWN0IHdzb2MiLCJzdWIiOiJBQkNERUYiLCJhdWQiOiJJSktMTU4iLCJpc3MiOiJGaXRiaXQiLCJ0eXAiOiJhY2Nlc3NfdG9rZW4iLCJpYXQiOjE0MzAzNDAxMzV9.z0VHrIEzjsBnjiNMBey6wtu26yHTnSWz_qlqoEpUlpc"
};
var refreshedToken = new OAuth2AccessToken()
{
Token = "Refreshed"
};
//mocking our implementation of token manager. This test is concerned with ensuring the wiring is done correctly. Not the actual refresh process.
var fakeManager = new Mock <ITokenManager>();
fakeManager.Setup(m => m.RefreshTokenAsync(It.IsAny <FitbitClient>())).Returns(() => Task.Run(() => refreshedToken));
//we shortcircuit the request to fake an expired token on the first request, and assuming the token is different the second time we let the request through
var fakeServer = new StaleTokenFaker();
var sut = new FitbitClient(dummyCredentials, originalToken, fakeServer, /*Explicity activate autorefresh, default is true*/ true, fakeManager.Object);
//Act
var actualResponse = await sut.HttpClient.GetAsync("https://dev.fitbit.com/");
//Assert
Assert.AreEqual(refreshedToken, sut.AccessToken);
fakeManager.Verify(m => m.RefreshTokenAsync(It.IsAny <FitbitClient>()), Times.Once);
//Expecte two interceptions. First when we get the 401 refresh, and second when we retry after refreshing the stale token
Assert.AreEqual(2, fakeServer.requestCount, "It looks like either the client did not retry after the token was refreshed, or the stale token was not detected");
}
public async Task GetDevicesAsync_Success()
{
string content = SampleDataHelper.GetContent("GetDevices-Single.json");
Func <HttpResponseMessage> responseMessage = new Func <HttpResponseMessage>(() =>
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(content)
});
});
Action <HttpRequestMessage, CancellationToken> verification = new Action <HttpRequestMessage, CancellationToken>((message, token) =>
{
Assert.AreEqual(HttpMethod.Get, message.Method);
Assert.AreEqual("https://api.fitbit.com/1/user/-/devices.json", message.RequestUri.AbsoluteUri);
});
FitbitClient fitbitClient = Helper.CreateFitbitClient(responseMessage, verification);
List <Device> response = await fitbitClient.GetDevicesAsync();
Assert.AreEqual(1, response.Count);
Device device = response.First();
ValidateSingleDevice(device);
}
public void Returns_content_if_response_is_OK()
{
string content = File.ReadAllText(SampleData.PathFor("DateActivity.txt"));
var mock = new Mock <IRestClient>();
var deserializer = new RestSharp.Deserializers.XmlDeserializer();
deserializer.RootElement = "summary";
mock.Setup(x => x.Execute <ActivitySummary>(It.IsAny <IRestRequest>()))
.Returns(new RestResponse <ActivitySummary>
{
StatusCode = HttpStatusCode.OK,
Content = content,
Data = deserializer.Deserialize <ActivitySummary>(new RestResponse()
{
Content = content
})
});
//var client = new GuidClient(mock.Object);
FitbitClient fitbitClient = new FitbitClient(mock.Object);
var result = fitbitClient.GetDayActivitySummary(DateTime.Now);
Assert.IsNotNull(result);
Assert.AreEqual(12345, result.Steps);
}
public async Task <OAuth2AccessToken> RefreshTokenAsync(FitbitClient client)
{
string postUrl = FitbitOauthPostUrl;
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "refresh_token"),
new KeyValuePair <string, string>("refresh_token", client.AccessToken.RefreshToken),
});
HttpClient httpClient;
if (client.HttpClient == null)
{
httpClient = new HttpClient();
}
else
{
httpClient = client.HttpClient;
}
var clientIdConcatSecret = OAuth2Helper.Base64Encode(client.AppCredentials.ClientId + ":" + client.AppCredentials.ClientSecret);
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", clientIdConcatSecret);
HttpResponseMessage response = await httpClient.PostAsync(postUrl, content);
string responseString = await response.Content.ReadAsStringAsync();
return(OAuth2Helper.ParseAccessTokenResponse(responseString));
}
public async Task GetIntraDayTimeSeriesStepsAsync_Success()
{
DateTime expectedResult = new DateTime(2016, 3, 8, 0, 1, 0);
string content = SampleDataHelper.GetContent("IntradayActivitiesSteps.json");
Func <HttpResponseMessage> responseMessage = new Func <HttpResponseMessage>(() =>
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(content)
});
});
Action <HttpRequestMessage, CancellationToken> verification = new Action <HttpRequestMessage, CancellationToken>((message, token) =>
{
message.Method.Should().Be(HttpMethod.Get);
message.RequestUri.AbsoluteUri.Should().Be("https://api.fitbit.com/1/user/-/activities/steps/date/2016-03-08/1d.json");
});
FitbitClient fitbitClient = Helper.CreateFitbitClient(responseMessage, verification);
IntradayData response = await fitbitClient.GetIntraDayTimeSeriesAsync(IntradayResourceType.Steps, new DateTime(2016, 3, 8), new TimeSpan(24, 0, 0));
response.DataSet[1].Time.Should().Be(expectedResult);
response.DataSet[1].Value.Should().Be("2");
}
static void Main(string[] args)
{
//Example of getting the Auth credentials for the first time by directoring the
//user to the fitbit site to get a PIN.
var consumerKey = "YOUR_CONSUMER_KEY_HERE";
var consumerSecret = "YOUR_CONSUMER_SECRET_HERE";
var requestTokenUrl = "http://api.fitbit.com/oauth/request_token";
var accessTokenUrl = "http://api.fitbit.com/oauth/access_token";
var authorizeUrl = "http://www.fitbit.com/oauth/authorize";
var a = new Authenticator(consumerKey, consumerSecret, requestTokenUrl, accessTokenUrl, authorizeUrl);
RequestToken token = a.GetRequestToken();
var url = a.GenerateAuthUrlFromRequestToken(token, false);
Process.Start(url);
Console.WriteLine("Enter the verification code from the website");
var pin = Console.ReadLine();
var credentials = a.GetAuthCredentialFromPin(pin, token);
//If you already have your credentials stored then rather than getting the users PIN again
//you could just start here
var fitbit = new FitbitClient(consumerKey, consumerSecret, credentials.AuthToken, credentials.AuthTokenSecret);
var profile = fitbit.GetUserProfile();
Console.WriteLine("Your last weight was {0}", profile.Weight);
Console.ReadLine();
}
public async Task GetSleepAsync_Success()
{
string content = SampleDataHelper.GetContent("GetSleep.json");
Func <HttpResponseMessage> responseMessage = new Func <HttpResponseMessage>(() =>
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(content)
});
});
Action <HttpRequestMessage, CancellationToken> verification = new Action <HttpRequestMessage, CancellationToken>((message, token) =>
{
Assert.AreEqual(HttpMethod.Get, message.Method);
Assert.AreEqual("https://api.fitbit.com/1.2/user/-/sleep/date/2014-10-17.json",
message.RequestUri.AbsoluteUri);
});
FitbitClient fitbitClient = Helper.CreateFitbitClient(responseMessage, verification);
SleepLogDateBase response = await fitbitClient.GetSleepDateAsync(new DateTime(2014, 10, 17));
ValidateSleep(response);
}
public async Task SetGoalsAsync_ActiveMinuitesSet()
{
FitbitClient fitbitClient = SetupFitbitClient("activeMinutes=50");
ActivityGoals response = await fitbitClient.SetGoalsAsync(activeMinutes : 50);
Assert.IsNotNull(response);
}
public async Task GetFatAsync_OneWeek_Success()
{
FitbitClient fitbitClient = SetupFitbitClient("https://api.fitbit.com/1/user/-/body/log/fat/date/2012-03-05/1w.json");
Fat response = await fitbitClient.GetFatAsync(new DateTime(2012, 3, 5), DateRangePeriod.OneWeek);
ValidateFat(response);
}
public async Task SetGoalsAsync_FloorsSet()
{
FitbitClient fitbitClient = SetupFitbitClient("floors=20");
ActivityGoals response = await fitbitClient.SetGoalsAsync(floors : 20);
Assert.IsNotNull(response);
}
public async Task SetGoalsAsync_DistanceSet()
{
FitbitClient fitbitClient = SetupFitbitClient("distance=8.5");
ActivityGoals response = await fitbitClient.SetGoalsAsync(distance : 8.5M);
Assert.IsNotNull(response);
}
public async Task SetGoalsAsync_CaloriesOutSet()
{
FitbitClient fitbitClient = SetupFitbitClient("caloriesOut=2000");
ActivityGoals response = await fitbitClient.SetGoalsAsync(caloriesOut : 2000);
Assert.IsNotNull(response);
}
//example using the time series, one per day
public ActionResult LastYearWeight()
{
FitbitClient client = GetFitbitClient();
TimeSeriesDataList weightSeries = client.GetTimeSeries(TimeSeriesResourceType.Weight, DateTime.UtcNow, DateRangePeriod.OneYear);
return(View(weightSeries));
}
/*
* //example using the direct API call getting all the individual logs
* public ActionResult MonthFat(string id)
* {
* DateTime dateStart = Convert.ToDateTime(id);
*
* FitbitClient client = GetFitbitClient();
*
* Fat fat = client.GetFat(dateStart, DateRangePeriod.OneMonth);
*
* if (fat == null || fat.FatLogs == null) //succeeded but no records
* {
* fat = new Fat();
* fat.FatLogs = new List<FatLog>();
* }
* return View(fat);
*
* }
*
* //example using the time series, one per day
* public ActionResult LastYearFat()
* {
* FitbitClient client = GetFitbitClient();
*
* TimeSeriesDataList fatSeries = client.GetTimeSeries(TimeSeriesResourceType.Fat, DateTime.UtcNow, DateRangePeriod.OneYear);
*
* return View(fatSeries);
*
* }
*
* //example using the direct API call getting all the individual logs
* public ActionResult MonthWeight(string id)
* {
* DateTime dateStart = Convert.ToDateTime(id);
*
* FitbitClient client = GetFitbitClient();
*
* Weight weight = client.GetWeight(dateStart, DateRangePeriod.OneMonth);
*
* if (weight == null || weight.Weights == null) //succeeded but no records
* {
* weight = new Weight();
* weight.Weights = new List<WeightLog>();
* }
* return View(weight);
*
* }
*
* //example using the time series, one per day
* public ActionResult LastYearWeight()
* {
* FitbitClient client = GetFitbitClient();
*
* TimeSeriesDataList weightSeries = client.GetTimeSeries(TimeSeriesResourceType.Weight, DateTime.UtcNow, DateRangePeriod.OneYear);
*
* return View(weightSeries);
*
* }
*
* /// <summary>
* /// This requires the Fitbit staff approval of your app before it can be called
* /// </summary>
* /// <returns></returns>
* public string TestIntraDay()
* {
* FitbitClient client = new FitbitClient(ConfigurationManager.AppSettings["FitbitConsumerKey"],
* ConfigurationManager.AppSettings["FitbitConsumerSecret"],
* Session["FitbitAuthToken"].ToString(),
* Session["FitbitAuthTokenSecret"].ToString());
*
* IntradayData data = client.GetIntraDayTimeSeries(IntradayResourceType.Steps, new DateTime(2012, 5, 28, 11, 0, 0), new TimeSpan(1, 0, 0));
*
* string result = "";
*
* foreach (IntradayDataValues intraData in data.DataSet)
* {
* result += intraData.Time.ToShortTimeString() + " - " + intraData.Value + Environment.NewLine;
* }
*
* return result;
*
* }
*
*/
private FitbitClient GetFitbitClient(string bearerToken, string refreshToken)
{
OAuth2Authorization authorization = new OAuth2Authorization(bearerToken, refreshToken);
FitbitClient client = new FitbitClient(authorization);
return(client);
}
public async Task GetWeightAsync_SevenDay_Success()
{
FitbitClient fitbitClient = SetupFitbitClient("https://api.fitbit.com/1/user/-/body/log/weight/date/2012-03-05/7d.json");
Weight response = await fitbitClient.GetWeightAsync(new DateTime(2012, 3, 5), DateRangePeriod.SevenDays);
ValidateWeight(response);
}
public async Task GetWeightAsync_TimeSpan_Success()
{
FitbitClient fitbitClient = SetupFitbitClient("https://api.fitbit.com/1/user/-/body/log/weight/date/2012-03-05/2012-03-06.json");
Weight response = await fitbitClient.GetWeightAsync(new DateTime(2012, 3, 5), new DateTime(2012, 3, 6));
ValidateWeight(response);
}
public ActionResult LastWeekSteps()
{
FitbitClient client = GetFitbitClient();
TimeSeriesDataList results = client.GetTimeSeries(TimeSeriesResourceType.Steps, DateTime.UtcNow.AddDays(-7), DateTime.UtcNow);
return(View(results));
}
public async Task SetGoalsAsync_AllSet()
{
FitbitClient fitbitClient = SetupFitbitClient("caloriesOut=2000&distance=8.5&floors=20&steps=10000&activeMinutes=50");
ActivityGoals response = await fitbitClient.SetGoalsAsync(2000, 8.5M, 20, 10000, 50);
Assert.IsNotNull(response);
}
public async Task SetGoalsAsync_StepsSet()
{
FitbitClient fitbitClient = SetupFitbitClient("steps=10000");
ActivityGoals response = await fitbitClient.SetGoalsAsync(steps : 10000);
Assert.IsNotNull(response);
}
public async Task <ActionResult> SleepGoal()
{
FitbitClient client = GetFitbitClient();
var response = await client.GetSleepGoalAsync();
return(View(response));
}
public async Task <ActionResult> ActivityGoals()
{
FitbitClient client = GetFitbitClient();
var response = await client.GetGoalsAsync(GoalPeriod.Daily);
return(View(response));
}
public async Task <ActionResult> WeightGoal(WeightGoal weightGoal)
{
FitbitClient client = GetFitbitClient();
var response = await client.SetWeightGoalAsync(weightGoal.StartDate, weightGoal.StartWeight, weightGoal.Weight);
return(View(response));
}
private static async Task <Activity> GetDayActivityAsync(FitbitClient client, DateTime date)
{
Activity dayActivity = await client.GetDayActivityAsync(date);
var x = await client.GetDayActivityAsync(date);
return(dayActivity);
}
/// <summary>
/// Imports data from fitbit
/// </summary>
/// <param name="daysSince">get data since x days ago</param>
/// <returns></returns>
public async Task<ActionResult> Import(int daysSince = 35)
{
var identity = await userManager.FindByIdAsync(this.User.Identity.GetUserId());
if(!identity?.Claims?.Any(b => b.ClaimType.Equals(Constants.FitbitClaimsToken)) ?? true) //null coalece to true which will be false because of the ! at the start of the if
{
return new ChallengeResult("Fitbit", Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = Request.Url.PathAndQuery, Area = string.Empty }));
}
var token = identity.Claims.First(a => a.ClaimType == Constants.FitbitClaimsToken);
var fitbitClient = new FitbitClient(new FitbitAppCredentials() { ClientId = this.fitbitAuth.ClientId, ClientSecret = this.fitbitAuth.ClientSecret }, new Fitbit.Api.Portable.OAuth2.OAuth2AccessToken() { Token = token.ClaimValue }, false);
try
{
var totalFoodForRange = Enumerable.Range(0, daysSince)
.Select(a => DateTime.Now.AddDays(-a))
.Select(a => fitbitClient.GetFoodAsync(a));
var results = await Task.WhenAll(totalFoodForRange);
results
.SelectMany(a => a.Foods)
.Select(a =>
new FoodLog
{
NutritionalValues = AutoMapper.Mapper.Map<Fitbit.Models.NutritionalValues, Data.NutritionalValues>(a.NutritionalValues),
FoodName = a.LoggedFood.Name,
FoodBrand = a.LoggedFood.Brand,
LoggedDate = a.LogDate
})
.Where(a => !identity.FoodLogs.Any(b => b.LoggedDate == a.LoggedDate && b.FoodName == a.FoodName && b.FoodBrand == a.FoodBrand))
.ForEach(a => identity.FoodLogs.Add(a));
await userManager.UpdateAsync(identity);
return RedirectToAction("Index", new { Success = true });
}
catch(Fitbit.Api.Portable.FitbitRequestException ex)
{
if(ex.Message.Contains("Unauthorized"))
{
return new ChallengeResult("Fitbit", Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = Request.Url.PathAndQuery, Area = string.Empty }));
}
throw;
}
}
public void ProcessSleepData_MinuteDataTomorrow()
{
var client = new FitbitClient("key", "secret", "token", "secret");
var sleep = new SleepData
{
Sleep = new List<SleepLog>
{
new SleepLog
{
StartTime = new DateTime(2014, 10,10, 22, 0, 0),
MinuteData = new List<MinuteData>
{
new MinuteData
{
DateTime = new DateTime(1900, 1, 1, 4, 0, 0) // the date part is derived
}
}
}
}
};
client.ProcessSleepData(sleep);
Assert.AreEqual(new DateTime(2014, 10, 11, 4, 0, 0), sleep.Sleep[0].MinuteData[0].DateTime);
}
public void ProcessSleepData_NullSleepHandled()
{
var client = new FitbitClient("key", "secret", "token", "secret");
client.ProcessSleepData(new SleepData());
}
public void ProcessSleepData_NullMinuteDataHandled()
{
var client = new FitbitClient("key", "secret", "token", "secret");
var sleep = new SleepData
{
Sleep = new List<SleepLog>
{
new SleepLog()
}
};
client.ProcessSleepData(sleep);
}
public async void SetGoalsAsync_NoGoalsSet()
{
var client = new FitbitClient("key", "secret", "token", "asecret");
await client.SetGoalsAsync();
}
public async void GetWeightAsync_DateRangePeriod_Max()
{
var client = new FitbitClient("key", "secret", "access", "accessSecret");
await client.GetWeightAsync(DateTime.Now, DateRangePeriod.Max);
}
public async void GetFatAsync_DateRangePeriod_ThreeMonths()
{
var client = new FitbitClient("key", "secret", "access", "accessSecret");
await client.GetFatAsync(DateTime.Now, DateRangePeriod.ThreeMonths);
}
public async void GetFatAsync_DateRangePeriod_OneYear()
{
var client = new FitbitClient("key", "secret", "access", "accessSecret");
await client.GetFatAsync(DateTime.Now, DateRangePeriod.OneYear);
}
private FitbitClient GetFitbitClient(string bearerToken, string refreshToken)
{
OAuth2Authorization authorization = new OAuth2Authorization(bearerToken, refreshToken);
FitbitClient client = new FitbitClient(authorization);
return client;
}
public void Constructor_HttpClient_Create()
{
var client = new FitbitClient("key", "secret", "access", "accessToken");
Assert.IsNotNull(client.HttpClient);
}
