def test_ticking_time_clock():
with freeze_time('2012-01-14 03:21:34', tick=True):
first = time.clock()
time.sleep(0.001) # Deal with potential clock resolution problems
with freeze_time('2012-01-14 03:21:35', tick=True):
second = time.clock()
time.sleep(0.001) # Deal with potential clock resolution problems
with freeze_time('2012-01-14 03:21:36', tick=True):
third = time.clock()
time.sleep(0.001)
# Rewind time backwards
with freeze_time('2012-01-14 03:20:00', tick=True):
fourth = time.clock()
time.sleep(0.001)
fifth = time.clock()
assert first > 0
assert second > first
assert second > 1
assert third > second
assert third > 2
assert third > fourth
assert second > fourth
assert first > fourth
assert fifth > fourth
def test_workflow_execution_start_to_close_timeout():
pass
with freeze_time("2015-01-01 12:00:00"):
conn = setup_workflow()
with freeze_time("2015-01-01 13:59:30"):
resp = conn.get_workflow_execution_history("test-domain", conn.run_id, "uid-abcd1234")
event_types = [evt["eventType"] for evt in resp["events"]]
event_types.should.equal(
["WorkflowExecutionStarted", "DecisionTaskScheduled"]
)
with freeze_time("2015-01-01 14:00:30"):
# => Workflow Execution Start to Close timeout reached!!
resp = conn.get_workflow_execution_history("test-domain", conn.run_id, "uid-abcd1234")
event_types = [evt["eventType"] for evt in resp["events"]]
event_types.should.equal(
["WorkflowExecutionStarted", "DecisionTaskScheduled", "WorkflowExecutionTimedOut"]
)
attrs = resp["events"][-1]["workflowExecutionTimedOutEventAttributes"]
attrs.should.equal({
"childPolicy": "ABANDON", "timeoutType": "START_TO_CLOSE"
})
# checks that event has been emitted at 14:00:00, not 14:00:30
resp["events"][-1]["eventTimestamp"].should.equal(1420120800.0)
def test_blacklist(self):
"""Test that users can only sign up if they are not blacklisted"""
t_open = datetime(2016, 1, 1)
t_close = datetime(2016, 12, 31)
ev = self.new_object("events", spots=100)
user1 = self.new_object("users")
user2 = self.new_object("users")
user1_token = self.get_user_token(user1['_id'])
user2_token = self.get_user_token(user1['_id'])
self.new_object("blacklist", user=user1['_id'],
start_time=t_open, end_time=t_close)
self.new_object("blacklist", user=user2['_id'],
start_time=t_open)
with freeze_time(datetime(2016, 6, 1)):
self.api.post('eventsignups', data={'user': str(user1['_id']),
'event': str(ev['_id'])}, token=user1_token,
status_code=422)
with freeze_time(datetime(2017, 6, 1)):
self.api.post('eventsignups', data={'user': str(user1['_id']),
'event': str(ev['_id'])}, token=user1_token,
status_code=201)
with freeze_time(datetime(2017, 6, 1)):
self.api.post('eventsignups', data={'user': str(user2['_id']),
'event': str(ev['_id'])}, token=user2_token,
status_code=422)
def test_pypy_compat():
try:
freeze_time("Jan 14th, 2012, 23:59:59", tick=True)
except SystemError:
pass
else:
raise AssertionError("tick=True should error on non-CPython")
def test_decision_task_start_to_close_timeout():
pass
with freeze_time("2015-01-01 12:00:00"):
conn = setup_workflow()
conn.poll_for_decision_task("test-domain", "queue")["taskToken"]
with freeze_time("2015-01-01 12:04:30"):
resp = conn.get_workflow_execution_history("test-domain", conn.run_id, "uid-abcd1234")
event_types = [evt["eventType"] for evt in resp["events"]]
event_types.should.equal(
["WorkflowExecutionStarted", "DecisionTaskScheduled", "DecisionTaskStarted"]
)
with freeze_time("2015-01-01 12:05:30"):
# => Decision Task Start to Close timeout reached!!
resp = conn.get_workflow_execution_history("test-domain", conn.run_id, "uid-abcd1234")
event_types = [evt["eventType"] for evt in resp["events"]]
event_types.should.equal(
["WorkflowExecutionStarted", "DecisionTaskScheduled", "DecisionTaskStarted",
"DecisionTaskTimedOut", "DecisionTaskScheduled"]
)
attrs = resp["events"][-2]["decisionTaskTimedOutEventAttributes"]
attrs.should.equal({
"scheduledEventId": 2, "startedEventId": 3, "timeoutType": "START_TO_CLOSE"
})
# checks that event has been emitted at 12:05:00, not 12:05:30
resp["events"][-2]["eventTimestamp"].should.equal(1420113900.0)
def test_one_time_wf_activate(self):
def get_person(person_id):
return db.session.query(Person).filter(Person.id == person_id).one()
with freeze_time("2015-04-10"):
_, wf = self.wf_generator.generate_workflow(self.one_time_workflow_1)
_, cycle = self.wf_generator.generate_cycle(wf)
self.wf_generator.activate_workflow(wf)
person_2 = get_person(self.random_people[2].id)
with freeze_time("2015-04-11"):
_, notif_data = common.get_daily_notifications()
self.assertIn(person_2.email, notif_data)
self.assertIn("cycle_started", notif_data[person_2.email])
self.assertIn(cycle.id, notif_data[person_2.email]["cycle_started"])
self.assertIn("my_tasks",
notif_data[person_2.email]["cycle_data"][cycle.id])
person_1 = get_person(self.random_people[0].id)
with freeze_time("2015-05-03"): # two days befor due date
_, notif_data = common.get_daily_notifications()
self.assertIn(person_1.email, notif_data)
self.assertNotIn("due_in", notif_data[person_1.email])
self.assertNotIn("due_today", notif_data[person_1.email])
with freeze_time("2015-05-04"): # one day befor due date
_, notif_data = common.get_daily_notifications()
self.assertEqual(len(notif_data[person_1.email]["due_in"]), 1)
with freeze_time("2015-05-05"): # due date
_, notif_data = common.get_daily_notifications()
self.assertEqual(len(notif_data[person_1.email]["due_today"]), 1)
def _soft_delete_audits(self):
with freezegun.freeze_time(self.FAKE_TODAY):
self.dbapi.soft_delete_audit(self.audit1.uuid)
with freezegun.freeze_time(self.FAKE_OLD_DATE):
self.dbapi.soft_delete_audit(self.audit2.uuid)
with freezegun.freeze_time(self.FAKE_OLDER_DATE):
self.dbapi.soft_delete_audit(self.audit3.uuid)
def test_bad_time_argument():
try:
freeze_time("2012-13-14", tz_offset=-4)
except ValueError:
pass
else:
assert False, "Bad values should raise a ValueError"
def test_invalid_type():
try:
freeze_time(int(4))
except TypeError:
pass
else:
assert False, "Bad types should raise a TypeError"
def test_prefill_entries_add_to_bottom(self):
config = self.default_config.copy()
tmp_entries_dir = tempfile.mkdtemp()
os.remove(self.entries_file)
self.entries_file = os.path.join(tmp_entries_dir, '%m_%Y.txt')
config['default']['file'] = self.entries_file
with freeze_time('2014-01-21'):
self.write_entries("""20/01/2014
alias_1 2 hello world
21/01/2014
alias_1 1 foo bar
""")
with freeze_time('2014-02-21'):
self.write_entries("""20/02/2014
alias_1 2 hello world
""")
self.run_command('edit', config_options=config)
with open(expand_date(self.entries_file), 'r') as f:
lines = f.readlines()
self.assertEqual('20/02/2014\n', lines[0])
self.assertEqual('21/02/2014\n', lines[3])
def test_previous_file_doesnt_autofill(self):
config = self.default_config.copy()
tmp_entries_dir = tempfile.mkdtemp()
os.remove(self.entries_file)
self.entries_file = os.path.join(tmp_entries_dir, '%m_%Y.txt')
config['default']['file'] = self.entries_file
with freeze_time('2014-01-21'):
self.write_entries("""20/01/2014
alias_1 2 hello world
21/01/2014
alias_1 1 foo bar
""")
with freeze_time('2014-02-21'):
self.write_entries("""20/02/2014
alias_1 2 hello world
""")
self.run_command('edit', args=['1'], config_options=config)
with freeze_time('2014-01-21'):
with open(expand_date(self.entries_file), 'r') as f:
lines = f.readlines()
self.assertNotIn('21/02/2014\n', lines)
def test_commit_previous_file_previous_month(self):
tmp_entries_dir = tempfile.mkdtemp()
config = self.default_config.copy()
os.remove(self.entries_file)
self.entries_file = os.path.join(tmp_entries_dir, '%m_%Y.txt')
config['default']['file'] = self.entries_file
with freeze_time('2014-01-01'):
self.write_entries("""01/01/2014
alias_1 2 january
""")
with freeze_time('2014-02-01'):
self.write_entries("""01/02/2014
alias_1 4 february
""")
options = self.default_options.copy()
options['ignore_date_error'] = True
stdout = self.run_command('commit', config_options=config,
options=options)
shutil.rmtree(tmp_entries_dir)
self.assertIn('january', stdout)
self.assertIn('february', stdout)
def test_soft_fail_with_reschedule(self):
sensor = self._make_sensor(
return_value=False,
poke_interval=10,
timeout=5,
soft_fail=True,
mode='reschedule')
dr = self._make_dag_run()
# first poke returns False and task is re-scheduled
date1 = timezone.utcnow()
with freeze_time(date1):
self._run(sensor)
tis = dr.get_task_instances()
self.assertEquals(len(tis), 2)
for ti in tis:
if ti.task_id == SENSOR_OP:
self.assertEquals(ti.state, State.NONE)
if ti.task_id == DUMMY_OP:
self.assertEquals(ti.state, State.NONE)
# second poke returns False, timeout occurs
date2 = date1 + timedelta(seconds=sensor.poke_interval)
with freeze_time(date2):
self._run(sensor)
tis = dr.get_task_instances()
self.assertEquals(len(tis), 2)
for ti in tis:
self.assertEquals(ti.state, State.SKIPPED)
def test_delete_already_deleted_obj(self):
"""
Tests the case when an object that was registered for deletion has already been deleted.
"""
account = G(Account)
self.initial_data_updater.model_objs_registered_for_deletion = [account]
self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
with freeze_time('2013-04-12'):
self.initial_data_updater.handle_deletions()
receipt = RegisteredForDeletionReceipt.objects.get()
self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account))
self.assertEquals(receipt.model_obj_id, account.id)
self.assertEquals(receipt.register_time, datetime(2013, 4, 12))
# Delete the model object. The receipt should still exist
account.delete()
self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1)
# Now, don't register the object for deletion and run it again at a different time
self.initial_data_updater.model_objs_registered_for_deletion = []
with freeze_time('2013-04-12 05:00:00'):
self.initial_data_updater.handle_deletions()
# The object should be deleted, along with its receipt
self.assertEquals(Account.objects.count(), 0)
self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def test_api__reset_password_reset__err_400__expired_token(self):
dbsession = get_tm_session(self.session_factory, transaction.manager)
admin = dbsession.query(User) \
.filter(User.email == '*****@*****.**') \
.one()
uapi = UserApi(
current_user=admin,
session=dbsession,
config=self.app_config,
)
with freeze_time("1999-12-31 23:59:59"):
reset_password_token = uapi.reset_password_notification(
admin,
do_save=True
)
params = {
'email': '*****@*****.**',
'reset_password_token': reset_password_token,
'new_password': '******',
'new_password2': 'mynewpassword',
}
transaction.commit()
with freeze_time("2000-01-01 00:00:05"):
res = self.testapp.post_json(
'/api/v2/auth/password/reset/modify',
status=400,
params=params,
)
assert isinstance(res.json, dict)
assert 'code' in res.json.keys()
assert res.json_body['code'] == error.EXPIRED_RESET_PASSWORD_TOKEN # nopep8
def setUpTestData(cls):
Region.objects.create(id='NI')
# Create 95c_ULB stops:
StopPoint.objects.bulk_create(
StopPoint(atco_code='7000000' + suffix, locality_centre=False, active=True) for suffix in (
'12165', '12648', '12668', '12701', '12729', '12730', '12731', '12732', '12733', '12734', '12735',
'12736', '12737', '12738', '12739', '12740', '12741', '12742', '12743', '12744', '12745', '12746',
'12747', '12748', '12749', '12750', '12757', '12778', '12779', '12780', '12781', '12782', '12783',
'15377'
)
)
# Create 212_GLE stops:
StopPoint.objects.bulk_create(
StopPoint(atco_code='7000000' + suffix, locality_centre=False, active=True) for suffix in (
'15363', '15678', '14232', '14230', '13311', '15229', '15679', '13331', '13214', '15739', '15746',
'13305', '15747', '14231', '15677', '00792'
)
)
Service.objects.bulk_create([
Service(service_code='212_GLE', date='2016-01-01', region_id='NI', current=True),
Service(service_code='95_ULB', date='2016-01-01', region_id='NI', current=True),
Service(service_code='95c_ULB', date='2016-01-01', region_id='NI', current=True, show_timetable=True)
])
with freeze_time('3 May 2017'):
generate_departures.handle_region(Region(id='NI'))
with freeze_time('4 May 2017'):
generate_departures.handle_region(Region(id='NI'))
def test_update_metric_should_update_metric_metadata(self):
metric_name = "test_update_metric_should_update_metric_metadata.a.b.c"
initial_metadata = MetricMetadata(
aggregator=Aggregator.total,
retention=Retention.from_string("42*1s"),
carbon_xfilesfactor=0.5,
)
create_date = datetime.datetime(2014, 1, 1)
update_date = datetime.datetime(2018, 1, 1)
new_metadata = MetricMetadata(
aggregator=Aggregator.average,
retention=Retention.from_string("43*100s"),
carbon_xfilesfactor=0.25,
)
with freezegun.freeze_time(create_date):
metric = bg_test_utils.make_metric(metric_name, initial_metadata)
self.accessor.create_metric(metric)
self.accessor.flush()
with freezegun.freeze_time(update_date):
self.accessor.update_metric(metric_name, new_metadata)
self.accessor.flush()
metric = self.accessor.get_metric(metric_name)
self.assertEqual(update_date, metric.updated_on)
self.assertEqual(new_metadata, metric.metadata)
def test_prefill_entries_add_to_bottom(self):
tmp_entries_dir = tempfile.mkdtemp()
os.remove(self.entries_file)
self.entries_file = os.path.join(tmp_entries_dir, '%m_%Y.txt')
with self.settings({'default': {'file': self.entries_file}}):
with freeze_time('2014-01-21'):
self.write_entries("""20/01/2014
alias_1 2 hello world
21/01/2014
alias_1 1 foo bar
""")
with freeze_time('2014-02-21'):
self.write_entries("""20/02/2014
alias_1 2 hello world
""")
self.run_command('edit')
with open(expand_date(self.entries_file), 'r') as f:
lines = f.readlines()
self.assertEqual('20/02/2014\n', lines[0])
self.assertEqual('21/02/2014\n', lines[3])
def test_previous_file_doesnt_autofill(self):
tmp_entries_dir = tempfile.mkdtemp()
os.remove(self.entries_file)
self.entries_file = os.path.join(tmp_entries_dir, '%m_%Y.txt')
with self.settings({'default': {'file': self.entries_file}}):
with freeze_time('2014-01-21'):
self.write_entries("""20/01/2014
alias_1 2 hello world
21/01/2014
alias_1 1 foo bar
""")
with freeze_time('2014-02-21'):
self.write_entries("""20/02/2014
alias_1 2 hello world
""")
self.run_command('edit', args=['1'])
with freeze_time('2014-01-21'):
with open(expand_date(self.entries_file), 'r') as f:
lines = f.readlines()
self.assertNotIn('21/02/2014\n', lines)
def test_activity_task_heartbeat_timeout():
with freeze_time("2015-01-01 12:00:00"):
conn = setup_workflow()
decision_token = conn.poll_for_decision_task(
"test-domain", "queue")["taskToken"]
conn.respond_decision_task_completed(decision_token, decisions=[
SCHEDULE_ACTIVITY_TASK_DECISION
])
conn.poll_for_activity_task(
"test-domain", "activity-task-list", identity="surprise")
with freeze_time("2015-01-01 12:04:30"):
resp = conn.get_workflow_execution_history(
"test-domain", conn.run_id, "uid-abcd1234")
resp["events"][-1]["eventType"].should.equal("ActivityTaskStarted")
with freeze_time("2015-01-01 12:05:30"):
# => Activity Task Heartbeat timeout reached!!
resp = conn.get_workflow_execution_history(
"test-domain", conn.run_id, "uid-abcd1234")
resp["events"][-2]["eventType"].should.equal("ActivityTaskTimedOut")
attrs = resp["events"][-2]["activityTaskTimedOutEventAttributes"]
attrs["timeoutType"].should.equal("HEARTBEAT")
# checks that event has been emitted at 12:05:00, not 12:05:30
resp["events"][-2]["eventTimestamp"].should.equal(1420113900.0)
resp["events"][-1]["eventType"].should.equal("DecisionTaskScheduled")
def test_should_accept_token_that_just_within_bounds_old():
# make token 31 seconds ago
with freeze_time('2001-01-01T12:00:00'):
token = create_jwt_token("key", "client_id")
with freeze_time('2001-01-01T12:00:30'):
assert decode_jwt_token(token, "key")
def test_force_one_wf_notifications(self, mock_mail):
with freeze_time("2015-02-01 13:39:20"):
_, wf_forced = self.wf_generator.generate_workflow(
self.quarterly_wf_forced)
response, wf_forced = self.wf_generator.activate_workflow(wf_forced)
_, wf = self.wf_generator.generate_workflow(self.quarterly_wf)
response, wf = self.wf_generator.activate_workflow(wf)
self.assert200(response)
user = models.Person.query.get(self.user.id)
with freeze_time("2015-01-29 13:39:20"):
_, notif_data = common.get_daily_notifications()
self.assertIn(user.email, notif_data)
self.assertIn("cycle_starts_in", notif_data[user.email])
self.assertIn(wf_forced.id, notif_data[user.email]["cycle_starts_in"])
self.assertIn(wf.id, notif_data[user.email]["cycle_starts_in"])
self.object_generator.generate_notification_setting(
self.user.id, "Email_Digest", False)
user = models.Person.query.get(self.user.id)
_, notif_data = common.get_daily_notifications()
self.assertIn(user.email, notif_data)
self.assertIn("cycle_starts_in", notif_data[user.email])
self.assertIn(wf_forced.id, notif_data[user.email]["cycle_starts_in"])
self.assertNotIn(wf.id, notif_data[user.email]["cycle_starts_in"])
def test_mailbox_size_with_changes(self):
service = self.create_mailbox_disk_service()
self.create_disk_resource()
account = self.create_account()
mailbox = self.create_mailbox(account=account)
now = timezone.now()
bp = now.date() + relativedelta(years=1)
options = dict(billing_point=bp, fixed_point=True, proforma=True, new_open=True)
self.allocate_disk(mailbox, 10)
bill = service.orders.bill(**options).pop()
self.assertEqual(9*10, bill.get_total())
with freeze_time(now+relativedelta(months=6)):
self.allocate_disk(mailbox, 20)
bill = service.orders.bill(**options).pop()
total = 9*10*0.5 + 19*10*0.5
self.assertEqual(total, bill.get_total())
with freeze_time(now+relativedelta(months=9)):
self.allocate_disk(mailbox, 30)
bill = service.orders.bill(**options).pop()
total = 9*10*0.5 + 19*10*0.25 + 29*10*0.25
self.assertEqual(total, bill.get_total())
with freeze_time(now+relativedelta(years=1)):
self.allocate_disk(mailbox, 10)
bill = service.orders.bill(**options).pop()
total = 9*10*0.5 + 19*10*0.25 + 29*10*0.25
self.assertEqual(total, bill.get_total())
def test_invoice_list(self):
# make some invoice for other company, to make sure they won't be
# included in the result
with db_transaction.manager:
for i in range(4):
with freeze_time('2013-08-16 00:00:{:02}'.format(i + 1)):
self.invoice_model.create(
customer=self.customer2,
amount=9999,
)
with db_transaction.manager:
guids = []
for i in range(4):
with freeze_time('2013-08-16 00:00:{:02}'.format(i + 1)):
invoice = self.invoice_model.create(
customer=self.customer,
amount=(i + 1) * 1000,
)
guids.append(invoice.guid)
guids = list(reversed(guids))
res = self.testapp.get(
'/v1/invoices',
extra_environ=dict(REMOTE_USER=self.api_key),
status=200,
)
items = res.json['items']
result_guids = [item['guid'] for item in items]
self.assertEqual(result_guids, guids)
def test_get_rolled_up_current(self):
# populate 4 states across different times
with freeze_time("2014-01-02 12:00:01"):
self.post_stat()
with freeze_time("2014-01-02 12:00:02"):
self.post_stat(state = 0)
with freeze_time("2014-01-02 12:00:03"):
self.post_stat(state = -1)
with freeze_time("2014-01-02 12:00:04"):
self.post_stat()
with freeze_time("2014-01-02 13:14:15"):
rv = self.app.get('/api/v1.0/status/current', headers = self.headers)
self.assertEqual(200, rv.status_code)
data = json.loads(rv.data)
status = data['status'][0]
self.assertEqual(1, len(data['status']))
self.assertEqual(4, len(status['states']))
self.assertEqual(self.json_data()['message'], status['states'][0]['message'])
self.assertEqual(1, status['current_state'])
self.assertEqual(-1, status['worst_state'])
def test_read_from_storage_cache(image, settings):
settings.BETTY_CACHE_STORAGE_SEC = 3600
cache_key = 'storage:' + image.source.name
lenna_path = os.path.join(TEST_DATA_PATH, 'Lenna.png')
with open(lenna_path, "rb") as lenna:
expected_bytes = lenna.read()
with patch.object(FieldFile, 'read') as mock_read:
mock_read.side_effect = lambda: expected_bytes[:]
# Check cache miss + fill, then cache hit
with freeze_time('2016-07-06 00:00'):
for _ in range(2):
assert image.read_source_bytes().getvalue() == expected_bytes
assert 1 == mock_read.call_count
assert cache.get(cache_key) == expected_bytes
# Check Expiration
with freeze_time('2016-07-06 01:00'):
assert not cache.get(cache_key)
# Check cache re-fill
assert image.read_source_bytes().getvalue() == expected_bytes
assert 2 == mock_read.call_count
assert cache.get(cache_key) == expected_bytes
def test_symlink_latest_log_directory(self):
handler = FileProcessorHandler(base_log_folder=self.base_log_folder,
filename_template=self.filename)
handler.dag_dir = self.dag_dir
date1 = (timezone.utcnow() + timedelta(days=1)).strftime("%Y-%m-%d")
date2 = (timezone.utcnow() + timedelta(days=2)).strftime("%Y-%m-%d")
p1 = os.path.join(self.base_log_folder, date1, "log1")
p2 = os.path.join(self.base_log_folder, date1, "log2")
if os.path.exists(p1):
os.remove(p1)
if os.path.exists(p2):
os.remove(p2)
link = os.path.join(self.base_log_folder, "latest")
with freeze_time(date1):
handler.set_context(filename=os.path.join(self.dag_dir, "log1"))
self.assertTrue(os.path.islink(link))
self.assertEqual(os.path.basename(os.readlink(link)), date1)
self.assertTrue(os.path.exists(os.path.join(link, "log1")))
with freeze_time(date2):
handler.set_context(filename=os.path.join(self.dag_dir, "log2"))
self.assertTrue(os.path.islink(link))
self.assertEqual(os.path.basename(os.readlink(link)), date2)
self.assertTrue(os.path.exists(os.path.join(link, "log2")))
def test_mailbox_with_recharge(self):
service = self.create_mailbox_disk_service()
self.create_disk_resource()
account = self.create_account()
mailbox = self.create_mailbox(account=account)
now = timezone.now()
bp = now.date() + relativedelta(years=1)
options = dict(billing_point=bp, fixed_point=True)
self.allocate_disk(mailbox, 100)
bill = service.orders.bill(**options).pop()
self.assertEqual(99*10, bill.get_total())
with freeze_time(now+relativedelta(months=6)):
self.allocate_disk(mailbox, 50)
bills = service.orders.bill(**options)
self.assertEqual([], bills)
with freeze_time(now+relativedelta(months=6)):
self.allocate_disk(mailbox, 200)
bill = service.orders.bill(new_open=True, **options).pop()
self.assertEqual((199-99)*10*0.5, bill.get_total())
with freeze_time(now+relativedelta(months=6)):
bills = service.orders.bill(new_open=True, **options)
self.assertEqual([], bills)
def test_recurring_without_tgts_skip(self, has_tg):
"""Test that Active Workflow without TGTs is skipped on cron job"""
with freeze_time(dtm.date(2017, 9, 25)):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(repeat_every=1,
unit=Workflow.MONTH_UNIT)
workflow_id = workflow.id
group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(
task_group=group,
start_date=dtm.date(2017, 9, 26),
end_date=dtm.date(2017, 9, 26) + dtm.timedelta(days=4))
self.generator.activate_workflow(workflow)
active_wf = db.session.query(Workflow).filter(
Workflow.id == workflow_id).one()
self.assertEqual(active_wf.next_cycle_start_date, dtm.date(2017, 9, 26))
self.assertEqual(active_wf.recurrences, True)
self.assertEqual(len(active_wf.cycles), 0)
TaskGroupTask.query.delete()
if not has_tg:
TaskGroup.query.delete()
db.session.commit()
with freeze_time(dtm.date(2017, 10, 25)):
start_recurring_cycles()
active_wf = db.session.query(Workflow).filter(
Workflow.id == workflow_id).one()
self.assertEqual(active_wf.next_cycle_start_date, dtm.date(2017, 9, 26))
self.assertEqual(active_wf.recurrences, True)
self.assertEqual(len(active_wf.cycles), 0)
def test_checkout_voucher_form_active_queryset_after_some_time(
voucher, request_checkout_with_item
):
assert Voucher.objects.count() == 1
voucher.start_date = datetime.date(year=2016, month=6, day=1)
voucher.end_date = datetime.date(year=2016, month=6, day=2)
voucher.save()
with freeze_time("2016-05-31"):
form = CheckoutVoucherForm(
{"voucher": voucher.code}, instance=request_checkout_with_item
)
assert form.fields["voucher"].queryset.count() == 0
with freeze_time("2016-06-01"):
form = CheckoutVoucherForm(
{"voucher": voucher.code}, instance=request_checkout_with_item
)
assert form.fields["voucher"].queryset.count() == 1
with freeze_time("2016-06-03"):
form = CheckoutVoucherForm(
{"voucher": voucher.code}, instance=request_checkout_with_item
)
assert form.fields["voucher"].queryset.count() == 0
def test_auth_token_flow_works_correctly(self):
base_time = datetime.now()
with app.test_client() as c:
# Step 1 : login
with freeze_time(base_time):
login_response = c.post_graphql(
self.login_query,
variables=dict(email=self.user.email, password="******"),
)
self.assertEqual(login_response.status_code, 200)
login_response_data = login_response.json["data"]["auth"][
"login"]
self.assertIn("accessToken", login_response_data)
self.assertIn("refreshToken", login_response_data)
# Step 2 : access protected endpoint within token expiration time
with freeze_time(base_time + timedelta(seconds=30)):
access_response = c.post_graphql(
self.check_query,
headers=[(
"Authorization",
f"Bearer {login_response_data['accessToken']}",
)],
)
self.assertEqual(access_response.status_code, 200)
access_response_data = access_response.json["data"]["auth"][
"check"]
self.assertEqual(access_response_data["userId"], self.user.id)
# Refresh access token after expiration
with freeze_time(base_time + timedelta(minutes=10) +
app.config["ACCESS_TOKEN_EXPIRATION"]):
expired_access_response = c.post_graphql(
self.check_query,
headers=[(
"Authorization",
f"Bearer {login_response_data['accessToken']}",
)],
)
self.assertIsNotNone(
expired_access_response.json.get("errors"))
self.assertIsNone(
expired_access_response.json["data"]["auth"]["check"])
refresh_response = c.post_graphql(
self.refresh_query,
headers=[(
"Authorization",
f"Bearer {login_response_data['refreshToken']}",
)],
)
self.assertEqual(refresh_response.status_code, 200)
refresh_response_data = refresh_response.json["data"]["auth"][
"refresh"]
self.assertIn("accessToken", refresh_response_data)
self.assertIn("refreshToken", refresh_response_data)
new_access_response = c.post_graphql(
self.check_query,
headers=[(
"Authorization",
f"Bearer {refresh_response_data['accessToken']}",
)],
)
self.assertEqual(new_access_response.status_code, 200)
new_access_response_data = new_access_response.json["data"][
"auth"]["check"]
self.assertEqual(new_access_response_data["userId"],
self.user.id)
reuse_refresh_token_response = c.post_graphql(
self.refresh_query,
headers=[(
"Authorization",
f"Bearer {login_response_data['refreshToken']}",
)],
)
self.assertIsNotNone(
reuse_refresh_token_response.json.get("errors"))
self.assertIsNone(reuse_refresh_token_response.json["data"]
["auth"]["refresh"])
def test_parse_filter_date(input_string, end_date, frozen_date, expected_date):
with freeze_time(frozen_date):
assert parse_maybe_relative_date_string(input_string,
end_date) == expected_date
def test_exporting_csv_table_writes_file_to_storage(data_fixture, api_client,
tmpdir, settings):
user, token = data_fixture.create_user_and_token()
table = data_fixture.create_database_table(user=user)
text_field = data_fixture.create_text_field(table=table,
name="text_field",
order=0)
option_field = data_fixture.create_single_select_field(table=table,
name="option_field",
order=1)
option_a = data_fixture.create_select_option(field=option_field,
value="A",
color="blue")
option_b = data_fixture.create_select_option(field=option_field,
value="B",
color="red")
date_field = data_fixture.create_date_field(
table=table,
date_include_time=True,
date_format="US",
name="date_field",
order=2,
)
grid_view = data_fixture.create_grid_view(table=table)
data_fixture.create_view_filter(view=grid_view,
field=text_field,
type="contains",
value="test")
data_fixture.create_view_sort(view=grid_view,
field=text_field,
order="ASC")
row_handler = RowHandler()
row_handler.create_row(
user=user,
table=table,
values={
text_field.id: "test",
date_field.id: "2020-02-01 01:23",
option_field.id: option_b.id,
},
)
row_handler.create_row(
user=user,
table=table,
values={
text_field.id: "atest",
date_field.id: "2020-02-01 01:23",
option_field.id: option_a.id,
},
)
storage = FileSystemStorage(location=(str(tmpdir)),
base_url="http://localhost")
with patch("baserow.contrib.database.export.handler.default_storage",
new=storage):
run_time = make_aware(parse_datetime("2020-02-01 01:00"), timezone=utc)
# DRF uses some custom internal date time formatting, use the field itself
# so the test doesn't break if we set a different default timezone format etc
expected_created_at = DateTimeField().to_representation(run_time)
with freeze_time(run_time):
with capture_on_commit_callbacks(execute=True):
response = api_client.post(
reverse(
"api:database:export:export_table",
kwargs={"table_id": table.id},
),
data={
"view_id": None,
"exporter_type": "csv",
"export_charset": "utf-8",
"csv_include_header": "True",
"csv_column_separator": ",",
},
format="json",
HTTP_AUTHORIZATION=f"JWT {token}",
)
response_json = response.json()
job_id = response_json["id"]
assert response_json == {
"id": job_id,
"created_at": expected_created_at,
"exported_file_name": None,
"exporter_type": "csv",
"progress_percentage": 0.0,
"status": "pending",
"table": table.id,
"view": None,
"url": None,
}
response = api_client.get(
reverse("api:database:export:get", kwargs={"job_id": job_id}),
format="json",
HTTP_AUTHORIZATION=f"JWT {token}",
)
json = response.json()
filename = json["exported_file_name"]
assert json == {
"id": job_id,
"created_at": expected_created_at,
"exported_file_name": filename,
"exporter_type": "csv",
"progress_percentage": 1.0,
"status": "complete",
"table": table.id,
"view": None,
"url": f"http://localhost:8000/media/export_files/{filename}",
}
file_path = tmpdir.join(settings.EXPORT_FILES_DIRECTORY, filename)
assert file_path.isfile()
expected = ("\ufeff"
"id,text_field,option_field,date_field\n"
"1,test,B,02/01/2020 01:23\n"
"2,atest,A,02/01/2020 01:23\n")
with open(file_path, "r", encoding="utf-8") as written_file:
assert written_file.read() == expected
def test_breakdown_by_cohort(self):
person1, person2, person3, person4 = self._create_multiple_people()
cohort = cohort_factory(name="cohort1",
team=self.team,
groups=[{
"properties": {
"name": "person1"
}
}])
cohort2 = cohort_factory(name="cohort2",
team=self.team,
groups=[{
"properties": {
"name": "person2"
}
}])
cohort3 = cohort_factory(
name="cohort3",
team=self.team,
groups=[
{
"properties": {
"name": "person1"
}
},
{
"properties": {
"name": "person2"
}
},
],
)
action = action_factory(name="watched movie", team=self.team)
action.calculate_events()
with freeze_time("2020-01-04T13:01:01Z"):
action_response = trends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
json.dumps(
[cohort.pk, cohort2.pk, cohort3.pk, "all"]),
"breakdown_type":
"cohort",
"actions": [{
"id": action.pk,
"type": "actions",
"order": 0
}],
}),
self.team,
)
event_response = trends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
json.dumps(
[cohort.pk, cohort2.pk, cohort3.pk, "all"]),
"breakdown_type":
"cohort",
"events": [{
"id": "watched movie",
"name": "watched movie",
"type": "events",
"order": 0,
}],
}),
self.team,
)
self.assertEqual(event_response[1]["label"],
"watched movie - cohort2")
self.assertEqual(event_response[2]["label"],
"watched movie - cohort3")
self.assertEqual(event_response[3]["label"],
"watched movie - all users")
self.assertEqual(sum(event_response[0]["data"]), 1)
self.assertEqual(event_response[0]["breakdown_value"], cohort.pk)
self.assertEqual(sum(event_response[1]["data"]), 3)
self.assertEqual(event_response[1]["breakdown_value"], cohort2.pk)
self.assertEqual(sum(event_response[2]["data"]), 4)
self.assertEqual(event_response[2]["breakdown_value"], cohort3.pk)
self.assertEqual(sum(event_response[3]["data"]), 7)
self.assertEqual(event_response[3]["breakdown_value"], "all")
self.assertTrue(
self._compare_entity_response(
event_response,
action_response,
))
def test_breakdown_filtering(self):
self._create_events()
# test breakdown filtering
with freeze_time("2020-01-04T13:01:01Z"):
response = trends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$some_property",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
},
{
"id": "no events"
},
],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - Other")
self.assertEqual(response[1]["label"], "sign up - other_value")
self.assertEqual(response[2]["label"], "sign up - value")
self.assertEqual(response[3]["label"], "no events - Other")
self.assertEqual(sum(response[0]["data"]), 2)
self.assertEqual(response[0]["data"][4 + 7], 2)
self.assertEqual(response[0]["breakdown_value"], "None")
self.assertEqual(sum(response[1]["data"]), 1)
self.assertEqual(response[1]["data"][5 + 7], 1)
self.assertEqual(response[1]["breakdown_value"], "other_value")
# check numerical breakdown
with freeze_time("2020-01-04T13:01:01Z"):
response = trends().run(
Filter(
data={
"date_from":
"-14d",
"breakdown":
"$some_numerical_prop",
"events": [
{
"id": "sign up",
"name": "sign up",
"type": "events",
"order": 0,
},
{
"id": "no events"
},
],
}),
self.team,
)
self.assertEqual(response[0]["label"], "sign up - Other")
self.assertEqual(response[0]["count"], 4.0)
self.assertEqual(response[1]["label"], "sign up - 80.0")
self.assertEqual(response[1]["count"], 1.0)
def test_interval_filtering(self):
self._create_events(use_time=True)
# test minute
with freeze_time("2020-01-02"):
response = trends().run(
Filter(
data={
"date_from": "2020-01-01",
"interval": "minute",
"events": [{
"id": "sign up"
}]
}),
self.team,
)
self.assertEqual(response[0]["labels"][6], "Wed. 1 January, 00:06")
self.assertEqual(response[0]["data"][6], 3.0)
# test hour
with freeze_time("2020-01-02"):
response = trends().run(
Filter(
data={
"date_from": "2019-12-24",
"interval": "hour",
"events": [{
"id": "sign up"
}]
}),
self.team,
)
self.assertEqual(response[0]["labels"][3],
"Tue. 24 December, 03:00")
self.assertEqual(response[0]["data"][3], 1.0)
# 217 - 24 - 1
self.assertEqual(response[0]["data"][192], 3.0)
# test week
with freeze_time("2020-01-02"):
response = trends().run(
Filter(
data={
"date_from": "2019-11-24",
"interval": "week",
"events": [{
"id": "sign up"
}]
}),
self.team,
)
self.assertEqual(response[0]["labels"][4], "Sun. 22 December")
self.assertEqual(response[0]["data"][4], 1.0)
self.assertEqual(response[0]["labels"][5], "Sun. 29 December")
self.assertEqual(response[0]["data"][5], 4.0)
# test month
with freeze_time("2020-01-02"):
response = trends().run(
Filter(
data={
"date_from": "2019-9-24",
"interval": "month",
"events": [{
"id": "sign up"
}]
}),
self.team,
)
self.assertEqual(response[0]["labels"][2], "Sat. 30 November")
self.assertEqual(response[0]["data"][2], 1.0)
self.assertEqual(response[0]["labels"][3], "Tue. 31 December")
self.assertEqual(response[0]["data"][3], 4.0)
with freeze_time("2020-01-02 23:30"):
event_factory(team=self.team,
event="sign up",
distinct_id="blabla")
# test today + hourly
with freeze_time("2020-01-02T23:31:00Z"):
response = trends().run(
Filter(
data={
"date_from": "dStart",
"interval": "hour",
"events": [{
"id": "sign up"
}]
}), self.team)
self.assertEqual(response[0]["labels"][23],
"Thu. 2 January, 23:00")
self.assertEqual(response[0]["data"][23], 1.0)
def _create_events(self, use_time=False):
person = person_factory(team_id=self.team.pk,
distinct_ids=["blabla", "anonymous_id"])
secondTeam = Team.objects.create(api_token="token123")
freeze_without_time = ["2019-12-24", "2020-01-01", "2020-01-02"]
freeze_with_time = [
"2019-12-24 03:45:34",
"2020-01-01 00:06:34",
"2020-01-02 16:34:34",
]
freeze_args = freeze_without_time
if use_time:
freeze_args = freeze_with_time
with freeze_time(freeze_args[0]):
event_factory(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "value"},
)
with freeze_time(freeze_args[1]):
event_factory(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "value"},
)
event_factory(team=self.team,
event="sign up",
distinct_id="anonymous_id")
event_factory(team=self.team,
event="sign up",
distinct_id="blabla")
with freeze_time(freeze_args[2]):
event_factory(
team=self.team,
event="sign up",
distinct_id="blabla",
properties={
"$some_property": "other_value",
"$some_numerical_prop": 80,
},
)
event_factory(team=self.team,
event="no events",
distinct_id="blabla")
# second team should have no effect
event_factory(
team=secondTeam,
event="sign up",
distinct_id="blabla",
properties={"$some_property": "other_value"},
)
no_events = action_factory(team=self.team, name="no events")
sign_up_action = action_factory(team=self.team, name="sign up")
return sign_up_action, person
def test_post_validate_redirects(self, monkeypatch, pyramid_request,
with_user):
remember = pretend.call_recorder(
lambda request, user_id: [("foo", "bar")])
monkeypatch.setattr(views, "remember", remember)
new_session = {}
user_id = uuid.uuid4()
user_service = pretend.stub(
find_userid=pretend.call_recorder(lambda username: user_id),
update_user=pretend.call_recorder(lambda *a, **kw: None),
)
pyramid_request.find_service = pretend.call_recorder(
lambda iface, context: user_service)
pyramid_request.method = "POST"
pyramid_request.session = pretend.stub(
items=lambda: [("a", "b"), ("foo", "bar")],
update=new_session.update,
invalidate=pretend.call_recorder(lambda: None),
new_csrf_token=pretend.call_recorder(lambda: None),
)
pyramid_request.set_property(
lambda r: str(uuid.uuid4()) if with_user else None,
name="unauthenticated_userid",
)
form_obj = pretend.stub(
validate=pretend.call_recorder(lambda: True),
username=pretend.stub(data="theuser"),
)
form_class = pretend.call_recorder(lambda d, user_service: form_obj)
pyramid_request.route_path = pretend.call_recorder(
lambda a: '/the-redirect')
now = datetime.datetime.utcnow()
with freezegun.freeze_time(now):
result = views.login(pyramid_request, _form_class=form_class)
assert isinstance(result, HTTPSeeOther)
assert pyramid_request.route_path.calls == [
pretend.call('manage.projects')
]
assert result.headers["Location"] == "/the-redirect"
assert result.headers["foo"] == "bar"
assert form_class.calls == [
pretend.call(pyramid_request.POST, user_service=user_service),
]
assert form_obj.validate.calls == [pretend.call()]
assert user_service.find_userid.calls == [pretend.call("theuser")]
assert user_service.update_user.calls == [
pretend.call(user_id, last_login=now),
]
if with_user:
assert new_session == {}
else:
assert new_session == {"a": "b", "foo": "bar"}
assert remember.calls == [pretend.call(pyramid_request, str(user_id))]
assert pyramid_request.session.invalidate.calls == [pretend.call()]
assert pyramid_request.find_service.calls == [
pretend.call(IUserService, context=None),
pretend.call(IUserService, context=None),
]
assert pyramid_request.session.new_csrf_token.calls == [pretend.call()]
def test_interaction_export(
self,
setup_es,
request_sortby,
orm_ordering,
):
"""
Test export of interaction search results with a policy feedback user.
Checks that all interaction kinds except for policy feedback are included in the export.
"""
# Faker generates job titles containing commas which complicates comparisons,
# so all contact job titles are explicitly set
company = CompanyFactory()
CompanyInteractionFactory(
company=company,
contacts=[
ContactFactory(company=company, job_title='Engineer'),
ContactFactory(company=company, job_title=None),
ContactFactory(company=company, job_title=''),
],
)
EventServiceDeliveryFactory(
company=company,
contacts=[
ContactFactory(company=company, job_title='Managing director'),
],
)
InvestmentProjectInteractionFactory(
company=company,
contacts=[
ContactFactory(company=company, job_title='Exports manager'),
],
)
ServiceDeliveryFactory(
company=company,
contacts=[
ContactFactory(company=company, job_title='Sales director'),
],
)
CompanyInteractionFactoryWithPolicyFeedback(
company=company,
contacts=[
ContactFactory(company=company,
job_title='Business development manager'),
],
policy_areas=PolicyArea.objects.order_by('?')[:2],
policy_issue_types=PolicyIssueType.objects.order_by('?')[:2],
)
setup_es.indices.refresh()
data = {}
if request_sortby:
data['sortby'] = request_sortby
url = reverse('api-v3:search:interaction-export')
with freeze_time('2018-01-01 11:12:13'):
response = self.api_client.post(url, data=data)
assert response.status_code == status.HTTP_200_OK
assert parse_header(response.get('Content-Type')) == ('text/csv', {
'charset':
'utf-8'
})
assert parse_header(response.get('Content-Disposition')) == (
'attachment',
{
'filename': 'Data Hub - Interactions - 2018-01-01-11-12-13.csv'
},
)
sorted_interactions = Interaction.objects.all().order_by(
orm_ordering,
'pk',
)
reader = DictReader(StringIO(response.getvalue().decode('utf-8-sig')))
assert reader.fieldnames == list(
SearchInteractionExportAPIView.field_titles.values())
expected_row_data = [{
'Date':
interaction.date,
'Type':
interaction.get_kind_display(),
'Service':
get_attr_or_none(interaction, 'service.name'),
'Subject':
interaction.subject,
'Link':
f'{settings.DATAHUB_FRONTEND_URL_PREFIXES["interaction"]}'
f'/{interaction.pk}',
'Company':
get_attr_or_none(interaction, 'company.name'),
'Company link':
f'{settings.DATAHUB_FRONTEND_URL_PREFIXES["company"]}'
f'/{interaction.company.pk}',
'Company country':
get_attr_or_none(
interaction,
'company.address_country.name',
),
'Company UK region':
get_attr_or_none(interaction, 'company.uk_region.name'),
'Company sector':
get_attr_or_none(interaction, 'company.sector.name'),
'Contacts':
_format_expected_contacts(interaction),
'Adviser':
get_attr_or_none(interaction, 'dit_adviser.name'),
'Service provider':
get_attr_or_none(interaction, 'dit_team.name'),
'Event':
get_attr_or_none(interaction, 'event.name'),
'Communication channel':
get_attr_or_none(interaction, 'communication_channel.name'),
'Service delivery status':
get_attr_or_none(
interaction,
'service_delivery_status.name',
),
'Net company receipt':
interaction.net_company_receipt,
'Policy issue types':
join_attr_values(interaction.policy_issue_types.all()),
'Policy areas':
join_attr_values(interaction.policy_areas.all(), separator='; '),
'Policy feedback notes':
interaction.policy_feedback_notes,
} for interaction in sorted_interactions]
actual_row_data = [_format_actual_csv_row(row) for row in reader]
assert actual_row_data == format_csv_data(expected_row_data)
from datetime import datetime
from os.path import dirname, join
from city_scrapers_core.utils import file_response
from freezegun import freeze_time
from city_scrapers.spiders.pa_liquorboard import PaLiquorboardSpider
test_response = file_response(
join(dirname(__file__), "files", "pa_liquorboard.html"),
url="https://www.lcb.pa.gov/About-Us/Board/Pages/Public-Meetings.aspx",
)
spider = PaLiquorboardSpider()
freezer = freeze_time("2019-02-08")
freezer.start()
parsed_items = [item for item in spider.parse(test_response)]
freezer.stop()
def test_start():
assert parsed_items[0]["start"] > datetime(2000, 1, 1, 0, 0)
def test_cross_user(self):
with freeze_time():
token = self.device.generate_challenge()
ok = self.device2.verify_token(token)
self.assertFalse(ok)
from datetime import datetime
from os.path import dirname, join
import pytest
from city_scrapers_core.constants import COMMITTEE, PASSED
from city_scrapers_core.utils import file_response
from freezegun import freeze_time
from city_scrapers.spiders.wayne_audit import WayneAuditSpider
freezer = freeze_time('2018-03-27')
freezer.start()
test_response = file_response(
join(dirname(__file__), "files", "wayne_audit.html"),
url='https://www.waynecounty.com/elected/commission/audit.aspx')
spider = WayneAuditSpider()
parsed_items = [item for item in spider.parse(test_response)]
freezer.stop()
@pytest.mark.parametrize('item', parsed_items)
def test_description(item):
assert item['description'] == ''
@pytest.mark.parametrize('item', parsed_items)
def test_location(item):
assert item['location'] == spider.location
@pytest.mark.parametrize('item', parsed_items)
def test_frequency_biyearly(self):
with freeze_time('2021-09-01'):
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(
tracking_disable=True).create({
'name':
'Accrual Plan For Test',
'level_ids': [(0, 0, {
'start_count': 1,
'start_type': 'day',
'added_value': 1,
'added_value_type': 'days',
'frequency': 'biyearly',
'maximum_leave': 10000,
})],
})
#this sets up an accrual on the 1st of January and the 1st of July
allocation = self.env['hr.leave.allocation'].with_user(
self.user_hrmanager_id).with_context(
tracking_disable=True).create({
'name':
'Accrual allocation for employee',
'accrual_plan_id':
accrual_plan.id,
'employee_id':
self.employee_emp.id,
'holiday_status_id':
self.leave_type.id,
'number_of_days':
0,
'allocation_type':
'accrual',
})
self.setAllocationCreateDate(allocation.id, '2021-09-01 00:00:00')
allocation.action_confirm()
allocation.action_validate()
self.assertFalse(
allocation.nextcall,
'There should be no nextcall set on the allocation.')
self.assertEqual(allocation.number_of_days, 0,
'There should be no days allocated yet.')
allocation._update_accrual()
next_date = datetime.date(2022, 1, 1)
self.assertEqual(
allocation.number_of_days, 0,
'There should be no days allocated yet. The accrual starts tomorrow.'
)
with freeze_time(next_date):
next_date = datetime.date(2022, 7, 1)
allocation._update_accrual()
# Prorated
self.assertAlmostEqual(allocation.number_of_days, 0.6576, 4,
'There should be 0.6576 day allocated.')
self.assertEqual(
allocation.nextcall, next_date,
'The next call date of the cron should be July 1st')
with freeze_time(next_date):
allocation._update_accrual()
# Not Prorated
self.assertAlmostEqual(allocation.number_of_days, 1.6576, 4,
'There should be 1.6576 day allocated.')
def interactions(setup_es):
"""Sets up data for the tests."""
data = []
with freeze_time('2017-01-01 13:00:00'):
company_1 = CompanyFactory(name='ABC Trading Ltd')
company_2 = CompanyFactory(name='Little Puddle Ltd')
data.extend([
CompanyInteractionFactory(
subject='Exports meeting',
date=dateutil_parse('2017-10-30T00:00:00Z'),
company=company_1,
contacts=[
ContactFactory(company=company_1,
first_name='Lee',
last_name='Danger'),
ContactFactory(company=company_1,
first_name='Francis',
last_name='Brady'),
ContactFactory(company=company_1,
first_name='Zanger Za',
last_name='Qa'),
],
dit_adviser__first_name='Angela',
dit_adviser__last_name='Lawson',
),
CompanyInteractionFactory(
subject='a coffee',
date=dateutil_parse('2017-04-05T00:00:00Z'),
company=company_2,
contacts=[
ContactFactory(company=company_1,
first_name='Try',
last_name='Slanger'),
],
dit_adviser__first_name='Zed',
dit_adviser__last_name='Zeddy',
),
CompanyInteractionFactory(
subject='Email about exhibition',
date=dateutil_parse('2016-09-02T00:00:00Z'),
company=company_2,
contacts=[
ContactFactory(company=company_1,
first_name='Caroline',
last_name='Green'),
],
dit_adviser__first_name='Prime',
dit_adviser__last_name='Zeddy',
),
CompanyInteractionFactory(
subject='talking about cats',
date=dateutil_parse('2018-02-01T00:00:00Z'),
company=company_2,
contacts=[
ContactFactory(company=company_1,
first_name='Full',
last_name='Bridge'),
],
dit_adviser__first_name='Low',
dit_adviser__last_name='Tremon',
),
CompanyInteractionFactory(
subject='Event at HQ',
date=dateutil_parse('2018-01-01T00:00:00Z'),
company=company_2,
contacts=[
ContactFactory(company=company_1,
first_name='Diane',
last_name='Pree'),
],
dit_adviser__first_name='Trevor',
dit_adviser__last_name='Saleman',
),
])
setup_es.indices.refresh()
yield data
def test_sessions_count_buckets(self):
# 0 seconds
with freeze_time("2012-01-11T01:25:30.000Z"):
event_factory(team=self.team,
event="1st action",
distinct_id="2")
event_factory(team=self.team,
event="1st action",
distinct_id="2")
event_factory(team=self.team,
event="1st action",
distinct_id="4")
with freeze_time("2012-01-11T01:25:32.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="4") # within 0-3 seconds
event_factory(team=self.team,
event="1st action",
distinct_id="6")
event_factory(team=self.team,
event="2nd action",
distinct_id="7")
with freeze_time("2012-01-11T01:25:40.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="6") # within 3-10 seconds
event_factory(team=self.team,
event="2nd action",
distinct_id="7") # within 3-10 seconds
with freeze_time("2012-01-15T04:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
event_factory(team=self.team,
event="3rd action",
distinct_id="4")
with freeze_time("2012-01-15T05:00:00.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2") # within 10-30 seconds
with freeze_time("2012-01-15T05:00:20.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="4") # within 30-60 seconds
# within 1-3 mins
with freeze_time("2012-01-17T04:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="1")
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
event_factory(team=self.team,
event="3rd action",
distinct_id="5")
with freeze_time("2012-01-17T05:01:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="1")
with freeze_time("2012-01-17T05:07:30.000Z"):
event_factory(
team=self.team, event="3rd action",
distinct_id="2") # test many events within a range
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
event_factory(team=self.team,
event="3rd action",
distinct_id="2") # within 3-10 mins
event_factory(team=self.team,
event="3rd action",
distinct_id="10")
with freeze_time("2012-01-17T05:20:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="5") # within 10-30 mins
event_factory(team=self.team,
event="3rd action",
distinct_id="9")
event_factory(team=self.team,
event="3rd action",
distinct_id="10")
with freeze_time("2012-01-17T05:40:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="9")
event_factory(team=self.team,
event="3rd action",
distinct_id="10") # within 30-60 mins
with freeze_time("2012-01-17T05:58:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="9") # -> within 30-60 mins
# within 1+ hours
with freeze_time("2012-01-21T04:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-21T05:20:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-21T05:45:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-21T06:00:30.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
response = sessions().run(
SessionsFilter(data={
"date_from": "all",
"session": "dist"
}), self.team)
compared_response = sessions().run(
SessionsFilter(data={
"date_from": "all",
"compare": True,
"session": "dist"
}), self.team)
for index, item in enumerate(response):
if item["label"] == "30-60 minutes" or item[
"label"] == "3-10 seconds":
self.assertEqual(item["count"], 2)
self.assertEqual(compared_response[index]["count"], 2)
else:
self.assertEqual(item["count"], 1)
self.assertEqual(compared_response[index]["count"], 1)
def test_check_gain(self):
# 2 accruals, one based on worked time, one not
# check gain
with freeze_time('2021-08-30'):
calendar_emp = self.env['resource.calendar'].create({
'name':
'40 Hours',
'tz':
self.employee_emp.tz,
'attendance_ids': [(0, 0, {
'name': '%s_%d' % ('40 Hours', index),
'hour_from': 8,
'hour_to': 12,
'dayofweek': str(index),
'day_period': 'morning'
}, {
'name': '%s_%d' % ('40 Hours', index),
'hour_from': 13,
'hour_to': 18,
'dayofweek': str(index),
'day_period': 'afternoon'
}) for index in range(5)],
})
self.employee_emp.resource_calendar_id = calendar_emp.id
accrual_plan_not_based_on_worked_time = self.env[
'hr.leave.accrual.plan'].with_context(
tracking_disable=True).create({
'name':
'Accrual Plan For Test',
'level_ids': [(0, 0, {
'start_count': 1,
'start_type': 'day',
'added_value': 5,
'added_value_type': 'days',
'frequency': 'weekly',
'maximum_leave': 10000,
})],
})
accrual_plan_based_on_worked_time = self.env[
'hr.leave.accrual.plan'].with_context(
tracking_disable=True).create({
'name':
'Accrual Plan For Test',
'level_ids': [(0, 0, {
'start_count': 1,
'start_type': 'day',
'added_value': 5,
'added_value_type': 'days',
'frequency': 'weekly',
'maximum_leave': 10000,
'is_based_on_worked_time': True,
})],
})
allocation_not_worked_time = self.env[
'hr.leave.allocation'].with_user(
self.user_hrmanager_id).with_context(
tracking_disable=True).create({
'name':
'Accrual allocation for employee',
'accrual_plan_id':
accrual_plan_not_based_on_worked_time.id,
'employee_id':
self.employee_emp.id,
'holiday_status_id':
self.leave_type.id,
'number_of_days':
0,
'allocation_type':
'accrual',
'state':
'validate',
})
allocation_worked_time = self.env['hr.leave.allocation'].with_user(
self.user_hrmanager_id).with_context(
tracking_disable=True).create({
'name':
'Accrual allocation for employee',
'accrual_plan_id':
accrual_plan_based_on_worked_time.id,
'employee_id':
self.employee_emp.id,
'holiday_status_id':
self.leave_type.id,
'number_of_days':
0,
'allocation_type':
'accrual',
'state':
'validate',
})
self.setAllocationCreateDate(allocation_not_worked_time.id,
'2021-08-01 00:00:00')
self.setAllocationCreateDate(allocation_worked_time.id,
'2021-08-01 00:00:00')
holiday_type = self.env['hr.leave.type'].create({
'name':
'Paid Time Off',
'requires_allocation':
'no',
'responsible_id':
self.user_hrmanager_id,
})
leave = self.env['hr.leave'].create({
'name':
'leave',
'employee_id':
self.employee_emp.id,
'holiday_status_id':
holiday_type.id,
'date_from':
'2021-09-02 00:00:00',
'date_to':
'2021-09-02 23:59:59',
})
leave.action_validate()
self.assertFalse(
allocation_not_worked_time.nextcall,
'There should be no nextcall set on the allocation.')
self.assertFalse(
allocation_worked_time.nextcall,
'There should be no nextcall set on the allocation.')
self.assertEqual(allocation_not_worked_time.number_of_days, 0,
'There should be no days allocated yet.')
self.assertEqual(allocation_worked_time.number_of_days, 0,
'There should be no days allocated yet.')
next_date = datetime.date(2021, 9, 6)
with freeze_time(next_date):
# next_date = datetime.date(2021, 9, 13)
self.env['hr.leave.allocation']._update_accrual()
# Prorated
self.assertAlmostEqual(allocation_not_worked_time.number_of_days,
4.2857, 4,
'There should be 4.2857 days allocated.')
# 3.75 -> starts 1 day after allocation date -> 31/08-3/09 => 4 days - 1 days time off => (3 / 4) * 5 days
# ^ result without prorata
# Prorated
self.assertAlmostEqual(allocation_worked_time.number_of_days,
3.42857, 4,
'There should be 3.42857 days allocated.')
self.assertEqual(
allocation_not_worked_time.nextcall,
datetime.date(2021, 9, 13),
'The next call date of the cron should be the September 13th')
self.assertEqual(
allocation_worked_time.nextcall, datetime.date(2021, 9, 13),
'The next call date of the cron should be the September 13th')
with freeze_time(next_date + relativedelta(days=7)):
next_date = datetime.date(2021, 9, 20)
self.env['hr.leave.allocation']._update_accrual()
self.assertAlmostEqual(allocation_not_worked_time.number_of_days,
9.2857, 4,
'There should be 9.2857 days allocated.')
self.assertEqual(
allocation_not_worked_time.nextcall, next_date,
'The next call date of the cron should be September 20th')
self.assertAlmostEqual(allocation_worked_time.number_of_days,
8.42857, 4,
'There should be 8.42857 days allocated.')
self.assertEqual(
allocation_worked_time.nextcall, next_date,
'The next call date of the cron should be September 20th')
def test_sessions_list(self):
with freeze_time("2012-01-14T03:21:34.000Z"):
event_factory(team=self.team,
event="1st action",
distinct_id="1")
event_factory(team=self.team,
event="1st action",
distinct_id="2")
with freeze_time("2012-01-14T03:25:34.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="1")
event_factory(team=self.team,
event="2nd action",
distinct_id="2")
with freeze_time("2012-01-15T03:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-15T03:59:35.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="1")
with freeze_time("2012-01-15T04:01:34.000Z"):
event_factory(team=self.team,
event="4th action",
distinct_id="1",
properties={"$os": "Mac OS X"})
event_factory(team=self.team,
event="4th action",
distinct_id="2",
properties={"$os": "Windows 95"})
team_2 = Team.objects.create()
Person.objects.create(team=self.team,
distinct_ids=["1", "3", "4"],
properties={"email": "bla"})
# Test team leakage
Person.objects.create(team=team_2,
distinct_ids=["1", "3", "4"],
properties={"email": "bla"})
with freeze_time("2012-01-15T04:01:34.000Z"):
response = sessions().run(
SessionsFilter(data={
"events": [],
"session": None
}), self.team)
self.assertEqual(len(response), 2)
self.assertEqual(response[0]["global_session_id"], 1)
with freeze_time("2012-01-15T04:01:34.000Z"):
response = sessions().run(
SessionsFilter(
data={
"events": [],
"properties": [{
"key": "$os",
"value": "Mac OS X"
}],
"session": None
}),
self.team,
)
self.assertEqual(len(response), 1)
def test_sessions_and_cohort(self):
with freeze_time("2012-01-14T03:21:34.000Z"):
event_factory(team=self.team,
event="1st action",
distinct_id="1")
event_factory(team=self.team,
event="1st action",
distinct_id="2")
with freeze_time("2012-01-14T03:25:34.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="1")
event_factory(team=self.team,
event="2nd action",
distinct_id="2")
with freeze_time("2012-01-15T03:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-15T03:59:35.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="1")
with freeze_time("2012-01-15T04:01:34.000Z"):
event_factory(team=self.team,
event="4th action",
distinct_id="1",
properties={"$os": "Mac OS X"})
event_factory(team=self.team,
event="4th action",
distinct_id="2",
properties={"$os": "Windows 95"})
team_2 = Team.objects.create()
Person.objects.create(team=self.team,
distinct_ids=["1", "3", "4"],
properties={"email": "bla"})
# Test team leakage
Person.objects.create(team=team_2,
distinct_ids=["1", "3", "4"],
properties={"email": "bla"})
cohort = Cohort.objects.create(team=self.team,
groups=[{
"properties": {
"email": "bla"
}
}])
cohort.calculate_people()
with freeze_time("2012-01-15T04:01:34.000Z"):
response = sessions().run(
SessionsFilter(
data={
"events": [],
"session":
None,
"properties": [{
"key": "id",
"value": cohort.pk,
"type": "cohort"
}],
}),
self.team,
)
self.assertEqual(len(response), 1)
from city_scrapers_core.constants import ADVISORY_COMMITTEE, PASSED
from city_scrapers_core.utils import file_response
from freezegun import freeze_time
from city_scrapers.spiders.chi_mayors_pedestrian_advisory_council import (
ChiMayorsPedestrianAdvisoryCouncilSpider)
test_response = file_response(
join(dirname(__file__), "files",
"chi_mayors_pedestrian_advisory_council.html"),
url=(
"http://chicagocompletestreets.org/getinvolved/mayors-advisory-councils/mpac-meeting-archives/" # noqa
))
spider = ChiMayorsPedestrianAdvisoryCouncilSpider()
freezer = freeze_time("2019-06-07")
freezer.start()
parsed_items = [item for item in spider.parse(test_response)]
freezer.stop()
def test_count():
assert len(parsed_items) == 8
@pytest.mark.parametrize('item', parsed_items)
def test_title(item):
assert item['title'] == "Mayor's Pedestrian Advisory Council"
def test_sessions_avg_length_interval(self):
with freeze_time("2012-01-14T03:21:34.000Z"):
event_factory(team=self.team,
event="1st action",
distinct_id="1")
event_factory(team=self.team,
event="1st action",
distinct_id="2")
with freeze_time("2012-01-14T03:25:34.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="1")
event_factory(team=self.team,
event="2nd action",
distinct_id="2")
with freeze_time("2012-01-25T03:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="1")
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-01-25T04:01:34.000Z"):
event_factory(team=self.team,
event="4th action",
distinct_id="1")
event_factory(team=self.team,
event="4th action",
distinct_id="2")
with freeze_time("2012-03-14T03:21:34.000Z"):
event_factory(team=self.team,
event="1st action",
distinct_id="2")
with freeze_time("2012-03-14T03:25:34.000Z"):
event_factory(team=self.team,
event="2nd action",
distinct_id="2")
with freeze_time("2012-03-15T03:59:34.000Z"):
event_factory(team=self.team,
event="3rd action",
distinct_id="2")
with freeze_time("2012-03-15T04:01:34.000Z"):
event_factory(team=self.team,
event="4th action",
distinct_id="2")
# month
month_response = sessions().run(
SessionsFilter(
data={
"date_from": "2012-01-01",
"date_to": "2012-04-01",
"interval": "month",
"session": "avg"
}),
self.team,
)
self.assertEqual(month_response[0]["data"][0], 180)
self.assertEqual(month_response[0]["data"][2], 180)
self.assertEqual(month_response[0]["labels"][0], "Tue. 31 January")
self.assertEqual(month_response[0]["labels"][1],
"Wed. 29 February")
self.assertEqual(month_response[0]["days"][0], "2012-01-31")
self.assertEqual(month_response[0]["days"][1], "2012-02-29")
# # week
week_response = sessions().run(
SessionsFilter(
data={
"date_from": "2012-01-01",
"date_to": "2012-02-01",
"interval": "week",
"session": "avg"
}),
self.team,
)
self.assertEqual(week_response[0]["data"][1], 240.0)
self.assertEqual(week_response[0]["data"][3], 120.0)
self.assertEqual(week_response[0]["labels"][0], "Sun. 1 January")
self.assertEqual(week_response[0]["labels"][1], "Sun. 8 January")
self.assertEqual(week_response[0]["days"][0], "2012-01-01")
self.assertEqual(week_response[0]["days"][1], "2012-01-08")
# # # hour
hour_response = sessions().run(
SessionsFilter(
data={
"date_from": "2012-03-14",
"date_to": "2012-03-16",
"interval": "hour",
"session": "avg"
}),
self.team,
)
self.assertEqual(hour_response[0]["data"][3], 240.0)
self.assertEqual(hour_response[0]["data"][27], 120.0)
self.assertEqual(hour_response[0]["labels"][0],
"Wed. 14 March, 00:00")
self.assertEqual(hour_response[0]["labels"][1],
"Wed. 14 March, 01:00")
self.assertEqual(hour_response[0]["days"][0],
"2012-03-14 00:00:00")
self.assertEqual(hour_response[0]["days"][1],
"2012-03-14 01:00:00")
def test_logs_services_disabled(self):
""" Test disabled logs for active / passive checks for services
:return: None
"""
self.setup_with_file('cfg/cfg_monitoring_logs.cfg',
'cfg/cfg_monitoring_logs_disabled.ini')
assert self.conf_is_correct
self._sched = self._scheduler
host = self._scheduler.hosts.find_by_name("test_host_0")
host.checks_in_progress = []
host.act_depend_of = [] # ignore the router
host.event_handler_enabled = False
svc = self._scheduler.services.find_srv_by_name_and_hostname(
"test_host_0", "test_ok_0")
# Make notifications sent very quickly
svc.notification_interval = 10.0
svc.checks_in_progress = []
svc.act_depend_of = [] # no hostchecks on critical checkresults
svc.event_handler_enabled = False
# Freeze the time !
initial_datetime = datetime.datetime(year=2018,
month=6,
day=1,
hour=18,
minute=30,
second=0)
with freeze_time(initial_datetime) as frozen_datetime:
assert frozen_datetime() == initial_datetime
# Get sure that host is UP
self.check(frozen_datetime, host, 0, 'Host is UP', [])
# Service is ok
self.check(frozen_datetime, svc, 0, 'Service is OK', [])
self.check(frozen_datetime, svc, 0, 'Service is OK', [])
# Service goes warning / SOFT
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [(
'warning',
'SERVICE ALERT: test_host_0;test_ok_0;WARNING;SOFT;1;Service is WARNING'
)])
# Service goes warning / HARD
# Get a service check, an alert and a notification
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [(
'warning',
'SERVICE ALERT: test_host_0;test_ok_0;WARNING;HARD;2;Service is WARNING'
)])
# Service notification raised
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [])
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [])
# Service goes OK
self.check(frozen_datetime, svc, 0, 'Service is OK', [(
'info',
'SERVICE ALERT: test_host_0;test_ok_0;OK;HARD;2;Service is OK')
])
self.check(frozen_datetime, svc, 0, 'Service is OK', [])
# Service goes CRITICAL
self.check(frozen_datetime, svc, 2, 'Service is CRITICAL', [(
'error',
'SERVICE ALERT: test_host_0;test_ok_0;CRITICAL;SOFT;1;Service is CRITICAL'
)])
self.check(frozen_datetime, svc, 2, 'Service is CRITICAL', [(
'error',
'SERVICE ALERT: test_host_0;test_ok_0;CRITICAL;HARD;2;Service is CRITICAL'
)])
# Service goes OK
self.check(frozen_datetime, svc, 0, 'Service is OK', [(
'info',
'SERVICE ALERT: test_host_0;test_ok_0;OK;HARD;2;Service is OK')
])
self.check(frozen_datetime, svc, 0, 'Service OK', [])
def test_liabilities_limit(member):
config = Configuration.get_solo()
config.liability_interval = 36
config.save()
test_date = timezone.now().date().replace(year=2010, month=12, day=31)
with freeze_time(test_date) as frozen_time:
Membership.objects.create(
member=member,
start=test_date.replace(year=2007, month=5, day=1),
amount=20,
interval=FeeIntervals.MONTHLY,
)
member.update_liabilites()
assert member.balance == -880.0
assert member.statute_barred_debt() == 0
frozen_time.move_to(test_date.replace(year=2011, month=1, day=1))
member.update_liabilites()
assert member.balance == -900.0
assert member.statute_barred_debt() == 160.0
t = Transaction.objects.create(value_datetime=test_date,
user_or_context="test")
t.debit(account=SpecialAccounts.bank,
amount=12,
user_or_context="test")
t.credit(
account=SpecialAccounts.fees_receivable,
amount=12,
member=member,
user_or_context="test",
)
t.save()
assert member.balance == -888.0
assert member.statute_barred_debt() == 148.0
t = Transaction.objects.create(
value_datetime=test_date.replace(year=2007, month=7, day=1),
user_or_context="test",
)
t.debit(account=SpecialAccounts.bank,
amount=13,
user_or_context="test")
t.credit(
account=SpecialAccounts.fees_receivable,
amount=13,
member=member,
user_or_context="test",
)
t.save()
assert member.balance == -875.0
assert member.statute_barred_debt() == 135.0
t = Transaction.objects.create(
value_datetime=test_date.replace(year=2007, month=12, day=31),
user_or_context="test",
)
t.debit(account=SpecialAccounts.bank,
amount=136,
user_or_context="test")
t.credit(
account=SpecialAccounts.fees_receivable,
amount=136,
member=member,
user_or_context="test",
)
t.save()
assert member.balance == -739.0
assert member.statute_barred_debt() == 0
assert member.statute_barred_debt(relativedelta(years=1)) == 239.0
def test_logs_services(self):
""" Test logs for active / passive checks for hosts
:return: None
"""
self.setup_with_file('cfg/cfg_monitoring_logs.cfg')
assert self.conf_is_correct
self._scheduler.pushed_conf.log_initial_states = True
self._scheduler.pushed_conf.log_active_checks = True
self._scheduler.pushed_conf.log_passive_checks = True
host = self._scheduler.hosts.find_by_name("test_host_0")
host.checks_in_progress = []
host.act_depend_of = [] # ignore the router
host.event_handler_enabled = True
svc = self._scheduler.services.find_srv_by_name_and_hostname(
"test_host_0", "test_ok_0")
# Make notifications interval set to 5 minutes
svc.notification_interval = 5
svc.checks_in_progress = []
svc.act_depend_of = [] # no hostchecks on critical checkresults
svc.event_handler_enabled = True
# Freeze the time !
initial_datetime = datetime.datetime(year=2018,
month=6,
day=1,
hour=18,
minute=30,
second=0)
with freeze_time(initial_datetime) as frozen_datetime:
assert frozen_datetime() == initial_datetime
# Get sure that host is UP
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', 'ACTIVE HOST CHECK: test_host_0;UP;0;Host is UP')])
# Service is ok
self.check(frozen_datetime, svc, 0, 'Service is OK', [(
'info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;0;Service is OK'
)])
self.check(frozen_datetime, svc, 0, 'Service is OK', [(
'info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;1;Service is OK'
)])
# Service goes warning / SOFT
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [
('warning',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;WARNING;1;Service is WARNING'
),
('warning',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;WARNING;SOFT;1;eventhandler'
),
('warning',
'SERVICE ALERT: test_host_0;test_ok_0;WARNING;SOFT;1;Service is WARNING'
),
])
# Service goes warning / HARD
# Get a service check, an alert and a notification
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [
('warning',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;WARNING;1;Service is WARNING'
),
('warning',
'SERVICE ALERT: test_host_0;test_ok_0;WARNING;HARD;2;Service is WARNING'
),
('warning',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;WARNING;HARD;2;eventhandler'
),
('warning',
'SERVICE NOTIFICATION: test_contact;test_host_0;test_ok_0;'
'WARNING;1;notify-service;Service is WARNING'),
])
# Notification not raised - too soon!
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [(
'warning',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;WARNING;2;Service is WARNING'
)])
# Notification not raised - too soon!
self.check(frozen_datetime, svc, 1, 'Service is WARNING', [(
'warning',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;WARNING;2;Service is WARNING'
)])
# Service goes OK
self.check(frozen_datetime, svc, 0, 'Service is OK', [
('info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;2;Service is OK'
),
('info',
'SERVICE ALERT: test_host_0;test_ok_0;OK;HARD;2;Service is OK'
),
('info',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;OK;HARD;2;eventhandler'
),
('info',
'SERVICE NOTIFICATION: test_contact;test_host_0;test_ok_0;OK;0;'
'notify-service;Service is OK')
])
self.check(frozen_datetime, svc, 0, 'Service is OK', [(
'info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;1;Service is OK'
)])
# Service goes CRITICAL
self.check(frozen_datetime, svc, 2, 'Service is CRITICAL', [
('error',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;CRITICAL;1;Service is CRITICAL'
),
('error',
'SERVICE ALERT: test_host_0;test_ok_0;CRITICAL;SOFT;1;Service is CRITICAL'
),
('error',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;CRITICAL;SOFT;1;eventhandler'
),
])
self.check(frozen_datetime, svc, 2, 'Service is CRITICAL', [
('error',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;CRITICAL;1;Service is CRITICAL'
),
('error',
'SERVICE ALERT: test_host_0;test_ok_0;CRITICAL;HARD;2;Service is CRITICAL'
),
('error',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;CRITICAL;HARD;2;eventhandler'
),
('error',
'SERVICE NOTIFICATION: test_contact;test_host_0;test_ok_0;'
'CRITICAL;1;notify-service;Service is CRITICAL')
])
# Service goes OK
self.check(frozen_datetime, svc, 0, 'Service is OK', [
('info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;2;Service is OK'
),
('info',
'SERVICE ALERT: test_host_0;test_ok_0;OK;HARD;2;Service is OK'
),
('info',
'SERVICE EVENT HANDLER: test_host_0;test_ok_0;OK;HARD;2;eventhandler'
),
('info',
'SERVICE NOTIFICATION: test_contact;test_host_0;test_ok_0;'
'OK;0;notify-service;Service is OK')
])
self.check(frozen_datetime, svc, 0, 'Service OK', [
('info',
'ACTIVE SERVICE CHECK: test_host_0;test_ok_0;OK;1;Service OK')
])
def test_logs_hosts(self):
""" Test logs for active / passive checks for hosts
:return: None
"""
self.setup_with_file('cfg/cfg_monitoring_logs.cfg')
assert self.conf_is_correct
self._scheduler.pushed_conf.log_initial_states = True
self._scheduler.pushed_conf.log_active_checks = True
self._scheduler.pushed_conf.log_passive_checks = True
host = self._scheduler.hosts.find_by_name("test_host_0")
# Make notifications interval set to 5 minutes
host.notification_interval = 5
host.checks_in_progress = []
host.act_depend_of = [] # ignore the router
host.event_handler_enabled = True
# Freeze the time !
initial_datetime = datetime.datetime(year=2018,
month=6,
day=1,
hour=18,
minute=30,
second=0)
with freeze_time(initial_datetime) as frozen_datetime:
assert frozen_datetime() == initial_datetime
# Host active checks
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', u'ACTIVE HOST CHECK: test_host_0;UP;0;Host is UP')])
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', u'ACTIVE HOST CHECK: test_host_0;UP;1;Host is UP')])
# Host goes DOWN / SOFT
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error',
'ACTIVE HOST CHECK: test_host_0;DOWN;1;Host is DOWN'),
('error', 'HOST ALERT: test_host_0;DOWN;SOFT;1;Host is DOWN'),
('error',
'HOST EVENT HANDLER: test_host_0;DOWN;SOFT;1;eventhandler'),
])
self.check(
frozen_datetime, host, 2, 'Host is DOWN',
[('error',
'ACTIVE HOST CHECK: test_host_0;DOWN;1;Host is DOWN'),
('error', 'HOST ALERT: test_host_0;DOWN;SOFT;2;Host is DOWN'),
('error',
'HOST EVENT HANDLER: test_host_0;DOWN;SOFT;2;eventhandler')])
# Host goes DOWN / HARD
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error',
'ACTIVE HOST CHECK: test_host_0;DOWN;2;Host is DOWN'),
('error', 'HOST ALERT: test_host_0;DOWN;HARD;3;Host is DOWN'),
('error',
'HOST EVENT HANDLER: test_host_0;DOWN;HARD;3;eventhandler'),
('error',
'HOST NOTIFICATION: test_contact;test_host_0;DOWN;1;notify-host;Host is DOWN'
)
])
# Notification not raised - too soon!
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error', 'ACTIVE HOST CHECK: test_host_0;DOWN;3;Host is DOWN')
])
# Notification not raised - too soon!
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error', 'ACTIVE HOST CHECK: test_host_0;DOWN;3;Host is DOWN')
])
# Host goes UP / HARD
# Get an host check, an alert and a notification
self.check(frozen_datetime, host, 0, 'Host is UP', [
('info', 'ACTIVE HOST CHECK: test_host_0;UP;3;Host is UP'),
('info', 'HOST ALERT: test_host_0;UP;HARD;3;Host is UP'),
('info',
'HOST EVENT HANDLER: test_host_0;UP;HARD;3;eventhandler'),
('info',
'HOST NOTIFICATION: test_contact;test_host_0;UP;0;notify-host;Host is UP'
)
])
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', 'ACTIVE HOST CHECK: test_host_0;UP;1;Host is UP')])
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', 'ACTIVE HOST CHECK: test_host_0;UP;1;Host is UP')])
from city_scrapers_core.constants import COMMISSION, PASSED
from city_scrapers_core.utils import file_response
from freezegun import freeze_time
from scrapy.settings import Settings
from city_scrapers.spiders.chi_community_development import ChiCommunityDevelopmentSpider
test_response = file_response(
join(dirname(__file__), "files", "chi_community_development.html"),
url=
'https://www.chicago.gov/city/en/depts/dcd/supp_info/community_developmentcommission.html'
)
spider = ChiCommunityDevelopmentSpider()
spider.settings = Settings(values={"CITY_SCRAPERS_ARCHIVE": False})
freezer = freeze_time("2018-05-01")
freezer.start()
parsed_items = [item for item in spider.parse(test_response)]
freezer.stop()
def test_meeting_count():
assert len(parsed_items) == 20
def test_unique_id_count():
assert len(set([item['id'] for item in parsed_items])) == 20
def test_logs_hosts_disabled(self):
""" Test disabled logs for active / passive checks for hosts
:return: None
"""
self.setup_with_file('cfg/cfg_monitoring_logs.cfg',
'cfg/cfg_monitoring_logs_disabled.ini')
assert self.conf_is_correct
self._sched = self._scheduler
host = self._scheduler.hosts.find_by_name("test_host_0")
# Make notifications sent very quickly
host.notification_interval = 10.0
host.checks_in_progress = []
host.act_depend_of = [] # ignore the router
host.event_handler_enabled = True
# Freeze the time !
initial_datetime = datetime.datetime(year=2018,
month=6,
day=1,
hour=18,
minute=30,
second=0)
with freeze_time(initial_datetime) as frozen_datetime:
assert frozen_datetime() == initial_datetime
# Host active checks
self.check(frozen_datetime, host, 0, 'Host is UP', [])
self.check(frozen_datetime, host, 0, 'Host is UP', [])
# Host goes DOWN / SOFT
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error', 'HOST ALERT: test_host_0;DOWN;SOFT;1;Host is DOWN')
])
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error', 'HOST ALERT: test_host_0;DOWN;SOFT;2;Host is DOWN')
])
# Host goes DOWN / HARD
self.check(frozen_datetime, host, 2, 'Host is DOWN', [
('error', 'HOST ALERT: test_host_0;DOWN;HARD;3;Host is DOWN')
])
# Host notification raised
self.check(frozen_datetime, host, 2, 'Host is DOWN', [])
self.check(frozen_datetime, host, 2, 'Host is DOWN', [])
# Host goes UP / HARD
# Get an host check, an alert and a notification
self.check(
frozen_datetime, host, 0, 'Host is UP',
[('info', 'HOST ALERT: test_host_0;UP;HARD;3;Host is UP')])
self.check(frozen_datetime, host, 0, 'Host is UP', [])
self.check(frozen_datetime, host, 0, 'Host is UP', [])
def test_calculate_usage(self) -> None:
self.team.event_names = ["$pageview", "custom event"]
self.team.event_properties = ["$current_url", "team_id", "value"]
self.team.save()
team2 = Team.objects.create()
with freeze_time("2020-08-01"):
# ignore stuff older than 30 days
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
with freeze_time("2020-10-01"):
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog2.com"
}],
},
)
DashboardItem.objects.create(
team=self.team,
filters={
"events": [{
"id": "custom event"
}],
"properties": [{
"key": "team_id",
"value": "3"
}]
},
)
DashboardItem.objects.create(
team=self.team,
filters={"events": [{
"id": "event that doesnt exist"
}]})
# broken dashboard item
DashboardItem.objects.create(team=self.team, filters={})
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
create_event(
distinct_id="test",
team=self.team,
event="$pageview",
properties={"$current_url": "https://posthog2.com"},
)
create_event(distinct_id="test",
team=self.team,
event="custom event",
properties={"team_id": "3"})
# team leakage
create_event(
distinct_id="test",
team=team2,
event="$pageview",
properties={"$current_url": "https://posthog.com"},
)
DashboardItem.objects.create(
team=team2,
filters={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$current_url",
"value": "https://posthog.com"
}],
},
)
calculate_event_property_usage_for_team(self.team.pk)
team = Team.objects.get(pk=self.team.pk)
self.assertEqual(
team.event_names_with_usage,
[
{
"event": "$pageview",
"usage_count": 2,
"volume": 2
},
{
"event": "custom event",
"usage_count": 1,
"volume": 1
},
],
)
self.assertEqual(
team.event_properties_with_usage,
[
{
"key": "$current_url",
"usage_count": 2,
"volume": 2
},
{
"key": "team_id",
"usage_count": 1,
"volume": 1
},
{
"key": "value",
"usage_count": 0,
"volume": 0
},
],
)
def test_todays_buckets(date, expected, freezer):
# assuming a ff.start_date of 2019-12-31
with freeze_time(date, tick=True):
ff = flippyflop.FlippyFlop(dummy_service, TEST_SPREADSHEET_ID)
result = ff._todays_buckets()
assert result == expected
def test_learner_data_multiple_courses(self, pacing, grade,
mock_course_api, mock_grades_api,
mock_certificate_api,
mock_enrollment_api):
enrollment1 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=self.enterprise_customer_user,
course_id=self.course_id,
)
course_id2 = 'course-v1:edX+DemoX+DemoCourse2'
enrollment2 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=self.enterprise_customer_user,
course_id=course_id2,
)
factories.DataSharingConsentFactory(
username=self.enterprise_customer_user.username,
course_id=course_id2,
enterprise_customer=self.enterprise_customer,
granted=True)
enrollment3 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=factories.EnterpriseCustomerUserFactory(
user_id=factories.UserFactory(username='******', id=2).id,
enterprise_customer=self.enterprise_customer,
),
course_id=self.course_id,
)
factories.DataSharingConsentFactory(
username='******',
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
granted=True)
def get_course_details(course_id):
"""
Mock course details - set course_id to match input
"""
return dict(pacing=pacing, course_id=course_id)
mock_course_api.return_value.get_course_details.side_effect = get_course_details
def get_course_certificate(course_id, username):
"""
Mock certificate data - return depending on course_id
"""
if '2' in course_id:
return dict(
username=username,
is_passing=True,
grade=grade,
)
else:
raise HttpNotFoundError
mock_certificate_api.return_value.get_course_certificate.side_effect = get_course_certificate
def get_course_grade(course_id, username):
"""
Mock grades data - set passed depending on course_id
"""
return dict(
passed='2' in course_id,
course_key=course_id,
username=username,
)
mock_grades_api.return_value.get_course_grade.side_effect = get_course_grade
# Mock enrollment data
mock_enrollment_api.return_value.get_course_enrollment.return_value = dict(
mode="verified")
# Collect the learner data, with time set to NOW
with freeze_time(self.NOW):
learner_data = list(self.exporter.export())
assert len(learner_data) == 6
assert learner_data[0].course_id == self.course_key
assert learner_data[1].course_id == self.course_id
for report1 in learner_data[0:1]:
assert report1.enterprise_course_enrollment_id == enrollment1.id
assert not report1.course_completed
assert report1.completed_timestamp is None
assert report1.grade == LearnerExporter.GRADE_INCOMPLETE
assert learner_data[2].course_id == self.course_key
assert learner_data[3].course_id == self.course_id
for report2 in learner_data[2:3]:
assert report2.enterprise_course_enrollment_id == enrollment3.id
assert not report2.course_completed
assert report2.completed_timestamp is None
assert report2.grade == LearnerExporter.GRADE_INCOMPLETE
assert learner_data[4].course_id == self.course_key
assert learner_data[5].course_id == course_id2
for report3 in learner_data[4:5]:
assert report3.enterprise_course_enrollment_id == enrollment2.id
# assert report3.course_id == course_id2
assert report3.course_completed
assert report3.completed_timestamp == self.NOW_TIMESTAMP
assert report3.grade == grade
# Get some data from the parent, if present
parent = data[name].get('parent')
if parent:
kwargs['parent'] = CertificateAuthority.objects.get(
name=parent)
kwargs['ca_crl_url'] = data[parent]['ca_crl_url']
# also update data
data[name]['crl'] = data[parent]['ca_crl_url']
freeze_now = now
if args.delay:
freeze_now += data[name]['delta']
with freeze_time(freeze_now):
ca = CertificateAuthority.objects.init(
name=data[name]['name'],
password=data[name]['password'],
subject=data[name]['subject'],
expires=datetime.utcnow() + data[name]['expires'],
key_type=data[name]['key_type'],
key_size=data[name]['key_size'],
algorithm=data[name]['algorithm'],
pathlen=data[name]['pathlen'],
**kwargs)
# Same values can only be added here because they require data from the already created CA
crl_path = reverse('django_ca:crl', kwargs={'serial': ca.serial})
ca.crl_url = '%s%s' % (testserver, crl_path)
ca.save()
