Add options for setting additional arguments to the tests

It adds:
- ini configuration cpp_arguments
- command line option --cpp-arguments

Author: elkin

README.rst

@@ -42,7 +42,7 @@ Usage
 =====
 
 Once installed, when py.test runs it will search and run tests
-founds in executable files, detecting if the suites are
+found in executable files, detecting if the suites are
 Google or Boost tests automatically.
 
 You can configure which files are tested for suites by using the ``cpp_files``
@@ -55,6 +55,22 @@ ini configuration:
 
 By default matches ``test_*`` and ``*_test`` executable files.
 
+Additional arguments to the C++ tests can be provided with the option
+``--cpp-arguments`` or with the ``cpp_arguments`` ini configuration.
+For example:
+
+.. code-block:: ini
+
+    [pytest]
+    cpp_arguments=-v --log-dir=logs
+
+Or the same with the command line option:
+
+.. code-block:: console
+
+    $ pytest --cpp-arguments='-v --log-dir=logs'
+
+
 Requirements
 ============
 

pytest_cpp/boost.py

@@ -28,7 +28,7 @@ def list_tests(self, executable):
         # inside the executable, so the test_id is a dummy placeholder :(
         return [os.path.basename(os.path.splitext(executable)[0])]
 
-    def run_test(self, executable, test_id):
+    def run_test(self, executable, test_id, test_args=()):
 
         def read_file(name):
             try:
@@ -46,6 +46,7 @@ def read_file(name):
             '--log_sink=%s' % log_xml,
             '--report_sink=%s' % report_xml,
         ]
+        args.extend(test_args)
         p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
         stdout, _ = p.communicate()
 

pytest_cpp/google.py

@@ -53,13 +53,14 @@ def strip_comment(x):
                 result.append(test_suite + strip_comment(line).strip())
         return result
 
-    def run_test(self, executable, test_id):
+    def run_test(self, executable, test_id, test_args=()):
         xml_filename = self._get_temp_xml_filename()
         args = [
             executable,
             '--gtest_filter=' + test_id,
             '--gtest_output=xml:%s' % xml_filename,
         ]
+        args.extend(test_args)
         try:
             subprocess.check_output(args,
                                     stderr=subprocess.STDOUT,

pytest_cpp/plugin.py

@@ -1,16 +1,17 @@
-import fnmatch
 import os
 import stat
+
 import pytest
-from pytest_cpp.boost import BoostTestFacade
 
+from pytest_cpp.boost import BoostTestFacade
 from pytest_cpp.error import CppFailureRepr, CppFailureError
-
 from pytest_cpp.google import GoogleTestFacade
 
 FACADES = [GoogleTestFacade, BoostTestFacade]
 DEFAULT_MASKS = ('test_*', '*_test')
 
+_ARGUMENTS = 'cpp_arguments'
+
 
 def pytest_collect_file(parent, path):
     try:
@@ -20,7 +21,16 @@ def pytest_collect_file(parent, path):
         is_executable = False
     if not is_executable:
         return
-    masks = parent.config.getini('cpp_files') or DEFAULT_MASKS
+
+    config = parent.config
+    masks = config.getini('cpp_files') or DEFAULT_MASKS
+
+    test_args = config.getoption(_ARGUMENTS)
+    if test_args:
+        test_args = test_args.split()
+    else:
+        test_args = config.getini(_ARGUMENTS) or ()
+
     if not parent.session.isinitpath(path):
         for pat in masks:
             if path.fnmatch(pat):
@@ -29,32 +39,43 @@ def pytest_collect_file(parent, path):
             return
     for facade_class in FACADES:
         if facade_class.is_test_suite(str(path)):
-            return CppFile(path, parent, facade_class())
+            return CppFile(path, parent, facade_class(), test_args)
 
 
 def pytest_addoption(parser):
     parser.addini("cpp_files", type="args",
         default=DEFAULT_MASKS,
         help="glob-style file patterns for C++ test module discovery")
+    parser.addini(_ARGUMENTS,
+                  type='args',
+                  default='',
+                  help='Additional arguments for test executables')
+
+    group = parser.getgroup('cpp tests')
+    group.addoption('--cpp-arguments', help='Additional test arguments')
 
 
 class CppFile(pytest.File):
-    def __init__(self, path, parent, facade):
+    def __init__(self, path, parent, facade, arguments):
         pytest.File.__init__(self, path, parent)
         self.facade = facade
+        self._arguments = arguments
 
     def collect(self):
         for test_id in self.facade.list_tests(str(self.fspath)):
-            yield CppItem(test_id, self, self.facade)
+            yield CppItem(test_id, self, self.facade, self._arguments)
 
 
 class CppItem(pytest.Item):
-    def __init__(self, name, collector, facade):
+    def __init__(self, name, collector, facade, arguments):
         pytest.Item.__init__(self, name, collector)
         self.facade = facade
+        self._arguments = arguments
 
     def runtest(self):
-        failures = self.facade.run_test(str(self.fspath), self.name)
+        failures = self.facade.run_test(str(self.fspath),
+                                        self.name,
+                                        self._arguments)
         if failures:
             raise CppFailureError(failures)
 
@@ -65,6 +86,3 @@ def repr_failure(self, excinfo):
 
     def reportinfo(self):
         return self.fspath, 0, self.name
-
-
-

tests/SConstruct

@@ -19,13 +19,16 @@ genv = env.Clone(LIBS=['gtest'] + LIBS)
 Export('env genv')
 
 genv.Program('gtest.cpp')
+genv.Program('gtest_args.cpp')
 
 boost_files = [
     'boost_success.cpp',
     'boost_failure.cpp',
     'boost_fatal_error.cpp',
     'boost_error.cpp',
     'boost_fixture_setup_error.cpp',
+    'boost_one_argument.cpp',
+    'boost_two_arguments.cpp'
 ]
 
 for filename in boost_files:

tests/boost_one_argument.cpp

@@ -0,0 +1,11 @@
+#define BOOST_TEST_MODULE TestOneArgument
+#include <boost/test/included/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(one_argument)
+{
+    int argc = boost::unit_test::framework::master_test_suite().argc;
+    char **argv = boost::unit_test::framework::master_test_suite().argv;
+
+    BOOST_CHECK( argc == 2 );
+    BOOST_CHECK_EQUAL(argv[1], "argument1");
+}

tests/boost_two_arguments.cpp

@@ -0,0 +1,12 @@
+#define BOOST_TEST_MODULE TestTwoArguments
+#include <boost/test/included/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(two_arguments)
+{
+    int argc = boost::unit_test::framework::master_test_suite().argc;
+    char **argv = boost::unit_test::framework::master_test_suite().argv;
+
+    BOOST_CHECK( argc == 3 );
+    BOOST_CHECK_EQUAL(argv[1], "argument1");
+    BOOST_CHECK_EQUAL(argv[2], "argument2");
+}

tests/gtest_args.cpp

@@ -0,0 +1,24 @@
+#include "gtest/gtest.h"
+
+namespace {
+int argsNumber;
+char **args;
+
+TEST(ArgsTest, one_argument) {
+  EXPECT_EQ(2, argsNumber);
+  EXPECT_STREQ("argument1", args[1]);
+}
+
+TEST(ArgsTest, two_arguments) {
+  EXPECT_EQ(3, argsNumber);
+  EXPECT_STREQ("argument1", args[1]);
+  EXPECT_STREQ("argument2", args[2]);
+}
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  argsNumber = argc;
+  args = argv;
+  return RUN_ALL_TESTS();
+}

tests/test_pytest_cpp.py

@@ -260,6 +260,101 @@ def test_cpp_files_option(testdir, exes):
     assert len(result.matchreport(exes.exe_name('gtest')).result) == 4
 
 
+def test_google_one_argument(testdir, exes):
+    testdir.makeini('''
+        [pytest]
+        cpp_arguments = argument1
+    ''')
+
+    result = testdir.inline_run(exes.get('gtest_args'),
+                                '-k',
+                                'ArgsTest.one_argument')
+    assert_outcomes(result,
+                    [('ArgsTest.one_argument', 'passed')])
+
+
+def test_google_two_arguments(testdir, exes):
+    testdir.makeini('''
+        [pytest]
+        cpp_arguments = argument1 argument2
+    ''')
+
+    result = testdir.inline_run(exes.get('gtest_args'),
+                                '-k',
+                                'ArgsTest.two_arguments')
+    assert_outcomes(result,
+                    [('ArgsTest.two_arguments', 'passed')])
+
+
+def test_google_one_argument_via_option(testdir, exes):
+    result = testdir.inline_run(exes.get('gtest_args'),
+                                '-k',
+                                'ArgsTest.one_argument',
+                                '--cpp-arguments', 'argument1')
+    assert_outcomes(result,
+                    [('ArgsTest.one_argument', 'passed')])
+
+
+def test_google_two_arguments_via_option(testdir, exes):
+    result = testdir.inline_run(exes.get('gtest_args'),
+                                '-k',
+                                'ArgsTest.two_arguments',
+                                '--cpp-arguments',
+                                'argument1 argument2')
+    assert_outcomes(result,
+                    [('ArgsTest.two_arguments', 'passed')])
+
+
+def test_argument_option_priority(testdir, exes):
+    testdir.makeini('''
+        [pytest]
+        cpp_arguments = argument2
+    ''')
+    result = testdir.inline_run(exes.get('gtest_args'),
+                                '-k',
+                                'ArgsTest.one_argument',
+                                '--cpp-arguments', 'argument1')
+    assert_outcomes(result,
+                    [('ArgsTest.one_argument', 'passed')])
+
+
+def test_boost_one_argument(testdir, exes):
+    testdir.makeini('''
+        [pytest]
+        cpp_arguments = argument1
+    ''')
+
+    result = testdir.inline_run(exes.get('boost_one_argument'))
+    assert_outcomes(result,
+                    [('boost_one_argument', 'passed')])
+
+
+def test_boost_two_arguments(testdir, exes):
+    testdir.makeini('''
+        [pytest]
+        cpp_arguments = argument1 argument2
+    ''')
+
+    result = testdir.inline_run(exes.get('boost_two_arguments'))
+    assert_outcomes(result,
+                    [('boost_two_arguments', 'passed')])
+
+
+def test_boost_one_argument_via_option(testdir, exes):
+    result = testdir.inline_run(exes.get('boost_one_argument'),
+                                '--cpp-arguments',
+                                'argument1')
+    assert_outcomes(result,
+                    [('boost_one_argument', 'passed')])
+
+
+def test_boost_two_arguments_via_option(testdir, exes):
+    result = testdir.inline_run(exes.get('boost_two_arguments'),
+                                '--cpp-arguments=argument1 argument2')
+    assert_outcomes(result,
+                    [('boost_two_arguments', 'passed')])
+
+
 def test_passing_files_directly_in_command_line(testdir, exes):
     f = exes.get('boost_success')
     result = testdir.runpytest(f)