text: # -*- coding: utf-8 -*-
  import datetime
  
  from django import forms
  from django.test import TestCase
  from django.urls import reverse_lazy
  
  from izi.apps.catalogue.models import Product
  from izi.forms import widgets
  from izi.test.factories import create_product
  
  
  class ImageInputTestCase(TestCase):
  
      def test_unbound_context(self):
          i = widgets.ImageInput()
          ctx = i.get_context('test_input', None, {'id': 'test-image-id'})
          self.assertEqual(ctx['image_id'], 'test-image-id-image')
          self.assertEqual(ctx['image_url'], '')
          self.assertEqual(
              ctx['widget']['attrs'],
              {'accept': 'image/*', 'id': 'test-image-id'}
          )
  
      def test_bound_context(self):
          i = widgets.ImageInput()
          ctx = i.get_context('test_input', '/dummy-image-value', {'id': 'test-image-id'})
          self.assertEqual(ctx['image_url'], '/dummy-image-value')
  
  
  class TimePickerInputTestCase(TestCase):
  
      def test_div_attrs_context(self):
          i = widgets.TimePickerInput(format='%H:%M')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['div_attrs'], {
              'data-iziWidget': 'time',
              'data-timeFormat': 'hh:ii',
          })
  
      def test_icon_classes_context(self):
          i = widgets.TimePickerInput(format='%H:%M')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['icon_classes'], 'icon-time glyphicon-time')
  
      def test_input_format_unicode(self):
          # Check that the widget can handle unicode formats
          i = widgets.TimePickerInput(format='τ-%H:%M')
          time = datetime.time(10, 47)
          html = i.render('time', time)
          self.assertIn('value="τ-10:47"', html)
  
  
  class DatePickerInputTestCase(TestCase):
  
      def test_div_attrs_context(self):
          i = widgets.DatePickerInput(format='%d/%m/%Y')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['div_attrs'], {
              'data-iziWidget': 'date',
              'data-dateFormat': 'dd/mm/yyyy',
          })
  
      def test_icon_classes_context(self):
          i = widgets.DatePickerInput(format='%H:%M')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['icon_classes'], 'icon-calendar glyphicon-calendar')
  
      def test_datepickerinput_format_unicode(self):
          # Check that the widget can handle unicode formats
          i = widgets.DatePickerInput(format='δ-%d/%m/%Y')
          date = datetime.date(2017, 5, 1)
          html = i.render('date', date)
          self.assertIn('value="δ-01/05/2017"', html)
  
  
  class DateTimePickerInputTestCase(TestCase):
  
      def test_div_attrs_context(self):
          i = widgets.DateTimePickerInput(format='%d/%m/%Y %H:%M')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['div_attrs'], {
              'data-iziWidget': 'datetime',
              'data-datetimeFormat': 'dd/mm/yyyy hh:ii',
          })
  
      def test_icon_classes_context(self):
          i = widgets.DateTimePickerInput(format='%d/%m/%Y %H:%M')
          ctx = i.get_context('test_input', None, {})
          self.assertEqual(ctx['icon_classes'], 'icon-calendar glyphicon-calendar')
  
      def test_datetimepickerinput_format_unicode(self):
          # Check that the widget can handle unicode formats
          i = widgets.DateTimePickerInput(format='δ-%d/%m/%Y %H:%M')
          date = datetime.datetime(2017, 5, 1, 10, 57)
          html = i.render('datetime', date)
          self.assertIn('value="δ-01/05/2017 10:57"', html)
  
  
  class TestWidgetsDatetimeFormat(TestCase):
  
      def test_datetime_to_date_format_conversion(self):
          format_testcases = (
              ('%Y-%m-%d', 'yyyy-mm-dd'),
              ('%Y-%m-%d %H:%M', 'yyyy-mm-dd'),
          )
          for format_, expected in format_testcases:
              self.assertEqual(widgets.datetime_format_to_js_date_format(format_), expected)
  
      def test_datetime_to_time_format_conversion(self):
          format_testcases = (
              ('%Y-%m-%d %H:%M', 'hh:ii'),
              ('%H:%M', 'hh:ii'),
          )
          for format_, expected in format_testcases:
              self.assertEqual(widgets.datetime_format_to_js_time_format(format_), expected)
  
  
  class AdvancedSelectWidgetTestCase(TestCase):
  
      def test_widget_disabled_options(self):
  
          choices = (
              ('red', 'Red'),
              ('blue', 'Blue'),
              ('green', 'Green'),
          )
  
          disabled_values = ('red', 'green')
  
          i = widgets.AdvancedSelect(choices=choices, disabled_values=disabled_values)
          html = i.render('advselect', [])
          self.assertInHTML('<option value="blue">Blue</option>', html, count=1)
          self.assertInHTML('<option value="red" disabled>Red</option>', html, count=1)
          self.assertInHTML('<option value="green" disabled>Green</option>', html, count=1)
  
  
  class RemoteSelectTestCase(TestCase):
  
      def setUp(self):
          self.url = reverse_lazy('dashboard:catalogue-product-lookup')
  
      def _get_form_field(self, **kwargs):
          return forms.ModelChoiceField(
              queryset=Product.objects.all(),
              widget=widgets.RemoteSelect(lookup_url=self.url),
              **kwargs
          )
  
      def _get_multiselect_form_field(self, **kwargs):
          return forms.ModelChoiceField(
              queryset=Product.objects.all(),
              widget=widgets.MultipleRemoteSelect(lookup_url=self.url),
              **kwargs
          )
  
      def test_remote_url_required(self):
          with self.assertRaises(ValueError):
              widgets.RemoteSelect()
  
      def test_select_widget_renders_only_selected_choices(self):
          create_product()
          p2 = create_product()
  
          field = self._get_form_field()
          form_choices = list(field.widget.options(name='name', value=[p2.pk]))
          # We should only have one choice, not two
          self.assertEqual(len(form_choices), 1)
          self.assertEqual(form_choices[0]['value'], p2.pk)
  
      def test_widget_attrs(self):
          field = self._get_form_field()
          attrs = field.widget.get_context(name='my_field', value=None, attrs={})['widget']['attrs']
          self.assertEqual(attrs['data-multiple'], '')
          self.assertEqual(attrs['data-required'], 'required')
          self.assertEqual(attrs['data-ajax-url'], self.url)
  
      def test_not_required_widget_attrs(self):
          field = self._get_multiselect_form_field(required=False)
          attrs = field.widget.get_context(name='my_field', value=None, attrs={})['widget']['attrs']
          self.assertEqual(attrs['data-required'], '')
  
      def test_multiselect_widget_renders_only_selected_choices(self):
          create_product()
          p2 = create_product()
          p3 = create_product()
  
          field = self._get_multiselect_form_field()
          form_choices = list(field.widget.options(name='name', value=[p2.pk, p3.pk]))
          # We should only have two choices, not three
          self.assertEqual(len(form_choices), 2)
  
      def test_multiselect_widget_attrs(self):
          field = self._get_multiselect_form_field()
          attrs = field.widget.get_context(name='my_field', value=None, attrs={})['widget']['attrs']
          self.assertEqual(attrs['data-multiple'], 'multiple')
  