现代模拟工具与黑魔法

测试挑战

在深入研究该方法本身之前，首先观察到这是一个静态方法。在 Java、C#、C++（以及许多其他语言）中，静态方法始终在编译（或链接）时绑定。这意味着调用静态方法的代码直接耦合到这些方法。方法的选择和调用机制选择得过早，无法轻松地让测试设置一个环境，使它们能够转移到测试控制的东西。可以使用 Michael Feathers 所谓的“链接缝合线”在运行时调用不同的静态方法。在 Java 的情况下，你可以确保具有静态方法的不同版本的类在类路径中更早地可用。下面将对此进行更多介绍。

Map<String, String> symbolToName = currencySymbols();
if (!symbolToName.containsKey(fromCurrency))
    throw new IllegalArgumentException(String.format(
            "Invalid from currency: %s", fromCurrency));
if (!symbolToName.containsKey(toCurrency))
    throw new IllegalArgumentException(String.format(
            "Invalid to currency: %s", toCurrency));

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();

StringBuffer result = new StringBuffer();
if (entity != null) {
    InputStream instream = entity.getContent();
    InputStreamReader irs = new InputStreamReader(instream);
    BufferedReader br = new BufferedReader(irs);
    String l;
    while ((l = br.readLine()) != null) {
        result.append(l);
    }
}
String theWholeThing = result.toString();

int start = theWholeThing.lastIndexOf("<div id=\"converter_results\"><ul><li>");
String substring = result.substring(start);
int startOfInterestingStuff = substring.indexOf("<b>") + 3;
int endOfIntererestingStuff = substring.indexOf("</b>",
        startOfInterestingStuff);
String interestingStuff = substring.substring(
        startOfInterestingStuff, endOfIntererestingStuff);
String[] parts = interestingStuff.split("=");
String value = parts[1].trim().split(" ")[0];

设置 - 练习代码

一个起点是简单地尝试使用空参数或“合理”的值来执行有问题的代码。由于该领域是货币转换，并且该方法接受两种货币，这似乎是一个合理的起点。

这是一个简单地执行代码的自动单元测试的开始。我的目标是完成这个方法。需要注意的是，虽然这段代码可以在有网络连接的情况下运行，但我写这个测试的时候已经关闭了我的连接，以确保我的测试不需要网络连接才能运行。

@Test
public void returnExpectedConversion_v1() {
    CurrencyConversion.convertFromTo("USD", "EUR");
}

如果网络已启用，这将起作用，但如果没有，代码将生成一个java.net.UnknownHostException。然而，它实际发生的地方是在CurrencyConversion.currencySymbols方法中，而不是在我们关心的方法中。使用旧的工具，这需要一些工作，但对于我们这篇文章中选择的工具来说，情况并非如此：JMockIt

通过验证

这是测试的第二个版本，它通过了第一个异常。

@Test
public void returnExpectedConversion_v2() {
    new NonStrictExpectations(CurrencyConversion.class) {
        {
            CurrencyConversion.currencySymbols();
            result = mapFrom("USD", "EUR");
        }
    };
    CurrencyConversion.convertFromTo("USD", "EUR");
}

private Map<String, String> mapFrom(String... keyValuePairs) {
    Map<String, String> result = new ConcurrentHashMap<String, String>();
    for (int i = 0; i < keyValuePairs.length; ++i)
        result.put(keyValuePairs[i], keyValuePairs[i]);
    return result;
}

运行这个，抛出了相同的异常，UnknownHostException，但异常现在是在测试中的方法中，而不是在被调用的方法中。这是一个改进。这允许代码通过验证，但如何实现呢？

new NonStrictExpectations(CurrencyConversion.class) {
    {
        CurrencyConversion.currencySymbols();
        result = mapFrom("USD", "EUR");
    }
};

注意使用NonStrictExpectations创建的匿名内部类？这种形式告诉 JMockIt 对 CurrencyConversion类做一些事情（在这种情况下替换一个静态方法）。内部 {} 中的代码是标准的 Java 实例初始化器。在该实例初始化器中执行的代码告诉 JMockIt 替换执行的方法，currencySymbols。这是一个对类进行部分模拟的例子；我们替换了类中的一个方法，这样每次调用它时，它都会返回分配给继承字段“result”的值。

这涉及一些黑魔法。JMockIt 做了一些 Java 字节码魔法，这段代码使用 JMockIt DSL 来实现这一点。要使它工作，需要将 JMockIt jar 文件添加到类路径中。如果你确保它在 JUnit 的 jar 文件之前列出，就足以使它发生。JMockIt 使用在其 MANIFEST.MF 文件中注册的 JavaAgent 来使这一切自动化。

处理客户端

现在代码在尝试读取网页的部分代码上失败了。

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();

这段代码稍微复杂一些，因为它嵌入在方法中，但我们可以解决这个问题。然而，这样做会需要更多工作。

• 前两行调用new。我们需要使这些对 new 运算符的使用返回一个我们控制的类。
• 下一行在HttpClient上调用execute方法，所以我们需要控制它。
• 最后一行在HttpResponse上调用getEntity方法，它是前一行的返回值，所以这总体上更加复杂。

以下是一种一举解决这三个问题的方法。

new NonStrictExpectations() {
    DefaultHttpClient httpclient;
    HttpResponse response;
    HttpEntity entity;

    {
        httpclient.execute((HttpUriRequest) any);
        result = response;
        response.getEntity();
        result = entity;
        entity.getContent();
        result = bais;
    }
};

在这个NonStrictExpectations的使用中，第一行没有传入参数，这意味着我们正在以某种方式处理实例，而不是静态内容。这个匿名内部类有三个字段：DefaultHttpClient、HttpResponse、HttpEntity。这些类在 Java 类加载器中完全被替换，只针对这个测试。这意味着，例如，调用 new DefaultHttpClient 将返回 JMockIt 创建的类的实例，而不是在 HttpClient jar 中找到的版本。

这是一个我称之为动态链接缝合线的例子。它是一个像 Michael Feathers 在他的书中讨论的链接缝合线，通常是通过构建脚本/文件魔法来实现的。然而，与使用构建脚本不同，这是使用一个库，这使得它可以在 Java 代码“内部”语言中使用，而不是在语言之外。

这段代码替换了这三个类，但用什么替换呢？

• HttpClient.execute方法将始终返回 response，它是 JMockIt 创建的 HttpResponse 子类的实例。
• HttpResponse.getEntity方法将始终返回 entity，它是 JMockIt 创建的 HttpEntity 子类的实例。
• HttpEntity.getContent方法将始终返回“bais”，我们将在下一节中看到。

不要误解，这是强大的东西。事实上，我有一个个人经验法则：如果我认为某件事很酷，那么它可能不适合实际开发。JMockIt 使我的“酷蜘蛛感应”过度兴奋。

处理文件 I/O

底层代码需要流的内容。为了创建它，测试使用一些标准的 Java 魔法来创建一个内存流。

final ByteArrayInputStream bais = new ByteArrayInputStream(
        "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>"
                .getBytes());

这从一个字符串创建一个内存中的ByteArrayInputStream。我怎么知道要放什么字符串？我不得不对底层代码进行逆向工程。即便如此，这也使代码能够执行。

整合

以下是一个测试作为单个方法，而不是像迄今为止那样被分解。

@Test
public void returnExpectedConversion_v3() throws Exception {
    final ByteArrayInputStream bais = new ByteArrayInputStream(
            "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>"
                    .getBytes());

    new NonStrictExpectations() {
        DefaultHttpClient httpclient;
        HttpResponse response;
        HttpEntity entity;

        {
            httpclient.execute((HttpUriRequest) any);
            result = response;
            response.getEntity();
            result = entity;
            entity.getContent();
            result = bais;
        }
    };

    new NonStrictExpectations(CurrencyConversion.class) {
        {
            CurrencyConversion.currencySymbols();
            result = mapFrom("USD", "EUR");
        }
    };
    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");
    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));
}

一方面，这相当令人印象深刻。我们设法在不接触代码的情况下端到端地执行了代码。如果我们想编写一些使用这个类的代码，我们现在有了一种方法。通常，在尝试接触一些代码之前，我们需要先对其进行测试，这样我们就知道在进行更改后是否破坏了任何东西。这被称为特征测试。像这样的写得不好的代码通常会使这样做变得非常困难。虽然它仍然很困难，但至少我们能够在不接触生产代码的情况下做到这一点。在代码周围进行特征测试可以使重构更安全。

所以我们完成了，对吧？

错了。

我们解决了症状，而不是原因

请注意，JMockIt 使得实现近乎黑魔法成为可能，但我们可以做得更好吗？如果我们尝试，投入的时间是否值得？在本节中，我们从同一个方法开始，对代码进行一些所谓的遗留重构，使其可以使用更传统的工具进行测试，在本例中是手工编写的测试替身。然后我们将进行比较，做出观察，然后看看什么将成为可能。

引入实例委托

静态方法的一个典型问题是它们不能被覆盖。为了解决这个问题，我们可能只需让类使用所有实例方法。但是，让我们假设在这个例子中，我们需要维护向后兼容性，所以我们需要保留静态方法（根据我的经验，这并非牵强附会）。

虽然我可能会尝试先进行测试，但事实上，我有一个现有的 JMockIt 测试，所以我会简单地进行必要的更改。我会通过将 CurrencyConversion 复制到一个新的包中来做到这一点，该包的名称添加了 v2（这个博客的源代码是从源代码生成的，所以我需要保留原始版本）。

要引入一个实例委托器。

• 引入类的静态实例。
• 将静态方法复制到实例方法中（你需要创建新的方法名称，因为静态方法和实例方法不能具有相同的名称和签名）。
• 将静态方法更改为在内部静态实例上调用实例方法。

以下是一种方法（内部实例的延迟初始化是故意的，如果你担心线程问题，我们可以使用双重检查锁定，或者只是使方法同步）。

private static CurrencyConversion instance;

private static CurrencyConversion getInstance() {
    if (instance == null) {
        instance = new CurrencyConversion();
    }

    return instance;
}

public static BigDecimal convertFromTo(String fromCurrency, String toCurrency) {
    return getInstance().convert(fromCurrency, toCurrency);
}

public static Map<String, String> currencySymbols() {
    return getInstance().getAllCurrencySymbols();
}

提取一些方法

有很多机会提取一些方法，所以这里是在进行了一些方法提取后 v2/CurrencyConversion 的一个版本。

public BigDecimal convert(String fromCurrency, String toCurrency) {
    validateCurrencies(fromCurrency, toCurrency);

    try {
        String result = getPage(fromCurrency, toCurrency);
        String value = extractToValue(result);
        return new BigDecimal(value);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

protected void validateCurrencies(String fromCurrency, String toCurrency) {
    Map<String, String> symbolToName = currencySymbols();
    if (!symbolToName.containsKey(fromCurrency))
        throw new IllegalArgumentException(String.format(
                "Invalid from currency: %s", fromCurrency));
    if (!symbolToName.containsKey(toCurrency))
        throw new IllegalArgumentException(String.format(
                "Invalid to currency: %s", toCurrency));
}

protected String extractToValue(String result) {
    String theWholeThing = result;
    int start = theWholeThing.lastIndexOf("<div id=\"converter_results\"><ul><li>");
    String substring = result.substring(start);
    int startOfInterestingStuff = substring.indexOf("<b>") + 3;
    int endOfIntererestingStuff = substring.indexOf("</b>",
            startOfInterestingStuff);
    String interestingStuff = substring.substring(
            startOfInterestingStuff, endOfIntererestingStuff);
    String[] parts = interestingStuff.split("=");
    return parts[1].trim().split(" ")[0];
}

protected String getPage(String fromCurrency, String toCurrency) throws URISyntaxException, IOException, HttpException {
    String url = String.format("http://www.gocurrency.com/v2/dorate.php?inV=1&from=%s&to=%s&Calculate=Convert", toCurrency, fromCurrency);
    HttpClient httpclient = new DefaultHttpClient();
    HttpGet httpget = new HttpGet(url);
    HttpResponse response = httpclient.execute(httpget);
    HttpEntity entity = response.getEntity();
    StringBuffer result = new StringBuffer();
    if (entity != null) {
        InputStream instream = entity.getContent();
        InputStreamReader irs = new InputStreamReader(instream);
        BufferedReader br = new BufferedReader(irs);
        String l;
        while ((l = br.readLine()) != null) {
            result.append(l);
        }
    }
    return result.toString();
}

这是一个针对这个类的最后一个测试的版本（位于 v2 包中）。这个测试通过了。

@Test
public void returnExpectedConversion_v4() throws Exception {
    final ByteArrayInputStream bais = new ByteArrayInputStream(
            "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>"
                    .getBytes());

    new NonStrictExpectations() {
        DefaultHttpClient httpclient;
        HttpResponse response;
        HttpEntity entity;

        {
            httpclient.execute((HttpUriRequest) any);
            result = response;
            response.getEntity();
            result = entity;
            entity.getContent();
            result = bais;
        }
    };

    new NonStrictExpectations(CurrencyConversion.class) {
        {
            CurrencyConversion.currencySymbols();
            result = mapFrom("USD", "EUR");
        }
    };
    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");
    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));
}

测试子类

现在我将使用手工编写的测试替身而不是 JMockIt 来重写这个测试。我不会展示所有中间步骤，我只展示最终结果。

class CurrencyConversion2_testingSubclass extends CurrencyConversion {
    @Override
    public void validateCurrencies(String fromCurrency, String toCurrency) {
    }

    @Override
    public Map<String, String> getAllCurrencySymbols() {
        return mapFrom("USD", "EUR");
    }

    @Override
    public String getPage(String fromCurrency, String toCurrency) {
        return "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>";
    }
}

@Test
public void returnExpectedConversion_v5() throws Exception {
    CurrencyConversion original = CurrencyConversion.reset(new CurrencyConversion2_testingSubclass());

    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");

    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));

    CurrencyConversion.reset(original);
}

这个测试产生了与 JMockIt 测试相同的结果，它手工完成了大部分工作。

请注意，为了使这成为可能，我们需要允许设置和重置新创建的 Singleton 类。

public static CurrencyConversion reset(CurrencyConversion other) {
    CurrencyConversion original = instance;
    instance = other;
    return original;
}

实际花费时间

这种引入实例委托器、可覆盖的静态单例和几个提取方法的技术可能看起来相当多。实际上，这种类型的更改很快。有多快？对于这个例子来说，我使用 IntelliJ 花了 3 分钟。Eclipse 也需要相同的时间。在 vi 中，可能需要 1 分钟（好吧，可能不是，但我确实在 Eclipse、IntelliJ 甚至 Visual Studio 中使用 vi 插件）。无论如何，一旦你练习了，它就很快。如果类一开始没有使用所有静态方法，我们本可以避免很多这种情况，但这是一个常见的问题，所以知道如何处理它是一个很好的通用技术。

是的，但是...

一个常见的担忧是，将所有这些提取方法设为 protected 会怎么样？这并不困扰我，因为我认为可测试性比设计更重要。这实际上是一个错误的二分法，但它听起来很有争议，所以我喜欢这么说。事实上，许多这些“受保护的方法”足够复杂，需要单独的类。接下来，引入依赖倒置，突然我连接了受我控制的依赖对象，它们具有可覆盖的方法，检查这个整体流程的各个部分变得轻而易举。分而治之。

第一次测试与第二次测试

以下是两个测试，用于比较。

使用 JMockIt

@Test
public void returnExpectedConversion_v4() throws Exception {
    final ByteArrayInputStream bais = new ByteArrayInputStream(
            "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>"
                    .getBytes());

    new NonStrictExpectations() {
        DefaultHttpClient httpclient;
        HttpResponse response;
        HttpEntity entity;

        {
            httpclient.execute((HttpUriRequest) any);
            result = response;
            response.getEntity();
            result = entity;
            entity.getContent();
            result = bais;
        }
    };

    new NonStrictExpectations(CurrencyConversion.class) {
        {
            CurrencyConversion.currencySymbols();
            result = mapFrom("USD", "EUR");
        }
    };
    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");
    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));
}

使用手工编写的模拟和重构

class CurrencyConversion2_testingSubclass extends CurrencyConversion {
    @Override
    public void validateCurrencies(String fromCurrency, String toCurrency) {
    }

    @Override
    public Map<String, String> getAllCurrencySymbols() {
        return mapFrom("USD", "EUR");
    }

    @Override
    public String getPage(String fromCurrency, String toCurrency) {
        return "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>";
    }
}

@Test
public void returnExpectedConversion_v5() throws Exception {
    CurrencyConversion original = CurrencyConversion.reset(new CurrencyConversion2_testingSubclass());

    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");

    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));

    CurrencyConversion.reset(original);
}

如果你必须支持测试代码，你更喜欢哪个版本？等等，先别回答。

第一次测试仍然通过

我想重申，即使我对生产代码进行了一些更改，JMockIt 测试仍然通过。这对我很感兴趣。事实上，如果你从 JMockIt 如何操作类加载器的角度考虑，这是有道理的。即便如此，它仍然很酷。

如果我们再次尝试使用 JMockIt 会怎样

为什么停在这里？如果我们花时间重写 JMockIt 测试，同时考虑对生产代码所做的更改，会发生什么？

@Test
public void returnExpectedConversion_final() throws Exception {
    new NonStrictExpectations(CurrencyConversion.class) {
        CurrencyConversion c;
        {
            c.validateCurrencies(anyString, anyString);
            c.getPage(anyString, anyString);
            result = "<div id=\"converter_results\"><ul><li><b>1 USD = 0.98 EUR</b>";
        }
    };
    BigDecimal result = CurrencyConversion.convertFromTo("USD", "EUR");
    assertThat(result.subtract(new BigDecimal(2)), is(lessThanOrEqualTo(new BigDecimal(0.001))));
}

现在你想要维护哪个？

请注意，一些重构使最终的 JMockIt 测试变得更好。事实上，编写这个版本的测试所需的重构量小于我所做的重构量。仅仅提取方法就足以极大地改善 JMockIt 测试。但是请注意，JMockIt 没有强迫这样做。不使用模拟工具或使用像 Mockito 这样的工具会强迫我进行一些重构才能使这个类能够进行测试。