def test_get_or_create_stranger__stranger_not_found(self):
from randtalkbot.stranger_service import Stranger as stranger_cls_mock
stranger_cls_mock.get.side_effect = DoesNotExist()
stranger_cls_mock.create.return_value = self.stranger_0
self.stranger_service.get_cached_stranger = Mock()
self.stranger_service.get_cached_stranger.return_value = 'cached_stranger'
self.assertEqual(
self.stranger_service.get_or_create_stranger(31416),
'cached_stranger',
)
self.stranger_service.get_cached_stranger.assert_called_once_with(
self.stranger_0)
def find_user(uid, is_admin=False):
cond = (
Users.disabled == False,
Users.id == uid,
)
if is_admin:
cond += (Users.is_admin == is_admin, )
q = Users.select().where(*cond)
if not q.count():
raise DoesNotExist("User doesn't exists")
return q.limit(1)[0]
def validate(self, class_name, id): # type: (str, Optional[int]) -> None
if self._field is None:
if not isinstance(self._limits, tuple):
raise RuntimeError('Expected a fixed limit')
limits = self._limits
else:
if not callable(self._limits):
raise RuntimeError('Expected a limit generator')
container = MemoryFieldContainer(name='id',
memory_field=self._field,
memory_address=self._field.get_address(None))
limits = self._limits(container.decode())
if id is None or not (limits[0] <= id <= limits[1]):
if limits[0] > limits[1]:
limit_info = 'No records available.'
elif limits[0] == limits[1]:
limit_info = 'Only one records available: {0}'.format(limits[0])
else:
limit_info = 'Available records: {0} <= id <= {1}'.format(limits[0], limits[1])
raise DoesNotExist('Could not find {0}({1}). {2}'.format(class_name, '' if id is None else id, limit_info))
async def get_next_step(self):
with db.connection_context():
try:
# Get the next step
step = ExperimentStep.select().where(
ExperimentStep.step_done == False).order_by(
ExperimentStep.id).first()
# Check if the step is none, and skip to the catch clause if it is
if step is None:
raise DoesNotExist('Step does not exist')
# Check if the step has an associated datapoint
if DataPoint.select().where(
ExperimentStep == step).count() < 1:
step.generate_datapoint()
# Convert step to dict
step_d = model_to_dict(step)
# Set the experiment id (different from the step id)
step_d['experiment_configuration_id'] = step_d[
'experiment_configuration']['id']
# Remove datetime and experiment configuration from the dict
# They are not needed in the client, and they are not directly serializable to json (due to missing datetime format)
del (step_d['created'])
del (step_d['experiment_configuration'])
# Return the step if it exists
return step_d
# Check if the step even exists
except DoesNotExist:
# It is OK if it does not exist, we should just stop measuring
print('No more steps ready')
# Return None if no step exists
return None
def save_pulse_counters(self, pulse_counters): # type: (List[PulseCounterDTO]) -> None
pulse_counters_to_save = []
for pulse_counter_dto in pulse_counters:
pulse_counter = PulseCounter.get_or_none(number=pulse_counter_dto.id) # type: PulseCounter
if pulse_counter is None:
raise DoesNotExist('A PulseCounter with id {0} could not be found'.format(pulse_counter_dto.id))
if pulse_counter.source == 'master':
# Only master pulse counters will be passed to the MasterController batch save
pulse_counters_to_save.append(pulse_counter_dto)
if 'name' in pulse_counter_dto.loaded_fields:
pulse_counter.name = pulse_counter_dto.name
elif pulse_counter.source == 'gateway':
pulse_counter = PulseCounterMapper.dto_to_orm(pulse_counter_dto)
else:
logger.warning('Trying to save a PulseCounter with unknown source {0}'.format(pulse_counter.source))
continue
if 'room' in pulse_counter_dto.loaded_fields:
if pulse_counter_dto.room is None:
pulse_counter.room = None
elif 0 <= pulse_counter_dto.room <= 100:
pulse_counter.room, _ = Room.get_or_create(number=pulse_counter_dto.room)
pulse_counter.save()
self._master_controller.save_pulse_counters(pulse_counters_to_save)
def test_create_reset_password_token_with_unknown_email(get_mock):
get_mock.side_effect = DoesNotExist()
result = CreateResetPasswordToken().execute(email='unknown_email')
assert not result
def test_sign_in_with_unknown_token(get_mock):
get_mock.side_effect = DoesNotExist()
with pytest.raises(InvalidCredentialsError):
SignIn().execute(email='*****@*****.**', password='******')
def mock_not_found_Account_get(*args, **kwargs):
raise DoesNotExist()
def mock_get(*args, **kwargs):
raise DoesNotExist()
def test_reset_password_with_unknown_email(get_mock):
get_mock.side_effect = DoesNotExist()
with pytest.raises(DoesNotExist):
ResetPassword().execute(reset_password_token='unknown',
password='******')
def test_activate_user_with_unknown_token(get_mock):
get_mock.side_effect = DoesNotExist()
with pytest.raises(DoesNotExist):
ActivateUser().execute(activation_token='unknown_token')