Example #1
0
def test_can_trap_errors_fails_if_error_does_not_happen():
    class_name = "%s.RuntimeError" % RuntimeError.__module__
    err = expect.error_to_happen(RuntimeError)

    try:
        with err:
            pass
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of(
            'Expected "%s" to happen but no errors happened during execution of with block.' % class_name
        )
    else:
        expect.not_to_be_here()

    try:
        with expect.error_to_happen(RuntimeError):
            pass
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of(
            'Expected "%s" to happen but no errors happened during execution of with block.' % class_name
        )
    else:
        expect.not_to_be_here()
Example #2
0
def test_can_trap_errors_fails_if_error_does_not_happen():
    class_name = "%s.RuntimeError" % RuntimeError.__module__
    err = expect.error_to_happen(RuntimeError)

    try:
        with err:
            pass
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of(
            'Expected "%s" to happen but no errors happened during execution of with block.'
            % class_name)
    else:
        expect.not_to_be_here()

    try:
        with expect.error_to_happen(RuntimeError):
            pass
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of(
            'Expected "%s" to happen but no errors happened during execution of with block.'
            % class_name)
    else:
        expect.not_to_be_here()
Example #3
0
    async def test_should_raise_for_invalid_compatibility_storage(self):
        request = RequestParameters(url="/image.jpg", )
        config = Config(
            FILE_LOADER_ROOT_PATH=STORAGE_PATH,
            STORES_CRYPTO_KEY_FOR_EACH_IMAGE=True,
        )
        importer = Importer(config)
        importer.import_modules()
        image_bytes = self.get_image_bytes("image.jpg")
        ctx = Context(self.context.server, config, importer)
        ctx.request = request
        storage = Storage(ctx)

        with expect.error_to_happen(
                RuntimeError,
                message=
            ("The 'COMPATIBILITY_LEGACY_RESULT_STORAGE' configuration should point "
             "to a valid result storage when using compatibility result storage."
             ),
        ):
            await storage.get()

        with expect.error_to_happen(
                RuntimeError,
                message=
            ("The 'COMPATIBILITY_LEGACY_RESULT_STORAGE' configuration should point "
             "to a valid result storage when using compatibility result storage."
             ),
        ):
            await storage.put(image_bytes)
Example #4
0
def test_task_get_by_task_id3(client):
    """Test getting a task by task id fails if task id is empty"""
    msg = "Task ID is required and can't be None or empty."
    with expect.error_to_happen(RuntimeError, message=msg):
        Task.get_by_task_id(None)

    with expect.error_to_happen(RuntimeError, message=msg):
        Task.get_by_task_id("")
Example #5
0
def test_task_create2(client):
    """Test creating a new task fails when no task_id provided"""
    msg = "ValidationError (Task:None) (Field is required: ['task_id'])"
    with expect.error_to_happen(ValidationError, message=msg):
        Task.create_task(None)

    with expect.error_to_happen(ValidationError, message=msg):
        Task.create_task("")
Example #6
0
def test_can_trap_errors():
    err = expect.error_to_happen(RuntimeError)

    with err:
        raise RuntimeError("something is wrong")

    expect(err).to_have_an_error_message_of('something is wrong')

    with expect.error_to_happen(RuntimeError, message="something is wrong"):
        raise RuntimeError("something is wrong")
Example #7
0
def test_can_trap_errors():
    err = expect.error_to_happen(RuntimeError)

    with err:
        raise RuntimeError("something is wrong")

    expect(err).to_have_an_error_message_of('something is wrong')

    with expect.error_to_happen(RuntimeError, message="something is wrong"):
        raise RuntimeError("something is wrong")
Example #8
0
def test_can_trap_errors_unicode():
    err = expect.error_to_happen(RuntimeError)

    with err:
        raise RuntimeError(six.u("algo está errado"))

    expect(err).to_have_an_error_message_of(six.u("algo está errado"))

    with expect.error_to_happen(RuntimeError, message=six.u("algo está errado")):
        raise RuntimeError(six.u("algo está errado"))
Example #9
0
def test_can_trap_errors_unicode():
    err = expect.error_to_happen(RuntimeError)

    with err:
        raise RuntimeError(six.u("algo está errado"))

    expect(err).to_have_an_error_message_of(six.u("algo está errado"))

    with expect.error_to_happen(RuntimeError,
                                message=six.u("algo está errado")):
        raise RuntimeError(six.u("algo está errado"))
    def test_exlude_failed_with_wrong_field_name(self):
        with expect.error_to_happen(
                ValueError,
                message="Invalid field 'wrong': Field not found in 'User'."):
            yield from User.objects.exclude("wrong").get(last_name="Else")

        with expect.error_to_happen(ValueError,
                                    message=("Invalid field 'embedded.wrong': "
                                             "Field not found in 'User'.")):
            yield from User.objects.exclude("embedded.wrong").get(
                last_name="Else")
    def test_exlude_failed_with_wrong_field_name(self):
        with expect.error_to_happen(
            ValueError,
            message="Invalid field 'wrong': Field not found in 'User'."
        ):
            User.objects.exclude('wrong')\
                .get(last_name="Else", callback=self.stop)

        with expect.error_to_happen(
            ValueError,
            message=("Invalid field 'embedded.wrong': "
                     "Field not found in 'User'.")
        ):
            User.objects.exclude('embedded.wrong')\
                .get(last_name="Else", callback=self.stop)
 async def test_fails_without_func(self):
     with expect.error_to_happen(
             RuntimeError,
             message=
             "'func' argument can't be None when calling thumbor's compatibility layer.",
     ):
         await compatibility_get(1, second=2)
Example #13
0
    def test_field_required(self):
        # 'required' should not appear on the field
        err = expect.error_to_happen(KeyError)
        field = UserResource.first_name.json_schema()

        with err:
            field['required']
    def test_status(self):
        with HTTMock(paynova_mock):
            with expect.error_to_happen(PaynovaException):
                self.paynova.request('POST', 'status/error')

            response = self.paynova.request('POST', 'status/success')
            expect(response).not_to_be_null()
    def test_can_project_reference_field(self):
        posts = yield from Post.objects.only('title', 'category.name')\
            .find_all(lazy=False)

        expect(posts).to_length(1)
        expect(posts[0].title).to_equal('post1 title')
        expect(posts[0].comments).to_length(0)
        expect(posts[0].text).to_be_null()
        expect(posts[0].category).to_be_instance_of(Category)
        expect(posts[0].category.name).to_equal('category1')
        expect(posts[0].category.descr).to_be_null()

        # the same with load_references
        posts = yield from Post.objects.only('title', 'category.name')\
            .find_all(lazy=True)

        expect(posts).to_length(1)
        expect(posts[0].title).to_equal('post1 title')
        expect(posts[0].comments).to_length(0)
        expect(posts[0].text).to_be_null()

        with expect.error_to_happen(LoadReferencesRequiredError):
            cat = posts[0].category

        yield from posts[0].load_references()

        expect(posts[0].category).to_be_instance_of(Category)
        expect(posts[0].category.name).to_equal('category1')
        expect(posts[0].category.descr).to_be_null()
Example #16
0
    def test_cant_handle_exceptions_without_callback(self):
        @on_exception(None)
        def test_func(self):
            raise RuntimeError("Test")

        with expect.error_to_happen(RuntimeError):
            test_func(self)
Example #17
0
 def test_get_tree_of_non_existent_project_will_raise_exception(self):
     error_message = "Error when trying to obtain tree for path" \
                     " . on ref master of repository repository-fake " \
                     "(Error when trying to obtain tree . on ref master of repository repository-fake " \
                     "(Repository does not exist).). (Gandalf server response HTTP 400)"
     with expect.error_to_happen(GandalfException, message=error_message):
         tree = self.gandalf.repository_tree('repository-fake')
Example #18
0
def test_adaptive_full_fit_in_fails_if_no_width_supplied():
    with expect.error_to_happen(
        ValueError,
        message="When using fit-in or full-fit-in, "
        "you must specify width and/or height.",
    ):
        url_for(adaptive_full_fit_in=True, image_url=IMAGE_URL)
    def test_can_project_reference_field(self):
        Post.objects.only('title', 'category.name').find_all(
            lazy=False, callback=self.stop
        )
        posts = self.wait()

        expect(posts).to_length(1)
        expect(posts[0].title).to_equal('post1 title')
        expect(posts[0].comments).to_length(0)
        expect(posts[0].text).to_be_null()
        expect(posts[0].category).to_be_instance_of(Category)
        expect(posts[0].category.name).to_equal('category1')
        expect(posts[0].category.descr).to_be_null()

        # the same with load_references
        Post.objects.only('title', 'category.name').find_all(
            lazy=True, callback=self.stop
        )
        posts = self.wait()

        expect(posts).to_length(1)
        expect(posts[0].title).to_equal('post1 title')
        expect(posts[0].comments).to_length(0)
        expect(posts[0].text).to_be_null()

        with expect.error_to_happen(LoadReferencesRequiredError):
            cat = posts[0].category

        posts[0].load_references(callback=self.stop)
        self.wait()

        expect(posts[0].category).to_be_instance_of(Category)
        expect(posts[0].category.name).to_equal('category1')
        expect(posts[0].category.descr).to_be_null()
def test_run2(client):
    """
    Tests that a docker executor raises HostUnavailableError
    when host is not available when running a container and
    deletes host and port metadata from execution
    """

    with client.application.app_context():
        task, job, execution = JobExecutionFixture.new_defaults()
        _, pool_mock, client_mock = PoolFixture.new_defaults(r"test-.+")

        client_mock.containers.run.side_effect = requests.exceptions.ConnectionError(
            "failed")

        exe = Executor(app=client.application, pool=pool_mock)

        msg = "Connection to host host:1234 failed with error: failed"
        with expect.error_to_happen(HostUnavailableError, message=msg):
            exe.run(
                task,
                job,
                execution,
                "mock-image",
                "latest",
                "command",
                blacklisted_hosts=set(),
            )

        expect(execution.metadata).not_to_include("docker_host")
        expect(execution.metadata).not_to_include("docker_port")
Example #21
0
    def test_cant_handle_exceptions_without_callback(self):
        @on_exception(None)
        def test_func(self):
            raise RuntimeError("Test")

        with expect.error_to_happen(RuntimeError):
            test_func(self)
def test_mark_as_done2(client):
    """
    Tests marking a container as done raises HostUnavailableError
    when docker host is not available
    """

    with client.application.app_context():
        containers = [
            ContainerFixture.new(
                container_id="fastlane-job-123",
                name="fastlane-job-123",
                stdout="stdout",
                stderr="stderr",
            )
        ]
        _, pool_mock, _ = PoolFixture.new_defaults(r"test.+",
                                                   max_running=1,
                                                   containers=containers)

        task, job, execution = JobExecutionFixture.new_defaults(
            container_id="fastlane-job-123")
        executor = Executor(client.application, pool_mock)

        containers[0].rename.side_effect = requests.exceptions.ConnectionError(
            "failed")

        message = "Connection to host host:1234 failed with error: failed"
        with expect.error_to_happen(HostUnavailableError, message=message):
            executor.mark_as_done(task, job, execution)
def test_circuit6(client):
    """
    Tests that when marking a container as done with a
    docker host that's not accessible, the circuit is open and
    a HostUnavailableError is raised
    """

    with client.application.app_context():
        client.application.config["DOCKER_CIRCUIT_BREAKER_MAX_FAILS"] = 1

        task, job, execution = JobExecutionFixture.new_defaults(
            docker_host="localhost",
            docker_port=4567,
            container_id=str(uuid4()))
        pool = DockerPool(([None, ["localhost:4567"], 2], ))
        executor = Executor(client.application, pool)

        expect(executor.get_circuit("localhost:4567").current_state).to_equal(
            "closed")

        with expect.error_to_happen(HostUnavailableError):
            executor.mark_as_done(task, job, execution)

        expect(executor.get_circuit("localhost:4567").current_state).to_equal(
            "open")
def test_run3(client):
    """
    Tests that a docker executor raises RuntimeError if no
    docker_host and docker_port available in execution
    """

    with client.application.app_context():
        task, job, execution = JobExecutionFixture.new_defaults()
        _, pool_mock, _ = PoolFixture.new_defaults(r"test-.+")

        exe = Executor(app=client.application, pool=pool_mock)

        del execution.metadata["docker_host"]
        del execution.metadata["docker_port"]

        msg = "Can't run job without docker_host and docker_port in execution metadata."
        with expect.error_to_happen(RuntimeError, message=msg):
            exe.run(
                task,
                job,
                execution,
                "mock-image",
                "latest",
                "command",
                blacklisted_hosts=set(),
            )

        expect(execution.metadata).not_to_include("docker_host")
        expect(execution.metadata).not_to_include("docker_port")
Example #25
0
 def test_when_invalid_configuration_of_filename_with_context_should_be_error(
     self, ):
     cfg = Config(
         ERROR_FILE_NAME_USE_CONTEXT="server..port",
         ERROR_FILE_LOGGER="toto",
     )
     with expect.error_to_happen(RuntimeError):
         ErrorHandler(cfg)
Example #26
0
 def test_cant_delete_exactly_match(self):
     err = expect.error_to_happen(HTTPError)
     with err:
         yield self.http_client.fetch(
             self.get_url('/much/api'),
             method='DELETE'
         )
     expect(err).to_have_an_error_message_of('HTTP 405: Method Not Allowed')
Example #27
0
 def test_can_set_error(self):
     err = expect.error_to_happen(HTTPError)
     with err:
         yield self.http_client.fetch(
             self.get_url('/much/error'),
             method='GET'
         )
     expect(err).to_have_an_error_message_of('HTTP 404: Not Found')
Example #28
0
 def test_when_missing_dsn(self):
     self.config = Config(
         SECURITY_KEY="ACME-SEC",
         USE_CUSTOM_ERROR_HANDLING=True,
         ERROR_HANDLER_MODULE="thumbor.error_handlers.sentry",
     )
     with expect.error_to_happen(RuntimeError):
         self.get_importer()
Example #29
0
 def test_convert_not_well_formed_svg_to_png(self):
     buffer = """<<svg width="10px" height="20px" viewBox="0 0 10 20"
                 xmlns="http://www.w3.org/2000/svg">
                     <rect width="100%" height="10" x="0" y="0"/>
                 </svg>""".encode('utf-8')
     with expect.error_to_happen(ParseError):
         self.engine.convert_svg_to_png(buffer)
     expect(self.engine.extension).to_be_null()
Example #30
0
def test_proper_valigns():
    """test_proper_haligns"""
    with expect.error_to_happen(
            ValueError,
            message=('Only "top", "middle" and "bottom"'
                     " are valid values for vertical alignment."),
    ):
        url_for(valign="wrong", image_url=IMAGE_URL)
Example #31
0
 def test_convert_not_well_formed_svg_to_png(self):
     buffer = b"""<<svg width="10px" height="20px" viewBox="0 0 10 20"
                 xmlns="http://www.w3.org/2000/svg">
                     <rect width="100%" height="10" x="0" y="0"/>
                 </svg>"""
     with expect.error_to_happen(ParseError):
         self.engine.convert_svg_to_png(buffer)
     expect(self.engine.extension).to_be_null()
Example #32
0
def test_proper_haligns():
    """test_proper_haligns"""
    with expect.error_to_happen(
            ValueError,
            message=('Only "left", "center" and "right"'
                     " are valid values for horizontal alignment."),
    ):
        url_for(halign="wrong", image_url=IMAGE_URL)
 def test_getting_invalid_user_fails_with_403(self):
     objectid = oid.ObjectId()
     err = expect.error_to_happen(HTTPError)
     with err:
         yield self.http_client.fetch(
             self.get_url('/user/%s' % objectid)
         )
     expect(err.error.code).to_equal(404)
Example #34
0
    def test_validate_config_security_key(self):
        server_parameters = mock.Mock(security_key=None)
        conf = Config(SECURITY_KEY=None)

        with expect.error_to_happen(
            RuntimeError,
            message="No security key was found for this instance of thumbor. "
                "Please provide one using the conf file or a security key file."):
            validate_config(conf, server_parameters)
Example #35
0
    def test_validate_config_security_key(self):
        server_parameters = mock.Mock(security_key=None)
        conf = Config(SECURITY_KEY=None)

        with expect.error_to_happen(
            RuntimeError,
            message="No security key was found for this instance of thumbor. "
                "Please provide one using the conf file or a security key file."):
            validate_config(conf, server_parameters)
    def test_fields_failed_with_wrong_field_name(self):
        with expect.error_to_happen(
                ValueError,
                message="Invalid field 'wrong': Field not found in 'User'."):
            yield from User.objects.fields(wrong=QueryFieldList.ONLY).get(
                last_name="Else")

        with expect.error_to_happen(ValueError,
                                    message=("Invalid field 'embedded.wrong': "
                                             "Field not found in 'User'.")):
            yield from User.objects.fields(
                embedded__wrong=QueryFieldList.EXCLUDE).get(last_name="Else")

        with expect.error_to_happen(ValueError,
                                    message=("Invalid field 'embedded.wrong': "
                                             "Field not found in 'User'.")):
            yield from User.objects.fields(slice__embedded__wrong=10).get(
                last_name="Else")
Example #37
0
 def test_when_invalid_path(self):
     self.config = Config(
         SECURITY_KEY="ACME-SEC",
         USE_CUSTOM_ERROR_HANDLING=True,
         SENTRY_DSN_URL="https://[email protected]/12345",
         ERROR_HANDLER_MODULE="thumbor.error_handlers.invalid",
     )
     with expect.error_to_happen(ImportError):
         self.get_importer()
Example #38
0
def test_webhooks_2(**kwargs):
    """Test webhooks fail on 500"""
    rm = kwargs["rm"]
    url = "http://some.test.url"
    text = "whatever"
    headers = {"qwe": "rty"}
    rm.get(url, text=text, status_code=500, headers=headers)

    h = webhooks.WebhooksDispatcher()
    msg = 'The GET request to http://some.test.url with body of "whatever..." failed with status code of %d.'
    with expect.error_to_happen(webhooks.WebhooksDispatchError,
                                message=msg % 500):
        h.dispatch("get", url, text, {})

    rm.get(url, text=text, status_code=400, headers=headers)
    with expect.error_to_happen(webhooks.WebhooksDispatchError,
                                message=msg % 400):
        h.dispatch("get", url, text, {})
Example #39
0
async def test_queueing_task_when_no_pool_runs_sync_and_exception_happens():
    instance = ThreadPool.instance(0)
    expect(instance).not_to_be_null()
    exception = Exception("Boom")

    def add():
        raise exception

    with expect.error_to_happen(Exception, message="Boom"):
        await instance.queue(add)
Example #40
0
async def test_can_run_task_in_foreground_and_exception_happens():
    instance = ThreadPool.instance(0)
    expect(instance).not_to_be_null()
    exception = Exception("Boom")

    def add():
        raise exception

    with expect.error_to_happen(Exception, message="Boom"):
        await instance._execute_in_foreground(add)
Example #41
0
    def test_should_be_an_error(self):
        iurl = self.get_image_url('image_3.jpg')
        ibytes = self.get_image_bytes('image.jpg')
        storage = FileStorage(self.context)
        storage.put(iurl, ibytes)

        with expect.error_to_happen(
            RuntimeError,
            message="STORES_CRYPTO_KEY_FOR_EACH_IMAGE can't be True if no SECURITY_KEY specified"
        ):
            storage.put_crypto(iurl)
    def test_can_delete(self):
        user = fix.UserFactory.create()
        response = yield self.http_client.fetch(
            self.get_url('/user/%s' % user.id),
            method='DELETE'
        )
        expect(response.code).to_equal(200)
        expect(response.body).to_equal('OK')

        with expect.error_to_happen(mongoengine.errors.DoesNotExist):
            models.User.objects.get(id=user.id)
Example #43
0
    async def test_should_be_an_error(self):
        iurl = self.get_image_url("image_3.jpg")
        ibytes = self.get_image_bytes("image.jpg")
        storage = FileStorage(self.context)
        await storage.put(iurl, ibytes)

        msg = "STORES_CRYPTO_KEY_FOR_EACH_IMAGE can't be True if no SECURITY_KEY specified"
        with expect.error_to_happen(
            RuntimeError, message=msg,
        ):
            await storage.put_crypto(iurl)
Example #44
0
    def test_validate_null_gifsicle_path(self, which_mock):
        server_parameters = mock.Mock(security_key=None)
        conf = Config(SECURITY_KEY='test', USE_GIFSICLE_ENGINE=True)

        which_mock.return_value = None

        with expect.error_to_happen(
            RuntimeError,
            message="If using USE_GIFSICLE_ENGINE configuration to True, "
                "the `gifsicle` binary must be in the PATH and must be an executable."
        ):
            validate_config(conf, server_parameters)
Example #45
0
def test_can_trap_errors_fails_if_wrong_error():
    class_name = "%s.RuntimeError" % RuntimeError.__module__
    value_class_name = "%s.ValueError" % ValueError.__module__
    err = expect.error_to_happen(RuntimeError)

    try:
        with err:
            raise ValueError("something else entirely")
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of('Expected "%s" to happen but "%s" happened during execution of with block.' % (class_name, value_class_name))
    else:
        expect.not_to_be_here()
    def test_can_get_user_instance_with_custom_queryset(self):
        user = models.CustomQuerySet(prop="Bernardo Heynemann")
        user.save(self.server.application.db)

        user = models.CustomQuerySet(prop="Rafael Floriano")
        user.save(self.server.application.db)

        err = expect.error_to_happen(HTTPError)
        with err:
            yield self.http_client.fetch(
                self.get_url('/custom_query_set/%s' % user.id),
            )
        expect(err.error.code).to_equal(404)
Example #47
0
    async def test_unique_field(self):
        class UniqueFieldDocument(Document):
            name = StringField(unique=True)

        await UniqueFieldDocument.objects.delete()

        await UniqueFieldDocument.ensure_index()

        await UniqueFieldDocument.objects.create(name="test")

        # msg = 'The index "test.UniqueFieldDocument.$name_1" was violated when trying to save this "UniqueFieldDocument" (error code: E11000).'
        with expect.error_to_happen(UniqueKeyViolationError):
            await UniqueFieldDocument.objects.create(name="test")
Example #48
0
 def test_cant_load_invalid_security_key_file(self):
     expected_msg = 'Could not find security key file at /bogus. Please verify the keypath argument.'
     with expect.error_to_happen(ValueError, message=expected_msg):
         ServerParameters(
             port=8888,
             ip='0.0.0.0',
             config_path='/tmp/config_path.conf',
             keyfile='/bogus',
             log_level='debug',
             app_class='app',
             fd='fd',
             gifsicle_path='gifsicle_path',
         )
Example #49
0
    def test_errors_on_gifsicle_should_raises_errors(self):
        engine = Engine(self.context)
        with open(join(STORAGE_PATH, "animated.gif"), "r") as im:
            buffer = im.read()

        engine.load(buffer, ".gif")
        with expect.error_to_happen(
            GifSicleError,
            message="gifsicle command returned errorlevel 1 for command"
            ' "{0} --some-invalid-opt /foo/'
            'bar.gif" (image maybe corrupted?)'.format(self.server.gifsicle_path),
        ):
            engine.run_gifsicle("--some-invalid-opt")
Example #50
0
def test_can_trap_errors_fails_if_wrong_error_message():
    class_name = "%s.ValueError" % ValueError.__module__
    err = expect.error_to_happen(ValueError, message="Woot?")

    try:
        with err:
            raise ValueError("something else entirely")
    except AssertionError:
        error = sys.exc_info()[1]
        expect(error).to_have_an_error_message_of(
            'Expected "%s" to have a message of "Woot?", but the actual error was "something else entirely".' % class_name
        )
    else:
        expect.not_to_be_here()
    def test_document_failed_to_save_partly_loaded_document(self):
        User.objects.only('first_name')\
            .get(first_name='Someone', callback=self.stop)
        user = self.wait()

        with expect.error_to_happen(
            PartlyLoadedDocumentError,
            message=(
                "Partly loaded document User can't be saved. Document should "
                "be loaded without 'only', 'exclude' or 'fields' "
                "QuerySet's modifiers"
            )
        ):
            user.save(self.stop)
    def test_fields_failed_with_wrong_field_name(self):
        with expect.error_to_happen(
            ValueError,
            message="Invalid field 'wrong': Field not found in 'User'."
        ):
            User.objects.fields(wrong=QueryFieldList.ONLY)\
                .get(last_name="Else", callback=self.stop)

        with expect.error_to_happen(
            ValueError,
            message=("Invalid field 'embedded.wrong': "
                     "Field not found in 'User'.")
        ):
            User.objects.fields(embedded__wrong=QueryFieldList.EXCLUDE)\
                .get(last_name="Else", callback=self.stop)

        with expect.error_to_happen(
            ValueError,
            message=("Invalid field 'embedded.wrong': "
                     "Field not found in 'User'.")
        ):
            User.objects.fields(slice__embedded__wrong=10)\
                .get(last_name="Else", callback=self.stop)
Example #53
0
    def test_can_resize_images_with_detection_error_not_ignoring_it(self):
        test_data = TestData(
            source_width=800, source_height=600,
            target_width=400, target_height=150,
            halign="center", valign="middle",
            focal_points=[],
            crop_left=0, crop_top=75, crop_right=800, crop_bottom=375
        )
        context = test_data.to_context(detectors=[MockErrorSyncDetector], ignore_detector_error=False)
        trans = Transformer(context)
        with expect.error_to_happen(Exception, message='x'):
            trans.transform(None)

        expect(test_data.engine.calls['resize']).to_length(0)
    def test_queryset_failed_to_save_partly_loaded_document(self):
        User.objects.only('first_name').filter(first_name='Someone')\
            .order_by(User.index).find_all(callback=self.stop)
        users = self.wait()

        expect(users).to_length(1)

        with expect.error_to_happen(
            PartlyLoadedDocumentError,
            message=(
                "Partly loaded document User can't be saved. Document should "
                "be loaded without 'only', 'exclude' or 'fields' "
                "QuerySet's modifiers"
            )
        ):
            User.objects.save(users[0], callback=self.stop)
Example #55
0
 def test_get_repository_tags_raise_exception_if_cannot_obtain_refs(self, m):
     repo = str(uuid.uuid4())
     url = 'http://*****:*****@globo.com>\tThu Jul 10 15:19:41 2014 -0300\t'
         u'Fulano de Tal\t<*****@*****.**>\tThu Jul 10 15:19:41 2014 -0300\t'
         u'Mantém configuração original da aplicação XPTO\n'
         u'6f3a27b391d65e0526acd152db9a1c3747791ff1\t1.2.3-xpto\t\t\t\t\t\t\t'
     )
     error = u'Error when trying to obtain the refs of repository %s ' % repo
     error += u'(Invalid git for-each-ref output [%s]).' % for_each_ref_out
     message = u'Error when trying to obtain tags on ref  of repository %s (%s).' % (repo, error)
     m.get(url, text=message, status_code=400)
     with expect.error_to_happen(GandalfException):
         self.gandalf.repository_get(repo)
    def test_can_create_unique_user(self):
        models.UniqueUser.objects.delete()

        models.UniqueUser(name="unique").save()

        err = expect.error_to_happen(HTTPError)
        with err:
            yield self.http_client.fetch(
                self.get_url('/unique_user/'),
                method='POST',
                body='name=unique'
            )

        expect(err.error.code).to_equal(409)
        encoding = locale.getdefaultlocale()[1]
        expect('unique keys' in err.error.response.body.decode(encoding)).to_be_true()
    def test_cannot_add_mandate_events_twice(self):
        date = datetime.utcnow().date()
        mandate_events_type = MandateEventsTypeFactory.create()
        mandate = MandateFactory.create()

        MandateEventsFactory.create(
            mandate_events_type=mandate_events_type,
            date=date,
            mandate=mandate
        )

        with expect.error_to_happen(IntegrityError):
            MandateEventsFactory.create(
                mandate_events_type=mandate_events_type,
                date=date,
                mandate=mandate
            )
    def test_can_create_invalid_user(self):
        models.ValidationUser.objects.delete()
        models.UniqueUser.objects.delete()

        user = models.UniqueUser(name="unique")
        user.save()

        err = expect.error_to_happen(HTTPError)
        with err:
            yield self.http_client.fetch(
                self.get_url('/validation_user/'),
                method='POST',
                body='items[]=%s' % user.id
            )

        expect(err.error.code).to_equal(400)
        expect(err.error.response.body).to_equal("ValidationError (ValidationUser:None) (Field is required: ['name'])")