Example #1
0
        public void ProcessResults_Parses_IDs_Response()
        {
            var reqProc = new MuteRequestProcessor <Mute> {
                Type = MuteType.IDs
            };

            List <Mute> mutes = reqProc.ProcessResults(IdsResponse);

            Assert.IsNotNull(mutes);
            Assert.IsNotNull(mutes.SingleOrDefault());
            var mute = mutes.Single();

            Assert.IsNotNull(mute);
            var idList = mute.IDList;

            Assert.IsNotNull(idList);
            Assert.IsTrue(idList.Any());
            var id = idList.First();

            Assert.AreEqual(5676142ul, id);
            var users = mute.Users;

            Assert.IsNotNull(users);
            Assert.IsFalse(users.Any());
            var cursor = mute.CursorMovement;

            Assert.IsNotNull(cursor);
            Assert.AreEqual(2, cursor.Previous);
            Assert.AreEqual(1, cursor.Next);
        }
        public void GetParameters_Handles_Input_Params()
        {
            var target = new MuteRequestProcessor<Mute>();
            Expression<Func<Mute, bool>> expression =
                mute =>
                    mute.Type == MuteType.List &&
                    mute.Cursor == 123l &&
                    mute.SkipStatus == true &&
                    mute.IncludeEntities == true;
            var lambdaExpression = expression as LambdaExpression;

            var queryParams = target.GetParameters(lambdaExpression);

            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair<string, string>("Type", ((int)MuteType.List).ToString(CultureInfo.InvariantCulture))));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair<string, string>("Cursor", "123")));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair<string, string>("SkipStatus", "True")));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair<string, string>("IncludeEntities", "True")));
        }
Example #3
0
        public void GetParameters_Handles_Input_Params()
        {
            var target = new MuteRequestProcessor <Mute>();
            Expression <Func <Mute, bool> > expression =
                mute =>
                mute.Type == MuteType.List &&
                mute.Cursor == 123L &&
                mute.SkipStatus == true &&
                mute.IncludeEntities == true;
            var lambdaExpression = expression as LambdaExpression;

            var queryParams = target.GetParameters(lambdaExpression);

            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair <string, string>("Type", ((int)MuteType.List).ToString(CultureInfo.InvariantCulture))));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair <string, string>("Cursor", "123")));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair <string, string>("SkipStatus", "True")));
            Assert.IsTrue(
                queryParams.Contains(
                    new KeyValuePair <string, string>("IncludeEntities", "True")));
        }
Example #4
0
        public void ProcessResults_Parses_UsersList_Response()
        {
            var reqProc = new MuteRequestProcessor <Mute> {
                Type = MuteType.List
            };

            List <Mute> muteList = reqProc.ProcessResults(UsersResponse);

            Assert.IsNotNull(muteList);
            Assert.IsNotNull(muteList.SingleOrDefault());
            var mute = muteList.Single();

            Assert.IsNotNull(mute);
            var users = mute.Users;

            Assert.IsNotNull(users);
            Assert.AreEqual(3, users.Count);
            var user = users.First();

            Assert.IsNotNull(user);
            Assert.AreEqual("93604443", user.UserIDResponse);
            var ids = mute.IDList;

            Assert.IsNotNull(ids);
            Assert.IsFalse(ids.Any());
            var cursor = mute.CursorMovement;

            Assert.IsNotNull(cursor);
            Assert.AreEqual(2, cursor.Previous);
            Assert.AreEqual(1, cursor.Next);
        }
        public void BuildUrl_Constructs_IDs_Url()
        {
            const string ExpectedUrl = "https://api.twitter.com/1.1/mutes/users/ids.json?cursor=123";
            var reqProc = new MuteRequestProcessor<Mute> { BaseUrl = "https://api.twitter.com/1.1/" };
            var parameters =
                new Dictionary<string, string>
                {
                        { "Type", ((int)MuteType.IDs).ToString(CultureInfo.InvariantCulture) },
                        { "Cursor", "123" }
                };

            Request req = reqProc.BuildUrl(parameters);

            Assert.AreEqual(ExpectedUrl, req.FullUrl);
        }
        public void BuildUrl_Constructs_List_Url()
        {
            const string ExpectedUrl = "https://api.twitter.com/1.1/mutes/users/list.json?cursor=123&include_entities=false&skip_status=true";
            var reqProc = new MuteRequestProcessor<Mute> { BaseUrl = "https://api.twitter.com/1.1/" };
            var parameters =
                new Dictionary<string, string>
                {
                        { "Type", ((int)MuteType.List).ToString(CultureInfo.InvariantCulture) },
                        { "Cursor", "123" },
                        { "IncludeEntities", false.ToString() },
                        { "SkipStatus", true.ToString() }
                };

            Request req = reqProc.BuildUrl(parameters);

            Assert.AreEqual(ExpectedUrl, req.FullUrl);
        }
Example #7
0
        public void BuildUrl_Constructs_IDs_Url()
        {
            const string ExpectedUrl = "https://api.twitter.com/1.1/mutes/users/ids.json?cursor=123";
            var          reqProc     = new MuteRequestProcessor <Mute> {
                BaseUrl = "https://api.twitter.com/1.1/"
            };
            var parameters =
                new Dictionary <string, string>
            {
                { "Type", ((int)MuteType.IDs).ToString(CultureInfo.InvariantCulture) },
                { "Cursor", "123" }
            };

            Request req = reqProc.BuildUrl(parameters);

            Assert.AreEqual(ExpectedUrl, req.FullUrl);
        }
Example #8
0
        public void BuildUrl_Constructs_List_Url()
        {
            const string ExpectedUrl = "https://api.twitter.com/1.1/mutes/users/list.json?cursor=123&include_entities=false&skip_status=true";
            var          reqProc     = new MuteRequestProcessor <Mute> {
                BaseUrl = "https://api.twitter.com/1.1/"
            };
            var parameters =
                new Dictionary <string, string>
            {
                { "Type", ((int)MuteType.List).ToString(CultureInfo.InvariantCulture) },
                { "Cursor", "123" },
                { "IncludeEntities", false.ToString() },
                { "SkipStatus", true.ToString() }
            };

            Request req = reqProc.BuildUrl(parameters);

            Assert.AreEqual(ExpectedUrl, req.FullUrl);
        }
        public void ProcessResults_Parses_IDs_Response()
        {
            var reqProc = new MuteRequestProcessor<Mute> { Type = MuteType.IDs };

            List<Mute> mutes = reqProc.ProcessResults(IdsResponse);

            Assert.IsNotNull(mutes);
            Assert.IsNotNull(mutes.SingleOrDefault());
            var mute = mutes.Single();
            Assert.IsNotNull(mute);
            var idList = mute.IDList;
            Assert.IsNotNull(idList);
            Assert.IsTrue(idList.Any());
            var id = idList.First();
            Assert.AreEqual(5676142ul, id);
            var users = mute.Users;
            Assert.IsNotNull(users);
            Assert.IsFalse(users.Any());
            var cursor = mute.CursorMovement;
            Assert.IsNotNull(cursor);
            Assert.AreEqual(2, cursor.Previous);
            Assert.AreEqual(1, cursor.Next);
        }
        public void ProcessResults_Parses_UsersList_Response()
        {
            var reqProc = new MuteRequestProcessor<Mute> { Type = MuteType.List };

            List<Mute> muteList = reqProc.ProcessResults(UsersResponse);

            Assert.IsNotNull(muteList);
            Assert.IsNotNull(muteList.SingleOrDefault());
            var mute = muteList.Single();
            Assert.IsNotNull(mute);
            var users = mute.Users;
            Assert.IsNotNull(users);
            Assert.AreEqual(3, users.Count);
            var user = users.First();
            Assert.IsNotNull(user);
            Assert.AreEqual("93604443", user.UserIDResponse);
            var ids = mute.IDList;
            Assert.IsNotNull(ids);
            Assert.IsFalse(ids.Any());
            var cursor = mute.CursorMovement;
            Assert.IsNotNull(cursor);
            Assert.AreEqual(2, cursor.Previous);
            Assert.AreEqual(1, cursor.Next);
        }