def subscription_cache_update(installation_id): # pragma: no cover
authentification()
r = utils.get_redis_for_cache()
sub = flask.request.get_json()
if sub is None:
return "Empty content", 400
sub_utils.save_subscription_to_cache(r, installation_id, sub)
return "Cache updated", 200
def setUp(self):
super(FunctionalTestBase, self).setUp()
self.existing_labels = []
self.pr_counter = 0
self.git_counter = 0
self.cassette_library_dir = os.path.join(CASSETTE_LIBRARY_DIR_BASE,
self.__class__.__name__,
self._testMethodName)
# Recording stuffs
if RECORD:
if os.path.exists(self.cassette_library_dir):
shutil.rmtree(self.cassette_library_dir)
os.makedirs(self.cassette_library_dir)
self.recorder = vcr.VCR(
cassette_library_dir=self.cassette_library_dir,
record_mode="all" if RECORD else "none",
match_on=["method", "uri"],
filter_headers=[
("Authorization", "<TOKEN>"),
("X-Hub-Signature", "<SIGNATURE>"),
("User-Agent", None),
("Accept-Encoding", None),
("Connection", None),
],
before_record_response=self.response_filter,
custom_patches=((pygithub.MainClass, "HTTPSConnection",
vcr.stubs.VCRHTTPSConnection), ),
)
if RECORD:
github.CachedToken.STORAGE = {}
else:
# Never expire token during replay
mock.patch.object(github_app,
"get_or_create_jwt",
return_value="<TOKEN>").start()
mock.patch.object(
github.GithubAppInstallationAuth,
"get_access_token",
return_value="<TOKEN>",
).start()
# NOTE(sileht): httpx pyvcr stubs does not replay auth_flow as it directly patch client.send()
# So anything occurring during auth_flow have to be mocked during replay
def get_auth(owner=None, repo=None, auth=None):
if auth is None:
auth = github.get_auth(owner, repo)
auth.installation = {
"id": config.INSTALLATION_ID,
}
auth.permissions_need_to_be_updated = False
auth.owner_id = config.TESTING_ORGANIZATION_ID
return auth
async def github_aclient(owner=None, repo=None, auth=None):
return github.AsyncGithubInstallationClient(
get_auth(owner, repo, auth))
def github_client(owner=None, repo=None, auth=None):
return github.GithubInstallationClient(
get_auth(owner, repo, auth))
mock.patch.object(github, "get_client", github_client).start()
mock.patch.object(github, "aget_client", github_aclient).start()
with open(engine.mergify_rule_path, "r") as f:
engine.MERGIFY_RULE = yaml.safe_load(f.read().replace(
"mergify[bot]", "mergify-test[bot]"))
mock.patch.object(branch_updater.utils, "Gitter",
self.get_gitter).start()
mock.patch.object(duplicate_pull.utils, "Gitter",
self.get_gitter).start()
if not RECORD:
# NOTE(sileht): Don't wait exponentialy during replay
mock.patch.object(context.Context._ensure_complete.retry, "wait",
None).start()
# Web authentification always pass
mock.patch("hmac.compare_digest", return_value=True).start()
branch_prefix_path = os.path.join(self.cassette_library_dir,
"branch_prefix")
if RECORD:
self.BRANCH_PREFIX = datetime.datetime.utcnow().strftime(
"%Y%m%d%H%M%S")
with open(branch_prefix_path, "w") as f:
f.write(self.BRANCH_PREFIX)
else:
with open(branch_prefix_path, "r") as f:
self.BRANCH_PREFIX = f.read()
self.master_branch_name = self.get_full_branch_name("master")
self.git = self.get_gitter(LOG)
self.addCleanup(self.git.cleanup)
loop = asyncio.get_event_loop()
loop.run_until_complete(web.startup())
self.app = testclient.TestClient(web.app)
# NOTE(sileht): Prepare a fresh redis
self.redis = utils.get_redis_for_cache()
self.redis.flushall()
self.subscription = {
"tokens": {
"mergify-test-1": config.ORG_ADMIN_GITHUB_APP_OAUTH_TOKEN
},
"subscription_active": self.SUBSCRIPTION_ACTIVE,
"subscription_reason": "You're not nice",
}
loop = asyncio.get_event_loop()
loop.run_until_complete(
sub_utils.save_subscription_to_cache(
config.INSTALLATION_ID,
self.subscription,
))
# Let's start recording
cassette = self.recorder.use_cassette("http.json")
cassette.__enter__()
self.addCleanup(cassette.__exit__)
integration = pygithub.GithubIntegration(config.INTEGRATION_ID,
config.PRIVATE_KEY)
self.installation_token = integration.get_access_token(
config.INSTALLATION_ID).token
base_url = config.GITHUB_API_URL
self.g_integration = pygithub.Github(self.installation_token,
base_url=base_url)
self.g_admin = pygithub.Github(config.ORG_ADMIN_PERSONAL_TOKEN,
base_url=base_url)
self.g_fork = pygithub.Github(self.FORK_PERSONAL_TOKEN,
base_url=base_url)
self.o_admin = self.g_admin.get_organization(
config.TESTING_ORGANIZATION)
self.o_integration = self.g_integration.get_organization(
config.TESTING_ORGANIZATION)
self.u_fork = self.g_fork.get_user()
assert self.o_admin.login == "mergifyio-testing"
assert self.o_integration.login == "mergifyio-testing"
assert self.u_fork.login in ["mergify-test2", "mergify-test3"]
self.r_o_admin = self.o_admin.get_repo(self.REPO_NAME)
self.r_o_integration = self.o_integration.get_repo(self.REPO_NAME)
self.r_fork = self.u_fork.get_repo(self.REPO_NAME)
self.url_main = f"{config.GITHUB_URL}/{self.r_o_integration.full_name}"
self.url_fork = (
f"{config.GITHUB_URL}/{self.u_fork.login}/{self.r_o_integration.name}"
)
self.cli_integration = github.get_client(
config.TESTING_ORGANIZATION,
self.REPO_NAME,
)
real_get_subscription = sub_utils.get_subscription
async def fake_retrieve_subscription_from_db(owner_id):
if owner_id == config.TESTING_ORGANIZATION_ID:
return self.subscription
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
async def fake_subscription(owner_id):
if owner_id == config.TESTING_ORGANIZATION_ID:
return await real_get_subscription(owner_id)
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
mock.patch(
"mergify_engine.branch_updater.sub_utils.get_subscription",
side_effect=fake_subscription,
).start()
mock.patch(
"mergify_engine.branch_updater.sub_utils._retrieve_subscription_from_db",
side_effect=fake_retrieve_subscription_from_db,
).start()
mock.patch(
"mergify_engine.sub_utils.get_subscription",
side_effect=fake_subscription,
).start()
mock.patch(
"github.MainClass.Installation.Installation.get_repos",
return_value=[self.r_o_integration],
).start()
self._event_reader = EventReader(self.app)
self._event_reader.drain()
def setUp(self):
super(FunctionalTestBase, self).setUp()
self.pr_counter = 0
self.git_counter = 0
self.cassette_library_dir = os.path.join(CASSETTE_LIBRARY_DIR_BASE,
self._testMethodName)
# Recording stuffs
if RECORD:
if os.path.exists(self.cassette_library_dir):
shutil.rmtree(self.cassette_library_dir)
os.makedirs(self.cassette_library_dir)
self.recorder = vcr.VCR(
cassette_library_dir=self.cassette_library_dir,
record_mode="all" if RECORD else "none",
match_on=["method", "uri"],
filter_headers=[
("Authorization", "<TOKEN>"),
("X-Hub-Signature", "<SIGNATURE>"),
("User-Agent", None),
("Accept-Encoding", None),
("Connection", None),
],
before_record_response=self.response_filter,
custom_patches=((github.MainClass, "HTTPSConnection",
vcr.stubs.VCRHTTPSConnection), ),
)
self.useFixture(
fixtures.MockPatchObject(branch_updater.utils, "Gitter",
lambda: self.get_gitter()))
self.useFixture(
fixtures.MockPatchObject(duplicate_pull.utils, "Gitter",
lambda: self.get_gitter()))
# Web authentification always pass
self.useFixture(
fixtures.MockPatch("hmac.compare_digest", return_value=True))
reponame_path = os.path.join(self.cassette_library_dir, "reponame")
if RECORD:
REPO_UUID = str(uuid.uuid4())
with open(reponame_path, "w") as f:
f.write(REPO_UUID)
else:
with open(reponame_path, "r") as f:
REPO_UUID = f.read()
self.name = "repo-%s-%s" % (REPO_UUID, self._testMethodName)
self.git = self.get_gitter()
self.addCleanup(self.git.cleanup)
web.app.testing = True
self.app = web.app.test_client()
# NOTE(sileht): Prepare a fresh redis
self.redis = utils.get_redis_for_cache()
self.redis.flushall()
self.subscription = {
"tokens": {
"mergifyio-testing": config.MAIN_TOKEN
},
"subscription_active": False,
"subscription_cost": 100,
"subscription_reason": "You're not nice",
}
sub_utils.save_subscription_to_cache(
self.redis,
config.INSTALLATION_ID,
self.subscription,
)
# Let's start recording
cassette = self.recorder.use_cassette("http.json")
cassette.__enter__()
self.addCleanup(cassette.__exit__)
integration = github.GithubIntegration(config.INTEGRATION_ID,
config.PRIVATE_KEY)
self.installation_token = integration.get_access_token(
config.INSTALLATION_ID).token
self.g_integration = github.Github(self.installation_token,
base_url="https://api.%s" %
config.GITHUB_DOMAIN)
self.g_admin = github.Github(config.MAIN_TOKEN,
base_url="https://api.%s" %
config.GITHUB_DOMAIN)
self.g_fork = github.Github(config.FORK_TOKEN,
base_url="https://api.%s" %
config.GITHUB_DOMAIN)
self.o_admin = self.g_admin.get_organization(
config.TESTING_ORGANIZATION)
self.o_integration = self.g_integration.get_organization(
config.TESTING_ORGANIZATION)
self.u_fork = self.g_fork.get_user()
assert self.o_admin.login == "mergifyio-testing"
assert self.o_integration.login == "mergifyio-testing"
assert self.u_fork.login == "mergify-test2"
self.r_o_admin = self.o_admin.create_repo(self.name)
self.r_o_integration = self.o_integration.get_repo(self.name)
self.url_main = "https://%s/%s" % (
config.GITHUB_DOMAIN,
self.r_o_integration.full_name,
)
self.url_fork = "https://%s/%s/%s" % (
config.GITHUB_DOMAIN,
self.u_fork.login,
self.r_o_integration.name,
)
# Limit installations/subscription API to the test account
install = {
"id": config.INSTALLATION_ID,
"target_type": "Org",
"account": {
"login": "******"
},
}
self.useFixture(
fixtures.MockPatch("mergify_engine.utils.get_installations",
lambda integration: [install]))
real_get_subscription = sub_utils.get_subscription
def fake_retrieve_subscription_from_db(install_id):
if int(install_id) == config.INSTALLATION_ID:
return self.subscription
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
def fake_subscription(r, install_id):
if int(install_id) == config.INSTALLATION_ID:
return real_get_subscription(r, install_id)
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
self.useFixture(
fixtures.MockPatch(
"mergify_engine.branch_updater.sub_utils.get_subscription",
side_effect=fake_subscription,
))
self.useFixture(
fixtures.MockPatch(
"mergify_engine.branch_updater.sub_utils._retrieve_subscription_from_db",
side_effect=fake_retrieve_subscription_from_db,
))
self.useFixture(
fixtures.MockPatch(
"mergify_engine.sub_utils.get_subscription",
side_effect=fake_subscription,
))
self.useFixture(
fixtures.MockPatch(
"github.MainClass.Installation.Installation.get_repos",
return_value=[self.r_o_integration],
))
self._event_reader = EventReader(self.app)
self._event_reader.drain()
def setUp(self):
super(FunctionalTestBase, self).setUp()
self.pr_counter = 0
self.git_counter = 0
self.cassette_library_dir = os.path.join(
CASSETTE_LIBRARY_DIR_BASE, self.__class__.__name__, self._testMethodName
)
# Recording stuffs
if RECORD:
if os.path.exists(self.cassette_library_dir):
shutil.rmtree(self.cassette_library_dir)
os.makedirs(self.cassette_library_dir)
self.recorder = vcr.VCR(
cassette_library_dir=self.cassette_library_dir,
record_mode="all" if RECORD else "none",
match_on=["method", "uri"],
filter_headers=[
("Authorization", "<TOKEN>"),
("X-Hub-Signature", "<SIGNATURE>"),
("User-Agent", None),
("Accept-Encoding", None),
("Connection", None),
],
before_record_response=self.response_filter,
custom_patches=(
(pygithub.MainClass, "HTTPSConnection", vcr.stubs.VCRHTTPSConnection),
),
)
if RECORD:
github.CachedToken.STORAGE = {}
else:
# Never expire token during replay
mock.patch.object(
github_app.GithubBearerAuth, "get_or_create_jwt", return_value="<TOKEN>"
).start()
mock.patch.object(
github.GithubInstallationAuth,
"get_access_token",
return_value="<TOKEN>",
).start()
github.CachedToken.STORAGE = {}
github.CachedToken(
installation_id=config.INSTALLATION_ID,
token="<TOKEN>",
expiration=datetime.datetime.utcnow() + datetime.timedelta(minutes=10),
)
github_app_client = github_app._Client()
mock.patch.object(github_app, "get_client", lambda: github_app_client).start()
mock.patch.object(branch_updater.utils, "Gitter", self.get_gitter).start()
mock.patch.object(duplicate_pull.utils, "Gitter", self.get_gitter).start()
if not RECORD:
# NOTE(sileht): Don't wait exponentialy during replay
mock.patch.object(
context.Context._ensure_complete.retry, "wait", None
).start()
# Web authentification always pass
mock.patch("hmac.compare_digest", return_value=True).start()
branch_prefix_path = os.path.join(self.cassette_library_dir, "branch_prefix")
if RECORD:
self.BRANCH_PREFIX = datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S")
with open(branch_prefix_path, "w") as f:
f.write(self.BRANCH_PREFIX)
else:
with open(branch_prefix_path, "r") as f:
self.BRANCH_PREFIX = f.read()
self.master_branch_name = self.get_full_branch_name("master")
self.git = self.get_gitter(LOG)
self.addCleanup(self.git.cleanup)
self.app = testclient.TestClient(web.app)
# NOTE(sileht): Prepare a fresh redis
self.redis = utils.get_redis_for_cache()
self.redis.flushall()
self.subscription = {
"tokens": {"mergifyio-testing": config.MAIN_TOKEN},
"subscription_active": False,
"subscription_reason": "You're not nice",
}
loop = asyncio.get_event_loop()
loop.run_until_complete(
sub_utils.save_subscription_to_cache(
config.INSTALLATION_ID, self.subscription,
)
)
# Let's start recording
cassette = self.recorder.use_cassette("http.json")
cassette.__enter__()
self.addCleanup(cassette.__exit__)
integration = pygithub.GithubIntegration(
config.INTEGRATION_ID, config.PRIVATE_KEY
)
self.installation_token = integration.get_access_token(
config.INSTALLATION_ID
).token
base_url = config.GITHUB_API_URL
self.g_integration = pygithub.Github(self.installation_token, base_url=base_url)
self.g_admin = pygithub.Github(config.MAIN_TOKEN, base_url=base_url)
self.g_fork = pygithub.Github(config.FORK_TOKEN, base_url=base_url)
self.o_admin = self.g_admin.get_organization(config.TESTING_ORGANIZATION)
self.o_integration = self.g_integration.get_organization(
config.TESTING_ORGANIZATION
)
self.u_fork = self.g_fork.get_user()
assert self.o_admin.login == "mergifyio-testing"
assert self.o_integration.login == "mergifyio-testing"
assert self.u_fork.login == "mergify-test2"
# NOTE(sileht): The repository have been manually created in mergifyio-testing
# organization and then forked in mergify-test2 user account
self.name = "functional-testing-repo"
self.r_o_admin = self.o_admin.get_repo(self.name)
self.r_o_integration = self.o_integration.get_repo(self.name)
self.r_fork = self.u_fork.get_repo(self.name)
self.url_main = f"{config.GITHUB_URL}/{self.r_o_integration.full_name}"
self.url_fork = (
f"{config.GITHUB_URL}/{self.u_fork.login}/{self.r_o_integration.name}"
)
installation = {"id": config.INSTALLATION_ID}
self.cli_integration = github.get_client(
config.TESTING_ORGANIZATION, self.name, installation
)
real_get_subscription = sub_utils.get_subscription
def fake_retrieve_subscription_from_db(install_id):
if int(install_id) == config.INSTALLATION_ID:
return self.subscription
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
def fake_subscription(r, install_id):
if int(install_id) == config.INSTALLATION_ID:
return real_get_subscription(r, install_id)
else:
return {
"tokens": {},
"subscription_active": False,
"subscription_reason": "We're just testing",
}
mock.patch(
"mergify_engine.branch_updater.sub_utils.get_subscription",
side_effect=fake_subscription,
).start()
mock.patch(
"mergify_engine.branch_updater.sub_utils._retrieve_subscription_from_db",
side_effect=fake_retrieve_subscription_from_db,
).start()
mock.patch(
"mergify_engine.sub_utils.get_subscription", side_effect=fake_subscription,
).start()
mock.patch(
"github.MainClass.Installation.Installation.get_repos",
return_value=[self.r_o_integration],
).start()
self._event_reader = EventReader(self.app)
self._event_reader.drain()
self._worker_thread = WorkerThread()
self._worker_thread.start()