現代化模擬工具與黑魔法

測試挑戰

在深入探討方法本身之前，首先觀察這是一個靜態方法。在 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 方法會永遠傳回回應，這是 JMockIt 建立的 HttpResponse 子類別的一個實例。
• HttpResponse.getEntity 方法會永遠傳回實體，這是 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;
}

實際執行時間

這種加入執行個體委派、可覆寫靜態 Singleton 和許多萃取方法的技術可能看起來相當多。在實務上，這種變更很快。有多快？對於這個範例，我使用 IntelliJ 花了 3 分鐘。Eclipse 也會花費相同時間。在 vi 中，可能 1 分鐘（好吧，可能不會，但我確實在 Eclipse、IntelliJ 甚至 Visual Studio 中使用 vi 外掛程式）。無論如何，一旦您練習過，就會很快。如果類別一開始就沒有使用所有靜態方法，我們可以避免許多這種情況，但這是一個常見問題，因此知道如何處理它是一種很好的通用技術。

是的，但是...

常見的疑慮是，如何讓所有這些提取的方法受到保護？這並不困擾我，因為我相信測試能力比設計更重要。這實際上是一個錯誤的二分法，但聽起來有爭議，所以我還是喜歡這麼說。事實上，許多這些「受保護的方法」都足夠複雜，足以保證個別類別。接下來，引入依賴反轉，突然間我正在連接受我控制的依賴物件，並使用可覆寫的方法，而且檢查此整體流程的個別部分變得輕而易舉。分而治之。

第一個測試與第二個測試

以下是兩個測試，用於比較

使用 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 等工具會迫使我進行一定程度的重構，才能讓這個類別接受測試。