def test_basic(sentry_init, capture_events):
sentry_init(integrations=[RqIntegration()])
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(crashing_job, foo=42)
worker.work(burst=True)
(event, ) = events
(exception, ) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "rq"
assert exception["stacktrace"]["frames"][-1]["vars"]["foo"] == "42"
assert event["transaction"] == "tests.integrations.rq.test_rq.crashing_job"
assert event["extra"]["rq-job"] == {
"args": [],
"description": "tests.integrations.rq.test_rq.crashing_job(foo=42)",
"func": "tests.integrations.rq.test_rq.crashing_job",
"job_id": event["extra"]["rq-job"]["job_id"],
"kwargs": {
"foo": 42
},
}
def test_transaction_no_error(
sentry_init,
capture_events,
DictionaryContaining # noqa:N803
):
sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(do_trick, "Maisey", trick="kangaroo")
worker.work(burst=True)
envelope = events[0]
assert envelope["type"] == "transaction"
assert envelope["contexts"]["trace"]["op"] == "rq.task"
assert envelope["transaction"] == "tests.integrations.rq.test_rq.do_trick"
assert envelope["extra"]["rq-job"] == DictionaryContaining({
"args": ["Maisey"],
"kwargs": {
"trick": "kangaroo"
},
"func":
"tests.integrations.rq.test_rq.do_trick",
"description":
"tests.integrations.rq.test_rq.do_trick('Maisey', trick='kangaroo')",
})
def test_traces_sampler_gets_correct_values_in_sampling_context(
sentry_init,
DictionaryContaining,
ObjectDescribedBy # noqa:N803
):
traces_sampler = mock.Mock(return_value=True)
sentry_init(integrations=[RqIntegration()], traces_sampler=traces_sampler)
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(do_trick, "Bodhi", trick="roll over")
worker.work(burst=True)
traces_sampler.assert_any_call(
DictionaryContaining({
"rq_job":
ObjectDescribedBy(
type=rq.job.Job,
attrs={
"description":
"tests.integrations.rq.test_rq.do_trick('Bodhi', trick='roll over')",
"result": "Bodhi, can you roll over? Good dog!",
"func_name": "tests.integrations.rq.test_rq.do_trick",
"args": ("Bodhi", ),
"kwargs": {
"trick": "roll over"
},
},
),
}))
def test_sync_worker_multiple_jobs(queue):
jobs = []
for i in range(3):
jobs.append(queue.enqueue(job_add1, i))
worker = rq.SimpleWorker([queue], connection=queue.connection)
worker.work(burst=True)
assert [job.result for job in jobs] == [1, 2, 3]
def test_job_with_retries(sentry_init, capture_events):
sentry_init(integrations=[RqIntegration()])
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(crashing_job, foo=42, retry=rq.Retry(max=1))
worker.work(burst=True)
assert len(events) == 1
def test_transaction_with_error(
sentry_init,
capture_events,
DictionaryContaining # noqa:N803
):
sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(chew_up_shoes, "Charlie", "Katie", shoes="flip-flops")
worker.work(burst=True)
error_event, envelope = events
assert error_event[
"transaction"] == "tests.integrations.rq.test_rq.chew_up_shoes"
assert error_event["contexts"]["trace"]["op"] == "rq.task"
assert error_event["exception"]["values"][0]["type"] == "Exception"
assert (error_event["exception"]["values"][0]["value"] ==
"Charlie!! Why did you eat Katie's flip-flops??")
assert envelope["type"] == "transaction"
assert envelope["contexts"]["trace"] == error_event["contexts"]["trace"]
assert envelope["transaction"] == error_event["transaction"]
assert envelope["extra"]["rq-job"] == DictionaryContaining({
"args": ["Charlie", "Katie"],
"kwargs": {
"shoes": "flip-flops"
},
"func":
"tests.integrations.rq.test_rq.chew_up_shoes",
"description":
"tests.integrations.rq.test_rq.chew_up_shoes('Charlie', 'Katie', shoes='flip-flops')",
})
def test_sync_worker_config_service(queue):
job = queue.enqueue(job_add1, 10)
with override_config("rq_worker", dict(service="my-worker-svc")):
worker = rq.SimpleWorker([queue], connection=queue.connection)
worker.work(burst=True)
assert job.result == 11
def test_sync_worker(queue):
job = queue.enqueue(job_add1, 1)
worker = rq.SimpleWorker([queue], connection=queue.connection)
worker.work(burst=True)
assert job.result == 2
def test_worker_class_job(queue):
queue.enqueue(JobClass().job_on_class, 2)
queue.enqueue(JobClass(), 4)
worker = rq.SimpleWorker([queue], connection=queue.connection)
worker.work(burst=True)
def test_worker_failing_job(queue):
queue.enqueue(job_fail)
worker = rq.SimpleWorker([queue], connection=queue.connection)
worker.work(burst=True)
def test_sync_worker_pin_service(queue):
job = queue.enqueue(job_add1, 10)
worker = rq.SimpleWorker([queue], connection=queue.connection)
Pin.override(worker, service="my-pin-svc")
worker.work(burst=True)
assert job.result == 11
def setUp(self):
super(TestEngineScenario, self).setUp()
self.cassette_library_dir = os.path.join(CASSETTE_LIBRARY_DIR_BASE,
self._testMethodName)
if RECORD_MODE != "none":
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=RECORD_MODE,
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: GitterRecorder(self.cassette_library_dir)))
self.useFixture(
fixtures.MockPatchObject(
backports.utils, 'Gitter',
lambda: GitterRecorder(self.cassette_library_dir)))
# Web authentification always pass
self.useFixture(
fixtures.MockPatch('hmac.compare_digest', return_value=True))
reponame_path = os.path.join(self.cassette_library_dir, "reponame")
gen_new_uuid = (RECORD_MODE == 'all'
or (RECORD_MODE == 'once'
and not os.path.exists(reponame_path)))
if gen_new_uuid:
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.pr_counter = 0
self.remaining_events = []
utils.setup_logging()
config.log()
self.git = GitterRecorder(self.cassette_library_dir, "tests")
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()
subscription = {"token": config.MAIN_TOKEN, "subscribed": False}
self.redis.set("subscription-cache-%s" % config.INSTALLATION_ID,
json.dumps(subscription))
# Let's start recording
cassette = self.recorder.use_cassette("http.json")
cassette.__enter__()
self.addCleanup(cassette.__exit__)
self.session = requests.Session()
self.session.trust_env = False
# Cleanup the remote testing redis
r = self.session.delete(
"https://gh.mergify.io/events-testing",
data=FAKE_DATA,
headers={"X-Hub-Signature": "sha1=" + FAKE_HMAC})
r.raise_for_status()
self.g_main = github.Github(config.MAIN_TOKEN)
self.g_fork = github.Github(config.FORK_TOKEN)
self.u_main = self.g_main.get_user()
self.u_fork = self.g_fork.get_user()
assert self.u_main.login == "mergify-test1"
assert self.u_fork.login == "mergify-test2"
self.r_main = self.u_main.create_repo(self.name)
self.url_main = "https://github.com/%s" % self.r_main.full_name
self.url_fork = "https://github.com/%s/%s" % (self.u_fork.login,
self.r_main.name)
integration = github.GithubIntegration(config.INTEGRATION_ID,
config.PRIVATE_KEY)
access_token = integration.get_access_token(
config.INSTALLATION_ID).token
g = github.Github(access_token)
user = g.get_user("mergify-test1")
repo = user.get_repo(self.name)
# Used to access the cache with its helper
self.engine = engine.MergifyEngine(g, config.INSTALLATION_ID,
access_token, subscription, user,
repo)
self.processor = self.engine.get_processor()
self.rq_worker = rq.SimpleWorker([
"incoming-events", "localhost-000-high", "localhost-001-high",
"localhost-000-low", "localhost-001-low"
],
connection=utils.get_redis_for_rq())
if self._testMethodName != "test_creation_pull_of_initial_config":
self.git("init")
self.git.configure()
self.git.add_cred(config.MAIN_TOKEN, "", self.r_main.full_name)
self.git.add_cred(config.FORK_TOKEN, "",
"%s/%s" % (self.u_fork.login, self.r_main.name))
self.git("config", "user.name", "%s-tester" % config.CONTEXT)
self.git("remote", "add", "main", self.url_main)
self.git("remote", "add", "fork", self.url_fork)
with open(self.git.tmp + "/.mergify.yml", "w") as f:
f.write(CONFIG)
self.git("add", ".mergify.yml")
self.git("commit", "--no-edit", "-m", "initial commit")
self.git("push", "--quiet", "main", "master")
self.git("checkout", "-b", "stable", "--quiet")
self.git("push", "--quiet", "main", "stable")
self.git("checkout", "-b", "nostrict", "--quiet")
self.git("push", "--quiet", "main", "nostrict")
self.git("checkout", "-b", "disabled", "--quiet")
self.git("push", "--quiet", "main", "disabled")
self.git("checkout", "-b", "enabling_label", "--quiet")
self.git("push", "--quiet", "main", "enabling_label")
self.r_fork = self.u_fork.create_fork(self.r_main)
self.git("fetch", "--quiet", "fork")
# NOTE(sileht): Github looks buggy here:
# We receive for the new repo the expected events:
# * installation_repositories
# * integration_installation_repositories
# but we receive them 6 times with the same sha1...
self.push_events([(None, {"action": "added"})] * 12)
def setUp(self):
super(TestEngineScenario, self).setUp()
self.session = requests.Session()
self.session.trust_env = False
self.recorder = betamax.Betamax(self.session)
self.useFixture(
fixtures.MockPatchObject(requests,
'Session',
return_value=self.session))
self.useFixture(
fixtures.MockPatchObject(
gh_update_branch.utils, 'Gitter',
lambda: GitterRecorder(self._testMethodName)))
# Web authentification always pass
self.useFixture(
fixtures.MockPatch('hmac.compare_digest', return_value=True))
reponame_path = (
"mergify_engine/tests/fixtures/cassettes/reponame_%s" %
self._testMethodName)
gen_new_uuid = (RECORD_MODE == 'all'
or (RECORD_MODE == 'once'
and not os.path.exists(reponame_path)))
if gen_new_uuid:
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.cassette_counter = 0
self.events_handler_counter = 0
self.events_getter_counter = 0
self.status_counter = 0
self.reviews_counter = 0
self.pr_counter = 0
self.last_event_id = None
utils.setup_logging()
config.log()
self.git = GitterRecorder('%s-tests' % self._testMethodName)
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()
self.redis.flushall()
self.redis.set("installation-token-%s" % INSTALLATION_ID, MAIN_TOKEN)
with self.cassette("setUp-prepare-repo", allow_playback_repeats=True):
# Cleanup the remote testing redis
r = self.session.delete("https://gh.mergify.io/events-testing")
r.raise_for_status()
self.g_main = github.Github(MAIN_TOKEN)
self.g_fork = github.Github(FORK_TOKEN)
self.u_main = self.g_main.get_user()
self.u_fork = self.g_fork.get_user()
assert self.u_main.login == "mergify-test1"
assert self.u_fork.login == "mergify-test2"
self.r_main = self.u_main.create_repo(self.name)
self.url_main = "https://%s:@github.com/%s" % (
MAIN_TOKEN, self.r_main.full_name)
self.git("init")
self.git("config", "user.name", "%s-bot" % config.CONTEXT)
self.git("config", "user.email", "*****@*****.**")
self.git("remote", "add", "main", self.url_main)
with open(self.git.tmp + "/.mergify.yml", "w") as f:
f.write(CONFIG)
self.git("add", ".mergify.yml")
self.git("commit", "--no-edit", "-m", "initial commit")
self.git("push", "main", "master")
self.git("checkout", "-b", "stable")
self.git("push", "main", "stable")
self.git("checkout", "-b", "nostrict")
self.git("push", "main", "nostrict")
self.r_fork = self.u_fork.create_fork(self.r_main)
self.url_fork = "https://%s:@github.com/%s" % (
FORK_TOKEN, self.r_fork.full_name)
self.git("remote", "add", "fork", self.url_fork)
self.git("fetch", "fork")
with self.cassette("setUp-login-engine", allow_playback_repeats=True):
g = github.Github(ACCESS_TOKEN)
user = g.get_user("mergify-test1")
repo = user.get_repo(self.name)
with self.cassette("setUp-create-engine", allow_playback_repeats=True):
self.engine = engine.MergifyEngine(g, INSTALLATION_ID, user, repo)
self.useFixture(
fixtures.MockPatchObject(worker, 'real_event_handler',
self.engine.handle))
queue = rq.Queue(connection=self.redis)
self.rq_worker = rq.SimpleWorker([queue], connection=queue.connection)
# NOTE(sileht): Github looks buggy here:
# We receive for the new repo the expected events:
# * installation_repositories
# * integration_installation_repositories
# but we receive them 6 times with the same sha1...
self.push_events(12)
