van.pg

van.pg è un modulo Python che fornisce un facile creazione di database PostgreSQL (e cluster) per unit testing.
sporchi Database
Database di test impiegano molto tempo per creare. In generale, è necessario essere un po 'attenti quando si decide di cancellare / ricreare un dispositivo database di test.
Inoltre, sembra che ci sia alcun modo robusto in PostgreSQL di capire se un database è stato commesso o no.
Così van.pg ha altra scelta che mettere la responsabilità da voi per notificare quando un database è sporco. Se questo non viene effettuato correttamente, l'isolamento di prova sarà compromessa. Non è l'ideale, ma il meglio che possiamo fare.
L'unica eccezione è se si utilizza sempre il pacchetto di transazione (http://pypi.python.org/pypi/transaction) per la gestione del database impegna. In questo caso è possibile richiedere la risorsa da sporcato ogni volta che una transazione è impegnata.
Integrazione con testresources
Il modo tipico di utilizzare questi apparecchi è via testresources (http://pypi.python.org/pypi/testresources/):
& Nbsp; >>> da testresources import ResourcedTestCase
& Nbsp; >>> da van.pg DatabaseManager import
& Nbsp; >>> psycopg2 import
& Nbsp; >>> def init_db (db):
& Nbsp; ... conn = psycopg2.connect (host = db.host, database = db.database)
& Nbsp; ... cur = conn.cursor ()
& Nbsp; ... cur.execute ("CREATE TABLE foo (bar INTEGER);")
& Nbsp; ... conn.commit ()
& Nbsp; ... conn.Close ()
& Nbsp; >>> classe MyTest (ResourcedTestCase):
& Nbsp; ...
& Nbsp; ... Risorse = [('db', DatabaseManager (initialize_sql = init_db))]
& Nbsp; ...
& Nbsp; ... def runTest (self):
& Nbsp; ... conn = psycopg2.connect (host = self.db.host, database = self.db.database)
& Nbsp; ... cur = conn.cursor ()
& Nbsp; ... cur.execute ("INSERT INTO VALORI foo (1);")
& Nbsp; ... conn.commit ()
& Nbsp; ... cur = conn.cursor ()
& Nbsp; ... cur.execute ("SELECT * FROM foo")
& Nbsp; ... self.assertEquals (cur.fetchall (), [(1,)])
& Nbsp; ... # NOTA: deve chiudere le connessioni o cadere database fallisce
& Nbsp; ... conn.Close ()
& Nbsp; ... self.db.dirtied () # abbiamo cambiato la DB, quindi ha bisogno di ri-caricamento
In realtà eseguire il test:
& Nbsp; >>> da unittest TextTestRunner import
& Nbsp; >>> import sys
& Nbsp; >>> corridore = TextTestRunner (flusso = sys.stdout)
& Nbsp; >>> runner.run (MyTest ()) # doctest: + ELLIPSIS
& Nbsp ;.
& Nbsp; ...
& Nbsp; OK
& Nbsp; ...
Database Utilizzo dei modelli
Se avete bisogno di ricreare lo stesso database molte volte, può essere più veloce di lasciare PostgreSQL copiare il database da un database di template. È possibile farlo avendo un DatabaseManager servire come modello per un altro:
& Nbsp; >>> template_db = DatabaseManager (initialize_sql = init_db)
& Nbsp; >>> classe MyTest2 (MyTest):
& Nbsp; ... Risorse = [('db', DatabaseManager (template = template_db))]
& Nbsp; >>> runner.run (MyTest2 ()) # doctest: + ELLIPSIS
& Nbsp ;.
& Nbsp; ...
& Nbsp; OK
& Nbsp; ...
integrazione transazione
Se la parola chiave argumen dirty_on_commit è True, un DatabaseManager segnerà il database come sporcato dopo ogni successo commit effettuate tramite il modulo di transazione. Ciò significa che ogni prova che sporca il database non deve informare manualmente.
& Nbsp; >>> uomo = DatabaseManager (dirty_on_commit = True)
Se si utilizza questa funzione, è necessario dipendere dalla transazione (http://pypi.python.org/pypi/transaction) pacchetto voi stessi.
Utilizzo di un database esistente
Per impostazione predefinita, van.pg crea un nuovo cluster di PostgreSQL in una cartella temporanea e lancia un demone PostgreSQL. Questo funziona la maggior parte del tempo, ma non è molto veloce.
Se si dispone di un cluster PostgreSQL già in esecuzione, si può dire van.pg di usarlo impostando la variabile d'ambiente VAN_PG_HOST. Ad esempio, per eseguire i test di van.pg contro un server PostgreSQL locale con la sua prese in / tmp / pgCluster fare:
VAN_PG_HOST = / tmp / python pgCluster prova setup.py
ATTENZIONE: i database a partire con TEST_DB nel database di destinazione sono suscettibili di essere caduto.
Connessioni di chiusura
Fare attenzione a chiudere bene tutte le connessioni al database una volta che il test viene fatto con esso. PostgreSQL non consente cadere database mentre ci sono connessioni aperte. Questo farà sì che van.pg all'errore quando si cerca di eliminare il database di prova.
Programatically creazione di un cluster
Ad un livello più basso, è possibile anche a livello di programmazione di manipolare il proprio cluster di PostgreSQL.
Inizializzazione del cluster:
& Nbsp; >>> da van.pg Cluster import
& Nbsp; >>> gruppo = Cluster ()
& Nbsp; >>> cluster.initdb ()
Che crea un database in una directory temporanea:
& Nbsp; >>> os import
& Nbsp; >>> DBDIR = cluster.dbdir
& Nbsp; >>> 'PG_VERSION' in os.listdir (DBDIR)
& Nbsp; La vera
Inizio esso:
& Nbsp; >>> cluster.start ()
Creare / Test di una base di dati:
& Nbsp; >>> dbname = cluster.createdb ()
Possiamo connettersi al database:
& Nbsp; >>> psycopg2 import
& Nbsp; >>> conn = psycopg2.connect (database = dbname, host = cluster.dbdir)
& Nbsp; >>> cur = conn.cursor ()
Twiddle il database per assicurarsi che possiamo fare i principi fondamentali:
& Nbsp; >>> cur.execute ("CREATE TABLE x (y int)")
& Nbsp; >>> cur.execute ("INSERT INTO x VALORI (1)")
& Nbsp; >>> conn.commit ()
& Nbsp; >>> cur.execute ("SELECT * from x")
& Nbsp; >>> cur.fetchall () [0] [0]
& Nbsp; 1
Arrestare il daemon cluster:
& Nbsp; >>> conn.Close ()
& Nbsp; >>> cluster.stop ()
Inizia di nuovo:
& Nbsp; >>> cluster.start ()
& Nbsp; >>> conn = psycopg2.connect (database = dbname, host = cluster.dbdir)
& Nbsp; >>> cur = conn.cursor ()
& Nbsp; >>> cur.execute ("SELECT * from x")
& Nbsp; >>> cur.fetchall () [0] [0]
& Nbsp; 1
E cleanup:
& Nbsp; >>> conn.Close ()
& Nbsp; >>> cluster.cleanup ()
& Nbsp; >>> cluster.dbdir è None
& Nbsp; La vera
& Nbsp; >>> os.path.exists (DBDIR)
& Nbsp; False
sviluppo
Sviluppo avviene su GitHub:
& Nbsp; http: //github.com/jinty/van.pg

Cosa c'è di nuovo in questa versione:

• Supporto Python 3.2.
• Goccia Python 2.5 il supporto.
• Aggiungi tox.ini per le prove contro di più versioni di Python.
• Esegui PostgreSQL come un sottoprocesso, piuttosto che come un demone (via pg_ctl).
• Re-organizzare il codice per migliorare il riutilizzo e la copertura di prova.

Requisiti :

• Python