MConnectSDK/MCC_xUnit/UnitTestSuite.cs

using MConnectSDK;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Xunit;

namespace MCC_xUnitTest
{
  public class UnitTestSuite
  {
    #region area oggetti globali 

    /// <summary>
    /// Token x cancellazione thread
    /// </summary>
    protected CancellationTokenSource _cts = new CancellationTokenSource();
    /// <summary>
    /// Istanza classe MaestroConnectClient
    /// </summary>
    public MConnectClient MCC;
    /// <summary>
    /// Risposta BASE della classe di comunicazione
    /// </summary>
    protected Result reqStatus;
    /// <summary>
    /// File conf yaml
    /// </summary>
    protected string confFilePath = "mconnect.conf.yaml";

    /// <summary>
    /// Restituisce un oggetto MCC inizializzato di base
    /// </summary>
    /// <returns></returns>
    public MConnectClient getNewMCC()
    {
      // arrange
      if (_cts != null)
      {
        _cts.Cancel();
      }

      // act (COMMON)
      MCC = new MConnectClient();
      return MCC;
    }

    #endregion


    [Fact]
    [Trait("Category", "Init")]
    public void Create_MCC()
    {
      // act
      MCC = getNewMCC();

      // assert
      Assert.NotNull(MCC);
    }

    [Fact]
    [Trait("Category", "Init")]
    public void initSDK_hasResult()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);

      // assert
      Assert.NotNull(taskResult.Result);
    }

    [Fact]
    [Trait("Category", "Init")]
    public void initSDK_throwNoConfig()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync("", CancellationToken.None);

      // assert is handled by the ExpectedException
      Action actual = () => taskResult.Result.ToString();


      // assert
      Assert.Throws<AggregateException>(actual);
    }

    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_callResultOk()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.True(reqStatus.CallResultOk);
    }
    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_error()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.Null(reqStatus.Error);
    }
    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_localOk()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.True(reqStatus.LocalStatusOk);
    }
    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_cloudOk()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.True(reqStatus.CloudStatusOk);
    }
    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_sourceOk()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.NotNull(reqStatus.Source);
    }
    [Fact]
    [Trait("Category", "InitResult")]
    public void initSDK_payloadOk()
    {
      // act
      MCC = getNewMCC();
      Task<Result> taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      reqStatus = taskResult.Result;

      // asserts
      Assert.Null(reqStatus.Payload);
    }


    #region Test OAUTH

    [Fact]
    [Trait("Category", "OAuth")]
    public void tryActGetUserCode()
    {
      // act
      MCC = getNewMCC();
      // init async... su DB NON auth...
      Task<Result> tResInit = MCC.InitSDKAsync(confFilePath.Replace("mconnect.conf", "mconnectNoAuth.conf"), CancellationToken.None);
      ActivationPayload actPayload = new ActivationPayload();
      string userCode = "";
      tResInit.Wait();
      // provo a chiamare procedura AUTH
      _cts = new CancellationTokenSource();
      // imposto scadenza max 10 sec...
      _cts.CancelAfter(10000);
      CancellationToken token = _cts.Token;
      // gestione progress...
      var progressHandler = new Progress<Result>(value =>
      {
        // aggiorno richiesta live...
        reqStatus = value;
        // se ho token chiudo!
        actPayload = (ActivationPayload)reqStatus.Payload;
        // salvo solo se != ""
        userCode = actPayload.UserCode != "" ? actPayload.UserCode : userCode;
        // forzo cancellazione
        _cts.Cancel();
      });
      var progress = progressHandler as IProgress<Result>;

      Task<Result> tResActivation = MCC.TryActivationAsync(token, progress);
      tResActivation.Wait();
      // assert
      Assert.True(userCode != "");
    }


    #endregion


    #region Test INFO UTENTI

    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    [Trait("Category", "UserData")]
    public void getUserList(bool getImages)
    {
      // act
      MCC = getNewMCC();
      // init async...
      Task<Result> taskResult1 = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      taskResult1.Wait();
      Task<Result> taskResult2 = MCC.GetClientStatusAsync();

      var userResult = MCC.getUserListAsync(getImages);
      List<UserData> userList = ((UserPayload)userResult.Result.Payload).UserList;

      // assert
      Assert.True(userList.Count > 0);
    }
    
    [Theory]
    [InlineData("slocatelli", "ViaDante16!", UserReason.AllOk)]
    [InlineData("slocatelli", "WrongPassword", UserReason.PwdMismatch)]
    [InlineData("slocatelli_wrong", "ViaDante16!", UserReason.UserNotFound)]
    [Trait("Category", "UserData")]
    public void tryLogin(string username, string password, UserReason loginResult)
    {
      // act
      MCC = getNewMCC();
      // init async...
      Task<Result> taskResult1 = MCC.InitSDKAsync(confFilePath, CancellationToken.None);
      taskResult1.Wait();
      Task<Result> userResult = MCC.TryUserLogin(username, password);
      userResult.Wait();

      // assert
      Assert.True(userResult.Result.Error.Reason == loginResult);
    }


    #endregion

  }
}