haarcuba/testix

Mocking framework for Python with *exact* Scenarios

testix's Issues

bug: is_context and awaitable retain their state througout a scenario

version 9.1.1

create expectation from FakeObject

this is an extension of the __dynamic__ functionality.
I want this to be possible:

for i in range(10):
    dynamicly_named_mock = Fake(f'name_{i}')
    s.__from_fake__(dyamically_named_mock).some_method( 'arg1', 'arg2', ... )

currently only this works:

for i in range(10):
    dynamicly_named_mock = Fake(f'name_{i}')
    s.__dynamic__(f'name_{i}').some_method( 'arg1', 'arg2', ... )

when failing, report scnario line in original test file that was violated

support class property

when we use properties in classes, it's unclear how to fake it in our tests.

today, to set a property in some object I use:

### this code can happen anywhere before the flow
the_object = Fake('the_object')
the_object.some_property = 'some_value'

### now we return this object
s.the_flow() >> Fake('the_object')

i suggest adding kwargs to Fake class, so i can use Fake like this:

s.the_flow() >> Fake('the_object', some_property='some_value',... )

bug: patcher may introduce new attribute and not clean it up

if patching an originally non-exising attribute, the current implementation will not clean it up

patch_module should allow for excluding some properties

Description

e.g.

patch_module(tested_module, 'paramiko', exclude=['ssh_exception'])

Motivation

this way, tested code can refer to paramiko exceptions and still be tested with a fake 'paramiko' module.

fix publishing

`call_formatter` can't handle long strings

this is because pprint.pformat breaks long strings and displayes them as tuples.
solution:
use pprint.pformat(width=HUGE_NUMBER)

phase 2

create some more documentation

rewrite docs for live-monitoring

the http server was a bad idea, lets do live monitoring

support async context managers natively

support contexts natively

something like

with s.tempfile.TemporaryFile() as f
       s.__from_fake__(f).read()

       run_some_code()

and the code is

with tempfile.TemporaryFile() as f:
    f.read()

badge update

code is messy - reactor it

incorporate some CI measures

update readme

line number should be displayed on ExpectationException

example:
E === Scenario XXXX ===
E expected: fake_object.get() (/path/to/file.py:65)
E actual : fake_object.get(parameter)

remove f-strings

support async results

e.g.

s.some_func() >> async_result(Fake('whatever'))

Fake attributes shoud be cleared when set

overall "this function should be called but I don't care about the arguments" feature

this is essentialy like IgnoreArgument but for an entire function call, e.g.

s.call_me(IgnoreAll())

and then the code can do any of the following:

call_me(1,2,3,x=1,y=2)
call_me()
call_me(x=1)

document writing the server

write the server, TDD, with unit tests

refactor

upgrade github actions

function call expectations are reversed

e.g.:

E       testix: ExpectationException                                                                                                                                         
E       testix details:                                                                                                                                                      
E       expected: tempfile.NamedTemporaryFile()                                                                                                                              
E       actual  : tempfile.NamedTemporaryFile(mode = 'w')    

but the test specified mode="w" and the code called without it.
in short, the actual and expected are reversed here.

Fake cannot have an attribute called "path"

improve docs

• explain on how strings can be used to represent object that are only "passed around"
• add advanced features docs

orderly docs for patch_module

include the custom value thing

version 9.1.2

support anonymous contexts

version 9

fix publish

document a failing e2e test

make e2e test in docs fail properly

fix docs theme

update deps

more docs

enforce awaiting on async expectations

e.g.

    @pytest.mark.asyncio
    async def test_async_context_managers(self):
        with scenario.Scenario('async context managers') as s:
            s.__async_with__.open('/path/to/file', 'rw') >> fake.Fake('my_file')
            s.__await_on__.my_file.read(500) >> 'some text'
            s.my_file.seek(0)
            s.__await_on__.my_file.write('more text')

            open_mock = fake.Fake('open')
            async with open_mock('/path/to/file', 'rw') as my_file:
                assert await my_file.read(500) == 'some text'
                my_file.seek(0)
                my_file.write('more text')
                # ^^^^ this line should have an await, but we don't catch this

documentation phase 1

create basic documentation project and host it

release 9.1.0

more docs

more docs

strings displayed incorrectly on failures

e.g.

E       Failed: 
E       testix: ExpectationException
E       testix details:
E       expected: thingy.insert()
E       actual  : thingy.set(status, failed)

it should be actual: thingy.set('status', 'failed')

publish from github

bug: if Fake('name') exists, you can still create FakeContext('name'), even though Fake should be a singleton

use >> syntax for throwing expectations

i.e.

s.my_mock.some_call(555).throwing(Exception)

should be

s.my_sock.some_call(555) >> throwin(Exception)

enforce use of with statement when we have a context manager expectation

Scenario() should have a name parameter

Description

we want

with Scenario(title='some-name') as s:
     ...

Motivation

this can be used to prettify some prints, and also increase tests readability.

testix should have a special FakePath for handling the / operator when faking pathlib

if we fake pathlib, the code under test may try to use / - in such a case
we need to return a new fake with the new path

release 6.0.0

modernize code, use poetry