Esempio n. 1
0
class TestImageLinkBlock:
    def test_properties(self):
        url = 'http://localhost/image.png'
        block = ImageLinkBlock(url=url)
        assert block.type == BlockType.IMAGE_LINK
        assert block.url == url

    @pytest.mark.parametrize('attributes,raises', [
        (dict(), pytest.raises(ValidationError)),
        (dict(type='####', url='http://localhost/image.png'),
         pytest.raises(ValidationError)),
        (dict(url='$*(#Y$('), pytest.raises(ValidationError)),
        (dict(url='http://localhost'), does_not_raise()),
        (dict(url='http://localhost/image.png'), does_not_raise()),
    ])
    def test_validator(self, attributes, raises):
        with raises:
            ImageLinkBlock(**attributes)

    def test_to_dict(self):
        assert ImageLinkBlock(url='http://localhost/image.png').dict(
            exclude_none=True) == {
                "type": "image_link",
                "url": "http://localhost/image.png",
            }

    def test_to_json(self):
        assert ImageLinkBlock(url='http://localhost/image.png').json(
            exclude_none=True
        ) == '{"type": "image_link", "url": "http://localhost/image.png"}'
Esempio n. 2
0
class TestGetDestination:
    @pytest.mark.parametrize(
        "parent,raising",
        [
            (flywheel.Subject(label="test"), does_not_raise()),
            (flywheel.Session(label="test"), does_not_raise()),
            (flywheel.Group(label="test"), pytest.raises(ValueError)),
            (flywheel.Project(label="test"), pytest.raises(ValueError)),
            (flywheel.Acquisition(label="test"), pytest.raises(ValueError)),
        ],
    )
    def test_container(self, sdk_mock, parent, raising):
        container = flywheel.models.analysis_output.AnalysisOutput(
            parent=parent, id="test"
        )
        sdk_mock.get_analysis.return_value = container
        sdk_mock.get.return_value = parent

        with raising:
            dest = get_destination(sdk_mock, "test")

            sdk_mock.get_analysis.assert_called_once_with("test")
            # assert dest.__class__ == parent.__class__
            assert isinstance(dest, parent.__class__)

    def test_analysis_does_not_exist(self, sdk_mock):
        container = flywheel.models.analysis_output.AnalysisOutput(
            parent=flywheel.Project(), id="test"
        )
        sdk_mock.get.side_effect = flywheel.rest.ApiException(status=404)
        sdk_mock.get_analysis.return_value = container
        with pytest.raises(flywheel.rest.ApiException):
            dest = get_destination(sdk_mock, "test")
            assert isinstance(dest, flywheel.Project)
 def left_metric_wrong_group_test_data(self):
     smoke_data = [
         dict(group=SpecialEuclidean(2), expected=does_not_raise()),
         dict(group=SpecialEuclidean(3), expected=does_not_raise()),
         dict(
             group=SpecialEuclidean(2, point_type="vector"),
             expected=pytest.raises(ValueError),
         ),
         dict(group=SpecialOrthogonal(3), expected=pytest.raises(ValueError)),
     ]
     return self.generate_tests(smoke_data)
Esempio n. 4
0
def test_initializing_repository_without_git_repo_does_not_raise_error(
    tmp_path: str, ) -> None:
    """Check initializing repository without git repository does not raise
    error"""
    with does_not_raise():
        repo = Repository(str(tmp_path))
        assert repo.git_wrapper is None
Esempio n. 5
0
def valid_axis_tester(Op):
    with pytest.raises(TypeError):
        Op(1.5)

    x = [tensor3()] * Op.nin
    with does_not_raise():
        Op(2)(*x)

    with pytest.raises(ValueError):
        Op(3)(*x)

    with does_not_raise():
        Op(-3)(*x)

    with pytest.raises(ValueError):
        Op(-4)(*x)
Esempio n. 6
0
 def test_timer_get_non_existent(self, name):
     if name == self.default_timer:
         condition = does_not_raise()
     else:
         condition = pytest.raises(IndexError)
     with condition:
         logger.get_timer(name)
Esempio n. 7
0
def test_cuda_array_interface_interop_out(dtype, module):
    expectation = does_not_raise()
    if dtype == "str":
        expectation = pytest.raises(NotImplementedError)
    if module == "cupy":
        module_constructor = cupy.asarray

        def to_host_function(x):
            return cupy.asnumpy(x)

    elif module == "numba":
        module_constructor = cuda.as_cuda_array

        def to_host_function(x):
            return x.copy_to_host()

    with expectation:
        np_data = np.arange(10).astype(dtype)
        cudf_data = cudf.Series(np_data)
        assert isinstance(cudf_data.__cuda_array_interface__, dict)

        module_data = module_constructor(cudf_data)
        got = to_host_function(module_data)

        expect = np_data

        assert_eq(expect, got)
Esempio n. 8
0
class TestLabelBlock:
    def test_properties(self):
        block = LabelBlock(text="msg", markdown=True)
        assert block.type == BlockType.LABEL
        assert block.text == 'msg'
        assert block.markdown is True

    @pytest.mark.parametrize(
        'attributes,raises',
        [
            (dict(), pytest.raises(ValidationError)),
            (dict(type='####'), pytest.raises(ValidationError)),
            (dict(text='msg'), pytest.raises(ValidationError)),
            (dict(text=''), pytest.raises(ValidationError)),
            (dict(text='a' * 201), pytest.raises(ValidationError)),
            (dict(markdown=True), pytest.raises(ValidationError)),
            (dict(text='msg', markdown=True), does_not_raise()),
        ],
    )
    def test_validator(self, attributes, raises):
        with raises:
            LabelBlock(**attributes)

    def test_to_dict(self):
        assert LabelBlock(text="msg",
                          markdown=True).dict(exclude_none=True) == {
                              "type": "label",
                              "text": "msg",
                              "markdown": True,
                          }

    def test_to_json(self):
        assert LabelBlock(text="msg", markdown=True).json(
            exclude_none=True
        ) == '{"type": "label", "text": "msg", "markdown": true}'
Esempio n. 9
0
def test_runner_stop_dont_raise_runtime_error(cancel_all_tasks_mock):
    cancel_all_tasks_mock.side_effect = RuntimeError("faiô!")
    runner = LoaferRunner()

    with does_not_raise():
        runner.loop.stop()
        runner.stop()
Esempio n. 10
0
def test_cuda_array_interface_interop_out_masked(dtype, module):
    expectation = does_not_raise()
    if module == "cupy":
        pytest.skip("cupy doesn't support version 1 of "
                    "`__cuda_array_interface__` yet")
        module_constructor = cupy.asarray

        def to_host_function(x):
            return cupy.asnumpy(x)

    elif module == "numba":
        expectation = pytest.raises(NotImplementedError)
        module_constructor = cuda.as_cuda_array

        def to_host_function(x):
            return x.copy_to_host()

    np_data = np.arange(10).astype("float64")
    np_data[[0, 2, 4, 6, 8]] = np.nan

    with expectation:
        cudf_data = cudf.Series(np_data).astype(dtype)
        assert isinstance(cudf_data.__cuda_array_interface__, dict)

        module_data = module_constructor(cudf_data)  # noqa: F841
Esempio n. 11
0
        def tangent_extrinsic_to_spherical_raises_test_data(self):
            smoke_data = []
            dim_list = [2, 3]
            for dim in dim_list:
                space = Hypersphere(dim)
                base_point = space.random_point()
                tangent_vec = space.to_tangent(space.random_point(), base_point)
                if dim == 2:
                    expected = does_not_raise()
                    smoke_data.append(
                        dict(
                            dim=2,
                            tangent_vec=tangent_vec,
                            base_point=None,
                            base_point_spherical=None,
                            expected=pytest.raises(ValueError),
                        )
                    )
                else:
                    expected = pytest.raises(NotImplementedError)
                smoke_data.append(
                    dict(
                        dim=dim,
                        tangent_vec=tangent_vec,
                        base_point=base_point,
                        base_point_spherical=None,
                        expected=expected,
                    )
                )

            return self.generate_tests(smoke_data)
Esempio n. 12
0
def test_cuda_array_interface_interop_in(dtype, module):
    np_data = np.arange(10).astype(dtype)

    expectation = does_not_raise()
    if module == "cupy":
        if not _have_cupy:
            pytest.skip("no cupy")
        module_constructor = cupy.array
        if dtype in datetime_dtypes:
            expectation = pytest.raises(ValueError)
    elif module == "numba":
        module_constructor = cuda.to_device

    with expectation:
        module_data = module_constructor(np_data)

        pd_data = pd.Series(np_data)
        # Test using a specific function for __cuda_array_interface__ here
        cudf_data = cudf.Series(module_data)

        assert_eq(pd_data, cudf_data)

        gdf = cudf.DataFrame()
        gdf["test"] = module_data
        pd_data.name = "test"
        assert_eq(pd_data, gdf["test"])
Esempio n. 13
0
class TestGetClassToBook:
    @pytest.mark.parametrize(
        "classes, target_time, class_name, expectation",
        (
            (
                [{
                    "id": 123,
                    "timeid": "1700_60",
                    "className": "foo"
                }],
                "1700",
                "foo",
                does_not_raise(),
            ),
            (
                [
                    {
                        "id": 123,
                        "timeid": "1700_60",
                        "className": "foo"
                    },
                    {
                        "id": 123,
                        "timeid": "1700_60",
                        "className": "foo"
                    },
                ],
                "1700",
                "foo",
                does_not_raise(),
            ),
            (
                [{
                    "id": 123,
                    "timeid": "1100_60",
                    "className": "foo"
                }],
                "1700",
                "foo",
                pytest.raises(NoBookingGoal),
            ),
        ),
    )
    def test_get_class_to_book(self, classes, target_time, class_name,
                               expectation):
        with expectation:
            assert get_class_to_book(classes, target_time, class_name) == 123
Esempio n. 14
0
def test_image_fetch(harness, oci_resource_data):
    harness.begin()
    with pytest.raises(MissingResourceError):
        harness.charm.image.fetch()

    harness.add_oci_resource(**oci_resource_data)
    with does_not_raise():
        harness.charm.image.fetch()
def test_check_predicates(user, predicates, raises, error_message):
    if raises is None:
        ctx = does_not_raise()
    else:
        ctx = pytest.raises(ParselglossyError, match="|".join(error_message))

    with ctx:
        check_predicates(incoming=user, predicates=predicates)
Esempio n. 16
0
def test_get_step_context_output_for_step_with_one_output(
    step_context_with_single_output, ):
    """Tests that getting the artifact uri or materializer for a step context
    with a single output does NOT raise an exception."""

    with does_not_raise():
        step_context_with_single_output.get_output_artifact_uri()
        step_context_with_single_output.get_output_materializer()
Esempio n. 17
0
def test_get_step_context_output_for_non_existing_output_key(
    step_context_with_two_outputs, ):
    """Tests that getting the artifact uri or materializer for an existing
    output does NOT raise an exception."""

    with does_not_raise():
        step_context_with_two_outputs.get_output_artifact_uri("output_1")
        step_context_with_two_outputs.get_output_materializer("output_2")
Esempio n. 18
0
def data_size_expectation_builder(data, nan_null_param=False):
    if nan_null_param and np.isnan(data).any():
        return pytest.raises((ValueError, ))

    if data.size > 0:
        return does_not_raise()
    else:
        return pytest.raises((ValueError, IndexError))
Esempio n. 19
0
def test_storage(tmpdir, engine, kw, ex):
    if ex is None:
        ex = does_not_raise()
    with ex:
        storage = create_storage(tmpdir=tmpdir, engine=engine, **kw)
        if isinstance(storage, FileStorage):
            _test_hexdigeststorage(storage)
        if isinstance(storage, JsonStorage):
            _test_jsonstorage(storage)
Esempio n. 20
0
def test_input_output_pairs(seqs, expected):
    """Test that the generation of input-output pairs works as expected."""
    with expected:
        assert input_output_pairs(seqs) is not None

    if expected == does_not_raise():
        xs, ys = input_output_pairs(seqs)
        assert xs.shape == (len(seqs), len(seqs[0]) + 1, 10)
        assert ys.shape == (len(seqs), len(seqs[0]) + 1, 25)
Esempio n. 21
0
def test_input_output_pairs(seqs, expected):

    with expected:
        assert input_output_pairs(seqs) is not None

    if expected == does_not_raise():
        xs, ys = input_output_pairs(seqs)
        assert xs.shape == (len(seqs), len(seqs[0]) + 1, 10)
        assert ys.shape == (len(seqs), len(seqs[0]) + 1, 25)
Esempio n. 22
0
def test_assert_valid_raster(file_path, exp_error):
    exp_exception = pytest.raises(
        LaymanError) if exp_error else does_not_raise()

    with exp_exception as exc_info:
        gdal.assert_valid_raster(file_path)

    if exp_error:
        test_util.assert_error(exp_error, exc_info)
def test_validation_prediction_recorder(config):
    with TemporaryDirectory() as temp_folder:
        recorder = ValidationPredictionRecorder(
            output_data_dir=temp_folder,
            **config['recorder_kwargs']
        )
        for call_config in config['record_calls']:
            with call_config.get('record_raises', does_not_raise()):
                recorder.record(*call_config['args'])
            if call_config.get('record_raises', None) is not None:
                return

        with config.get('save_raises', does_not_raise()):
            recorder.save()
        if config.get('save_raises', None) is not None:
            return
        df = pd.read_csv(os.path.join(temp_folder, PREDICTIONS_OUTPUT_FILE), header=None)
        assert df.equals(config['expected_output'])
Esempio n. 24
0
class TestToNormalize(object):
    """
    to_normalizeのテスト
    """

    lat_data = [
        # @formatter:off
        (-000.000000000001, None, pytest.raises(StackRouteException)),
        (+000.000000000000, -90.000000000000, does_not_raise()),
        (+000.000000000001, -89.999999999999, does_not_raise()),
        (+090.000000000000, +00.000000000000, does_not_raise()),
        (+179.999999999999, +89.999999999999, does_not_raise()),
        (+180.000000000000, +90.000000000000, does_not_raise()),
        (+180.000000000001, None, pytest.raises(StackRouteException))
        # @formatter:on
    ]

    @pytest.mark.parametrize('lat,expected,expectation', lat_data)
    def test_to_normalize_default(self, lat, expected, expectation):
        with expectation:
            assert stack_route._to_normalize(d=lat) == expected

    @pytest.mark.parametrize('lat,expected,expectation', lat_data)
    def test_to_normalize_lat(self, lat, expected, expectation):
        with expectation:
            assert stack_route._to_normalize(d=lat, is_lon=False) == expected

    lon_data = [
        # @formatter:off
        (-000.000000000001, None, pytest.raises(StackRouteException)),
        (+000.000000000000, -180.000000000000, does_not_raise()),
        (+000.000000000001, -179.999999999999, does_not_raise()),
        (+180.000000000000, +000.000000000000, does_not_raise()),
        (+359.999999999999, +179.999999999999, does_not_raise()),
        (+360.000000000000, +180.000000000000, does_not_raise()),
        (+360.000000000001, None, pytest.raises(StackRouteException))
        # @formatter:on
    ]

    @pytest.mark.parametrize('lon,expected,expectation', lon_data)
    def test_to_normalize_lon(self, lon, expected, expectation):
        with expectation:
            assert stack_route._to_normalize(d=lon, is_lon=True) == expected
Esempio n. 25
0
def test_market_initialization(valid_binary_address, first_address,
                               second_address):

    exception = pytest.raises(ValueError)

    if valid_binary_address == first_address == second_address:
        exception = does_not_raise()

    with exception:
        TokenPair(base_token=first_address, quote_token=second_address)
Esempio n. 26
0
    def test_import_csv(self, contacts, contacts_expectation):
        listings = 'sample_data/listings.csv'
        raise_exp = does_not_raise()
        if not isinstance(contacts_expectation, does_not_raise):
            raise_exp = contacts_expectation

        with raise_exp:
            listings_cv = create_path(listings)
            contacts_cv = create_path(contacts)
            listings_df, contacts_df = import_csv(listings_cv, contacts_cv)
Esempio n. 27
0
def test_access_step_component_after_calling():
    """Tests that a step component exists after the step was called."""
    @step
    def some_step():
        pass

    step_instance = some_step()
    step_instance()

    with does_not_raise():
        _ = step_instance.component
Esempio n. 28
0
def test_rep_same_lengths(seqs, expected):
    params = load_params()[1]

    with expected:
        assert rep_same_lengths(seqs, params, apply_fun) is not None

    if expected == does_not_raise():
        h_final, c_final, h_avg = rep_same_lengths(seqs, params, apply_fun)
        assert h_final.shape == (len(seqs), 1900)
        assert c_final.shape == (len(seqs), 1900)
        assert h_avg.shape == (len(seqs), 1900)
Esempio n. 29
0
def test_rep_arbitrary_lengths(seqs, expected):
    params = load_params_1900()

    with expected:
        assert rep_arbitrary_lengths(seqs, params) is not None

    if expected == does_not_raise():
        h_final, c_final, h_avg = rep_arbitrary_lengths(seqs, params)
        assert h_final.shape == (len(seqs), 1900)
        assert c_final.shape == (len(seqs), 1900)
        assert h_avg.shape == (len(seqs), 1900)
Esempio n. 30
0
def test_initialize_step_with_config():
    """Tests that a step can only be initialized with it's defined
    config class."""
    class StepConfig(BaseStepConfig):
        pass

    class DifferentConfig(BaseStepConfig):
        pass

    @step
    def step_with_config(config: StepConfig) -> None:
        pass

    # initialize with wrong config classes
    with pytest.raises(StepInterfaceError):
        step_with_config(config=BaseStepConfig())  # noqa

    with pytest.raises(StepInterfaceError):
        step_with_config(config=DifferentConfig())  # noqa

    # initialize with wrong key
    with pytest.raises(StepInterfaceError):
        step_with_config(wrong_config_key=StepConfig())  # noqa

    # initializing with correct key should work
    with does_not_raise():
        step_with_config(config=StepConfig())

    # initializing as non-kwarg should work as well
    with does_not_raise():
        step_with_config(StepConfig())

    # initializing with multiple args or kwargs should fail
    with pytest.raises(StepInterfaceError):
        step_with_config(StepConfig(), config=StepConfig())

    with pytest.raises(StepInterfaceError):
        step_with_config(StepConfig(), StepConfig())

    with pytest.raises(StepInterfaceError):
        step_with_config(config=StepConfig(), config2=StepConfig())