Пример #1
0
def s_codes_extend(codes):
    return s.one_of(
        s.builds(app, codes, codes),
        s.builds(abstract, codes),
        s.builds(join, codes, codes),
        s.builds(QUOTE, codes),
    )
Пример #2
0
def models(
    model,  # type: Type[dm.Model]
    **field_strategies  # type: Union[st.SearchStrategy[Any], DefaultValueType]
):
    # type: (...) -> st.SearchStrategy[Any]
    """Return a strategy for examples of ``model``.

    .. warning::
        Hypothesis creates saved models. This will run inside your testing
        transaction when using the test runner, but if you use the dev console
        this will leave debris in your database.

    ``model`` must be an subclass of :class:`~django:django.db.models.Model`.
    Strategies for fields may be passed as keyword arguments, for example
    ``is_staff=st.just(False)``.

    Hypothesis can often infer a strategy based the field type and validators
    - for best results, make sure your validators are derived from Django's
    and therefore have the known types and attributes.
    Passing a keyword argument skips inference for that field; pass a strategy
    or pass ``hypothesis.extra.django.models.default_value`` to skip
    inference for that field.

    Foreign keys are not automatically derived. If they're nullable they will
    default to always being null, otherwise you always have to specify them.
    For example, examples of a Shop type with a foreign key to Company could
    be generated with::

      shop_strategy = models(Shop, company=models(Company))
    """
    result = {}
    for k, v in field_strategies.items():
        if not isinstance(v, DefaultValueType):
            result[k] = v
    missed = []  # type: List[Text]
    for f in model._meta.concrete_fields:
        if not (f.name in field_strategies or isinstance(f, dm.AutoField)):
            result[f.name] = _get_strategy_for_field(f)
            if result[f.name].is_empty:
                missed.append(f.name)
    if missed:
        raise InvalidArgument(
            u'Missing arguments for mandatory field%s %s for model %s'
            % (u's' if missed else u'', u', '.join(missed), model.__name__))

    for field in result:
        if model._meta.get_field(field).primary_key:
            # The primary key is generated as part of the strategy. We
            # want to find any existing row with this primary key and
            # overwrite its contents.
            kwargs = {field: result.pop(field)}
            kwargs['defaults'] = st.fixed_dictionaries(result)
            return _models_impl(
                st.builds(model.objects.update_or_create, **kwargs)
            )

    # The primary key is not generated as part of the strategy, so we
    # just match against any row that has the same value for all
    # fields.
    return _models_impl(st.builds(model.objects.get_or_create, **result))
Пример #3
0
def s_codes_extend(terms):
    return s.one_of(
        s.builds(APP, terms, terms),
        s.builds(JOIN, terms, terms),
        s.builds(QUOTE, terms),
        s.builds(ABS, terms),
        s.builds(FUN, s_vars, terms),
    )
Пример #4
0
def s_terms_extend(terms):
    return s.one_of(
        s.builds(app, terms, terms),
        s.builds(
            bohm.abstract,
            terms.filter(lambda c: i0 not in quoted_vars(c)),
        ),
        s.builds(join, terms, terms),
        s.builds(QUOTE, terms),
    )
Пример #5
0
def from_dtype(dtype):
    # type: (np.dtype) -> st.SearchStrategy[Any]
    """Creates a strategy which can generate any value of the given dtype."""
    check_type(np.dtype, dtype, 'dtype')
    # Compound datatypes, eg 'f4,f4,f4'
    if dtype.names is not None:
        # mapping np.void.type over a strategy is nonsense, so return now.
        return st.tuples(
            *[from_dtype(dtype.fields[name][0]) for name in dtype.names])

    # Subarray datatypes, eg '(2, 3)i4'
    if dtype.subdtype is not None:
        subtype, shape = dtype.subdtype
        return arrays(subtype, shape)

    # Scalar datatypes
    if dtype.kind == u'b':
        result = st.booleans()  # type: SearchStrategy[Any]
    elif dtype.kind == u'f':
        if dtype.itemsize == 2:
            result = st.floats(width=16)
        elif dtype.itemsize == 4:
            result = st.floats(width=32)
        else:
            result = st.floats()
    elif dtype.kind == u'c':
        if dtype.itemsize == 8:
            float32 = st.floats(width=32)
            result = st.builds(complex, float32, float32)
        else:
            result = st.complex_numbers()
    elif dtype.kind in (u'S', u'a'):
        # Numpy strings are null-terminated; only allow round-trippable values.
        # `itemsize == 0` means 'fixed length determined at array creation'
        result = st.binary(max_size=dtype.itemsize or None
                           ).filter(lambda b: b[-1:] != b'\0')
    elif dtype.kind == u'u':
        result = st.integers(min_value=0,
                             max_value=2 ** (8 * dtype.itemsize) - 1)
    elif dtype.kind == u'i':
        overflow = 2 ** (8 * dtype.itemsize - 1)
        result = st.integers(min_value=-overflow, max_value=overflow - 1)
    elif dtype.kind == u'U':
        # Encoded in UTF-32 (four bytes/codepoint) and null-terminated
        result = st.text(max_size=(dtype.itemsize or 0) // 4 or None
                         ).filter(lambda b: b[-1:] != u'\0')
    elif dtype.kind in (u'm', u'M'):
        if '[' in dtype.str:
            res = st.just(dtype.str.split('[')[-1][:-1])
        else:
            res = st.sampled_from(TIME_RESOLUTIONS)
        result = st.builds(dtype.type, st.integers(-2**63, 2**63 - 1), res)
    else:
        raise InvalidArgument(u'No strategy inference for {}'.format(dtype))
    return result.map(dtype.type)
Пример #6
0
 def steps(self):
     values = self.values()
     if not self.forked:
         return (
             s.just(FORK_NOW)
             | s.builds(Insert, values, values, s.none())
             | s.builds(Delete, values, values, s.none())
         )
     else:
         targets = s.sampled_from((self.left, self.right))
         return s.builds(Insert, values, values, targets) | s.builds(Delete, values, values, targets)
Пример #7
0
def regex_strategy(regex, fullmatch):
    if not hasattr(regex, "pattern"):
        regex = re.compile(regex)

    is_unicode = isinstance(regex.pattern, text_type)

    parsed = sre_parse.parse(regex.pattern, flags=regex.flags)

    if not parsed:
        if is_unicode:
            return st.text()
        else:
            return st.binary()

    if is_unicode:
        base_padding_strategy = st.text()
        empty = st.just(u"")
        newline = st.just(u"\n")
    else:
        base_padding_strategy = st.binary()
        empty = st.just(b"")
        newline = st.just(b"\n")

    right_pad = base_padding_strategy
    left_pad = base_padding_strategy

    if fullmatch:
        right_pad = empty
    elif parsed[-1][0] == sre.AT:
        if parsed[-1][1] == sre.AT_END_STRING:
            right_pad = empty
        elif parsed[-1][1] == sre.AT_END:
            if regex.flags & re.MULTILINE:
                right_pad = st.one_of(
                    empty, st.builds(operator.add, newline, right_pad)
                )
            else:
                right_pad = st.one_of(empty, newline)
    if fullmatch:
        left_pad = empty
    elif parsed[0][0] == sre.AT:
        if parsed[0][1] == sre.AT_BEGINNING_STRING:
            left_pad = empty
        elif parsed[0][1] == sre.AT_BEGINNING:
            if regex.flags & re.MULTILINE:
                left_pad = st.one_of(empty, st.builds(operator.add, left_pad, newline))
            else:
                left_pad = empty

    base = base_regex_strategy(regex, parsed).filter(regex.search)

    return maybe_pad(regex, base, left_pad, right_pad)
Пример #8
0
    def make_radix(base):
        """
        Build a radix from base.

        :param int base: the base of the radix
        """
        list1 = build_nat(base, max_len)
        list2 = build_nat(base, max_len)
        list3 = build_nat(base, max_len)
        if list1 == [] and list2 == [] and list3 == []:
            return strategies.builds(Radix, strategies.just(0), list1, list2, list3, strategies.just(base))
        else:
            return strategies.builds(
                Radix, strategies.sampled_from((-1, 1)), list1, list2, list3, strategies.just(base)
            )
Пример #9
0
    def steps(self):
        strategies = []
        for rule in self.rules():
            converted_arguments = {}
            valid = True
            if rule.precondition is not None and not rule.precondition(self):
                continue
            for k, v in sorted(rule.arguments.items()):
                if isinstance(v, Bundle):
                    bundle = self.bundle(v.name)
                    if not bundle:
                        valid = False
                        break
                converted_arguments[k] = v
            if valid:
                strategies.append(TupleStrategy((
                    just(rule),
                    FixedKeysDictStrategy(converted_arguments)
                ), tuple))
        if not strategies:
            raise InvalidDefinition(
                u'No progress can be made from state %r' % (self,)
            )

        for name, bundle in self.bundles.items():
            if len(bundle) > 1:
                strategies.append(
                    builds(
                        ShuffleBundle, just(name),
                        lists(integers(0, len(bundle) - 1))))

        return one_of(strategies)
Пример #10
0
def ip4_addr_strings():
    """A strategy for IPv4 address strings.

    This consists of four strings representing integers [0..255],
    without zero-padding, joined by dots.
    """
    return st.builds('{}.{}.{}.{}'.format, *(4 * [st.integers(0, 255)]))
Пример #11
0
def subtitles(strict=True):
    '''A Hypothesis strategy to generate Subtitle objects.'''
    # max_value settings are just to avoid overflowing TIMEDELTA_MAX_DAYS by
    # using arbitrary low enough numbers
    timestamp_strategy = timedeltas(min_value=0, max_value=999999)

    # If we want to test \r, we'll test it by ourselves. It makes testing
    # harder without because we don't get the same outputs as inputs on Unix.
    content_strategy = st.text(min_size=1).filter(lambda x: '\r' not in x)
    proprietary_strategy = st.text().filter(
        lambda x: all(eol not in x for eol in '\r\n')
    )

    if strict:
        content_strategy = content_strategy.filter(is_strictly_legal_content)

    subtitle_strategy = st.builds(
        srt.Subtitle,
        index=st.integers(min_value=0),
        start=timestamp_strategy,
        end=timestamp_strategy,
        proprietary=proprietary_strategy,
        content=content_strategy,
    )

    return subtitle_strategy
Пример #12
0
def subtitles(strict=True):
    """A Hypothesis strategy to generate Subtitle objects."""
    # max_value settings are just to avoid overflowing TIMEDELTA_MAX_DAYS by
    # using arbitrary low enough numbers.
    #
    # We also skip subs with start time >= end time, so we split them into two
    # groups to avoid overlap.
    start_timestamp_strategy = timedeltas(min_value=0, max_value=500000)
    end_timestamp_strategy = timedeltas(min_value=500001, max_value=999999)

    # If we want to test \r, we'll test it by ourselves. It makes testing
    # harder without because we don't get the same outputs as inputs on Unix.
    content_strategy = st.text(min_size=1).filter(lambda x: "\r" not in x)
    proprietary_strategy = st.text().filter(
        lambda x: all(eol not in x for eol in "\r\n")
    )

    if strict:
        content_strategy = content_strategy.filter(is_strictly_legal_content)

    subtitle_strategy = st.builds(
        srt.Subtitle,
        index=st.integers(min_value=0),
        start=start_timestamp_strategy,
        end=end_timestamp_strategy,
        proprietary=proprietary_strategy,
        content=content_strategy,
    )

    return subtitle_strategy
def reusable():
    return st.one_of(
        st.sampled_from(base_reusable_strategies),

        st.builds(
            st.floats, min_value=st.none() | st.floats(),
            max_value=st.none() | st.floats(), allow_infinity=st.booleans(),
            allow_nan=st.booleans()
        ),

        st.builds(st.just, st.lists(max_size=0)),
        st.builds(st.sampled_from, st.lists(st.lists(max_size=0))),

        st.lists(reusable).map(st.one_of),
        st.lists(reusable).map(lambda ls: st.tuples(*ls)),
    )
Пример #14
0
def patches():
    """Returns a strategy which generates a Patch object.
    At present, planex.patchqueue.Patchqueue only supports a single
    guard on each patch.
    """
    # If support for multiple guards is added, the max_size constraint
    # can be increased.
    return st.builds(Patch, files(), st.sets(guards(), min_size=0, max_size=1))
Пример #15
0
def test_reports_repr_diff_in_flaky_error():
    @given(builds(DifferentReprEachTime))
    def rude(x):
        assert not any(t[3] == u"best_satisfying_template" for t in inspect.getouterframes(inspect.currentframe()))

    with raises(Flaky) as e:
        rude()
    assert u"Call 1:" in e.value.args[0]
Пример #16
0
def patchqueues():
    """Returns a strategy which generates a PatchQueue object containing
    a list of uniquely-named Patch objects.
    """
    return st.builds(PatchQueue,
                     st.lists(patches(),
                              unique_by=lambda x: x.patch.name,
                              max_size=5))
Пример #17
0
    def ip(cls):
        """
        Strategy for IP generation.
        """
        def format_ip(o1, o2, o3, o4):
            return '{:d}.{:d}.{:d}.{:d}'.format(o1, o2, o3, o4)

        octet = integers(1, 254)
        return builds(format_ip, octet, octet, octet, octet)
Пример #18
0
def offline_instruments():
    """
    Returns a strategy for any instrument that does not need the internet to do
    a query.
    """
    offline_instr = ['lyra', 'noaa-indices', 'noaa-predict', 'soon', 'goes']
    offline_instr = st.builds(a.Instrument, st.sampled_from(offline_instr))

    return st.one_of(offline_instr)
def emails():
    # Not capable of generating the full range of legal email
    # addresses (RFC 5321 ``Mailbox`` productions).  Might be worth
    # expanding someday.  Or might not.
    return strategies.builds(
        u"{local}@{domain}".format,
        local=_local_part(),
        domain=domains(),
    )
Пример #20
0
def urls():
    """
    Strategy for generating ``twisted.python.url.URL``\s.
    """
    return s.builds(
        URL,
        scheme=s.just(u'https'),
        host=dns_names(),
        path=s.lists(s.text(max_size=64), min_size=1, max_size=10))
Пример #21
0
    def network(cls):
        """
        Strategy for generation of networks in CIDR notation.
        """
        def format_network(ip, routing_prefix):
            return '{0:s}/{1:d}'.format(ip, routing_prefix)

        routing_prefix = integers(0, 32)
        return builds(format_network, cls.ip(), routing_prefix)
Пример #22
0
def online_instruments():
    """
    Returns a strategy for any instrument that does not need the internet to do
    a query
    """
    online_instr = ['rhessi']
    online_instr = st.builds(a.Instrument, st.sampled_from(online_instr))

    return online_instr
Пример #23
0
    def export_line(cls):
        """
        Strategy that generates nfs export lines.
        """
        def format_export(path, clients):
            return '{0:s} {1:s}'.format(path, ' '.join(clients))

        path = cls.path()
        clients = lists(cls.client(), min_size=1)
        return builds(format_export, path, clients)
Пример #24
0
    def client_string(cls):
        """
        Strategy for generation of nfs clients.
        """
        def format_client(host, options):
            return '{0:s}{1:s}'.format(host, options)

        host = cls.host()
        options = cls.options_string()
        return builds(format_client, host, options)
Пример #25
0
 def steps(self):
     if not self.space:
         return builds(Action, just('setup'), tuples(st_keys, st_values))
     global_actions = [Action('copydict', ()), Action('cleardict', ())]
     if self.space.reference:
         return (
             self.st_setitem() | sampled_from(global_actions) |
             self.st_updateitem() | self.st_delitem())
     else:
         return (self.st_setitem() | sampled_from(global_actions))
Пример #26
0
def offline_instruments():
    """
    Returns a strategy for any instrument that does not need the internet to do
    a query
    """
    offline_instr = ['lyra', 'norh', 'noaa-indices', 'noaa-predict', 'goes']
    offline_instr = st.builds(a.Instrument, st.sampled_from(offline_instr))

    eve = st.just(a.Instrument('eve') & a.Level(0))
    return st.one_of(offline_instr, eve)
Пример #27
0
def domains():
    """A strategy for :rfc:`1035` fully qualified domain names."""
    atoms = st.text(string.ascii_letters + '0123456789-',
                    min_size=1, max_size=63
                    ).filter(lambda s: '-' not in s[0] + s[-1])
    return st.builds(
        lambda x, y: '.'.join(x + [y]),
        st.lists(atoms, min_size=1),
        # TODO: be more devious about top-level domains
        st.sampled_from(['com', 'net', 'org', 'biz', 'info'])
    ).filter(lambda url: len(url) <= 255)
def test_resolving_recursive_type():
    try:
        assert isinstance(st.builds(Tree).example(), Tree)
    except ResolutionFailed:
        assert sys.version_info[:2] == (3, 5)
        pytest.xfail("python 3.5 typing module may not resolve annotations")
    except TypeError:
        # TypeError raised if typing.get_type_hints(Tree.__init__) fails; see
        # https://github.com/HypothesisWorks/hypothesis-python/issues/1074
        assert sys.version_info[:2] == (3, 5)
        pytest.skip("Could not find type hints to resolve")
def test_errors_are_deferred_until_repr_is_calculated():
    s = st.builds(
        lambda x, y: 1,
        st.just(IHaveABadRepr()),
        y=st.one_of(
            st.sampled_from((IHaveABadRepr(),)), st.just(IHaveABadRepr()))
    ).map(lambda t: t).filter(lambda t: True).flatmap(
        lambda t: st.just(IHaveABadRepr()))

    with pytest.raises(ValueError):
        repr(s)
Пример #30
0
def from_attrs_attribute(attrib, target):
    """Infer a strategy from the metadata on an attr.Attribute object."""
    # Try inferring from the default argument.  Note that this will only help
    # the user passed `infer` to builds() for this attribute, but in that case
    # we use it as the minimal example.
    default = st.nothing()
    if isinstance(attrib.default, attr.Factory):
        if not getattr(attrib.default, "takes_self", False):  # new in 17.1
            default = st.builds(attrib.default.factory)
    elif attrib.default is not attr.NOTHING:
        default = st.just(attrib.default)

    # Try inferring None, exact values, or type from attrs provided validators.
    null = st.nothing()  # updated to none() on seeing an OptionalValidator
    in_collections = []  # list of in_ validator collections to sample from
    validator_types = set()  # type constraints to pass to types_to_strategy()
    if attrib.validator is not None:
        validator = attrib.validator
        if isinstance(validator, attr.validators._OptionalValidator):
            null = st.none()
            validator = validator.validator
        if isinstance(validator, attr.validators._AndValidator):
            vs = validator._validators
        else:
            vs = [validator]
        for v in vs:
            if isinstance(v, attr.validators._InValidator):
                if isinstance(v.options, string_types):
                    in_collections.append(list(all_substrings(v.options)))
                else:
                    in_collections.append(v.options)
            elif isinstance(v, attr.validators._InstanceOfValidator):
                validator_types.add(v.type)

    # This is the important line.  We compose the final strategy from various
    # parts.  The default value, if any, is the minimal shrink, followed by
    # None (again, if allowed).  We then prefer to sample from values passed
    # to an in_ validator if available, but infer from a type otherwise.
    # Pick one because (sampled_from((1, 2)) | from_type(int)) would usually
    # fail validation by generating e.g. zero!
    if in_collections:
        sample = st.sampled_from(list(ordered_intersection(in_collections)))
        strat = default | null | sample
    else:
        strat = default | null | types_to_strategy(attrib, validator_types)

    # Better to give a meaningful error here than an opaque "could not draw"
    # when we try to get a value but have lost track of where this was created.
    if strat.is_empty:
        raise ResolutionFailed(
            "Cannot infer a strategy from the default, validator, type, or "
            "converter for attribute=%r of class=%r" % (attrib, target)
        )
    return strat
Пример #31
0
def object_schema(schema: dict) -> st.SearchStrategy[Dict[str, JSONType]]:
    """Handle a manageable subset of possible schemata for objects."""
    required = schema.get("required", [])  # required keys
    min_size = max(len(required), schema.get("minProperties", 0))
    max_size = schema.get("maxProperties", math.inf)
    assert min_size <= max_size, (min_size, max_size)

    names = schema.get("propertyNames", {})  # schema for optional keys
    if names == FALSEY:
        assert min_size == 0, schema
        return st.builds(dict)
    names["type"] = "string"

    properties = schema.get("properties", {})  # exact name: value schema
    patterns = schema.get("patternProperties",
                          {})  # regex for names: value schema
    # schema for other values; handled specially if nothing matches
    additional = schema.get("additionalProperties", {})
    additional_allowed = additional != FALSEY

    dependencies = schema.get("dependencies", {})
    dep_names = {k: v for k, v in dependencies.items() if isinstance(v, list)}
    dep_schemas = {k: v for k, v in dependencies.items() if k not in dep_names}
    del dependencies

    name_strats = (
        st.sampled_from(
            sorted(dep_names) + sorted(dep_schemas) + sorted(properties)) if
        (dep_names or dep_schemas or properties) else st.nothing(),
        from_schema(names) if additional_allowed else st.nothing(),
        st.one_of([st.from_regex(p) for p in sorted(patterns)]),
    )
    all_names_strategy = st.one_of([s for s in name_strats if not s.is_empty
                                    ]).filter(make_validator(names).is_valid)

    @st.composite  # type: ignore
    def from_object_schema(draw: Any) -> Any:
        """Do some black magic with private Hypothesis internals for objects.

        It's unfortunate, but also the only way that I know of to satisfy all
        the interacting constraints without making shrinking totally hopeless.

        If any Hypothesis maintainers are reading this... I'm so, so sorry.
        """
        # Hypothesis internals are not type-annotated... I do mean *black* magic!
        elements = cu.many(
            draw(st.data()).conjecture_data,
            min_size=min_size,
            max_size=max_size,
            average_size=min(min_size + 5, (min_size + max_size) / 2),
        )
        out: dict = {}
        while elements.more():
            for key in required:
                if key not in out:
                    break
            else:
                for k in set(dep_names).intersection(out):  # pragma: no cover
                    # nocover because some of these conditionals are rare enough
                    # that not all test runs hit them, but are still essential.
                    key = next((n for n in dep_names[k] if n not in out), None)
                    if key is not None:
                        break
                else:
                    key = draw(
                        all_names_strategy.filter(lambda s: s not in out))

            pattern_schemas = [
                patterns[rgx] for rgx in sorted(patterns)
                if re.search(rgx, string=key) is not None
            ]
            if key in properties:
                pattern_schemas.insert(0, properties[key])

            if pattern_schemas:
                out[key] = draw(merged_as_strategies(pattern_schemas))
            else:
                out[key] = draw(from_schema(additional))

            for k, v in dep_schemas.items():
                if k in out and not make_validator(v).is_valid(out):
                    out.pop(key)
                    elements.reject()

        for k in set(dep_names).intersection(out):
            assume(set(out).issuperset(dep_names[k]))
        return out

    return from_object_schema()
Пример #32
0

def test_may_not_fill_with_non_nan_when_unique_is_set_and_type_is_not_number():
    @given(nps.arrays(
        dtype='U', shape=10,
        unique=True, fill=st.just(u'')))
    def test(arr):
        pass

    with pytest.raises(InvalidArgument):
        test()


@given(st.data(),
       st.builds('{}[{}]'.format,
                 st.sampled_from(('datetime64', 'timedelta64')),
                 st.sampled_from(nps.TIME_RESOLUTIONS)
                 ).map(np.dtype)
       )
def test_inferring_from_time_dtypes_gives_same_dtype(data, dtype):
    ex = data.draw(nps.from_dtype(dtype))
    assert dtype == ex.dtype


@given(st.data(), nps.byte_string_dtypes() | nps.unicode_string_dtypes())
def test_inferred_string_strategies_roundtrip(data, dtype):
    # Check that we never generate too-long or nul-terminated strings, which
    # cannot be read back out of an array.
    arr = np.zeros(shape=1, dtype=dtype)
    ex = data.draw(nps.from_dtype(arr.dtype))
    arr[0] = ex
    assert arr[0] == ex
Пример #33
0
def points():
    x = integers(min_value=-100, max_value=100)
    y = integers(min_value=-100, max_value=100)
    return builds(Point, x, y)
Пример #34
0
def test_cannot_force_inference_for_unannotated_arg():
    with pytest.raises(InvalidArgument):
        st.builds(non_annotated_func, a=infer, c=st.none()).example()
    with pytest.raises(InvalidArgument):
        st.builds(non_annotated_func, a=st.none(), c=infer).example()
Пример #35
0
def test_required_args(target, args, kwargs):
    # Mostly checking that `self` (and only self) is correctly excluded
    st.builds(
        target, *map(st.just, args), **{k: st.just(v) for k, v in kwargs.items()}
    ).example()
))
def test_replaces_decimals_unaffected(x, persister):
    assert persister._replace_decimals(x) == x


texts = st.text(max_size=5)
events = st.builds(
    Event,
    kind=st.sampled_from(['task', 'control']),
    task_id=texts,
    timestamp=st.floats(min_value=0, allow_nan=False, allow_infinity=False),
    terminal=st.booleans(),
    success=st.booleans(),
    task_config=st.dictionaries(
        max_size=5,
        keys=texts,
        values=st.lists(
            st.one_of(
                texts,
                st.dictionaries(max_size=5, keys=texts, values=texts),
            ),
            max_size=5,
        )
    ),
    raw=st.sampled_from([None]),
)


@settings(max_examples=50)
@given(x=events)
def test_event_to_item_timestamp(x, persister):
    res = persister._event_to_item(x)['M']
Пример #37
0
            of 2D points on the surface of an ellipse.
        n (int, optional):
            The number of points on the surface of the ellipsoid (ellipse).

    Returns:
        :math:`(N, 3)` or :math:`(N, 2)` :class:`numpy.ndarray`: The points.
    """
    points = []
    points = np.zeros((n, 3))
    points[:, 0] = np.random.normal(0, a, n)
    points[:, 1] = np.random.normal(0, b, n)
    if c > 0:
        points[:, 2] = np.random.normal(0, c, n)
    ds = np.linalg.norm(points / [a, b, c if c else 1], axis=-1)
    points /= ds[:, np.newaxis]
    return points if c else points[:, :2]


EllipsoidSurfaceStrategy = builds(
    points_from_ellipsoid_surface,
    floats(0.1, 5),
    floats(0.1, 5),
    floats(0.1, 5),
    integers(5, 15),
)

EllipseSurfaceStrategy = builds(points_from_ellipsoid_surface,
                                floats(0.1, 5),
                                floats(0.1, 5),
                                n=integers(5, 15))
def test_build_class_with_target_kwarg():
    NamedTupleWithTargetField = collections.namedtuple('Something', ['target'])
    ds.builds(NamedTupleWithTargetField, target=ds.integers()).example()
Пример #39
0
def dicts(keys, vals, max_size=3):
    return s.builds(Dict, s.lists(s.tuples(keys, vals), max_size=max_size))
Пример #40
0
def lists(vals, max_size=3):
    return s.builds(List, s.lists(vals, max_size=max_size))
Пример #41
0
def subscripts(values, slice_):
    return s.builds(Subscript, values, slice_)
Пример #42
0
        return self.s.repr_tree()


class Subscript(Node):
    node_class = astroid.Subscript


class List(Node):
    node_class = astroid.List


class Dict(Node):
    node_class = astroid.Dict


consts = s.builds(astroid.Const, s.none() | s.integers() | s.text())


def subscripts(values, slice_):
    return s.builds(Subscript, values, slice_)


def lists(vals, max_size=3):
    return s.builds(List, s.lists(vals, max_size=max_size))


def dicts(keys, vals, max_size=3):
    return s.builds(Dict, s.lists(s.tuples(keys, vals), max_size=max_size))


NestedLists = s.deferred(lambda: consts | lists(NestedLists))
Пример #43
0
    BYearBegin,
)

# ----------------------------------------------------------------
# Helpers for generating random data

with warnings.catch_warnings():
    warnings.simplefilter('ignore')
    min_dt = pd.Timestamp(1900, 1, 1).to_pydatetime(),
    max_dt = pd.Timestamp(1900, 1, 1).to_pydatetime(),

gen_date_range = st.builds(
    pd.date_range,
    start=st.datetimes(
        # TODO: Choose the min/max values more systematically
        min_value=pd.Timestamp(1900, 1, 1).to_pydatetime(),
        max_value=pd.Timestamp(2100, 1, 1).to_pydatetime()),
    periods=st.integers(min_value=2, max_value=100),
    freq=st.sampled_from('Y Q M D H T s ms us ns'.split()),
    tz=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()),
)

gen_random_datetime = st.datetimes(min_value=min_dt,
                                   max_value=max_dt,
                                   timezones=st.one_of(st.none(),
                                                       dateutil_timezones(),
                                                       pytz_timezones()))

# The strategy for each type is registered in conftest.py, as they don't carry
# enough runtime information (e.g. type hints) to infer how to build them.
gen_yqm_offset = st.one_of(*map(st.from_type, [
    MonthBegin, MonthEnd, BMonthBegin, BMonthEnd, QuarterBegin, QuarterEnd,
Пример #44
0
    """Similar to ascii_text, but does not generate multiline strings."""
    return text(_ascii_inline, min_size=min_size, max_size=max_size)


# Strategy for identifiers, i.e. strings that can be used as symbols (function
# names, etc.) in Python programs.
# Unqualified identifiers cannot contain ".", qualified identifiers can
# (but only between unqualified identifiers, i.e. not at the beginning or end).
unqualified_identifiers = text(string.ascii_letters, min_size=1, max_size=5)
qualified_identifiers = lists(unqualified_identifiers, min_size=2, max_size=3).map(
    ".".join
)
identifiers = unqualified_identifiers | qualified_identifiers

# Strategy for python.Line objects.
lines = builds(py.Line, ascii_inline_text(), indent_levels)

# Strategy for lists of strings to be used as comment text in tests.
comments = lists(ascii_inline_text(), max_size=3)

# Strategy for python.Statement objects. Basically, if you ask for a Statement,
# you get an instance of one of Statement's subclasses.
# All Statement subclasses should be mentioned here.
# We need deferred to break the cyclic dependency between builds() that depend statements.
statements = deferred(
    lambda: one_of(
        opaque_blocks,
        functions,
        decorations,
        classes,
        standalones,
Пример #45
0
def test_does_not_error_on_unhashable_kwarg():
    with pytest.raises(InvalidArgument):
        st.builds(lambda alphabet: 1, alphabet=['a', 'b', 'c']).validate()
def test_builds_can_specify_target_with_target_kwarg():
    ds.builds(x=ds.integers(), target=lambda x: x).example()
Пример #47
0
        return [
            Segment(start, end) for start, end in combinations(points_list, 2)
        ]

    return (strategies.lists(points, min_size=2, max_size=8,
                             unique=True).map(to_net))


rational_segments_lists = ((rational_coordinates_strategies.map(
    planar.segments).flatmap(strategies.lists))
                           | (rational_coordinates_strategies.map(
                               planar.points).flatmap(points_to_nets)))
segments_lists = (
    (coordinates_strategies.map(planar.segments).flatmap(strategies.lists))
    | (coordinates_strategies.map(planar.points).flatmap(points_to_nets)))
empty_multipolygons = strategies.builds(Multipolygon, strategies.builds(list))
empty_multiregions = strategies.builds(list)
empty_multisegments = strategies.builds(Multisegment, strategies.builds(list))
multipolygons = coordinates_strategies.flatmap(planar.multipolygons)
multiregions = coordinates_strategies.flatmap(planar.multicontours)
multisegments = coordinates_strategies.flatmap(planar.multisegments)
empty_multisegments_with_multisegments = strategies.tuples(
    empty_multisegments, multisegments)
rational_multisegments_strategies = (rational_coordinates_strategies.map(
    planar.multisegments))
rational_multisegments_pairs = (
    rational_multisegments_strategies.flatmap(to_pairs))
rational_multisegments_triplets = (
    rational_multisegments_strategies.flatmap(to_triplets))
multisegments_strategies = coordinates_strategies.map(planar.multisegments)
multisegments_pairs = multisegments_strategies.flatmap(to_pairs)
def test_builds_raises_with_no_target():
    with pytest.raises(InvalidArgument):
        ds.builds().example()
Пример #49
0
    def to_json(self):
        return json.dumps(self.value)

    @classmethod
    def from_json(cls, string):
        value = string
        return cls(value)


# Passing a zero-arg function to `deferred` lets us write recursive definitions!
json_strat = st.deferred(lambda: st.one_of(
    # JSON values are defined as nil, false, true, number, string, ...
    st.none(),
    st.booleans(),
    st.floats(),
    st.text(),
    # or arrays of json, or "objects" ie string: json dictionaries.
    st.lists(json_strat),
    st.dictionaries(st.text(), json_strat)))


# `builds` draws an example from `json_strat`, then calls Record(value=...)
@given(st.builds(Record, value=json_strat))
def test_record_json_roundtrip(record):
    string = record.to_json()
    new = Record.from_json(string)
    #assert record == new
    # TODO: fix the first problem in the code being tested
    # TODO: fix the second problem by using hypothesis.assume in the test,
    #       or an argument to one of the strategies defining json
Пример #50
0
def test_force_builds_to_infer_strategies_for_default_args():
    # By default, leaves args with defaults and minimises to 2+4=6
    assert minimal(st.builds(annotated_func), lambda ex: True) == 6
    # Inferring integers() for args makes it minimise to zero
    assert minimal(st.builds(annotated_func, b=infer, d=infer), lambda ex: True) == 0
Пример #51
0
def test_raises_for_arg_with_unresolvable_annotation():
    with pytest.raises(ResolutionFailed):
        st.builds(unknown_annotated_func).example()
    with pytest.raises(ResolutionFailed):
        st.builds(unknown_annotated_func, a=st.none(), c=infer).example()
Пример #52
0

class Foo:
    def __init__(self, x):
        pass


class Bar(Foo):
    pass


class Baz(Foo):
    pass


st.register_type_strategy(Bar, st.builds(Bar, st.integers()))
st.register_type_strategy(Baz, st.builds(Baz, st.integers()))


@pytest.mark.parametrize(
    "var,expected",
    [
        (typing.TypeVar("V"), object),
        (typing.TypeVar("V", bound=int), int),
        (typing.TypeVar("V", bound=Foo), (Bar, Baz)),
        (typing.TypeVar("V", bound=typing.Union[int, str]), (int, str)),
        (typing.TypeVar("V", int, str), (int, str)),
    ],
)
@settings(suppress_health_check=[HealthCheck.too_slow])
@given(data=st.data())
Пример #53
0
def test_cannot_pass_infer_as_posarg():
    with pytest.raises(InvalidArgument):
        st.builds(annotated_func, infer).example()
Пример #54
0
    thread.start()
    thread.join()
    assert results == ["success", "success"]


@given(integers())
def test_can_call_an_argument_f(f):
    # See issue https://github.com/HypothesisWorks/hypothesis-python/issues/38
    # for details
    pass


Litter = namedtuple("Litter", ("kitten1", "kitten2"))


@given(builds(Litter, integers(), integers()))
def test_named_tuples_are_of_right_type(litter):
    assert isinstance(litter, Litter)


@fails_with(AttributeError)
@given(integers().map(lambda x: x.nope))
@settings(suppress_health_check=HealthCheck.all())
def test_fails_in_reify(x):
    pass


@given(text("a"))
def test_a_text(x):
    assert set(x).issubset(set("a"))
Пример #55
0
def test_issue_946_regression():
    # Turned type hints into kwargs even if the required posarg was passed
    st.builds(annotated_func, st.integers()).example()
Пример #56
0
def strat_two(draw):
    return draw(st.builds(dict, some_text=st.text(min_size=1)))
Пример #57
0
def strat_one(draw):
    return draw(st.builds(dict, val=st.builds(dict, two=strat_two())))
Пример #58
0
def strat():
    return st.builds(dict, one=strat_one())
Пример #59
0
        return importlib.import_module("unittest.mock")
    else:
        return pytest.importorskip("mock")


# ----------------------------------------------------------------
# Global setup for tests using Hypothesis

# Registering these strategies makes them globally available via st.from_type,
# which is use for offsets in tests/tseries/offsets/test_offsets_properties.py
for name in 'MonthBegin MonthEnd BMonthBegin BMonthEnd'.split():
    cls = getattr(pd.tseries.offsets, name)
    st.register_type_strategy(
        cls, st.builds(
            cls,
            n=st.integers(-99, 99),
            normalize=st.booleans(),
        ))

for name in 'YearBegin YearEnd BYearBegin BYearEnd'.split():
    cls = getattr(pd.tseries.offsets, name)
    st.register_type_strategy(
        cls,
        st.builds(
            cls,
            n=st.integers(-5, 5),
            normalize=st.booleans(),
            month=st.integers(min_value=1, max_value=12),
        ))

for name in 'QuarterBegin QuarterEnd BQuarterBegin BQuarterEnd'.split():
Пример #60
0
def test_builds_repr():
    assert repr(st.builds(foo, st.just(1), x=st.just(10))) == \
        u'builds(foo, just(1), x=just(10))'