public void Call_NotMoreThen3CallsPerSecond()
        {
            int invocationCount = 0;
            var browser = new Mock<IBrowser>();
            browser.Setup(m => m.GetJson(It.IsAny<string>()))
                   .Returns(@"{ ""response"": 2 }")
                   .Callback(() => invocationCount++);

            var api = new VkApi {Browser = browser.Object};

            var start = DateTimeOffset.Now;
            while (true)
            {
                api.Call("someMethod", VkParameters.Empty, true);

                int total = (int)(DateTimeOffset.Now - start).TotalMilliseconds;
                if (total > 999)
                    break;

            }

            // Не больше 4 раз, т.к. 4-ый раз вызывается через 1002 мс после первого вызова, а total выходит через 1040 мс
            // переписать тест, когда придумаю более подходящий метод проверки
            browser.Verify(m => m.GetJson(It.IsAny<string>()), Times.AtMost(4));
        }

        /// <summary>
        /// Получение json по url-адресу
        /// </summary>
        /// <param name="url">Адрес получения json</param>
        /// <returns>Строка в формате json</returns>
        public string GetJson(string url, VkApi vkApi)
        {
            var separatorPosition = url.IndexOf('?');
            string methodUrl = separatorPosition < 0 ? url : url.Substring(0, separatorPosition);
            string parameters = separatorPosition < 0 ? string.Empty : url.Substring(separatorPosition + 1);

            return WebCall.PostCall(methodUrl, parameters, vkApi).Response;
        }

 private WebCall(string url, Cookies cookies, VkApi vk)
 {
     Request = (HttpWebRequest)WebRequest.Create(url);
     Request.Accept = "text/html";
     Request.UserAgent = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)";
     Request.CookieContainer = cookies.Container;
     if (!vk.isDefaultVkApi)
     {
         createProxy(ProxyManager.getInstance().reserveOrGet(vk.email), Request);
     }
     Result = new WebCallResult(url, cookies);
 }

        public static WebCallResult PostCall(string url, string parameters,VkApi vk)
        {
            var call = new WebCall(url, new Cookies(), vk);
            call.Request.Method = "POST";
            call.Request.ContentType = "application/x-www-form-urlencoded";
            
            var data = Encoding.UTF8.GetBytes(parameters);
            call.Request.ContentLength = data.Length;

            using (var requestStream = call.Request.GetRequestStream())
                requestStream.Write(data, 0, data.Length);                

            return call.MakeRequest(vk);
        }

        public static WebCallResult Post(WebForm form, VkApi vk)
        {
            var call = new WebCall(form.ActionUrl, form.Cookies, vk);

            var request = call.Request;
            
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            var formRequest = form.GetRequest();
            request.ContentLength = formRequest.Length;
            request.Referer = form.OriginalUrl;
            request.GetRequestStream().Write(formRequest, 0, formRequest.Length);
            request.AllowAutoRedirect = false;

            return call.MakeRequest(vk);
        }

        public void Init()
        {
            var browser = new Mock<IBrowser>();
            browser.Setup(m => m.GetJson(It.Is<string>(s => s == Url)))
                .Callback(Callback)
                .Returns(() =>
                {
                    if (string.IsNullOrWhiteSpace(Json))
                    {
                        throw new ArgumentNullException(nameof(Json), @"Json не может быть равен null. Обновите значение поля Json");
                    }
                    return Json;
                });

            browser.Setup(o => o.Authorize(
                It.IsAny<ulong>(),
                It.IsAny<string>(),
                It.IsAny<string>(),
                It.IsAny<Settings>(),
                It.IsAny<Func<string>>(),
                It.IsAny<long?>(),
                It.IsAny<string>(),
                It.IsAny<string>(),
                It.IsAny<int?>(),
                It.IsAny<string>(),
                It.IsAny<string>()
                )
			)
			.Returns(VkAuthorization.From(new Uri("https://vk.com/auth?__q_hash=qwerty&access_token=token&expires_in=1000&user_id=1")));
            Api = new VkApi
            {
                Browser = browser.Object
            };
            Api.Authorize(new ApiAuthParams
            {
	            ApplicationId = 1,
				Login = "login",
				Password = "pass",
				Settings = Settings.All
            });
	        Api.RequestsPerSecond = 10000; // Чтобы тесты быстрее выполнялись
        }

 public void Search_EmptyAccessToken_ThrowAccessTokenInvalidException()
 {
     var vk = new VkApi();
     int count;
     This.Action(() => vk.Users.Search(Query, out count)).Throws<AccessTokenInvalidException>();
 }

		/// <summary>
		/// Методы для работы с подарками.
		/// </summary>
		/// <param name="vk">API.</param>
		internal GiftsCategory(VkApi vk)
		{
			_vk = vk;
		}

 internal DocsCategory(VkApi vk)
 {
     _vk = vk;
     Ex = new DocsCategoryExtended(this, _vk);
 }

		/// <summary>
		/// Методы для работы с приложениями.
		/// </summary>
		/// <param name="vk">API.</param>
		internal AppsCategory(VkApi vk)
		{
			_vk = vk;
		}

 internal UsersCategory(VkApi vk)
 {
     _vk = vk;
 }

 public void AuthorizeByTokenNegative()
 {
     Api = new VkApi(); // В базовом классе предопределено свойство AccessToken
     Api.Authorize("", 1);
     Assert.That(Api.UserId, Is.Null);
 }

 /// <summary>
 /// Методы для работы с подарками.
 /// </summary>
 /// <param name="vk">API.</param>
 public AuthCategory(VkApi vk)
 {
     _vk = vk;
 }

 /// <summary>
 /// Методы для работы с закладками.
 /// </summary>
 /// <param name="vk">API.</param>
 internal FaveCategory(VkApi vk)
 {
     _vk = vk;
 }

        public void Call_ThrowsCaptchaNeededException()
        {
            const string json =
                @"{
                    'error': {
                      'error_code': 14,
                      'error_msg': 'Captcha needed',
                      'request_params': [
                        {
                          'key': 'oauth',
                          'value': '1'
                        },
                        {
                          'key': 'method',
                          'value': 'messages.send'
                        },
                        {
                          'key': 'uid',
                          'value': '242508553'
                        },
                        {
                          'key': 'message',
                          'value': 'hello10'
                        },
                        {
                          'key': 'type',
                          'value': '0'
                        },
                        {
                          'key': 'access_token',
                          'value': '1fe7889c3395722934b1'
                        }
                      ],
                      'captcha_sid': '548747100691',
                      'captcha_img': 'http://api.vk.com/captcha.php?sid=548747100284&s=1'
                    }
                  }";

            var browser = Mock.Of<IBrowser>(m => m.GetJson(It.IsAny<string>()) == json);
            var api = new VkApi {Browser = browser};

            var ex = This.Action(() => api.Call("messages.send", VkParameters.Empty, true)).Throws<CaptchaNeededException>();

            ex.Sid.ShouldEqual(548747100691);
            ex.Img.ShouldEqual(new Uri("http://api.vk.com/captcha.php?sid=548747100284&s=1"));
        }

 internal FaveCategory(VkApi vk)
 {
     _vk = vk;
     Ex = new FaveCategoryExtended(this, _vk);
 }

 internal DocsCategoryExtended(DocsCategory docsCategory, VkApi vk)
 {
     _docs = docsCategory;
     _vk = vk;
 }

 internal DatabaseCategory(VkApi vk)
 {
     _vk = vk;
 }

		/// <summary>
		/// API для работы с лайками.
		/// </summary>
		/// <param name="vk">The vk.</param>
		internal LikesCategory(VkApi vk)
		{
			_vk = vk;
		}

 internal FriendsCategory(VkApi vk)
 {
     _vk = vk;
 }