将数据库日志添加到JUnit3

在过去的十年中，我们已经编写了成千上万的JUnit3测试，现在正尝试将结果合并到数据库中，而不是分散的日志文件中。 事实证明，扩展TestCase类非常容易做到这一点。 注意：这种方法并不直接适用于JUnit4或其他测试框架，但是通常可以做类似的事情。

被测类及其测验

出于演示目的，我们可以使用单个方法来定义一个类进行测试。

public class MyTestedClass {

    public String op(String a, String b) {
        return ((a == null) ? "" : a) + ":" + ((b == null) ? "" : b);
    }
}

具有单个要测试方法的类比您想象的要少的限制。 在前面提到的数千个测试中，我们仅测试了四种方法。

这是上述类的一些测试。

public class MySimpleTest extends SimpleTestCase {

    private MyTestedClass obj = new MyTestedClass();

    public void test1() {
        assertEquals("a:b", obj.op("a", "b"));
    }

    public void test2() {
        assertEquals(":b", obj.op(null, "b"));
    }

    public void test3() {
        assertEquals("a:", obj.op("a", null));
    }

    public void test4() {
        assertEquals(":", obj.op(null, null));
    }

    public void test5() {
        // this will fail
        assertEquals(" : ", obj.op(null, null));
    }
}

使用TestListener捕获基本信息

JUnit3允许向侦听器添加其测试过程。 在测试运行之前和之后以及测试失败或有错误（引发异常）的任何时间调用此侦听器。 此TestListener将基本测试信息写入System.out，以作为概念证明。 修改它以将信息写入数据库，JMS主题等很容易。

public class SimpleTestListener implements TestListener {
    private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
    private long start;
    private boolean successful = true;
    private String name;
    private String failure = null;

    SimpleTestListener() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public void startTest(Test test) {
        start = System.currentTimeMillis();
    }

    public void addError(Test test, Throwable t) {
        // cache information about error.
        successful = false;
    }

    public void addFailure(Test test, AssertionFailedError e) {
        // cache information about failure.
        failure = e.getMessage();
        successful = false;
    }

    /**
     * After the test finishes we can update the database with statistics about
     * the test - name, elapsed time, whether it was successful, etc.
     */
    public void endTest(Test test) {
        long elapsed = System.currentTimeMillis() - start;

        SimpleDateFormat fmt = new SimpleDateFormat();
        fmt.setTimeZone(UTC);

        System.out.printf("[%s, %s, %s, %d, %s, %s]\n", test.getClass().getName(), name, fmt.format(new Date(start)),
                elapsed, failure, Boolean.toString(successful));

        // write any information about errors or failures to database.
    }
}

生产TestListener应该在错误和失败方面做更多的事情。 我将其忽略，以便专注于更广泛的问题。

该侦听器不是线程安全的，因此我们将要使用Factory模式为每个测试创建一个新实例。 我们可以在工厂中创建重量级对象，例如，在工厂中打开SQL DataSource并将新的Connection传递给每个实例。

public class SimpleTestListenerFactory {
    public static final SimpleTestListenerFactory INSTANCE = new SimpleTestListenerFactory();

    public SimpleTestListenerFactory() {
        // establish connection data source here?
    }

    public SimpleTestListener newInstance() {
        // initialize listener.
        SimpleTestListener listener = new SimpleTestListener();
        return listener;
    }
}

如果我们知道测试框架是纯串行的，我们可以通过创建缓冲区并在startTest（）中调用System.setOut（）然后在endTest（）中还原原始System.out来捕获所有控制台输出。 只要测试永不重叠，此方法就行得通，否则会引起问题。 但是，这可能会出现问题– IDE可能具有自己的允许并行执行的测试运行程序。

我们用自己的方法覆盖标准的run（）方法，该方法在调用现有的run（）方法之前创建并注册一个侦听器。

public class SimpleTestCase extends TestCase {
     
        public void run(TestResult result) {
            SimpleTestListener l = SimpleTestListenerFactory.INSTANCE.newInstance();
            result.addListener(l);
            l.setName(getName());
            super.run(result);
            result.removeListener(l);
        }
    }

现在，我们将预期的结果发送到System.out。

[MySimpleTest, test1, 8/2/15 11:58 PM, 0, null, true]
[MySimpleTest, test2, 8/2/15 11:58 PM, 10, null, true]
[MySimpleTest, test3, 8/2/15 11:58 PM, 0, null, true]
[MySimpleTest, test4, 8/2/15 11:58 PM, 0, null, true]
[MySimpleTest, test5, 8/2/15 11:58 PM, 4, expected same:<:> was not:< : >, false]

使用外观和TestListener捕获呼叫信息

这是一个好的开始，但我们可能会做得更好。 在上面提到的数千个测试中，仅调用了4种方法-如果我们能够捕获这些调用的输入和输出值，则将非常强大。

如果由于某些原因不可接受AOP，则可以使用AOP或日志记录外观包装这些功能。 在简单的情况下，我们可以简单地捕获输入和输出值。

public class MyFacadeClass extends MyTestedClass {
        private MyTestedClass parent;
        private String a;
        private String b;
        private String result;
     
        public MyFacadeClass(MyTestedClass parent) {
            this.parent = parent;
        }
     
        public String getA() {
            return a;
        }
     
        public String getB() {
            return b;
        }
     
        public String getResult() {
            return result;
        }
     
        /**
         * Wrap tested method so we can capture input and output.
         */
        public String op(String a, String b) {
            this.a = a;
            this.b = b;
            String result = parent.op(a, b);
            this.result = result;
            return result;
        }
    }

我们像以前一样记录基本信息，并添加一些新代码来记录输入和输出。

public class AdvancedTestListener extends SimpleTestListener {

    AdvancedTestListener() {
    }

    /**
     * Log information as before but also log call details.
     */
    public void endTest(Test test) {
        super.endTest(test);

        // add captured inputs and outputs
        if (test instanceof MyAdvancedTest) {
            MyTestedClass obj = ((MyAdvancedTest) test).obj;
            if (obj instanceof MyFacadeClass) {
                MyFacadeClass facade = (MyFacadeClass) obj;
                System.out.printf("[, , %s, %s, %s]\n", facade.getA(), facade.getB(), facade.getResult());
            }
        }
    }
}

日志现在显示基本信息和呼叫详细信息。

[MyAdvancedTest, test2, 8/3/15 12:13 AM, 33, null, true]
[, , null, b, :b]
[MyAdvancedTest, test3, 8/3/15 12:13 AM, 0, null, true]
[, , a, null, a:]
[MyAdvancedTest, test4, 8/3/15 12:13 AM, 0, null, true]
[, , null, null, :]
[MyAdvancedTest, test1, 8/3/15 12:13 AM, 0, null, true]
[, , a, b, a:b]

我们希望将基本详细信息和呼叫详细信息相关联，但是通过添加唯一的测试ID可以轻松实现。

在现实世界中，这种方法还不够，在单个测试中，被测方法可能被多次调用。 在这种情况下，我们要么需要一种方法来缓存多组输入和输出值，要么需要扩展侦听器，以便我们可以在每个涵盖方法的末尾调用它。

通过将结果编码为XML或JSON而不是简单的列表，可以使结果更具扩展性。 这将使我们仅捕获感兴趣的值或轻松处理将来添加的字段。

[MyAdvancedTest, test2, 8/3/15 12:13 AM, 33, null, true]
{"a":null, "b":"b", "results":":b" }
[MyAdvancedTest, test3, 8/3/15 12:13 AM, 0, null, true]
{"a":"a", "b":null, "results":"a:" }
[MyAdvancedTest, test4, 8/3/15 12:13 AM, 0, null, true]
{"a":null, "b":null, "results":":" }
[MyAdvancedTest, test1, 8/3/15 12:13 AM, 0, null, true]
{"a":" a", "b":"b", "results":" a:b" }

捕获

现在我们可以通过重放捕获的输入来重新运行测试，但是盲目比较结果存在两个问题。 首先，如果我们只关心单个值，这将是很多不必要的工作。 其次，许多测试是不确定的（例如，它们使用随时间变化的固定数据甚至实时数据），而我们不关心的事情可能会改变。

这不是一个容易的问题。 如果幸运的话，测试将遵循标准模式，我们可以对正在执行的测试做出很好的猜测，但需要手动进行验证。

首先，我们需要使用捕获某些或所有方法调用的外观包装测试方法的结果。 调用历史记录应该以一种我们以后可以重播的形式提供，例如一系列方法名称和序列化参数。

其次，我们需要包装TestCase assertX方法，以便捕获最近的方法调用以及传递给assert调用的值（当然还有结果）。

例

通过示例最容易展示和删除该过程。 让我们从一个简单的POJO开始。

public class Person {
    private String firstName;
    private String lastName;

    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
}

在这种情况下，我们的外观仅需要记录方法名称。

典型的测试方法是

public void test1() {
    Person p = getTestPerson();
    assertEquals("John", p.getFirstName());
    assertEquals("Smith", p.getLastName());
}

使用包装的assertX方法

static PersonFacade person;

public static void assertEquals(String expected, String actual) {
    // ignoring null handling...
    boolean results = expected.equals(actual);
    LOG.log("assertEquals('" + expected + "',"+person.getMethodsCalled()+ ") = " + results);
    person.clearMethodsCalled();
    if (!results) {
        throw new AssertionFailedError("Expected same:<" + expected + " > was not:<" + actual + ">");
    }
}

所以我们会得到像

assertEquals('John', getFirstName()) = true;
assertEquals('Smith', getLastName()) = false;

不难看出如何通过测试框架来解析它，但是现在还为时过早。 第二种测试方法是

public void test1() {
    Person p = getTestPerson();
    assertEquals("john", p.getFirstName().toLowerCase());
}

并且我们的简单代码不会捕获toLowerCase（） 。 我们的日志将错误记录：

assertEquals('John', getFirstName()) = false;

更为病理的情况是：

public void test1() {
    Person p = getTestPerson();
    LOG.log("testing " + p.getFirstName());
    assertEquals("john", "joe");
}

断言与包装的类无关。

有明显的创可贴，例如，我们可以捕获外观中的返回值，但这是一个非常深的兔子洞，我们希望远离它。 我认为答案是做出合理的第一次尝试，手动验证结果，然后再做。 （可选：将测试重写为可以捕获的形式。）

翻译自: https://www.javacodegeeks.com/2015/08/adding-database-logging-to-junit3.html