def test_subunit_output_with_tags():
    """
    Test Subunit output with tags
    """

    state.expect = [
        Includes({
            'status': 'success',
            'tags': set(['slow-ish']),
        }),
        Includes({
            'status': 'success',
            'tags': set(['fast-ish']),
        }),
        Includes({
            'status': 'success',
            'tags': set(),
        }),
        Includes({
            'status': 'success',
            'tags': set(),
        }),
    ]

    runner = Runner(feature_name('tagged_features'), enable_subunit=True)
    runner.run()

def test_subunit_output_undefined_steps():
    """
    Test Subunit output with undefined steps
    """

    state.expect = [
        Includes({
            'status': 'fail',
            'details': Includes({
                'steps': ContentContains(
                    '? When this test step is undefined\n'),
            }),
        }),
        Includes({
            'status': 'fail',
            'details': Includes({
                'steps': ContentContains(
                    '? When this test step is undefined\n'),
            }),
        }),
    ]

    with assert_raises(SystemExit):
        runner = Runner(feature_name('undefined_steps'), enable_subunit=True)
        runner.run()

def test_xunit_output_with_one_error():
    'Test xunit output with one errors'
    called = []
    def assert_correct_xml(filename, content):
        called.append(True)
        assert_xsd_valid(filename, content)
        root = etree.fromstring(content)
        assert_equals(root.get("tests"), "2")
        assert_equals(root.get("failures"), "1")
        assert_equals(len(root.getchildren()), 2)

        passed, failed = root.findall("testcase")
        assert_equals(passed.get("name"), "Given my step that passes")
        assert_true(float(passed.get("time")) > 0)
        assert_equals(failed.get("name"), "Given my step that blows a exception")
        assert_true(float(failed.get("time")) > 0)
        assert_true(failed.find("failure") is not None)

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name('error_traceback'), enable_xunit=True)
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_jsonreport_output_with_different_filename():
    'Test jsonreport output with different filename'
    with check_jsonreport('error_traceback', "custom_filename.json"):
        runner = Runner(
            feature_name('error_traceback'), enable_jsonreport=True,
            jsonreport_filename="custom_filename.json"
        )
        runner.run()

def run_check(name, assert_fcn, output_filename):
    runner = Runner(feature_name(name), bunch_output_file=output_filename)
    original_wrt_fcn = bunch_output.write_output
    bunch_output.write_output = assert_fcn
    try:
        runner.run()
    finally:
        bunch_output.write_output = original_wrt_fcn

def test_xunit_does_not_throw_exception_when_missing_step_definition():
    def dummy_write(filename, content):
        pass

    old = xunit_output.wrt_output
    xunit_output.wrt_output = dummy_write
    runner = Runner(feature_name('missing_steps'), enable_xunit=True,
                    xunit_filename="mising_steps.xml")
    runner.run()

    xunit_output.wrt_output = old

def test_xunit_output_with_unicode_characters_in_error_messages():
    called = []
    def assert_correct_xml(filename, content):
        called.append(True)
        assert_xsd_valid(filename, content)

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name('unicode_traceback'), enable_xunit=True,
                    xunit_filename="custom_filename.xml")
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_xunit_output_with_outline():
    'Test xunit output with different filename'
    called = []
    def assert_correct_xml(filename, content):
        called.append(True)
        assert_equals(filename, "custom_filename.xml")

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name('fail_outline'), enable_xunit=True,
        xunit_filename="custom_filename.xml")
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_subunit_output_with_no_errors():
    """
    Test Subunit output with no errors
    """

    state.expect = [
        Includes({
            'id': 'one commented scenario: Do nothing',
            'status': 'success',
            'details': Keys('stdout', 'stderr', 'steps'),
        }),
    ]

    runner = Runner(feature_name('commented_feature'), enable_subunit=True)
    runner.run()

def test_xunit_xml_output_with_no_errors():
    'Test xunit doc xml output'

    called = []

    def assert_correct_xml_output(filename, doc):
        called.append(True)
        expect(doc.toxml).when.called.doesnt.throw(UnicodeDecodeError)

    old = xunit_output.write_xml_doc
    xunit_output.write_xml_doc = assert_correct_xml_output
    runner = Runner(feature_name('xunit_unicode_and_bytestring_mixing'), enable_xunit=True)
    try:
        runner.run()
    finally:
        xunit_output.write_xml_doc = old

def test_xunit_output_with_different_filename():
    "Test xunit output with different filename"
    called = []

    def assert_correct_xml(filename, content):
        called.append(True)
        assert_xsd_valid(filename, content)
        assert_equals(filename, "custom_filename.xml")

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name("error_traceback"), enable_xunit=True, xunit_filename="custom_filename.xml")
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_xunit_output_with_no_errors():
    'Test xunit output with no errors'
    called = []
    def assert_correct_xml(filename, content):
        called.append(True)
        root = etree.fromstring(content)
        assert_equals(root.get("tests"), "1")
        assert_equals(len(root.getchildren()), 1)
        assert_equals(root.find("testcase").get("name"), "Given I do nothing")
        assert_true(float(root.find("testcase").get("time")) > 0)

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name('commented_feature'), enable_xunit=True)
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_subunit_output_with_one_error():
    """
    Test Subunit output with one error
    """

    state.expect = [
        Includes({
            'status': 'success',
            'details': Keys('stdout', 'stderr', 'steps'),
        }),
        Includes({
            'status': 'fail',
            'details': Keys('stdout', 'stderr', 'traceback', 'steps'),
        }),
    ]

    runner = Runner(feature_name('error_traceback'), enable_subunit=True)
    runner.run()

def test_subunit_output_unicode():
    """
    Test Subunit output with unicode traceback
    """

    state.expect = [
        Includes({
            'status': 'success',
        }),
        Includes({
            'status': 'fail',
            'details': Includes({
                'traceback': ContentContains('given_my_daemi_that_blows_a_exception'),
            }),
        }),
    ]

    runner = Runner(feature_name('unicode_traceback'), enable_subunit=True)
    runner.run()

def test_xunit_xml_output_with_mixed_unicode():
    """Test xunit doc xml output"""

    called = []

    def assert_correct_xml_output(filename, doc):
        called.append(True)
        expect(doc.toxml).when.called.doesnt.throw(UnicodeDecodeError)

    old = xunit_output.write_xml_doc
    xunit_output.write_xml_doc = assert_correct_xml_output
    runner = Runner(feature_name('xunit_unicode_and_bytestring_mixing'),
                    enable_xunit=True,
                    verbosity=2)

    with assert_raises(SystemExit):
        runner.run()

    xunit_output.write_xml_doc = old

def test_xunit_output_with_no_steps():
    'Test xunit output with no steps'
    called = []
    def assert_correct_xml(filename, content):
        called.append(True)
        assert_xsd_valid(filename, content)
        root = etree.fromstring(content)
        assert_equals(root.get("tests"), "1")
        assert_equals(root.find("testcase").get("name"), "Given I do nothing")
        assert_equals(len(root.getchildren()), 1)
        assert_equals(root.find("testcase/skipped").get("type"), "UndefinedStep(Given I do nothing)")
        assert_equals(float(root.find("testcase").get("time")), 0)

    old = xunit_output.wrt_output
    xunit_output.wrt_output = assert_correct_xml
    runner = Runner(feature_name('no_steps_defined'), enable_xunit=True)
    runner.run()

    assert_equals(1, len(called), "Function not called")
    xunit_output.wrt_output = old

def test_subunit_output_console():
    """
    Test Subunit output to console
    """

    state.expect = [
        Includes({
            'status': 'success',
            'details': Includes({
                'stdout': ContentContains('Badger'),
            }),
        }),
        Includes({
            'status': 'success',
            'details': Includes({
                'stderr': ContentContains('Mushroom'),
            }),
        }),
    ]

    runner = Runner(feature_name('writes_to_console'), enable_subunit=True)
    runner.run()

def test_jsonreport_output_with_no_steps():
    'Test jsonreport output with no steps'
    with check_jsonreport('missing_steps'):
        runner = Runner(feature_name('missing_steps'), enable_jsonreport=True)
        runner.run()

def test_xunit_does_not_throw_exception_when_missing_step_definition():
    with check_jsonreport('missing_steps'):
        runner = Runner(feature_name('missing_steps'), enable_jsonreport=True)
        runner.run()

def test_jsonreport_output_with_unicode_characters_in_error_messages():
    with check_jsonreport('unicode_traceback'):
        runner = Runner(feature_name('unicode_traceback'), enable_jsonreport=True)
        runner.run()