def verify_file(self, path): return ImageService.verify_file(path)
def test_get_revision(self): image = Generators.image(is_wip=True) revision = Generators.imageRevision(image=image) self.assertEqual(ImageService(image).get_revision(revision.label), revision)
def test_get_final_revision(self): image = Generators.image(is_wip=True) final = Generators.imageRevision(image=image, is_final=True) Generators.imageRevision(image=image, is_final=False, label='C') self.assertEqual(ImageService(image).get_final_revision(), final)
def test_display_download_menu_everybody(self): image = Generators.image(download_limitations=DownloadLimitation.EVERYBODY) self.assertTrue(ImageService(image).display_download_menu(image.user)) self.assertTrue(ImageService(image).display_download_menu(Generators.user())) self.assertTrue(ImageService(image).display_download_menu(AnonymousUser))
def test_get_next_available_revision_label_after_z(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image, label='Z') self.assertEqual(ImageService(image).get_next_available_revision_label(), 'BA')
def test_needs_premium_subscription_to_platesolve_solar_system(self, is_platesolvable): image = Generators.image() is_platesolvable.return_value = False self.assertFalse(ImageService(image).needs_premium_subscription_to_platesolve())
def test_display_download_menu_me_only(self): image = Generators.image(download_limitations=DownloadLimitation.ME_ONLY) self.assertTrue(ImageService(image).display_download_menu(image.user)) self.assertFalse(ImageService(image).display_download_menu(Generators.user())) self.assertFalse(ImageService(image).display_download_menu(AnonymousUser))
def test_get_crop_box_collection(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '100,100,200,200' self.assertEqual(ImageService(image).get_crop_box('collection'), '100,100,200,200')
def test_get_crop_box_iotd_top_left(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '100,100,200,200' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,0,1000,380')
def test_get_default_cropping_rectangular(self): image = Generators.image(is_wip=True) image.w = 1000 image.h = 600 self.assertEqual(ImageService(image).get_default_cropping(), '200,0,800,600')
def test_get_crop_box_gallery_inverted(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '100,100,200,200' self.assertEqual(ImageService(image).get_crop_box('gallery_inverted'), '100,100,200,200')
def test_get_default_cropping_revision(self, get_revision): image = Generators.image(is_wip=True) revision = Generators.imageRevision(image=image) revision.w = revision.h = 1000 get_revision.return_value = revision self.assertEqual(ImageService(image).get_default_cropping(revision_label=revision.label), '0,0,1000,1000')
def common_variables(request): from django_user_agents.utils import get_and_set_user_agent from django_bouncy.models import Bounce, Complaint get_and_set_user_agent(request) hard_bounces = None soft_bounces = None complained = False if request.user.is_authenticated(): cache_key = 'hard_bounces_%d' % request.user.pk hard_bounces = cache.get(cache_key) if hard_bounces is None: hard_bounces = Bounce.objects.filter( hard=True, address=request.user.email, bounce_type="Permanent") cache.set(cache_key, hard_bounces, 3600) cache_key = 'soft_bounces_%d' % request.user.pk soft_bounces = cache.get(cache_key) if soft_bounces is None: soft_bounces = Bounce.objects.filter( hard=False, address=request.user.email, bounce_type="Transient", created_at__gte=datetime.now() - timedelta(days=7))[:3] cache.set(cache_key, soft_bounces, 3600) cache_key = 'complained_%d' % request.user.pk complained = cache.get(cache_key) if complained is None: complained = Complaint.objects.filter(address=request.user.email).exists() cache.set(cache_key, complained, 3600) d = { 'True': True, 'False': False, 'STATIC_URL': settings.STATIC_URL, 'LANGUAGE_CODE': request.LANGUAGE_CODE if hasattr(request, "LANGUAGE_CODE") else "en", 'DEBUG_MODE': settings.DEBUG, 'REQUEST_COUNTRY': get_client_country_code(request), 'IMAGES_URL': settings.IMAGES_URL, 'MEDIA_URL': settings.MEDIA_URL, 'ADS_ENABLED': settings.ADS_ENABLED, 'ADSENSE_ENABLED': settings.ADSENSE_ENABLED, 'ADMANAGER_PUBLISHER_ID': settings.ADMANAGER_PUBLISHER_ID, 'NATIVE_RESPONSIVE_WIDE_SLOT': settings.NATIVE_RESPONSIVE_WIDE_SLOT, 'NATIVE_RESPONSIVE_RECTANGULAR_SLOT': settings.NATIVE_RESPONSIVE_RECTANGULAR_SLOT, 'NATIVE_RESPONSIVE_RECTANGULAR_SLOT_2': settings.NATIVE_RESPONSIVE_RECTANGULAR_SLOT_2, 'DONATIONS_ENABLED': settings.DONATIONS_ENABLED, 'PREMIUM_ENABLED': settings.PREMIUM_ENABLED, 'PREMIUM_MAX_IMAGES_FREE': settings.PREMIUM_MAX_IMAGES_FREE, 'PREMIUM_MAX_IMAGES_LITE': settings.PREMIUM_MAX_IMAGES_LITE, 'PREMIUM_MAX_IMAGES_FREE_2020': settings.PREMIUM_MAX_IMAGES_FREE_2020, 'PREMIUM_MAX_IMAGES_LITE_2020': settings.PREMIUM_MAX_IMAGES_LITE_2020, 'PREMIUM_MAX_IMAGES_PREMIUM_2020': settings.PREMIUM_MAX_IMAGES_PREMIUM_2020, 'PREMIUM_MAX_IMAGE_SIZE_FREE_2020': settings.PREMIUM_MAX_IMAGE_SIZE_FREE_2020, 'PREMIUM_MAX_IMAGE_SIZE_LITE_2020': settings.PREMIUM_MAX_IMAGE_SIZE_LITE_2020, 'PREMIUM_MAX_IMAGE_SIZE_PREMIUM_2020': settings.PREMIUM_MAX_IMAGE_SIZE_PREMIUM_2020, 'PREMIUM_MAX_REVISIONS_FREE_2020': settings.PREMIUM_MAX_REVISIONS_FREE_2020, 'PREMIUM_MAX_REVISIONS_LITE_2020': settings.PREMIUM_MAX_REVISIONS_LITE_2020, 'PREMIUM_MAX_REVISIONS_PREMIUM_2020': settings.PREMIUM_MAX_REVISIONS_PREMIUM_2020, 'PREMIUM_PRICE_FREE_2020': settings.PREMIUM_PRICE_FREE_2020, 'PREMIUM_PRICE_LITE_2020': settings.PREMIUM_PRICE_LITE_2020, 'PREMIUM_PRICE_PREMIUM_2020': settings.PREMIUM_PRICE_PREMIUM_2020, 'PREMIUM_PRICE_ULTIMATE_2020': settings.PREMIUM_PRICE_ULTIMATE_2020, 'PAYPAL_TEST': settings.PAYPAL_TEST, 'IOTD_SHOW_CHOOSING_JUDGE': settings.IOTD_SHOW_CHOOSING_JUDGE, 'ENABLE_SOLVING': settings.ENABLE_SOLVING, 'GOOGLE_ANALYTICS_ID': settings.GOOGLE_ANALYTICS_ID, 'GOOGLE_ADS_ID': settings.GOOGLE_ADS_ID, 'READONLY_MODE': settings.READONLY_MODE, 'HARD_BOUNCES': hard_bounces, 'SOFT_BOUNCES': soft_bounces, 'HAS_COMPLAINT': complained, 'COUNTRIES': COUNTRIES, 'COOKIELAW_ACCEPTED': request.COOKIES.get('cookielaw_accepted', False), 'AUTOMATIC_RECOVERY_CONFIRMATION_BEGINS': Image.all_objects.filter( user=request.user, corrupted=True, recovered__isnull=False).order_by('recovered').first().recovered + timedelta(days=14) \ if request.user.is_authenticated() and \ Image.all_objects.filter( user=request.user, corrupted=True, recovered__isnull=False).exists() \ else None, 'min_index_to_like': settings.MIN_INDEX_TO_LIKE, 'enums': { 'SubjectType': SubjectType, }, } if request.user.is_authenticated() and request.user.userprofile.is_image_moderator(): d['images_pending_moderation_no'] = ImageService().get_images_pending_moderation().count() return d
def get_context_data(self, **kwargs): context = super(ImageDetailView, self).get_context_data(**kwargs) image = context['object'] r = self.kwargs.get('r') if r is None: r = '0' revision_image = None instance_to_platesolve = image is_revision = False if r != '0': try: revision_image = ImageRevision.objects.filter(image=image, label=r)[0] instance_to_platesolve = revision_image is_revision = True except: pass ############################# # GENERATE ACQUISITION DATA # ############################# from astrobin.moon import MoonPhase gear_list = ( (_('Imaging telescopes or lenses'), image.imaging_telescopes.all(), 'imaging_telescopes'), (_('Imaging cameras'), image.imaging_cameras.all(), 'imaging_cameras'), (_('Mounts'), image.mounts.all(), 'mounts'), (_('Guiding telescopes or lenses'), image.guiding_telescopes.all(), 'guiding_telescopes'), (_('Guiding cameras'), image.guiding_cameras.all(), 'guiding_cameras'), (_('Focal reducers'), image.focal_reducers.all(), 'focal_reducers'), (_('Software'), image.software.all(), 'software'), (_('Filters'), image.filters.all(), 'filters'), (_('Accessory'), image.accessories.all(), 'accessories'), ) makes_list = ','.join( filter( None, reduce(lambda x, y: x + y, [ list(x.values_list('make', flat=True)) for x in [y[1] for y in gear_list] ]))) deep_sky_acquisitions = DeepSky_Acquisition.objects.filter(image=image) ssa = None image_type = None deep_sky_data = {} if is_revision: w, h = get_image_resolution(revision_image) else: w, h = get_image_resolution(image) try: ssa = SolarSystem_Acquisition.objects.get(image=image) except SolarSystem_Acquisition.DoesNotExist: pass if deep_sky_acquisitions: image_type = 'deep_sky' moon_age_list = [] moon_illuminated_list = [] dsa_data = { 'dates': [], 'frames': {}, 'integration': 0, 'darks': [], 'flats': [], 'flat_darks': [], 'bias': [], 'bortle': [], 'mean_sqm': [], 'mean_fwhm': [], 'temperature': [], } for a in deep_sky_acquisitions: if a.date is not None and a.date not in dsa_data['dates']: dsa_data['dates'].append(a.date) m = MoonPhase(a.date) moon_age_list.append(m.age) moon_illuminated_list.append(m.illuminated * 100.0) if a.number and a.duration: key = "" if a.filter is not None: key = "filter(%s)" % a.filter.get_name() if a.iso is not None: key += '-ISO(%d)' % a.iso if a.gain is not None: key += '-gain(%.2f)' % a.gain if a.sensor_cooling is not None: key += '-temp(%d)' % a.sensor_cooling if a.binning is not None: key += '-bin(%d)' % a.binning key += '-duration(%d)' % a.duration try: current_frames = dsa_data['frames'][key]['integration'] except KeyError: current_frames = '0x0"' integration_re = re.match(r'^(\d+)x(\d+)"$', current_frames) current_number = int(integration_re.group(1)) dsa_data['frames'][key] = {} dsa_data['frames'][key][ 'filter_url'] = a.filter.get_absolute_url( ) if a.filter is not None else '#' dsa_data['frames'][key][ 'filter'] = a.filter if a.filter is not None else '' dsa_data['frames'][key][ 'iso'] = 'ISO%d' % a.iso if a.iso is not None else '' dsa_data['frames'][key][ 'gain'] = '(gain: %.2f)' % a.gain if a.gain is not None else '' dsa_data['frames'][key][ 'sensor_cooling'] = '%dC' % a.sensor_cooling if a.sensor_cooling is not None else '' dsa_data['frames'][key]['binning'] = 'bin %sx%s' % ( a.binning, a.binning) if a.binning else '' dsa_data['frames'][key]['integration'] = '%sx%s"' % ( current_number + a.number, a.duration) dsa_data['integration'] += (a.duration * a.number / 3600.0) for i in ['darks', 'flats', 'flat_darks', 'bias']: if a.filter and getattr(a, i): dsa_data[i].append("%d" % getattr(a, i)) elif getattr(a, i): dsa_data[i].append(getattr(a, i)) if a.bortle: dsa_data['bortle'].append(a.bortle) if a.mean_sqm: dsa_data['mean_sqm'].append(a.mean_sqm) if a.mean_fwhm: dsa_data['mean_fwhm'].append(a.mean_fwhm) if a.temperature: dsa_data['temperature'].append(a.temperature) def average(values): if not len(values): return 0 return float(sum(values)) / len(values) frames_list = sorted(dsa_data['frames'].items()) deep_sky_data = ( (_('Dates'), sorted(dsa_data['dates'])), (_('Frames'), ('\n' if len(frames_list) > 1 else '') + u'\n'.join("%s %s" % ( "<a href=\"%s\">%s</a>:" % (f[1]['filter_url'], f[1]['filter']) if f[1]['filter'] else '', "%s %s %s %s %s" % (f[1]['integration'], f[1]['iso'], f[1]['gain'], f[1]['sensor_cooling'], f[1]['binning']), ) for f in frames_list)), (_('Integration'), "%.1f %s" % (dsa_data['integration'], _("hours"))), (_('Darks'), '~%d' % (int(reduce(lambda x, y: int(x) + int(y), dsa_data['darks'])) / len(dsa_data['darks'])) if dsa_data['darks'] else 0), (_('Flats'), '~%d' % (int(reduce(lambda x, y: int(x) + int(y), dsa_data['flats'])) / len(dsa_data['flats'])) if dsa_data['flats'] else 0), (_('Flat darks'), '~%d' % (int( reduce(lambda x, y: int(x) + int(y), dsa_data['flat_darks'])) / len(dsa_data['flat_darks'])) if dsa_data['flat_darks'] else 0), (_('Bias'), '~%d' % (int(reduce(lambda x, y: int(x) + int(y), dsa_data['bias'])) / len(dsa_data['bias'])) if dsa_data['bias'] else 0), (_('Avg. Moon age'), ("%.2f " % (average(moon_age_list), ) + _("days")) if moon_age_list else None), (_('Avg. Moon phase'), "%.2f%%" % (average(moon_illuminated_list), ) if moon_illuminated_list else None), (_('Bortle Dark-Sky Scale'), "%.2f" % (average([float(x) for x in dsa_data['bortle']])) if dsa_data['bortle'] else None), (_('Mean SQM'), "%.2f" % (average([float(x) for x in dsa_data['mean_sqm']])) if dsa_data['mean_sqm'] else None), (_('Mean FWHM'), "%.2f" % (average([float(x) for x in dsa_data['mean_fwhm']])) if dsa_data['mean_fwhm'] else None), (_('Temperature'), "%.2f" % (average([float(x) for x in dsa_data['temperature']])) if dsa_data['temperature'] else None), ) elif ssa: image_type = 'solar_system' profile = None if self.request.user.is_authenticated(): profile = self.request.user.userprofile ############## # BASIC DATA # ############## published_on = \ to_user_timezone(image.uploaded, profile) \ if profile else image.uploaded if image.published: published_on = \ to_user_timezone(image.published, profile) \ if profile else image.published alias = 'regular' if not image.sharpen_thumbnails else 'regular_sharpened' mod = self.request.GET.get('mod') if mod == 'inverted': alias = 'regular_inverted' subjects = [] skyplot_zoom1 = None if image.solution: subjects = SolutionService(image.solution).get_objects_in_field() skyplot_zoom1 = image.solution.skyplot_zoom1 if is_revision and revision_image.solution: subjects = SolutionService( revision_image.solution).get_objects_in_field() if revision_image.solution.skyplot_zoom1: skyplot_zoom1 = revision_image.solution.skyplot_zoom1 licenses = ( (0, 'cc/c.png', LICENSE_CHOICES[0][1]), (1, 'cc/cc-by-nc-sa.png', LICENSE_CHOICES[1][1]), (2, 'cc/cc-by-nc.png', LICENSE_CHOICES[2][1]), (3, 'cc/cc-by-nc-nd.png', LICENSE_CHOICES[3][1]), (4, 'cc/cc-by.png', LICENSE_CHOICES[4][1]), (5, 'cc/cc-by-sa.png', LICENSE_CHOICES[5][1]), (6, 'cc/cc-by-nd.png', LICENSE_CHOICES[6][1]), ) locations = '; '.join([u'%s' % (x) for x in image.locations.all()]) ###################### # PREFERRED LANGUAGE # ###################### preferred_language = image.user.userprofile.language if preferred_language: try: preferred_language = LANGUAGES[preferred_language] except KeyError: preferred_language = _("English") else: preferred_language = _("English") ########################## # LIKE / BOOKMARKED THIS # ########################## like_this = image.toggleproperties.filter(property_type="like") bookmarked_this = image.toggleproperties.filter( property_type="bookmark") ############## # NAVIGATION # ############## image_next = None image_prev = None try: nav_ctx = self.request.GET.get('nc') if nav_ctx is None: nav_ctx = self.request.session.get('nav_ctx') if nav_ctx is None: nav_ctx = 'user' nav_ctx_extra = self.request.GET.get('nce') if nav_ctx_extra is None: nav_ctx_extra = self.request.session.get('nav_ctx_extra') # Always only lookup public, non corrupted images! if nav_ctx == 'user': image_next = Image.objects \ .exclude(corrupted=True) \ .filter(user=image.user, pk__gt=image.pk).order_by('pk')[0:1] image_prev = Image.objects \ .exclude(corrupted=True) \ .filter(user=image.user, pk__lt=image.pk).order_by('-pk')[0:1] elif nav_ctx == 'collection': try: try: collection = image.collections.get(pk=nav_ctx_extra) except ValueError: # Maybe this image is in a single collection collection = image.collections.all()[0] if collection.order_by_tag: collection_images = Image.objects \ .exclude(corrupted=True) \ .filter(user=image.user, collections=collection, keyvaluetags__key=collection.order_by_tag) \ .order_by('keyvaluetags__value') current_index = 0 for iter_image in collection_images.all(): if iter_image.pk == image.pk: break current_index += 1 image_next = collection_images.all()[current_index + 1] \ if current_index < collection_images.count() - 1 \ else None image_prev = collection_images.all()[current_index - 1] \ if current_index > 0 \ else None else: image_next = Image.objects \ .exclude(corrupted=True) \ .filter(user=image.user, collections=collection, pk__gt=image.pk).order_by('pk')[0:1] image_prev = Image.objects \ .exclude(corrupted=True) \ .filter(user=image.user, collections=collection, pk__lt=image.pk).order_by('-pk')[0:1] except Collection.DoesNotExist: # image_prev and image_next will remain None pass elif nav_ctx == 'group': try: group = image.part_of_group_set.get(pk=nav_ctx_extra) if group.public: image_next = Image.objects \ .exclude(corrupted=True) \ .filter(part_of_group_set=group, pk__gt=image.pk).order_by('pk')[0:1] image_prev = Image.objects \ .exclude(corrupted=True) \ .filter(part_of_group_set=group, pk__lt=image.pk).order_by('-pk')[0:1] except (Group.DoesNotExist, ValueError): # image_prev and image_next will remain None pass elif nav_ctx == 'all': image_next = Image.objects.exclude(corrupted=True).filter( pk__gt=image.pk).order_by('pk')[0:1] image_prev = Image.objects.exclude(corrupted=True).filter( pk__lt=image.pk).order_by('-pk')[0:1] except Image.DoesNotExist: image_next = None image_prev = None if image_next and isinstance(image_next, QuerySet): image_next = image_next[0] if image_prev and isinstance(image_prev, QuerySet): image_prev = image_prev[0] ################# # RESPONSE DICT # ################# from astrobin_apps_platesolving.solver import Solver if skyplot_zoom1 and not skyplot_zoom1.name.startswith('images/'): skyplot_zoom1.name = 'images/' + skyplot_zoom1.name response_dict = context.copy() response_dict.update({ 'SHARE_PATH': settings.SHORT_BASE_URL, 'alias': alias, 'mod': mod, 'revisions': ImageService(image) \ .get_revisions(include_corrupted=self.request.user == image.user) \ .select_related('image__user__userprofile'), 'revisions_with_description': ImageService(image) \ .get_revisions_with_description(include_corrupted=self.request.user == image.user) \ .select_related('image__user__userprofile'), 'is_revision': is_revision, 'revision_image': revision_image, 'revision_label': r, 'instance_to_platesolve': instance_to_platesolve, 'show_solution': instance_to_platesolve.mouse_hover_image == "SOLUTION" and instance_to_platesolve.solution and instance_to_platesolve.solution.status >= Solver.SUCCESS, 'show_advanced_solution': instance_to_platesolve.mouse_hover_image == "SOLUTION" and instance_to_platesolve.solution and instance_to_platesolve.solution.status == Solver.ADVANCED_SUCCESS, 'skyplot_zoom1': skyplot_zoom1, 'image_ct': ContentType.objects.get_for_model(Image), 'like_this': like_this, 'user_can_like': can_like(self.request.user, image), 'bookmarked_this': bookmarked_this, 'comments_number': NestedComment.objects.filter( deleted=False, content_type__app_label='astrobin', content_type__model='image', object_id=image.id).count(), 'gear_list': gear_list, 'makes_list': makes_list, 'image_type': image_type, 'ssa': ssa, 'deep_sky_data': deep_sky_data, 'private_message_form': PrivateMessageForm(), 'promote_form': ImagePromoteForm(instance=image), 'upload_revision_form': ImageRevisionUploadForm(), 'upload_uncompressed_source_form': UncompressedSourceUploadForm(instance=image), 'dates_label': _("Dates"), 'published_on': published_on, 'show_contains': (image.subject_type == SubjectType.DEEP_SKY and subjects) or (image.subject_type != SubjectType.DEEP_SKY), 'subjects': subjects, 'subject_type': ImageService(image).get_subject_type_label(), 'hemisphere': ImageService(image).get_hemisphere(r), 'license_icon': static('astrobin/icons/%s' % licenses[image.license][1]), 'license_title': licenses[image.license][2], 'resolution': '%dx%d' % (w, h) if (w and h) else None, 'locations': locations, 'solar_system_main_subject': ImageService(image).get_solar_system_main_subject_label(), 'content_type': ContentType.objects.get(app_label='astrobin', model='image'), 'preferred_language': preferred_language, 'select_group_form': GroupSelectForm( user=self.request.user) if self.request.user.is_authenticated() else None, 'in_public_groups': Group.objects.filter(Q(public=True, images=image)), 'image_next': image_next, 'image_prev': image_prev, 'nav_ctx': nav_ctx, 'nav_ctx_extra': nav_ctx_extra, }) return response_dict
def test_get_revisions_includes_corrupted(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image) Generators.imageRevision(image=image, corrupted=True, label='C') self.assertEqual(ImageService(image).get_revisions(include_corrupted=True).count(), 2)
def test_get_crop_box_iotd_bottom_right(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '800,800,900,900' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,620,1000,1000')
def test_get_hemisphere_no_solution(self): image = Generators.image() PlateSolvingGenerators.solution(image) self.assertEqual(Image.HEMISPHERE_TYPE_UNKNOWN, ImageService(image).get_hemisphere())
def test_get_crop_box_iotd_center_large_crop(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '10,10,990,990' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,310,1000,690')
def test_get_revisions_with_title_or_description_only_title_but_empty(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image) Generators.imageRevision(image=image, label='C', title='') self.assertEqual(ImageService(image).get_revisions_with_title_or_description().count(), 0)
def test_get_crop_box_iotd_center_example_1(self): image = Generators.image(is_wip=True) image.w = 400 image.h = 800 image.square_cropping = '50,50,350,350' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,124,400,276')
def test_display_download_menu_null(self): image = Generators.image(download_limitations=None) self.assertTrue(ImageService(image).display_download_menu(image.user)) self.assertFalse(ImageService(image).display_download_menu(Generators.user())) self.assertFalse(ImageService(image).display_download_menu(AnonymousUser))
def test_get_crop_box_iotd_center_example_2(self): image = Generators.image(is_wip=True) image.w = 2100 image.h = 2500 image.square_cropping = '100,400,100,2200' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,901,2100,1699')
def test_get_revisions_with_title_or_description(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image) Generators.imageRevision(image=image, label='C', title='Foo', description='Bar') self.assertEqual(ImageService(image).get_revisions_with_title_or_description().count(), 1)
def test_get_crop_box_iotd_edge(self): image = Generators.image(is_wip=True) image.w = 1200 image.h = 500 image.square_cropping = '0,20,0,20' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,0,1200,455')
def test_get_next_available_revision_label_with_deleted_revision(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image) to_delete = Generators.imageRevision(image=image, corrupted=True, label='C') to_delete.delete() self.assertEqual(ImageService(image).get_next_available_revision_label(), 'D')
def test_get_crop_box_iotd_tiny_image(self): image = Generators.image(is_wip=True) image.w = 100 image.h = 100 image.square_cropping = '0,0,50,50' self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,6,100,44')
def test_get_final_revision_label(self): image = Generators.image(is_wip=True) revision = Generators.imageRevision(image=image, is_final=True) self.assertEqual(ImageService(image).get_final_revision_label(), revision.label) another = Generators.imageRevision(image=image, is_final=True, label='C') self.assertEqual(ImageService(image).get_final_revision_label(), another.label)
def test_get_crop_box_regular(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 image.square_cropping = '450,450,550,550' self.assertEqual(ImageService(image).get_crop_box('regular'), None)
def test_get_default_cropping(self): image = Generators.image(is_wip=True) image.w = image.h = 1000 self.assertEqual(ImageService(image).get_default_cropping(), '0,0,1000,1000')
def test_get_next_available_revision_label(self): image = Generators.image(is_wip=True) Generators.imageRevision(image=image) self.assertEquals( ImageService(image).get_next_available_revision_label(), 'C')