def test_update_layout(self):
ks = pykintone.load(envs.FILE_PATH)
form_api = ks.app(self.TEST_APP.app_id).administration().form()
f1 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "title", "title")
f2 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "description", "description")
fields = [f1, f2]
# add fields
add_result = form_api.add(fields)
self.assertTrue(add_result.ok)
# create layout
layout = Layout.create(fields)
form_api.update_layout(layout)
v_def = form_api.get_layout(preview=True)
self.assertTrue(1, len(v_def.layouts))
# update layout
size = 200
layout.fields[0].width = size
form_api.update_layout(layout)
updated = form_api.get_layout(preview=True).layouts[0]
lf = [f for f in updated.fields if f.code == layout.fields[0].code][0]
self.assertTrue(size, lf.size.width)
def getRecords(self):
app = pykintone.load(envs.FILE_ACCOUNT).app()
resp = app.select(ds['app']['query'])
if not resp.ok:
print(resp.error)
return resp.records
def test_models(self):
app = pykintone.load(envs.FILE_PATH).app()
keyword = "models_test"
select_models = lambda : app.select("stringField = \"{0}\"".format(keyword)).models(TestAppModel)
# initialize model
ms = []
for i in range(2):
m = TestAppModel()
m.my_key = "model_test_{0}".format(i)
m.stringField = keyword
m.numberField = i
ms.append(m)
# create model
result = app.batch_create(ms)
self.assertTrue(result.ok)
# get model
createds = select_models()
# update model
for i, m in enumerate(createds):
m.numberField = i + 1
app.batch_update(createds)
updateds = select_models()
for i, m in enumerate(createds):
self.assertEqual(i + 1, m.numberField)
# delete model
app.delete(updateds)
deleted = select_models()
self.assertEqual(0, len(deleted))
def test_model(self):
app = pykintone.load(envs.FILE_PATH).app()
# initialize model
model = TestAppModel()
model.my_key = "model_test"
model.stringField = "model_test"
model.numberField = 1
model.radio = "radio1"
model.checkbox = ["check2"]
model.changeLogs.append(History("initialized"))
# create model
result = app.create(model)
self.assertTrue(result.ok)
# get model
created = app.get(result.record_id).model(TestAppModel)
# update model
created.stringField = "model_updated"
created.changeLogs[0].historyDesc = "updated"
created.changeLogs.append(History("added"))
app.update(created)
updated = app.get(result.record_id).model(TestAppModel)
self.assertEqual(created.stringField, updated.stringField)
self.assertEqual(2, len(updated.changeLogs))
for i, c in enumerate(created.changeLogs):
self.assertEqual(c.historyDesc, updated.changeLogs[i].historyDesc)
# delete model
app.delete(updated)
deleted = app.get(result.record_id).model(TestAppModel)
self.assertFalse(deleted)
def test_uesrs(self):
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
self.assertTrue(len(users) > 0)
for u in users:
self.assertTrue(u.name)
def setUpClass(cls):
account = pykintone.load(envs.FILE_PATH).account
admin = Administrator(account)
cls.TEST_APP = admin.create_application("test view edit")
fields = cls._default_form()
add_result = admin.form().add(fields, app_id=cls.TEST_APP.app_id)
def test_update_layout(self):
ks = pykintone.load(envs.FILE_PATH)
form_api = ks.app(self.TEST_APP.app_id).administration().form()
f1 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "title", "title")
f2 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "description",
"description")
fields = [f1, f2]
# add fields
add_result = form_api.add(fields)
self.assertTrue(add_result.ok)
# create layout
layout = Layout.create(fields)
form_api.update_layout(layout)
v_def = form_api.get_layout(preview=True)
self.assertTrue(1, len(v_def.layouts))
# update layout
size = 200
layout.fields[0].width = size
form_api.update_layout(layout)
updated = form_api.get_layout(preview=True).layouts[0]
lf = [f for f in updated.fields if f.code == layout.fields[0].code][0]
self.assertTrue(size, lf.size.width)
def test_models(self):
app = pykintone.load(envs.FILE_PATH).app()
keyword = "models_test"
select_models = lambda: app.select("stringField = \"{0}\"".format(
keyword)).models(TestAppModel)
# initialize model
ms = []
for i in range(2):
m = TestAppModel()
m.my_key = "model_test_{0}".format(i)
m.stringField = keyword
m.numberField = i
ms.append(m)
# create model
result = app.batch_create(ms)
self.assertTrue(result.ok)
# get model
createds = select_models()
# update model
for i, m in enumerate(createds):
m.numberField = i + 1
app.batch_update(createds)
updateds = select_models()
for i, m in enumerate(createds):
self.assertEqual(i + 1, m.numberField)
# delete model
app.delete(updateds)
deleted = select_models()
self.assertEqual(0, len(deleted))
def test_comment(self):
app = pykintone.load(envs.FILE_PATH).app()
model = TestAppModelSimple()
model.my_key = "comment_test"
model.stringField = "comment_test_now"
result = app.create(model)
self.assertTrue(result.ok) # confirm create the record to test comment
_record_id = result.record_id
# create comment
r_created = app.comment(_record_id).create("コメントのテスト")
self.assertTrue(r_created.ok)
# it requires Administrator user is registered in kintone
r_created_m = app.comment(_record_id).create(
"メンションのテスト", [("Administrator", "USER")])
self.assertTrue(r_created_m.ok)
# select comment
r_selected = app.comment(_record_id).select(True, 0, 10)
self.assertTrue(r_selected.ok)
self.assertTrue(2, len(r_selected.raw_comments))
comments = r_selected.comments()
self.assertTrue(1, len(comments[-1].mentions))
# delete comment
for c in comments:
r_deleted = app.comment(_record_id).delete(c.comment_id)
self.assertTrue(r_deleted.ok)
r_selected = app.comment(_record_id).select()
self.assertEqual(0, len(r_selected.raw_comments))
# done test
app.delete(_record_id)
def test_copy_application(self):
kintone = pykintone.load(envs.FILE_PATH)
app = kintone.app()
with kintone.administration().transaction().as_test_mode() as admin:
created = admin.copy_application("copied application", app.app_id)
self.assertTrue(created.ok)
def test_single(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {"my_key": {"value": "test0"}, "radio": {"value": "radio1"}}
# create
result = app.create(record)
self.assertTrue(result.ok)
record_id = result.record_id
first_revision = result.revision
created = app.get(record_id)
self.assertTrue(created.ok)
# update
update = {
"$id": {
"value": record_id
},
"$revision": {
"value": result.revision
},
"radio": {
"value": "radio2"
}
}
result = app.update(update)
self.assertTrue(result.ok)
self.assertTrue(first_revision < result.revision)
updated = app.get(record_id).record
self.assertTrue("redio2", updated["radio"]["value"])
# delete
result = app.delete(record_id)
self.assertTrue(result.ok)
def test_create_rollback_application(self):
kintone = pykintone.load(envs.FILE_PATH)
with kintone.administration().transaction().as_test_mode() as admin:
created = admin.create_application("test_create_application")
admin.revision = created.revision
self.assertTrue(created.ok)
def test_uesrs(self):
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
self.assertTrue(len(users) > 0)
for u in users:
self.assertTrue(u.name)
def test_comment(self):
app = pykintone.load(envs.FILE_PATH).app()
model = TestAppModelSimple()
model.my_key = "comment_test"
model.stringField = "comment_test_now"
result = app.create(model)
self.assertTrue(result.ok) # confirm create the record to test comment
_record_id = result.record_id
# create comment
r_created = app.comment(_record_id).create("コメントのテスト")
self.assertTrue(r_created.ok)
# it requires Administrator user is registered in kintone
r_created_m = app.comment(_record_id).create("メンションのテスト", [("Administrator", "USER")])
self.assertTrue(r_created_m.ok)
# select comment
r_selected = app.comment(_record_id).select(True, 0, 10)
self.assertTrue(r_selected.ok)
self.assertTrue(2, len(r_selected.raw_comments))
comments = r_selected.comments()
self.assertTrue(1, len(comments[-1].mentions))
# delete comment
for c in comments:
r_deleted = app.comment(_record_id).delete(c.comment_id)
self.assertTrue(r_deleted.ok)
r_selected = app.comment(_record_id).select()
self.assertEqual(0, len(r_selected.raw_comments))
# done test
app.delete(_record_id)
def test_model(self):
app = pykintone.load(envs.FILE_PATH).app()
# initialize model
model = TestAppModel()
model.my_key = "model_test"
model.stringField = "model_test"
model.numberField = 1
model.radio = "radio1"
model.checkbox = ["check2"]
model.changeLogs.append(History("initialized"))
# create model
result = app.create(model)
self.assertTrue(result.ok)
# get model
created = app.get(result.record_id).model(TestAppModel)
# update model
created.stringField = "model_updated"
created.changeLogs[0].historyDesc = "updated"
created.changeLogs.append(History("added"))
app.update(created)
updated = app.get(result.record_id).model(TestAppModel)
self.assertEqual(created.stringField, updated.stringField)
self.assertEqual(2, len(updated.changeLogs))
for i, c in enumerate(created.changeLogs):
self.assertEqual(c.historyDesc, updated.changeLogs[i].historyDesc)
# delete model
app.delete(updated)
deleted = app.get(result.record_id).model(TestAppModel)
self.assertFalse(deleted)
def test_user_organization_titles(self):
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
tested = False
for u in users[:5]:
code = u.code
ots_result = export_api.get_user_organization_titles(code)
self.assertTrue(ots_result.ok)
ots = ots_result.organization_titles
if len(ots) > 0:
tested = True
for ot in ots:
self.assertTrue(ot.organization.code)
if ot.title is None:
print(
"ot.title is None. Please set a job title to the user {} for stricter test."
.format(code))
else:
self.assertTrue(ot.title.code)
if not tested:
print(
"Caution, organization and title deserialization is not checked. Please make user who belongs to some organization."
)
def tearDownClass(cls):
account = pykintone.load(envs.FILE_PATH).account
admin = Administrator(account)
rollbacked = admin.rollback_settings(cls.TEST_APP.app_id)
cls.TEST_APP = None
print(
"You have to delete the application from the application administration view."
)
def test_get_application_informations(self):
app = pykintone.load(envs.FILE_PATH).app()
ai = app.administration().select_app_info(name="pykintone").infos
self.assertTrue(ai)
app_id = ai[0].app_id
ai = app.administration().select_app_info(app_ids=[app_id]).infos
self.assertTrue(ai)
def test_error(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {"radio": {"value": "xxxxx"}}
# create (will be error)
result = app.create(record)
self.assertFalse(result.ok)
def test_options(self):
app = pykintone.load(envs.FILE_PATH).app()
app.requests_opstions = {
"verify": True
}
result = app.select()
self.assertTrue(result.ok)
self.assertTrue(len(result.records) > 0)
def create_card(comment, entities, file_path, submitter, conf_path):
app = pykintone.load(conf_path).app()
name, company, location = entities['PERSON'], entities[
'ORGANIZATION'], entities['LOCATION']
card = BusinessCard(app, name, company, location, comment, submitter,
file_path)
result = app.create(card)
return result
def test_select(self):
app = pykintone.load(envs.FILE_PATH).app()
result = app.select()
self.assertTrue(result.ok)
self.assertTrue(len(result.records) > 0)
record_id = result.records[0]["$id"]["value"]
result = app.get(record_id)
self.assertTrue(result.ok)
print(result.record)
def test_select(self):
app = pykintone.load(envs.FILE_PATH).app()
result = app.select()
self.assertTrue(result.ok)
self.assertTrue(len(result.records) > 0)
record_id = result.records[0]["$id"]["value"]
result = app.get(record_id)
self.assertTrue(result.ok)
print(result.record)
def test_error(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {
"radio": {
"value": "xxxxx"
}
}
# create (will be error)
result = app.create(record)
self.assertFalse(result.ok)
def test_api_interface(self):
# load from file
kintone = pykintone.load(envs.FILE_PATH)
app = kintone.app()
self.assertTrue(app)
# login
app = pykintone.login("domain", "user_id", "password").app(1, api_token="token")
self.assertTrue(app)
# app
app = pykintone.app("domain", 1, "token")
self.assertTrue(app)
def test_user_select(self):
app = pykintone.load(envs.FILE_PATH).app()
model = TestAppModel()
model.my_key = "user_select_field_check"
result = app.create(model)
self.assertTrue(result.ok)
created = app.get(result.record_id).model(TestAppModel)
created.user_select = sf.UserSelect(created.creator.code)
result = app.update(created)
self.assertTrue(result.ok)
app.delete([created])
def test_user_select(self):
app = pykintone.load(envs.FILE_PATH).app()
model = TestAppModel()
model.my_key = "user_select_field_check"
result = app.create(model)
self.assertTrue(result.ok)
created = app.get(result.record_id).model(TestAppModel)
created.user_select = sf.UserSelect(created.creator.code)
result = app.update(created)
self.assertTrue(result.ok)
app.delete([created])
def test_process(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {"my_key": {"value": "test_process"}}
for c in ("single", "multiple"):
created_id = app.create(record).record_id
created = app.get(created_id).record
if c == "single":
proceeded = app.proceed(created, "処理開始")
else:
proceeded = app.batch_proceed([created], "処理開始")
app.delete(created_id) # delete record
self.assertTrue(proceeded.ok)
def test_update_general_settings(self):
account = pykintone.load(envs.FILE_PATH).account
with Administrator(account).as_test_mode() as admin:
created = admin.create_application("test_create_application")
self.assertTrue(created.ok)
g = admin.general_settings()
s = g.get(preview=True).settings
s.description = "test edit description"
result = g.update(s)
self.assertTrue(result.revision)
after_updated = g.get(preview=True).settings
self.assertEquals(s.description, after_updated.description)
def appDataget(self):
# 受け取った引数でAPP接続先を変える
fileName = self.appName + '_account.yml'
try:
account = pykintone.load(fileName)
app = account.app()
result = app.select("flag = 0").records
return result
except Exception:
texta = "{}:アプリデータ取得に失敗\n"
dt = datetime.datetime.now()
with open("log.txt", "a") as fileobj:
text = texta.format(dt)
fileobj.write(text)
def test_create_application(self):
kintone = pykintone.load(envs.FILE_PATH)
with kintone.administration().transaction() as admin:
# create application
created = admin.create_application("my_application")
# create form
f1 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "title", "Title")
f2 = ff.BaseFormField.create("MULTI_LINE_TEXT", "description", "Desc")
admin.form().add([f1, f2])
# create view
view = View.create("mylist", ["title", "description"])
admin.view().update(view)
def test_get_layout(self):
app = pykintone.load(envs.FILE_PATH).app()
fl = app.administration().form().get_layout()
self.assertTrue(fl.ok)
# deserialize check
layouts = fl.layouts
self.assertTrue(len(layouts) > 0)
self.assertTrue(len(layouts[0].fields) > 0)
for lf in layouts[0].fields:
self.assertTrue(isinstance(lf, LayoutField))
self.assertTrue(isinstance(lf.size, LayoutFieldSize))
# serialize check
serialized = layouts[0].serialize()
self.assertTrue(fl.raw[0], serialized)
def test_uesr_groups(self):
from datetime import datetime
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
tested = False
for u in users[:5]:
code = u.code
groups_result = export_api.get_user_groups(code)
self.assertTrue(groups_result.ok)
if len(groups_result.groups) > 0:
tested = True
for g in groups_result.groups:
self.assertTrue(g.name)
if not tested:
print("Caution, gruop deserialization is not checked. Please make user who belongs to some group.")
def test_file(self):
import os
app = pykintone.load(envs.FILE_PATH).app()
file_path = os.path.join(os.path.dirname(__file__), "./kintone.PNG")
model = TestAppModel()
model.my_key = "file_field_check"
model.attachfile = sf.File.upload(file_path, app)
self.assertTrue(model.attachfile)
result = app.create(model)
self.assertTrue(result.ok)
created = app.get(result.record_id).model(TestAppModel)
file = created.attachfile.download(app)
self.assertTrue(file)
app.delete([created])
def test_get_layout(self):
app = pykintone.load(envs.FILE_PATH).app()
fl = app.administration().form().get_layout()
self.assertTrue(fl.ok)
# deserialize check
layouts = fl.layouts
self.assertTrue(len(layouts) > 0)
self.assertTrue(len(layouts[0].fields) > 0)
for lf in layouts[0].fields:
self.assertTrue(isinstance(lf, LayoutField))
self.assertTrue(isinstance(lf.size, LayoutFieldSize))
# serialize check
serialized = layouts[0].serialize()
self.assertTrue(fl.raw[0], serialized)
def test_file(self):
import os
app = pykintone.load(envs.FILE_PATH).app()
file_path = os.path.join(os.path.dirname(__file__), "./kintone.PNG")
model = TestAppModel()
model.my_key = "file_field_check"
model.attachfile = sf.File.upload(file_path, app)
self.assertTrue(model.attachfile)
result = app.create(model)
self.assertTrue(result.ok)
created = app.get(result.record_id).model(TestAppModel)
file = created.attachfile.download(app)
self.assertTrue(file)
app.delete([created])
def insertOrderManagementAPP(self):
print(appDataList[0])
account = pykintone.load("test.yml")
app = account.app()
record = Kintone()
record.channel = "test6"
record.customer = "test7"
try:
app.create(record)
except Exception:
texta = "{}:受注管理表の更新に失敗\n"
dt = datetime.datetime.now()
with open("log.txt", "a") as fileobj:
text = texta.format(dt)
fileobj.write(text)
def test_process(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {
"my_key": {
"value": "test_process"
}
}
for c in ("single", "multiple"):
created_id = app.create(record).record_id
created = app.get(created_id).record
if c == "single":
proceeded = app.proceed(created, "処理開始")
else:
proceeded = app.batch_proceed([created], "処理開始")
app.delete(created_id) # delete record
self.assertTrue(proceeded.ok)
def test_uesr_groups(self):
from datetime import datetime
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
tested = False
for u in users[:5]:
code = u.code
groups_result = export_api.get_user_groups(code)
self.assertTrue(groups_result.ok)
if len(groups_result.groups) > 0:
tested = True
for g in groups_result.groups:
self.assertTrue(g.name)
if not tested:
print(
"Caution, gruop deserialization is not checked. Please make user who belongs to some group."
)
def test_user_organization_titles(self):
export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting
users = export_api.get_users().users
tested = False
for u in users[:5]:
code = u.code
ots_result = export_api.get_user_organization_titles(code)
self.assertTrue(ots_result.ok)
ots = ots_result.organization_titles
if len(ots) > 0:
tested = True
for ot in ots:
self.assertTrue(ot.organization.code)
self.assertTrue(ot.title.code)
if not tested:
print("Caution, organization and title deserialization is not checked. Please make user who belongs to some organization.")
def test_single(self):
app = pykintone.load(envs.FILE_PATH).app()
record = {
"my_key": {
"value": "test0"
},
"radio": {
"value": "radio1"
}
}
# create
result = app.create(record)
self.assertTrue(result.ok)
record_id = result.record_id
first_revision = result.revision
created = app.get(record_id)
self.assertTrue(created.ok)
# update
update = {
"$id": {
"value": record_id
},
"$revision": {
"value": result.revision
},
"radio": {
"value": "radio2"
}
}
result = app.update(update)
self.assertTrue(result.ok)
self.assertTrue(first_revision < result.revision)
updated = app.get(record_id).record
self.assertTrue("redio2", updated["radio"]["value"])
# delete
result = app.delete(record_id)
self.assertTrue(result.ok)
def test_update_views(self):
ks = pykintone.load(envs.FILE_PATH)
view_api = ks.app(self.TEST_APP.app_id).administration().view()
view_name = "test_view"
codes = FormAPI.gather_codes(self._default_form())
views = View.create(view_name, codes[1:])
# add views
add_result = view_api.update(views)
self.assertTrue(add_result.ok)
v_def = view_api.get(preview=True).views
self.assertEqual(1, len(v_def))
# update fields
views = [View.create(view_name, codes), View.create("another_view", codes, index=2)]
update_result = view_api.update(views, revision=add_result.revision)
self.assertTrue(update_result.ok)
v_def = view_api.get(preview=True).views
self.assertEqual(2, len(v_def))
original = [v for v in v_def if v.name == view_name][0]
self.assertEqual(len(codes), len(original.fields))
def test_update_fields(self):
ks = pykintone.load(envs.FILE_PATH)
form_api = ks.app(self.TEST_APP.app_id).administration().form()
fields = self._make_fields()
codes = form_api.gather_codes(fields)
def filter_by_codes(fs, target_codes):
return [f for f in fs if f.code in target_codes]
# add fields
add_result = form_api.add(fields)
self.assertTrue(add_result.ok)
f_def = form_api.get(preview=True).fields
created = filter_by_codes(f_def, codes)
self.assertEqual(len(fields), len(created))
# delete fields
delete_result = form_api.delete(fields, revision=add_result.revision)
self.assertTrue(delete_result.ok)
f_def = form_api.get(preview=True).fields
deleted = filter_by_codes(f_def, codes)
self.assertEqual(0, len(deleted))
def test_update_fields(self):
ks = pykintone.load(envs.FILE_PATH)
form_api = ks.app(self.TEST_APP.app_id).administration().form()
fields = self._make_fields()
codes = form_api.gather_codes(fields)
def filter_by_codes(fs, target_codes):
return [f for f in fs if f.code in target_codes]
# add fields
add_result = form_api.add(fields)
self.assertTrue(add_result.ok)
f_def = form_api.get(preview=True).fields
created = filter_by_codes(f_def, codes)
self.assertEqual(len(fields), len(created))
# delete fields
delete_result = form_api.delete(fields, revision=add_result.revision)
self.assertTrue(delete_result.ok)
f_def = form_api.get(preview=True).fields
deleted = filter_by_codes(f_def, codes)
self.assertEqual(0, len(deleted))
dotenv_path = join(dirname(__file__), '.env')
load_dotenv(dotenv_path)
# LINE Pay API
LINE_PAY_CHANNEL_ID = os.environ.get("LINE_PAY_CHANNEL_ID")
LINE_PAY_CHANNEL_SECRET = os.environ.get("LINE_PAY_CHANNEL_SECRET")
LINE_PAY_IS_SANDBOX = False # True | False
api = LinePayApi(LINE_PAY_CHANNEL_ID,
LINE_PAY_CHANNEL_SECRET,
is_sandbox=LINE_PAY_IS_SANDBOX)
# Cache
CACHE = {}
# kintone
account = pykintone.load("account.yml")
kintone = account.app()
class PayTransaction(model.kintoneModel):
def __init__(self):
super(PayTransaction, self).__init__()
self.transaction_id = ""
self.transaction_type = ""
self.method = ""
self.total_amount = 0
self.currency = ""
self.payment_status = ""
self.reg_key = ""
def test_get_view(self):
app = pykintone.load(envs.FILE_PATH).app()
vr = app.administration().view().get()
self.assertTrue(vr.ok)
views = vr.views
self.assertTrue(len(views) > 0)
def test_get_form(self):
app = pykintone.load(envs.FILE_PATH).app()
fr = app.administration().form().get()
self.assertTrue(fr.ok)
fields = fr.fields
self.assertTrue(len(fields) > 0)
def tearDownClass(cls):
account = pykintone.load(envs.FILE_PATH).account
admin = Administrator(account)
rollbacked = admin.rollback_settings(cls.TEST_APP.app_id)
cls.TEST_APP = None
print("You have to delete the application from the application administration view.")
def test_get_general_settings(self):
app = pykintone.load(envs.FILE_PATH).app()
s = app.administration().general_settings().get().settings
self.assertTrue(s.name)
def test_get_application_information(self):
app = pykintone.load(envs.FILE_PATH).app()
ai = app.administration().get_app_info().info
self.assertTrue(ai)
def test_batch(self):
app = pykintone.load(envs.FILE_PATH).app()
records = [{
"my_key": {
"value": "test_m0"
},
"radio": {
"value": "radio1"
}
}, {
"my_key": {
"value": "test_m1"
},
"radio": {
"value": "radio2"
}
}]
# create
result = app.batch_create(records)
self.assertTrue(result.ok)
record_keys = result.keys
ids = [str(k.record_id) for k in record_keys]
query = "レコード番号 in ({0})".format(",".join(ids))
created = app.select(query)
self.assertTrue(created.ok)
# update
updates = [{
"$id": {
"value": record_keys[0].record_id
},
"$revision": {
"value": record_keys[0].revision
},
"radio": {
"value": "radio2"
}
}, {
"$id": {
"value": record_keys[1].record_id
},
"$revision": {
"value": record_keys[1].revision
},
"radio": {
"value": "radio1"
}
}]
result = app.batch_update(updates)
self.assertTrue(result.ok)
for r in result.keys:
prev = [k for k in record_keys if k.record_id == r.record_id]
self.assertTrue(len(prev) == 1)
self.assertTrue(prev[0].revision < r.revision)
# delete
result = app.delete(ids)
self.assertTrue(result.ok)
def test_options(self):
app = pykintone.load(envs.FILE_PATH).app()
app.requests_options = {"verify": True}
result = app.select()
self.assertTrue(result.ok)
self.assertTrue(len(result.records) > 0)
def setUpClass(cls):
account = pykintone.load(envs.FILE_PATH).account
admin = Administrator(account)
cls.TEST_APP = admin.create_application("test form edit")
def test_batch(self):
app = pykintone.load(envs.FILE_PATH).app()
records = [
{
"my_key": {
"value": "test_m0"
},
"radio": {
"value": "radio1"
}
},
{
"my_key": {
"value": "test_m1"
},
"radio": {
"value": "radio2"
}
}
]
# create
result = app.batch_create(records)
self.assertTrue(result.ok)
record_keys = result.keys
ids = [str(k.record_id) for k in record_keys]
query = "レコード番号 in ({0})".format(",".join(ids))
created = app.select(query)
self.assertTrue(created.ok)
# update
updates = [
{
"$id": {
"value": record_keys[0].record_id
},
"$revision": {
"value": record_keys[0].revision
},
"radio": {
"value": "radio2"
}
},
{
"$id": {
"value": record_keys[1].record_id
},
"$revision": {
"value": record_keys[1].revision
},
"radio": {
"value": "radio1"
}
}
]
result = app.batch_update(updates)
self.assertTrue(result.ok)
for r in result.keys:
prev = [k for k in record_keys if k.record_id == r.record_id]
self.assertTrue(len(prev) == 1)
self.assertTrue(prev[0].revision < r.revision)
# delete
result = app.delete(ids)
self.assertTrue(result.ok)
def setUpClass(cls):
account = pykintone.load(envs.FILE_PATH).account
admin = Administrator(account)
cls.TEST_APP = admin.create_application("test form edit")
def test_get_form(self):
app = pykintone.load(envs.FILE_PATH).app()
fr = app.administration().form().get()
self.assertTrue(fr.ok)
fields = fr.fields
self.assertTrue(len(fields) > 0)
