public void ProcessResults_Parses_Category_Response()
{
var reqProc = new UserRequestProcessor <User> {
Type = UserType.Category, BaseUrl = "http://api.twitter.com/1.1/"
};
List <User> userList = reqProc.ProcessResults(CategoryResponse);
Assert.IsNotNull(userList);
Assert.AreEqual(1, userList.Count);
var user = userList.Single();
Assert.IsNotNull(user);
var categories = user.Categories;
Assert.IsNotNull(categories);
Assert.IsTrue(categories.Any());
var category = categories.First();
Assert.IsNotNull(category);
Assert.AreEqual(64, category.Size);
Assert.AreEqual("Funny", category.Name);
Assert.AreEqual("funny", category.Slug);
var users = category.Users;
Assert.IsNotNull(users);
Assert.IsTrue(users.Any());
var catUser = users.First();
Assert.IsNotNull(catUser);
Assert.AreEqual("OMG TestMethods", catUser.Name);
}
public void ProcessResults_Parses_BannerSizes_Response()
{
var reqProc = new UserRequestProcessor <User> {
Type = UserType.BannerSizes, BaseUrl = "http://api.twitter.com/1.1/"
};
List <User> userList = reqProc.ProcessResults(BannerSizesResponse);
Assert.IsNotNull(userList);
Assert.IsTrue(userList.Any());
Assert.AreEqual(1, userList.Count);
var user = userList.Single();
Assert.IsNotNull(user);
var bannerSizes = user.BannerSizes;
Assert.IsNotNull(bannerSizes);
Assert.AreEqual(6, bannerSizes.Count);
var firstSize = bannerSizes.First();
Assert.IsNotNull(firstSize);
Assert.AreEqual("ipad_retina", firstSize.Label);
Assert.AreEqual(1252, firstSize.Width);
Assert.AreEqual(626, firstSize.Height);
Assert.AreEqual("https://si0.twimg.com/profile_banners/16761255/1355801341/ipad_retina", firstSize.Url);
}
/// <summary>
/// Update Twitter colors
/// </summary>
/// <remarks>
/// The # character prefix is optional. At least one color argument must be provided.
/// </remarks>
/// <param name="background">background color</param>
/// <param name="text">text color</param>
/// <param name="link">link color</param>
/// <param name="sidebarFill">sidebar color</param>
/// <param name="sidebarBorder">sidebar border color</param>
/// <param name="includeEntities">Set to false to not include entities. (default: true)</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <returns>User info with new colors</returns>
public async Task<User> UpdateAccountColorsAsync(string background, string text, string link, string sidebarFill, string sidebarBorder, bool includeEntities, bool skipStatus, CancellationToken cancelToken = default(CancellationToken))
{
var accountUrl = BaseUrl + "account/update_profile_colors.json";
if (string.IsNullOrWhiteSpace(background) &&
string.IsNullOrWhiteSpace(text) &&
string.IsNullOrWhiteSpace(link) &&
string.IsNullOrWhiteSpace(sidebarFill) &&
string.IsNullOrWhiteSpace(sidebarBorder))
throw new ArgumentException("At least one of the colors (background, text, link, sidebarFill, or sidebarBorder) must be provided as arguments, but none are specified.", NoInputParam);
var reqProc = new UserRequestProcessor<User>();
RawResult =
await TwitterExecutor.PostToTwitterAsync<User>(
accountUrl,
new Dictionary<string, string>
{
{ "profile_background_color", string.IsNullOrWhiteSpace(background) ? null : background.TrimStart('#') },
{ "profile_text_color", string.IsNullOrWhiteSpace(text) ? null : text.TrimStart('#') },
{ "profile_link_color", string.IsNullOrWhiteSpace(link) ? null : link.TrimStart('#') },
{ "profile_sidebar_fill_color", string.IsNullOrWhiteSpace(sidebarFill) ? null : sidebarFill.TrimStart('#') },
{ "profile_sidebar_border_color", string.IsNullOrWhiteSpace(sidebarBorder) ? null : sidebarBorder.TrimStart('#') },
{ "include_entities", includeEntities.ToString().ToLower() },
{ "skip_status", skipStatus.ToString().ToLower() }
},
cancelToken)
.ConfigureAwait(false);
return reqProc.ProcessActionResult(RawResult, UserAction.SingleUser);
}
/// <summary>
/// lets logged-in user report spam
/// </summary>
/// <param name="userID">user id of alleged spammer</param>
/// <param name="screenName">screen name of alleged spammer</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>Alleged spammer user info</returns>
public static User ReportSpam(this TwitterContext ctx, string userID, string screenName, Action<TwitterAsyncResponse<User>> callback)
{
if (string.IsNullOrEmpty(userID) &&
string.IsNullOrEmpty(screenName))
{
throw new ArgumentException("Either userID or screenName is a required parameter.");
}
string reportSpamUrl = ctx.BaseUrl + "users/report_spam.json";
var createParams = new Dictionary<string, string>
{
{ "user_id", userID },
{ "screen_name", screenName }
};
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
reportSpamUrl,
createParams,
response => reqProc.ProcessActionResult(response, UserAction.SingleUser));
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
/// <summary>
/// Update Twitter colors
/// </summary>
/// <remarks>
/// The # character prefix is optional. At least one color argument must be provided.
/// </remarks>
/// <param name="background">background color</param>
/// <param name="text">text color</param>
/// <param name="link">link color</param>
/// <param name="sidebarFill">sidebar color</param>
/// <param name="sidebarBorder">sidebar border color</param>
/// <param name="includeEntities">Set to false to not include entities. (default: true)</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>User info with new colors</returns>
public static User UpdateAccountColors(this TwitterContext ctx, string background, string text, string link, string sidebarFill, string sidebarBorder, bool includeEntities, bool skipStatus, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile_colors.json";
if (string.IsNullOrEmpty(background) &&
string.IsNullOrEmpty(text) &&
string.IsNullOrEmpty(link) &&
string.IsNullOrEmpty(sidebarFill) &&
string.IsNullOrEmpty(sidebarBorder))
{
throw new ArgumentException("At least one of the colors (background, text, link, sidebarFill, or sidebarBorder) must be provided as arguments, but none are specified.", NoInputParam);
}
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
accountUrl,
new Dictionary<string, string>
{
{ "profile_background_color", string.IsNullOrEmpty(background) ? (string)null : background.TrimStart('#') },
{ "profile_text_color", string.IsNullOrEmpty(text) ? (string)null : text.TrimStart('#') },
{ "profile_link_color", string.IsNullOrEmpty(link) ? (string)null : link.TrimStart('#') },
{ "profile_sidebar_fill_color", string.IsNullOrEmpty(sidebarFill) ? (string)null : sidebarFill.TrimStart('#') },
{ "profile_sidebar_border_color", string.IsNullOrEmpty(sidebarBorder) ? (string)null : sidebarBorder.TrimStart('#') },
{ "include_entities", includeEntities.ToString().ToLower() },
{ "skip_status", skipStatus.ToString().ToLower() }
},
response => reqProc.ProcessActionResult(response, UserAction.SingleUser));
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
public void ProcessActionResult_Parses_SingleUser_Response()
{
var reqProc = new UserRequestProcessor <User>();
User user = reqProc.ProcessActionResult(SingleUserResponse, UserAction.SingleUser);
VerifySingleUserResponse(user);
}
public void BuildUrl_Throws_On_Null_Params()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var ex = L2TAssert.Throws <ArgumentException>(() => reqProc.BuildUrl(null));
Assert.AreEqual <string>("Type", ex.ParamName);
}
public void ProcessResults_Returns_Empty_Collection_When_Empty_Results()
{
var userProc = new UserRequestProcessor <User> {
BaseUrl = "http://api.twitter.com/1.1/"
};
List <User> users = userProc.ProcessResults(string.Empty);
Assert.IsFalse(users.Any());
}
public void ProcessUsersInCategoryResultsTest()
{
var statProc = new UserRequestProcessor <User>()
{
BaseUrl = "http://api.twitter.com/1/"
};
XElement twitterResponse = XElement.Load(new StringReader(m_usersInCategoryResponse));
var actual = (List <User>)statProc.ProcessResults(twitterResponse);
Assert.AreEqual(2, actual.Count);
}
public void BuildUrl_Throws_On_Missing_Type()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string> {
};
var ex = L2TAssert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual <string>("Type", ex.ParamName);
}
async Task<User> MuteAsync(IDictionary<string, string> muteParams, CancellationToken cancelToken = default(CancellationToken))
{
var muteUrl = BaseUrl + "mutes/users/create.json";
var reqProc = new UserRequestProcessor<User>();
RawResult =
await TwitterExecutor
.PostToTwitterAsync<User>(muteUrl, muteParams, cancelToken)
.ConfigureAwait(false);
return reqProc.ProcessActionResult(RawResult, UserAction.SingleUser);
}
public void ProcessResultsMultipleResultsTest()
{
var statProc = new UserRequestProcessor <User>()
{
BaseUrl = "http://twitter.com/"
};
XElement twitterResponse = XElement.Load(new StringReader(m_testQueryResponse));
var actual = statProc.ProcessResults(twitterResponse);
var actualQuery = actual as IList <User>;
Assert.IsNotNull(actualQuery);
Assert.AreEqual(actualQuery.Count(), 1);
}
public void GetParametersTest()
{
var reqProc = new UserRequestProcessor <User>();
Expression <Func <User, bool> > expression =
user =>
user.Type == UserType.Friends &&
user.ID == "10" &&
user.UserID == "10" &&
user.ScreenName == "JoeMayo" &&
user.Cursor == "10819235" &&
user.Slug == "twitter" &&
user.Query == "Joe Mayo" &&
user.Page == 2 &&
user.PerPage == 10;
LambdaExpression lambdaExpression = expression as LambdaExpression;
var queryParams = reqProc.GetParameters(lambdaExpression);
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Type", ((int)UserType.Friends).ToString())));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("ID", "10")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("UserID", "10")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("ScreenName", "JoeMayo")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("ID", "10")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Cursor", "10819235")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Slug", "twitter")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Query", "Joe Mayo")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Page", "2")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("PerPage", "10")));
}
public void BuildUrl_Category_Thows_On_Missing_Slug()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Category).ToString() },
};
var ex = Assert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.Equal("Slug", ex.ParamName);
}
public void ProcessResults_Parses_Show_Response()
{
var reqProc = new UserRequestProcessor <User> {
Type = UserType.Show, BaseUrl = "https://api.twitter.com/1.1/"
};
List <User> users = reqProc.ProcessResults(SingleUserResponse);
Assert.IsNotNull(users);
Assert.AreEqual(1, users.Count);
var user = users.First();
VerifySingleUserResponse(user);
}
public void BuildUrl_Lookup_Throws_On_Missing_ScreenName()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
};
ArgumentException ex = L2TAssert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("ScreenNameListOrUserIdList", ex.ParamName);
}
public void BuildUrl_Search_Throws_On_Missing_Query()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Search).ToString() },
};
var ex = L2TAssert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("Query", ex.ParamName);
}
public void BuildUrl_Categores_Throws_On_Missing_Slug()
{
var reqProc = new UserRequestProcessor <User>();
Dictionary <string, string> parameters =
new Dictionary <string, string>
{
{ "Type", ((int)UserType.CategoryStatus).ToString() },
//{ "Slug", "Technology" }
};
var ex = L2TAssert.Throws <ArgumentNullException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("Slug", ex.ParamName);
}
void TestMultipleUserResponse(UserType type)
{
var reqProc = new UserRequestProcessor <User> {
Type = type, BaseUrl = "http://api.twitter.com/1.1/"
};
List <User> userList = reqProc.ProcessResults(MultipleUserResponse);
Assert.IsNotNull(userList);
Assert.IsTrue(userList.Any());
var user = userList.First();
Assert.IsNotNull(user);
Assert.AreEqual("bbccff", user.ProfileSidebarBorderColor);
}
public void BuildUrl_Show_Throws_On_Null_ScreenName()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Show).ToString() },
{ "ScreenName", null }
};
var ex = L2TAssert.Throws <ArgumentNullException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("ScreenName", ex.ParamName);
}
public void BuildUrl_BannerSize_Requires_NonEmpty_UserID()
{
const string ExpectedParamName = "UserID";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.BannerSizes).ToString() },
{ "UserID", "" },
//{ "ScreenName", "JoeMayo" }
};
var ex = L2TAssert.Throws<ArgumentNullException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual(ExpectedParamName, ex.ParamName);
}
protected void Button1_Click(object sender, EventArgs e)
{
IUserRequestProcessor bl = new UserRequestProcessor();
UserPL pl = new UserPL();
pl.Name = TxtName1.Text;
pl.City = TxtCity1.Text;
pl.Email = TxtEmail1.Text;
bl.InsertUser(pl);
GridView1.DataSource = bl.SelectUser();
GridView1.DataBind();
}
public void BuildUrl_Constructs_BannerSize_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/profile_banner.json?user_id=15411837&screen_name=JoeMayo";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.BannerSizes).ToString() },
{ "UserID", "15411837" },
{ "ScreenName", "JoeMayo" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Lookup_Constructs_Url_With_ScreenNameList_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/lookup.json?screen_name=JoeMayo%2CLinqToTweeter";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "ScreenNameList", "JoeMayo,LinqToTweeter" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildURLTest()
{
UserRequestProcessor <User> reqProc = new UserRequestProcessor <User>();
reqProc.BaseUrl = "http://twitter.com/";
Dictionary <string, string> parameters =
new Dictionary <string, string>
{
{ "Type", ((int)UserType.Friends).ToString() },
{ "ID", "15411837" }
};
string expected = "http://twitter.com/statuses/friends/15411837.xml";
var actual = reqProc.BuildURL(parameters);
Assert.AreEqual(expected, actual);
}
public void BuildUrl_Constructs_Categories_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/suggestions/technology/members.json";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.CategoryStatus).ToString() },
{ "Slug", "Technology" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Categories_Constructs_Url_For_Lang_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/suggestions.json?lang=it";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Categories).ToString() },
{ "Lang", "it" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Lookup_Constructs_Url_With_UserIDList_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/lookup.json?user_id=1%2C2";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "UserIdList", "1,2" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Lookup_Throws_On_Both_UserID_And_ScreenName_Params()
{
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "ScreenName", "JoeMayo,LinqToTweeter" },
{ "UserID", "1,2" }
};
var ex = L2TAssert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("ScreenNameOrUserID", ex.ParamName);
}
public void BuildUrl_BannerSize_Requires_NonNull_ScreenName()
{
const string ExpectedParamName = "ScreenName";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.BannerSizes).ToString() },
//{ "UserID", null },
{ "ScreenName", null }
};
var ex = L2TAssert.Throws <ArgumentNullException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual(ExpectedParamName, ex.ParamName);
}
public void BuildUrl_Constructs_BannerSize_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/profile_banner.json?user_id=15411837&screen_name=JoeMayo";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.BannerSizes).ToString() },
{ "UserID", "15411837" },
{ "ScreenName", "JoeMayo" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_BannerSize_Requires_ScreenName_Or_UserID()
{
const string ExpectedParamName = "ScreenNameOrUserID";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.BannerSizes).ToString() },
//{ "UserID", "15411837" },
//{ "ScreenName", "JoeMayo" }
};
var ex = Assert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.Equal(ExpectedParamName, ex.ParamName);
}
/// <summary>
/// Removes banner from authenticated user's profile.
/// </summary>
/// <param name="callback">Async Callback.</param>
/// <returns>Empty User instance.</returns>
public static User RemoveProfileBanner(this TwitterContext ctx, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/remove_profile_banner.json";
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
accountUrl,
new Dictionary<string, string>(),
response => reqProc.ProcessActionResult(response, UserAction.SingleUser));
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
public void BuildUrl_Constructs_Show_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/show.json?user_id=15411837&screen_name=JoeMayo&include_entities=true";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Show).ToString() },
{ "UserID", "15411837" },
{ "ScreenName", "JoeMayo" },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Contributors_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/contributors.json?user_id=123&include_entities=true&skip_status=true";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Contributors).ToString() },
{ "UserID", "123" },
//{ "ScreenName", "JoeMayo" },
{ "IncludeEntities", true.ToString() },
{ "SkipStatus", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Search_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/search.json?q=Joe%20Mayo&page=2&count=10&include_entities=true";
var reqProc = new UserRequestProcessor <User> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)UserType.Search).ToString() },
{ "Query", "Joe Mayo" },
{ "Page", "2" },
{ "Count", "10" },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void NullParametersTest()
{
UserRequestProcessor <User> target = new UserRequestProcessor <User>()
{
BaseUrl = "http://twitter.com/"
};
Dictionary <string, string> parameters = null;
string actual;
try
{
actual = target.BuildURL(parameters);
Assert.Fail("Expected ArgumentException.");
}
catch (ArgumentException ae)
{
Assert.AreEqual <string>("Type", ae.ParamName);
}
}
public void UserRequestProcessor_Handles_Actions()
{
var reqProc = new UserRequestProcessor<User>();
Assert.IsInstanceOfType(reqProc, typeof(IRequestProcessorWithAction<User>));
}
public void ProcessActionResult_Parses_SingleUser_Response()
{
var reqProc = new UserRequestProcessor<User>();
User user = reqProc.ProcessActionResult(SingleUserResponse, UserAction.SingleUser);
VerifySingleUserResponse(user);
}
/// <summary>
/// Sends an image to Twitter to be placed as the user's profile banner.
/// </summary>
/// <param name="banner">byte[] containing image data.</param>
/// <param name="width">Pixel width to clip image.</param>
/// <param name="height">Pixel height to clip image.</param>
/// <param name="offsetLeft">Pixels to offset start of image from the left.</param>
/// <param name="offsetTop">Pixels to offset start of image from the top.</param>
/// <param name="callback">Async callback routine.</param>
/// <returns>
/// Account of authenticated user who's profile banner will be updated.
/// Url of new banner will appear in ProfileBannerUrl property.
/// </returns>
public static User UpdateProfileBanner(this TwitterContext ctx, byte[] banner, string fileName, string imageType, int width, int height, int offsetLeft, int offsetTop, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile_banner.json";
if (banner == null || banner.Length == 0)
{
throw new ArgumentException("banner is required.", "banner");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException("fileName is required.", "fileName");
}
if (string.IsNullOrEmpty(imageType))
{
throw new ArgumentException("imageType is required.", "imageType");
}
var parameters = new Dictionary<string, string>
{
{ "width", width.ToString() },
{ "height", height.ToString() },
{ "offset_left", offsetLeft.ToString() },
{ "offset_top", offsetTop.ToString() },
{ "banner", "IMAGE_DATA" }
};
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostTwitterImage(accountUrl, parameters, banner, fileName, imageType, reqProc);
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
/// <summary>
/// Allows removal of background image by setting back to the default background. Once the background image is removed
/// it can not be turned back on.
/// </summary>
/// <param name="ctx"></param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <returns></returns>
public static User RemoveBackgroundImage(this TwitterContext ctx, bool skipStatus, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile_background_image.json";
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
accountUrl,
new Dictionary<string, string>
{
{ "use", "false" },
{ "skip_status", skipStatus.ToString()}
},
response => reqProc.ProcessActionResult(response, UserAction.SingleUser));
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
public void BuildUrl_Lookup_Constructs_Url_With_ScreenNameList_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/lookup.json?screen_name=JoeMayo%2CLinqToTweeter";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "ScreenNameList", "JoeMayo,LinqToTweeter" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Returns_Empty_Collection_When_Empty_Results()
{
var userProc = new UserRequestProcessor<User> { BaseUrl = "http://api.twitter.com/1.1/" };
List<User> users = userProc.ProcessResults(string.Empty);
Assert.IsFalse(users.Any());
}
public void BuildUrl_Constructs_Search_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/search.json?q=Joe%20Mayo&page=2&count=10&include_entities=true";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Search).ToString() },
{ "Query", "Joe Mayo" },
{ "Page", "2" },
{ "Count", "10" },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
/// <summary>
/// sends an image file to Twitter to replace user image
/// </summary>
/// <remarks>
/// You can only run this method with a period of time between executions;
/// otherwise you get WebException errors from Twitter
/// </remarks>
/// <param name="imageFilePath">full path to file, including file name</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>User with new image info</returns>
public static User UpdateAccountImage(this TwitterContext ctx, string imageFilePath, bool skipStatus, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile_image.json";
if (string.IsNullOrEmpty(imageFilePath))
{
throw new ArgumentException("imageFilePath is required.", "imageFilePath");
}
var reqProc = new UserRequestProcessor<User>();
var parameters = new Dictionary<string, string>
{
{ "skip_status", skipStatus.ToString().ToLower() }
};
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostTwitterFile(accountUrl, parameters, imageFilePath, reqProc);
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
public void BuildUrl_Throws_On_Missing_Type()
{
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string> { };
var ex = L2TAssert.Throws<ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual<string>("Type", ex.ParamName);
}
/// <summary>
/// sends an image file to Twitter to replace background image
/// </summary>
/// <param name="image">full path to file, including file name</param>
/// <param name="fileName">name to pass to Twitter for the file</param>
/// <param name="imageType">type of image: must be one of jpg, gif, or png</param>
/// <param name="tile">Tile image across background.</param>
/// <param name="use">Whether to use uploaded background image or not</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <param name="includeEntities">Set to false to not include entities. (default: true)</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <returns>User with new image info</returns>
public static User UpdateAccountBackgroundImage(this TwitterContext ctx, byte[] image, string fileName, string imageType, bool tile, bool use, bool includeEntities, bool skipStatus, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile_background_image.json";
if (image == null || image.Length == 0)
{
throw new ArgumentException("image is required.", "image");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException("fileName is required.", "fileName");
}
if (string.IsNullOrEmpty(imageType))
{
throw new ArgumentException("imageType is required.", "imageType");
}
var parameters = new Dictionary<string, string>
{
{ "include_entities", includeEntities.ToString().ToLower() },
{ "skip_status", skipStatus.ToString().ToLower() }
};
if (tile)
{
parameters.Add("tile", true.ToString().ToLower());
parameters.Add("use", use.ToString().ToLower());
}
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostTwitterImage(accountUrl, parameters, image, fileName, imageType, reqProc);
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
public void ProcessResults_Parses_BannerSizes_Response()
{
var reqProc = new UserRequestProcessor<User> { Type = UserType.BannerSizes, BaseUrl = "http://api.twitter.com/1.1/" };
List<User> userList = reqProc.ProcessResults(BannerSizesResponse);
Assert.IsNotNull(userList);
Assert.IsTrue(userList.Any());
Assert.AreEqual(1, userList.Count);
var user = userList.Single();
Assert.IsNotNull(user);
var bannerSizes = user.BannerSizes;
Assert.IsNotNull(bannerSizes);
Assert.AreEqual(6, bannerSizes.Count);
var firstSize = bannerSizes.First();
Assert.IsNotNull(firstSize);
Assert.AreEqual("ipad_retina", firstSize.Label);
Assert.AreEqual(1252, firstSize.Width);
Assert.AreEqual(626, firstSize.Height);
Assert.AreEqual("https://si0.twimg.com/profile_banners/16761255/1355801341/ipad_retina", firstSize.Url);
}
public void UserRequestProcessor_Works_With_Json_Format_Data()
{
var reqProc = new UserRequestProcessor<User>();
Assert.IsInstanceOfType(reqProc, typeof(IRequestProcessorWantsJson));
}
public void GetParameters_Handles_Input_Params()
{
var reqProc = new UserRequestProcessor<User>();
Expression<Func<User, bool>> expression =
user =>
user.Type == UserType.Show &&
user.UserID == 10 &&
user.UserIdList == "1,2" &&
user.ScreenName == "JoeMayo" &&
user.ScreenNameList == "JoeMayo,Linq2Tweeter" &&
user.Cursor == 10819235 &&
user.Slug == "twitter" &&
user.Query == "Joe Mayo" &&
user.Page == 2 &&
user.Count == 10 &&
user.Lang == "it" &&
user.IncludeEntities == true &&
user.SkipStatus == true &&
user.ImageSize == ProfileImageSize.Mini;
var lambdaExpression = expression as LambdaExpression;
var queryParams = reqProc.GetParameters(lambdaExpression);
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Type", ((int)UserType.Show).ToString())));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("UserID", "10")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("UserIdList", "1,2")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("ScreenName", "JoeMayo")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("ScreenNameList", "JoeMayo,Linq2Tweeter")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Cursor", "10819235")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Slug", "twitter")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Query", "Joe Mayo")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Page", "2")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Count", "10")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Lang", "it")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeEntities", "True")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("SkipStatus", "True")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("ImageSize", ((int)ProfileImageSize.Mini).ToString())));
}
public void BuildUrl_Lookup_Throws_On_Both_UserID_And_ScreenName_Params()
{
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "ScreenName", "JoeMayo,LinqToTweeter" },
{ "UserID", "1,2" }
};
var ex = L2TAssert.Throws<ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("ScreenNameOrUserID", ex.ParamName);
}
public void BuildUrl_Constructs_Lookup_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/lookup.json?user_id=1%2C2&include_entities=true";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Lookup).ToString() },
{ "UserIdList", "1,2" },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Retains_Original_Input_Parameters()
{
var reqProc = new UserRequestProcessor<User>
{
Type = UserType.Show,
BaseUrl = "https://api.twitter.com/1.1/",
UserID = 123ul,
UserIdList = "1,2",
ScreenName = "JoeMayo",
ScreenNameList = "JoeMayo,Linq2Tweeter",
Page = 1,
Count = 10,
Cursor = 456,
Slug = "myslug",
Query = "myquery",
Lang = "en-US",
SkipStatus = true,
ImageSize = ProfileImageSize.Bigger,
IncludeEntities = true
};
List<User> users = reqProc.ProcessResults(SingleUserResponse);
Assert.IsNotNull(users);
Assert.AreEqual(1, users.Count);
var user = users.First();
Assert.AreEqual(123ul, user.UserID);
Assert.AreEqual("1,2", user.UserIdList);
Assert.AreEqual("JoeMayo", user.ScreenName);
Assert.AreEqual("JoeMayo,Linq2Tweeter", user.ScreenNameList);
Assert.AreEqual(1, user.Page);
Assert.AreEqual(10, user.Count);
Assert.AreEqual(456L, user.Cursor);
Assert.AreEqual("myslug", user.Slug);
Assert.AreEqual("myquery", user.Query);
Assert.AreEqual("en-US", user.Lang);
Assert.IsTrue(user.SkipStatus);
Assert.AreEqual(ProfileImageSize.Bigger, user.ImageSize);
Assert.IsTrue(user.IncludeEntities);
}
public void BuildUrl_Search_Throws_On_Missing_Query()
{
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Search).ToString() },
};
var ex = L2TAssert.Throws<ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual("Query", ex.ParamName);
}
void TestMultipleUserResponse(UserType type)
{
var reqProc = new UserRequestProcessor<User> { Type = type, BaseUrl = "http://api.twitter.com/1.1/" };
List<User> userList = reqProc.ProcessResults(MultipleUserResponse);
Assert.IsNotNull(userList);
Assert.IsTrue(userList.Any());
var user = userList.First();
Assert.IsNotNull(user);
Assert.AreEqual("bbccff", user.ProfileSidebarBorderColor);
}
public void ProcessResults_Parses_Category_Response()
{
var reqProc = new UserRequestProcessor<User> { Type = UserType.Category, BaseUrl = "http://api.twitter.com/1.1/" };
List<User> userList = reqProc.ProcessResults(CategoryResponse);
Assert.IsNotNull(userList);
Assert.AreEqual(1, userList.Count);
var user = userList.Single();
Assert.IsNotNull(user);
var categories = user.Categories;
Assert.IsNotNull(categories);
Assert.IsTrue(categories.Any());
var category = categories.First();
Assert.IsNotNull(category);
Assert.AreEqual(64, category.Size);
Assert.AreEqual("Funny", category.Name);
Assert.AreEqual("funny", category.Slug);
var users = category.Users;
Assert.IsNotNull(users);
Assert.IsTrue(users.Any());
var catUser = users.First();
Assert.IsNotNull(catUser);
Assert.AreEqual("OMG TestMethods", catUser.Name);
}
public void BuildUrl_Throws_On_Null_Params()
{
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var ex = L2TAssert.Throws<ArgumentException>(() => reqProc.BuildUrl(null));
Assert.AreEqual<string>("Type", ex.ParamName);
}
public void ProcessResults_Parses_Show_Response()
{
var reqProc = new UserRequestProcessor<User> { Type = UserType.Show, BaseUrl = "https://api.twitter.com/1.1/" };
List<User> users = reqProc.ProcessResults(SingleUserResponse);
Assert.IsNotNull(users);
Assert.AreEqual(1, users.Count);
var user = users.First();
VerifySingleUserResponse(user);
}
public void BuildUrl_Constructs_Contributors_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/users/contributors.json?user_id=123&include_entities=true&skip_status=true";
var reqProc = new UserRequestProcessor<User> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)UserType.Contributors).ToString() },
{ "UserID", "123" },
//{ "ScreenName", "JoeMayo" },
{ "IncludeEntities", true.ToString() },
{ "SkipStatus", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
/// <summary>
/// Update account profile info
/// </summary>
/// <param name="name">User Name</param>
/// <param name="url">Web Address</param>
/// <param name="location">Geographic Location</param>
/// <param name="description">Personal Description</param>
/// <param name="includeEntities">Set to false to not include entities. (default: true)</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>User with new info</returns>
public static User UpdateAccountProfile(this TwitterContext ctx, string name, string url, string location, string description, bool includeEntities, bool skipStatus, Action<TwitterAsyncResponse<User>> callback)
{
var accountUrl = ctx.BaseUrl + "account/update_profile.json";
if (string.IsNullOrEmpty(name) &&
string.IsNullOrEmpty(url) &&
string.IsNullOrEmpty(location) &&
string.IsNullOrEmpty(description))
{
throw new ArgumentException("At least one of the text fields (name, email, url, location, or description) must be provided as arguments, but none are specified.", NoInputParam);
}
if (!string.IsNullOrEmpty(name) && name.Length > 20)
{
throw new ArgumentException("name must be no longer than 20 characters", "name");
}
if (!string.IsNullOrEmpty(url) && url.Length > 100)
{
throw new ArgumentException("url must be no longer than 100 characters", "url");
}
if (!string.IsNullOrEmpty(location) && location.Length > 30)
{
throw new ArgumentException("location must be no longer than 30 characters", "location");
}
if (!string.IsNullOrEmpty(description) && description.Length > 160)
{
throw new ArgumentException("description must be no longer than 160 characters", "description");
}
var reqProc = new UserRequestProcessor<User>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
accountUrl,
new Dictionary<string, string>
{
{ "name", name },
{ "url", url },
{ "location", location },
{ "description", description },
{ "include_entities", includeEntities.ToString().ToLower() },
{ "skip_status", skipStatus.ToString().ToLower() }
},
response => reqProc.ProcessActionResult(response, UserAction.SingleUser));
User user = reqProc.ProcessActionResult(resultsJson, UserAction.SingleUser);
return user;
}
