def start():
client = Client()
client.url = "http://84.201.129.208:8080"
# change url if need
import_id = do_send_import(client, "post")
print("import_id: ", import_id)
# todo: check in db
print()
print("all_citizens")
all_citizens = do_get_all_citizens(client, import_id, "get")
for i in all_citizens:
print(i)
print()
user_after_patched = do_patch_data(client, import_id, "patch")
print("user_after_patched")
for i in user_after_patched:
print(i)
# todo: check in db
print()
all_citizens = do_get_all_citizens(client, import_id, "get")
print("all_citizens")
for i in all_citizens:
print(i)
print()
print("presents")
presents = do_birthday_presents(client, import_id, "get")
for i in presents:
print(i, presents[i])
print()
print("stats")
stats = do_calc_stat(client, import_id, "get")
for i in stats:
print(i)
def test_field(self):
user = factories.UserFactory()
client = Client()
response = client.query(queries.ALL_USERS2)
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertIn("allUsers2", data["data"])
self.assertTrue(data["data"]["allUsers2"])
self.assertEqual(data["data"]["allUsers2"][0]["id"], str(user.id))
def test_filter_charfield_iexact(self):
user = factories.UserFactory()
query = queries.ALL_USERS3_WITH_FILTER % {
"filter": 'email_Iexact: "%s"' % user.email,
"fields": "username",
}
client = Client()
response = client.query(query)
self.assertEqual(response.status_code, 200, response.content)
data = response.json()
self.assertIn("allUsers3", data["data"])
self.assertIn("results", data["data"]["allUsers3"])
self.assertTrue(data["data"]["allUsers3"]["results"])
self.assertEqual(data["data"]["allUsers3"]["results"][0]["username"],
user.username)
class BaseTest(TestCase):
expected_status_code = 200
def login(self):
user = self.user
self.client.login(username=user.username, password='******')
def setUp(self):
self.client = Client()
self.user = UserFactory()
def try_mutate(self, query, operation_name, variables):
full_query = query % {
"name": operation_name
}
payload = query_builder(
full_query, operation_name,
variables=variables
)
response = self.client.mutate(payload)
self.assertEqual(response.status_code, 200, response.content)
self.assertEqual(response.status_code, self.expected_status_code)
return response
def test_get_books(self):
"""Test getting all books."""
resp = Client(app).get(BooksResource.path)
assert Status.good(resp)
resp = resp.json()
assert resp['limit'] == BooksResource.default_limit
assert resp['offset'] == BooksResource.default_offset
assert resp['total'] == len(self.books)
assert resp['count'] == len(self.books)
results_by_id = {i['id']: i for i in resp['items']}
for book in self.books:
res = results_by_id[book.id]
for attr in ('id', 'title', 'published'):
assert getattr(book, attr) == getattr(res, attr)
assert len(res['authors']) == len(book['authors'])
assert res['authors'][0].id == book.authors[0].id
def test_main():
client = Client()
variables = {
"file": {
"filename": "lorem1.txt",
"content": b64_lorem
},
"image": {
"filename": "fork1.jpg",
"content": b64_img
},
}
expected_response = json.loads("""
{
"data": {
"testFileCreate": {
"ok": true,
"result": {
"id": "1",
"file": {
"filename": "lorem1.txt",
"size": 2941,
"url": "/media/lorem1.txt"
},
"image": {
"url": "/media/fork1.jpg",
"size": 39116,
"filename": "fork1.jpg"
}
}
}
}
}
""")
response = client.query(QUERY, variables=variables).json()
verify_response(expected_response, response)
assert response["data"]["testFileCreate"]["result"]["file"][
"content"].startswith("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIG")
assert response["data"]["testFileCreate"]["result"]["image"][
"content"].startswith("/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAg")
def test_issue_8():
client = Client()
expected_response = {
"data": {"issue8Create": {"ok": True, "result": {"text": "test_1"}}}
}
response = client.query(gql_1).json()
verify_response(expected_response, response)
expected_response = {"data": {"issue8Create": {"ok": True}}}
response = client.query(gql_2).json()
verify_response(expected_response, response)
expected_response = {
"data": {"issue8Update": {"ok": True, "result": {"id": "1", "text": "test_1_bis1"}}}
}
response = client.query(gql_3).json()
verify_response(expected_response, response)
expected_response = {
"data": {"issue8Update": {"ok": True}}
}
response = client.query(gql_4).json()
verify_response(expected_response, response)
class ParentTest:
expected_status_code = 200
expected_return_payload = {}
@property
def query(self):
raise NotImplementedError()
def setUp(self):
self.user = factories.UserFactory()
self.client = Client()
self.response = self.client.query(self.query)
self.data = self.response.json()
def test_should_return_expected_status_code(self):
self.assertEqual(self.response.status_code, self.expected_status_code)
def test_should_return_expected_payload(self):
self.assertEqual(self.response.json(), self.expected_return_payload,
self.response.content)
MORE_BLOBS = 999
logging_log_level = logging.INFO
log_level = 'error'
if os.getenv('BLOBSTASH_DEBUG'):
logging_log_level = logging.DEBUG
log_level = 'debug'
logging.basicConfig(level=logging_log_level)
logging.info('Running integration tests...')
b = BlobStash(config='tests/blobstash.yaml')
b.cleanup()
c = Client()
logging.info('Start BlobStash')
b.run(log_level=log_level)
logging.info('[STEP 1] Testing the blob store...')
# FIXME(tsileo): only GET/POST at / and GET /{hash}
logging.info('Insert test blob')
blob = Blob.from_data(b'hello')
resp = c.put_blob(blob)
assert resp.status_code == 200, 'failed to put blob {}'.format(blob.hash)
logging.info('Fetch test blob back')
blob2 = c.get_blob(blob.hash, to_blob=True)
assert blob2.data == blob.data, 'failed to fetch blob {} != {}'.format(blob.data, blob2.data)
def setUp(self):
self.client = Client()
from blobstash.base.test_utils import BlobStash
MORE_BLOBS = 999
logging_log_level = logging.INFO
log_level = 'error'
if os.getenv('BLOBSTASH_DEBUG'):
logging_log_level = logging.DEBUG
log_level = 'debug'
logging.basicConfig(level=logging_log_level)
logging.info('Running integration tests...')
b = BlobStash(config='tests/blobstash.yaml')
b.cleanup()
c = Client()
logging.info('Start BlobStash')
b.run(log_level=log_level)
logging.info('[STEP 1] Testing the blob store...')
# FIXME(tsileo): only GET/POST at / and GET /{hash}
logging.info('Insert test blob')
blob = Blob.from_data(b'hello')
resp = c.put_blob(blob)
assert resp.status_code == 200, 'failed to put blob {}'.format(blob.hash)
logging.info('Fetch test blob back')
blob2 = c.get_blob(blob.hash, to_blob=True)
assert blob2.data == blob.data, 'failed to fetch blob {} != {}'.format(
blob.data, blob2.data)
def test_main():
client = Client()
for i in range(10):
b = TestRelayB(text=str(i))
b.save()
for j in range(10):
TestRelayA(text=str(i) + "-" + str(j), test_relay_b=b).save()
query = """
{
testRelayBs(offset: 5, first: 1) {
pageInfo {
hasNextPage
hasPreviousPage
startCursor
endCursor
}
edges {
cursor
node {
id
text
testRelayAs(offset: 5, first: 1) {
pageInfo {
hasNextPage
hasPreviousPage
startCursor
endCursor
}
edges {
cursor
node {
id
text
}
}
}
}
}
}
}
"""
expected_response = json.loads(
"""
{
"data": {
"testRelayBs": {
"pageInfo": {
"hasNextPage": true,
"hasPreviousPage": false,
"startCursor": "YXJyYXljb25uZWN0aW9uOjU=",
"endCursor": "YXJyYXljb25uZWN0aW9uOjU="
},
"edges": [
{
"cursor": "YXJyYXljb25uZWN0aW9uOjU=",
"node": {
"id": "VGVzdFJlbGF5QlR5cGU6Ng==",
"text": "5",
"testRelayAs": {
"pageInfo": {
"hasNextPage": true,
"hasPreviousPage": false,
"startCursor": "YXJyYXljb25uZWN0aW9uOjU=",
"endCursor": "YXJyYXljb25uZWN0aW9uOjU="
},
"edges": [
{
"cursor": "YXJyYXljb25uZWN0aW9uOjU=",
"node": {
"id": "VGVzdFJlbGF5QVR5cGU6NTY=",
"text": "5-5"
}
}
]
}
}
}
]
}
}
}
"""
)
response = client.query(query).json()
verify_response(expected_response, response)
b5_id = response["data"]["testRelayBs"]["edges"][0]["node"]["id"]
a5_5_id = response["data"]["testRelayBs"]["edges"][0]["node"]["testRelayAs"][
"edges"
][0]["node"]["id"]
query = """
query node ($id: ID!){
node(id:$id){
... on TestRelayAType{
id
text
testRelayB{
id
text
}
}
}
}
"""
expected_response = json.loads(
"""
{
"data": {
"node": {
"id": "VGVzdFJlbGF5QVR5cGU6NTY=",
"text": "5-5",
"testRelayB": {
"id": "VGVzdFJlbGF5QlR5cGU6Ng==",
"text": "5"
}
}
}
}
"""
)
response = client.query(query, variables={"id": a5_5_id}).json()
verify_response(expected_response, response)
query = """
mutation testRelayACreate($input: TestRelayACreateInput!){
testRelayACreate(input:$input){
ok
result{
id
text
testRelayB{
id
text
}
}
}
}
"""
variables = {"input": {"text": "11", "testRelayB": {"create": {"text": "11"}}}}
expected_response = json.loads(
"""
{
"data": {
"testRelayACreate": {
"ok": true,
"result": {
"id": "VGVzdFJlbGF5QVR5cGU6MTAx",
"text": "11",
"testRelayB": {
"id": "VGVzdFJlbGF5QlR5cGU6MTE=",
"text": "11"
}
}
}
}
}
"""
)
response = client.query(query, variables=variables).json()
verify_response(expected_response, response)
a_11_id = response["data"]["testRelayACreate"]["result"]["id"]
b_11_id = response["data"]["testRelayACreate"]["result"]["testRelayB"]["id"]
query = """
mutation testRelayAUpdate($input: TestRelayAUpdateInput!, $where: TestRelayAWhereInput!){
testRelayAUpdate(input:$input, where:$where){
ok
result{
id
text
testRelayB{
id
text
}
}
}
}
"""
variables = {
"where": {"id": {"exact": a_11_id}},
"input": {
"text": "11-bis",
},
}
expected_response = json.loads(
"""
{
"data": {
"testRelayAUpdate": {
"ok": true,
"result": {
"id": "VGVzdFJlbGF5QVR5cGU6MTAx",
"text": "11-bis",
"testRelayB": {
"id": "VGVzdFJlbGF5QlR5cGU6MTE=",
"text": "11"
}
}
}
}
}
"""
)
response = client.query(query, variables=variables).json()
verify_response(expected_response, response)
def test_main():
for i in range(10):
a = TestConnA()
a.text = str(i)
a.nb = i
a.save()
for j in range(10):
b = TestConnB()
b.text = str(j)
b.nb = j
b.test_conn_a = a
b.save()
c = TestConnC()
c.text = str(j)
c.nb = j
c.test_conn_a = a
c.save()
client = Client()
query = """
query{
testConnAs(limit:2, offset:2){
count
nbAvg
data{
id
nb
text
testConnBs(first:2, offset:2){
totalCount
nbAvg
edges{
node{
id
nb
text
}
}
}
testConnCs(limit:2, offset:2){
id
nb
text
}
}
}
}
"""
variables = {
"input": {
"text": "a1",
"testFkB": {
"create": {
"text": "b1",
"testFkC": {
"create": {
"text": "c1"
}
}
}
},
}
}
expected_response = json.loads("""
{
"data": {
"testConnAs": {
"count": 10,
"nbAvg": 4.5,
"data": [
{
"id": "3",
"nb": 2,
"text": "2",
"testConnBs": {
"totalCount": 10,
"nbAvg": 4.5,
"edges": [
{
"node": {
"id": "VGVzdENvbm5CVHlwZToyMw==",
"nb": 2,
"text": "2"
}
},
{
"node": {
"id": "VGVzdENvbm5CVHlwZToyNA==",
"nb": 3,
"text": "3"
}
}
]
},
"testConnCs": [
{
"id": "23",
"nb": 2,
"text": "2"
},
{
"id": "24",
"nb": 3,
"text": "3"
}
]
},
{
"id": "4",
"nb": 3,
"text": "3",
"testConnBs": {
"totalCount": 10,
"nbAvg": 4.5,
"edges": [
{
"node": {
"id": "VGVzdENvbm5CVHlwZTozMw==",
"nb": 2,
"text": "2"
}
},
{
"node": {
"id": "VGVzdENvbm5CVHlwZTozNA==",
"nb": 3,
"text": "3"
}
}
]
},
"testConnCs": [
{
"id": "33",
"nb": 2,
"text": "2"
},
{
"id": "34",
"nb": 3,
"text": "3"
}
]
}
]
}
}
}
""")
response = client.query(query, variables=variables).json()
verify_response(expected_response, response)
def test_relation_old():
client = Client()
variables = {
"input": {
"name": "p1",
"childs": {
"create": [{
"name": "p2"
}, {
"name": "p3"
}]
},
"father": {
"create": {
"name": "p4"
},
},
"friends": {
"create": [{
"name": "p5"
}, {
"name": "p6"
}]
},
}
}
expected_response = {
"data": {
"personCreate": {
"ok": True,
"errors": [],
"result": {
"name": "p1",
"childs": {
"data": [{
"name": "p2"
}, {
"name": "p3"
}]
},
"father": {
"name": "p4"
},
"friends": {
"data": [{
"name": "p5"
}, {
"name": "p6"
}]
},
},
}
}
}
response = client.query(MUTATION_CREATE_TEST_A, variables=variables).json()
verify_response(expected_response, response)
p1_id = response["data"]["personCreate"]["result"]["id"]
p2_id = response["data"]["personCreate"]["result"]["childs"]["data"][0][
"id"]
p3_id = response["data"]["personCreate"]["result"]["childs"]["data"][1][
"id"]
p4_id = response["data"]["personCreate"]["result"]["father"]["id"]
p5_id = response["data"]["personCreate"]["result"]["friends"]["data"][0][
"id"]
p6_id = response["data"]["personCreate"]["result"]["friends"]["data"][1][
"id"]
def setUp(self):
self.client = Client()
self.user = UserFactory()
from tests.integrations.send_import.data_generator import gen_test_import_send_request_data
from tests.client import Client
def do_send_import(client, method_type):
request_data = gen_test_import_send_request_data()
request_data = request_data[0]
res = client.do_request("/imports", request_data["request"], method_type)
if res["status"] == 201:
res = res["result"]
return res["data"]["import_id"]
if __name__ == "__main__":
client = Client()
res = do_send_import(client, "post")
print(res)
def setUp(self):
self.user = factories.UserFactory()
self.client = Client()
self.response = self.client.query(self.query)
self.data = self.response.json()
