def test_varargs(self):
# Works for lists too
self.assertEqual(self._q(query.add([2, 3, 5])), 10)
# Works for a variable equal to a list
self.assertEqual(
self._q(query.let({"x": [2, 3, 5]}, query.add(query.var("x")))),
10)
def test_lambda_query(self):
invalid_lambda = lambda: query.add(1, 2)
self.assertRaises(ValueError,
lambda: self._q(query.map_(query.lambda_query(invalid_lambda), [])))
expr = query.map_(query.lambda_query(lambda a: query.add(a, 1)),
[1, 2, 3])
self.assertEqual(self._q(expr), [2, 3, 4])
def test_lambda_expr(self):
self.assertJson(query.lambda_("a", query.var("a")),
'{"expr":{"var":"a"},"lambda":"a"}')
self.assertJson(
query.lambda_(["a", "b"], query.add(query.var("a"),
query.var("b"))),
'{"expr":{"add":[{"var":"a"},{"var":"b"}]},"lambda":["a","b"]}')
def test_lambda_query(self):
#pylint: disable=unnecessary-lambda
self.assertJson(query.lambda_query(lambda a: a),
'{"expr":{"var":"a"},"lambda":"a"}')
self.assertJson(
query.lambda_query(lambda a, b: query.add(a, b)),
'{"expr":{"add":[{"var":"a"},{"var":"b"}]},"lambda":["a","b"]}')
def test_count_mean_sum(self):
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
self._q(query.create_collection({"name": "countmeansum_test"}))
self._q(
query.create_index({
"name": "countmeansum_idx",
"source": query.collection("countmeansum_test"),
"active": True,
"values": [{
"field": ["data", "value"]
}]
}))
self._q(
query.foreach(
query.lambda_(
"x",
query.create(
query.collection("countmeansum_test"),
{"data": {
"value": query.add(query.var("x"), 2)
}})), data))
m = query.match(query.index("countmeansum_idx"))
expected = [9, 5.0, 45, 9, 7.0, 63]
self.assertEqual(
self._q([
query.count(data),
query.mean(data),
query.sum(data),
query.count(m),
query.mean(m),
query.sum(m)
]), expected)
def test_reduce(self):
data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
data2 = ["Fauna", "DB", " ", "rocks"]
q1 = query.reduce(query.lambda_query(lambda accum, value: query.add(query.var("accum"), query.var("value"))), 0, data1)
q2 = query.reduce(query.lambda_query(lambda accum, value: query.concat([query.var("accum"), query.var("value")])), "", data2)
self.assertEqual(self._q(q1), 45)
self.assertEqual(self._q(q2), "FaunaDB rocks")
def processMatchCounter():
resp = client.query(
q.let(
{'currVal': q.select(['data', 'data'], q.get(q.ref(q.collection('match_aggregate_info'), getIntValue('match_count'))))},
q.update(
q.ref(
q.collection('match_aggregate_info'),
getIntValue('match_count')
),
{
"data": {
"data": q.add(1, q.var('currVal'))
}
}
)
)
)
return getDataFromRef(resp)
def create_transaction(client, num_customers, max_txn_amount):
#
# This method is going to create a random transaction that moves a random amount
# from a source customer to a destination customer. Prior to committing the transaction
# a check will be performed to insure that the source customer has a sufficient balance
# to cover the amount and not go into an overdrawn state.
#
uuid = uuid4().urn[9:]
source_id = randint(1, num_customers)
dest_id = randint(1, num_customers)
while dest_id == source_id:
dest_id = randint(1, num_customers)
amount = randint(1, max_txn_amount)
transaction = {"uuid": uuid, "sourceCust": source_id, "destCust": dest_id , "amount": amount}
res = client.query(
q.let(
{"source_customer": q.get(q.match(q.index("customer_by_id"), source_id)),
"dest_customer": q.get(q.match(q.index("customer_by_id"), dest_id))},
q.let(
{"source_balance": q.select(["data", "balance"], q.var("source_customer")),
"dest_balance": q.select(["data", "balance"], q.var("dest_customer"))},
q.let(
{"new_source_balance": q.subtract(q.var("source_balance"), amount),
"new_dest_balance": q.add(q.var("dest_balance"), amount)},
q.if_(
q.gte(q.var("new_source_balance"), 0),
q.do(
q.create(q.class_("transactions"), {"data": transaction}),
q.update(q.select("ref", q.var("source_customer")),
{"data": {"txnID": uuid, "balance": q.var("new_source_balance")}}),
q.update(q.select("ref", q.var("dest_customer")),
{"data": {"txnID": uuid, "balance": q.var("new_dest_balance")}})
),
"Error. Insufficient funds."
)
)
)
)
)
def test_do(self):
self.assertJson(query.do(query.add(1, 2), query.var("x")),
'{"do":[{"add":[1,2]},{"var":"x"}]}')
self.assertJson(query.do(1), '{"do":[1]}')
self.assertJson(query.do(1, 2), '{"do":[1,2]}')
self.assertJson(query.do([1, 2]), '{"do":[[1,2]]}')
def test_add(self):
self.assertJson(query.add(1), '{"add":1}')
self.assertJson(query.add(1, 2, 3), '{"add":[1,2,3]}')
self.assertJson(query.add([1, 2, 3]), '{"add":[1,2,3]}')
def test_reduce(self):
expected = '{"collection":[1,2,3,4,5,6,7,8,9],"initial":0,"reduce":{"expr":{"add":[{"var":"accum"},{"var":"val"}]},"lambda":["accum","val"]}}'
col = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lambda_ = query.lambda_query(lambda accum, val: query.add(accum, val))
initial = 0
self.assertJson(query.reduce(lambda_, initial, col), expected)
def test_lambda_query_multiple_args(self):
#pylint: disable=unnecessary-lambda
expr = query.map_(query.lambda_query(lambda a, b: query.add(a, b)),
[[1, 1], [2, 2], [3, 3]])
self.assertEqual(self._q(expr), [2, 4, 6])
def test_add(self):
self.assertEqual(self._q(query.add(2, 3, 5)), 10)
self._assert_bad_query(query.add())
def test_query_error(self):
self._assert_query_error(add(1, "two"), BadRequest, "invalid argument",
["add", 1])
def subscribe_to_anime(self, anime_link: str):
try:
# create a new anime document
anime_info = anime_alarm.utils.GGAScraper().get_anime_info(
anime_link)
print(anime_info['anime_id'])
result = client.query(
q.let(
{
'user_anime_list':
q.select(['data', 'animes_watching'],
q.get(q.ref(q.collection(users),
self.chat_id))),
},
q.if_(
# check if this anime exists in the db
q.exists(
q.match(q.index(anime_by_id),
anime_info['anime_id'])),
# if it exists...
q.let(
{
'anime_ref':
q.select(
'ref',
q.get(
q.match(q.index(anime_by_id),
anime_info['anime_id'])))
},
q.if_(
# check if user has subscribed to this anime already
q.contains_value(q.var('anime_ref'),
q.var('user_anime_list')),
'This anime is already on your watch list!',
q.do(
q.update(
q.ref(q.collection(users),
self.chat_id),
{
'data': {
'animes_watching':
q.append(
q.var('user_anime_list'),
[q.var('anime_ref')])
}
}),
q.update(
q.var('anime_ref'), {
'data': {
'followers':
q.add(
q.select([
'data', 'followers'
], q.get(
q.var('anime_ref'))),
1)
}
}),
))),
q.let(
{'new_anime_id': q.new_id()},
q.do(
# create new anime document
q.create(
q.ref(q.collection(animes),
q.var('new_anime_id')),
{
'data': {
'title':
anime_info['title'],
'followers':
1,
'link':
anime_link,
'anime_id':
anime_info['anime_id'],
'anime_alias':
anime_info['anime_alias'],
'episodes':
anime_info['number_of_episodes'],
'last_episode': {
'link':
anime_info[
'latest_episode_link'],
'title':
anime_info[
'latest_episode_title'],
},
}
}),
# add to user's list of subscribed animes
q.update(
q.ref(q.collection(users), self.chat_id), {
'data': {
'animes_watching':
q.append(
q.var('user_anime_list'), [
q.ref(
q.collection(animes),
q.var('new_anime_id'))
])
}
}),
)))))
if isinstance(result, str):
updater.bot.send_message(chat_id=self.chat_id, text=result)
else:
updater.bot.send_message(
chat_id=self.chat_id,
text='You are now listening for updates on ' +
anime_info['title'])
except Exception as err:
log_error(err)
