Ejemplo n.º 1
0
    def setUp(self):
        test_kwargs = create_fennec_test_args({
            'checksums_enabled':
            True,
            'updates_enabled':
            True,
            'push_to_candidates_enabled':
            True,
            'push_to_releases_enabled':
            True,
            'push_to_releases_automatic':
            True,
            'branch':
            'mozilla-beta',
            'repo_path':
            'releases/mozilla-beta',
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['beta', 'release'],
            'final_verify_channels': ['beta', 'release'],
            'partner_repacks_platforms': [],
            'eme_free_repacks_platforms': [],
            'sha1_repacks_platforms': [],
            'en_US_config':
            EN_US_CONFIG,
            'l10n_config':
            L10N_CONFIG,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(
            self.graph,
            "release-{}-{}_push_to_releases".format("mozilla-beta", "fennec"))
Ejemplo n.º 2
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={'queue:task-priority:high'}),
        }, extra=True, required=True)

        self.test_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'version': '42.0b2',
                        'build_number': 3,
                    }
                }
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_candidates_enabled': True,
            'checksums_enabled': True,
            'updates_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {"task_id": "abc"},
                    "android-4-2-x86": {"task_id": "lmn"},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_chcksms")
Ejemplo n.º 3
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(
                    scopes={
                        "project:releng:signing:format:gpg",
                        "queue:define-task:buildbot-bridge/buildbot-bridge",
                        "queue:create-task:buildbot-bridge/buildbot-bridge",
                        "queue:task-priority:high"
                    }),
                'tasks':
                None,
            },
            extra=True,
            required=True)

        test_kwargs = create_fennec_test_args({
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "unsigned_task_id": "xyz",
                        "signed_task_id": "xyx"
                    },
                    "android-4-2-x86": {
                        "unsigned_task_id": "xyz",
                        "signed_task_id": "xyz"
                    },
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
Ejemplo n.º 4
0
    def setUp(self):
        self.task_schema = Schema(
            {
                'task': {
                    'scopes': list,
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'product':
                            'fennec',
                            'version':
                            '42.0b2',
                            'build_number':
                            3,
                            'repo_path':
                            'releases/foo',
                            'script_repo_revision':
                            'abcd',
                            'revision':
                            'abcdef123456',
                            'tuxedo_server_url':
                            'https://bouncer.real.allizom.org/api',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_candidates_enabled':
            True,
            'push_to_releases_enabled':
            True,
            'uptake_monitoring_enabled':
            True,
            'signing_pvt_key':
            PVT_KEY_FILE,
            'uptake_monitoring_platforms':
            ["android-4-0-armv7-api15", "android-4-2-x86"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        'signed_task_id': 'abc',
                        'unsigned_task_id': 'abc'
                    },
                    "android-4-2-x86": {
                        'signed_task_id': 'abc',
                        'unsigned_task_id': 'abc'
                    },
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-fennec_uptake_monitoring")
        self.payload = self.task["task"]["payload"]
Ejemplo n.º 5
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(
                    scopes={
                        "queue:task-priority:high",
                        "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                        "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
                    })
            },
            extra=True,
            required=True)

        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'aws-provisioner-v1',
                    'workerType': 'gecko-3-b-linux',
                }
            },
            extra=True,
            required=True)

        self.human_task_schema = Schema(None)

        test_kwargs = create_fennec_test_args({
            'checksums_enabled':
            True,
            'updates_enabled':
            True,
            'push_to_candidates_enabled':
            True,
            'push_to_releases_enabled':
            True,
            'push_to_releases_automatic':
            True,
            'branch':
            'mozilla-beta',
            'repo_path':
            'releases/mozilla-beta',
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['beta', 'release'],
            'final_verify_channels': ['beta', 'release'],
            'partner_repacks_platforms': ['win32', 'macosx64'],
            'eme_free_repacks_platforms': ['win32', 'macosx64'],
            'sha1_repacks_platforms': ['win32'],
            'en_US_config':
            EN_US_CONFIG,
            'l10n_config':
            L10N_CONFIG,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(
            self.graph,
            "release-{}-{}_push_to_releases".format("mozilla-beta", "fennec"))
        self.human_task = get_task_by_name(self.graph, self.human_task_name)
Ejemplo n.º 6
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(scopes={"queue:task-priority:high"})
            },
            extra=True,
            required=True)

        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'repo_path': 'releases/foo',
                            'script_repo_revision': 'abcd',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        self.push_to_mirrors_schema = Schema(
            {
                'task': {
                    'provisionerId': 'aws-provisioner-v1',
                    'workerType': 'gecko-3-b-linux',
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_releases_enabled':
            True,
            'bouncer_enabled':
            True,
            'postrelease_mark_as_shipped_enabled':
            True,
            'signing_pvt_key':
            PVT_KEY_FILE,
            'final_verify_channels': ['foo'],
            'release_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {},
                    "android-4-2-x86": {},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-fennec_mark_as_shipped")
        self.push_to_mirrors = get_task_by_name(
            self.graph, "release-foo-fennec_push_to_releases")
Ejemplo n.º 7
0
    def setUp(self):
        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'balrog_api_root': 'https://balrog.real/api',
                            'channels': 'alpha, release-dev',
                            'schedule_at': '2017-06-16T13:49:31.719007',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        self.push_to_mirrors_schema = Schema(
            {
                'task': {
                    'provisionerId': 'aws-provisioner-v1',
                    'workerType': 'gecko-3-b-linux',
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_candidates_enabled':
            True,
            'push_to_releases_enabled':
            True,
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'publish_to_balrog_channels': ["release-dev", "alpha"],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "task_id": "abc"
                    },
                    "android-4-2-x86": {
                        "task_id": "def"
                    },
                }
            },
            'release_eta':
            '2017-06-16T13:49:31.719007',
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(
            self.graph, "release-foo-fennec_schedule_publishing_in_balrog")
        self.push_to_mirrors = get_task_by_name(
            self.graph, "release-foo-fennec_push_to_releases")
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={'queue:task-priority:high'}),
        }, required=True, extra=True)

        self.push_to_mirrors_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'gecko-3-b-linux',
            }
        }, extra=True, required=True)

        self.uptake_monitoring_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge'
            }
        }, extra=True, required=True)

        self.task_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'product': 'fennec',
                        'version': '42.0b2',
                        'build_number': 3,
                        'repo_path': 'releases/foo',
                        'script_repo_revision': 'abcd',
                        'revision': 'abcdef123456',
                        'tuxedo_server_url': 'https://bouncer.real.allizom.org/api',
                    }
                }
            }
        }, required=True, extra=True)

        test_kwargs = create_fennec_test_args({
            'push_to_releases_enabled': True,
            'postrelease_bouncer_aliases_enabled': True,
            'release_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {"task_id": "abc"},
                    "android-4-2-x86": {"task_id": "def"},
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_bouncer_aliases")
        self.push_to_mirrors = get_task_by_name(self.graph, "release-foo-fennec_push_to_releases")
        self.uptake_monitoring = get_task_by_name(self.graph, "release-foo-fennec_uptake_monitoring")
Ejemplo n.º 9
0
    def setUp(self):
        test_kwargs = create_fennec_test_args({
            'source_enabled': True,
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'push_to_releases_automatic': True,
            'release_channels': ['foo', 'bar'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': EN_US_CONFIG,
        })
        self.graph = make_task_graph(**test_kwargs)

        self.push_to_mirrors = get_task_by_name(self.graph, "release-foo_fennec_push_to_releases")
        self.foo_source_signing_beet = get_task_by_name(self.graph, "foo_source_signing_beet")
        self.foo_source_beet = get_task_by_name(self.graph, "foo_source_beet")
Ejemplo n.º 10
0
    def setUp(self):
        test_kwargs = create_fennec_test_args({
            'source_enabled': True,
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'push_to_releases_automatic': True,
            'release_channels': ['foo', 'bar'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': EN_US_CONFIG,
        })
        self.graph = make_task_graph(**test_kwargs)

        self.push_to_mirrors = get_task_by_name(self.graph, "release-foo_fennec_push_to_releases")
        self.foo_source_signing_beet = get_task_by_name(self.graph, "foo_source_signing_beet")
        self.foo_source_beet = get_task_by_name(self.graph, "foo_source_beet")
Ejemplo n.º 11
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "queue:task-priority:high",
            })
        }, extra=True, required=True)

        self.task_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'next_version': '42.0b3',
                        'repo_path': 'releases/foo',
                        'script_repo_revision': 'abcd',
                    }
                }
            }
        }, extra=True, required=True)

        self.push_to_mirrors_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'gecko-3-b-linux',
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_releases_enabled': True,
            'bouncer_enabled': True,
            'postrelease_version_bump_enabled': True,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {"task_id": "abc"},
                    "android-4-2-x86": {"task_id": "def"},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_version_bump")
        self.push_to_mirrors = get_task_by_name(self.graph, "release-foo-fennec_push_to_releases")
Ejemplo n.º 12
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(scopes={'queue:task-priority:high'}),
            },
            extra=True,
            required=True)

        self.test_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'version': '42.0b2',
                            'build_number': 3,
                        }
                    }
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_candidates_enabled': True,
            'checksums_enabled': True,
            'updates_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "task_id": "abc"
                    },
                    "android-4-2-x86": {
                        "task_id": "lmn"
                    },
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_chcksms")
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "queue:task-priority:high",
                "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
            })
        }, required=True, extra=True)

        self.task_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'gecko-3-b-linux',
            }
        }, extra=True, required=True)

        self.human_task_schema = Schema({
            'task': {
                'provisionerId': 'null-provisioner',
                'workerType': 'human-decision',
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'checksums_enabled': True,
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['beta', 'release'],
            'final_verify_channels': ['beta', 'release'],
            'partner_repacks_platforms': ['win32', 'macosx64'],
            'eme_free_repacks_platforms': ['win32', 'macosx64'],
            'sha1_repacks_platforms': ['win32'],
            'en_US_config': EN_US_CONFIG,
            'l10n_config': L10N_CONFIG,
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(
            self.graph, "release-{}-{}_push_to_releases".format("mozilla-beta", "fennec")
        )
        self.human_task = get_task_by_name(self.graph, self.human_task_name)
    def setUp(self):
        test_kwargs = create_fennec_test_args({
            'checksums_enabled': True,
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'push_to_releases_automatic': True,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['beta', 'release'],
            'final_verify_channels': ['beta', 'release'],
            'partner_repacks_platforms': [],
            'eme_free_repacks_platforms': [],
            'sha1_repacks_platforms': [],
            'en_US_config': EN_US_CONFIG,
            'l10n_config': L10N_CONFIG,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-{}-{}_push_to_releases".format("mozilla-beta", "fennec"))
Ejemplo n.º 15
0
    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_fennec_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,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "unsigned_task_id": "xyz",
                        "signed_task_id": "xyz"
                    },
                    "android-4-2-x86": {
                        "unsigned_task_id": "xyz",
                        "signed_task_id": "xyz"
                    },
                }
            },
        })

        graph = make_task_graph(**test_kwargs)
        do_common_assertions(graph)
    def setUp(self):
        self.task_schema = Schema({
            'task': {
                'scopes': list,
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'product': 'fennec',
                        'version': '42.0b2',
                        'build_number': 3,
                        'repo_path': 'releases/foo',
                        'script_repo_revision': 'abcd',
                        'revision': 'abcdef123456',
                        'tuxedo_server_url': 'https://bouncer.real.allizom.org/api',
                    }
                }
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'uptake_monitoring_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'uptake_monitoring_platforms': ["android-4-0-armv7-api15", "android-4-2-x86"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {'signed_task_id': 'abc', 'unsigned_task_id': 'abc'},
                    "android-4-2-x86": {'signed_task_id': 'abc', 'unsigned_task_id': 'abc'},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_uptake_monitoring")
        self.payload = self.task["task"]["payload"]
Ejemplo n.º 17
0
    def setUp(self):
        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'build_number': 3,
                            'repo_path': 'releases/foo',
                            'script_repo_revision': 'abcd',
                        }
                    }
                }
            },
            required=True,
            extra=True)

        test_kwargs = create_fennec_test_args({
            'bouncer_enabled': True,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "task_id": "abc"
                    },
                    "android-4-2-x86": {
                        "task_id": "def"
                    },
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-fennec_bncr_sub")
Ejemplo n.º 18
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "docker-worker:cache:tc-vcs",
                "docker-worker:image:taskcluster/builder:*",
                "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
                "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                "docker-worker:cache:build-foo-release-workspace",
                "docker-worker:cache:tooltool-cache",
                "project:releng:signing:format:gpg",
                "project:releng:signing:cert:release-signing",
                "docker-worker:relengapi-proxy:tooltool.download.public",
            })
        }, extra=True, required=True)

        self.task_schema = Schema({
            'task': {
                'scopes': generate_scope_validator(scopes={
                    "docker-worker:cache:tc-vcs",
                    "docker-worker:image:taskcluster/builder:0.5.9",
                    "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                    "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
                    "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                    "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                    "docker-worker:cache:build-foo-release-workspace",
                    "docker-worker:cache:tooltool-cache",
                    "docker-worker:relengapi-proxy:tooltool.download.public",
                }),
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'gecko-3-b-linux',
                'payload': {
                    'artifacts': dict,
                    'command': list,
                    'cache': dict,
                    'image': Match(r'^mozillareleases/source-builder@sha256'),
                    'env': {
                        'MOZ_PKG_VERSION': '42.0b2',
                    }
                }
            }
        }, extra=True, required=True)

        self.signing_task_schema = Schema({
            'task': {
                'scopes': generate_scope_validator(scopes={
                    "project:releng:signing:format:gpg",
                    "project:releng:signing:cert:release-signing",
                }),
                'provisionerId': 'signing-provisioner-v1',
                'workerType': 'signing-worker-v1',
                'payload': All({
                    'signingManifest': str,
                }, Length(1))
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'source_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': EN_US_CONFIG,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "foo_source")
        self.signing_task = get_task_by_name(self.graph, "foo_source_signing")
Ejemplo n.º 19
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(scopes={'queue:task-priority:high'}),
            },
            required=True,
            extra=True)

        self.push_to_mirrors_schema = Schema(
            {
                'task': {
                    'provisionerId': 'aws-provisioner-v1',
                    'workerType': 'gecko-3-b-linux',
                }
            },
            extra=True,
            required=True)

        self.uptake_monitoring_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge'
                }
            },
            extra=True,
            required=True)

        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'product':
                            'fennec',
                            'version':
                            '42.0b2',
                            'build_number':
                            3,
                            'repo_path':
                            'releases/foo',
                            'script_repo_revision':
                            'abcd',
                            'revision':
                            'abcdef123456',
                            'tuxedo_server_url':
                            'https://bouncer.real.allizom.org/api',
                        }
                    }
                }
            },
            required=True,
            extra=True)

        test_kwargs = create_fennec_test_args({
            'push_to_releases_enabled':
            True,
            'postrelease_bouncer_aliases_enabled':
            True,
            'release_channels': ['foo'],
            'signing_pvt_key':
            PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "android-4-0-armv7-api15": {
                        "task_id": "abc"
                    },
                    "android-4-2-x86": {
                        "task_id": "def"
                    },
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-fennec_bouncer_aliases")
        self.push_to_mirrors = get_task_by_name(
            self.graph, "release-foo-fennec_push_to_releases")
        self.uptake_monitoring = get_task_by_name(
            self.graph, "release-foo-fennec_uptake_monitoring")
Ejemplo n.º 20
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "docker-worker:cache:tc-vcs",
                "docker-worker:image:taskcluster/builder:*",
                "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
                "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                "docker-worker:cache:build-foo-release-workspace",
                "docker-worker:cache:tooltool-cache",
                "project:releng:signing:format:gpg",
                "project:releng:signing:cert:release-signing",
                "docker-worker:relengapi-proxy:tooltool.download.public",
            })
        }, extra=True, required=True)

        self.task_schema = Schema({
            'task': {
                'scopes': generate_scope_validator(scopes={
                    "docker-worker:cache:tc-vcs",
                    "docker-worker:image:taskcluster/builder:0.5.9",
                    "queue:define-task:aws-provisioner-v1/gecko-3-b-linux",
                    "queue:create-task:aws-provisioner-v1/gecko-3-b-linux",
                    "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                    "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                    "docker-worker:cache:build-foo-release-workspace",
                    "docker-worker:cache:tooltool-cache",
                    "docker-worker:relengapi-proxy:tooltool.download.public",
                }),
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'gecko-3-b-linux',
                'payload': {
                    'artifacts': dict,
                    'command': list,
                    'cache': dict,
                    'image': Match(r'^rail/source-builder@sha256'),
                    'env': {
                        'MOZ_PKG_VERSION': '42.0b2',
                    }
                }
            }
        }, extra=True, required=True)

        self.signing_task_schema = Schema({
            'task': {
                'scopes': generate_scope_validator(scopes={
                    "project:releng:signing:format:gpg",
                    "project:releng:signing:cert:release-signing",
                }),
                'provisionerId': 'signing-provisioner-v1',
                'workerType': 'signing-worker-v1',
                'payload': All({
                    'signingManifest': str,
                }, Length(1))
            }
        }, extra=True, required=True)

        test_kwargs = create_fennec_test_args({
            'source_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': EN_US_CONFIG,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "foo_source")
        self.signing_task = get_task_by_name(self.graph, "foo_source_signing")