bdsoha / expycted Goto Github PK

Integrate Code Climate into development workflow:

• Publish test coverage reports in CI
• Add pep8 static code analysis
• Execute code analysis on PRs

Instead of checking equivalence, the matcher should use the IsMatcher to check exact equality.

This will be a breaking change.

The logic from the current be implementation should be moved to the weak qualifier of equals.

• Use utilities to shorten test cases
• Cleanup duplicates
• Refactor filesystem fixtures
• get_singleton has no effect
• Add tests for alias

Add generic typing to:

• assertion_property
• matcher_proxy
• Add type checks for mypy
• Test in vscode
• Test in PyCharm

Return Expectation after assertion in matcher_proxy.py to allow chaining.

.github/workflows/python-package.yml is repeated.

Support Path objects in folder expectations

• Add tests for signature()
• Add tests for details()

Allow assertion method chaining:

expect([1, 2, 3]).to.contain(3).and_to_not.contain(7)
# expect([1, 2, 3]).to.contain(3).and_not.contain(7)
# expect([1, 2, 3]).to.contain(3).and_to.contain(2)

Add chains:

• and_to
• and_to_not
• and_not

I would like to propose a few additions and refactors (with your approval, I can begin working on them):

• #11
• #18
• #15
• #19
• #9

Add the following GitHub templates:

• Issue template (feature request)
• Issue template (bug report)
• #62
• #60
• #61

Inspiration can be gathered from this repo

Needed:

• Testing folder contents
• Testing whether nested dictionaries have user defined structure/contain some "path" (Pydantic already handles this well enough)

Nice to have:

• Testing click CLI tools approachably (Just doesn't sound interesting enough in hindsight)
• Testing API responses (Can be done using already available matchers and some minor additional logic, not substantial enough for the effort)

Reset negated state after each assertion.

Assuming:

def test():
    data = ['hello']

    # Using the `assert` keyword
    assert isinstance(data, list)
    assert len(data) == 1
    assert 'hello' in data
    assert 'world' not in data

    # Using expectations
    expect(data) \
        .to.be_a_list() \
        .and_to.have_len(1) \
        .and_not.contain('world') \
        .and_to.contain('hello') \

This will currently fail due to the chained functionally of .and_not.contain('world') maintaining the negated stated.

Optionally colorize assertion messages to express the difference between the actual and expected values.

Add additional expectations:

• to_be_list()
• to_be_tuple()
• to_be_set()
• to_be_dict()
• to_have_length()
• to_have_attribute()
• to_have_attributes()
• to_almost_equal()
• to_be_instanceof()
• to_be_bool()
• to_be_numeric() # Strict
• to_be_callable()
• to_be_int()
• to_be_float()
• to_be_str()
• to_be_none()
• to_startwith()
• to_endwith()
• to_match() # regex
• add documentation

Allow higher-order expectations to assert all values in an iterable item using syntax expect([1,2,3]).each.to_be_numeric(3).

• Add a chain method for .each to assert each value independently
• Add a chain method for .all as an alias to .each
• Add a chain method for .any to assert that at least one value conforms to the expectation

Reset negated state after each assertion in #22 was not completed.

Rewrite core internals in a more object oriented fashion.

• Move the responsibility for evaluating (comparing actual and expected) from BaseExpectation to a new base class

class BaseMatcher:
    def message(self, *, actual=None, **kwargs) -> str:
        ...

    def _match(self, *, actual=None, **kwargs):
        ...

    def _negate(self, *, actual=None, **kwargs):
        ...

    def __call__(self, *, actual=None, **kwargs) -> bool:
       ...

• #37
• #38
• #39
• #41
• #40
• #42
• #43
• #44
• #45
• #46
• #52
• #51
• #50
• #49
• #48
• #47
• #53
• #54

Use dynamic assertion calls instead of manually invoking self._internal_{method}.

Should be added to the docs-site with a CONTRIBUTING.md pointing to it.

Good Examples:

• https://github.com/vuejs/vitepress/blob/main/.github/contributing.md
• https://gist.github.com/briandk/3d2e8b3ec8daf5a27a62
• https://github.com/apache/airflow/blob/main/CONTRIBUTING.rst (very in-depth)
• https://github.com/cezaraugusto/github-template-guidelines/blob/master/.github/CONTRIBUTING.md
• https://github.com/nayafia/contributing-template

Add documentation as a static site on GitHub pages.

• Add CI deployment to GitHub pages
• Add a custom CNAME record
• Create docs directory with .md files and VitePress
• Refactor the main readme to point the documentation site
• Remove the PYPIREADME.md
• #69

Pages

• Introduction / What is Expycted?
• Introduction / Installation
• Introduction / Getting Started
• Expectations / Overview + Available Expectations
• Expectations / Strict Mode
• Expectations / Higher Order Tests
• Expectations / Interface / Main
• Expectations / Interface / Chains
• Expectations / Interface / Filesystem
• Expectations / Interface / Functions
• Get Involved / Introduction (issues/bugs/docs)
• Get Involved / Development Install
• Get Involved / Contribution Workflow
• Get Involved / Pull Request Guidelines

Move away from the use of Poetry and Pipenv as part of the development workflow.
Such solutions are great, but the choice of a development work-belt should be that of the developer and not opinionated.

Instead, move to vanilla Python.

• Replace Poetry in pyproject.toml
• Migrate Pipenv into pyproject.toml
• Add [project.optional-dependencies] for test and ci dependencies
• Extract version using dynamic = ["version"] from a __version__ variable
• Update CI workflows
• Update .gitignore

• to_return
• to_raise

Integrate pre-commit into the project:

• #73
• #67
• Run single/double quote checks
• #63
• Run pydocstyle
• #66
• #64
• Add black