sixty-north / cosmic-ray Goto Github PK
View Code? Open in Web Editor NEWMutation testing for Python
License: MIT License
Mutation testing for Python
License: MIT License
drone, landscape, etc. Look into the options.
Our tests need a reliable way to compare two ast nodes for value equality. For example, do two Num nodes hold the same numeric value? I'm sure there are devilish details here, but this is necessary for more realistic tests.
This is the kind of wacky thing that mutants might do.
One example of bad behavior is when we run cosmic ray over bottle.
We could install a cosmic-ray executable as part of setup.py. This can use the same underlying mechanism as the executable package, of course.
Right now we only really support unittest-based test discovery. There are other systems out there that we might reasonably support, so consider a way to at least abstract the discovery concept.
We could install a cosmic-ray executable as part of setup.py. This can use the same underlying mechanism as the executable package, of course.
Right now we only support Python 3 (and probably really only Python 3.3+ or something like that.) It may not be easy to support multiple versions of Python in a single code base; for example, the finder/loader system may not be available very far back. In this case perhaps we should just have two version of the tool.
Right now we're only known to work with normal Python source-based modules. We may not work with C-extension modules, zip modules, or anything else, but in principle I think we can work with a lot of these. And if we can't, we need to be robust (and informative) in the face of things we can't handle.
Some users might want to be able to specify more than one test root. This should be very straightforward to implement.
We obviously need more operations. This task really is "make a list of operators and make issues for creating them."
We obviously need more operations. This task really is "make a list of operators and make issues for creating them."
Something screwy happens with modules or importing or something. Just go to the bottle source directory and run python -m cosmic_ray.app bottle test
.
It stands to reason that we could parallelize the heck out of Cosmic Ray with the multiprocessing module. In fact, considering how simple it should be, we would be remiss if we didn't.
Right now we only support Python 3 (and probably really only Python 3.3+ or something like that.) It may not be easy to support multiple versions of Python in a single code base; for example, the finder/loader system may not be available very far back. In this case perhaps we should just have two version of the tool.
In some cases we'll find that surviving mutations are completely acceptable. Consider ways to allow users to add exceptions.
Right now we only really support unittest-based test discovery. There are other systems out there that we might reasonably support, so consider a way to at least abstract the discovery concept.
Right now we're only known to work with normal Python source-based modules. We may not work with C-extension modules, zip modules, or anything else, but in principle I think we can work with a lot of these. And if we can't, we need to be robust (and informative) in the face of things we can't handle.
drone, landscape, etc. Look into the options.
We obviously need more operations. This task really is "make a list of operators and make issues for creating them."
In some cases we'll find that surviving mutations are completely acceptable. Consider ways to allow users to add exceptions.
Just a simple main.py to kick off main processing.
Right now we're only known to work with normal Python source-based modules. We may not work with C-extension modules, zip modules, or anything else, but in principle I think we can work with a lot of these. And if we can't, we need to be robust (and informative) in the face of things we can't handle.
We currently pipe all logging and results to stdout via the logging module. We should consider a system whereby mutation results are piped to a place where different formatters can be applied. For example, it would be nice to be able to get emacs-formatted output for simple clicking in a compilation-mode buffer.
Perhaps the logging module gives us everything we need. Probably so. But at a minimum it should be possible to see just the results – incompetent, killed, or survived + location information + operation info – without seeing everything else.
We could install a cosmic-ray executable as part of setup.py. This can use the same underlying mechanism as the executable package, of course.
Our tests need a reliable way to compare two ast nodes for value equality. For example, do two Num nodes hold the same numeric value? I'm sure there are devilish details here, but this is necessary for more realistic tests.
In some cases we'll find that surviving mutations are completely acceptable. Consider ways to allow users to add exceptions.
This is the kind of wacky thing that mutants might do.
One example of bad behavior is when we run cosmic ray over bottle.
Some users might want to be able to specify more than one test root. This should be very straightforward to implement.
Right now we're only known to work with normal Python source-based modules. We may not work with C-extension modules, zip modules, or anything else, but in principle I think we can work with a lot of these. And if we can't, we need to be robust (and informative) in the face of things we can't handle.
Just a simple main.py to kick off main processing.
We currently pipe all logging and results to stdout via the logging module. We should consider a system whereby mutation results are piped to a place where different formatters can be applied. For example, it would be nice to be able to get emacs-formatted output for simple clicking in a compilation-mode buffer.
Perhaps the logging module gives us everything we need. Probably so. But at a minimum it should be possible to see just the results – incompetent, killed, or survived + location information + operation info – without seeing everything else.
Right now we only really support unittest-based test discovery. There are other systems out there that we might reasonably support, so consider a way to at least abstract the discovery concept.
Some users might want to be able to specify more than one test root. This should be very straightforward to implement.
It stands to reason that we could parallelize the heck out of Cosmic Ray with the multiprocessing module. In fact, considering how simple it should be, we would be remiss if we didn't.
It stands to reason that we could parallelize the heck out of Cosmic Ray with the multiprocessing module. In fact, considering how simple it should be, we would be remiss if we didn't.
We currently pipe all logging and results to stdout via the logging module. We should consider a system whereby mutation results are piped to a place where different formatters can be applied. For example, it would be nice to be able to get emacs-formatted output for simple clicking in a compilation-mode buffer.
Perhaps the logging module gives us everything we need. Probably so. But at a minimum it should be possible to see just the results – incompetent, killed, or survived + location information + operation info – without seeing everything else.
Right now we only support Python 3 (and probably really only Python 3.3+ or something like that.) It may not be easy to support multiple versions of Python in a single code base; for example, the finder/loader system may not be available very far back. In this case perhaps we should just have two version of the tool.
Just a simple main.py to kick off main processing.
drone, landscape, etc. Look into the options.
drone, landscape, etc. Look into the options.
Right now we only really support unittest-based test discovery. There are other systems out there that we might reasonably support, so consider a way to at least abstract the discovery concept.
Our tests need a reliable way to compare two ast nodes for value equality. For example, do two Num nodes hold the same numeric value? I'm sure there are devilish details here, but this is necessary for more realistic tests.
This is the kind of wacky thing that mutants might do.
One example of bad behavior is when we run cosmic ray over bottle.
Something screwy happens with modules or importing or something. Just go to the bottle source directory and run python -m cosmic_ray.app bottle test
.
In some cases we'll find that surviving mutations are completely acceptable. Consider ways to allow users to add exceptions.
We could install a cosmic-ray executable as part of setup.py. This can use the same underlying mechanism as the executable package, of course.
Some users might want to be able to specify more than one test root. This should be very straightforward to implement.
Right now we only support Python 3 (and probably really only Python 3.3+ or something like that.) It may not be easy to support multiple versions of Python in a single code base; for example, the finder/loader system may not be available very far back. In this case perhaps we should just have two version of the tool.
It stands to reason that we could parallelize the heck out of Cosmic Ray with the multiprocessing module. In fact, considering how simple it should be, we would be remiss if we didn't.
Something screwy happens with modules or importing or something. Just go to the bottle source directory and run python -m cosmic_ray.app bottle test
.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.