def test_get_relations():
"""Test relations can be resolved in json-formatted collections."""
with get_fixture_uri(
('collections/artists.json', 'collections/albums.json',
'collections/tracks.json')) as (artists_uri, albums_uri, tracks_uri):
# Artists
artists = Collection(Artist,
artists_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
# Albums
albums = Collection(Album,
albums_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
albums.connect(Album.Properties.artist, artists)
# Tracks
tracks = Collection(Track,
tracks_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
tracks.connect(Track.Properties.album, albums)
tracks.connect(Track.Properties.artist, artists)
# Fetch track, and ensure relations can be resolved
assert_that(
tracks.get(Track['id'] == 1),
has_properties({
'id':
1,
'title':
'Ascension (feat. Vince Staples)',
'artist':
has_properties({
'id': 1,
'title': 'Gorillaz'
}),
'album':
has_properties({
'id':
1,
'title':
'Humanz',
'artist':
has_properties({
'id': 1,
'title': 'Gorillaz'
})
})
}))
def test_relations():
"""Test collection relations with dynamic models."""
# Artists
artists = Collection(Artist, 'memory://', plugins=[
byte.compilers.operation,
byte.executors.memory
])
# Albums
albums = Collection(Album, 'memory://', plugins=[
byte.compilers.operation,
byte.executors.memory
])
albums.connect(Album.Properties.artist, artists)
# Tracks
tracks = Collection(Track, 'memory://', plugins=[
byte.compilers.operation,
byte.executors.memory
])
tracks.connect(Track.Properties.album, albums)
tracks.connect(Track.Properties.artist, artists)
# Create objects
artists.create(
id=1,
title='Daft Punk'
)
albums.create(
id=1,
artist_id=1,
title='Discovery'
)
tracks.create(
id=1,
artist_id=1,
album_id=1,
title='One More Time'
)
# Fetch track, and ensure relations can be resolved
track = tracks.get(Track['id'] == 1)
assert track.id == 1
assert track.artist.id == 1
assert track.album.id == 1
assert track.album.artist.id == 1
def test_all():
"""Test all items are returned from json-formatted collection."""
with get_fixture_uri('collections/artists.json') as artists_uri:
artists = Collection(Artist,
artists_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
# Fetch artists, and validate properties
assert_that(
list(artists.all().iterator()),
all_of(
has_length(5),
has_items(
has_properties({
'id': 1,
'title': 'Gorillaz'
}), has_properties({
'id': 2,
'title': 'Daft Punk'
}), has_properties({
'id': 3,
'title': 'Friendly Fires'
}), has_properties({
'id': 4,
'title': 'Miike Snow'
}), has_properties({
'id': 5,
'title': 'LCD Soundsystem'
}))))
def test_multiple_legacy():
"""Test legacy insert query for multiple items is complied correctly."""
users = Collection(User, 'sqlite://:memory:?table=users')
compiler = SqliteCompiler(users.executor, version=(3, 6, 0))
statements = list(
compiler.compile(
users.insert(User['username'], User['password']).items(
{
'username': '******',
'password': '******'
}, {
'username': '******',
'password': '******'
})))
assert_that(
statements,
equal_to([
('INSERT INTO "users" ("username", "password") VALUES (?, ?);',
('one', 'alpha')),
('INSERT INTO "users" ("username", "password") VALUES (?, ?);',
('two', 'beta'))
]))
def test_simple():
"""Test items can be retrieved by primary key."""
users = Collection(User, 'apsw://:memory:?table=users', plugins=[
byte.compilers.sqlite,
byte.executors.apsw
])
# Create table, and add items directly to database
with users.executor.connection() as connection:
with connection.cursor() as cursor:
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
username VARCHAR(255),
password VARCHAR(255)
);
""")
cursor.execute("INSERT INTO users (id, username, password) VALUES (1, 'one', 'alpha');")
cursor.execute("INSERT INTO users (id, username, password) VALUES (2, 'two', 'beta');")
cursor.execute("INSERT INTO users (id, username, password) VALUES (3, 'three', 'charlie');")
# Validate items
user = users.select().where(User['id'] == 2).first()
assert_that(user, all_of(
not_none(),
has_properties({
'username': '******',
'password': '******'
})
))
def test_all():
"""Test select query can be compiled to return all items."""
users = Collection(User, 'sqlite://:memory:?table=users')
statements = list(users.executor.compiler.compile(users.all()))
assert_that(statements, equal_to([('SELECT * FROM "users";', ())]))
def test_single():
"""Test single item can be inserted into a database."""
users = Collection(User, 'pysqlite://:memory:?table=users', plugins=[
byte.compilers.sqlite,
byte.executors.pysqlite
])
# Create table
with users.executor.connection() as connection:
with connection.cursor() as cursor:
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
username VARCHAR(255),
password VARCHAR(255)
);
""")
# Insert item
users.insert().items(
{'username': '******', 'password': '******'}
).execute()
# Validate items
assert_that(list(users.all()), only_contains(
has_properties({
'username': '******',
'password': '******'
})
))
def test_and():
"""Test AND expression inside string can be compiled and executed."""
users = Collection(User,
'sqlite://:memory:?table=users',
plugins=[byte.compilers.sqlite, byte.executors.sqlite])
# Create table, and add items directly to database
with users.executor.connection() as connection:
with connection.cursor() as cursor:
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
username VARCHAR(255),
password VARCHAR(255)
);
""")
cursor.execute(
"INSERT INTO users (id, username, password) VALUES (1, 'one', 'alpha');"
)
cursor.execute(
"INSERT INTO users (id, username, password) VALUES (2, 'two', 'beta');"
)
cursor.execute(
"INSERT INTO users (id, username, password) VALUES (3, 'three', 'charlie');"
)
# Validate items
users = list(users.select().where('id > 1 and password != ?',
'charlie').execute())
assert_that(users, has_length(1))
def test_rollback():
"""Test transaction is committed correctly."""
users = Collection(User, 'pysqlite://:memory:?table=users', plugins=[
byte.compilers.sqlite,
byte.executors.pysqlite
])
# Create table
with users.executor.connection() as connection:
with connection.cursor() as cursor:
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
username VARCHAR(255),
password VARCHAR(255)
);
""")
# Insert multiple items (with conflict) inside transaction
with pytest.raises(sqlite3.IntegrityError):
with users.transaction():
users.insert().items({'id': 1, 'username': '******', 'password': '******'}).execute()
users.insert().items({'id': 2, 'username': '******', 'password': '******'}).execute()
users.insert().items({'id': 1, 'username': '******', 'password': '******'}).execute()
users.insert().items({'id': 3, 'username': '******', 'password': '******'}).execute()
# Ensure items were inserted
assert_that(list(users.all()), has_length(0))
# Validate executor state
assert_that(users.executor.transactions, has_length(0))
assert_that(users.executor.connections.active, equal_to(0))
def test_already_inside_transaction():
"""Ensure an exception is raised while attempting to create a transaction while already in a transaction."""
users = Collection(User,
'apsw://:memory:?table=users',
plugins=[byte.compilers.sqlite, byte.executors.apsw])
# Insert multiple items (with conflict) inside transaction
with pytest.raises(Exception):
with users.transaction():
with users.transaction():
pass
def test_where():
"""Test select query with where expressions can be compiled."""
users = Collection(User, 'sqlite://:memory:?table=users')
statements = list(
users.executor.compiler.compile(
users.select().where(User['id'] == 142)))
assert_that(
statements,
equal_to([('SELECT * FROM "users" WHERE "users"."id" == ?;', (142, ))
]))
def test_where():
"""Test json-formatted collections can be filtered with expressions."""
with get_fixture_uri('collections/cities.json') as cities_uri:
cities = Collection(City,
cities_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
# Fetch cities, and validate properties
items = list(
cities.select().where(City['country'] == 'New Zealand').iterator())
assert_that(
items,
all_of(
has_length(35),
has_items(
has_properties({
'id': '2179537',
'name': 'Wellington',
'country': 'New Zealand',
'subcountry': 'Wellington'
}),
has_properties({
'id': '2179670',
'name': 'Wanganui',
'country': 'New Zealand',
'subcountry': 'Manawatu-Wanganui'
}),
has_properties({
'id': '2181133',
'name': 'Timaru',
'country': 'New Zealand',
'subcountry': 'Canterbury'
}),
has_properties({
'id': '2181742',
'name': 'Taupo',
'country': 'New Zealand',
'subcountry': 'Waikato'
}),
has_properties({
'id': '2184155',
'name': 'Pukekohe East',
'country': 'New Zealand',
'subcountry': 'Auckland'
}),
)))
def test_get_basic():
"""Test items can be retrieved from json-formatted collections."""
with get_fixture_uri('collections/artists.json') as artists_uri:
artists = Collection(Artist,
artists_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
# Fetch artist, and validate properties
assert_that(artists.get(Artist['id'] == 1),
has_properties({
'id': 1,
'title': 'Gorillaz'
}))
def test_create():
"""Test items can be created on json-formatted collections."""
with get_fixture_uri('collections/artists.json') as artists_uri:
artists = Collection(Artist,
artists_uri,
plugins=[
byte.compilers.operation, byte.executors.file,
byte.formats.json
])
# Create artist
artists.create(id=123, title='Fenech-Soler')
# Fetch artist, and validate properties
assert_that(artists.get(Artist['id'] == 123),
has_properties({
'id': 123,
'title': 'Fenech-Soler'
}))
def test_all():
"""Test all items can be retrieved from database."""
users = Collection(User,
'apsw://:memory:?table=users',
plugins=[byte.compilers.sqlite, byte.executors.apsw])
# Create table, and add items directly to database
with users.executor.connection() as connection:
with connection.cursor() as cursor:
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
username VARCHAR(255),
password VARCHAR(255)
);
""")
cursor.execute(
"INSERT INTO users (username, password) VALUES ('one', 'alpha');"
)
cursor.execute(
"INSERT INTO users (username, password) VALUES ('two', 'beta');"
)
cursor.execute(
"INSERT INTO users (username, password) VALUES ('three', 'charlie');"
)
# Validate items
assert_that(
users.all(),
only_contains(
has_properties({
'username': '******',
'password': '******'
}), has_properties({
'username': '******',
'password': '******'
}), has_properties({
'username': '******',
'password': '******'
})))
def test_basic():
"""Test collection with dynamic models."""
artists = Collection(Artist, 'memory://', plugins=[
byte.compilers.operation,
byte.executors.memory
])
# Update memory collection
artists.executor.update({
1: {
'id': 1,
'title': 'Daft Punk'
}
})
# Fetch artist, and validate properties
artist = artists.get(Artist['id'] == 1)
assert artist
assert artist.id == 1
assert artist.title == 'Daft Punk'
from __future__ import absolute_import, division, print_function
from byte.collection import Collection
from byte.core.models.expressions.proxy import ProxyEqual, ProxyLessThan, ProxyNotEqual, ProxyOr
from tests.base.models.dynamic.user import User
from hamcrest import *
users = Collection(User)
def test_or():
"""Test select() query can be created with an OR operator inside a string expression."""
query = users.select().where('id < 35 or username == "alpha"')
assert_that(
query,
has_property(
'state',
has_entries({
# where()
'where':
all_of(
has_length(1),
has_items(
# id < 35 or username == "alpha"
all_of(
instance_of(ProxyOr),
has_properties({
'values':
all_of(
