Vraag Hoe automatisch testen uit te voeren wanneer er een verandering is in mijn project (Django)?


Op het moment dat ik hardloop python manage.py test af en toe nadat ik belangrijke wijzigingen heb aangebracht in mijn django-project. Is het mogelijk om deze tests automatisch uit te voeren wanneer ik een bestand in mijn project wijzig en sla? Het is handig om bugs eerder te detecteren (ik weet dat rails ongeveer zoiets als rspec heeft). Ik gebruik neus en django-neus. Bij voorbaat bedankt.


22
2018-03-01 20:42


oorsprong


antwoorden:


Gebruik entr:

$ find . -name '*.py' | entr python ./manage.py test

Of combineer het voor extra krediet ack:

$ ack --python | entr python ./manage.py test

Als u wilt dat het zelfs nieuwe bestanden vindt terwijl u ze toevoegt:

$ until ack -f --python | entr -d python ./manage.py test; do sleep 1; done

16
2017-07-22 08:41



Ik ben een JavaScript-ontwikkelaar dus ik gebruikte de hulpmiddelen die JS-ontwikkelaar met Node.js heeft gebouwd om hetzelfde doel te bereiken in mijn projecten. Het is heel eenvoudig, maar je moet ook nodeJS installeren om het werkend te krijgen.

Ik heb een bestand met de naam gruntfile.js gemaakt in de hoofdmap van mijn project:

//gruntfile.js
module.exports = function(grunt) {

  grunt.initConfig({
    watch: {
      files: ['*.py'],
      tasks: ['shell']
    },
    shell: {
      test: {
        command: 'python main_test.py'
      }
    }
  });

  grunt.loadNpmTasks('grunt-contrib-watch');
  grunt.loadNpmTasks('grunt-shell');

  grunt.registerTask('default', ['watch']);
};

Wat het doet is in principe elk bestand in die map bekijken dat een py-extensie heeft en als deze is gewijzigd, voer dan een shell-opdracht uit die in dit geval mijn python-test is (je zou deze willen veranderen, mijn testnaam was main_test.py). Om dit grunt-script te kunnen uitvoeren, moet je Node.js installeren en daarna heb je npm in je globale pad. daarna moet je ook een paar knoopmodules insluiten. Al deze modules, met uitzondering van grunt-cli, worden opgeslagen in je huidige map, dus zorg dat je de root van je project bent of in welke map je ook gruntfile.js invoert. Voer vervolgens de fallowing-opdrachten uit.

npm install grunt-cli -g
npm install grunt
npm install grunt-contrib-watch
npm install grunt-shell

Maak je geen zorgen over de grootte, dit zijn hele kleine modules. Nu je alles hebt ingesteld, kun je gewoon rennen grunt en het zal je Py-bestanden gaan bekijken en wanneer je ze opslaat zal het je testen uitvoeren. Het is misschien niet de beste manier om Python-tests uit te voeren, maar zoals ik al zei, ik ben een JavaScript-ontwikkelaar en ik denk dat Grunt een zeer eenvoudige manier heeft geboden om tests uit te voeren, zelfs voor andere talen, dus ik gebruik het.


8
2017-07-12 05:53



Ik heb het gewoon geprobeerd nose-watch en het werkte fantastisch! installeer de plug-in en voer de test uit met de --with-watch keuze.

Bijwerken: :( het lijkt niet goed te werken bij tests van de manage.py-helpdesk van django-nose.

Uiteindelijk heb ik ervoor gekozen om te gebruiken tdaemon, die django ondersteunt, hoewel het misschien ook een beetje gehannes vereist voor volwaardige projecten.

Hier is bijvoorbeeld hoe ik het heb uitgevoerd voor mijn django-project:

tdaemon -t django --custom-args=a_specific_app_to_test -d --ignore-dirs logs

De --custom-args was om tests te focussen op een specifieke app (hetzelfde als je zou doen) python manage.py test a_specific_app_to_test

De -d argument is om logboekregistratie voor foutopsporing in te schakelen, die afdrukt welke bestandsverandering de run heeft geactiveerd.

De --ignore-dirs was nodig omdat mijn tests aan de logboeken schreven (wat op zichzelf een probleem is!) en tdaemon ging in een oneindige lus.


7
2018-03-05 09:05



py.test antwoord:

pip install pytest-xdist
py.test -f # will watch all subfolders for changes, and rerun the tests

5
2017-12-13 09:38



Ik deed dit met gulp. Installeer gulp-shell:

npm install gulp-shell --save-dev    

En in de gulpfile.js:

var shell = require('gulp-shell')

gulp.task('run-tests', shell.task([
   'python3 manage.py test']))

gulp.task('watch', function(){
   gulp.watch(['./your-project-name/**/*.html', './your-project-name/**/*.py'], ['run-tests']);
});

gulp.task('default',['run-tests','watch']);

En het voert de tests uit wanneer er wijzigingen zijn opgeslagen in elke .py of .html-bestanden!


1
2017-10-09 00:49



Een andere Javascript-ontwikkelaar hier, die ik heb gevonden nodemon (https://github.com/remy/nodemon) om redelijk goed te werken. Standaard kijkt het *.jsbestanden maar dat kan worden geconfigureerd met de --ext vlag. Om het te gebruiken, doe:

npm install -g nodemon
cd /your/project/dir/
nodemon --ext py --exec "python manage.py test"

Nu, wanneer een *.py bestandswijzigingen, zal het uw opdracht opnieuw uitvoeren. Het vindt zelfs nieuwe bestanden.


1
2017-11-24 04:14



Je kunt gebruiken Django Supervisor op de top van Django. Hiermee wordt het gebruik van een CI-tool vermeden (wat in elk geval nuttig kan zijn, dit maakt het andere antwoord niet ongeldig - misschien gewoon complementair).


0
2018-03-07 03:12



Ik ben gewend watchr, zoiets Watchr


0
2017-11-28 04:58



Ik zou het opzetten aanbevelen Django-nose en sniffer. Het is vrij eenvoudig in te stellen en werkt geweldig. Iets in de trant van deze scent.py was de enige maat die ik nodig had. Dan kun je gewoon rennen sniffer -x myapp.tests.

Neus wordt geleverd met een aantal andere dingen die testen een beetje leuker maken om mee te werken.


0
2018-04-29 12:52



Ik heb een Gulp-taak geschreven om automatisch te worden uitgevoerd ./manage.py test wanneer een opgegeven Python-bestand wordt gewijzigd of verwijderd. Hiervoor heb je Node nodig.

Installeer eerst Gulp:

yarn add -D gulp@next

Gebruik dan het volgende gulpfile.js en maak de nodige aanpassingen:

const { exec } = require('child_process');
const gulp = require('gulp');

const runDjangoTests = (done) => {
  const task = exec('./manage.py test --keepdb', {
    shell: '/bin/bash', // Accept SIGTERM signal. Doesn't work with /bin/sh
  });

  task.stdout.pipe(process.stdout);
  task.stderr.pipe(process.stderr);

  task.on('exit', () => {
    done();
  });

  return task;
};

gulp.task('test', runDjangoTests);

gulp.task('watch', (done) => {
  let activeTask;
  const watcher = gulp.watch('**/*.py', {
    // Ignore whatever directories you need to
    ignored: ['.venv/*', 'node_modules'],
  });

  const runTask = (message) => {
    if (activeTask) {
      activeTask.kill();
      console.log('\n');
    }

    console.log(message);
    activeTask = runDjangoTests(done);
  };

  watcher.on('change', (path) => {
    runTask(`File ${path} was changed. Running tests:`);
  });

  watcher.on('unlink', (path) => {
    runTask(`File ${path} was removed. Running tests:`);
  });
});

Ren dan gewoon node node_modules/gulp/bin/gulp.js watch om de taak uit te voeren :)


0
2017-07-20 11:36



U hebt een continue integratieserver nodig, iets als Jenkins.


-3
2018-03-01 20:44