如何将参数化的JUnit测试运行程序与使用Spring注入的字段一起使用?

我假设您使用的是JUnit4.x,因为您提到了参数化测试运行程序。这意味着您没有使用@runwith(springjunit4classrunner)。没问题,只是列出我的假设。

下面使用Spring从XML文件获取测试文件目录。它不会注入它,但是数据仍然可以用于测试。在静态方法中也不例外。

我看到的唯一缺点是,这可能意味着您的Spring配置被多次解析/配置。如果需要的话,您可以加载一个包含测试特定信息的小文件。

@RunWith(Parameterized.class)
public class MyTest {
    @Parameters
    public static Collection<Object[]> data() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/jeanne/jeanne.xml");
        String dir = ctx.getBean("testFilesDirectory", String.class);

            // write java code to link files in test directory to the array
        return Arrays.asList(new Object[][] { { 1 } });
    }
// rest of test class
}

可以使用Spring中的TestContextManager。在这个例子中,我使用的是理论而不是参数化。

@RunWith(Theories.class)
@ContextConfiguration(locations = "classpath:/spring-context.xml")
public class SeleniumCase {
  @DataPoints
  public static WebDriver[] drivers() {
    return new WebDriver[] { firefoxDriver, internetExplorerDriver };
  }

  private TestContextManager testContextManager;

  @Autowired
  SomethingDao dao;

  private static FirefoxDriver firefoxDriver = new FirefoxDriver();
  private static InternetExplorerDriver internetExplorerDriver = new InternetExplorerDriver();

  @AfterClass
  public static void tearDown() {
    firefoxDriver.close();
    internetExplorerDriver.close();
  }

  @Before
  public void setUpStringContext() throws Exception {
    testContextManager = new TestContextManager(getClass());
    testContextManager.prepareTestInstance(this);
  }

  @Theory
  public void testWork(WebDriver driver) {
    assertNotNull(driver);
    assertNotNull(dao);
  }
}

我在这里找到了这个解决方案: How to do Parameterized/Theories tests with Spring

对于2015年末或以后阅读的人来说, Spring 4.2 除了SpringJunit4ClassRunner之外,还添加了SpringClassRule和SpringMethodRule,它们利用对 Spring TestContext Framework .

这意味着对任何类似跑步者的一流支持 MockitoJUnitRunner 或 Parameterized :

@RunWith(Parameterized.class)
public class FibonacciTest {
    @ClassRule public static final SpringClassRule SCR = new SpringClassRule();
    @Rule public final SpringMethodRule springMethodRule = new SpringMethodRule();

    long input;
    long output;

    public FibonacciTest(long input, long output) { this.input = input; ...} 

    @Test
    public void testFibonacci() {
        Assert.assertEquals(output, fibonacci(input));
    }

    public List<Long[]> params() {
        return Arrays.asList(new Long[][] { {0, 0}, {1, 1} });
    }
}

用注释测试类就足够了 @RunWith(Parameterized.class) 和 @ContextConfiguration 使用 @Autowired 用于依赖项注入和使用 TestContextManager 在用于初始化的构造函数中,例如:

@RunWith(Parameterized.class)
@ContextConfiguration(classes = TestConfig.class)
public class MyTest {

    @Autowired
    private DataSource dataSource;

    private final int param;

    @Parameterized.Parameters
    public static List<Object[]> params() {
        return Arrays.asList(new Object[][]{
            {1},
            {2},
        });
    }

    public MyTest(int p) {
        this.param = p;
        new TestContextManager(getClass()).prepareTestInstance(this);
    }

    @Test
    public void testSomething() {
       …
    }
}

我对参数化的.class使用以下解决方案,没有任何问题: http://bmocanu.ro/coding/320/combining-junit-theoriesparameterized-tests-with-spring/

@ContextConfiguration(value = "classpath:test-context.xml")
public abstract class AbstractJunitTest extends AbstractJUnit4SpringContextTests {
    private static TestContextManager testContextManager = null;
    private static DAOFactory daoFactory = null;

    @Before
    public void initApplicationContext() throws Exception {
        if (testContextManager == null) {
            testContextManager = new TestContextManager(getClass());
            testContextManager.prepareTestInstance(this);
            daoFactory = (DAOFactory)applicationContext.getBean("daoFactory");
        }
    }

    protected DAOFactory getDaoFactory() throws Exception {
        return daoFactory;
    }
}



@RunWith(Parameterized.class)
public class SomeTestClass extends AbstractJunitTest {
     ...
}

这里是第一个没有JUnit 4.12参数化工厂的解决方案,下面是一个改进的解决方案。

没有事务支持的静态上下文

让Spring使用 TestContextManager 班级。

技巧是使用一个假测试实例来获取自动连接的字段,并将它们传递给参数化测试,该测试将有效地运行。

但请记住 prepareTestInstance() 做自动布线,但不管理测试事务和其他好东西处理 beforeTestMethod() 和 afterTestMethod() .

@RunWith(Parameterized.class)
@ContextConfiguration(locations = {"/test-context.xml", "/mvc-context.xml"})
@WebAppConfiguration
@ActiveProfiles("test-profile")
public class MyTest {

  @Parameters
  public static Collection<Object[]> params() throws Exception {
    final MyTest fakeInstance = new MyTest();
    final TestContextManager contextManager = new TestContextManager(MyTest.class);
    contextManager.prepareTestInstance(fakeInstance);
    final WebApplicationContext context = fakeInstance.context;

    // Do what you need with Spring context, you can even access web resources
    final Resource[] files = context.getResources("path/files");
    final List<Object[]> params = new ArrayList<>();
    for (Resource file : files) {
      params.add(new Object[] {file, context});
    }
    return params;
  }

  @Parameter
  public Resource file;
  @Autowired
  @Parameter(1)
  public WebApplicationContext context;
}

但是,如果有很多自动连线字段,则会出现一个缺点,因为必须手动将它们传递给数组参数。

带全弹簧支架的参数化工厂

Junit 4.12介绍 ParametersRunnerFactory 它允许将参数化测试和弹簧注射相结合。

public class SpringParametersRunnerFactory implements ParametersRunnerFactory {
@Override
  public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
    final BlockJUnit4ClassRunnerWithParameters runnerWithParameters = new BlockJUnit4ClassRunnerWithParameters(test);
    return new SpringJUnit4ClassRunner(test.getTestClass().getJavaClass()) {
      @Override
      protected Object createTest() throws Exception {
        final Object testInstance = runnerWithParameters.createTest();
        getTestContextManager().prepareTestInstance(testInstance);
        return testInstance;
      }
    };
  }
}

工厂可以添加到以前的测试类中,以提供像 test transaction , reinit dirty context 和 servlet test . 当然,不再需要将自动连线字段从假测试实例传递到参数化测试。

@UseParametersRunnerFactory(SpringParametersRunnerFactory.class)
@RunWith(Parameterized.class)
@ContextConfiguration(locations = {"/test-context.xml", "/mvc-context.xml"})
@WebAppConfiguration
@Transactional
@TransactionConfiguration
public class MyTransactionalTest {

  @Parameters
  public static Collection<Object[]> params() throws Exception {
    final MyTransactionalTest fakeInstance = new MyTransactionalTest();
    final TestContextManager contextManager = new TestContextManager(MyTransactionalTest.class);
    contextManager.prepareTestInstance(fakeInstance);
    final WebApplicationContext context = fakeInstance.context;

    // Do what you need with Spring context, you can even access web resources
    final Resource[] files = context.getResources("path/files");
    final List<Object[]> params = new ArrayList<>();
    for (Resource file : files) {
      params.add(new Object[] {file});
    }
    return params;
  }

  @Parameter
  public Resource file;

  @Autowired
  private WebApplicationContext context;
}

记住,Spring注入使用@autowired,但也使用setter。因此,不要使用@autowired,而是使用setter:

private static String directory;

public void setDirectory(String directory) {
    this.directory = directory;
}

public static String getDirectory() {
     return directory;
}