DEV Community: Buddy Reno

Implementing a Property Change Tracker For Testing in C#

Buddy Reno — Mon, 02 Dec 2019 22:07:09 +0000

While testing a view model I was creating for a form in an app, I found myself needing the ability to test that a boolean value was being transformed a couple times during a function. I looked into Fluent Assertions (the testing library I was using) and around Google, but didn't find any out-of-the-box solutions.

Since this was a view model that implemented INotifyPropertyChanged, I knew I could tie into the event and make my own tracker! Here's how I created that.

Setup

Let's create a class to start building from.

// We'll need only 2 libraries
using System.Collections.Generic;
using System.ComponentModel;

namespace SharedUtilities.Testing
{
  public PropertyChangeTracker() 
  {
  }
}

The first thing we need to do is to consume a view model in the constructor that implements INotifyPropertyChanged. If you aren't sure what this is, check out the docs here.

namespace SharedUtilities.Testing
{
  private INotifyPropertyChanged _vmInstance;  

  public PropertyChangeTracker(INotifyPropertyChanged vmInstance) 
  {
    _vmInstance = vmInstance;
  }
}

PropertyChangeTracker, utilizes constructor injection to take advantage of inversion of control with an object that implements INotifyPropertyChanged. The argument is then stored in a private variable. Now a "tracker" listener can be assigned to the PropertyChanged event.

public PropertyChangeTracker(INotifyPropertyChanged vmInstance) 
{
  _vmInstance = vmInstance;
  _vmInstance.PropertyChanged += Tracker;
}

private void Tracker(object sender, PropertyChangedEventArgs e) 
{
}

It's important to declare the Tracker function with PropertyChangedEventArgs as opposed to EventArgs. This allows access to the PropertyName variable.

Creating The Tracker

Let's use the PropertyName variable from PropertyChangedEventArgs to gain access to the value of the changed property.

//inside the Tracker method

var prop = sender.GetType().GetProperty(e.PropertyName);
var value = prop?.GetValue(sender);

Awesome! Now we have access to the property name through e.PropertyName as well as the value using the GetValue method! The next step is to create a class that can store the results to give back to the test using this tracker.

public class PropertyChangeTracker
{
  // CODE
}

public class PropertyChangedInfo 
{
  public string PropertyName { get; set; }
  public object Value { get; set; }
}

Note that the Value property is specified as being an object. because we don't know anything about the view model or the property that is being changed. During testing, you will know and can cast the results at that time to the specified type.

We'll also need to declare a list of this new class type to hold all of the property changes that occur.

public class PropertyChangeTracker 
{
  private INotifyPropertyChanged _vmInstance;
  public List<PropertyChangedInfo> ChangedProperties;

  public PropertyChangeTracker(INotifyPropertyChanged vmInstance) 
  {
    ChangedProperties = new List<PropertyChangedInfo>();
    _vmInstance = vmInstance;
    _vmInstance.PropertyChanged += Tracker;
  }
}

Now the Tracker method can add to this list every time it's called using the new PropertyChangedInfo class.

private void Tracker(object sender, PropertyChangedEventArgs e) 
{
  var prop = sender.GetType().GetProperty(e.PropertyName);
  var value = prop?.GetValue(sender);
  var changedProp = new PropertyChangedInfo() 
  {
    PropertyName = prop?.Name,
    Value = value
  };

  ChangedProperties.Add(changedProp);
}

Using it in a test:

// Assuming a method called SaveUser that modifies a boolean property twice
var tracker = new PropertyChangeTracker(classUnderTest);
classUnderTest.SaveUser();

// Using Fluent Assertions
((bool) tracker.ChangedProperties.First().Value).Should().BeTrue();
((bool) tracker.ChangedProperties.Last().Value).Should().BeFalse();

One More Improvement...

There's one problem with this implementation. If any other properties are modified within the method, those would also be added to the list. We could get around that issue by filtering the list with PropertyName:

var newList = tracker.ChangedProperties.FindAll(x => x.PropertyName == "IsBusy");

This seems like too much work. This would require a lot of repetition constantly filtering trackers every time we use them. One of the best principles a programmer can take advantage of is DRY (Don't Repeat Yourself), and we can do that with an option to only track properties we care about. Time to improve the tracker!

We'll start by accepting an optional property name in the constructor:

private string PropertyFilterName;

public PropertyChangeTracker(INotifyPropertyChanged vmInstance, string propNameToTrack = "")
{
  PropertyFilterName = propNameToTrack;
}

Then, in the Tracker code, add a few if statements to control which property is added to the changed list.

if (PropertyFilterName != string.Empty)
{
  // Only add to the list if the names match the filter.
  if (PropertyFilterName == prop?.Name)
  {
    ChangedProperties.Add(changedProp);
  }
}
else 
{
  // if PropertyFilterName is blank, track all changes.
  ChangedProperties.Add(changedProp);
}

Done! Now this same test with a little modification will only track the property that we care about asserting.

var tracker = new PropertyChangeTracker(classUnderTest, "IsBusy");
classUnderTest.SaveUser();

((bool) tracker.ChangedProperties.First().Value).Should().BeTrue();
((bool) tracker.ChangedProperties.Last().Value).Should().BeFalse();

Wrapping Up

I've been doing a deep dive through work and my free time in C#, learning everything it has to offer. I'm sure there are better ways to do property change tracking, but this worked for my use case. I'm extremely open to improvements and changes! Comment if this helps you or you can help make this code better! Here's the full class:

using System.Collections.Generic;
using System.ComponentModel;

namespace SharedUtilities.Testing
{
    public class PropertyChangeTracker
    {
        public List<PropertyChangedInfo> ChangedProperties;
        private INotifyPropertyChanged _vmInstance;
        private string PropertyFilterName;

        public PropertyChangeTracker(INotifyPropertyChanged vmInstance, string propNameToTrack = "")
        {
            PropertyFilterName = propNameToTrack;
            ChangedProperties = new List<PropertyChangedInfo>();
            _vmInstance = vmInstance;
            _vmInstance.PropertyChanged += Tracker;
        }

        private void Tracker(object sender, PropertyChangedEventArgs e)
        {
            var prop = sender.GetType().GetProperty(e.PropertyName);
            var value = prop?.GetValue(sender);
            var changedProp = new PropertyChangedInfo()
            {
                PropertyName = prop?.Name,
                Value = value
            };

            if (PropertyFilterName != string.Empty)
            {
                if (PropertyFilterName == prop?.Name)
                {
                    ChangedProperties.Add(changedProp);
                }
            }
            else
            {
                ChangedProperties.Add(changedProp);
            }
        }
    }

    public class PropertyChangedInfo
    {
        public string PropertyName { get; set; }
        public object Value { get; set; }
    }
}

Expanding Objects in Chrome Dev Tools Happens Asynchronously 🤦‍♂️

Buddy Reno — Mon, 19 Aug 2019 12:30:36 +0000

I had a moment the other day while I was trying to understand how a feature was working from another team. I console logged an object that was being sent to a function to see those properties. When I expanded this object in Chrome's devtools, I knew that some of those values were not correct.

After going round and round for about an hour, I finally saw a little icon next to the object when it was expanded. I hovered over it and things finally made sense.

...oh.

When you console log an object like a string, number, or something with a value that can be shown in the small preview line, that will be the value that it was when the log happened. The console keeps a reference to that value if it's an object that we can expand to see its various properties. When you expand, Chrome reaches into that object and builds out the log at that particular moment so if any modifications happened between the console log and the user expanding the object, those modifications will be shown.

If this is something you need to get around and see the values of some of the underlying properties, log the various properties individually instead of the parent object.

It's a small thing, but something to be aware of when you're trying to figure out how something works. It's easy to miss.

Organizing Routes In Rails

Buddy Reno — Tue, 04 Jun 2019 15:17:09 +0000

I love Ruby on Rails, but one thing that bothered me a lot was how quickly the routes.rb file can get unwieldy. When I began creating version 2 of an API I was making, this issue presented itself. Thankfully, there's an easy way to handle this with a little knowledge of how ruby can reference extended objects.

Consider the following example routes file:

Rails.application.routes.draw do
  root to: redirect("https://www.example.com/show")

  get "/ready", to: proc { [200, {}, [""]] }


  namespace :api do
    namespace :v1 do
      # about 31 routes
    end
    namespace :v2 do
      # about 36 routes
    end
    # v3, v4, v5 and so on
  end
end

That can get extremely long and drawn out, especially if you can't drop older versions of the API for an extended period of time. We can break this up easily by utilizing some events and methods of ruby's extend class and break these versioned routes into their own files.

Folder and File Structure

The routes.rb file is located in the config folder of a Rails app. Create a new folder in the same place: config/routes. We'll store the new route extensions here.

Inside that folder, I want to name the file the same thing as the namespace that will be in the file. The first route collection I want to siphon off is :api :v1. Name the file api_v1_routes.rb to match our module and namespace structure.

Open the new file and create a module called ApiV1Routes.

module ApiV1Routes
end

Extended

When you extend an object, ruby has a helpful event called extended that allows you to execute some code after the object is... extended.

module ApiV1Routes
  def self.extended(router)
  end
end

In the above method, when we create a class that extends this particular module, the extended event will fire with a reference to the object that is being extended. In our case, the extended method is going to receive the router as a parameter.

Execution In Context

Now we have a module that can get a reference to the rails router when it's extended, how do we add routes to the router from here?

All objects in ruby have a method called instance_exec. This takes a block and executes the block within the context of the caller. In our ApiV1Routes module, this looks like the following.

module ApiV1Routes
  def self.extended(router)
    router.instance_exec do

      # add routes
      namespace :api do
        namespace :v1 do
          # 31 v1 routes
        end
      end

    end
  end
end

According to the documentation for instance_exec, the self is set to the calling object so we have access to all the object's instance variables and methods.

In order to set the context, the variable self is set to obj while the code is executing, giving the code access to obj’s instance variables.

The routes are being added as if we were within the routes.rb file itself!

Tying it all together.

Now that we've created the module we need rails to load these route modules, otherwise we won't be able to reference them in our code.

Open the application.rb file, which should also be located in the config folder. Add the following line of code:

# Load split router files
config.autoload_paths += %W(#{config.root}/config/routes)

This tells rails to load the files in the routes folder, since config/routes isn't a default that rails will autoload for you.

Back in the routes.rb file, at the top add extend ApiV1Routes before everything else in the do block.

Rails.application.routes.draw do
  extend ApiV1Routes
  extend ApiV2Routes

  # all our other routes
end

That's it! Any routes you've added this way should now be able to be used! Repeat this for any clearly defined route structures you'd like to separate, then add the extend ModuleName to the routes.rb file.