def setUp(self): super().setUp() set_current_instance(self.instance) self.device = G(GCMDevice) self.device.refresh_from_db() self.url = reverse('v1:gcm-devices-detail', args=(self.instance.name, self.device.registration_id)) self.config = GCMConfig.objects.create(development_api_key='123qwe')
def test_storage_limit_causes_a_block(self): set_current_instance(self.instance) klass = G(Klass, schema=[{ 'name': 'file', 'type': 'file' }], name='test', description='test') url = reverse('v1:dataobject-list', args=(self.instance.name, klass.name)) with tempfile.NamedTemporaryFile() as tmp_file: tmp_file.write(b'*' * 1000) tmp_file.seek(0) response = self.client.post(url, {'file': tmp_file}, format='multipart') self.assertEqual(response.status_code, status.HTTP_201_CREATED) with tempfile.NamedTemporaryFile() as tmp_file: tmp_file.write(b'*' * 1000) tmp_file.seek(0) response = self.client.post(url, {'file': tmp_file}, format='multipart') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def _migrate_tenants(self, tenants, apps): for tenant in tenants: db = get_instance_db(tenant) connection = connections[db] set_current_instance(tenant) self._notice("=== Running migrate for schema: %s" % tenant.schema_name) signals.pre_tenant_migrate.send(sender=tenant, tenant=tenant, verbosity=self.verbosity, using=connection.alias) schema_created = self._migrate_schema(connection, tenant) with ignore_signal(post_migrate): self.run_migrations(connection, apps, schema_created=schema_created, skip_checks=True) signals.post_tenant_migrate.send( sender=tenant, tenant=tenant, verbosity=self.verbosity, using=connection.alias, created=schema_created, partial=False, )
def setUp(self): super().setUp() set_current_instance(self.instance) schema = [ { 'name': 'name', 'type': 'string' }, { 'name': 'ref', 'type': 'reference', 'target': 'self' }, { 'name': 'user', 'type': 'reference', 'target': 'user' }, ] self.klass = G(Klass, schema=schema, name='test', description='test') DataObject.load_klass(self.klass) self.object = G(DataObject, _klass=self.klass, name='a') self.user = G(User) DataObject.load_klass(self.klass) self.object_2 = G(DataObject, _klass=self.klass, name='b', user=self.user.pk, ref=self.object.pk) self.hla = G(DataObjectHighLevelApi, klass=self.klass) self.endpoint_url = reverse('v2:hla-objects-endpoint', args=[self.instance.name, self.hla.name])
def setUp(self): super().setUp() set_current_instance(self.instance) self.socket = G(Socket, name='name', status=Socket.STATUSES.OK) self.schedule = G(CodeBoxSchedule, socket=self.socket) self.url = reverse('v1:codebox-schedule-detail', args=(self.instance.name, self.schedule.id,))
def setUp(self): super().setUp() instance_data = { 'name': 'anothertestinstance', 'description': 'another test desc', 'owner': self.admin } self.another_instance = G(Instance, **instance_data) self.admin.add_to_instance(self.another_instance) set_current_instance(self.instance) self.hosting = G(Hosting, name='test_name_one', description='test_description') set_current_instance(self.another_instance) self.another_hosting = G(Hosting, name='test_name_two', description='test_description') self.url = reverse('v1.1:hosting-list', args=(self.instance.name,)) self.detail_url = reverse('v1.1:hosting-detail', args=(self.instance.name, self.hosting.id)) self.another_url = reverse('v1.1:hosting-list', args=(self.another_instance.name,)) self.another_detail_url = reverse('v1.1:hosting-detail', args=(self.another_instance.name, self.another_hosting.id)) self.hosting_data = { 'name': 'some_name', 'description': 'some_description', 'domains': ['test.test.io'] }
def setUp(self): super().setUp() set_current_instance(self.instance) self.webhook = Webhook.objects.create(name='webhook', codebox=G(CodeBox)) self.url = reverse('v1:webhook-detail', args=(self.instance.name, self.webhook.name,))
def test_user_is_created_only_once(self): self.client.post(self.url, self.post_data) set_current_instance(self.instance) self.assertEquals(User.objects.count(), 1) self.client.post(self.url, self.post_data) self.assertEquals(User.objects.count(), 1)
def instance_context(instance): previous_instance = get_current_instance() try: set_current_instance(instance) yield finally: set_current_instance(previous_instance)
def setUp(self): super().setUp() set_current_instance(self.instance) self.config = G(GCMConfig, development_api_key='test') self.message = G(GCMMessage) self.url = reverse('v1:gcm-messages-detail', args=(self.instance.name, self.message.pk))
def setUp(self): super().setUp() set_current_instance(self.instance) self.klass = G(Klass, schema=[{ 'name': 'name', 'type': 'string' }, { 'name': 'geo', 'type': 'geopoint', 'filter_index': True }], name='klas') DataObject.load_klass(self.klass) for name, geo_data in ( ('Warsaw', Point(21.0122, 52.2297)), ('Krakow', Point(19.9450, 50.0647)), # 252km distance ('Lodz', Point(19.4560, 51.7592)), # 119km ('Otwock', Point(21.2616, 52.1053)), # 21km ('empty', None)): DataObject.objects.create(_klass=self.klass, name=name, geo=geo_data) self.url = reverse('v1:dataobject-list', args=(self.instance.name, self.klass.name))
def setUp(self): super().setUp() set_current_instance(self.instance) self.config = G(APNSConfig) self.message = G(APNSMessage) self.url = reverse('v1:apns-messages-detail', args=(self.instance.name, self.message.pk))
def test_if_codebox_run_increments_instance_counter(self): self.assertIsNone(redis.get(self.codebox_limit_key)) CodeBoxTask.delay(**self.run_kwargs) set_current_instance(self.instance) self.assertEqual(redis.get(self.codebox_limit_key), b'1')
def get_incentive(self, instance, incentive_pk): set_current_instance(instance) try: incentive = Cached(self.incentive_class, kwargs={'pk': incentive_pk}).get() except self.incentive_class.DoesNotExist: self.get_logger().warning( "%s[pk=%s] for %s cannot be run, because script was not found.", self.incentive_class.__name__, incentive_pk, instance) return None if hasattr(incentive, 'codebox_id'): try: incentive.codebox = Cached(CodeBox, kwargs={'pk': incentive.codebox_id}).get() except CodeBox.DoesNotExist: self.get_logger().warning( "%s[pk=%s] for %s cannot be run, because script was not found.", self.incentive_class.__name__, incentive.pk, instance) return None socket = None if incentive.socket_id: try: socket = Cached(Socket, kwargs={'pk': incentive.socket_id}).get() except Socket.DoesNotExist: pass incentive.socket = socket return incentive
def run(self, trace_spec, result_info): instance = self._get_instance(trace_spec) if not instance: return set_current_instance(instance) trace_class = self._get_trace_class(trace_spec) trace = self._get_trace(trace_spec, trace_class) for k, v in result_info.items(): setattr(trace, k, v) if not trace._saved: # If we're dealing with unsaved object, we need the list key as well so pass kwargs for it trace.save(**self._get_trace_context(trace_spec)) else: trace.save(update_fields=result_info.keys()) if trace_spec['type'] == 'schedule': ScheduleNextTask.delay(instance_pk=trace_spec['instance_id'], schedule_id=trace_spec['obj_id']) if 'socket' in trace_spec: self.publish_log(instance, trace, trace_spec) codebox_finished.send(sender=trace_class, instance=instance, object_id=trace_spec['obj_id'], trace=trace)
def test_user_is_created(self): set_current_instance(self.instance) self.assertFalse(User.objects.exists()) self.client.post(self.url, self.post_data) set_current_instance(self.instance) self.assertTrue(User.objects.exists())
def run(self, instance_pks): for instance_pk in instance_pks: instance = _get_instance(instance_pk) if instance is None: continue if not OwnerInGoodStanding.is_admin_in_good_standing( instance.owner_id): continue set_current_instance(instance) schedules = CodeBoxSchedule.objects.get_for_process() for schedule in schedules: key = PERIODIC_SCHEDULE_TEMPLATE.format( instance_pk=instance.pk, schedule_pk=schedule.pk, scheduled_at=schedule.scheduled_next.isoformat()) can_run = redis.set(name=key, value=1, nx=True, ex=SCHEDULE_TRACE_TIMEOUT) if not can_run: time_in_queue = timezone.now() - schedule.scheduled_next if time_in_queue > timedelta(minutes=2): self.get_logger().warning( "%s in %s cannot be run yet, because it was already scheduled for %s, time in queue: %s.", schedule, instance, schedule.scheduled_next.isoformat(), time_in_queue) else: ScheduleTask.delay(schedule.id, instance_pk) if schedules: admin = Cached(Admin, kwargs={'id': instance.owner_id}).get() admin.update_last_access()
def publish_log(self, instance, trace, trace_spec): serializer_class = self._get_serializer_class(trace_spec) view_kwargs = self._get_trace_context(trace_spec) view_kwargs['instance'] = instance trace.executed_at = parse_datetime(trace.executed_at) payload = serializer_class(trace, excluded_fields=('links', )).data trace_self_link = reverse('{}:{}'.format( self.api_version, serializer_class.hyperlinks[0][1]), args=(instance.name, trace_spec['obj_name'] or trace_spec['obj_id'], trace.pk)) payload['links'] = {'self': trace_self_link} socket = trace_spec['socket'] room = 'socket:{}'.format(socket) metadata = {'type': 'trace', 'socket': socket} if trace_spec['type'] == 'socket_endpoint': metadata['source'] = 'endpoint' metadata['endpoint'] = trace_spec['obj_name'] elif trace_spec['type'] in ('trigger', 'schedule'): metadata['source'] = 'event_handler' metadata['event_handler'] = trace_spec['event_handler'] set_current_instance(instance) channel = Channel.get_eventlog() channel.create_change(room=room, author={}, metadata=metadata, payload=payload, action=Change.ACTIONS.CUSTOM)
def initialize_request(self, request, *args, **kwargs): instance = getattr(request, 'instance', kwargs.get('instance', None)) if not isinstance(instance, Instance): value = instance.lower() instance = None if INSTANCE_NAME_REGEX.match(value): try: instance = Cached(Instance, kwargs=dict(name=value)).get() except Instance.DoesNotExist: pass if instance is not None: try: self.validate_instance(instance) if getattr(request, 'instance', None) is None and request.META.get( 'HTTP_HOST_TYPE') != 'hosting': admin = Cached(Admin, kwargs={ 'id': instance.owner_id }).get() admin.update_last_access() self.kwargs['instance'] = instance set_current_instance(instance) except SyncanoException as ex: request.error = ex instance = None request.instance = instance return super().initialize_request(request, *args, **kwargs)
def run(self, model_class_name, object_pk, instance_pk=None, **kwargs): logger = self.get_logger() try: model_class = apps.get_model(model_class_name) except (LookupError, ValueError): # do not retry raise if instance_pk is not None: try: instance = Cached(Instance, kwargs=dict(pk=instance_pk)).get() set_current_instance(instance) except Instance.DoesNotExist: logger.warning( 'Error occurred during deletion of %s[pk=%s] in Instance[pk=%s]. ' 'Instance no longer exists.', model_class_name, object_pk, instance_pk) return logger.info('Deleting %s[pk=%s] in %s.', model_class_name, object_pk, instance) else: logger.info('Deleting %s[pk=%s] in public schema.', model_class_name, object_pk) try: db = router.db_for_write(model_class) with transaction.atomic(db): model_class.all_objects.filter(pk=object_pk).delete() except Exception as exc: raise self.retry(exc=exc)
def test_codebox_task_handles_dead_codebox(self): self.schedule.schedule_now() self.schedule.codebox.soft_delete() ScheduleTask.delay(self.schedule.pk, self.instance.pk) set_current_instance(self.instance) trace_list = ScheduleTrace.list(schedule=self.schedule) self.assertEqual(len(trace_list), 0)
def setUp(self): super().setUp() set_current_instance(self.instance) self.config = G(APNSConfig) self.url = reverse('v1:apns-messages-list', args=(self.instance.name, ))
def setUp(self): self.instance = G(Instance, name='testtest') self.admin = G(Admin, is_active=True) self.admin.add_to_instance(self.instance) self.apikey = self.admin.key self.client.defaults['HTTP_X_API_KEY'] = self.apikey source = 'print META' runtime_name = LATEST_PYTHON_RUNTIME set_current_instance(self.instance) self.codebox = CodeBox.objects.create(label='test', source=source, runtime_name=runtime_name) self.klass = G(Klass, name='dog', schema=[{ 'name': 'name', 'type': 'string' }]) DataObject._meta.get_field('_data').reload_schema(None) self.signal = 'post_delete' klass_pk = self.klass.pk self.event_characteristics = (self.signal, klass_pk) self.trigger = Trigger.objects.create(signal=self.signal, codebox=self.codebox, klass=self.klass)
def setUp(self): super().setUp() set_current_instance(self.instance) self.socket = G(Socket, name='name', status=Socket.STATUSES.OK) self.hosting = G(Hosting, socket=self.socket) self.edit_url = reverse('v1.1:hosting-detail', args=(self.instance.name, self.hosting.id,)) self.set_default_url = reverse('v1.1:hosting-set-default', args=(self.instance.name, self.hosting.id,))
def test_running_codebox_with_crontab_schedule(self): self.schedule.interval_sec = None self.schedule.crontab = "2 * * * *" self.schedule.schedule_now() ScheduleTask.delay(self.schedule.pk, self.instance.pk) set_current_instance(self.instance) trace_list = ScheduleTrace.list(schedule=self.schedule) self.assertEqual(len(trace_list), 1)
def test_schedule_with_dead_codebox_will_not_be_run( self, codebox_task_mock): self.schedule.schedule_now() codebox = self.schedule.codebox codebox.soft_delete() SchedulerDispatcher.delay() set_current_instance(self.instance) self.assertFalse(codebox_task_mock.called)
def test_running_task(self): codebox = self.create_codebox() CodeBoxTask.delay(incentive_pk=codebox.id, instance_pk=self.instance.pk) set_current_instance(self.instance) self.assertEqual( CodeBoxTrace.list(codebox=codebox)[0].result['stdout'], "hello")
def test_schedule_tasks_integration(self, process_mock): self.schedule_tasks(self.instance.pk, Trigger.objects.all(), {'name': 'Brunhilda'}) set_current_instance(self.instance) traces_list = TriggerTrace.list(trigger=self.trigger) self.assertEqual(len(traces_list), 1) last_trace = traces_list[0] self.assertEqual(last_trace.status, 'success')
def setUp(self): super().setUp() set_current_instance(self.instance) self.socket = G(Socket, name='name', status=Socket.STATUSES.OK) self.script = G(CodeBox, socket=self.socket) self.edit_url = reverse('v1:codebox-detail', args=(self.instance.name, self.script.id,)) self.run_url = reverse('v1:codebox-run', args=(self.instance.name, self.script.id,))
def setUp(self): super().setUp() set_current_instance(self.instance) self.socket = G(Socket, name='name', status=Socket.STATUSES.OK) self.webhook = G(Webhook, socket=self.socket) self.edit_url = reverse('v1:webhook-detail', args=(self.instance.name, self.webhook.name,)) self.run_url = reverse('v1:webhook-run', args=(self.instance.name, self.webhook.name,))