Json Parsing Tests - ExpandoObject or Json strings

Setting Up Jason Parsing Tests Using Dynamic Objects Or Strings

[Test]
public void SomeTestUsingExpandoObject()
{
  // arrange
  const string getItemEventDataValue = @"{
      ""_PrimaryId"": ""F:\\dasda\\ToMO-005775.json"",
      ""_SecondaryId"": ""123456"",
      ""RetrievalResult"": ""Processed Successfully""
    }";
  dynamic indexItemRaw = new ExpandoObject();
  indexItemRaw.id = sourceIndexItemId;
  indexItemRaw.version = sourceIndexItemVersion.ToString(CultureInfo.InvariantCulture);
  dynamic source = new ExpandoObject();
  source.getItemEventData = getItemEventDataValue;
  indexItemRaw.source = source;

  // act
  IEnumerable<ClaimDto> claimsEnum = someMapper.Map(JObject.FromObject(indexItemRaw));
  var claimDtos = claimsEnum.ToList();
  
  //assert
  ...
}

[Test]
public void SomeTestUsingJSonStringOnly()
{
  //How to set up unit tests using strings to set up the data, instead of dynamic objects.
  //Sometimes it can be simpler, especially if you retrieve the raw data from a run
  //Here is the above test, arranged using a string as an example
  //In this case I thought it was more complicated to set everything up as a string
  //(because one of the json string object entries (the "getItemEventData") was itself a json string)
  // arrange
  string rawJToken = @"
  {
    ""id"": ""{sourceIndexItemId}"",
    ""version"": ""1.0"",
    ""source"": {
      ""getItemEventData"": ""{
         \""PrimaryId\"": \""F:\\\\dasda\\\\ToMO-005775.json\"",
         \""SecondaryId\"": \""123456\""
         \""RetrievalResult\"": \""Processed Successfully\""
      }""
    }
  }";
  rawJToken = rawJToken.Replace("{sourceIndexItemId}", sourceIndexItemId);
  JToken jtoken = JToken.Parse(rawJToken);

  //act
  IEnumerable<ClaimDto> claimsEnum = someMapper.Map(jtoken);
  var claimDtos = claimsEnum.ToList();

  //assert
  ...
}

Plant UML

Quite often I need to examine some existing code to find a solution to a problem. Sometimes this requires going in detail about what calls what and when. However, usually the code your looking at has many calls to many other objects. We don't want the details of every single call, just the important ones. Here sequence diagrams are very useful to document this visually. I prefer to use PlantUML for this because it allows you to write the diagram as text, PlantUml takes care of spacing everything appropriately. You can just get your object name/type and the method called on it from your IDE.
PlantUML is found at this web address: https://www.plantuml.com/ .
Here is some good documentation on how to use it: https://crashedmind.github.io/PlantUMLHitchhikersGuide/ .
Here is an example of using Plant UML to create a sequence diagram in UML:

@startuml actor Requestor as Actor participant MyApiController #9999ff 'note right of MyApiController 'All Api methods go through TryProcessRequest() 'end note Actor -/ MyApiController: Indexing note left: Normally this would be\ninitiated by a message\non the ServiceBus activate MyApiController MyApiController -> MyApiController: TryProcessRequest activate MyApiController note right: All Api methods go\nthrough TryProcessRequest() participant ServiceBus #99FF99 MyApiController -/ ServiceBus : PublishToTopic("topic.fromAlpha", IndexingCommand) deactivate MyApiController deactivate MyApiController ServiceBus -/ MyIndexingCommandHandler : HandleMessageAsync () activate MyIndexingCommandHandler  MyIndexingCommandHandler -> Indexer : RunIndexingJobAsync() activate Indexer note right: Number of retries of this method\nis controlled by SystemSetting\n"MyIndexingRetries", "FoobarService", 10\nIt is using the default value of 10! Indexer -> MyIndexingCommandHandler : IndexMyItem() note right: IndexMyItem is invoked as a task\nwith a timeout controlled by SystemSetting\n"MyIndexingTimeoutSeconds", "FoobarService", 600\nIt is being set to 3 minutes (180). MyIndexingCommandHandler -> Indexer : DoIndexingAsync() Indexer -> IndexingOperations : AddOrUpdateAsync() activate IndexingOperations IndexingOperations -[#red]> IIndexRepository : SaveAsync() deactivate IndexingOperations deactivate Indexer deactivate MyIndexingCommandHandler ServiceBus -[#red]/ UpdateIndexingSourceHandler : HandleMessageAsync<IndexingUpdateEvent>() note left #FFAAAA: Only if the\nSaveAsync()\ncall succeeds @enduml

Here is the resulting image, click on it to open it full size:

Linqpad Notepad++ Hyperlink Extension

When searching through some files using LinqPad it can be useful to print out the results as a hyperlink that will open the file in Notepad++ at a particular line number.

public static class NotepadppExtension
{
    // Usage
    //string filePath = "X:/some/path/file.txt";
    //filePath.CreateNotePadppHyperLink(lineNumber);

    private const string NotePadppPath = @"C:\Program Files\Notepad++\notepad++.exe";
    private static bool onceOnly = false;

    public static Hyperlinq CreateNotepadppHyperLink(this string filePath, int lineNumber)
    {
        if (!onceOnly)
        {
            onceOnly = true;
            Debug.Assert(File.Exists(NotePadppPath), $"Notepad++.exe Path: \"{NotePadppPath}\" is wrong");
        }
        ProcessStartInfo psi = new ProcessStartInfo()
        {
            FileName = NotePadppPath,
            WorkingDirectory = Path.GetDirectoryName(NotePadppPath),
            //Arguments = " " + filePath + " -n" + lineNumber.ToString() + " ",
        };
        psi.ArgumentList.Add(filePath);
        psi.ArgumentList.Add("-n" + lineNumber.ToString());
        var filelink = new Hyperlinq(() => Process.Start(psi), filePath);

        return filelink;
    }
}

Usage

string filePath = .... ;
filePath.CreateNotePadppHyperLink(lineNumber);

A search files example in Linq

void Main()
{
	Directory.EnumerateFiles(
	@"X:\Backup\Documents\Journals\", 
	"*.log", SearchOption.AllDirectories)
		.SelectMany(file => TryFileReadLines(file).Select((text,n)=> 
                 new {Text=text,LineNumber=n+1, Link=file.CreateNotepadppHyperLink(n+1)}))
		.Where(line => 
		    //Regex.IsMatch(line.text, @"CallSearcherBase")  && 
		    line.Text.Contains("\"Search for this text\"", StringComparison.OrdinalIgnoreCase) )	
		.Dump("Matches found");
}

String Replace with StringComparison

I found this https://stackoverflow.com/questions/244531/is-there-an-alternative-to-string-replace-that-is-case-insensitive/13847351#comment31063745_244933 I added a few defensive checks.

public static string Replace(
    this string src,
    string oldValue,
    string newValue,
    StringComparison comparison)
{
    if (string.IsNullOrEmpty(oldValue))
        throw new ArgumentException("String cannot be of zero length or null.", "oldValue");
        
    if (string.IsNullOrEmpty(newValue)) // It can be an empty string though
        throw new ArgumentException("String cannot be null.", "newValue");

    // skip the loop entirely if oldValue and newValue are the same
    if (string.Compare(oldValue, newValue, comparison) == 0)
        return src;

    if (oldValue.Length > src.Length)
        return src;

    int index = src.IndexOf(oldValue, comparison);
    if (index == -1)
        return src;

    var sb = new StringBuilder(src.Length);

    int previousIndex = 0;

    while (index != -1)
    {
        sb.Append(src.Substring(previousIndex, index - previousIndex));
        sb.Append(newValue);
        index += oldValue.Length;

        previousIndex = index;
        index = src.IndexOf(oldValue, index, comparison);
    }

    sb.Append(src.Substring(previousIndex));

    return sb.ToString();
}

xUnit vs MSTest vs NUnit

There is a good comparison of the 3 unit test libraries:

https://xunit.net/docs/comparisons

EventAggregator in Javascript

I found an EventAggregator in Javascript here: https://davidwalsh.name/pubsub-javascript. It was nice and simple, but it was using a hidden javascript object to map the topic string to an array of listeners. I thought that a Map is more appropriate for this functionality so I changed the code to use one.

I do a lot of logging because this class tends to be the thing that fires all the domain events in a project, so logging here is very useful. I would like to convert it to Typescript some time. In my case the events were mostly sent to the Controller portion of MVC controllers which would decide if they needed to update their Models/Views

"use strict";

// Originally from here: https://davidwalsh.name/pubsub-javascript, 
// changed to use the Map class
// Allows objects to publish and subscribe to custom events/topics
// Changed to use a Map class rather than using an object
var eventAggregator = (function () {
    // maps a topic string to an array of subscriber/listener functions, 
    // each subscriber/listener function takes a single data object parameter 
    var _topicsMap = new Map();
    var _publishingEnabled = false;

    return {
        // topic is a string, listener is a function that takes a 
        // single data object parameter
        Subscribe: function (topic, listener) { 
            // Create the topic's object if not yet created, 
            // the key is the topic string, the value is an empty array (of listeners)
            if (!_topicsMap.has(topic)) _topicsMap.set(topic, []);

            // Add the listener to the array
            var index = _topicsMap.get(topic).push(listener) - 1;

            // Provide handle back for removal of topic
            return {
                Dispose: function () {
                    delete _topicsMap.get(topic)[index];
                }
            };
        },

        Enabled: function (isEnabled) {
            if (_publishingEnabled != isEnabled) {
                _publishingEnabled = isEnabled;
                let isEnabledStr = _publishingEnabled ? "enabled" : "disabled";
                console.log("Events publishing is " + isEnabledStr);
            }
        },

        Publish: function (topic, data) {
            // If publishing is disabled, or the topic doesn't exist,
            // or there's no listeners in the array, just leave
            if (!_publishingEnabled) {
                console.log("'" + topic + "' Events: Publishing is disabled");
                return;
            }
            else if (!_topicsMap.has(topic)) {
                console.warn("Events: Either the topic '" + topic + 
                "' doesn't exist, or there's no listeners in queue");
                return;
            }

            let dataSafe = (data) ? data : "";
            if (typeof dataSafe === 'string' || dataSafe instanceof String) {
                console.log("Events: event raised on topic: '"
                   + topic + "' with data '" + dataSafe + "'");
            } else {
               console.log("Events: event raised on topic: '"
                 + topic + "' with '" + JSON.stringify({ data }) + "'");
            }
            // Cycle through topics array, invoking each listener function
            _topicsMap.get(topic).forEach(function (item) {
                item(data != undefined ? data : {});
            });
        }
    };
})();

FileSystemWatcher Extensions

We can use extension classes to allow React to be used with other FileSystemWatcher usage cases:

public static class FileSystemWatcherExtender
{
  // Returns an IObservable, which is effectively a publisher
  // which can be subscribed to and disposed of when finished with
  public static IObservable<FileSystemEventArgs> 
    GetFileChangedPublisher(this FileSystemWatcher fileSystemWatcher)
  {
      Debug.Assert(fileSystemWatcher != null);
      var result = Observable
        .FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
            ev => fileSystemWatcher.Changed += ev,
            ev => fileSystemWatcher.Changed -= ev)
        .Select(ev => ev.EventArgs);
      return result;
  }

  // Use this to subscribe to FileSystemWatcher errors
  public static IObservable<ErrorEventArgs> 
    GetErrorPublisher(this FileSystemWatcher fileSystemWatcher)
  {
    Debug.Assert(fileSystemWatcher != null);
    return Observable
      .FromEventPattern<ErrorEventHandler, ErrorEventArgs>(
            ev => fileSystemWatcher.Error += ev,
            ev => fileSystemWatcher.Error -= ev)
      .Select(x => x.EventArgs);
  }
}

And to use it

FileSystemWatcher filesystemwatcher = BuildMyFileSystemWatcher();
...
// Subscribed to filesystem watcher changes
// where "onChanged" is a Func<FileSystemEventArgs>
IDisposable subscription = fileSystemWatcher.GetFileChangedPublisher().Subscribe(onChanged);   
...
subscription.Dispose(); // Finish with our subscription
...