Ejemplo n.º 1
0
        public void DoSyncApiCall_Success()
        {
            // ARRANGE
            string   version   = "4.13.0";
            DateTime buildTime = new DateTime(2019, 1, 1, 0, 0, 0);

            ApiServerVersion expected = new ApiServerVersion {
                ServerVersion  = version,
                RestApiVersion = version,
                BuildDate      = buildTime
            };

            RestResponse response = FactoryRestSharp.RestResponse;

            response.Content    = JsonConvert.SerializeObject(expected);
            response.StatusCode = HttpStatusCode.OK;
            Mock.NonPublic.Arrange <bool>(response, "IsSuccessful").Returns(true);
            IRestRequest request = FactoryRestSharp.GetServerVersionMock();

            Mock.Arrange(() => DracoonClient.HttpConfig).Returns(new DracoonHttpConfig {
                WebProxy = new WebProxy()
            });
            Mock.Arrange(() => new RestClient().Execute(request)).IgnoreInstance().Returns(response);

            IInternalDracoonClient c    = FactoryClients.InternalDracoonClientMock();
            IRequestExecutor       exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);

            // ACT
            ApiServerVersion actual = exec.DoSyncApiCall <ApiServerVersion>(request, RequestType.GetServerVersion);

            // ASSERT
            Assert.Equal(expected.BuildDate, actual.BuildDate);
            Assert.Equal(expected.RestApiVersion, actual.RestApiVersion);
            Assert.Equal(expected.ServerVersion, actual.ServerVersion);
        }
        public string GetVersion()
        {
            _client.Executor.CheckApiServerVersion();
            IRestRequest     request = _client.Builder.GetServerVersion();
            ApiServerVersion result  = _client.Executor.DoSyncApiCall <ApiServerVersion>(request, RequestType.GetServerVersion);

            return(result.ServerVersion);
        }
        void IRequestExecutor.CheckApiServerVersion(string minVersionForCheck = ApiConfig.MinimumApiVersion)
        {
            if (_isServerVersionCompatible && minVersionForCheck == ApiConfig.MinimumApiVersion)
            {
                return;
            }

            if (_apiVersion == null)
            {
                ApiServerVersion serverVersion =
                    ((IRequestExecutor)this).DoSyncApiCall <ApiServerVersion>(_client.Builder.GetServerVersion(), RequestType.GetServerVersion);
                string version = serverVersion.RestApiVersion;
                if (version.Contains("-"))
                {
                    version = version.Remove(version.IndexOf("-"));
                }

                _apiVersion = Regex.Split(version, "\\.");
            }

            string[] minVersion = Regex.Split(minVersionForCheck, "\\.");
            for (int iterate = 0; iterate < 3; iterate++)
            {
                int remoteVersionPart = int.Parse(_apiVersion[iterate]);
                int minVersionPart    = int.Parse(minVersion[iterate]);
                if (remoteVersionPart > minVersionPart)
                {
                    break;
                }

                if (remoteVersionPart < minVersionPart)
                {
                    if (minVersionForCheck == ApiConfig.MinimumApiVersion)
                    {
                        throw new DracoonApiException(DracoonApiCode.API_VERSION_NOT_SUPPORTED);
                    }

                    throw new DracoonApiException(new DracoonApiCode(0, "Server API versions < " + minVersionForCheck + " are not supported."));
                }
            }

            if (minVersionForCheck == ApiConfig.MinimumApiVersion)
            {
                _isServerVersionCompatible = true;
            }
        }