def test_encryption(self):
        self.task_schema = Schema({
            'task': {
                'payload': {
                    'encryptedEnv': All(Length(2), [Match(r'^wcB')])  # Must have 2 elements, starting with wcB
                }
            }
        }, required=True, extra=True)

        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'repo_path': 'foo/bar',
            'branch': 'mozilla-beta',
            'signing_class': 'dep-signing',
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'signing_pvt_key': PVT_KEY_FILE,
            'accepted_mar_channel_id': 'firefox-mozilla-beta',
            'signing_cert': 'dep',
            'moz_disable_mar_cert_verification': True,
            'en_US_config': {
                "platforms": {
                    "macosx64": {"unsigned_task_id": "xyz", "signed_task_id": "xyz"},
                    "win32": {"unsigned_task_id": "xyz", "signed_task_id": "xyz"},
                }
            },
        })

        graph = make_task_graph(**test_kwargs)
        do_common_assertions(graph)
        for p in ("win32", "macosx64"):
            for v in ("38.0build1", "37.0build2"):
                balrog = get_task_by_name(graph, "{}_en-US_{}_funsize_balrog_task".format(p, v))
                verify(balrog, self.task_schema)

    def test_partials_present(self):
        for pl in ["win32", "linux64"]:
            for part in ["37.0", "38.0"]:
                task_name = "release-mozilla-beta_firefox_{pl}_l10n_repack_1_{part}_update_generator".format(pl=pl, part=part)
                partial_task = get_task_by_name(self.graph, task_name)

                verify(partial_task, Schema(dict))  # The task must exist as a dict (ie not None)

def do_common_assertions(graph):
    _cached_taskIDs = set()
    if graph['tasks']:
        for t in graph['tasks']:
            assert t['taskId'] not in _cached_taskIDs
            verify(t, COMMON_TASK_SCHEMA)

            _cached_taskIDs.add(t['taskId'])

    def test_multichannel(self):
        for chan in ["beta", "release"]:
            multichan_schema = Schema({
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'VERIFY_CONFIG': "{chan}-firefox-win32.cfg".format(chan=chan),
                        }
                    }
                }
            }, extra=True, required=True)

            multichan_task = get_task_by_name(self.graph, "release-beta_firefox_win32_update_verify_{chan}_3".format(chan=chan))
            verify(multichan_task, multichan_schema, TestBB_UpdateVerifyMultiChannel.not_allowed)

    def test_funsize_name(self):
        for platform in ("win32", "linux64",):
            for version in ("37.0", "38.0",):
                for chunk in ('1', '2',):
                    generator_schema = Schema({
                        'task': {'metadata': {
                            'name': "[funsize] Update generating task %s chunk %s for %s" % (platform, chunk, version,)}}
                    }, extra=True, required=True)
                    signing_schema = Schema({
                        'task': {'metadata': {
                            'name': "[funsize] MAR signing task %s chunk %s for %s" % (platform, chunk, version,)}}
                    }, extra=True, required=True)
                    balrog_schema = Schema({
                        'task': {'metadata': {
                            'name': "[funsize] Publish to Balrog %s chunk %s for %s" % (platform, chunk, version,)}}
                    }, extra=True, required=True)
                    generator = get_task_by_name(self.graph,
                                                 "release-mozilla-beta_firefox_{pl}_l10n_repack_{c}_{part}_update_generator".format(
                                                     pl=platform, part=version, c=chunk))
                    signing = get_task_by_name(self.graph,
                                               "release-mozilla-beta_firefox_{pl}_l10n_repack_{c}_{part}_signing_task".format(
                                                   pl=platform, part=version, c=chunk))
                    balrog = get_task_by_name(self.graph,
                                              "release-mozilla-beta_firefox_{pl}_l10n_repack_{c}_{part}_balrog_task".format(
                                                  pl=platform, part=version, c=chunk))

                    verify(generator, generator_schema)
                    verify(signing, signing_schema)
                    verify(balrog, balrog_schema)

 def test_all_builders_exist(self):
     for p in ['win32', 'win64', 'macosx64']:
         for i in xrange(1, 7):  # test full chunk size
             builder_task = get_task_by_name(self.graph, "release-beta_firefox_%s_update_verify_beta_%s" % (p, i))
             verify(builder_task, self.builder_exists_schema)

 def test_task(self):
     verify(self.task, self.test_schema, self.generate_task_dependency_validator(), TestChecksums.not_allowed)

 def test_decode(self):
     verify(self.decode, self.claims_schema)

 def test_tasks(self):
     for platform, task in self.tasks.iteritems():
         verify(task, self.task_schema, self.generate_command_requirements_validator(platform), TestBeetmoverl10nPartialsCandidates.not_allowed)

 def test_uptake_monitoring(self):
     verify(self.uptake_monitoring, self.uptake_monitoring)

 def test_human_task(self):
     verify(self.human_task, self.human_task_schema, self.generate_human_task_requires_validator())

 def test_task(self):
     verify(self.task, self.task_schema,
            TestPushToMirrorsAutomatic.validate_task_not_allowed,
            TestPushToMirrorsAutomatic.validate_task_command,
            self.generate_task_requires_validator())

 def test_task(self):
     verify(self.task, self.task_schema, TestSnapBuilder.validate_task_payload)

 def test_uptake_monitoring_task(self):
     verify(self.task, self.task_schema, self.generate_task_dependency_validator())

 def test_notification_configuration(self):
     for task in self.graph["tasks"]:
         verify(task, self.notifications_schema)

 def test_channel(self):
     verify(self.task, self.task_schema, self.__class__.not_allowed)

 def test_human_task(self):
     verify(self.human_task, self.human_task_schema)

 def test_push_to_mirrors(self):
     verify(self.push_to_mirrors, self.push_to_mirrors_schema)

 def test_task(self):
     verify(self.task, self.task_schema, self.generate_dependency_validator())

 def test_task_schema(self):
     verify(self.task, self.task_schema)