def create_ass_matr_statement(row):
cod_asignatura, any_academic, userid, idp = row
statement = Statement({
'actor': Agent({
'account': AgentAccount({
'name': idp,
}),
}),
'verb': Verb({
'id': 'http://la.uoc.edu/verb/subject/enrolment',
'display': LanguageMap({'en-US': 'Enrolment'}),
}),
'object': Activity({
'id': 'http://la.uoc.edu/object/subject/code/%s' % cod_asignatura,
'definition': ActivityDefinition({
'extensions': Extensions({
'edu:uoc:la:subject': {
'code': cod_asignatura
},
'edu:uoc:la:semester': {
'code': any_academic,
}
})
})
}),
'result': Result({
}),
'timestamp': datetime.datetime.utcnow(),
'context': Context({
'registration': uuid.uuid4(),
})
})
return json.loads(statement.to_json())
def create_Performance_statement(row):
division, num_expediente, idp, cod_asignatura, desc_assignatura, af, nf, supera_s_n, seguiment_ac_s_n, tipus_examen, qe, qualificacio_teorica, nota_prova_validacio, cod_estudios, desc_estudios, codi_aula, any_academic = row
statement = Statement({
'actor': Agent({
'account': AgentAccount({
'name': idp,
}),
}),
'verb': Verb({
'id': 'http://la.uoc.edu/verb/performance',
'display': LanguageMap({'en-US': 'Enrolment'}),
}),
'object': Activity({
'id': 'http://la.uoc.edu/object/expedient/code/%s' % num_expediente,
'definition': ActivityDefinition({
'extensions': Extensions({
'edu:uoc:la:expedient': {
'code': num_expediente,
'division': division,
},
'edu:uoc:la:subject': {
'code': cod_asignatura,
'description': desc_assignatura,
'evaluation': {
'af': af,
'nf': nf,
'ac': {
'follows': seguiment_ac_s_n == 'Si',
'pass': supera_s_n == 'Si',
},
'examType': tipus_examen,
'qe': qe,
'qt': qualificacio_teorica,
'validationTest': {
'qualification': nota_prova_validacio
}
}
},
'edu:uoc:la:semester': {
'code': any_academic,
},
'edu:uoc:la:study': {
'code': cod_estudios,
'description': desc_estudios,
},
'edu:uoc:la:classroom': {
'code': codi_aula,
},
})
})
}),
'result': Result({
}),
'timestamp': datetime.datetime.utcnow(),
'context': Context({
'registration': uuid.uuid4(),
})
})
return json.loads(statement.to_json())
def process_event(self, event_edx):
course_id = event_edx['context'].get('course_id', None)
if course_id is None or course_id == '':
try:
# We need to do this because we receive a string instead than a dictionary
event = json.loads(event_edx['event'])
course_id = event['POST'].get('course_id', None)[0]
except:
pass # No event data, just skip
if course_id != '' and course_id in self.course_ids:
try:
# Sometimes we receive time as python datetime, sometimes as string...
timepart = event_edx['time']
timestamp = xutils.make_datetime_for_tincan(timepart)
actor = None
user_id = 0
try:
user_id = event_edx['context'].get('user_id', 0)
except:
user_id = json.loads(event_edx['context']).get('user_id', 0)
try:
actor = self.get_actor(user_id)
except (ValueError, UserSocialAuth.DoesNotExist) as e:
# Only logged ECO user need to be tracked
return
verb, obj = self.to_xapi(event_edx, course_id)
context = self.get_context(course_id, user_id)
d = {"time_with_millis": timepart}
context.extensions = Extensions(d)
# verb = None means to not record the action
if verb:
statement = Statement(
actor=actor,
verb=verb,
object=obj,
context=context,
timestamp=timestamp
)
tldat = TrackingLog(
dtcreated=timestamp,
user_id=user_id,
course_id=course_id,
statement=statement.to_json(),
original_event=json.dumps(event_edx, cls=DateTimeJSONEncoder)
)
# We don't need to add duplication event test, so we save directly
tldat.save()
except Exception as e: # pylint: disable=broad-except
log.exception(e)
else:
if course_id != '':
# print 'Course not activated', course_id # Uncomment for debug
pass
def create_Matricula_statement(row):
division, num_expediente, any_academico, inv_estado_expediente, idp, anula_matricula, motiu_anulacio, cod_plan, desc_plan, cod_estudios, desc_estudios, tipo_educacion, oficial_propi, cod_area, desc_area = row
statement = Statement({
'actor': Agent({
'account': AgentAccount({
'name': idp,
}),
}),
'verb': Verb({
'id': 'http://la.uoc.edu/verb/enrolment',
'display': LanguageMap({'en-US': 'Enrolment'}),
}),
'object': Activity({
'id': 'http://la.uoc.edu/object/expedient/code/%s' % num_expediente,
'definition': ActivityDefinition({
'extensions': Extensions({
'edu:uoc:la:expedient': {
'code': num_expediente,
'division': division,
'status': inv_estado_expediente,
},
'edu:uoc:la:semester': {
'code': any_academico,
},
'edu:uoc:la:plan': {
'code': cod_plan,
'description': desc_plan,
},
'edu:uoc:la:study': {
'code': cod_estudios,
'description': desc_estudios,
'type': tipo_educacion,
'official': oficial_propi,
},
'edu:uoc:la:area': {
'code': cod_area,
'description': desc_area,
},
'edu:uoc:la:enrolment': {
'cancelation': {
'date': anula_matricula,
'reason': motiu_anulacio,
},
}
})
})
}),
'result': Result({
'success': not anula_matricula,
}),
'timestamp': datetime.datetime.utcnow(),
'context': Context({
'registration': uuid.uuid4(),
})
})
return json.loads(statement.to_json())
def create_login_logout_statement(row):
print(row)
if len(row) == 5:
userid, login, logout, ip, lastaction = row
else:
return json.loads("{}")
try:
logintime = datetime.datetime.strptime(login, "%d%m%Y%H%M%S").isoformat()
logouttime = datetime.datetime.strptime(logout, "%d%m%Y%H%M%S").isoformat()
lastactiontime = datetime.datetime.strptime(lastaction, "%d%m%Y%H%M%S").isoformat()
except ValueError:
logintime = ''
logouttime = ''
lastactiontime = ''
statement = Statement({
'actor': Agent({
'account': AgentAccount({
'name': userid,
}),
}),
'verb': Verb({
'id': 'http://la.uoc.edu/verb/login',
'display': LanguageMap({'en-US': 'Login'}),
}),
'object': Activity({
'id': 'http://la.uoc.edu/object/login',
'definition': ActivityDefinition({
'extensions': Extensions({
'edu:uoc:la:campus': {
'userid': userid,
},
'edu:uoc:la:login': {
'login': logintime,
'logout': logouttime,
'lastactiontime': lastactiontime,
},
})
})
}),
'result': Result({
}),
'timestamp': datetime.datetime.utcnow(),
'context': Context({
'registration': uuid.uuid4(),
})
})
return json.loads(statement.to_json())
def test_ToJSON(self):
statement = Statement(
**{'id': '016699c6-d600-48a7-96ab-86187498f16f', 'actor': {'name': 'test'}, 'verb': {'id': 'test'},
'object': {'object_type': 'Agent', 'name': 'test'}, 'authority': {'name': 'test'},
'context': {'registration': '016699c6-d600-48a7-96ab-86187498f16f'},
'attachments': [{'usage_type': 'test'}]})
self.assertEqual(statement.to_json(),
'{"verb": {"id": "test"}, '
'"attachments": [{"usageType": "test"}], '
'"object": {"name": "test", "objectType": "Agent"}, '
'"actor": {"name": "test", "objectType": "Agent"}, '
'"version": "1.0.1", '
'"authority": {"name": "test", "objectType": "Agent"}, '
'"context": {"registration": "016699c6-d600-48a7-96ab-86187498f16f"}, '
'"id": "016699c6-d600-48a7-96ab-86187498f16f"}')
def test_FromJSONToJSON(self):
json_str = '{"id":"016699c6-d600-48a7-96ab-86187498f16f", ' \
'"actor": {"name":"test"}, ' \
'"verb": {"id":"test"}, ' \
'"object": {"object_type":"Agent", "name":"test"}, ' \
'"authority":{ "name":"test"}, ' \
'"context": {"registration":"016699c6-d600-48a7-96ab-86187498f16f"}, ' \
'"attachments":[{"usage_type":"test"}]}'
statement = Statement.from_json(json_str)
self.assertEqual(statement.id, uuid.UUID('016699c6-d600-48a7-96ab-86187498f16f'))
self.agentVerificationHelper(statement.actor)
self.verbVerificationHelper(statement.verb)
self.agentVerificationHelper(statement.object)
self.agentVerificationHelper(statement.authority)
self.contextVerificationHelper(statement.context)
for k in statement.attachments:
self.attachmentVerificationHelper(k)
self.assertEqual(statement.to_json(),
'{"verb": {"id": "test"}, '
'"attachments": [{"usageType": "test"}], '
'"object": {"name": "test", "objectType": "Agent"}, '
'"actor": {"name": "test", "objectType": "Agent"}, '
'"version": "1.0.1", '
'"authority": {"name": "test", "objectType": "Agent"}, '
'"context": {"registration": "016699c6-d600-48a7-96ab-86187498f16f"}, '
'"id": "016699c6-d600-48a7-96ab-86187498f16f"}')
def create_AEP_statement(row):
cod_element, estat_solicitud, any_acad_valida, desc_estat, any_academico, idp, num_expedient, asigna_clase, estat, num_creditos, cod_plan = row
statement = Statement({
'actor': Agent({
'account': AgentAccount({
'name': idp,
}),
}),
'verb': Verb({
'id': 'http://la.uoc.edu/verb/aeprequest',
'display': LanguageMap({'en-US': 'AEP Request'}),
}),
'object': Activity({
'id': 'http://la.uoc.edu/object/subject/code/%s' % cod_element,
'definition': ActivityDefinition({
'extensions': Extensions({
'edu:uoc:la:subject': {
'code': cod_element,
'credits': num_creditos,
},
'edu:uoc:la:plan': {
'code': cod_plan,
},
'edu:uoc:la:semester': {
'code': any_academico,
'validated': any_acad_valida,
},
'edu:uoc:la:expedient': {
'code': num_expedient,
},
'edu:uoc:la:aep': {
'status': estat,
'classification': asigna_clase
}
})
})
}),
'result': Result({
'success': estat == 'A',
}),
'timestamp': datetime.datetime.utcnow(),
'context': Context({
'registration': uuid.uuid4(),
})
})
return json.loads(statement.to_json())
def test_InitId(self):
statement = Statement(id='016699c6-d600-48a7-96ab-86187498f16f')
self.assertEquals(statement.id, uuid.UUID('016699c6-d600-48a7-96ab-86187498f16f'))
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
def test_InitDifferentNamingObject(self):
statement = Statement(object={'objectType': 'Agent', 'name': 'test'})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.agentVerificationHelper(statement.object)
def test_InitAnonAuthority(self):
statement = Statement(authority={'name': 'test'})
self.assertIsNone(statement.id)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.actor)
self.agentVerificationHelper(statement.authority)
def test_InitAnonGroupActor(self):
statement = Statement(actor={'member': [Agent(name='test')], 'object_type': 'Group'})
self.assertIsNone(statement.id)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.groupVerificationHelper(statement.actor)
def test_InitStatementRefObject(self):
statement = Statement(object=StatementRef(object_type='StatementRef'))
self.assertIsNone(statement.id)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.statementrefVerificationHelper(statement.object)
def test_InitEmptyAuthority(self):
statement = Statement(authority={})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsInstance(statement.authority, Agent)
def test_InitEmptyObject(self):
statement = Statement(object={})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsInstance(statement.object, Activity)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
def test_InitEmptyVerb(self):
statement = Statement(verb={})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsInstance(statement.verb, Verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
def test_InitVerb(self):
statement = Statement(verb=Verb(id='test'))
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.verbVerificationHelper(statement.verb)
def test_InitAgentActor(self):
statement = Statement(actor=Agent(name='test'))
self.assertIsNone(statement.id)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.agentVerificationHelper(statement.actor)
def test_InitAnonObject(self):
statement = Statement(object={'id': 'test'})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.activityVerificationHelper(statement.object)
def test_InitEmpty(self):
statement = Statement()
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
def test_InitGroupActor(self):
statement = Statement(actor=Group(member=[Agent(name='test')]))
self.assertIsNone(statement.id)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.groupVerificationHelper(statement.actor)
def test_save_statement(self):
statement = Statement(actor=self.agent,
verb=self.verb,
object=self.activity)
response = self.lrs.save_statement(statement)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self.assertIsNotNone(response.content.id)
self._vars_verifier(statement, response.content,
['_authority', '_stored'])
def test_save_statement_ref(self):
statement = Statement(actor=self.agent,
verb=self.verb,
object=self.statement_ref,
id=str(uuid.uuid4()))
response = self.lrs.save_statement(statement)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self._vars_verifier(statement, response.content,
['_authority', '_stored'])
def sendstatement_left_session(self, conn):
# http://activitystrea.ms/schema/1.0/leave
verb = Verb(
id='http://activitystrea.ms/schema/1.0/leave',
display=LanguageMap({'en-US': 'left'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._session_object)
self._send_to_LRS(statement)
def test_save_statements(self):
statement1 = Statement(actor=self.agent,
verb=self.verb,
object=self.activity)
statement2 = Statement(actor=self.agent,
verb=self.verb,
object=self.activity,
context=self.context)
response = self.lrs.save_statements(
StatementList([statement1, statement2]))
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self.assertIsNotNone(response.content[0].id)
self.assertIsNotNone(response.content[1].id)
self._vars_verifier(statement1, response.content[0],
['_authority', '_stored'])
self._vars_verifier(statement2, response.content[1],
['_authority', '_stored'])
def test_InitVersion(self):
statement = Statement(version='test')
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.assertEqual(statement.version, 'test')
def sendstatement_initialized_presentation(self, conn):
# sent when a participant's browser has finished loading the revealjs presentation
verb = Verb(
id='http://adlnet.gov/expapi/verbs/initialized',
display=LanguageMap({'en-US': 'initialized'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object)
self._send_to_LRS(statement)
def test_InitContext(self):
statement = Statement(context=Context(registration='016699c6-d600-48a7-96ab-86187498f16f'))
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.contextVerificationHelper(statement.context)
def test_InitEmptyAttachments(self):
statement = Statement(attachments=[])
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.assertEqual(statement.attachments, [])
def test_InitResult(self):
statement = Statement(result=Result(duration=timedelta(days=7)))
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.resultVerificationHelper(statement.result)
def test_InitEmptyResult(self):
statement = Statement(result={})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.assertIsInstance(statement.result, Result)
def test_InitEmptyContext(self):
statement = Statement(context={})
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.assertIsInstance(statement.context, Context)
def test_query_statements_no_microsecond(self):
tstamp = utc.localize(datetime.utcnow())
s1 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()),
timestamp=tstamp)
self.lrs.save_statement(s1)
s2 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()),
timestamp=tstamp)
self.lrs.save_statement(s2)
s3 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()),
timestamp=tstamp)
self.lrs.save_statement(s3)
query = {
"agent": self.agent,
"verb": self.verb,
"activity": self.parent,
"related_activities": True,
"related_agents": True,
"limit": 2
}
response = self.lrs.query_statements(query)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self.assertIsInstance(response.content, StatementsResult)
self.assertTrue(hasattr(response.content, 'more'))
self.assertIsNotNone(response.content.more)
self._vars_verifier(s1, response.content.statements[0])
self._vars_verifier(s2, response.content.statements[1])
def test_save_statement_group(self):
statement = Statement(actor=self.agent,
verb=self.verb,
object=self.group,
id=str(uuid.uuid4()))
response = self.lrs.save_statement(statement)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self._vars_verifier(statement, response.content)
def test_InitAttachments(self):
statement = Statement(attachments=[Attachment(usage_type='test')])
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.verb)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
for k in statement.attachments:
self.attachmentVerificationHelper(k)
def sendstatement_completed_slide(self, conn, slide_info):
# sent when a participant's presentation leaves the current slide (we want to record duration)
# slide_info includes title (could be None) indexh and indexv
verb = Verb(
id='http://adlnet.gov/expapi/verbs/completed',
display=LanguageMap({'en-US': 'completed'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._make_slide_object(slide_info))
self._send_to_LRS(statement)
def statement_builder(actor, verb, object, context, result, timestamp=None):
statement = None
if timestamp is None:
statement = Statement(
actor=actor,
verb=verb,
object=object,
context=context,
result=result,
)
else:
statement = Statement(
actor=actor,
verb=verb,
object=object,
context=context,
result=result,
timestamp=timestamp
)
return statement
def thread_function(stack):
for i in range(len(stack)):
s = stack[i]
statement = Statement.from_json(s)
if debug_log_print:
print("Tracing: Sending statement number {} from stack".format(
i + 1))
if not _send_statement_lrs(
statement): # Send statement and receive HTTP response
io.add_statement(
statement) # Backup the statement if it couldn't been sent
def process_data(x, lines):
i = 0
for row in lines:
event = json.loads(row)
try:
dt = dateutil.parser.parse(event['time'])
except ValueError:
print 'Data error -> ', event['time']
continue
# event['context']['user_id'] = 6 # used only for local test, comment in the real environment
user_id = event['context'].get('user_id')
if user_id == '':
continue
# Search for events of same user in the same date (seconds precision)
tls = TrackingLog.objects.filter(dtcreated=xutils.make_datetime_for_tincan(dt), user_id=user_id)
if tls:
differentMillis = True
for t in tls:
statement = Statement.from_json(t.statement)
try:
t_event = statement.context.extensions['time_with_millis']
if t_event == event['time']:
differentMillis = False
break
except: # pylint: disable=bare-except
pass
if differentMillis:
i = i + 1
x.process_event(event)
else:
# Skip duplicate events
# print "Tracking event already exists for dt: %s and user_id : %s ", event['time'], user_id
# print event
pass
else:
i = i + 1
x.process_event(event)
print "%s events sent to backend", str(i)
# otherwise create a standard object
else:
obj = ACTIVITY_ROUTES[eventname](row['objecttable'], row['objectid'], row['contextinstanceid'])
# Context can be built off the object
row['object'] = obj.TYPE_EN
context = obj.getContext(row)
# Timestamp
timestamp = datetime.fromtimestamp(row['timecreated']).strftime('%Y-%m-%dT%H:%M:%S') + config.TIMEZONE
# Create a statement of information
statement = Statement(
actor=actor,
verb=obj.getVerb(),
result=obj.getResult(),
object=obj.getObject(),
context=context,
timestamp=timestamp
)
# Commit the statement
response = lrs.save_statement(statement)
if not response.success:
# TODO : Format proper error here
responseObject = json.loads(response.data)
logging.error("Failed to insert statement for logID: '%s' for eventname = '%s'"%(row['id'], row['eventname']))
print statement.to_json()
print str(responseObject['message'][0])
sys.exit(5)
except moodleObjects.moodleCritical as e:
def test_ToJSONEmpty(self):
statement = Statement()
self.assertEqual(statement.to_json(), '{"version": "1.0.1"}')
def test_ToJSONEmpty(self):
statement = Statement()
self.assertEqual(statement.to_json(), '{}')
