def test_generate_static_docs(self): # make sure we start clean if os.path.exists(get_base_url_path()): shutil.rmtree(get_base_url_path()) # generate a doc tarball, and extract it base_url = get_base_url() tar_filename = generate.generate_static_docs(env_root) tgz = tarfile.open(tar_filename) tgz.extractall(get_sdk_docs_root()) broken_links = [] # get each HTML file... for root, subFolders, filenames in os.walk(get_sdk_docs_root()): for filename in filenames: if not filename.endswith(".html"): continue if root.endswith("static-files"): continue filename = os.path.join(root, filename) # ...and feed it to the link checker linkChecker = Link_Checker(self, filename, base_url) linkChecker.feed(open(filename, "r").read()) broken_links.extend(linkChecker.errors) if broken_links: print print "The following links are broken:" for broken_link in sorted(broken_links): print " "+ broken_link self.fail("%d links are broken" % len(broken_links)) # clean up shutil.rmtree(get_base_url_path()) tgz.close() os.remove(tar_filename) generate.clean_generated_docs(os.path.join(env_root, "doc"))
def test_generate_static_docs_does_not_smoke(self): filename = 'testdocs.tgz' if os.path.exists(filename): os.remove(filename) filename = generate.generate_static_docs(env_root) self.assertTrue(os.path.exists(filename)) os.remove(filename)
def test_generate_static_docs(self): # make sure we start clean if os.path.exists(get_base_url_path()): shutil.rmtree(get_base_url_path()) # generate a doc tarball, and extract it base_url = get_base_url() tar_filename = generate.generate_static_docs(env_root) tgz = tarfile.open(tar_filename) tgz.extractall(get_sdk_docs_root()) broken_links = [] # get each HTML file... for root, subFolders, filenames in os.walk(get_sdk_docs_root()): for filename in filenames: if not filename.endswith(".html"): continue if root.endswith("static-files"): continue filename = os.path.join(root, filename) # ...and feed it to the link checker linkChecker = Link_Checker(self, filename, base_url) linkChecker.feed(open(filename, "r").read()) broken_links.extend(linkChecker.errors) if broken_links: print print "The following links are broken:" for broken_link in sorted(broken_links): print " " + broken_link self.fail("%d links are broken" % len(broken_links)) # clean up shutil.rmtree(get_base_url_path()) tgz.close() os.remove(tar_filename) generate.clean_generated_docs(os.path.join(env_root, "doc"))
def test_generate_static_docs_does_not_smoke(self): filename = 'testdocs.tgz' if os.path.exists(filename): os.remove(filename) filename = generate.generate_static_docs(env_root) self.assertTrue(os.path.exists(filename)) os.remove(filename)
def test_generate_static_docs(self): # make sure we start clean if os.path.exists(get_base_url_path()): shutil.rmtree(get_base_url_path()) # generate a doc tarball, and extract it base_url = get_base_url() tar_filename = generate.generate_static_docs(env_root, base_url) tgz = tarfile.open(tar_filename) tgz.extractall(get_sdk_docs_root()) # get each HTML file... for root, subFolders, filenames in os.walk(get_sdk_docs_root()): for filename in filenames: if not filename.endswith(".html"): continue filename = os.path.join(root, filename) # ...and feed it to the link checker linkChecker = Link_Checker(self, filename, base_url) linkChecker.feed(open(filename, "r").read()) # clean up shutil.rmtree(get_base_url_path()) tgz.close() os.remove(tar_filename) generate.clean_generated_docs(os.path.join(env_root, "doc"))
def run(arguments=sys.argv[1:], target_cfg=None, pkg_cfg=None, defaults=None, env_root=os.environ.get('CUDDLEFISH_ROOT'), stdout=sys.stdout): versions = get_versions() sdk_version = versions["version"] display_version = "Add-on SDK %s (%s)" % (sdk_version, versions["full"]) parser_kwargs = dict(arguments=arguments, global_options=global_options, parser_groups=parser_groups, usage=usage, version=display_version, defaults=defaults) (options, args) = parse_args(**parser_kwargs) config_args = get_config_args(options.config, env_root); # reparse configs with arguments from local.json if config_args: parser_kwargs['arguments'] += config_args (options, args) = parse_args(**parser_kwargs) command = args[0] if command == "init": initializer(env_root, args) return if command == "testpkgs": test_all_packages(env_root, defaults=options.__dict__) return elif command == "testex": test_all_examples(env_root, defaults=options.__dict__) return elif command == "testall": test_all(env_root, defaults=options.__dict__) return elif command == "testcfx": test_cfx(env_root, options.verbose) return elif command == "docs": from cuddlefish.docs import generate if len(args) > 1: docs_home = generate.generate_named_file(env_root, filename=args[1]) else: docs_home = generate.generate_local_docs(env_root) webbrowser.open(docs_home) return elif command == "sdocs": from cuddlefish.docs import generate filename = generate.generate_static_docs(env_root) print >>stdout, "Wrote %s." % filename return target_cfg_json = None if not target_cfg: if not options.pkgdir: options.pkgdir = find_parent_package(os.getcwd()) if not options.pkgdir: print >>sys.stderr, ("cannot find 'package.json' in the" " current directory or any parent.") sys.exit(1) else: options.pkgdir = os.path.abspath(options.pkgdir) if not os.path.exists(os.path.join(options.pkgdir, 'package.json')): print >>sys.stderr, ("cannot find 'package.json' in" " %s." % options.pkgdir) sys.exit(1) target_cfg_json = os.path.join(options.pkgdir, 'package.json') target_cfg = packaging.get_config_in_dir(options.pkgdir) # At this point, we're either building an XPI or running Jetpack code in # a Mozilla application (which includes running tests). use_main = False inherited_options = ['verbose', 'enable_e10s'] enforce_timeouts = False if command == "xpi": use_main = True elif command == "test": if 'tests' not in target_cfg: target_cfg['tests'] = [] inherited_options.extend(['iterations', 'filter', 'profileMemory', 'stopOnError']) enforce_timeouts = True elif command == "run": use_main = True else: print >>sys.stderr, "Unknown command: %s" % command print >>sys.stderr, "Try using '--help' for assistance." sys.exit(1) if use_main and 'main' not in target_cfg: # If the user supplies a template dir, then the main # program may be contained in the template. if not options.templatedir: print >>sys.stderr, "package.json does not have a 'main' entry." sys.exit(1) if not pkg_cfg: pkg_cfg = packaging.build_config(env_root, target_cfg, options.packagepath) target = target_cfg.name # TODO: Consider keeping a cache of dynamic UUIDs, based # on absolute filesystem pathname, in the root directory # or something. if command in ('xpi', 'run'): from cuddlefish.preflight import preflight_config if target_cfg_json: config_was_ok, modified = preflight_config(target_cfg, target_cfg_json) if not config_was_ok: if modified: # we need to re-read package.json . The safest approach # is to re-run the "cfx xpi"/"cfx run" command. print >>sys.stderr, ("package.json modified: please re-run" " 'cfx %s'" % command) else: print >>sys.stderr, ("package.json needs modification:" " please update it and then re-run" " 'cfx %s'" % command) sys.exit(1) # if we make it this far, we have a JID else: assert command == "test" jid = buildJID(target_cfg) targets = [target] if command == "test": targets.append(options.test_runner_pkg) extra_packages = [] if options.extra_packages: extra_packages = options.extra_packages.split(",") if extra_packages: targets.extend(extra_packages) target_cfg.extra_dependencies = extra_packages deps = packaging.get_deps_for_targets(pkg_cfg, targets) from cuddlefish.manifest import build_manifest, ModuleNotFoundError # Figure out what loader files should be scanned. This is normally # computed inside packaging.generate_build_for_target(), by the first # dependent package that defines a "loader" property in its package.json. # This property is interpreted as a filename relative to the top of that # file, and stored as a path in build.loader . generate_build_for_target() # cannot be called yet (it needs the list of used_deps that # build_manifest() computes, but build_manifest() needs the list of # loader files that it computes). We could duplicate or factor out this # build.loader logic, but that would be messy, so instead we hard-code # the choice of loader for manifest-generation purposes. In practice, # this means that alternative loaders probably won't work with # --strip-xpi. assert packaging.DEFAULT_LOADER == "api-utils" assert pkg_cfg.packages["api-utils"].loader == "lib/cuddlefish.js" cuddlefish_js_path = os.path.join(pkg_cfg.packages["api-utils"].root_dir, "lib", "cuddlefish.js") loader_modules = [("api-utils", "lib", "cuddlefish", cuddlefish_js_path)] scan_tests = command == "test" test_filter_re = None if scan_tests and options.filter: test_filter_re = options.filter if ":" in options.filter: test_filter_re = options.filter.split(":")[0] try: manifest = build_manifest(target_cfg, pkg_cfg, deps, scan_tests, test_filter_re, loader_modules) except ModuleNotFoundError, e: print str(e) sys.exit(1)
def run(arguments=sys.argv[1:], target_cfg=None, pkg_cfg=None, defaults=None, env_root=os.environ.get('CUDDLEFISH_ROOT'), stdout=sys.stdout): versions = get_versions() sdk_version = versions["version"] display_version = "Add-on SDK %s (%s)" % (sdk_version, versions["full"]) parser_kwargs = dict(arguments=arguments, global_options=global_options, parser_groups=parser_groups, usage=usage, version=display_version, defaults=defaults) (options, args) = parse_args(**parser_kwargs) config_args = get_config_args(options.config, env_root) # reparse configs with arguments from local.json if config_args: parser_kwargs['arguments'] += config_args (options, args) = parse_args(**parser_kwargs) command = args[0] if command == "init": initializer(env_root, args) return if command == "testpkgs": test_all_packages(env_root, defaults=options.__dict__) return elif command == "testaddons": test_all_testaddons(env_root, defaults=options.__dict__) return elif command == "testex": test_all_examples(env_root, defaults=options.__dict__) return elif command == "testall": test_all(env_root, defaults=options.__dict__) return elif command == "testcfx": if options.filter: print >> sys.stderr, "The filter option is not valid with the testcfx command" return test_cfx(env_root, options.verbose) return elif command == "docs": from cuddlefish.docs import generate if len(args) > 1: docs_home = generate.generate_named_file(env_root, filename=args[1]) else: docs_home = generate.generate_local_docs(env_root) webbrowser.open(docs_home) return elif command == "sdocs": from cuddlefish.docs import generate filename = generate.generate_static_docs(env_root) print >> stdout, "Wrote %s." % filename return elif command not in ["xpi", "test", "run"]: print >> sys.stderr, "Unknown command: %s" % command print >> sys.stderr, "Try using '--help' for assistance." sys.exit(1) target_cfg_json = None if not target_cfg: if not options.pkgdir: options.pkgdir = find_parent_package(os.getcwd()) if not options.pkgdir: print >> sys.stderr, ("cannot find 'package.json' in the" " current directory or any parent.") sys.exit(1) else: options.pkgdir = os.path.abspath(options.pkgdir) if not os.path.exists(os.path.join(options.pkgdir, 'package.json')): print >> sys.stderr, ("cannot find 'package.json' in" " %s." % options.pkgdir) sys.exit(1) target_cfg_json = os.path.join(options.pkgdir, 'package.json') target_cfg = packaging.get_config_in_dir(options.pkgdir) # At this point, we're either building an XPI or running Jetpack code in # a Mozilla application (which includes running tests). use_main = False inherited_options = ['verbose', 'enable_e10s'] enforce_timeouts = False if command == "xpi": use_main = True elif command == "test": if 'tests' not in target_cfg: target_cfg['tests'] = [] inherited_options.extend( ['iterations', 'filter', 'profileMemory', 'stopOnError']) enforce_timeouts = True elif command == "run": use_main = True else: assert 0, "shouldn't get here" if use_main and 'main' not in target_cfg: # If the user supplies a template dir, then the main # program may be contained in the template. if not options.templatedir: print >> sys.stderr, "package.json does not have a 'main' entry." sys.exit(1) if not pkg_cfg: pkg_cfg = packaging.build_config(env_root, target_cfg, options.packagepath) target = target_cfg.name # TODO: Consider keeping a cache of dynamic UUIDs, based # on absolute filesystem pathname, in the root directory # or something. if command in ('xpi', 'run'): from cuddlefish.preflight import preflight_config if target_cfg_json: config_was_ok, modified = preflight_config(target_cfg, target_cfg_json) if not config_was_ok: if modified: # we need to re-read package.json . The safest approach # is to re-run the "cfx xpi"/"cfx run" command. print >> sys.stderr, ( "package.json modified: please re-run" " 'cfx %s'" % command) else: print >> sys.stderr, ("package.json needs modification:" " please update it and then re-run" " 'cfx %s'" % command) sys.exit(1) # if we make it this far, we have a JID else: assert command == "test" jid = buildJID(target_cfg) targets = [target] if command == "test": targets.append(options.test_runner_pkg) extra_packages = [] if options.extra_packages: extra_packages = options.extra_packages.split(",") if extra_packages: targets.extend(extra_packages) target_cfg.extra_dependencies = extra_packages deps = packaging.get_deps_for_targets(pkg_cfg, targets) from cuddlefish.manifest import build_manifest, ModuleNotFoundError, \ BadChromeMarkerError # Figure out what loader files should be scanned. This is normally # computed inside packaging.generate_build_for_target(), by the first # dependent package that defines a "loader" property in its package.json. # This property is interpreted as a filename relative to the top of that # file, and stored as a path in build.loader . generate_build_for_target() # cannot be called yet (it needs the list of used_deps that # build_manifest() computes, but build_manifest() needs the list of # loader files that it computes). We could duplicate or factor out this # build.loader logic, but that would be messy, so instead we hard-code # the choice of loader for manifest-generation purposes. In practice, # this means that alternative loaders probably won't work with # --strip-xpi. assert packaging.DEFAULT_LOADER == "api-utils" assert pkg_cfg.packages["api-utils"].loader == "lib/cuddlefish.js" cuddlefish_js_path = os.path.join(pkg_cfg.packages["api-utils"].root_dir, "lib", "cuddlefish.js") loader_modules = [("api-utils", "lib", "cuddlefish", cuddlefish_js_path)] scan_tests = command == "test" test_filter_re = None if scan_tests and options.filter: test_filter_re = options.filter if ":" in options.filter: test_filter_re = options.filter.split(":")[0] try: manifest = build_manifest(target_cfg, pkg_cfg, deps, scan_tests, test_filter_re, loader_modules) except ModuleNotFoundError, e: print str(e) sys.exit(1)
def run(arguments=sys.argv[1:], target_cfg=None, pkg_cfg=None, defaults=None, env_root=os.environ.get('CUDDLEFISH_ROOT'), stdout=sys.stdout): parser_kwargs = dict(arguments=arguments, global_options=global_options, parser_groups=parser_groups, usage=usage, defaults=defaults) (options, args) = parse_args(**parser_kwargs) config_args = get_config_args(options.config, env_root); # reparse configs with arguments from local.json if config_args: parser_kwargs['arguments'] += config_args (options, args) = parse_args(**parser_kwargs) command = args[0] if command == "init": initializer(env_root, args) return if command == "testpkgs": test_all_packages(env_root, defaults=options.__dict__) return elif command == "testex": test_all_examples(env_root, defaults=options.__dict__) return elif command == "testall": test_all(env_root, defaults=options.__dict__) return elif command == "testcfx": test_cfx(env_root, options.verbose) return elif command == "docs": from cuddlefish.docs import generate if len(args) > 1: docs_home = generate.generate_docs(env_root, filename=args[1]) else: docs_home = generate.generate_docs(env_root) webbrowser.open(docs_home) return elif command == "sdocs": from cuddlefish.docs import generate # TODO: Allow user to change this filename via cmd line. filename = generate.generate_static_docs(env_root, base_url=options.baseurl) print >>stdout, "Wrote %s." % filename return target_cfg_json = None if not target_cfg: if not options.pkgdir: options.pkgdir = find_parent_package(os.getcwd()) if not options.pkgdir: print >>sys.stderr, ("cannot find 'package.json' in the" " current directory or any parent.") sys.exit(1) else: options.pkgdir = os.path.abspath(options.pkgdir) if not os.path.exists(os.path.join(options.pkgdir, 'package.json')): print >>sys.stderr, ("cannot find 'package.json' in" " %s." % options.pkgdir) sys.exit(1) target_cfg_json = os.path.join(options.pkgdir, 'package.json') target_cfg = packaging.get_config_in_dir(options.pkgdir) # At this point, we're either building an XPI or running Jetpack code in # a Mozilla application (which includes running tests). use_main = False inherited_options = ['verbose', 'enable_e10s'] enforce_timeouts = False if command == "xpi": use_main = True elif command == "test": if 'tests' not in target_cfg: target_cfg['tests'] = [] inherited_options.extend(['iterations', 'filter', 'profileMemory']) enforce_timeouts = True elif command == "run": use_main = True else: print >>sys.stderr, "Unknown command: %s" % command print >>sys.stderr, "Try using '--help' for assistance." sys.exit(1) if use_main and 'main' not in target_cfg: # If the user supplies a template dir, then the main # program may be contained in the template. if not options.templatedir: print >>sys.stderr, "package.json does not have a 'main' entry." sys.exit(1) if not pkg_cfg: pkg_cfg = packaging.build_config(env_root, target_cfg, options.packagepath) target = target_cfg.name # the harness_guid is used for an XPCOM class ID. We use the # JetpackID for the add-on ID and the XPCOM contract ID. if "harnessClassID" in target_cfg: # For the sake of non-bootstrapped extensions, we allow to specify the # classID of harness' XPCOM component in package.json. This makes it # possible to register the component using a static chrome.manifest file harness_guid = target_cfg["harnessClassID"] else: import uuid harness_guid = str(uuid.uuid4()) # TODO: Consider keeping a cache of dynamic UUIDs, based # on absolute filesystem pathname, in the root directory # or something. if command in ('xpi', 'run'): from cuddlefish.preflight import preflight_config if target_cfg_json: config_was_ok, modified = preflight_config(target_cfg, target_cfg_json) if not config_was_ok: if modified: # we need to re-read package.json . The safest approach # is to re-run the "cfx xpi"/"cfx run" command. print >>sys.stderr, ("package.json modified: please re-run" " 'cfx %s'" % command) else: print >>sys.stderr, ("package.json needs modification:" " please update it and then re-run" " 'cfx %s'" % command) sys.exit(1) # if we make it this far, we have a JID else: assert command == "test" if "id" in target_cfg: jid = target_cfg["id"] else: jid = harness_guid if not ("@" in jid or jid.startswith("{")): jid = jid + "@jetpack" unique_prefix = '%s-' % jid # used for resource: URLs bundle_id = jid # the resource: URL's prefix is treated too much like a DNS hostname unique_prefix = unique_prefix.lower() unique_prefix = unique_prefix.replace("@", "-at-") unique_prefix = unique_prefix.replace(".", "-dot-") targets = [target] if command == "test": targets.append(options.test_runner_pkg) extra_packages = [] if options.extra_packages: extra_packages = options.extra_packages.split(",") if extra_packages: targets.extend(extra_packages) target_cfg.extra_dependencies = extra_packages deps = packaging.get_deps_for_targets(pkg_cfg, targets) from cuddlefish.manifest import build_manifest, ModuleNotFoundError uri_prefix = "resource://%s" % unique_prefix # Figure out what loader files should be scanned. This is normally # computed inside packaging.generate_build_for_target(), by the first # dependent package that defines a "loader" property in its package.json. # This property is interpreted as a filename relative to the top of that # file, and stored as a URI in build.loader . generate_build_for_target() # cannot be called yet (it needs the list of used_deps that # build_manifest() computes, but build_manifest() needs the list of # loader files that it computes). We could duplicate or factor out this # build.loader logic, but that would be messy, so instead we hard-code # the choice of loader for manifest-generation purposes. In practice, # this means that alternative loaders probably won't work with # --strip-xpi. assert packaging.DEFAULT_LOADER == "api-utils" assert pkg_cfg.packages["api-utils"].loader == "lib/cuddlefish.js" cuddlefish_js_path = os.path.join(pkg_cfg.packages["api-utils"].root_dir, "lib", "cuddlefish.js") loader_modules = [("api-utils", "lib", "cuddlefish", cuddlefish_js_path)] scan_tests = command == "test" try: manifest = build_manifest(target_cfg, pkg_cfg, deps, uri_prefix, scan_tests, loader_modules) except ModuleNotFoundError, e: print str(e) sys.exit(1)