Question

I have the following class

public interface IAuthProvider
{
    string GenerateKey();
}

public class AuthProvider : IAuthProvider
{
    public string GenerateKey()
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var data = new byte[16];
            rng.GetBytes(data);
            return BitConverter.ToString(data).Replace("-","");
        }
    }
}

I also have the follow unit tests to go with it

[TestClass]
public class AuthProviderTests
{
    private AuthProvider _provider;
    private string _key;

    [TestInitialize]
    public void Initialize()
    {
        _provider = new AuthProvider();
        _key = _provider.GenerateKey();
    }

    [TestMethod]
    public void GenerateKey_key_length_is_32_characters()
    {
        Assert.AreEqual(32, _key.Length);
    }

    [TestMethod]
    public void GenerateKey_key_is_valid_uppercase_hexidecimal_string()
    {
        Assert.IsTrue(_key.All(c =>
            (c >= '0' && c <= '9') || 
            (c >= 'A' && c <= 'F')
        ));
    }

    [TestMethod]
    public void GenerateKey_keys_are_random()
    {
        var keys = new List<string>
            {
                _provider.GenerateKey(),
                _provider.GenerateKey(),
                _provider.GenerateKey(),
                _provider.GenerateKey(),
                _provider.GenerateKey()
            };

        var distinctCount = keys.Distinct().Count();

        Assert.AreEqual(5, distinctCount);
    }
}

Everything works great. However I need to create a method (and tests to go with it) called GenerateSecret. This method will do exactly the same as GenerateKey().

Now I am thinking I should create a method called GenerateRandomHexString(int bytes) and copy the code from GenerateKey into it. Then for GenerateKey and GenerateSecret I should use the follow code:

public interface IAuthProvider
{
    string GenerateKey();
    string GenerateSecret();
    string GenerateRandomHexString(int bytes);
}

public class AuthProvider : IAuthProvider
{
    public string GenerateKey()
    {
        return GenerateRandomHexString(16);
    }

    public string GenerateSecret()
    {
        return GenerateRandomHexString(16);
    }

    public string GenerateRandomHexString(int bytes)
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var data = new byte[bytes];
            rng.GetBytes(data);
            return BitConverter.ToString(data).Replace("-","");
        }
    }
}

Now for the tests, should I just write the tests for the GenerateRandomHexString method, or should I write tests also for the GenerateSecret and GenerateKey (which will be pretty much identical tests)

Answer 1

It’s a bad idea to create many interface methods to do the same thing. I also don’t put overloads on interfaces. The problem this creates is that methods that have the same semantic meaning can have wildly divergent implementations. They might not in the simplest cases, but simple cases often become complex ones eventually.

I love extension methods for this problem.

public interface IAuthProvider
{
    string GenerateKey();
}

public static class IAuthProviderExtensions
{
    public static string GenerateSecret(this IAuthProvider provider)
    {
         return provider.GenerateKey();
    }
}

Test:

[Test]
public void GenerateSecretIsAliasForGenerateKey()
{
    var mockProvider = new Mock<IAuthProvider>();
    var key = GenerateARandomStringSomehow();
    mockProvider.Setup(p=>p.GenerateKey()).Returns(key);
    Assert.That(mockProvider.Object.GenerateSecret(), Is.EqualTo(key));
}