Python get_in_memory_database Examples

Example #1

File: test_database.py Project: keredson/peewee

    def test_drop_index(self):
        db = database_initializer.get_in_memory_database()

        class IndexedModel(Model):
            idx = CharField(index=True)
            uniq = CharField(unique=True)
            f1 = IntegerField()
            f2 = IntegerField()

            class Meta:
                database = db
                indexes = (
                    (('f1', 'f2'), True),
                    (('idx', 'uniq'), False),
                )

        IndexedModel.create_table()
        indexes = db.get_indexes(IndexedModel._meta.db_table)

        self.assertEqual(sorted(idx.name for idx in indexes), [
            'indexedmodel_f1_f2',
            'indexedmodel_idx',
            'indexedmodel_idx_uniq',
            'indexedmodel_uniq'])

        with self.log_queries() as query_log:
            IndexedModel._drop_indexes()

        self.assertEqual(sorted(query_log.queries), sorted([
            ('DROP INDEX %s' % idx.name, []) for idx in indexes]))
        self.assertEqual(db.get_indexes(IndexedModel._meta.db_table), [])

Example #2

    def test_doc_example(self):
        db = database_initializer.get_in_memory_database()
        TweetDeferred = DeferredRelation()

        class Base(Model):
            class Meta:
                database = db

        class User(Base):
            username = CharField()
            favorite_tweet = ForeignKeyField(TweetDeferred, null=True)

        class Tweet(Base):
            user = ForeignKeyField(User)
            message = TextField()

        TweetDeferred.set_model(Tweet)
        with db.transaction():
            User.create_table()
            Tweet.create_table()

        # SQLite does not support alter + add constraint.
        self.assertRaises(
            OperationalError,
            lambda: db.create_foreign_key(User, User.favorite_tweet))

Example #3

    def test_drop_index(self):
        db = database_initializer.get_in_memory_database()

        class IndexedModel(Model):
            idx = CharField(index=True)
            uniq = CharField(unique=True)
            f1 = IntegerField()
            f2 = IntegerField()

            class Meta:
                database = db
                indexes = (
                    (('f1', 'f2'), True),
                    (('idx', 'uniq'), False),
                )

        IndexedModel.create_table()
        indexes = db.get_indexes(IndexedModel._meta.db_table)

        self.assertEqual(sorted(idx.name for idx in indexes), [
            'indexedmodel_f1_f2',
            'indexedmodel_idx',
            'indexedmodel_idx_uniq',
            'indexedmodel_uniq'])

        with self.log_queries() as query_log:
            IndexedModel._drop_indexes()

        self.assertEqual(sorted(query_log.queries), sorted([
            ('DROP INDEX "%s"' % idx.name, []) for idx in indexes]))
        self.assertEqual(db.get_indexes(IndexedModel._meta.db_table), [])

Example #4

File: test_sqlite_ext.py Project: PhDuc/peewee

def check_fts5():
    tmp_db = database_initializer.get_in_memory_database()
    class FTS5Test(FTS5Model):
        data = BareField(null=True)
        class Meta:
            database = tmp_db

    try:
        FTS5Test.create_table()
    except OperationalError:
        try:
            sqlite3.enable_load_extension(True)
            sqlite3.load_extension('fts5')
        except OperationalError:
            return False
    finally:
        tmp_db.close()

    return True

Example #5

File: test_sqlite_ext.py Project: PhDuc/peewee

def check_fts5():
    tmp_db = database_initializer.get_in_memory_database()

    class FTS5Test(FTS5Model):
        data = BareField(null=True)

        class Meta:
            database = tmp_db

    try:
        FTS5Test.create_table()
    except OperationalError:
        try:
            sqlite3.enable_load_extension(True)
            sqlite3.load_extension('fts5')
        except OperationalError:
            return False
    finally:
        tmp_db.close()

    return True

Example #6

File: test_keys.py Project: xr09/peewee

    def test_doc_example(self):
        db = database_initializer.get_in_memory_database()
        TweetProxy = Proxy()
        class Base(Model):
            class Meta:
                database = db
        class User(Base):
            username = CharField()
            favorite_tweet = ForeignKeyField(TweetProxy, null=True)
        class Tweet(Base):
            user = ForeignKeyField(User)
            message = TextField()
        TweetProxy.initialize(Tweet)
        with db.transaction():
            User.create_table()
            Tweet.create_table()

        # SQLite does not support alter + add constraint.
        self.assertRaises(
            OperationalError,
            lambda: db.create_foreign_key(User, User.favorite_tweet))

Example #7

File: test_keys.py Project: nad2000/peewee

    def test_composite_key_inheritance(self):
        db = database_initializer.get_in_memory_database()

        class Person(TestModel):
            first = TextField()
            last = TextField()
            class Meta:
                database = db
                primary_key = CompositeKey('first', 'last')

        class Employee(Person):
            title = TextField()

        self.assertTrue(Employee._meta.composite_key)
        primary_key = Employee._meta.primary_key
        self.assertTrue(isinstance(primary_key, CompositeKey))
        self.assertEqual(primary_key.field_names, ('first', 'last'))

        ddl, _ = compiler.create_table(Employee)
        self.assertEqual(ddl, (
            'CREATE TABLE "employee" ("first" TEXT NOT NULL, '
            '"last" TEXT NOT NULL, "title" TEXT NOT NULL, '
            'PRIMARY KEY ("first", "last"))'))

Example #8

    def test_composite_key_inheritance(self):
        db = database_initializer.get_in_memory_database()

        class Person(TestModel):
            first = TextField()
            last = TextField()

            class Meta:
                database = db
                primary_key = CompositeKey('first', 'last')

        class Employee(Person):
            title = TextField()

        self.assertTrue(Employee._meta.composite_key)
        primary_key = Employee._meta.primary_key
        self.assertTrue(isinstance(primary_key, CompositeKey))
        self.assertEqual(primary_key.field_names, ('first', 'last'))

        ddl, _ = compiler.create_table(Employee)
        self.assertEqual(ddl,
                         ('CREATE TABLE "employee" ("first" TEXT NOT NULL, '
                          '"last" TEXT NOT NULL, "title" TEXT NOT NULL, '
                          'PRIMARY KEY ("first", "last"))'))

Example #9

File: test_extra_fields.py Project: BulletSilver/peewee

except ImportError:
    AESEncryptedField = None
try:
    from playhouse.fields import PasswordField
except ImportError:
    PasswordField = None
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase
from playhouse.tests.base import skip_if
from playhouse.tests.base import ulit
from playhouse.tests.base import TestModel

PY2 = sys.version_info[0] == 2


db = database_initializer.get_in_memory_database()


class BaseModel(Model):
    class Meta:
        database = db


class CompressedModel(BaseModel):
    data = CompressedField()


class PickledModel(BaseModel):
    data = PickledField()

Example #10

from peewee import *
from peewee import Expression
from peewee import OP
from playhouse.hybrid import hybrid_method
from playhouse.hybrid import hybrid_property
from playhouse.shortcuts import *
from playhouse.test_utils import assert_query_count
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase
from playhouse.tests.base import PeeweeTestCase
from playhouse.tests.libs import mock

db = database_initializer.get_in_memory_database()


class BaseModel(Model):
    class Meta:
        database = db


class TestModel(BaseModel):
    name = CharField()
    number = IntegerField()


class Category(BaseModel):
    name = CharField()
    parent = ForeignKeyField('self', null=True, related_name='children')


class User(BaseModel):

Example #11

import datetime
import unittest

from peewee import *
from playhouse import _speedups as speedups
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase

db = database_initializer.get_in_memory_database(use_speedups=True)


class BaseModel(Model):
    class Meta:
        database = db


class Note(BaseModel):
    content = TextField()
    timestamp = DateTimeField(default=datetime.datetime.now)


class TestResultWrappers(ModelTestCase):
    requires = [Note]

    def setUp(self):
        super(TestResultWrappers, self).setUp()
        for i in range(10):
            Note.create(content='note-%s' % i)

    def test_dirty_fields(self):
        note = Note.create(content='huey')

Example #12

File: test_test_utils.py Project: 1kko/mdpdp

import functools

from peewee import *
from playhouse.test_utils import assert_query_count
from playhouse.test_utils import count_queries
from playhouse.test_utils import test_database
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase


db1 = database_initializer.get_in_memory_database()
db1._flag = 'db1'
db2 = database_initializer.get_in_memory_database()
db2._flag = 'db2'

class BaseModel(Model):
    class Meta:
        database = db1

class Data(BaseModel):
    key = CharField()

    class Meta:
        order_by = ('key',)

class DataItem(BaseModel):
    data = ForeignKeyField(Data, related_name='items')
    value = CharField()

    class Meta:
        order_by = ('value',)

Example #13

import functools

from peewee import *
from playhouse.test_utils import assert_query_count
from playhouse.test_utils import count_queries
from playhouse.test_utils import test_database
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase

db1 = database_initializer.get_in_memory_database()
db1._flag = 'db1'
db2 = database_initializer.get_in_memory_database()
db2._flag = 'db2'


class BaseModel(Model):
    class Meta:
        database = db1


class Data(BaseModel):
    key = CharField()

    class Meta:
        order_by = ('key', )


class DataItem(BaseModel):
    data = ForeignKeyField(Data, related_name='items')
    value = CharField()

Example #14

File: test_speedups.py Project: alexlatchford/peewee

import datetime
import unittest

from peewee import *
from playhouse import _speedups as speedups
from playhouse.tests.base import database_initializer
from playhouse.tests.base import ModelTestCase


db = database_initializer.get_in_memory_database(use_speedups=True)

class BaseModel(Model):
    class Meta:
        database = db

class Note(BaseModel):
    content = TextField()
    timestamp = DateTimeField(default=datetime.datetime.now)


class TestResultWrappers(ModelTestCase):
    requires = [Note]

    def setUp(self):
        super(TestResultWrappers, self).setUp()
        for i in range(10):
            Note.create(content='note-%s' % i)

    def test_dirty_fields(self):
        note = Note.create(content='huey')
        self.assertFalse(note.is_dirty())

Example #15

File: test_csv_utils.py Project: BulletSilver/peewee

 def setUp(self):
     super(TestCustomConverter, self).setUp()
     self.db = database_initializer.get_in_memory_database()

Example #16

File: test_csv_utils.py Project: sakho3600/Bibliotheque

 def setUp(self):
     super(TestCustomConverter, self).setUp()
     self.db = database_initializer.get_in_memory_database()