class TestMSSQLQmark(unittest.TestCase):
def setUp(self):
self.builder = QueryBuilder(MSSQLGrammar, table="users")
def test_can_compile_select(self):
mark = self.builder.select("username").where("name", "Joe")
sql = "SELECT [users].[username] FROM [users] WHERE [users].[name] = '?'"
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, ["Joe"])
def test_can_compile_update(self):
mark = self.builder.update({
"name": "Bob"
}, dry=True).where("name", "Joe")
sql = "UPDATE [users] SET [users].[name] = '?' WHERE [users].[name] = '?'"
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, ["Bob", "Joe"])
def test_can_compile_insert(self):
mark = self.builder.create({"name": "Bob"}, query=True)
sql = "INSERT INTO [users] ([users].[name]) VALUES ('?')"
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, ["Bob"])
def test_can_compile_where_in(self):
mark = self.builder.where_in("id", [1, 2, 3])
sql = "SELECT * FROM [users] WHERE [users].[id] IN ('?', '?', '?')"
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, ["1", "2", "3"])
class BaseDeleteGrammarTest:
def setUp(self):
self.builder = QueryBuilder(SQLiteGrammar, table="users")
def test_can_compile_delete(self):
to_sql = self.builder.delete("id", 1, query=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_delete_in(self):
to_sql = self.builder.delete("id", [1, 2, 3], query=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_delete_with_where(self):
to_sql = (self.builder.where("age",
20).where("profile",
1).delete(query=True).to_sql())
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
class TestMSSQLUpdateGrammar(unittest.TestCase):
def setUp(self):
self.builder = QueryBuilder(MSSQLGrammar, table="users")
def test_can_compile_update(self):
to_sql = (self.builder.where("name", "bob").update({
"name": "Joe"
},
dry=True).to_sql())
sql = "UPDATE [users] SET [users].[name] = 'Joe' WHERE [users].[name] = 'bob'"
self.assertEqual(to_sql, sql)
def test_can_compile_update_with_multiple_where(self):
to_sql = (self.builder.where("name", "bob").where("age", 20).update(
{
"name": "Joe"
}, dry=True).to_sql())
sql = "UPDATE [users] SET [users].[name] = 'Joe' WHERE [users].[name] = 'bob' AND [users].[age] = '20'"
self.assertEqual(to_sql, sql)
def test_raw_expression(self):
to_sql = self.builder.update({
"name": Raw("[username]")
}, dry=True).to_sql()
sql = "UPDATE [users] SET [users].[name] = [username]"
self.assertEqual(to_sql, sql)
class BaseTestCaseUpdateGrammar:
def setUp(self):
self.builder = QueryBuilder(PostgresGrammar,
connection_class=PostgresConnection,
table="users")
def test_can_compile_update(self):
to_sql = (self.builder.where("name", "bob").update({
"name": "Joe"
},
dry=True).to_sql())
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_multiple_update(self):
to_sql = self.builder.update({
"name": "Joe",
"email": "*****@*****.**"
},
dry=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_update_with_multiple_where(self):
to_sql = (self.builder.where("name", "bob").where("age", 20).update(
{
"name": "Joe"
}, dry=True).to_sql())
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_increment(self):
to_sql = self.builder.increment("age").to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_decrement(self):
to_sql = self.builder.decrement("age", 20).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
class BaseInsertGrammarTest:
def setUp(self):
self.builder = QueryBuilder(PostgresGrammar, table="users")
def test_can_compile_insert(self):
to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_insert_with_keywords(self):
to_sql = self.builder.create(name="Joe", query=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_bulk_create(self):
to_sql = self.builder.bulk_create([{
"name": "Joe"
}, {
"name": "Bill"
}, {
"name": "John"
}],
query=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_bulk_create_qmark(self):
to_sql = self.builder.bulk_create([{
"name": "Joe"
}, {
"name": "Bill"
}, {
"name": "John"
}],
query=True).to_qmark()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
class BaseQMarkTest:
def setUp(self):
self.builder = QueryBuilder(grammar=MySQLGrammar, table="users")
def test_can_compile_select(self):
mark = self.builder.select("username").where("name", "Joe")
sql, bindings = getattr(
self, inspect.currentframe().f_code.co_name.replace("test_", "")
)()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_delete(self):
mark = self.builder.where("name", "Joe").delete(query=True)
sql, bindings = getattr(
self, inspect.currentframe().f_code.co_name.replace("test_", "")
)()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_update(self):
mark = self.builder.update({"name": "Bob"}, dry=True).where("name", "Joe")
sql, bindings = getattr(
self, inspect.currentframe().f_code.co_name.replace("test_", "")
)()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_in(self):
mark = self.builder.where_in("id", [1, 2, 3])
sql, bindings = getattr(
self, inspect.currentframe().f_code.co_name.replace("test_", "")
)()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_not_null(self):
mark = self.builder.where_not_null("id")
sql, bindings = getattr(
self, inspect.currentframe().f_code.co_name.replace("test_", "")
)()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def get_builder(self, table="users"):
connection = MockConnectionFactory().make("mssql")
return QueryBuilder(
grammar=MSSQLGrammar,
connection_class=connection,
connection="mssql",
table=table,
model=User,
)
def get_builder(self, table="users"):
connection = ConnectionFactory().make("postgres")
return QueryBuilder(
grammar=PostgresGrammar,
connection=connection,
table=table,
# model=User,
connection_details=DATABASES,
).on("postgres")
def get_builder(self, table="users"):
connection = ConnectionFactory().make("sqlite")
return QueryBuilder(
grammar=SQLiteGrammar,
connection="dev",
table=table,
model=User,
connection_details=DATABASES,
).on("dev")
def get_builder(self, table="users"):
connection = MockConnectionFactory().make("default")
return QueryBuilder(
grammar=MySQLGrammar,
connection_class=connection,
connection="mysql",
table=table,
connection_details=DATABASES,
)
class TestMySQLDeleteGrammar(unittest.TestCase):
def setUp(self):
self.builder = QueryBuilder(MSSQLGrammar, table="users")
def test_can_compile_delete(self):
to_sql = self.builder.delete("id", 1, query=True).to_sql()
sql = "DELETE FROM [users] WHERE [users].[id] = '1'"
self.assertEqual(to_sql, sql)
def test_can_compile_delete_with_where(self):
to_sql = (self.builder.where("age", 20).where(
"profile", 1).set_action("delete").delete(query=True).to_sql())
sql = (
"DELETE FROM [users] WHERE [users].[age] = '20' AND [users].[profile] = '1'"
)
self.assertEqual(to_sql, sql)
def get_builder(self, table="users"):
connection = MockConnectionFactory().make("sqlite")
return QueryBuilder(
self.grammar,
connection_class=connection,
connection="mysql",
table=table,
dry=True,
)
def get_builder(self, table="users"):
connection = MockConnectionFactory().make("postgres")
return QueryBuilder(
self.grammar,
connection_class=connection,
connection="postgres",
table=table,
model=Model(),
)
class TestMySQLInsertGrammar(unittest.TestCase):
def setUp(self):
self.builder = QueryBuilder(MSSQLGrammar, table="users")
def test_can_compile_insert(self):
to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql()
sql = "INSERT INTO [users] ([users].[name]) VALUES ('Joe')"
self.assertEqual(to_sql, sql)
def get_builder(self, table="users", dry=True):
connection = MockConnectionFactory().make("mssql")
return QueryBuilder(
# self.grammar,
connection_class=connection,
connection="mssql",
table=table,
model=ModelTest(),
dry=dry,
)
def test_builder_alone(self):
self.assertTrue(
QueryBuilder(
connection_details={
"default": "sqlite",
"sqlite": {
"driver": "sqlite",
"database": "orm.sqlite3",
"prefix": "",
},
}).table("users"))
def get_builder(self, table="users", dry=True):
connection = MockConnectionFactory().make("default")
return QueryBuilder(
grammar=self.grammar,
connection_class=connection,
connection="mysql",
table=table,
model=User(),
dry=dry,
connection_details=DATABASES,
)
def test_builder_alone(self):
self.assertTrue(
QueryBuilder(
connection_class=MockConnection,
connection="postgres",
connection_details={
"default": "postgres",
"postgres": {
"driver": "postgres",
"host": "localhost",
"user": "******",
"password": "******",
"database": "orm",
"port": "5432",
"prefix": "",
"grammar": "postgres",
},
},
).table("users"))
def test_builder_alone(self):
self.assertTrue(
QueryBuilder(
dry=True,
connection_details={
"default": "mysql",
"mysql": {
"driver": "mysql",
"host": "localhost",
"username": "******",
"password": "",
"database": "orm",
"port": "3306",
"prefix": "",
"grammar": "mysql",
"options": {
"charset": "utf8mb4"
},
},
},
).table("users"))
def setUp(self):
self.builder = QueryBuilder(PostgresGrammar, table="users")
def setUp(self):
self.builder = QueryBuilder(grammar=MySQLGrammar, table="users")
def setUp(self):
self.builder = QueryBuilder(PostgresGrammar,
connection_class=PostgresConnection,
table="users")
def get_builder(self, table="users"):
connection = ConnectionFactory().make("mysql")
return QueryBuilder(grammar=MySQLGrammar,
connection=connection,
table=table).on("mysql")
def get_builder(self, table="users"):
connection = MockConnectionFactory().make("sqlite")
return QueryBuilder(grammar=SQLiteGrammar,
connection_class=connection,
table=table,
model=User)
def test_not_between_persisted(self):
builder = QueryBuilder().table("users").on("dev")
users = builder.where_not_null("id").not_between("age", 1, 2).count()
self.assertEqual(users, 0)
class BaseQMarkTest:
def setUp(self):
self.builder = QueryBuilder(grammar=MySQLGrammar, table="users")
def test_can_compile_select(self):
mark = self.builder.select("username").where("name", "Joe")
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_delete(self):
mark = self.builder.where("name", "Joe").delete(query=True)
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_update(self):
mark = self.builder.update({
"name": "Bob"
}, dry=True).where("name", "Joe")
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_in(self):
mark = self.builder.where_in("id", [1, 2, 3])
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_not_null(self):
mark = self.builder.where_not_null("id")
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, [])
def test_can_compile_where_with_falsy_values(self):
mark = self.builder.where("name", 0)
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_with_true_value(self):
mark = self.builder.where("is_admin", True)
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_where_with_false_value(self):
mark = self.builder.where("is_admin", False)
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def test_can_compile_sub_group_bindings(self):
mark = self.builder.where(lambda query: (query.where(
"challenger", 1).or_where("proposer", 1).or_where("referee", 1)))
sql, bindings = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(mark.to_qmark(), sql)
self.assertEqual(mark._bindings, bindings)
def setUp(self):
self.builder = QueryBuilder(SQLiteGrammar, table="users")
class BaseTestCaseUpdateGrammar:
def setUp(self):
self.builder = QueryBuilder(SQLiteGrammar, table="users")
def test_can_compile_update(self):
to_sql = (self.builder.where("name", "bob").update({
"name": "Joe"
},
dry=True).to_sql())
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_multiple_update(self):
to_sql = self.builder.update({
"name": "Joe",
"email": "*****@*****.**"
},
dry=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
def test_can_compile_update_with_multiple_where(self):
to_sql = (self.builder.where("name", "bob").where("age", 20).update(
{
"name": "Joe"
}, dry=True).to_sql())
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
# def test_can_compile_increment(self):
# to_sql = self.builder.increment("age")
# print(to_sql)
# self.assertTrue(to_sql.isnumeric())
# def test_can_compile_decrement(self):
# to_sql = self.builder.decrement("age", 20).to_sql()
# sql = getattr(
# self, inspect.currentframe().f_code.co_name.replace("test_", "")
# )()
# self.assertEqual(to_sql, sql)
def test_raw_expression(self):
to_sql = self.builder.update({
"name": Raw('"username"')
}, dry=True).to_sql()
sql = getattr(
self,
inspect.currentframe().f_code.co_name.replace("test_", ""))()
self.assertEqual(to_sql, sql)
