def test_offset_range(self):
if VERSION == 26:
return
msg = FixMessage()
with self.assertRaises(ValueError):
msg._tz_offset_string(1500)
with self.assertRaises(ValueError):
msg._tz_offset_string(1440)
msg._tz_offset_string(1439)
msg._tz_offset_string(0)
msg._tz_offset_string(-1439)
with self.assertRaises(ValueError):
msg._tz_offset_string(-1440)
with self.assertRaises(ValueError):
msg._tz_offset_string(-1500)
def test_sequence_access(self):
"""Test sequence access to message fields"""
msg = FixMessage()
msg.append_pair(8, "FIX.4.2")
msg.append_pair(35, "A")
msg.append_pair(108, 30)
msg.append_pair(141, "N")
msg.append_pair(383, 16384)
self.assertEqual(35, msg[1][0])
self.assertEqual(141, msg[3][0])
fields = []
for tag, _ in msg:
fields.append(int(tag))
self.assertEqual([8, 35, 108, 141, 383], fields)
return
def test_stop_tag(self):
"""Test termination using alternative tag number."""
pkt = FixMessage()
pkt.append_pair(8, "FIX.4.2")
pkt.append_pair(35, "D")
pkt.append_pair(29, "A")
pkt.append_pair(20000, "xxx")
pkt.append_pair(10, "000")
buf = pkt.encode()
p = FixParser(stop_tag=20000)
p.append_buffer(buf)
m = p.get_message()
self.assertIsNotNone(m)
self.assertEqual(b"FIX.4.2", m.get(8))
self.assertEqual(b"D", m.get(35))
self.assertEqual(b"A", m.get(29))
self.assertEqual(b"xxx", m.get(20000))
self.assertEqual(False, 10 in m)
def test_tzto_minutes(self):
"""Test TZTimeOnly formatting without seconds"""
msg = FixMessage()
t = 1484581872.933458
msg.append_tz_time_only(1079, t, precision=None)
test = time.localtime(t)
s = "%02u:%02u" % (test.tm_hour, test.tm_min)
offset = self.calculate_tz_offset(t)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1079))
def test_raw_data(self):
"""Test parsing of raw data fields."""
raw = b"raw\x01data"
pkt = FixMessage()
pkt.append_pair(8, "FIX.4.2")
pkt.append_pair(35, "D")
pkt.append_data(95, 96, raw)
buf = pkt.encode()
parser = FixParser()
parser.append_buffer(buf)
msg = parser.get_message()
self.assertIsNotNone(msg)
self.assertEqual(b"FIX.4.2", msg.get(8))
self.assertEqual(b"D", msg.get(35))
self.assertEqual(len(raw), int(msg.get(95)))
self.assertEqual(raw, msg.get(96))
return
def test_stop_tag_deprecated(self):
"""Test deprecated setting of stop tag."""
pkt = FixMessage()
pkt.append_pair(8, "FIX.4.2")
pkt.append_pair(35, "D")
pkt.append_pair(29, "A")
pkt.append_pair(20000, "xxx")
pkt.append_pair(10, "000")
buf = pkt.encode()
p = FixParser()
p.set_message_terminator(tag=20000)
p.append_buffer(buf)
m = p.get_message()
self.assertIsNotNone(m)
self.assertEqual(b"FIX.4.2", m.get(8))
self.assertEqual(b"D", m.get(35))
self.assertEqual(b"A", m.get(29))
self.assertEqual(b"xxx", m.get(20000))
self.assertEqual(False, 10 in m)
def test_tzto_seconds_only(self):
"""Test formatting of TZTimeOnly values with seconds only"""
msg = FixMessage()
t = 1484581872.933458
msg.append_tz_time_only(1079, t, 0)
test = time.localtime(t)
s = "%02u:%02u:%02u" % \
(test.tm_hour, test.tm_min, test.tm_sec)
offset = self.calculate_tz_offset(t)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1079))
def test_tzto_datetime(self):
msg = FixMessage()
t = 1484581872.933458
local = datetime.datetime.fromtimestamp(t)
msg.append_tz_time_only(1079, local)
test = time.localtime(t)
s = "%02u:%02u:%02u.%03u" % \
(test.tm_hour, test.tm_min, test.tm_sec, int((t % 1) * 1e3))
offset = self.calculate_tz_offset(t)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1079))
def test_append_tzts_float(self):
msg = FixMessage()
t = 1484581872.933458
msg.append_tz_timestamp(1132, t)
test = time.localtime(t)
s = "%04u%02u%02u-%02u:%02u:%02u.%03u" % \
(test.tm_year, test.tm_mon, test.tm_mday,
test.tm_hour, test.tm_min, test.tm_sec,
int((t - int(t)) * 1000))
offset = self.calculate_tz_offset(t)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1132))
def market_order(n, side, price):
order = FixMessage()
order.append_pair(8, "FIX.4.4")
order.append_pair(35, "D")
order.append_pair(34, n)
order.append_pair(49, trade_auth.SenderCompID)
order.append_utc_timestamp(52)
order.append_pair(56, trade_auth.TargetCompID)
order.append_pair(55, "EURUSD.spa")
order.append_pair(54, side)
order.append_pair(59, "3")
order.append_utc_timestamp(60)
order.append_pair(40, "1")
order.append_pair(44, price)
order.append_pair(38, "10000")
order.append_utc_timestamp(11)
order_msg = order.encode()
print("sent order", order_msg)
s.sendall(order_msg)
print(str(s.recv(trade_auth.SocketConnectPort)).replace('\\x01', '|'))
def login(n):
message = FixMessage()
print('UTC', datetime.datetime.utcnow())
print('LOCAL', datetime.datetime.now())
message.append_pair(8, "FIX.4.4")
message.append_pair(35, "A")
message.append_pair(34, n)
message.append_pair(49, trade_auth.SenderCompID)
message.append_utc_timestamp(52, None)
message.append_pair(56, trade_auth.TargetCompID)
message.append_pair(98, "0")
message.append_pair(108, "30")
message.append_pair(141, "Y")
message.append_pair(553, trade_auth.Username)
message.append_pair(554, trade_auth.Password)
msg = message.encode()
print("logon msg", msg)
s.sendall(msg)
print("logon response", s.recv(7550))
def test_tzts_microseconds(self):
"""Test formatting of TZTimestamp values with microseconds"""
msg = FixMessage()
t = 1484581872.933458
msg.append_tz_timestamp(1253, t, 6)
test = time.localtime(t)
s = "%04u%02u%02u-%02u:%02u:%02u.%06u" % \
(test.tm_year, test.tm_mon, test.tm_mday,
test.tm_hour, test.tm_min, test.tm_sec,
int((t % 1) * 1e6))
offset = self.calculate_tz_offset(t)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1253))
def data_subscribe(n):
data = FixMessage()
data.append_pair(8, "FIX.4.4")
data.append_pair(35, "V")
data.append_pair(49, price_auth.SenderCompID)
data.append_pair(56, price_auth.TargetCompID)
data.append_pair(34, n)
data.append_utc_timestamp(52)
data.append_pair(262, "2")
data.append_pair(263, "1")
data.append_pair(264, "1")
data.append_pair(265, "0") #1
data.append_pair(146, "1")
data.append_pair(55, "EURUSD.spa")
data.append_pair(267, "2")
data.append_pair(269, "0")
data.append_pair(269, "1")
sent = data.encode()
print("data request ", sent)
s.sendall(data.encode())
print(s.recv(price_auth.SocketConnectPort))
def test_raw_data_tags(self):
"""Test functions to add and remove raw data tags."""
raw = b"raw\x015000=1"
pkt = FixMessage()
pkt.append_pair(8, "FIX.4.2")
pkt.append_pair(35, "D")
pkt.append_data(5001, 5002, raw)
pkt.append_pair(20000, "private tag")
buf = pkt.encode()
parser = FixParser()
parser.add_raw(5001, 5002)
parser.append_buffer(buf)
msg = parser.get_message()
self.assertIsNotNone(msg)
self.assertEqual(b"FIX.4.2", msg.get(8))
self.assertEqual(b"D", msg.get(35))
self.assertEqual(len(raw), int(msg.get(5001)))
self.assertEqual(raw, msg.get(5002))
self.assertEqual(b"private tag", msg.get(20000))
parser.reset()
parser.remove_raw(5001, 5002)
parser.append_buffer(buf)
msg = parser.get_message()
self.assertIsNotNone(msg)
self.assertEqual(b"FIX.4.2", msg.get(8))
self.assertEqual(b"D", msg.get(35))
self.assertEqual(len(raw), int(msg.get(5001)))
self.assertEqual(b"raw", msg.get(5002))
self.assertEqual(b"1", msg.get(5000))
self.assertEqual(b"private tag", msg.get(20000))
return
def test_tzto_microseconds(self):
"""Test formatting of TZTimeOnly values with microseconds"""
msg = FixMessage()
t = 1484581872.933458
msg.append_tz_time_only(1079, t, 6)
test = time.localtime(t)
s = "%02u:%02u:%02u.%06u" % \
(test.tm_hour, test.tm_min, test.tm_sec, int((t % 1) * 1e6))
offset = int(
(datetime.datetime.fromtimestamp(t) -
datetime.datetime.utcfromtimestamp(t)).total_seconds() / 60)
if offset == 0:
s += "Z"
else:
offset_hours = abs(offset) / 60
offset_mins = abs(offset) % 60
s += "%c%02u" % ("+" if offset > 0 else "-", offset_hours)
if offset_mins > 0:
s += ":%02u" % offset_mins
self.assertEqual(fix_str(s), msg.get(1079))
return
def test_string_with_bad_tag(self):
"""Test field set with bad tag in tag=value string"""
msg = FixMessage()
with self.assertRaises(ValueError):
msg.append_string("foo=bar")
return
def test_string_without_equals(self):
"""Test field set with string not containing equals sign"""
msg = FixMessage()
with self.assertRaises(ValueError):
msg.append_string("FIX.4.2")
return
def test_string_with_equals(self):
"""Test field set with tag=value string"""
msg = FixMessage()
msg.append_string("8=FIX.4.2")
self.assertEqual(fix_str("FIX.4.2"), msg.get(8))
return
def test_utcto_parts_15_51_12_933_458(self):
msg = FixMessage()
msg.append_utc_time_only_parts(1, 15, 51, 12, 933, 458)
self.assertEqual(fix_str("15:51:12.933458"), msg.get(1))
return
def test_utcts_explicit_none(self):
"""Test UTCTimestamp with explicit None timestamp value"""
msg = FixMessage()
msg.append_utc_timestamp(52, None)
return
def test_utcts_default(self):
"""Test UTCTimestamp with no supplied timestamp value"""
msg = FixMessage()
msg.append_utc_timestamp(52)
return
def test_time_explicit_none(self):
"""Test explicit None as timestamp value"""
msg = FixMessage()
msg.append_time(52, None)
return
def test_time_defaults(self):
"""Test no supplied timestamp value"""
msg = FixMessage()
msg.append_time(52)
return
def test_empty_message(self):
"""Test encoding of empty message"""
msg = FixMessage()
with self.assertRaises(ValueError):
msg.encode()
return
def test_raw_msg_type(self):
"""Test encoding of MessageType(35) in raw mode"""
pkt = FixMessage()
pkt.append_pair(35, "D")
self.assertEqual(fix_str("35=D\x01"), pkt.encode(True))
return
def test_raw_checksum(self):
"""Test encoding of CheckSum(10) in raw mode"""
pkt = FixMessage()
pkt.append_pair(10, 42)
self.assertEqual(fix_str("10=42\x01"), pkt.encode(True))
return
def test_raw_body_length(self):
"""Test encoding of BodyLength(9) in raw mode"""
pkt = FixMessage()
pkt.append_pair(9, 42)
self.assertEqual(fix_str("9=42\x01"), pkt.encode(True))
return
def test_raw_empty_message(self):
"""Test raw encoding of empty message"""
pkt = FixMessage()
self.assertEqual(fix_str(""), pkt.encode(True))
return
def test_raw_begin_string(self):
"""Test raw encoding of BeginString(8)"""
pkt = FixMessage()
pkt.append_pair(8, "FIX.4.4")
self.assertEqual(fix_str("8=FIX.4.4\x01"), pkt.encode(True))
return
def test_append_tzts_none(self):
"""Test TimezoneTimeOnly with explicit None"""
msg = FixMessage()
msg.append_tz_timestamp(1253, None)
return
