def test_base_form_catches_gender_of_consent(self):
     site_consents.registry = {}
     self.consent_factory(
         start=self.study_open_datetime,
         end=self.study_open_datetime + timedelta(days=50),
         version='1.0',
         gender=[MALE])
     subject_consent = mommy.prepare_recipe(
         'edc_consent.subjectconsent',
         consent_datetime=self.study_open_datetime,
         dob=self.dob,
         gender=MALE)
     form = SubjectConsentForm(subject_consent.__dict__)
     subject_consent.initials = subject_consent.first_name[
         0] + subject_consent.last_name[0]
     self.assertTrue(form.is_valid())
     subject_consent = mommy.prepare_recipe(
         'edc_consent.subjectconsent',
         consent_datetime=self.study_open_datetime,
         dob=self.dob,
         gender=FEMALE)
     form = SubjectConsentForm(subject_consent.__dict__)
     subject_consent.initials = subject_consent.first_name[
         0] + subject_consent.last_name[0]
     self.assertFalse(form.is_valid())

def test_blog_exposes_articles_tags_are_order():
    """
    The Blog model can retrieve a list of all available tags.
    The list of tags is ordered according to the usage so that
    more used tags are listed first.
        - the Blog page is a child of the root page
        - the Blog page contains two posts
        - post_1 has two tags, post_2 has one tags
        - a tag is used twice while the other only once
        - blog.tags must return two tags; the first one should be
          the most common
    """
    # create a blog page with two posts
    root_page = get_root_page()
    blog = mommy.prepare_recipe('tests.recipes.blog')
    posts = mommy.prepare_recipe('tests.recipes.post', _quantity=2)
    link_page(root_page, blog)
    link_page(blog, posts)
    # append two tags to two different posts
    tag_1 = mommy.make('blog.PostTag', content_object=posts[0]).tag
    tag_2 = mommy.make('blog.PostTag', content_object=posts[1]).tag
    # one tag is used twice
    mommy.make('blog.PostTag', tag=tag_2, content_object=posts[0])

    assert len(blog.tags) == 2
    assert blog.tags[0] == tag_2
    assert blog.tags[1] == tag_1

def test_blog_tag_filter(rf):
    """
    Alice is a user that wants to read our blog. She opens the
    /blog/ webpage and choose a particular tag filter.
    She expects to find only a subset of posts, according to
    the chosen tag.
        - the Blog page contains three posts
        - two posts shares one tag while the other one has
          a different tag
        - Alice navigates to /blog/ page choosing the common tag
        - Alice expects to see two posts
    """
    # create a blog page with three posts
    root_page = get_root_page()
    blog = mommy.prepare_recipe('tests.recipes.blog')
    posts = mommy.prepare_recipe('tests.recipes.post', _quantity=3)
    link_page(root_page, blog)
    link_page(blog, posts)
    # append the proper tags
    tag_1 = mommy.make('blog.PostTag', content_object=posts[0]).tag
    tag_2 = mommy.make('blog.PostTag', content_object=posts[1]).tag
    # the third post is tagged with tag_1
    mommy.make('blog.PostTag', tag=tag_1, content_object=posts[2])
    # create a fake request with a tag attribute
    request = add_site_to_request(rf.get(blog.slug, {'tag': tag_1.name}))
    context = blog.get_context(request)
    assert len(context['articles']) == 2
    assert context['current_tag'] == tag_1.name

    def test_save_related_instances_on_prepare_recipe(self):
        dog = mommy.prepare_recipe("test.generic.homeless_dog")
        self.assertIsNone(dog.id)
        self.assertIsNone(dog.owner.id)

        dog = mommy.prepare_recipe("test.generic.homeless_dog", _save_related=True)
        self.assertIsNone(dog.id)
        self.assertTrue(dog.owner.id)

 def test_do_not_create_related_model(self):
     """
       It should not attempt to create other object when
       passing the object as argument
     """
     person = mommy.make_recipe('test.generic.person')
     self.assertEqual(Person.objects.count(), 1)
     mommy.make_recipe('test.generic.dog', owner=person)
     self.assertEqual(Person.objects.count(), 1)
     mommy.prepare_recipe('test.generic.dog', owner=person)
     self.assertEqual(Person.objects.count(), 1)

    def test_gets_most_recent_assignment_date(self):
        assignment1 = mommy.prepare_recipe('devices.assignment_recipe')
        assignment2 = mommy.prepare_recipe('devices.assignment_recipe')

        old_date = datetime.date.today() - datetime.timedelta(days=14)
        assignment1.save()
        assignment2.save()
        self.device.save()
        mommy.make('DeviceAssignment', device=self.device, assignment=assignment1, assignment_date=old_date)
        mommy.make('DeviceAssignment', device=self.device, assignment=assignment2)
        result = self.device.get_last_assignment_date()
        assert_equal(result, assignment2.assignment_date())

    def _assert_text_field_has_maximum_length_of_characters(self, mommy_recipe, field, max_length):
        """
        Helper method for asserting a field has a maximum length of characters
        """
        test_object1 = mommy.prepare_recipe(mommy_recipe, **{field: 'a'*(max_length+1)})
        exclude_fields = test_object1._meta.get_all_field_names()
        exclude_fields.remove(field)
        test_object1.full_clean.when.called_with(exclude=exclude_fields).should\
            .throw(ValidationError, "{'%s': [u'%s must be %s characters or less']}" % (field, field, max_length))

        test_object2 = mommy.prepare_recipe(mommy_recipe, **{field: 'a'*max_length})
        test_object2.full_clean.when.called_with(exclude=exclude_fields).should_not.throw(Exception)

 def test_can_get_last_assignment_date(self):
     assignment = mommy.prepare_recipe('devices.assignment_recipe')
     assignment.save()
     self.device.save()
     mommy.make('DeviceAssignment', device=self.device, assignment=assignment)
     result = self.device.get_last_assignment_date()
     assert_equal(result, assignment.assignment_date())

 def test_increment_for_strings(self):
     person = mommy.make_recipe("test.generic.serial_person")
     self.assertEqual(person.name, "joe1")
     person = mommy.prepare_recipe("test.generic.serial_person")
     self.assertEqual(person.name, "joe2")
     person = mommy.make_recipe("test.generic.serial_person")
     self.assertEqual(person.name, "joe3")

 def test_increment_after_override_definition_field(self):
     person = mommy.make_recipe("test.generic.serial_person", name="tom")
     self.assertEqual(person.name, "tom")
     person = mommy.make_recipe("test.generic.serial_person")
     self.assertEqual(person.name, "joe1")
     person = mommy.prepare_recipe("test.generic.serial_person")
     self.assertEqual(person.name, "joe2")

    def test_lcavailed_post_save_without_lc_number_validation(self):
        """Test saving LcAvailed with lc_number validation switched off."""

        lc = mommy.prepare_recipe('lcavail.lcavailed')

        # calling save() on the LcAvailed instance will raise ValidationError
        # because the lc_number will not return True when we call
        # adhocmodels.models.ValidTransactionRef.is_valid_trxn_ref(
        #     lc_number)
        with nt.assert_raises(ValidationError):
            lc.save()

        # we assert that no LcAvailed object has been created because the
        # previous call raised ValidationError
        nt.eq_(LcAvailed.objects.count(), 0)

        # we set the dont_validate property for lc_number
        lc.dont_validate = {
            'lc_number': True,
        }

        # calling save( now will not raise ValidationError)
        lc.save()

        # we check that an LcAvailed object has indeed been created
        nt.eq_(LcAvailed.objects.count(), 1)

 def test_do_query_lookup_for_recipes_prepare_method(self):
     """
       It should not attempt to create other object when
       using query lookup syntax
     """
     dog = mommy.prepare_recipe('test.generic.dog', owner__name='James')
     self.assertEqual(dog.owner.name, 'James')

def test_blog_exposes_empty_tags_as_default():
    """
    The Blog model can retrieve a list of all available tags.
    By default, a Post doesn't have a Tag.
        - the Blog page is a child of the root page
        - the Blog page contains a post
        - blog.tags must return an empty list
    """
    # create a blog post with two posts
    root_page = get_root_page()
    blog = mommy.prepare_recipe('tests.recipes.blog')
    post = mommy.prepare_recipe('tests.recipes.post')
    link_page(root_page, blog)
    link_page(blog, post)

    assert len(blog.tags) == 0

 def setup(self):
     self.project = models.Project(name='Selene')
     self.device = mommy.prepare_recipe('devices.non_asset_device_recipe')
     self.device.sequence = None
     self.device.code = None
     self.device.save()
     self.project.save()

def test_blog_articles():
    """
    Test the Blog model so that users may retrieve all published
    articles.
        - the Blog page is a child of the root page
        - the Blog page contains two posts
        - blog.articles must return two (live) posts
    """
    # create a blog post with two posts
    root_page = get_root_page()
    blog = mommy.prepare_recipe('tests.recipes.blog')
    posts = mommy.prepare_recipe('tests.recipes.post', _quantity=2)
    link_page(root_page, blog)
    link_page(blog, posts)

    assert len(blog.articles) == 2

 def test_should_not_set_life_start_date_on_device_for_non_laptop(self):
     device_type = models.DeviceType.objects.get_or_create(code='M', name='Mouse')[0]
     device_type.save()
     device = mommy.prepare_recipe('devices.non_asset_device_recipe')
     device.device_type = device_type
     device.save()
     self.get_response(self.build_request(devices=[device.id]))
     device = models.DeviceAssignment.objects.filter(device__device_type__name='Mouse')[0].device
     assert_is_none(device.life_start_date)

 def test_base_form_catches_consent_datetime_before_study_open(self):
     subject_consent = mommy.prepare_recipe(
         'edc_consent.subjectconsent',
         consent_datetime=self.study_open_datetime + relativedelta(days=1),
         dob=self.dob)
     subject_consent.initials = subject_consent.first_name[
         0] + subject_consent.last_name[0]
     consent_form = SubjectConsentForm(data=subject_consent.__dict__)
     self.assertTrue(consent_form.is_valid())
     self.assertIsNone(consent_form.errors.get('consent_datetime'))
     subject_consent = mommy.prepare_recipe(
         'edc_consent.subjectconsent',
         consent_datetime=self.study_open_datetime - relativedelta(days=1),
         dob=self.dob)
     data = subject_consent.__dict__
     data['initials'] = data['first_name'][0] + data['last_name'][0]
     consent_form = SubjectConsentForm(data=data)
     self.assertFalse(consent_form.is_valid())

 def test_base_form_catches_dob_upper(self):
     subject_consent = mommy.prepare_recipe(
         'edc_consent.subjectconsent',
         consent_datetime=self.study_open_datetime,
         dob=self.dob - relativedelta(years=100))
     subject_consent.initials = subject_consent.first_name[
         0] + subject_consent.last_name[0]
     consent_form = SubjectConsentForm(subject_consent.__dict__)
     self.assertFalse(consent_form.is_valid())

 def test_should_return_assignment_date_for_device_without_lifetime(self):
     assignment = mommy.prepare_recipe('devices.assignment_recipe')
     assignment.save()
     self.device.device_type.life_time = None
     self.device.assign()
     self.device.save()
     mommy.make('DeviceAssignment', device=self.device, assignment=assignment)
     result = self.device.life_start_date_or_assignment_date()
     assert_equal(result, assignment.assignment_date())

 def test_should_set_device_status_to_assigned(self):
     device = mommy.prepare_recipe('devices.non_asset_device_recipe')
     uid = 'Hack to id the record: we should tear down!'
     device.model = uid
     device.sequence = None
     device.code = None
     device.save()
     self.get_response(self.build_request(devices=[device.id]))
     assert_equal((models.Device.objects.get(model=uid)).device_status.name,
                  (models.DeviceStatus.objects.get(name=models.DeviceStatus.ASIGNADO)).name)