ProGuide Regression Testing - Esri/arcgis-pro-sdk GitHub Wiki

using ArcGIS.Core;
using ArcGIS.Desktop.Core;
using ArcGIS.Desktop.Internal.Core;
using ArcGISTest;
using System.Diagnostics;
using System.Windows.Markup;

namespace GetSymbolSwatchTests
{
  [ArcGISTestClass]
  public static class TestEnvironment
  {
    [AssemblyInitialize()]
    public static void AssemblyInitialize(TestContext testContext)
    {
      StartApplication();
    }

    [AssemblyCleanup]
    public static void AssemblyCleanup()
    {
      StopApplication();
    }

    /// <summary>
    /// Starts an instance of ArcGIS Pro Application
    /// </summary>
    public static async void StartApplication()
    {
      var evt = new System.Threading.ManualResetEvent(false);
      System.Threading.Tasks.Task ready = null;

      var uiThread = new System.Threading.Thread(() =>
      {
        try
        {
          Application = new ProApp();
          ready = Application.TestModeInitializeAsync();
          evt.Set();
        }
        catch (XamlParseException)
        {
          throw new FatalArcGISException("Pro is not licensed");
        }
        catch (Exception ex)
        {
          throw ex;
        }
        finally
        {
          evt.Set();
        }

        System.Windows.Threading.Dispatcher.Run();
      });

      uiThread.TrySetApartmentState(System.Threading.ApartmentState.STA);
      uiThread.Name = "Test UI Thread";
      uiThread.IsBackground = true;
      uiThread.Start();

      evt.WaitOne(); // Task ready to wait on.

      if (ready != null)
      {
        try
        {
          await ready;
        }
        catch (Exception ex)
        {
          throw ex;
        }
      }
    }

    /// <summary>
    /// Shuts down the ArcGIS Pro Application instance
    /// </summary>
    [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
    public static void StopApplication()
    {
      try
      {
        if (Application != null)
          Application.Shutdown();
      }
      catch (Exception e)
      {
        //do not re-throw the exception here.
        Debug.Print("Application.Shutdown threw an exception that was ignored. message: {0}", e.Message);
      }
    }

    /// <summary>
    /// Get an instance of ArcGIS Pro Application
    /// </summary>
    public static ProApp Application { get; private set; }
  }
}

namespace ArcGISTest
{
  public class ArcGISTestClass: Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute
  {
    public ArcGISTestClass(string productId = "ArcGISPro") : base()
    {
      // Install domain wide assembly resolver
      TestResolver.Install(productId);
    }
  }
}

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full 
// license information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text.Json;
using Microsoft.Win32;

namespace ArcGISTest
{
  internal static class TestResolver
  {
    private static Dictionary<string, string> assemblyMap = new Dictionary<string, string>();

    private static string _productId = "ArcGISPro";
    private static string _installDir = String.Empty;

    static TestResolver()
    {
    }

    static public void Install(string productId = "ArcGISPro")
    {
      _productId = productId;
      ConfigureResolver();
      AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CustomResolverHandler);
    }

    private static Assembly CustomResolverHandler(object sender, ResolveEventArgs args)
    {
      System.Reflection.Assembly retAsm = null;

      try
      {
        string filename = args.Name.Split(',')[0];

        if (filename.Contains(".resources.dll"))
          return null;

        string folder = string.Empty;
        var match = assemblyMap.TryGetValue(filename, out folder);

        filename = String.Concat(filename, ".dll");

        if (match)
        {
          retAsm ??= Assembly.LoadFrom(Path.Combine(folder, filename));
        } else
        {
          retAsm ??= Assembly.LoadFrom(Path.Combine(GetProInstallLocation(), 
                                                                     filename));
        }
      }
      catch
      {
        try
        {
          retAsm ??= Assembly.LoadFrom(Path.Combine(
                       GetProInstallLocation(), "Configurations", "Intelligence", 
                           "ArcGIS.Desktop.Intelligence.Configuration.dll"));
        }
        catch
        {
        }
      }

      return retAsm;
    }

    private static string GetProInstallLocation()
    {
      if (!String.IsNullOrEmpty(_installDir))
        return _installDir;

      try
      {
        var sk = Registry.LocalMachine.OpenSubKey(@$"Software\ESRI\{_productId}");
        _installDir = sk.GetValue("InstallDir") as string;
      }
      catch
      {
        try
        {
          var sku = Registry.CurrentUser.OpenSubKey(@$"Software\ESRI\{_productId}");
          _installDir = sku.GetValue("InstallDir") as string;
        }
        catch
        {
        }
      }

      _installDir = Path.Combine(_installDir, "bin");
      return _installDir;
    }

    private static void ConfigureResolver()
    {
      // Already configured
      if (assemblyMap.Count != 0)
      {
        return;
      }

      string installPath = GetProInstallLocation();
      string jsonPath = Path.Combine(installPath, "InstallDependencies.json");
      if (!File.Exists(jsonPath))
      {
        return;
      }

      try
      {
        string fileContent = File.ReadAllText(jsonPath);
        var jd = JsonDocument.Parse(fileContent);
        var root = jd.RootElement;
        var installationNode = root.GetProperty("Installation");

        var folders = installationNode.GetProperty("Folders");
        int count = folders.GetArrayLength();

        for (int i = 0; i < count; ++i)
        {
          var folder = folders[i];
          var folderPath = folder.GetProperty("Path");
          var fullPath = Path.Combine(installPath, folderPath.ToString());

          var assemblies = folder.GetProperty("Assemblies");
          int asmCount = assemblies.GetArrayLength();

          for (int j = 0; j < asmCount; ++j)
          {
            var assm = assemblies[j];
            var asmName = assm.GetProperty("Name");

            assemblyMap.Add(asmName.ToString(), fullPath);
          }
        }
      }
      catch (Exception e)
      {
        System.Diagnostics.Trace.WriteLine(
                  $"Error processing dependency file: {e.Message}");
      }
    }
  }
}

public static async void StartApplication()
    {
      ...

      var uiThread = new System.Threading.Thread(() =>
      {
        try
        {
          //pass in the name of the configuration under test
          Application = new ProApp("MyConfiguration");
          ready = Application.TestModeInitializeAsync();
          evt.Set();
        }
        catch (XamlParseException) ...
        catch (Exception ex) ...
        finally ...
        ...
      });
      ...
    }

using ArcGIS.Desktop.Core;
using ArcGIS.Desktop.Framework.Threading.Tasks;
using ArcGIS.Desktop.Mapping;
using ArcGISTest;
using GetSymbolSwatch;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace GetSymbolSwatchTests
{
  [ArcGISTestClass]
  public class ShowSymbolSwatchDockpaneViewModelTests
  {
    static Map _map = null;
    static IEnumerable<Layer> _layers = null;

    [ClassInitialize]
    public static void ClassInitialize(TestContext testContext)
    {
      //=========================================
      //TODO: Change this path to point to the location of "DevSummit21.aprx" on your machine or to
      //whichever project you are using
      //
      Project project = Project.OpenAsync(@"..\DevSummit21\DevSummit21.aprx").Result;
      QueuedTask.Run(() =>
      {
        _map = project.GetItems<MapProjectItem>().Where(
                             x => x.Name.Equals("Map")).FirstOrDefault().GetMap();
        _layers = _map.GetLayersAsFlattenedList();
      }).Wait();
    }

    [ClassCleanup]
    public static void ClassCleanup()
    {
    }

    [TestInitialize]
    public void TestInitialize()
    {
    }

    [TestCleanup]
    public void TestCleanup()
    {
    }

    [TestMethod]
    public async Task SwatchCountTest()
    {
      ShowSymbolSwatchDockpaneViewModel showSymbolSwatchDockpaneViewModel = 
                                                new ShowSymbolSwatchDockpaneViewModel();

      //var cmdRefreshSwatches = showSymbolSwatchDockpaneViewModel.CmdRefreshSwatches;
      //await _map.OpenViewAsync();
      //cmdRefreshSwatches.Execute(null);

      await showSymbolSwatchDockpaneViewModel.UpdateCollection(_layers.OfType<FeatureLayer>());

      Assert.AreEqual(3, showSymbolSwatchDockpaneViewModel.SymbolSwatchInfoList.Count, 
                         "SymbolSwatchList does not contain expected number of swatches");

    }

    [DataTestMethod]
    [DataRow(0, "Cities", "CIMSimpleRenderer", null, DisplayName = "SimpleRenderer")]
    [DataRow(0, "Volcanos", "CIMClassBreaksRenderer", "127.000000 - 141.000000", 
                                                             DisplayName = "ClassBreaksRenderer")]
    [DataRow(1, "Volcanos", "CIMClassBreaksRenderer", "141.000001 - 165.000000", 
                                                             DisplayName = "ClassBreaksRenderer")]
    public async Task SwatchInfoTest(int swatchIndex, string featureLayerName, 
                                                                   string rendererType, string note)
    {
      ShowSymbolSwatchDockpaneViewModel showSymbolSwatchDockpaneViewModel = 
                                                          new ShowSymbolSwatchDockpaneViewModel();
      await showSymbolSwatchDockpaneViewModel.UpdateCollection(
                 _layers.Where((layer) => { 
                       if (layer.Name == featureLayerName) return true; else return false; 
                 }).OfType<FeatureLayer>());

      SymbolSwatchInfo swatchInfo = 
                        showSymbolSwatchDockpaneViewModel.SymbolSwatchInfoList[swatchIndex];
      Assert.AreEqual(featureLayerName, swatchInfo.FeatureClassName, 
                                       "SwatchInfo feature layer name does not match expected value");
      Assert.AreEqual(rendererType, swatchInfo.RendererType, 
                                       "SwatchInfo feature renderer type does not match expected value");

      if (note is null)
        Assert.IsNull(note);
      else
        Assert.AreEqual(note, swatchInfo.Note);
    }
  }
}

[assembly: InternalsVisibleTo("GetSymbolSwatchTests")]

    internal protected ShowSymbolSwatchDockpaneViewModel() {
      BindingOperations.EnableCollectionSynchronization(SymbolSwatchInfoList, _lockCollection);
    }

public ICommand CmdRefreshSwatches
{
  get
  {
    return _cmdRefreshSwatches ?? (_cmdRefreshSwatches = new RelayCommand(() =>
    {
      SymbolSwatchInfoList.Clear();
      if (MapView.Active?.Map == null) return;
      var layers = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>();

      UpdateCollection(layers);
    }));
  }
}

public async Task UpdateCollection(IEnumerable<FeatureLayer> layers)
{
  await QueuedTask.Run(() =>
  {
    foreach (FeatureLayer layer in layers)
    {
      CIMRenderer renderer = layer.GetRenderer();
      var types = renderer.GetType().ToString().Split(new char[] { '.' });
      var type = types[types.Length - 1];
      switch (type)
      {
        case "CIMSimpleRenderer":
          var simpleSi = GetSymbolStyleItem((renderer as CIMSimpleRenderer).Symbol.Symbol);
          var newSimpleSymbolSwatchInfo = 
                          new SymbolSwatchInfo(layer.Name, type, simpleSi.PreviewImage);
          lock (_lockCollection)
          {
            SymbolSwatchInfoList.Add(newSimpleSymbolSwatchInfo);
          }
          break;
        case "CIMUniqueValueRenderer":
          var uniqueValueRenderer = renderer as CIMUniqueValueRenderer;

          if (uniqueValueRenderer.Groups is null)
            continue;

          foreach (CIMUniqueValueGroup nextGroup in uniqueValueRenderer.Groups)
          {
            foreach (CIMUniqueValueClass nextClass in nextGroup.Classes)
            {
              CIMMultiLayerSymbol multiLayerSymbol = nextClass.Symbol.Symbol as CIMMultiLayerSymbol;
              var mlSi = GetSymbolStyleItem(multiLayerSymbol);
              var newMlSymbolSwatchInfo = new SymbolSwatchInfo(layer.Name, type, mlSi.PreviewImage)
              {
                Note = nextClass.Label
              };
              lock (_lockCollection)
              {
                SymbolSwatchInfoList.Add(newMlSymbolSwatchInfo);
              }
            }
          }
          break;
        case "CIMClassBreaksRenderer":
          var classBreaksRenderer = renderer as CIMClassBreaksRenderer;
          foreach (CIMClassBreak nextClass in classBreaksRenderer.Breaks)
          {
            var classBreakSymbol = nextClass.Symbol.Symbol as CIMSymbol;
            var mlSi = GetSymbolStyleItem(classBreakSymbol);
            var newMlSymbolSwatchInfo = new SymbolSwatchInfo(layer.Name, type, mlSi.PreviewImage)
            {
              Note = nextClass.Label
            };
            lock (_lockCollection)
            {
              SymbolSwatchInfoList.Add(newMlSymbolSwatchInfo);
            }
          }
          if (classBreaksRenderer.UseExclusionSymbol)
          {
            var classBreakSymbol = classBreaksRenderer.ExclusionSymbol.Symbol as CIMSymbol;
            var mlSi = GetSymbolStyleItem(classBreakSymbol);
            var newMlSymbolSwatchInfo = new SymbolSwatchInfo(layer.Name, type, mlSi.PreviewImage)
            {
              Note = classBreaksRenderer.ExclusionLabel
            };
            lock (_lockCollection)
            {
              SymbolSwatchInfoList.Add(newMlSymbolSwatchInfo);
            }
          }
          break;
        default:
          var defaultSymbolSwatchInfo = new SymbolSwatchInfo(layer.Name, type, null)
          {
            Note = "Sample code not implemented"
          };
          lock (_lockCollection)
          {
            SymbolSwatchInfoList.Add(defaultSymbolSwatchInfo);
          }
          break;
      }
    }
  });
}