def test_file_handler_construction_fails_with_more_than_two_parameters(self):
     assert_raises(TypeError,
                   models.FileHandler,
                   None,
                   None,
                   None,
                   exc_pattern=r'__init__.. takes at most 3 arguments .4 given.')

 def test_set_as_lazy_fail_when_not_not_bool(self):
     rl = models.RelationShip()
     assert_raises(TypeError, rl.set_lazy, None)
     assert_raises(TypeError, rl.set_lazy, object())
     assert_raises(TypeError, rl.set_lazy, {})
     assert_raises(TypeError, rl.set_lazy, [])
     assert_raises(TypeError, rl.set_lazy, ())

def test_render_html_param_filename_takes_string():
    assert_raises(TypeError, template.render_html, None, None,
                  exc_pattern=r'sponge.template.render_html ' \
                  'takes a string as filename param, got None.')
    assert_raises(TypeError, template.render_html, 5, None,
                  exc_pattern=r'sponge.template.render_html ' \
                  'takes a string as filename param, got 5.')

 def test_set_as_self_referenced_fail_when_not_not_bool(self):
     rl = models.RelationShip()
     assert_raises(TypeError, rl.set_self_referenced, None)
     assert_raises(TypeError, rl.set_self_referenced, object())
     assert_raises(TypeError, rl.set_self_referenced, {})
     assert_raises(TypeError, rl.set_self_referenced, [])
     assert_raises(TypeError, rl.set_self_referenced, ())

def test_templates_render_html_raises_context_already_have_make_url():
    assert_raises(KeyError,
                  template.render_html,
                  'index.html',
                  {'make_url': "ss"},
                  exc_pattern=r'The key "make_url" is already in ' \
                  'template context as[:] %s' % re.escape(repr(template.make_url)))

def test_templates_render_html_raises_filename_empty():
    assert_raises(TypeError,
                  template.render_html,
                  '',
                  {},
                  exc_pattern=r'sponge.template.render_html ' \
                  'filename param can not be empty.')

def test_action_registry_raises_if_action_does_not_feature_regex():
    def should_raise():
        class ActionToTest5(ActionBase):
            def execute():
                pass
    
    assert_raises(NotImplementedError, should_raise, exc_pattern=r'^The action ActionToTest5 does not implement the attribute regex$')

def test_setup_all_path_must_be_absolute():
    d = {}
    cf = core.ConfigValidator({})
    sp = core.SpongeConfig(d, cf)
    assert_raises(TypeError, sp.setup_all, 'relative/path/',
                  exc_pattern=r'SpongeConfig.setup_all takes a ' \
                  'absolute path, got relative/path/.')

def test_model_file_manager_get_raises_wrong_param():
    class Woo(Model):
        objects = managers.FileSystemModelManager(base_path='/home/woo')
        def __unicode__(self):
            return '<FooBar(name=%r)>' % self.name

    assert_raises(TypeError, Woo.objects.get, blabla='x', exc_pattern=r'blabla is not a valid field in %r' % Woo)

def test_model_file_manager_method_delete_takes_model_or_modelset():
    codecs_mock = Mock()
    file_mock = Mock()
    path_mock = Mock()

    path_mock.expects(once()).exists(eq('/home/wee/Wee.json')).will(return_value(True))
    path_mock.expects(once()).exists(eq('/home/wee')).will(return_value(True))

    os_path_module = managers.os.path
    codecs_module = managers.codecs
    managers.codecs = codecs_mock
    managers.os.path = path_mock

    class Wee(Model):
        objects = managers.FileSystemModelManager(base_path='/home/wee')

    assert_raises(TypeError, Wee.objects.delete, None,
                  exc_pattern=r'delete\(\) takes a Wee as parameter, got None')

    assert_raises(TypeError, Wee.objects.delete, 5,
                  exc_pattern=r'delete\(\) takes a Wee as parameter, got 5')

    file_mock.verify()
    codecs_mock.verify()

    managers.codecs = codecs_module
    managers.os.path = os_path_module

def test_page_registry_resolve_raises_with_wrong_none_url():
    def do_resolve_fail():
        PageRegistry.resolve(Settings(), None, exists_func=fake_abs)

    exc = 'PageRegistry.resolve argument 2 must be a string. Got None.'
    assert_raises(TypeError, do_resolve_fail,
                  exc_pattern=re_compile(exc))

    def test_floatfield_fail_on_validate(self):
        class Person(Model):
            weight = fields.FloatField()

        person_dict = {'Person': {'weight': None}}
        assert_raises(fields.FieldValidationError,
                          Person.from_dict,
                          person_dict)

def test_request_fails_with_headers_non_dict():
    b = Bolacha()
    assert_raises(TypeError, b.request, 'http://somewhere', 'GET', headers=5,
                  exc_pattern=r'Bolacha.request, parameter headers must be ' \
                  'a dict or NoneType. Got 5')
    assert_raises(TypeError, b.request, 'http://somewhere', 'GET', headers='bla',
                  exc_pattern=r'Bolacha.request, parameter headers must be ' \
                  'a dict or NoneType. Got \'bla\'')

def test_time():
    dta1 = TimeAttribute("%H:%M:%S")
    dta2 = TimeAttribute("%H:%M:%S")
    dta1.fill('creation_time', '23:44:10')
    dta2.fill('creation_time', time(hour=23, minute=44, second=10))
    assert_equals(dta1.value, time(hour=23, minute=44, second=10))
    assert_equals(dta2.value, time(hour=23, minute=44, second=10))
    assert_raises(TypeError, dta1.fill, 'creation_time', 100.5)

    def test_textfield_fail(self):
        class Person(Model):
            biography = fields.TextField()

        person_dict = {'Person': {'biography': 00}}
        assert_raises(TypeError,
                          Person.from_dict,
                          person_dict)

    def test_booleanfield_fail(self):
        class Person(Model):
            married = fields.BooleanField(positives=["true", "yes"],
                                          negatives=["false", "no"])

        person_dict = {'Person': {'married': None}}

        assert_raises(TypeError, Person.from_dict, person_dict)

def test_page_registry_resolve_raises_with_wrong_none_settings_and_none_url():
    def do_resolve_fail():
        PageRegistry.resolve(None, None, exists_func=fake_abs)

    exc = 'PageRegistry.resolve takes a pyccuracy.common.Settings ' \
          'object first parameter. Got None.'
    assert_raises(TypeError, do_resolve_fail,
                  exc_pattern=re_compile(exc))

def test_request_fails_method_non_string():
    b = Bolacha()
    assert_raises(TypeError, b.request, 'http://gnu', None,
                  exc_pattern=r'Bolacha.request, parameter method must be ' \
                  'a string. Got None')
    assert_raises(TypeError, b.request, 'http://gnu', 99,
                  exc_pattern=r'Bolacha.request, parameter method must be ' \
                  'a string. Got 99')

def test_takes_dict_on_creation():
    cf = core.ConfigValidator({})
    assert_raises(TypeError, core.SpongeConfig, None, cf,
                  exc_pattern=r'SpongeConfig parameter 1 ' \
                  'must be a dict, got None.')
    assert_raises(TypeError, core.SpongeConfig, 5, cf,
                  exc_pattern=r'SpongeConfig parameter 1 ' \
                  'must be a dict, got 5.')

def test_request_fails_url_non_string():
    b = Bolacha()
    assert_raises(TypeError, b.request, None, None,
                  exc_pattern=r'Bolacha.request, parameter url must be ' \
                  'a string. Got None')
    assert_raises(TypeError, b.request, 99, None,
                  exc_pattern=r'Bolacha.request, parameter url must be ' \
                  'a string. Got 99')