def mkdir(path):
"""Create a directory"""
cl = Client()
res = cl.create_dir(path)
stat = res['status']
if stat != Status.ok:
print(Status.description(stat))
def rm(path):
"""Delete a file or directory"""
cl = Client()
res = cl.delete(path)
stat = res['status']
if stat != Status.ok:
print(Status.description(stat))
def run():
config = ConfigParser.ConfigParser()
with open(CONFIG_PATH) as config_fp:
config.readfp(config_fp)
logging.config.dictConfig(LOGGING_CONFIG)
client = Client(config)
client.start()
def places(request):
context_dict = {}
if request.method == 'POST':
from_station = request.POST.get('from_station')
to_station = request.POST.get('to_station')
date = request.POST.get('departure_date')
time = request.POST.get('departure_time')
train_number = request.POST.get('train_number')
departure_date = datetime.strptime(date, "%Y-%m-%d")
client = Client(api_usernumber = conf.USER_NUMBER, api_passmd5 = conf.USER_PASSMD5, id_terminal = conf.ID_TERMINAL, id_service = conf.ID_SERVICE, request_url = conf.API_URL)
df = DateFormat(departure_date)
places = client.get_train_places(from_station, to_station, df.format('d.m.Y'), time, train_number)
data = json.dumps(places, ensure_ascii=False)
response_dict = json.loads(data)
if 'status' in response_dict:
context_dict['error'] = response_dict['message']
else:
context_dict = place_handler(response_dict)
context_dict['data'] = data
context_dict['from_station'] = Station.objects.get(code=from_station)
context_dict['to_station'] = Station.objects.get(code=to_station)
context_dict['departure_date'] = date
context_dict['departure_time'] = time
context_dict['train_number'] = train_number
context_dict['stations'] = Station.objects.all()
return render(request, 'search/places.html', context_dict)
def download(path_from, path_to):
"""Download a file"""
cl = Client()
res = cl.download_file(path_from, path_to)
# print(res)
stat = res['status']
if stat != Status.ok:
print(Status.description(stat))
def create(self, callback=None, connectionType=None, vhost=None):
from client.client import Client
client = Client(self.room)
client.callback = callback
client.type = connectionType
if vhost:
client.vhost = vhost
self.clientList[client.unique_key] = client
return client.unique_key
def upload(local_path, remote_path):
"""Create a file"""
cl = Client()
if os.path.isdir(local_path):
print("You can't upload directory as a file")
else:
res = cl.create_file(local_path, remote_path)
stat = res['status']
if stat != Status.ok:
print(Status.description(stat))
class Ui_Form(QWidget):
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setupUi(self)
self.client = Client('localhost')
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(8, 600)
self.horizontalLayout = QHBoxLayout(Form)
self.horizontalLayout.setObjectName("horizontalLayout")
self.horizontalLayout.setGeometry(QRect(0, 0, 600, 600))
self.horizontalLayout.setSizeConstraint(QLayout.SetFixedSize)
self.gridLayout = QGridLayout()
# self.gridLayout.setSizeConstraint(QLayout.SetMaximumSize)
self.gridLayout.setObjectName("gridLayout")
self.horizontalLayout.addLayout(self.gridLayout)
self.row = 0;
self.col = 0;
self.width = 3;
self.entries = []
self.retranslateUi(Form)
QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
_translate = QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
def addImageLabel(self, pic):
print (pic)
pixmap = QPixmap(pic).scaled(200, 200, Qt.KeepAspectRatio)
label = QLabel(self)
label.setPixmap(pixmap)
self.entries.append(label)
self.gridLayout.addWidget(label, *(self.row, self.col))
self.col += 1
if self.col % self.width == 0:
self.col = 0
self.row += 1
def removeImageLabel(self, position):
item = position[0] * self.width + position[1]
label = self.gridLayout.takeAt(item)
widget = label.widget();
widget.deleteLater();
def run(self):
self.client.getAllPhoto()
jpgList = glob.glob1("temp", "*.jpg")
for each in jpgList:
self.addImageLabel("temp/" + each)
def main():
parser = argparse.ArgumentParser(description='Tic Tac Toe')
subparsers = parser.add_subparsers(title='module', dest='module')
subparsers.required = True
subparsers.add_parser('server', help='start the server')
subparsers.add_parser('client', help='start a client')
args = parser.parse_args()
if args.module == 'server':
server = Server()
try:
server.start()
except BaseException as e:
logger.error('Process interrupted, stopping the server', exc_info=e)
finally:
server.stop()
elif args.module == 'client':
client = Client()
try:
client.connect()
client.run()
except BaseException as e:
logger.error('Process interrupted, disconnecting the client', exc_info=e)
finally:
client.disconnect()
else:
print('unknown module {}'.format(args.module), file=sys.stderr)
def ls(path):
"""List directory contents"""
cl = Client()
dir_ls = cl.list_dir(path)
stat = dir_ls['status']
if stat == Status.ok:
for item, info in dir_ls['items'].items():
fr = "-rw-r--r--"
if info['type'] == NodeType.directory:
fr = "drwxr-xr-x"
date = datetime.datetime.fromtimestamp(info['date'])
date_format = '%b %d %H:%M' if date.year == datetime.datetime.today().year else '%b %d %Y'
print('%.11s %.10s %6sB %.15s %s' % (fr,
getpass.getuser(),
info['size'],
datetime.datetime.fromtimestamp(info['date']).strftime(date_format),
item))
else:
print(Status.description(stat))
def buy_ticket(request):
context_dict = {}
if request.method == 'POST':
from_station = request.POST.get('from_station')
to_station = request.POST.get('to_station')
date = request.POST.get('departure_date')
time = request.POST.get('departure_time')
train_number = request.POST.get('train_number')
car_number = request.POST.get('car_number')
car_type = request.POST.get('car_type')
doc_type = request.POST.get('doc_type')
doc_number = request.POST.get('doc_number')
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
middle_name = request.POST.get('middle_name')
full_name = last_name+"="+first_name+"="+middle_name
departure_date = datetime.strptime(date+" "+time, "%Y-%m-%d %H:%M")
df = DateFormat(departure_date)
client = Client(api_usernumber = conf.USER_NUMBER, api_passmd5 = conf.USER_PASSMD5, id_terminal = conf.ID_TERMINAL, id_service = conf.ID_SERVICE, request_url = conf.API_URL)
class_service = ""
if car_type==u"Люкс":
class_service = u'1Л'
elif car_type == u"Купе":
class_service = u'2К'
elif car_type == u"Плацкартный":
class_service = u'3П'
print car_type
print class_service
booking = client.buy_ticket(from_station, to_station, df.format('d.m.Y H:i'), train_number, car_type, car_number, class_service, '0', '0', 'null', '1', 'null', 'null', doc_type, doc_number, full_name, car_type[0], '1')
data = json.dumps(booking, ensure_ascii=False)
response_dict = json.loads(data)
if "GtETicket_Response" in response_dict:
context_dict = handle_ticket(response_dict)
else:
context_dict['error'] = data
context_dict['from_station'] = Station.objects.get(code=from_station)
context_dict['to_station'] = Station.objects.get(code=to_station)
context_dict['departure_date'] = date
context_dict['stations'] = Station.objects.all()
return render(request, 'search/ticket.html', context_dict)
def test_duplicate_alias(self, client: Client):
client.add_address("baz", "foo", force=True)
show_foo = client.show_address("foo", show_secret=True)
assert show_foo.secret_key is not None
def test_transfer_to_noop(self, client: Client):
client.transfer(10, 'bootstrap1', 'noop', ['--arg', 'Unit'])
utils.bake(client)
def test_balances_foo_bar(self, client: Client, session):
# 999.95 = 1000 - transfer fees
assert client.get_balance(session['keys'][0]) == 999.95
assert client.get_balance(session['keys'][1]) == 2000
def test_context_suffix_no_rpc(proxy_client: Client, path: str):
"""
This test checks that the proxy client never does a useless RPC.
I.e. it checks that if the proxy client requested
`/chains/<main>/blocks/<head>/context/raw/bytes/some_path`
it doesn't later request
`/chains/<main>/blocks/<head>/context/raw/bytes/some_other_path`
with `some_other_path` being a suffix of `some_path`. In this
scenario, the proxy client should look for the tail of
`some_other_path` that is a suffix of `some_path` and use this
suffix to get the data within the tree received by the first request.
For this, this test inspects the debug output produced by
setting TEZOS_LOG to alphas.proxy_rpc->debug. This causes the client
to print the RPCs done to get pieces of the context:
alpha.proxy_rpc: P/v1/constants
alpha.proxy_rpc: Received tree of size 1
alpha.proxy_rpc: P/v1/first_level
alpha.proxy_rpc: Received tree of size 1
alpha.proxy_rpc: P/cycle/0/random_seed
alpha.proxy_rpc: Received tree of size 1
alpha.proxy_rpc: P/cycle/0/roll_snapshot
alpha.proxy_rpc: Received tree of size 1
alpha.proxy_rpc: P/cycle/0/last_roll/0
where P is /chains/<main>/blocks/<head>/context/raw/bytes
In the client, this behavior is implemented by putting the result
of RPC calls in a trie.
"""
cmd = ["rpc", "get", path]
(_, stderr, _) = proxy_client.run_generic(cmd, env_change=_PROXY_RPC_LOG)
prefix = "/chains/<main>/blocks/<head>/context/raw/bytes"
search_re = f".proxy_rpc: {prefix}/(.*)"
# The suffix of RPCs querying data, such as "v1/constants",
# "v1/first_level", "cycle/0/random_seed", etc. (see method doc)
context_queries = []
for line in stderr.splitlines():
match = re.search(search_re, line)
if match:
suffix = match.group(1)
context_queries.append(suffix)
assert len(context_queries) >= 2, "There should be at least two queries"
def gen_msg(query_before, query):
return (f"Query {query_before} should not be followed by query" +
f" {query} because the latter is a suffix of the former." +
" Hence the proxy should reuse the data of the first query.")
i = len(context_queries) - 1
while i >= 0:
query = context_queries[i]
j = i - 1
while j >= 0:
query_before = context_queries[j]
assert not query_before.startswith(query), gen_msg(
query_before, query)
j -= 1
i -= 1
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setupUi(self)
self.client = Client('localhost')
def connect(stdscr, server_ip):
global connection
connection = Client()
connection.connect(server_ip)
return connected(stdscr)
def status(path):
"""Check if path refers to file or directory"""
cl = Client()
res = cl.path_status(path)
print('%s is a %s' % (path, NodeType.description(res['type'])))
def setUp(self):
self.app = MagicMock()
self.client = Client(self.app, 'localhost', 5000)
class TestClient(unittest.TestCase):
def setUp(self):
self.app = MagicMock()
self.client = Client(self.app, 'localhost', 5000)
def test_send(self):
message = "test"
with patch("socket.socket.send") as mock:
self.client.send(message)
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0][0], message)
def test_connect(self):
self.client._host = "localhost"
self.client._port = 5000
with patch("socket.socket.connect") as mock:
self.client.connect()
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0][0], (self.client._host, self.client._port))
def test_process_users_list(self):
user1 = "user1"
user2 = "user2"
history = "history"
data = "<users>" + user1 + "," + user2 + "<history>" + history
self.client.process_users_list(data)
self.assertEqual(self.client.user_list, [user1, user2])
self.assertEqual(self.app.show_users.call_count, 1)
self.assertEqual(self.app.display.call_count, 2)
self.assertEqual(self.app.display.call_args_list[0][0], (history,))
def test_process_add_user(self):
user = "******"
data = "<users-add>" + user
self.client.process_add_user(data)
self.assertTrue(user in self.client.user_list)
self.assertEqual(self.app.show_users.call_count, 1)
self.assertEqual(self.app.show_users.call_args[0][0], self.client.user_list)
self.assertEqual(self.app.display.call_count, 1)
self.assertTrue(user in self.app.display.call_args[0][0])
def test_process_remove_user(self):
user = "******"
self.client.user_list.append(user)
data = "<users-remove>" + user
self.client.process_remove_user(data)
self.assertTrue(user not in self.client.user_list)
self.assertEqual(self.app.show_users.call_count, 1)
self.assertEqual(self.app.show_users.call_args[0][0], self.client.user_list)
self.assertEqual(self.app.display.call_count, 1)
self.assertTrue(user in self.app.display.call_args[0][0])
def test_process_data_users_list(self):
data = "<users>users<history>history"
with patch("client.client.Client.process_users_list") as mock:
self.client.process_data(data)
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0][0], data)
def test_process_data_new_user(self):
data = "<users-add>user"
with patch("client.client.Client.process_add_user") as mock:
self.client.process_data(data)
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0][0], data)
def test_process_data_remove_user(self):
data = "<users-remove>user"
with patch("client.client.Client.process_remove_user") as mock:
self.client.process_data(data)
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0][0], data)
def test_process_data_message(self):
data = "message"
self.client.process_data(data)
self.assertEqual(self.app.display.call_count, 1)
self.assertEqual(self.app.display.call_args[0][0], data)
def test_operation_size_medium(self, client: Client):
bytes_arg = "0x" + ("00" * 24 * 1024) # 24 KB of data.
client.transfer(10, 'bootstrap1', 'bytes', ['--arg', bytes_arg])
utils.bake(client)
def test_no_service_3(self, client: Client):
path = '/chains/main/blocks/head/context/raw/bytes/non-existent?depth=0'
with assert_run_failure('No service found at this URL'):
client.rpc('get', path)
def test_proto_known(self, client: Client):
res = client.list_protocols()
assert PROTO in res
def run():
# Parse configuration to constants
logging.config.dictConfig(LOGGING_CONFIG)
client = Client()
client.start()
def test_level1(self, client: Client):
assert client.get_level(params=PARAMS) == 1
def test_split_large_file(self):
chunks = Client.split_file('test_large.txt')
self.assertEqual(chunks[1], self.content[1024:])
self.assertEqual(chunks[0]+chunks[1], self.content)
def test_level2(self, client: Client):
head = client.rpc('get', '/chains/main/blocks/head/', params=PARAMS)
assert head['header']['level'] == 2
def test_balances_bar_foo(self, client: Client, session):
assert client.get_balance(session['keys'][0]) == 2000
assert client.get_balance(session['keys'][1]) == 1000
def cat(path):
"""Print a file"""
cl = Client()
res = cl.get_file_content(path)
print(res)
def test_first_protocol(self, client: Client):
proto = 'PrihK96nBAFSxVL1GLJTVhu9YnzkMFiBeuJRPA8NwuZVZCE1L6i'
assert client.get_protocol() == proto
def test_proto_client_known(self, client: Client):
res = client.list_understood_protocols()
assert 'ProtoDemoCou' in res
def test_protocol_genesis(self, client: Client):
assert client.get_protocol(params=PARAMS) == PROTO_GENESIS
def test_level1(self, client: Client):
assert client.get_level() == 1
def test_gen_keys(self, client: Client, session):
session['keys'] = ['foo', 'bar', 'boo']
sigs = [None, 'secp256k1', 'ed25519']
for key, sig in zip(session['keys'], sigs):
args = [] if sig is None else ['--sig', sig]
client.gen_key(key, args)
def test_inject_operations(self, client: Client):
client.run(['increment', 'a'])
client.run(['increment', 'b'])
client.run(['transfer', '10'])
def test_transfer_foo_bar(self, client: Client, session):
client.reveal(session['keys'][0], ['--fee', '0', '--force-low-fee'])
utils.bake(client)
client.transfer(1000, session['keys'][0], session['keys'][1],
['--fee', '0.05'])
utils.bake(client)
def test_mempool(self, client: Client):
ops = client.get_mempool()
assert len(ops['applied']) == 3
def test_transfer_failure(self, client: Client, session):
with pytest.raises(Exception):
client.transfer(999.95, session['keys'][0], session['keys'][1])
def test_bake_command_2(self, client: Client):
time.sleep(1)
client.run(['bake', 'This is block 3'])
def test_transfer_king_queen(self, client: Client, session):
keys = session['keys']
client.transfer(10, keys[3], keys[4], TRANSFER_ARGS)
utils.bake(client)
def test_level3(self, client: Client):
head = client.rpc('get', '/chains/main/blocks/head/')
assert head['header']['level'] == 3
def test_no_service_2(self, client: Client):
path = ('/chains/main/blocks/head/context/raw/bytes/'
'non-existent?depth=-1')
expected = r'Failed to parse argument \'depth\' \("-1"\)'
with assert_run_failure(expected):
client.rpc('get', path)
def test_rpc_counter_b(self, client: Client):
head = client.rpc('get', '/chains/main/blocks/head/counter/b')
assert head == 111
def test_operation_size_oversized(self, client: Client):
bytes_arg = "0x" + ("00" * 36 * 1024) # 36 KB of data.
expected_error = "Oversized operation"
with assert_run_failure(expected_error):
client.transfer(10, 'bootstrap1', 'bytes', ['--arg', bytes_arg])
def test_get_counter_commands(self, client: Client):
message_a = client.run(['get', 'a'])
assert message_a == "The counter value is 91\n"
message_b = client.run(['get', 'b'])
assert message_b == "The counter value is 111\n"
def check_level_greater_than(
client: Client, level, chain: str = 'main'
) -> bool:
return client.get_level(chain=chain) >= level
from client.client import Client
from flask import Blueprint, render_template, session, request
from authentication.authenticator import login_required, group_access_level
api = Client()
page = 'members'
members_page = Blueprint('members_page', __name__)
@members_page.before_request
@login_required
def client_auth(**kwargs):
api.set_auth_header('Bearer %s' % session['jwt'])
@members_page.route("/groups/<groupId>/members")
@login_required
@group_access_level('member')
def MembersPage(**kwargs):
subtab = request.args.get('subtab', 'members')
user_role = kwargs.get('user_role')
username = kwargs.get('username', None)
groupId = kwargs.get('groupId', None)
group = api.groups.get(groupId=groupId).json()
members = api.groups.members.list(groupId=groupId).json()
requests = []
if user_role == 'admin':
requests = api.groups.requests.list(groupId=groupId).json()
from client.client import Client
import asyncore
import socket
from time import sleep
import sys
from inputOutput.filehandling import get_client_config
from inputOutput.output import show_info_dialog, show_input_dialog, show_option_dialog
if __name__ == '__main__':
choice = show_option_dialog("Do you want to use config file?",
["yes", "no"])
if choice == "yes":
address, port, programId, username = get_client_config()
client = Client((address, int(port)), programId,
username)
asyncore.loop()
else:
show_info_dialog("This client is intended to run on one processor core "
"and calculates results from clustering documents given "
"a set of parameters (received from server). If you want"
" to use more cores, run additional clients. You can "
"exit the client at any time by pressing ctrl + c.\n")
hostAddress = show_input_dialog("Please type in the ip address or domain "
"name of the host on the form '0.0.0.0' "
"or 'domain.com': ")
port = show_input_dialog("Please input the port the server listens to: ")
programId = show_input_dialog("Please specify programId: ")
help='port of the server this client will connect to')
parser.add_argument('-l',
'--logging',
type=int,
default=30,
help='set the logging level')
args = parser.parse_args()
port = args.port
pub_key_location = 'client/public.key'
private_key_location = 'client/private.key'
logging.getLogger().setLevel(args.logging)
a = Client(f'http://localhost:{port}', pub_key_location, private_key_location)
# resp = a.send_transaction("what what what asdfasdfasdfasdfasdf;lkj asdf adsf asdf asdf asdf aaaaaaaaaadg asdg asd gas dgas dga sdgWhat a horrible candle-snuffing word. That's like saying, He can't climb that mountain, he's just a man, or That's not a diamond, it's just a rock. Just.")
# b = resp.json()
# print(b)
inp = ''
while not inp is 'exit' and not inp is 'x':
print(
"s: send\ng: get transaction by id\na: get all of your transactions\nx: exit"
)
inp = input('>')
if inp == 's':
notes = input('patient notes: ')
resp = a.send_transaction(notes)
print(resp.json())
class Ui_Form(QWidget):
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setupUi(self)
self.client = Client('localhost')
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(1000, 688)
contents = QWidget(self)
contents.setGeometry(QtCore.QRect(800, 40, 100, 30))
self.getPhotoBtn = QtWidgets.QPushButton(contents)
self.getPhotoBtn.setObjectName("getPhotoBtn")
self.getPhotoBtn.clicked.connect(self.getPhotoBtnEvent)
contents = QWidget(self)
contents.setGeometry(QtCore.QRect(800, 80, 100, 30))
self.synchBtn = QtWidgets.QPushButton(contents)
self.synchBtn.setObjectName("synchBtn")
self.synchBtn.clicked.connect(self.synchBtnEvent)
self.horizontalLayoutContents = QtWidgets.QWidget(self)
self.horizontalLayoutContents.setGeometry(QRect(40, 40, 700, 600))
self.horizontalLayout = QtWidgets.QHBoxLayout(self.horizontalLayoutContents)
self.scrollAreaWidgetContents = QtWidgets.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 600, 600))
self.gridLayout = QtWidgets.QGridLayout()
self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.scrollAreaWidgetContents)
self.horizontalLayout_2.addLayout(self.gridLayout)
self.scrollArea = QtWidgets.QScrollArea(self)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.horizontalLayout.addWidget(self.scrollArea)
self.row = 0;
self.col = 0;
self.width = 3;
self.entries = []
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def getPhotoBtnEvent(self):
self.client.getAllPhoto()
jpgList = glob.glob1("temp", "*.jpg")
for each in jpgList:
self.addImageLabel(each)
def synchBtnEvent(self):
self.client.synchrinize()
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
self.getPhotoBtn.setText(_translate("Form", "getphoto"))
self.synchBtn.setText(_translate("Form", "synchronize"))
def addImageLabel(self, pic):
pixmap = QPixmap('temp/' + pic).scaled(200, 200, Qt.KeepAspectRatio)
label = MyQLabel(self)
label.setName(pic)
label.setPixmap(pixmap)
self.entries.append(label)
self.gridLayout.addWidget(label, *(self.row, self.col))
self.col += 1
if self.col % self.width == 0:
self.col = 0
self.row += 1
def removeImageLabel(self, position):
item = position[0] * self.width + position[1]
label = self.gridLayout.takeAt(item)
widget = label.widget();
widget.deleteLater();
from tornado.ioloop import IOLoop
from rx import Observable
from rx.subjects import Subject
from rx.concurrency import QtScheduler, AsyncIOScheduler
from client.client import Client
from client.client_window import ClientWindow
import utils
if __name__ == '__main__':
app = QApplication(sys.argv)
scheduler = QtScheduler(QtCore)
stock_prices = Subject()
client = Client(port='9999')
loop = asyncio.new_event_loop()
asyncio_scheduler = AsyncIOScheduler(loop)
def run_client():
asyncio.set_event_loop(loop)
asyncio.get_event_loop().call_soon(utils.run_client_websocket, client,
stock_prices)
asyncio.get_event_loop().run_forever()
thread = Thread(target=run_client, daemon=True)
thread.start()
client_window = ClientWindow(stock_prices_stream=stock_prices)
client_window.get_orders() \
#!/usr/bin/python
from sys import argv
from client.client import Client
client = Client()
try:
if "-s" in argv:
try:
client.run()
except Exception, ex:
print ex
else:
client.run()
except KeyboardInterrupt:
print "KeyboardInterrupt"
if client.run:
client.run = False
def test_split_small_file(self):
chunks = Client.split_file('test_small.txt')
self.assertEqual(chunks[0], self.content[:12])
self.assertEqual(len(chunks), 1)
