Demonstration of bad code, and even worst way of testing bad code

BadClass.cs

using System;

namespace Micro.Starter.Api {
  public class BadClass {
    private IService _service = new Service(); // it's a bad idea to do new inside a class, remember, new is glue
    public void Greet(string name) {
      Console.WriteLine(_service.Greet(name));
    }
  }
}

BadClass.test.cs

namespace Tests
{
    public class BadClassTest
    {
        [Test]
        public void TestGreetDoesNotThrowException()
        {
            var unit = new BadClass();
            // var mock = new Mock<IService>();
            // mock.Setup();
            // use reflection to change the implementation under the hood,
            // unit._service = mock;
            Assert.DoesNotThrow(() => unit.Greet())
        }
    }
}

Service.cs

namespace Micro.Starter.Api {
  public interface IService {
    string Greet(string name);
  }
  public class Service : IService {
    public string Greet(string name) {
        return $"Hello {name}";
    }
  }
}

Looking at this, it should be abundantly clear that, if you're trying to "hack" into internals to do something, then you're doing something wrong, remember, new is glue, here, your class is glued to the Service implementation of IService, there's no way to change that except doing dirty hacks like shown above.

Why is it that this in C# and many languages accepted as a bad practice, but using the following is not considered a bad pattern?

jest.mock('./getTime', () => ({
    getTime: jest.fn().mockReturnValue('mockNow')
}));