FISLib_Old/Vinno.vCloud.Common.FIS/Test/VCloudServiceTest.cs

using JsonRpcLite.Rpc;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using Vinno.IUS.Common.Log;
using Vinno.IUS.Common.Network.Leaf;
using Vinno.vCloud.FIS.CrossPlatform.Common;

namespace Vinno.vCloud.Common.FIS.Test
{
    public class VCloudServiceTest : IVCloudServiceTest
    {
        private readonly bool _isTestInOldMode;
        private readonly bool _isSonopost;

        private VCloudTestItem _currentTestItem;

        protected readonly VCloudTestItem _cloudServerConnectionTest;

        internal static string WorkingFolder { get; private set; }

        /// <summary>
        /// Item test status changed
        /// </summary>
        public event EventHandler<VCloudServiceTestResult> TestStatusChanged;

        /// <summary>
        /// raised when Test Finished
        /// </summary>
        public event EventHandler TestFinished;

        /// <summary>
        /// Test items
        /// </summary>
        public IList<VCloudTestItem> Items { get; }

        /// <summary>
        /// Enable remedical service
        /// </summary>
        public bool EnableRemedicalService { get; private set; }

        /// <summary>
        /// Enalbe live service
        /// </summary>
        public bool EnableLiveUsService { get; private set; }

        /// <summary>
        /// Terminal Name
        /// </summary>
        public string TerminalName { get; private set; }

        /// <summary>
        /// vCloud host address
        /// </summary>
        public string VCloudHost { get; private set; }

        /// <summary>
        /// vCloud port
        /// </summary>
        public int VCloudPort { get; private set; }

        public string TerminalVersion { get; private set; }

        public VCloudServiceTest(bool isTestInOldServer, string vCloudHost, int vCloudPort, string currentUsVersion, string workingFolder, string terminalVersion, int screenWidth, int screenHeight, string usModel, string deviceType, bool isUseHttps, bool supportLiveVideo)
        {
            VCloudHost = vCloudHost;
            VCloudPort = vCloudPort;
            TerminalVersion = terminalVersion;
            _isTestInOldMode = isTestInOldServer;
            if (_isTestInOldMode)
            {
                _cloudServerConnectionTest = new VCloudServerConnectionTest(this, currentUsVersion);
                if (!CommonParameter.Instance.IsSonopost)
                {
                    Items = new List<VCloudTestItem>()
                    {
                        new NetworkStatusTest(this),
                        _cloudServerConnectionTest,
                        new RemedicalServiceTest(this),
                    };
                    if (supportLiveVideo)
                    {
                        Items.Add(new LiveUsServiceTest(this, screenWidth, screenHeight));
                    }
                }
                else
                {
                    Items = new List<VCloudTestItem>()
                    {
                        new NetworkStatusTest(this),
                        _cloudServerConnectionTest,
                        new RemedicalServiceTest(this),
                    };
                    if (supportLiveVideo)
                    {
                        Items.Add(new LiveUsServiceTestForSonopost(this));
                    }
                }
            }
            else
            {
                _cloudServerConnectionTest = new VCloudServerConnectionTestV2(this, isUseHttps);
                Items = new List<VCloudTestItem>()
                {
                    new NetworkStatusTestV2(this),
                    _cloudServerConnectionTest,
                    new RemedicalServiceTestV2(this),
                };
                if (supportLiveVideo)
                {
                    Items.Add(new LiveUsServiceTestV2(this, screenWidth, screenHeight, usModel, deviceType, currentUsVersion));
                }
            }
            if (!string.IsNullOrEmpty(workingFolder))
            {
                WorkingFolder = Path.Combine(workingFolder);
            }
            else WorkingFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
        }

        /// <summary>
        /// Execute vCloud test
        /// </summary>
        /// <param name="cancelTokenSource"></param>
        /// <param name="enableRemedicalService"></param>
        /// <param name="enableLiveUsService"></param>
        /// <param name="terminalName"></param>
        public void Execute(CancellationTokenSource cancelTokenSource, bool enableRemedicalService, bool enableLiveUsService, string terminalName = null)
        {
            EnableRemedicalService = enableRemedicalService;
            EnableLiveUsService = enableLiveUsService;
            TerminalName = terminalName ?? string.Empty;
            Logger.WriteLineInfo($"vCloudServiceTest - Execute vCloud server test");
            RunTest(cancelTokenSource);
        }

        /// <summary>
        /// Retry vcloud test
        /// </summary>
        /// <param name="cancelTokenSource"></param>
        public void Retry(CancellationTokenSource cancelTokenSource)
        {
            if (_isTestInOldMode)
            {
                ((VCloudServerConnectionTest)_cloudServerConnectionTest).Close();
            }
            else
            {
                ((VCloudServerConnectionTestV2)_cloudServerConnectionTest).Close();
            }
            Logger.WriteLineInfo($"vCloudServiceTest - Retry vCloud server test");
            foreach (var item in Items)
            {
                item.Status = VCloudTestItemStatus.None;
            }
            RunTest(cancelTokenSource);
        }

        /// <summary>
        /// Skip current test item
        /// </summary>
        /// <param name="cancelTokenSource"></param>
        public void Skip(CancellationTokenSource cancelTokenSource)
        {
            if (_isTestInOldMode)
            {
                ((VCloudServerConnectionTest)_cloudServerConnectionTest).Close();
            }
            else
            {
                ((VCloudServerConnectionTestV2)_cloudServerConnectionTest).Close();
            }
            Logger.WriteLineInfo($"vCloudServiceTest - Skip current vCloud server test item");
            if (_currentTestItem != null)
            {
                _currentTestItem.Status = VCloudTestItemStatus.Skipped;
            }
            RunTest(cancelTokenSource);
        }

        /// <summary>
        /// Close test;
        /// </summary>
        public void Close()
        {
            if (_isTestInOldMode)
            {
                ((VCloudServerConnectionTest)_cloudServerConnectionTest).Close();
            }
            else
            {
                ((VCloudServerConnectionTestV2)_cloudServerConnectionTest).Close();
            }
        }

        private void RunTest(CancellationTokenSource cancelTokenSource)
        {
            try
            {
                if (cancelTokenSource.IsCancellationRequested)
                {
                    return;
                }

                foreach (var item in Items)
                {
                    if (item.Status == VCloudTestItemStatus.TestDone || item.Status == VCloudTestItemStatus.Skipped)
                    {
                        continue;
                    }

                    if (cancelTokenSource.IsCancellationRequested)
                    {
                        return;
                    }

                    _currentTestItem = item;
                    OnTestStatusChanged(new VCloudServiceTestResult(item.Id, VCloudTestItemStatus.TestBeginned));
                    var result = item.Execute();
                    item.Status = result.Status;
                    OnTestStatusChanged(result);

                    if (cancelTokenSource.IsCancellationRequested)
                    {
                        return;
                    }
                    if (item.Status == VCloudTestItemStatus.TestFailed || item.Status == VCloudTestItemStatus.CanSkipped)
                    {
                        break;
                    }
                    if (cancelTokenSource.IsCancellationRequested)
                    {
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"RunTest Error:{ex}");
            }
            finally
            {
                OnTestFinished();
            }
        }

        public ClientLeaf GetvCloudLeaf()
        {
            if (_isTestInOldMode)
            {
                return ((VCloudServerConnectionTest)_cloudServerConnectionTest).Leaf;
            }
            else
            {
                return null;
            }
        }

        public JsonRpcClient GetJsonRpcClient()
        {
            if (!_isTestInOldMode)
            {
                return ((VCloudServerConnectionTestV2)_cloudServerConnectionTest).Client;
            }
            else
            {
                return null;
            }
        }

        protected virtual void OnTestStatusChanged(VCloudServiceTestResult e)
        {
            TestStatusChanged?.Invoke(this, e);
        }

        private void OnTestFinished()
        {
            TestFinished?.Invoke(this, EventArgs.Empty);
        }
    }
}