C# class after refactoring to improve testability

csharp-class-refactored-for-testability.cs

// This is an example class illustrating some common patterns
// to simplify unit testing
public class MuchEasierToTest{
  // Changed to ISomeModel so we can inject a mock model during testing
  ISomeModel model;
  IPath path;
    
  // Update constructor to take ISomeOtherDependency so we can inject a mock instance
  // during testing. Same thing for ISomeModelFactory and IPath.
  public ReallyHardToTest(ISomeOtherDependency otherDependency, ISomeModelFactory someModelFactory, IPath path){
    // Invoke the method on our factory instead of directly creating a Model instance
    // Our tests can now verify that a new ISomeModel instance is created in the constructor
    model = someModelFactory.Create();
    
    // Because we are programming against ISomeOtherDependency, we can verify that this
    // method is invoked at test time.
    otherDependency.DoSomething();
    
    this.path = path;
  }
  
  public void SetFilename(string fileName){  
    // Invoke method on injected IPath instance instead of the
    // static Path class.
    model.Filename = path.GetFileName(fileName);
  }
}

PathWrapper.cs

// This code implements a wrapper around the static Path class.
// The interface allows us to inject a mock IPath instance at
// test time (for example when testing the MuchEasierToTest class).

public interface IPath{
  string GetFileName(string fileName);
}

public class PathImpl : IPath {
  public string GetFileName(string fileName){
    return Path.GetFileName(fileName);
  }
}

SomeModel.cs

// Introducing an interface enables us to mock SomeModel in tests
public interface ISomeModel{
  string FileName{get;set;}
}

// Same concrete SomeModel type as in original file.
public class SomeModel : ISomeModel{
  public string FileName{get;set;}
}

// Introducing a factory interface enables us to verify
// that creation logic is invoked and also to control
// the result of creation by returning a mock instance
public interface ISomeModelFactory{
  ISomeModel Create();
}

// Notice that the factory class only has one responsibility:
// To give us a new instance of a type implementing ISomeModel.
// At test time, we will be able to inject a mock factory instance
// and control what it returns, giving us better control over
// our test coverage.
public class SomeModelFactory : ISomeModelFactory{
  public ISomeModel Create(){
    return new SomeModel();
  }
}

SomeOtherDependency.cs

// Introducing an interface enables us to mock SomeOtherDependency in tests
public interface ISomeOtherDependency{
  void DoSomething();
}

// Same concrete SomeOtherDependency type as original file
public class SomeOtherDependency : ISomeOtherDependency{
  public void DoSomething(){
    // Just here for illustration.
  }
}