def setUp(self):
     test_args = create_firefox_test_args({
         'source_enabled': True,
         'checksums_enabled': True,
         'updates_enabled': True,
         'bouncer_enabled': True,
         'push_to_candidates_enabled': True,
         'push_to_releases_enabled': True,
         'uptake_monitoring_enabled': True,
         'postrelease_version_bump_enabled': True,
         'postrelease_mark_as_shipped_enabled': True,
         'postrelease_bouncer_aliases_enabled': True,
         'push_to_releases_automatic': True,
         'signing_pvt_key': PVT_KEY_FILE,
         'publish_to_balrog_channels': ['foo'],
         'partner_repacks_platforms': [
             'win32',
             'macosx64',
         ],
         'en_US_config': {
             "platforms": {
                 "macosx64": {"task_id": "abc"},
                 "win32": {"task_id": "def"},
                 "win64": {"task_id": "jgh"},
                 "linux": {"task_id": "ijk"},
                 "linux64": {"task_id": "lmn"},
             }
         }
     })
     self.graph = make_task_graph(**test_args)
Exemple #2
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_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,
            'en_US_config': {
                "platforms": {
                    "macosx64": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"}
                }
            },
        })

        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 setUp(self):
        self.task_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'opt-linux64',
            }
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'en_US_config': EN_US_CONFIG,
            'l10n_config': self.l10n_config,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'final_verify_channels': ['beta'],
            'release_channels': ['beta']
        })

        self.graph = make_task_graph(**test_kwargs)
        self.tasks = {
            'win32': get_task_by_name(
                self.graph, "release-{}_{}_{}_l10n_repack_partial_{}build{}_beetmover_candidates_{}".format(
                    "mozilla-beta", "firefox", 'win32', "38.0", 1, 1
                )
            ),
            'macosx64': get_task_by_name(
                self.graph, "release-{}_{}_{}_l10n_repack_partial_{}build{}_beetmover_candidates_{}".format(
                    "mozilla-beta", "firefox", 'macosx64', "37.0", 2, 1
                )
            ),
        }
 def setUp(self):
     self.task_schema = Schema({
         'task': {
             'provisionerId': 'buildbot-bridge',
             'workerType': 'buildbot-bridge',
             'payload': {
                 'properties': {
                     'CHANNEL': 'beta-cdntest'
                 }
             }
         }
     }, extra=True, required=True)
     test_args = create_firefox_test_args({
         'updates_enabled': True,
         'push_to_candidates_enabled': True,
         'push_to_releases_enabled': True,
         'update_verify_enabled': True,
         'updates_builder_enabled': True,
         'signing_pvt_key': PVT_KEY_FILE,
         'branch': 'beta',
         'release_channels': ['beta'],
         'final_verify_channels': ['beta'],
         'l10n_config': L10N_CONFIG,
         'en_US_config': EN_US_CONFIG,
         'uptake_monitoring_enabled': True,
         'update_verify_channel': 'beta-cdntest',
         'update_verify_requires_cdn_push': True,
     })
     self.graph = make_task_graph(**test_args)
     self.task = get_task_by_name(self.graph, "release-beta_firefox_win32_update_verify_beta_3")
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "queue:*",
                "docker-worker:*",
                "scheduler:*",
                "project:releng:signing:format:gpg",
                "project:releng:signing:format:mar",
                "project:releng:signing:cert:release-signing",
                "docker-worker:feature:balrogVPNProxy"
            })
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"}
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.generator_image = get_task_by_name(self.graph, "funsize_update_generator_image")
        self.funsize_balrog_image = get_task_by_name(self.graph, "funsize_balrog_image")
    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',
                    }
                }
            }
        }, extra=True, required=True)

        test_kwargs = create_firefox_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": {
                    "macosx64": {"task_id": "abc"},
                    "win32": {"task_id": "def"},
                    "win64": {"task_id": "jgh"},
                    "linux": {"task_id": "ijk"},
                    "linux64": {"task_id": "lmn"},
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_publish_balrog")
Exemple #7
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_firefox_test_args({
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "linux": {
                        "task_id": "xyz"
                    },
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
    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_firefox_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": {
                    "macosx64": {"task_id": "abc"},
                    "win64": {"task_id": "jgh"},
                    "linux64": {"task_id": "lmn"},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_chcksms")
Exemple #9
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "docker-worker:image:taskcluster/builder:*",
                "queue:define-task:aws-provisioner-v1/opt-linux64",
                "queue:create-task:aws-provisioner-v1/opt-linux64",
                "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                "project:releng:signing:format:gpg",
                "project:releng:signing:cert:release-signing",
            })
        }, extra=True, required=True)

        self.task_schema = Schema({
            'task': {
                'scopes': generate_scope_validator(scopes={
                    "queue:define-task:aws-provisioner-v1/opt-linux64",
                    "queue:create-task:aws-provisioner-v1/opt-linux64",
                    "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                    "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                }),
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'opt-linux64',
                'payload': {
                    'image': str,
                    'command': list,
                    'artifacts': dict,
                    'env': {
                        '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(Length(1), {
                    'signingManifest': str,
                })
            }

        }, required=True, extra=True)

        test_kwargs = create_firefox_test_args({
            'snap_enabled': True,
            'en_US_config': EN_US_CONFIG,
            'signing_pvt_key': PVT_KEY_FILE,
        })

        self.graph = make_task_graph(**test_kwargs)

        self.task = get_task_by_name(self.graph, "foo_snap")
        self.signing_task = get_task_by_name(self.graph, "foo_snap_signing")
Exemple #10
0
    def setUp(self):
        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'enUS_platforms': ['win32'],
            'en_US_config': {
                "platforms": {
                    "win32": {"task_id": "xyy"}
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 1,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "ru": "default",
                    "uk": "default",
                    "zh-TW": "default",
                },
            },
            'partial_updates': {
                '38.0': {
                    'buildNumber': 1,
                    'locales': [
                        'de', 'en-GB', 'ru', 'uk', 'zh-TW'
                    ]
                },
                '37.0': {
                    'buildNumber': 2,
                    'locales': [
                        'de', 'en-GB', 'ru', 'uk'
                    ]
                }
            }
        })
        self.graph = make_task_graph(**test_kwargs)

        self.update_generator_37 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1_37.0_update_generator")
        self.update_generator_38 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1_38.0_update_generator")

        self.beetmover_candidates_37 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_partial_37.0build2_beetmover_candidates_1")
        self.beetmover_candidates_38 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_partial_38.0build1_beetmover_candidates_1")
    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': 'aws-provisioner-v1',
                    'workerType': 'b2gtest',
                    'payload': {
                        'image': Match(r'^rail/python-test-runner'),
                        'command': [str],
                        'env': dict,
                    }
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_firefox_test_args({
            'push_to_releases_enabled':
            True,
            'release_channels': ['beta', 'release'],
            'final_verify_channels': ['beta', 'release'],
            'final_verify_platforms':
            ["macosx64", "win32", "win64", "linux", "linux64"],
            'signing_pvt_key':
            PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.tasks = [
            get_task_by_name(self.graph,
                             "{chan}_final_verify".format(chan=chan))
            for chan in (
                'beta',
                'release',
            )
        ]
 def setUp(self):
     self.notifications_schema = Schema(
         {
             "task": {
                 "extra": {
                     #  Notification section is either 'no notifications' or the below schema
                     "notifications": Any(
                         Schema(
                             {
                                 Any("task-completed", "task-exception", "task-failed"): {
                                     "subject": str,
                                     "message": str,
                                 }
                             },
                             extra=True,
                             required=True,
                         ),
                         "no notifications",
                     )
                 }
             }
         },
         required=True,
         extra=True,
     )
     test_kwargs = create_firefox_test_args(
         {
             "source_enabled": True,
             "updates_enabled": True,
             "bouncer_enabled": True,
             "checksums_enabled": True,
             "push_to_candidates_enabled": True,
             "push_to_releases_enabled": True,
             "push_to_releases_automatic": True,
             "postrelease_version_bump_enabled": True,
             "postrelease_mark_as_shipped_enabled": True,
             "postrelease_bouncer_aliases_enabled": True,
             "release_channels": ["foo"],
             "final_verify_channels": ["foo"],
             "signing_pvt_key": PVT_KEY_FILE,
             "en_US_config": {
                 "platforms": {
                     "macosx64": {"task_id": "abc"},
                     "win32": {"task_id": "def"},
                     "win64": {"task_id": "jgh"},
                     "linux": {"task_id": "ijk"},
                     "linux64": {"task_id": "lmn"},
                 }
             },
         }
     )
     self.graph = make_task_graph(**test_kwargs)
Exemple #13
0
 def setUp(self):
     test_args = create_firefox_test_args({
         'source_enabled':
         True,
         'checksums_enabled':
         True,
         'updates_enabled':
         True,
         'bouncer_enabled':
         True,
         'push_to_candidates_enabled':
         True,
         'push_to_releases_enabled':
         True,
         'uptake_monitoring_enabled':
         True,
         'postrelease_version_bump_enabled':
         True,
         'postrelease_mark_as_shipped_enabled':
         True,
         'postrelease_bouncer_aliases_enabled':
         True,
         'push_to_releases_automatic':
         True,
         'signing_pvt_key':
         PVT_KEY_FILE,
         'publish_to_balrog_channels': ['foo'],
         'partner_repacks_platforms': [
             'win32',
             'macosx64',
         ],
         'en_US_config': {
             "platforms": {
                 "macosx64": {
                     "task_id": "abc"
                 },
                 "win32": {
                     "task_id": "def"
                 },
                 "win64": {
                     "task_id": "jgh"
                 },
                 "linux": {
                     "task_id": "ijk"
                 },
                 "linux64": {
                     "task_id": "lmn"
                 },
             }
         }
     })
     self.graph = make_task_graph(**test_args)
 def setUp(self):
     test_kwargs = create_firefox_test_args({
         'updates_enabled': True,
         'push_to_candidates_enabled': True,
         'update_verify_enabled': True,
         'branch': 'beta',
         'release_channels': ["beta", "release"],
         'enUS_platforms': ["linux", "linux64", "win64", "win32", "macosx64"],
         'signing_pvt_key': PVT_KEY_FILE,
         'en_US_config': EN_US_CONFIG,
         'l10n_config': L10N_CONFIG,
     })
     self.graph = make_task_graph(**test_kwargs)
Exemple #15
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',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        test_kwargs = create_firefox_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": {
                    "macosx64": {
                        "task_id": "abc"
                    },
                    "win32": {
                        "task_id": "def"
                    },
                    "win64": {
                        "task_id": "jgh"
                    },
                    "linux": {
                        "task_id": "ijk"
                    },
                    "linux64": {
                        "task_id": "lmn"
                    },
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-firefox_publish_balrog")
 def setUp(self):
     test_kwargs = create_firefox_test_args({
         'updates_enabled':
         True,
         'push_to_candidates_enabled':
         True,
         'repo_path':
         'releases/mozilla-beta',
         'branch':
         'mozilla-beta',
         'signing_pvt_key':
         PVT_KEY_FILE,
         'enUS_platforms': ["win32", "macosx64"],
         'final_verify_platforms': ["macosx64", "win32"],
         'release_channels': ['beta'],
         'final_verify_channels': ['beta'],
         'en_US_config': {
             "platforms": {
                 "macosx64": {
                     "task_id": "xyz"
                 },
                 "win32": {
                     "task_id": "xyy"
                 }
             }
         },
         'l10n_config': {
             "platforms": {
                 "win32": {
                     "en_us_binary_url":
                     "https://queue.taskcluster.net/something/firefox.exe",
                     "locales": ["de", "en-GB", "zh-TW"],
                     "chunks": 1,
                 },
                 "macosx64": {
                     "en_us_binary_url":
                     "https://queue.taskcluster.net/something/firefox.tar.xz",
                     "locales": ["de", "en-GB", "zh-TW"],
                     "chunks": 1,
                 },
             },
             "changesets": {
                 "de": "default",
                 "en-GB": "default",
                 "zh-TW": "default",
             },
         },
     })
     self.graph = make_task_graph(**test_kwargs)
     self.task = get_task_by_name(self.graph, "beta_final_verify")
    def setUp(self):
        self.task_schema = Schema({
            'task': {
                'workerType': 'opt-linux64',
                'provisionerId': 'aws-provisioner-v1',
                'extra': {
                    'l10n_changesets': 'ab cd\nef gh\nij kl\n',
                },
            },
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            'source_enabled': True,
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'push_to_releases_automatic': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['foo', 'bar'],
            'partner_repacks_platforms': ['win32', 'linux'],
            'l10n_changesets': {"ab": "cd", "ef": "gh", "ij": "kl"},
            'en_US_config': {
                "platforms": {
                    "linux": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"},
                },
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },

                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                },
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "foo_l10n_changeset")
Exemple #18
0
    def setUp(self):
        test_kwargs = create_firefox_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_firefox_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")
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={'queue:task-priority:high'}),
        }, required=True, extra=True)

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

        self.task_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'product': 'firefox',
                        '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_firefox_test_args({
            'postrelease_bouncer_aliases_enabled': True,
            'release_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)

        self.task = get_task_by_name(self.graph, "release-foo-firefox_bouncer_aliases")
        self.human_task = get_task_by_name(self.graph, "publish_release_human_decision")
    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_firefox_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": {
                    "macosx64": {
                        "task_id": "abc"
                    },
                    "win64": {
                        "task_id": "jgh"
                    },
                    "linux64": {
                        "task_id": "lmn"
                    },
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_chcksms")
    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.human_task_schema = Schema({
            'task': {
                'provisionerId': 'null-provisioner',
                'workerType': 'human-decision',
            }
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            '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": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_version_bump")
        self.human_task = get_task_by_name(self.graph, "publish_release_human_decision")
Exemple #22
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_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,
            'en_US_config': {
                "platforms": {
                    "macosx64": {
                        "task_id": "xyz"
                    },
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
        })

        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)
Exemple #23
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',
                        'partial_versions': '37.0build2, 38.0build1',
                        'balrog_api_root': 'https://balrog.real/api',
                        'platforms': 'linux, linux64, macosx64, win32, win64',
                        'channels': 'bar, foo',
                    }
                }
            }
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'bouncer_enabled': True,
            'push_to_candidates_enabled': True,
            'postrelease_version_bump_enabled': True,
            'updates_builder_enabled': True,
            'release_channels': ['foo', 'bar'],
            'final_verify_channels': ['foo', 'beta'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                'platforms': {
                    'macosx64': {'task_id': 'abc'},
                    'win32': {'task_id': 'def'},
                    'win64': {'task_id': 'ghi'},
                    'linux': {'task_id': 'jkl'},
                    'linux64': {'task_id': 'mno'},
                }
            }
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_updates")
    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',
                            'partial_versions':
                            ', '.join([
                                '37.0build2',
                                '38.0build1',
                            ]),
                        }
                    }
                }
            },
            required=True,
            extra=True)

        test_kwargs = create_firefox_test_args({
            'bouncer_enabled': True,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo_firefox_bncr_sub")
Exemple #25
0
    def setUp(self):
        test_kwargs = create_firefox_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': [],
            '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", "firefox"))
    def setUp(self):
        test_kwargs = create_firefox_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': ["macosx64", "win32", "win64", "linux", "linux64"],
            'partner_repacks_platforms': ["macosx64", "win32", "win64", "linux", "linux64"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {"task_id": "abc"},
                    "win32": {"task_id": "def"},
                    "win64": {"task_id": "jgh"},
                    "linux": {"task_id": "ijk"},
                    "linux64": {"task_id": "lmn"},
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },

                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                },
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_uptake_monitoring")
Exemple #27
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(
                    scopes={
                        "queue:*", "docker-worker:*", "scheduler:*",
                        "project:releng:signing:format:gpg",
                        "project:releng:signing:format:mar",
                        "project:releng:signing:cert:release-signing",
                        "docker-worker:feature:balrogVPNProxy"
                    })
            },
            extra=True,
            required=True)

        test_kwargs = create_firefox_test_args({
            'updates_enabled':
            True,
            'branch':
            'mozilla-beta',
            'repo_path':
            'releases/mozilla-beta',
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {
                        "task_id": "xyz"
                    },
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.generator_image = get_task_by_name(
            self.graph, "funsize_update_generator_image")
        self.funsize_balrog_image = get_task_by_name(self.graph,
                                                     "funsize_balrog_image")
    def setUp(self):
        self.task_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'opt-linux64',
                'extra': {
                    'build_props': {
                        'product': 'firefox',
                        'locales': ["de", "en-GB", "zh-TW"],
                        'branch': 'mozilla-beta',
                        'version': '42.0b2',
                        'revision': 'abcdef123456',
                        'platform': str,
                    }
                }
            }
        }, extra=True, required=True)

        test_kwargs = create_firefox_test_args({
            'push_to_candidates_enabled': True,
            'branch': 'mozilla-beta',
            'repo_path': 'releases/mozilla-beta',
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': EN_US_CONFIG,
            'l10n_config': self.l10n_config,
        })

        self.graph = make_task_graph(**test_kwargs)
        self.tasks = {
            'win32': get_task_by_name(
                self.graph, "release-{}_{}_{}_l10n_repack_beetmover_candidates_1".format("mozilla-beta",
                                                                                         "firefox",
                                                                                         'win32')
            ),
            'macosx64': get_task_by_name(
                self.graph, "release-{}_{}_{}_l10n_repack_beetmover_candidates_1".format("mozilla-beta",
                                                                                         "firefox",
                                                                                         'macosx64')
            ),
        }
Exemple #29
0
    def setUp(self):
        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={
                "queue:task-priority:high",
                "queue:define-task:aws-provisioner-v1/opt-linux64",
                "queue:create-task:aws-provisioner-v1/opt-linux64",
            })
        }, required=True, extra=True)

        self.task_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'opt-linux64',
            }
        }, extra=True, required=True)

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

        test_kwargs = create_firefox_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'],
            '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", "firefox")
        )
        self.human_task = get_task_by_name(self.graph, self.human_task_name)
    def setUp(self):
        self.task_schema = Schema({
            'task': {
                'scopes': list,
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'product': 'firefox',
                        '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_firefox_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': ["macosx64", "win32", "win64", "linux", "linux64"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {"task_id": "abc"},
                    "win32": {"task_id": "def"},
                    "win64": {"task_id": "jgh"},
                    "linux": {"task_id": "ijk"},
                    "linux64": {"task_id": "lmn"},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "release-foo-firefox_uptake_monitoring")
        self.payload = self.task["task"]["payload"]
Exemple #31
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_firefox_test_args({
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "linux": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"}
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
    def setUp(self):
        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'repo_path': 'releases/mozilla-beta',
            'branch': 'mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'enUS_platforms': ["win32", "macosx64"],
            'final_verify_platforms': ["macosx64", "win32"],
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"}
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "macosx64": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },

                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                },
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph, "beta_final_verify")
    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': {
                        'NO_BBCONFIG': '1',
                        'VERIFY_CONFIG': 'beta-firefox-win32.cfg',
                        'TOTAL_CHUNKS': '12',
                        'THIS_CHUNK': '3'
                    }
                }
            }
        }, extra=True, required=True)

        # Ensure the task exists, and is a dict
        self.builder_exists_schema = Schema(dict)

        test_args = create_firefox_test_args({
            'updates_enabled': True,
            'push_to_candidates_enabled': True,
            'update_verify_enabled': True,
            'updates_builder_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'branch': 'beta',
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'l10n_config': L10N_CONFIG,
            'en_US_config': EN_US_CONFIG,
        })
        self.graph = make_task_graph(**test_args)
        self.task = get_task_by_name(self.graph, "release-beta_firefox_win32_update_verify_beta_3")
    def setUp(self):
        self.task_schema = Schema({
            'task': {
                'provisionerId': 'aws-provisioner-v1',
                'workerType': 'b2gtest',
                'payload': {
                    'command': [str],
                    'env': dict,
                    'image': Match(r'^rail/python-test-runner'),
                }
            }
        }, extra=True, required=True)

        self.graph_schema = Schema({
            'scopes': generate_scope_validator(scopes={'queue:task-priority:high'}),
        }, extra=True, required=True)

        test_args = create_firefox_test_args({
            'push_to_releases_enabled': True,
            'uptake_monitoring_enabled': True,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'final_verify_platforms': ["macosx64", "win32", "win64", "linux", "linux64"],
            'enUS_platforms': ["linux", "linux64", "win64", "win32", "macosx64"],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                },
            },
        })
        self.graph = make_task_graph(**test_args)
        self.task = get_task_by_name(self.graph, "foo_final_verify")
    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',
                        'partial_versions': ', '.join([
                            '37.0build2',
                            '38.0build1',
                        ]),
                    }
                }
            }
        }, required=True, extra=True)

        test_kwargs = create_firefox_test_args({
            'bouncer_enabled': True,
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'signing_pvt_key': PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })

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

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

        self.task_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'product':
                            'firefox',
                            '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_firefox_test_args({
            'postrelease_bouncer_aliases_enabled':
            True,
            'release_channels': ['foo'],
            'signing_pvt_key':
            PVT_KEY_FILE,
            'en_US_config': {
                "platforms": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)

        self.task = get_task_by_name(self.graph,
                                     "release-foo-firefox_bouncer_aliases")
        self.human_task = get_task_by_name(self.graph,
                                           "publish_release_human_decision")
    def setUp(self):
        test_kwargs = create_firefox_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':
            ["macosx64", "win32", "win64", "linux", "linux64"],
            'partner_repacks_platforms':
            ["macosx64", "win32", "win64", "linux", "linux64"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {
                        "task_id": "abc"
                    },
                    "win32": {
                        "task_id": "def"
                    },
                    "win64": {
                        "task_id": "jgh"
                    },
                    "linux": {
                        "task_id": "ijk"
                    },
                    "linux64": {
                        "task_id": "lmn"
                    },
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                },
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-firefox_uptake_monitoring")
Exemple #38
0
    def setUp(self):
        self.graph_schema = Schema(
            {
                'scopes':
                generate_scope_validator(
                    scopes={
                        "docker-worker:image:taskcluster/builder:*",
                        "queue:define-task:aws-provisioner-v1/opt-linux64",
                        "queue:create-task:aws-provisioner-v1/opt-linux64",
                        "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                        "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                        "project:releng:signing:format:gpg",
                        "project:releng:signing:cert:release-signing",
                    })
            },
            extra=True,
            required=True)

        self.task_schema = Schema(
            {
                'task': {
                    'scopes':
                    generate_scope_validator(
                        scopes={
                            "queue:define-task:aws-provisioner-v1/opt-linux64",
                            "queue:create-task:aws-provisioner-v1/opt-linux64",
                            "queue:define-task:aws-provisioner-v1/build-c4-2xlarge",
                            "queue:create-task:aws-provisioner-v1/build-c4-2xlarge",
                        }),
                    'provisionerId':
                    'aws-provisioner-v1',
                    'workerType':
                    'opt-linux64',
                    'payload': {
                        'image': str,
                        'command': list,
                        'artifacts': dict,
                        'env': {
                            '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(Length(1), {
                        'signingManifest': str,
                    })
                }
            },
            required=True,
            extra=True)

        test_kwargs = create_firefox_test_args({
            'snap_enabled': True,
            'en_US_config': EN_US_CONFIG,
            'signing_pvt_key': PVT_KEY_FILE,
        })

        self.graph = make_task_graph(**test_kwargs)

        self.task = get_task_by_name(self.graph, "foo_snap")
        self.signing_task = get_task_by_name(self.graph, "foo_snap_signing")
Exemple #39
0
    def setUp(self):
        self.chunk_1_schema = Schema(
            {
                'task': {
                    'payload': {
                        'buildername':
                        'release-mozilla-beta_firefox_win32_l10n_repack',
                        'properties': {
                            'locales': 'de:default en-GB:default ru:default',
                            'en_us_binary_url':
                            'https://queue.taskcluster.net/something/firefox.exe',
                            'repo_path': 'releases/mozilla-beta',
                            'script_repo_revision': 'abcd',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        self.chunk_2_schema = Schema(
            {
                'task': {
                    'payload': {
                        'buildername':
                        'release-mozilla-beta_firefox_win32_l10n_repack',
                        'properties': {
                            'en_us_binary_url':
                            'https://queue.taskcluster.net/something/firefox.exe',
                            'script_repo_revision': 'abcd',
                            'repo_path': 'releases/mozilla-beta',
                            'locales': 'uk:default zh-TW:default',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        self.artifacts_1_schema = self.artifacts_2_schema = Schema(
            dict)  # Tasks must exist as a dict
        self.chunk_3_schema = self.artifacts_3_schema = Schema(
            None)  # Tasks must be None

        self.partials_schema = Schema(dict)

        test_kwargs = create_firefox_test_args({
            'updates_enabled':
            True,
            'repo_path':
            'releases/mozilla-beta',
            'branch':
            'mozilla-beta',
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'en_US_platforms': ['win32'],
            'en_US_config': {
                "platforms": {
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 2,
                    },
                    "linux64": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 2,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "ru": "default",
                    "uk": "default",
                    "zh-TW": "default",
                },
            },
        })
        self.graph = make_task_graph(**test_kwargs)

        self.chunk_1 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1")
        self.chunk_2 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_2")
        self.chunk_3 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_3")

        self.artifacts_1 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_1")
        self.artifacts_2 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_2")
        self.artifacts_3 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_3")
Exemple #40
0
    def setUp(self):
        self.chunk_0_schema = self.chunk_2_schema = Schema(None)
        self.chunk_1_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'buildername': 'release-mozilla-beta_firefox_win32_l10n_repack',
                    'properties': {
                        'repo_path': 'releases/mozilla-beta',
                        'script_repo_revision': 'abcd',
                        'locales': 'de:default en-GB:default zh-TW:default',
                        'en_us_binary_url': 'https://queue.taskcluster.net/something/firefox.exe',
                    }
                }
            }
        }, extra=True, required=True)

        self.artifact_0_schema = self.artifact_2_schema = Schema(None)
        self.artifact_1_schema = Schema({
            'task': {
                'provisionerId': 'null-provisioner',
                'workerType': 'buildbot',
            }
        }, extra=True, required=True)

        test_arguments = create_firefox_test_args({
            'updates_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'branch': "mozilla-beta",
            'repo_path': "releases/mozilla-beta",
            'release_channels': ["beta"],
            'final_verify_channels': ["beta"],

            'en_US_config': {
                "platforms": {
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },

                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                }
            },
        })

        self.graph = make_task_graph(**test_arguments)

        self.chunk_0 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_0")
        self.chunk_1 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1")
        self.chunk_2 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_2")

        self.artifact_0 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_0")
        self.artifact_1 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_1")
        self.artifact_2 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_2")
Exemple #41
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/opt-linux64",
                "queue:create-task:aws-provisioner-v1/opt-linux64",
                "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/opt-linux64",
                    "queue:create-task:aws-provisioner-v1/opt-linux64",
                    "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': 'opt-linux64',
                '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_firefox_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")
Exemple #42
0
    def setUp(self):
        self.chunk_0_schema = self.chunk_2_schema = Schema(None)
        self.chunk_1_schema = Schema(
            {
                'task': {
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'buildername':
                        'release-mozilla-beta_firefox_win32_l10n_repack',
                        'properties': {
                            'repo_path':
                            'releases/mozilla-beta',
                            'script_repo_revision':
                            'abcd',
                            'locales':
                            'de:default en-GB:default zh-TW:default',
                            'en_us_binary_url':
                            'https://queue.taskcluster.net/something/firefox.exe',
                        }
                    }
                }
            },
            extra=True,
            required=True)

        self.artifact_0_schema = self.artifact_2_schema = Schema(None)
        self.artifact_1_schema = Schema(
            {
                'task': {
                    'provisionerId': 'null-provisioner',
                    'workerType': 'buildbot',
                }
            },
            extra=True,
            required=True)

        test_arguments = create_firefox_test_args({
            'updates_enabled':
            True,
            'signing_pvt_key':
            PVT_KEY_FILE,
            'branch':
            "mozilla-beta",
            'repo_path':
            "releases/mozilla-beta",
            'release_channels': ["beta"],
            'final_verify_channels': ["beta"],
            'en_US_config': {
                "platforms": {
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                }
            },
        })

        self.graph = make_task_graph(**test_arguments)

        self.chunk_0 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_0")
        self.chunk_1 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1")
        self.chunk_2 = get_task_by_name(
            self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_2")

        self.artifact_0 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_0")
        self.artifact_1 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_1")
        self.artifact_2 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_2")
Exemple #43
0
    def setUp(self):
        test_kwargs = create_firefox_test_args({
            'updates_enabled':
            True,
            'push_to_candidates_enabled':
            True,
            'branch':
            'mozilla-beta',
            'repo_path':
            'releases/mozilla-beta',
            'signing_pvt_key':
            PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'enUS_platforms': ['win32'],
            'en_US_config': {
                "platforms": {
                    "win32": {
                        "task_id": "xyy"
                    }
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux64": {
                        "en_us_binary_url":
                        "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 1,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "ru": "default",
                    "uk": "default",
                    "zh-TW": "default",
                },
            },
            'partial_updates': {
                '38.0': {
                    'buildNumber': 1,
                    'locales': ['de', 'en-GB', 'ru', 'uk', 'zh-TW']
                },
                '37.0': {
                    'buildNumber': 2,
                    'locales': ['de', 'en-GB', 'ru', 'uk']
                }
            }
        })
        self.graph = make_task_graph(**test_kwargs)

        self.update_generator_37 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_1_37.0_update_generator"
        )
        self.update_generator_38 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_1_38.0_update_generator"
        )

        self.beetmover_candidates_37 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_partial_37.0build2_beetmover_candidates_1"
        )
        self.beetmover_candidates_38 = get_task_by_name(
            self.graph,
            "release-mozilla-beta_firefox_win32_l10n_repack_partial_38.0build1_beetmover_candidates_1"
        )
    def setUp(self):
        self.task_schema = Schema(
            {
                'task': {
                    'scopes': list,
                    'provisionerId': 'buildbot-bridge',
                    'workerType': 'buildbot-bridge',
                    'payload': {
                        'properties': {
                            'product':
                            'firefox',
                            '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_firefox_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':
            ["macosx64", "win32", "win64", "linux", "linux64"],
            'release_channels': ['foo'],
            'final_verify_channels': ['foo'],
            'en_US_config': {
                "platforms": {
                    "macosx64": {
                        "task_id": "abc"
                    },
                    "win32": {
                        "task_id": "def"
                    },
                    "win64": {
                        "task_id": "jgh"
                    },
                    "linux": {
                        "task_id": "ijk"
                    },
                    "linux64": {
                        "task_id": "lmn"
                    },
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)
        self.task = get_task_by_name(self.graph,
                                     "release-foo-firefox_uptake_monitoring")
        self.payload = self.task["task"]["payload"]
Exemple #45
0
 def setUp(self):
     self.notifications_schema = Schema(
         {
             'task': {
                 'extra': {
                     #  Notification section is either 'no notifications' or the below schema
                     'notifications':
                     Any(
                         Schema(
                             {
                                 Any(
                                     'task-completed',
                                     'task-exception',
                                     'task-failed',
                                 ): {
                                     'subject': str,
                                     'message': str,
                                 }
                             },
                             extra=True,
                             required=True), 'no notifications')
                 }
             }
         },
         required=True,
         extra=True)
     test_kwargs = create_firefox_test_args({
         'source_enabled':
         True,
         'updates_enabled':
         True,
         'bouncer_enabled':
         True,
         'checksums_enabled':
         True,
         'push_to_candidates_enabled':
         True,
         'push_to_releases_enabled':
         True,
         'push_to_releases_automatic':
         True,
         'postrelease_version_bump_enabled':
         True,
         'postrelease_mark_as_shipped_enabled':
         True,
         'postrelease_bouncer_aliases_enabled':
         True,
         'release_channels': ['foo'],
         'final_verify_channels': ['foo'],
         'signing_pvt_key':
         PVT_KEY_FILE,
         'en_US_config': {
             "platforms": {
                 "macosx64": {
                     "task_id": "abc"
                 },
                 "win32": {
                     "task_id": "def"
                 },
                 "win64": {
                     "task_id": "jgh"
                 },
                 "linux": {
                     "task_id": "ijk"
                 },
                 "linux64": {
                     "task_id": "lmn"
                 },
             }
         },
     })
     self.graph = make_task_graph(**test_kwargs)
Exemple #46
0
    def setUp(self):
        self.chunk_1_schema = Schema({
            'task': {
                'payload': {
                    'buildername': 'release-mozilla-beta_firefox_win32_l10n_repack',
                    'properties': {
                        'locales': 'de:default en-GB:default ru:default',
                        'en_us_binary_url': 'https://queue.taskcluster.net/something/firefox.exe',
                        'repo_path': 'releases/mozilla-beta',
                        'script_repo_revision': 'abcd',
                    }
                }
            }
        }, extra=True, required=True)

        self.chunk_2_schema = Schema({
            'task': {
                'payload': {
                    'buildername': 'release-mozilla-beta_firefox_win32_l10n_repack',
                    'properties': {
                        'en_us_binary_url': 'https://queue.taskcluster.net/something/firefox.exe',
                        'script_repo_revision': 'abcd',
                        'repo_path': 'releases/mozilla-beta',
                        'locales': 'uk:default zh-TW:default',
                    }
                }
            }
        }, extra=True, required=True)

        self.artifacts_1_schema = self.artifacts_2_schema = Schema(dict)  # Tasks must exist as a dict
        self.chunk_3_schema = self.artifacts_3_schema = Schema(None)  # Tasks must be None

        self.partials_schema = Schema(dict)

        test_kwargs = create_firefox_test_args({
            'updates_enabled': True,
            'repo_path': 'releases/mozilla-beta',
            'branch': 'mozilla-beta',
            'signing_pvt_key': PVT_KEY_FILE,
            'release_channels': ['beta'],
            'final_verify_channels': ['beta'],
            'en_US_platforms': ['win32'],
            'en_US_config': {
                "platforms": {
                    "win32": {"task_id": "xyy"}
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 2,
                    },
                    "linux64": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "ru", "uk", "zh-TW"],
                        "chunks": 2,
                    },
                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "ru": "default",
                    "uk": "default",
                    "zh-TW": "default",
                },
            },
        })
        self.graph = make_task_graph(**test_kwargs)

        self.chunk_1 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_1")
        self.chunk_2 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_2")
        self.chunk_3 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_3")

        self.artifacts_1 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_1")
        self.artifacts_2 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_2")
        self.artifacts_3 = get_task_by_name(self.graph, "release-mozilla-beta_firefox_win32_l10n_repack_artifacts_3")
    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',
                            'next_version': '42.0b3',
                        }
                    }
                }
            },
            extra=True,
            required=True)

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

        test_kwargs = create_firefox_test_args({
            '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": {
                    "macosx64": {},
                    "win32": {},
                    "win64": {},
                    "linux": {},
                    "linux64": {},
                }
            },
        })
        self.graph = make_task_graph(**test_kwargs)

        self.task = get_task_by_name(self.graph,
                                     "release-foo-firefox_mark_as_shipped")
        self.human_task = get_task_by_name(self.graph,
                                           "publish_release_human_decision")
    def setUp(self):
        # Task attributes common to each partner repack
        common_task_schema = Schema({
            'task': {
                'provisionerId': 'buildbot-bridge',
                'workerType': 'buildbot-bridge',
                'payload': {
                    'properties': {
                        'version': '42.0b2',
                        'build_number': 3,
                    }
                }
            }
        })

        self.partner_task_schema = common_task_schema.extend({
            'task': {
                'payload': {
                    'properties': {
                        'repack_manifests_url': '[email protected]:mozilla-partners/repack-manifests.git',
                    }
                }
            }
        }, required=True, extra=True)

        self.eme_free_task_schema = common_task_schema.extend({
            'task': {
                'payload': {
                    'properties': {
                        'repack_manifests_url': 'https://github.com/mozilla-partners/mozilla-EME-free-manifest',
                    }
                }
            }
        }, required=True, extra=True)

        self.sha1_task_schema = common_task_schema.extend({
            'task': {
                'payload': {
                    'properties': {
                        'repack_manifests_url': 'https://github.com/mozilla-partners/mozilla-sha1-manifest',
                    }
                }
            }
        }, required=True, extra=True)

        test_kwargs = create_firefox_test_args({
            'push_to_candidates_enabled': True,
            'push_to_releases_enabled': True,
            'push_to_releases_automatic': True,
            'source_enabled': True,
            'signing_pvt_key': PVT_KEY_FILE,
            'partner_repacks_platforms': ['win32', 'linux'],
            'release_channels': ['foo', 'bar'],
            'en_US_config': {
                "platforms": {
                    "linux": {"task_id": "xyz"},
                    "win32": {"task_id": "xyy"}
                }
            },
            'l10n_config': {
                "platforms": {
                    "win32": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.exe",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },
                    "linux": {
                        "en_us_binary_url": "https://queue.taskcluster.net/something/firefox.tar.xz",
                        "locales": ["de", "en-GB", "zh-TW"],
                        "chunks": 1,
                    },

                },
                "changesets": {
                    "de": "default",
                    "en-GB": "default",
                    "zh-TW": "default",
                },
            },
        })

        self.graph = make_task_graph(**test_kwargs)
        self.partner_tasks = [
            get_task_by_name(self.graph, "release-foo-firefox-{}_partner_repacks".format(platform))
            for platform in ["win32", "linux"]
        ]
        self.eme_free_tasks = [
            get_task_by_name(self.graph, "release-foo-firefox-{}_eme_free_repacks".format(platform))
            for platform in ["win32", "linux"]
        ]
        self.sha1_tasks = [
            get_task_by_name(self.graph, "release-foo-firefox-{}_sha1_repacks".format(platform))
            for platform in ["win32", "linux"]
        ]

        self.partner_push_to_mirrors_task = get_task_by_name(self.graph, "release-foo-firefox_partner_repacks_copy_to_releases")
        self.push_to_mirrors_task = get_task_by_name(self.graph, "release-foo_firefox_push_to_releases")

        self.upstream_dependencies = [
            "release-foo_firefox_{}_complete_en-US_beetmover_candidates".format(platform)
            for platform in ["win32", "linux"]
        ] + [
            "release-foo_firefox_{}_l10n_repack_beetmover_candidates_1".format(platform)
            for platform in ["win32", "linux"]
        ]