def _do_test(path, test, failure=True, require_install=False, set_type=0, listed=False, xpi_mode='r'): package_data = open(path, 'rb') package = XPIManager(package_data, mode=xpi_mode, name=path) err = ErrorBundle() if listed: err.save_resource('listed', True) # Populate in the dependencies. if set_type: err.detected_type = set_type # Conduit test requires type if require_install: err.save_resource('has_install_rdf', True) rdf_data = package.read('install.rdf') install_rdf = RDFParser(err, rdf_data) err.save_resource('install_rdf', install_rdf) populate_chrome_manifest(err, package) test(err, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def test_webapp_pass(): """Test that a bland webapp file throws no errors.""" err = ErrorBundle() _detect(err, _get_json()) print err.print_summary(verbose=True) assert not err.failed()
def _run_test_raw(data, failure=True, detected_type=0, listed=True, overrides=None, compat=False): 'Runs a test on an install.rdf snippet' data = data.strip() err = ErrorBundle() err.detected_type = detected_type err.save_resource('listed', listed) err.overrides = overrides if compat: err.save_resource('is_compat_test', True) err.save_resource('has_install_rdf', True) err.save_resource('install_rdf', RDFParser(err, data)) installrdf.test_install_rdf_params(err) print err.print_summary(verbose=True) if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def _do_test(path, test, failure=True, require_install=False, set_type=0, listed=False, xpi_mode="r"): package_data = open(path, "rb") package = XPIManager(package_data, mode=xpi_mode, name=path) err = ErrorBundle() if listed: err.save_resource("listed", True) # Populate in the dependencies. if set_type: err.detected_type = set_type # Conduit test requires type if require_install: err.save_resource("has_install_rdf", True) rdf_data = package.read("install.rdf") install_rdf = RDFParser(err, rdf_data) err.save_resource("install_rdf", install_rdf) populate_chrome_manifest(err, package) test(err, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def test_structure(structure): err = ErrorBundle() err.supported_versions = {} mock_package = MockXPI(structure) content.test_packed_packages(err, mock_package) print err.print_summary(verbose=True) assert err.failed()
def test_blacklisted_files(): """ Tests the validator's ability to hash each individual file and (based on this information) determine whether the addon passes or fails the validation process. """ package_data = open('tests/resources/libraryblacklist/blocked.xpi') package = XPIManager(package_data, mode='r', name='blocked.xpi') err = ErrorBundle() test_content.test_packed_packages(err, package) print err.print_summary() assert err.notices assert not err.failed() eq_( err.metadata.get('identified_files'), { 'test.js': { 'path': 'This file is a false script to facilitate ' 'testing of library blacklisting.' } })
def _do_test(path, test, failure=True, require_install=False, set_type=0): package_data = open(path, "rb") package = XPIManager(package_data, path) contents = package.get_file_data() err = ErrorBundle() # Populate in the dependencies. if set_type: err.set_type(set_type) # Conduit test requires type if require_install: err.save_resource("has_install_rdf", True) rdf_data = package.read("install.rdf") install_rdf = RDFParser(rdf_data) err.save_resource("install_rdf", install_rdf) test(err, contents, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def _run_test_raw(data, failure=True, detected_type=0, listed=True, overrides=None, compat=False): "Runs a test on an install.rdf snippet" data = data.strip() err = ErrorBundle() err.detected_type = detected_type err.save_resource("listed", listed) err.overrides = overrides if compat: err.save_resource("is_compat_test", True) err.save_resource("has_install_rdf", True) err.save_resource("install_rdf", RDFParser(err, data)) installrdf.test_install_rdf_params(err) print err.print_summary(verbose=True) if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def test_webapp_pass(): """Test that a bland webapp file throws no errors.""" err = ErrorBundle() validator.webapp.detect_webapp(err, json.dumps(_get_json())) print err.print_summary(verbose=True) assert not err.failed()
def test_hidden_files(test_input): """Tests that hidden files are reported.""" err = ErrorBundle() err.supported_versions = {} mock_package = MockXPI(test_input) content.test_packed_packages(err, mock_package) print err.print_summary(verbose=True) assert err.failed()
def test_webapp_no_default_locale(): """Test that locales require default_locale.""" err = ErrorBundle() data = _get_json() del data["default_locale"] _detect(err, data) print err.print_summary(verbose=True) assert err.failed()
def test(versions): err = ErrorBundle() err.supported_versions = versions parser = MarkupParser(err) parser.process(name, data, name.split(".")[-1]) print err.print_summary(verbose=True) assert not err.failed() return err
def _do_test_raw(rdf, listed=True, overrides=None): err = ErrorBundle(listed=listed) err.overrides = overrides rdf = RDFParser(err, rdf.strip()) err.save_resource("has_install_rdf", True) err.save_resource("install_rdf", rdf) targetapp.test_targetedapplications(err) print err.print_summary() return err
def test_skip_blacklisted_file(): """Ensure blacklisted files are skipped for processing.""" package_data = open('tests/resources/libraryblacklist/errors.xpi') package = XPIManager(package_data, mode='r', name='errors.xpi') err = ErrorBundle() test_content.test_packed_packages(err, package) print err.print_summary() assert err.notices assert not err.failed()
def test_skip_blacklisted_file(): """Ensure blacklisted files are skipped for processing.""" package_data = open("tests/resources/libraryblacklist/errors.xpi") package = XPIManager(package_data, mode="r", name="errors.xpi") err = ErrorBundle() test_content.test_packed_packages(err, package) print err.print_summary() assert err.notices assert not err.failed()
def test_package_corrupt(): "Tests the test_package function fails with a non-zip" tip = submain.test_inner_package submain.test_inner_package = lambda x, y, z: "success" name = "tests/resources/junk.xpi" err = ErrorBundle(None, True) result = submain.test_package(err, name, name) submain.test_inner_package = tip err.print_summary(True); assert err.failed()
def _do_test(path, should_fail=False): data = open(path).read() err = ErrorBundle() csstester.test_css_file(err, "css.css", data) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_package_corrupt(): "Tests the test_package function fails with a corrupt file" tip = submain.test_inner_package submain.test_inner_package = lambda x, z, for_appversions: "success" name = "tests/resources/corrupt.xpi" err = ErrorBundle() result = submain.test_package(err, name, name) submain.test_inner_package = tip err.print_summary(True); assert err.failed()
def test_package_corrupt(): "Tests the test_package function fails with a corrupt file" tip = submain.test_inner_package submain.test_inner_package = lambda x, z, for_appversions: "success" name = "tests/resources/corrupt.xpi" err = ErrorBundle() result = submain.test_package(err, name, name) submain.test_inner_package = tip err.print_summary(True) assert err.failed()
def test_blacklisted_files(): """Tests the validator's ability to hash each individual file and (based on this information) determine whether the addon passes or fails the validation process.""" package_data = open("tests/resources/libraryblacklist/blocked.xpi") package = XPIManager(package_data, "blocked.xpi") contents = package.get_file_data() err = ErrorBundle() libblacklist.test_library_blacklist(err, contents, package) print err.print_summary() assert err.notices
def test_boring(): """Test that boring output strips out color sequences.""" stdout = sys.stdout sys.stdout = StringIO() # Use the StringIO as an output buffer. bundle = ErrorBundle() bundle.error((), "<<BLUE>><<GREEN>><<YELLOW>>") bundle.print_summary(no_color=True) outbuffer = sys.stdout sys.stdout = stdout outbuffer.seek(0) assert outbuffer.getvalue().count("<<GREEN>>") == 0
def test_boring(): """Test that boring output strips out color sequences.""" stdout = sys.stdout sys.stdout = StringIO() # Use the StringIO as an output buffer. bundle = ErrorBundle() bundle.error((), '<<BLUE>><<GREEN>><<YELLOW>>') bundle.print_summary(no_color=True) outbuffer = sys.stdout sys.stdout = stdout outbuffer.seek(0) assert outbuffer.getvalue().count('<<GREEN>>') == 0
def _do_test(path, should_fail=False, detected_type=None): data = open(path).read() err = ErrorBundle() if detected_type is not None: err.detected_type = detected_type csstester.test_css_file(err, "css.css", data) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def _do_test(path, should_fail=False, detected_type=None): data = open(path).read() err = ErrorBundle() if detected_type is not None: err.detected_type = detected_type csstester.test_css_file(err, 'css.css', data) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_password_in_defaults_prefs(): """ Tests that passwords aren't stored in the defaults/preferences/*.js files for bug 647109. """ password_js = open("tests/resources/content/password.js").read() assert not _do_test_raw(password_js).failed() err = ErrorBundle() err.supported_versions = {} mock_package = MockXPI({"defaults/preferences/foo.js": "tests/resources/content/password.js"}) content.test_packed_packages(err, mock_package) print err.print_summary() assert err.failed()
def test_blacklisted_files(): """ Tests the validator's ability to hash each individual file and (based on this information) determine whether the addon passes or fails the validation process. """ package_data = open("tests/resources/libraryblacklist/blocked.xpi") package = XPIManager(package_data, mode="r", name="blocked.xpi") err = ErrorBundle() test_content.test_packed_packages(err, package) print err.print_summary() assert err.notices assert not err.failed()
def test_hidden_files(): """Tests that hidden files are reported.""" err = ErrorBundle() err.supported_versions = {} mock_package = MockXPI({".hidden": "tests/resources/content/junk.xpi"}) content.test_packed_packages(err, mock_package) print err.print_summary(verbose=True) assert err.failed() err = ErrorBundle() mock_package_mac = MockXPI({"dir/__MACOSX/foo": "tests/resources/content/junk.xpi"}) content.test_packed_packages(err, mock_package_mac) print err.print_summary(verbose=True) assert err.failed()
def test_password_in_defaults_prefs(): """ Tests that passwords aren't stored in the defaults/preferences/*.js files for bug 647109. """ password_js = open("tests/resources/content/password.js").read() assert not _do_test_raw(password_js).failed() err = ErrorBundle() err.supported_versions = {} mock_package = MockXPI( {"defaults/preferences/foo.js": "tests/resources/content/password.js"}) content._process_file(err, mock_package, "defaults/preferences/foo.js", password_js, "foo.js") print err.print_summary() assert err.failed()
def _run_test(filename, failure=True, detected_type=0): "Runs a test on an install.rdf file" err = ErrorBundle() err.detected_type = detected_type data = open(filename).read() parser = RDFParser(data) installrdf._test_rdf(err, parser) print err.print_summary() if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def test_blacklisted_files(): """ Tests the validator's ability to hash each individual file and (based on this information) determine whether the addon passes or fails the validation process. """ package_data = open("tests/resources/libraryblacklist/blocked.xpi") package = XPIManager(package_data, mode="r", name="blocked.xpi") err = ErrorBundle() test_content.test_packed_packages(err, package) print err.print_summary() assert err.notices assert not err.failed() eq_(err.metadata.get("identified_files"), {'test.js': {'path': 'This file is a false script to facilitate ' 'testing of library blacklisting.'}})
def _test_xul_raw(data, path, should_fail=False, type_=None): filename = path.split("/")[-1] extension = filename.split(".")[-1] err = ErrorBundle() err.supported_versions = {} if type_: err.detected_type = type_ parser = markuptester.MarkupParser(err, debug=True) parser.process(filename, data, extension) print err.print_summary(verbose=True) if should_fail: assert err.failed() else: assert not err.failed(fail_on_warnings=False) return err
def _do_simulated_test(function, structure, failure=False, ff4=False): """"Performs a test on a function or set of functions without generating a full package.""" dict_structure = {'__MACOSX/foo.bar': True} for item in structure: dict_structure[item] = True err = ErrorBundle() err.save_resource('ff4', ff4) function(err, structure) err.print_summary(True) if failure: assert err.failed() else: assert not err.failed() return err
def _do_simulated_test(function, structure, failure=False, ff4=False): """"Performs a test on a function or set of functions without generating a full package.""" dict_structure = {"__MACOSX/foo.bar": True} for item in structure: dict_structure[item] = True err = ErrorBundle(None, True) err.save_resource("ff4", ff4) function(err, dict_structure, None) err.print_summary(True) if failure: assert err.failed() else: assert not err.failed() return err
def test_linked_manifest_recursion(): """Test that recursive linked manifests are flagged properly.""" err = ErrorBundle() package = MockXPI({ "chrome.manifest": "tests/resources/submain/linkman/base1.manifest", "submanifest.manifest": "tests/resources/submain/linkman/recurse.manifest"}) submain.populate_chrome_manifest(err, package) chrome = err.get_resource("chrome.manifest") assert chrome print err.print_summary(verbose=True) assert err.failed() assert not err.notices # From the base file: assert list(chrome.get_triples(subject="foo")) # From the linked manifest: assert not list(chrome.get_triples(subject="zap"))
def _run_test_raw(data, failure=True, detected_type=0, listed=True, overrides=None): "Runs a test on an install.rdf snippet" data = data.strip() err = ErrorBundle() err.detected_type = detected_type err.save_resource("listed", listed) err.overrides = overrides parser = RDFParser(data) installrdf._test_rdf(err, parser) print err.print_summary(verbose=True) if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def test_linked_manifest_recursion(): """Test that recursive linked manifests are flagged properly.""" err = ErrorBundle() package = MockXPI({ 'chrome.manifest': 'tests/resources/submain/linkman/base1.manifest', 'submanifest.manifest': 'tests/resources/submain/linkman/recurse.manifest'}) submain.populate_chrome_manifest(err, package) chrome = err.get_resource('chrome.manifest') assert chrome print err.print_summary(verbose=True) assert err.failed() assert not err.notices # From the base file: assert list(chrome.get_triples(subject='foo')) # From the linked manifest: assert not list(chrome.get_triples(subject='zap'))
def test_notice_friendly(): """Tests notice-related human-friendly text output functions of the error bundler.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() bundle.notice((), "foobar") # Load the JSON output as an object. output = bundle.print_summary(verbose=True, no_color=True) print output assert output.count("foobar")
def _do_test(path, test, failure=True, require_install=False, set_type=0, listed=False, xpi_mode='r'): package_data = open(path, 'rb') package = XPIManager(package_data, mode=xpi_mode, name=path) err = ErrorBundle() if listed: err.save_resource('listed', True) # Populate in the dependencies. if set_type: err.detected_type = set_type # Conduit test requires type if require_install: if 'install.rdf' in package: err.save_resource('has_install_rdf', True) rdf_data = package.read('install.rdf') install_rdf = RDFParser(err, rdf_data) err.save_resource('install_rdf', install_rdf) elif 'manifest.json' in package: err.save_resource('has_manifest_json', True) manifest_data = package.read('manifest.json') manifest_json = ManifestJsonParser(err, manifest_data) err.save_resource('install_rdf', manifest_json) populate_chrome_manifest(err, package) test(err, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def _do_test(path, should_fail=False, type_=None): markup_file = open(path) data = markup_file.read() markup_file.close() filename = path.split("/")[-1] extension = filename.split(".")[-1] err = ErrorBundle(None, True) if type_: err.set_type(type_) parser = markuptester.MarkupParser(err, True) parser.process(filename, data, extension) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_linked_manifest_recursion(): """Test that recursive linked manifests are flagged properly.""" err = ErrorBundle() package = MockXPI({ 'chrome.manifest': 'tests/resources/submain/linkman/base1.manifest', 'submanifest.manifest': 'tests/resources/submain/linkman/recurse.manifest' }) submain.populate_chrome_manifest(err, package) chrome = err.get_resource('chrome.manifest') assert chrome print err.print_summary(verbose=True) assert not err.failed() assert not err.notices # From the base file: assert list(chrome.get_entries('foo')) # From the linked manifest: assert not list(chrome.get_entries('zap'))
def test_linked_manifest_recursion(): """Test that recursive linked manifests are flagged properly.""" err = ErrorBundle() package = MockXPI( { "chrome.manifest": "tests/resources/submain/linkman/base1.manifest", "submanifest.manifest": "tests/resources/submain/linkman/recurse.manifest", } ) submain.populate_chrome_manifest(err, package) chrome = err.get_resource("chrome.manifest") assert chrome print err.print_summary(verbose=True) assert not err.failed() assert not err.notices # From the base file: assert list(chrome.get_entries("foo")) # From the linked manifest: assert not list(chrome.get_entries("zap"))
def test_notice_friendly(): """ Test notice-related human-friendly text output functions of the error bundler. """ # Use the StringIO as an output buffer. bundle = ErrorBundle() bundle.notice((), 'foobar') # Load the JSON output as an object. output = bundle.print_summary(verbose=True, no_color=True) print output assert output.count('foobar')
def test_file_structure(): """ Test the means by which file names and line numbers are stored in errors, warnings, and messages. """ # Use the StringIO as an output buffer. bundle = ErrorBundle(True) # No color since no output # Populate the bundle with some test data. bundle.error((), "error", description="", filename="file1", column=123) bundle.error((), "error", description="", filename="file2") bundle.error((), "error") # Push a state bundle.push_state("foo") bundle.warning((), "warning", description="", filename="file4", column=123) bundle.warning((), "warning", description="", filename="file5") bundle.warning((), "warning") bundle.pop_state() # Load the JSON output as an object. output = json.loads(bundle.render_json()) # Do the same for friendly output output2 = bundle.print_summary(verbose=False) # Do the same for verbose friendly output output3 = bundle.print_summary(verbose=True) # Run some basic tests assert len(output["messages"]) == 6 assert len(output2) < len(output3) print output print "*" * 50 print output2 print "*" * 50 print output3 print "*" * 50 messages = [ "file1", "file2", "", ["foo", "file4"], ["foo", "file5"], ["foo", ""] ] for message in output["messages"]: print message assert message["file"] in messages messages.remove(message["file"]) if isinstance(message["file"], list): pattern = message["file"][:] pattern.pop() pattern.append("") file_merge = " > ".join(pattern) print file_merge assert output3.count(file_merge) else: assert output3.count(message["file"]) assert not messages
class TestCase(object): def setUp(self): self.err = None self.is_jetpack = False self.is_bootstrapped = False self.detected_type = None self.listed = True def reset(self): """ Reset the test case so that it can be run a second time (ideally with different parameters). """ self.err = None def setup_err(self, for_appversions=None): """ Instantiate the error bundle object. Use the `instant` parameter to have it output errors as they're generated. `for_appversions` may be set to target the test cases at a specific Gecko version range. An existing error bundle will be overwritten with a fresh one that has the state that the test case was setup with. """ self.err = ErrorBundle(instant=True, for_appversions=for_appversions or {}, listed=self.listed) self.err.handler = OutputHandler(sys.stdout, True) if self.is_jetpack: self.err.metadata["is_jetpack"] = True if self.is_bootstrapped: self.err.save_resource("em:bootstrap", True) if self.detected_type is not None: self.err.detected_Type = self.detected_type def assert_failed(self, with_errors=False, with_warnings=None): """First, asserts that the error bundle registers a failure (recognizing whether warnings are acknowledged). Second, if `with_errors`is True, the presence of errors is asserted. If it is not true (default), it is tested that errors are not present. If `with_warnings` is not None, the presence of warnings is tested just like `with_errors`. """ assert self.err.failed( fail_on_warnings=with_warnings or with_warnings is None), \ "Test did not fail; failure was expected." if with_errors: assert self.err.errors, "Errors were expected." elif self.err.errors: raise AssertionError("Tests found unexpected errors: %s" % self.err.print_summary(verbose=True)) if with_warnings is not None: if with_warnings: assert self.err.warnings, "Warnings were expected." elif self.err.warnings: raise ("Tests found unexpected warnings: %s" % self.err.print_summary()) def assert_notices(self): """Assert that notices have been generated during the validation process. """ assert self.err.notices, "Notices were expected." def assert_passes(self, warnings_pass=False): """Assert that no errors have been raised. If `warnings_pass` is True, also assert that there are no warnings. """ assert not self.failed(fail_on_warnings=not warnings_pass), \ ("Test was intended to pass%s, but it did not." % (" with warnings" if warnings_pass else "")) def assert_silent(self): """ Assert that no messages (errors, warnings, or notices) have been raised. """ assert not self.err.errors, 'Got these: %s' % self.err.errors assert not self.err.warnings, 'Got these: %s' % self.err.warnings assert not self.err.notices, 'Got these: %s' % self.err.notices assert not any(self.err.compat_summary.values()), \ "Found compatibility messages." def assert_got_errid(self, errid): """ Assert that a message with the given errid has been generated during the validation process. """ assert any(msg["id"] == errid for msg in (self.err.errors + self.err.warnings + self.err.notices)), \ "%s was expected, but it was not found." % repr(errid)
class TestCase(object): def setUp(self): self.err = None self.is_jetpack = False self.is_bootstrapped = False self.detected_type = None self.listed = True def reset(self): """ Reset the test case so that it can be run a second time (ideally with different parameters). """ self.err = None def setup_err(self, for_appversions=None): """ Instantiate the error bundle object. Use the `instant` parameter to have it output errors as they're generated. `for_appversions` may be set to target the test cases at a specific Gecko version range. An existing error bundle will be overwritten with a fresh one that has the state that the test case was setup with. """ self.err = ErrorBundle(instant=True, for_appversions=for_appversions or {}, listed=self.listed) self.err.handler = OutputHandler(sys.stdout, True) if self.is_jetpack: self.err.metadata['is_jetpack'] = True if self.is_bootstrapped: self.err.save_resource('em:bootstrap', True) if self.detected_type is not None: self.err.detected_Type = self.detected_type def assert_failed(self, with_errors=False, with_warnings=None): """ Asserts that the error bundle has registered a failure. If `with_warnings` is any true value, or `None`, a warning is considered a failure. `with_warnings` or `with_errors` may be any of the following: * True: Messages of this type must be present. * False: Messages of this type must not be present. * None: Messages of this type may or may not be present. * Iterable of dicts: For dict returned by the iterator, at least one message must have a matching item for every key/value pair in the dict. """ assert self.err.failed( fail_on_warnings=with_warnings or with_warnings is None), \ 'Test did not fail; failure was expected.' def find_message(messages, props): # Returns true if any message in messages has all of the # key/value pairs in props. return any( set(props.iteritems()) <= set(message.iteritems()) for message in messages) def test_messages(mtype, expected): messages = getattr(self.err, mtype) if isinstance(expected, collections.Iterable): assert all(find_message(messages, props) for props in expected) elif expected: assert messages, 'Expected %s.' % mtype elif expected is not None: assert not messages, ('Tests found unexpected %s: %s' % mtype, self.err.print_summary(verbose=True)) test_messages('errors', with_errors) test_messages('warnings', with_warnings) def assert_notices(self): """Assert that notices have been generated during the validation process. """ assert self.err.notices, 'Notices were expected.' def assert_passes(self, warnings_pass=False): """Assert that no errors have been raised. If `warnings_pass` is True, also assert that there are no warnings. """ assert not self.failed(fail_on_warnings=not warnings_pass), \ ('Test was intended to pass%s, but it did not.' % (' with warnings' if warnings_pass else '')) def assert_silent(self): """ Assert that no messages (errors, warnings, or notices) have been raised. """ assert not self.err.errors, 'Got these: %s' % self.err.errors assert not self.err.warnings, 'Got these: %s' % self.err.warnings assert not self.err.notices, 'Got these: %s' % self.err.notices assert not any(self.err.compat_summary.values()), \ 'Found compatibility messages.' def assert_got_errid(self, errid): """ Assert that a message with the given errid has been generated during the validation process. """ assert any(msg['id'] == errid for msg in (self.err.errors + self.err.warnings + self.err.notices)), \ '%s was expected, but it was not found.' % repr(errid)
def test_file_structure(): """ Test the means by which file names and line numbers are stored in errors, warnings, and messages. """ # Use the StringIO as an output buffer. bundle = ErrorBundle(True) # No color since no output # Populate the bundle with some test data. bundle.error((), 'error', description='', filename='file1', column=123) bundle.error((), 'error', description='', filename='file2') bundle.error((), 'error') # Push a state bundle.push_state('foo') bundle.warning((), 'warning', description='', filename='file4', column=123) bundle.warning((), 'warning', description='', filename='file5') bundle.warning((), 'warning') bundle.pop_state() # Load the JSON output as an object. output = json.loads(bundle.render_json()) # Do the same for friendly output output2 = bundle.print_summary(verbose=False) # Do the same for verbose friendly output output3 = bundle.print_summary(verbose=True) # Run some basic tests assert len(output['messages']) == 6 assert len(output2) < len(output3) print output print '*' * 50 print output2 print '*' * 50 print output3 print '*' * 50 messages = [ 'file1', 'file2', '', ['foo', 'file4'], ['foo', 'file5'], ['foo', ''] ] for message in output['messages']: print message assert message['file'] in messages messages.remove(message['file']) if isinstance(message['file'], list): pattern = message['file'][:] pattern.pop() pattern.append('') file_merge = ' > '.join(pattern) print file_merge assert output3.count(file_merge) else: assert output3.count(message['file']) assert not messages