def test_status_categories(self):
self.assertFalse(is_informational(99))
self.assertTrue(is_informational(100))
self.assertTrue(is_informational(199))
self.assertFalse(is_informational(200))
self.assertFalse(is_success(199))
self.assertTrue(is_success(200))
self.assertTrue(is_success(299))
self.assertFalse(is_success(300))
self.assertFalse(is_redirect(299))
self.assertTrue(is_redirect(300))
self.assertTrue(is_redirect(399))
self.assertFalse(is_redirect(400))
self.assertFalse(is_client_error(399))
self.assertTrue(is_client_error(400))
self.assertTrue(is_client_error(499))
self.assertFalse(is_client_error(500))
self.assertFalse(is_server_error(499))
self.assertTrue(is_server_error(500))
self.assertTrue(is_server_error(599))
self.assertFalse(is_server_error(600))
def test_survey_response_smoke_test(self, survey_response):
client = Client()
username = "******"
email = "*****@*****.**"
password = "******"
u = User.objects.create_user(username, email, password)
login = client.login(username=username, password=password)
self.assertTrue(login)
response = client.post(reverse("response-list"), json.dumps(survey_response), content_type="application/json")
self.assertFalse(status.is_server_error(response.status_code), response.json())
# Make a survey
s = {"owner": u.id, "name": "a title", "schema": EXAMPLE_SCHEMA}
response = client.post(reverse("survey-list"), json.dumps(s), content_type="application/json")
self.assertTrue(status.is_success(response.status_code), response.content)
# Upload the result again
survey_response["survey"] = response.json()["id"]
response = client.post(reverse("response-list"), json.dumps(survey_response), content_type="application/json")
self.assertTrue(status.is_success(response.status_code), response.content)
self.crawl("http://testserver" + reverse("api-root"), seen=[])
def test_get(self):
"""
GET should not work.
"""
response = self.client.get('/')
self.assertFalse(status.is_success(response.status_code))
response = self.client.get('/test')
self.assertFalse(status.is_success(response.status_code))
def test_url_available(self):
print "\n Try if the links are available\n" \
"Expect to get the success code\n"
index_url = reverse("index")
response = self.client.get(index_url)
self.assertTrue(status.is_success(response.status_code))
print "got index\n"
post_list_url = reverse("post-list")
response = self.client.get(post_list_url)
self.assertTrue(status.is_success(response.status_code))
print "got api blog list\n"
def test_add_term_to_taxonomy():
# TODO: Use API to create taxonomy
taxonomy = TaxonomyFactory(name='Test Ebola Questions')
response1 = add_term(taxonomy=taxonomy.slug, name='Vaccine')
response2 = add_term(taxonomy=taxonomy.slug, name='Time')
assert status.is_success(response1.status_code), response1.data
assert status.is_success(response2.status_code), response2.data
terms = get_terms(taxonomy.slug).data
assert len(terms) == 2
assert all(term['taxonomy'] == taxonomy.slug for term in terms)
def get_taxonomies():
request = APIRequestFactory().get("")
view = TaxonomyViewSet.as_view(actions={'get': 'list'})
response = view(request)
assert status.is_success(response.status_code), response.data
return response
def create_item(**kwargs):
request = APIRequestFactory().post('/items', kwargs)
view = ItemViewSet.as_view(actions={'post': 'create'})
response = view(request)
assert status.is_success(response.status_code), response.data
return response
def get_terms(taxonomy_slug):
request = APIRequestFactory().get("", data={'taxonomy': taxonomy_slug})
view = TermViewSet.as_view(actions={'get': 'list'})
response = view(request)
assert status.is_success(response.status_code), response.data
return response
def test_files_direct_upload(self):
filename = os.path.join(os.path.dirname(__file__), "testimage.png")
with open(filename, 'rb') as f:
response = self.client.post('/files.json', {"file": f})
self.assertTrue(
status.is_success(response.status_code), response.data
)
fileid = response.data['id']
# is_image model/serializer property should be set
self.assertEqual(response.data['is_image'], True)
# File should not still be open after upload is completed
instance = File.objects.get(pk=fileid)
self.assertTrue(instance.file.closed)
# Width and height on images should be set automatically
self.assertEqual(instance.width, 1)
self.assertEqual(instance.height, 1)
# If mimetype parameter is accessed after file is saved, the mimetype
# should come from the FileType and the actual file should not be
# read again.
del instance.file._file
self.assertEqual(instance.mimetype, "image/png")
self.assertFalse(hasattr(instance.file, "_file"))
def test_files_attachment_multi(self):
filename1 = os.path.join(os.path.dirname(__file__), "testimage.png")
filename2 = os.path.join(os.path.dirname(__file__), "version.txt")
with open(filename1, 'rb') as f1:
with open(filename2, 'rb') as f2:
response = self.client.post('/photoattachedmodels.json', {
"name": "Test Photo",
"photos": [f1, f2]
})
self.assertTrue(
status.is_success(response.status_code), response.data
)
self.assertEqual(response.data['name'], "Test Photo")
self.assertIn("photos", response.data)
self.assertEqual(len(response.data['photos']), 2)
photo = None
text = None
for row in response.data['photos']:
if row['is_image']:
photo = row
else:
text = row
self.assertEqual(photo['width'], 1)
self.assertEqual(photo['name'], "testimage.png")
self.assertIn("photos/testimage", photo['file'])
self.assertEqual(text['width'], None)
self.assertEqual(text['name'], "version.txt")
self.assertIn("photos/version", text['file'])
def test_rest_custom_lookup_fk(self):
SlugModel.objects.create(
code='test1',
name='Test #1',
)
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test1',
'name': "Test FK",
})
self.assertTrue(status.is_success(response.status_code), response.data)
rid = response.data.get('id')
self.assertEqual(response.data, {
'id': rid,
'label': 'Test FK (Test #1)',
'name': 'Test FK',
'ref_id': 'test1',
'ref_label': 'Test #1',
})
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test_invalid',
'name': "Test FK",
})
self.assertTrue(
status.is_client_error(response.status_code), response.data
)
self.assertEqual(response.data, {
'ref_id': ['Object with code=test_invalid does not exist.']
})
def test_activities_endpoint(self):
url = reverse('activities:activity-list')
expect_url = '/api/activities/'
msg = 'activities endpoint should be located at {0}'
assert url == expect_url, msg.format(expect_url)
response = self.c.get(url)
self.assertTrue(status.is_success(response.status_code))
def add_terms(item_id, taxonomy_slug, names):
""" Add named terms `names` within the Taxonomy with `taxonomy_slug` to the
Item with id `item_id`
args:
item_id: e.g. 67
taxonomy_slug: e.g. 'ebola-questions'
names: names of terms in the Taxonomy with given slug
returns:
response from the server
raises:
TransportException on failure
The taxonomy must already exist. If the taxonomy is open, any terms that
do not exist will be created, otherwise an exception will be raised.
"""
view = get_view({'post': 'add_terms'})
terms = {'taxonomy': taxonomy_slug, 'name': names}
request = request_factory.post('', terms)
response = view(request, item_pk=item_id)
if status.is_success(response.status_code):
return response.data
else:
response.data['status_code'] = response.status_code
response.data['terms'] = terms
response.data['item_id'] = item_id
raise TransportException(response.data)
return response.data
def test_activity_detail_endpoint(self):
url = reverse('activities:activity-detail', args={self.activity.pk})
msg = 'activity detail endpoint should be located at {0}'
expect_url = '/api/activities/{}/'.format(self.activity.pk)
assert url == expect_url, msg.format(expect_url)
response = self.c.get(url)
self.assertTrue(status.is_success(response.status_code))
def list(**kwargs):
""" Return a list of Terms
If keyword arguments are given, they are used
to filter the terms. This can be used to list
the terms in a given taxonomy.
Args:
**kwargs: Filters
Returns:
list: List of terms
Raises:
TransportException: On transport failure.
'status_code' is set to the response
status code.
"""
view = get_view(actions={'get': 'list'})
request = request_factory.get("", kwargs)
response = view(request)
if not status.is_success(response.status_code):
response.data['status_code'] = response.status_code
raise TransportException(response.data)
return response.data
def test_rest_cache_filter(self):
other_user = User.objects.create(username='******')
UserManagedModel.objects.create(id=2, user=other_user)
UserManagedModel.objects.create(id=3, user=other_user)
for auth in False, True:
if auth:
self.client.force_authenticate(self.user)
tests = [
(3, 1 if auth else 0, '/usermanagedmodels.json'),
(3, 3, '/usermanagedmodels/'),
(3, 3, '/usermanagedmodels.json?page=1'),
(1, 1, '/usermanagedmodels.json?user_id=%s' % self.user.pk),
(2, 2, '/usermanagedmodels.json?user_id=%s' % other_user.pk),
]
for expect_count, expect_items, url in tests:
response = self.client.get(url)
self.assertTrue(
status.is_success(response.status_code), response.data
)
self.assertEqual(
len(response.data['list']), expect_items,
"%s should return %s items for %s" % (
url, expect_items,
"authed user" if auth else "anonymous user"
)
)
self.assertEqual(response.data['pages'], 1)
self.assertEqual(response.data['per_page'], 50)
self.assertEqual(response.data['count'], expect_count)
def test_marker_collection(self, mock_serializer):
map_id = 1
returnvalue = {"id": 1,
"canvas_course_id": 73,
"title": "title",
"latitude": "43",
"longitude": "72",
"zoom": 4,
"maptype": 1,
"thumbnail": "https://maps.googleapis.com/maps/api/staticmap?center=43,72&zoom=4&size=200x150&maptype=satellite",
"markers": [{"title": "title",
"map": 1,
"latitude": "24",
"longitude": "25",
"description": "description",
"external_url": "blank",
"created_by_id": "huid",
"created_by_full_name": "name",
"modified_by_id": "huid",
"date_created": "2015-09-12T03:26:23.222000Z",
"date_modified": "2015-09-12T03:26:23.222000Z"}],
"date_created": "2015-09-12T03:26:23.222000Z",
"date_modified": "2015-09-12T03:26:23.222000Z",
"created_by_id": "huid",
"created_by_full_name": "name",
"modified_by_id": "huid",
"description": "description"}
mock_serializer.return_value = SerializerStub(returnvalue)
result = map_location(self.request, map_id)
self.assertTrue(status.is_success(result.status_code))
self.assertEqual(json.loads(result.render().content), returnvalue)
def test_initiator_zero_reason_behaviours(self):
"""Evaluate whether trades with zero value are properly accepted
and commenting rules enforced"""
Scenario = namedtuple('Scenario',
['create_draft_first', 'zero_reason', 'create_a_comment'])
Results = namedtuple('Results', ['saving_draft_succeeds', 'proposing_trade_succeeds'])
expected_results = {}
expected_results[Scenario(True, self.zero_reason['other'], False)] = Results(True, False)
expected_results[Scenario(True, self.zero_reason['other'], True)] = Results(True, True)
expected_results[Scenario(False, self.zero_reason['other'], None)] = Results(None, False)
expected_results[Scenario(False, self.zero_reason['affiliate'], None)]\
= Results(None, True)
expected_results[Scenario(True, self.zero_reason['affiliate'], False)]\
= Results(True, True)
expected_results[Scenario(True, self.zero_reason['affiliate'], True)]\
= Results(True, True)
expected_results[Scenario(False, None, None)] = Results(None, False)
expected_results[Scenario(True, None, False)] = Results(False, False)
expected_results[Scenario(True, None, True)] = Results(False, False)
initiating_org = self.users[
self.user_map[
self.UserRelationship.INITIATOR
]].organization
responding_org = self.users[
self.user_map[
self.UserRelationship.RESPONDENT
]].organization
for scenario, result in expected_results.items():
with self.subTest("evaluating scenario",
scenario=scenario,
res=result):
payload = {
'fairMarketValuePerCredit': 0.0,
'initiator': initiating_org.id,
'numberOfCredits': 1,
'respondent': responding_org.id,
'tradeEffectiveDate': datetime.datetime.today().strftime('%Y-%m-%d'),
'type': self.credit_trade_types['sell'].id,
'zeroReason': scenario.zero_reason.id if scenario.zero_reason else None,
}
if scenario.create_draft_first:
payload['status'] = self.statuses['draft'].id
response = self.clients[self.user_map[self.UserRelationship.INITIATOR]].post(
'/api/credit_trades',
content_type='application/json',
data=json.dumps(payload)
)
self.assertEqual(status.is_success(response.status_code),
result.saving_draft_succeeds)
ct_id = response.data['id'] if 'id' in response.data else None
if scenario.create_a_comment and result.saving_draft_succeeds:
response = self.clients[self.user_map[self.UserRelationship.INITIATOR]]. \
post(
'/api/comments',
content_type='application/json',
data=json.dumps({
"comment": "explanatory comment",
"creditTrade": ct_id,
"privilegedAccess": False
})
)
self.assertTrue(status.is_success(response.status_code))
if result.saving_draft_succeeds:
payload['status'] = self.statuses['submitted'].id
response = self.clients[self.user_map[self.UserRelationship.INITIATOR]]. \
put(
'/api/credit_trades/{}'.format(ct_id),
content_type='application/json',
data=json.dumps(payload)
)
self.assertEqual(status.is_success(response.status_code),
result.proposing_trade_succeeds)
else:
payload['status'] = self.statuses['submitted'].id
response = self.clients[self.user_map[self.UserRelationship.INITIATOR]].post(
'/api/credit_trades',
content_type='application/json',
data=json.dumps(payload)
)
self.assertEqual(status.is_success(response.status_code),
result.proposing_trade_succeeds)
def test_rest_default_per_page(self):
response = self.client.get('/parents.json')
self.assertTrue(status.is_success(response.status_code), response.data)
self.assertEqual(response.data['per_page'], 50)
def test_create_random_column_datetime_form(self):
"""Create a random number column with no values"""
# Get the workflow first
self.workflow = models.Workflow.objects.all().first()
# Column name and current number of them
cname = 'random_column'
ncols = self.workflow.ncols
# JSON POST request for column creation with incorrect string value
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'datetime',
'raw_categories': 'bogus',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNone(new_column)
# JSON POST request for column creation with a single integer
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'datetime',
'raw_categories':
'2020-09-11 12:04:43+0930',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNone(new_column)
# JSON POST request for column creation with a multiple strings
dtimes = [
parse_datetime('2020-09-11 12:04:43+0930'),
parse_datetime('2020-09-12 12:04:43+0930')
]
resp = self.get_response(
'column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'datetime',
'raw_categories':
'2020-09-11 12:04:43+0930, 2020-09-12 12:04:43+0930',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' not in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols + 1)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNotNone(new_column)
self.assertEqual(new_column.name, cname)
self.assertEqual(new_column.data_type, 'datetime')
data_frame = pandas.load_table(
self.workflow.get_data_frame_table_name())
self.assertTrue(all(element in dtimes
for element in data_frame[cname]))
# Delete the column
services.delete_column(self.workflow.user, self.workflow, new_column)
def test_rest_custom_lookup(self):
response = self.client.get('/slugmodels/test.json')
self.assertTrue(status.is_success(response.status_code), response.data)
self.assertEqual(response.data['id'], 'test')
def test_sql_update_create(self):
"""Create a new SQL Scheduled operation."""
initial_df = self.workflow.data_frame()
# Create the new table in the DB for the scheduled operation
with connection.connection.cursor() as cursor:
# Add the extra table to the database for the merge
for query, fields in SQL_QUERIES:
cursor.execute(query, fields)
# Save some current variables for future checks
current_ops = models.ScheduledOperation.objects.count()
current_tasks = PeriodicTask.objects.count()
current_nrows = self.workflow.nrows
current_columns = self.workflow.ncols
# Index page should be ok
resp = self.get_response('scheduler:index')
self.assertTrue(status.is_success(resp.status_code))
# GET the page to select the SQL connection
resp = self.get_response('scheduler:select_sql')
self.assertTrue(status.is_success(resp.status_code))
for sql_conn in models.SQLConnection.objects.all():
self.assertTrue(sql_conn.name in str(resp.content))
# Get the connection pointing to localhost
sql_conn = models.SQLConnection.objects.get(name='remote server 2')
# Modify connection to point to the test DB
sql_conn.db_name = settings.DATABASE_URL['NAME']
sql_conn.save(update_fields=['db_name'])
# GET the form to create the scheduled SQL operation
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)})
self.assertTrue(status.is_success(resp.status_code))
# POST incorrect form without a dst key
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'src_key': 'email',
'how_merge': 'outer',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertIn('operation requires the names', str(resp.content))
# POST incorrect form without a src key
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'dst_key': 'email',
'how_merge': 'outer',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertIn('operation requires the names', str(resp.content))
# POST incorrect form without a non-existent dst_key
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'dst_key': 'INCORRECT NAME',
'src_key': 'email',
'how_merge': 'outer',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertIn('is not a key column', str(resp.content))
# POST incorrect form without an incorrect dst_key
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'dst_key': 'Gender',
'src_key': 'email',
'how_merge': 'outer',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertIn('is not a key column', str(resp.content))
# POST incorrect form without a merge method
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'dst_key': 'Gender',
'src_key': 'email',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertIn('requires a merge method', str(resp.content))
# POST the correct form to create the SQL operation
resp = self.get_response('scheduler:sqlupload',
{'pk': str(sql_conn.id)},
method='POST',
req_params={
'name': 'schedule sql upload',
'execute': '05/31/2999 14:35',
'dst_key': 'email',
'src_key': 'email',
'how_merge': 'outer',
'db_password': '******'
})
self.assertTrue(status.is_success(resp.status_code))
self.assertEqual(current_ops + 1,
models.ScheduledOperation.objects.count())
# Execute the operation
s_item = self.workflow.scheduled_operations.get(
name='schedule sql upload')
tasks.execute_scheduled_operation(s_item.id)
# Verify the result of the operation
s_item.refresh_from_db()
self.workflow.refresh_from_db()
# Identical number of tasks pending than at the start
self.assertEqual(current_tasks + 1, PeriodicTask.objects.count())
# Operation must have status equal to DONE
self.assertEqual(s_item.status, models.scheduler.STATUS_DONE)
# Operation execution time must be reflected in the log field
self.assertIsNotNone(s_item.last_executed_log)
# Number of rows and columns in workflow has changed
self.assertEqual(self.workflow.nrows, current_nrows + 3)
self.assertEqual(self.workflow.ncols, current_columns + 1)
# New column with the right name and type
new_column = self.workflow.columns.filter(name='NEW COLUMN').first()
self.assertIsNotNone(new_column)
self.assertEqual(new_column.data_type, 'double')
result_df = self.workflow.data_frame()
# New rows with the right email
email_values = list(result_df['email'])
self.assertIn('*****@*****.**', email_values)
self.assertIn('*****@*****.**', email_values)
self.assertIn('*****@*****.**', email_values)
# Columns with the right value
old_hecs_count = initial_df['Enrolment Type'].loc[
initial_df['Enrolment Type'] == 'Local'].count()
new_hecs_count = result_df['Enrolment Type'].loc[
result_df['Enrolment Type'] == 'Local'].count()
self.assertEqual(old_hecs_count + 6, new_hecs_count)
self.assertEqual(result_df['NEW COLUMN'].count(), 6)
def test_rest_detail_at_root(self):
response = self.client.get('/instance.json')
self.assertTrue(status.is_success(response.status_code), response.data)
self.assertTrue(response.data['description'] == "Test")
def test_rest_list_at_root(self):
response = self.client.get("/.json")
self.assertTrue(status.is_success(response.status_code), response.data)
self.assertTrue(len(response.data['list']) == 1)
def test_rest_limit(self):
response = self.client.get('/children.json?limit=10')
self.assertTrue(status.is_success(response.status_code), response.data)
self.assertEqual(response.data['per_page'], 10)
def test_get_todos_success(self):
""" GET with auth should return a 2XX """
self.client.force_authenticate(self.user)
response = self.client.get(self.URL)
self.assertTrue(status.is_success(response.status_code))
def test_home():
response = http.get(path='/')
assert status.is_success(response.status_code)
def test_schedule_email(self):
action_name = 'simple action'
s_subject = 'subject'
# Get list of workflows
response = self.client.get(reverse('scheduler:api_scheduled_email'))
self.assertEqual(response.data['count'], 0)
self.assertEqual(response.data['next'], None)
self.assertEqual(response.data['previous'], None)
# Get the action
action = models.Action.objects.get(name=action_name,
workflow__name='wflow1')
# Schedule one of the actions
response = self.client.post(reverse('scheduler:api_scheduled_email'), {
'name': self.s_name,
'description_text': self.s_desc,
'operation_type': 'action_run_personalized_email',
'workflow': action.workflow.id,
'action': action.id,
'execute': self.s_execute,
'payload': {
'item_column': 'email',
'subject': s_subject,
'cc_email': '',
'bcc_email': '',
'track_read': False,
'send_confirmation': False,
},
},
format='json')
# Element has been scheduled
self.assertEqual(response.status_code, 201)
sch_item = models.ScheduledOperation.objects.get(action=action)
self.assertEqual(sch_item.name, self.s_name)
self.assertEqual(sch_item.description_text, self.s_desc)
self.assertEqual(sch_item.action, action)
self.assertEqual(sch_item.payload['subject'], s_subject)
# Update the element
response = self.client.put(reverse(
'scheduler:api_rud_email', kwargs={'pk': sch_item.id}), {
'name': self.s_name + '2',
'description_text': self.s_desc,
'operation_type': 'action_run_personalized_email',
'workflow': action.workflow.id,
'action': action.id,
'execute': self.s_execute,
'payload': {
'item_column': 'email',
'subject': s_subject,
'cc_email': '',
'bcc_email': '',
'track_read': False,
'send_confirmation': False
}
},
format='json')
# Element has been scheduled
self.assertTrue(status.is_success(response.status_code))
sch_item = models.ScheduledOperation.objects.get(action=action)
self.assertEqual(sch_item.name, self.s_name + '2')
# Delete the element
response = self.client.delete(
reverse('scheduler:api_rud_email', kwargs={'pk': sch_item.id}))
self.assertEqual(response.status_code, 204)
def test_request_get(self):
self.get_new_band()
response = self.api_client.get(self.url)
assert status.is_success(response.status_code)
assert len(response.json()['results']) >= 1
def test_accounts_device_get(self):
data = {
'id': 'test-device-id',
}
response = client.get('/accounts/device', data=data, follow=True)
assert status.is_success(response.status_code)
def test_schedule_json(self):
action_name = 'json action'
# Get list of workflows
response = self.client.get(reverse('scheduler:api_scheduled_json'))
self.assertEqual(response.data['count'], 0)
self.assertEqual(response.data['next'], None)
self.assertEqual(response.data['previous'], None)
# Get the action
action = models.Action.objects.get(name=action_name,
workflow__name='wflow1')
# Schedule one of the actions
response = self.client.post(reverse('scheduler:api_scheduled_json'), {
'name': self.s_name,
'description_text': self.s_desc,
'operation_type': 'action_run_personalized_json',
'workflow': action.workflow.id,
'action': action.id,
'execute': self.s_execute,
'payload': {
'item_column': 'email',
'token': 'whatever',
'field1': 'value1',
'field2': 'value2',
},
},
format='json')
# Element has been created
self.assertEqual(response.status_code, 201)
sch_item = models.ScheduledOperation.objects.get(action=action)
self.assertEqual(sch_item.name, self.s_name)
self.assertEqual(sch_item.description_text, self.s_desc)
self.assertEqual(sch_item.action, action)
# Update the element
response = self.client.put(reverse(
'scheduler:api_rud_json', kwargs={'pk': sch_item.id}), {
'name': self.s_name + '2',
'description_text': self.s_desc,
'operation_type': 'action_run_personalized_json',
'workflow': action.workflow.id,
'action': action.id,
'execute': self.s_execute,
'payload': {
'item_column': 'email',
'token': 'whatever',
'field1': 'value1',
'field2': 'value2',
},
},
format='json')
# Element has been scheduled
self.assertTrue(status.is_success(response.status_code))
sch_item = models.ScheduledOperation.objects.get(action=action)
self.assertEqual(sch_item.name, self.s_name + '2')
# Delete the element
response = self.client.delete(
reverse('scheduler:api_rud_json', kwargs={'pk': sch_item.id}))
self.assertEqual(response.status_code, 204)
# Schedule the action with the wrong function
response = self.client.post(reverse('scheduler:api_scheduled_email'), {
'name': self.s_name,
'description_text': self.s_desc,
'operation_type': 'action_run_personalized_json',
'workflow': action.workflow.id,
'action': action.id,
'execute': self.s_execute,
'payload': {
'item_column': 'email',
'token': 'whatever',
'field1': 'value1',
'field2': 'value2',
},
},
format='json')
# Element has NOT been created
self.assertEqual(response.status_code, 500)
def download_worker(request, url, filepath):
taskname = request.GET.get('taskname', '')
if taskname == 'aio_update':
logtype = OperationLog.TYPE_UPDATE_AIO_BASE
if taskname == 'iso_update':
logtype = OperationLog.TYPE_UPDATE_AIO_ISO
if taskname == 'driver_update':
logtype = OperationLog.TYPE_UPDATE_AIO_DRIVE
r = requests.get(url, stream=True, verify=False)
if not status.is_success(r.status_code):
SaveOperationLog(
request.user, logtype,
json.dumps(
{
'失败': '下载文件失败，状态码:{}'.format(r.status_code),
'文件名': '{}'.format(url)
},
ensure_ascii=False), get_operator(request))
_logger.error('下载文件失败，状态码:{}'.format(r.status_code))
return
SaveOperationLog(
request.user, logtype,
json.dumps({
'状态': '开始下载文件',
'文件名': '{}'.format(url)
},
ensure_ascii=False), get_operator(request))
lastsize = 0
size = 0
bneedlog = True
with open(filepath, 'wb') as fd:
for chunk in r.iter_content(1024 * 1024):
size += len(chunk)
fd.write(chunk)
bneedlog = True
if size >= lastsize + 100 * 1024 * 1024:
SaveOperationLog(
request.user, logtype,
json.dumps(
{'下载状态': '已下载：{:.1f}MB'.format(size / (1024 * 1024))},
ensure_ascii=False), get_operator(request))
bneedlog = False
lastsize = size
if bneedlog:
SaveOperationLog(
request.user, logtype,
json.dumps({'下载状态': '已下载：{:.1f}MB'.format(size / (1024 * 1024))},
ensure_ascii=False), get_operator(request))
_logger.info(
'download update file finish and bigin execute update, filepath:{}'.
format(filepath))
g_thread_handle.setName('processing_' + taskname)
# 判断是否 执行更新操作
if getattr(threading.current_thread(), 'do_run', True):
processupload(filepath, request.user, get_operator(request))
try:
os.remove(filepath)
except:
pass
SaveOperationLog(
request.user, logtype,
json.dumps({
'状态': '更新完成',
'文件名': '{}'.format(url)
},
ensure_ascii=False), get_operator(request))
else:
_logger.info(
'download update file is finished, but task has been canceled and file will be remouved, filepath:{}'
.format(filepath))
SaveOperationLog(
request.user, logtype,
json.dumps({
'状态': '下载完成，任务被取消，文件将删除',
'文件名': '{}'.format(url)
},
ensure_ascii=False), get_operator(request))
try:
os.remove(filepath)
except:
pass
return
def test_get_accounts_device_list(self):
response = client.get('/accounts/device/list')
assert status.is_success(response.status_code)
def test_create_random_column_number_form(self):
"""Create a random number column with no values"""
# Get the workflow first
self.workflow = models.Workflow.objects.all().first()
# Column name and current number of them
cname = 'random_column'
ncols = self.workflow.ncols
# JSON POST request for column creation with string value
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'double',
'raw_categories': 'bogus',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNone(new_column)
# JSON POST request for column creation with a single integer
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'double',
'raw_categories': '13.0',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNone(new_column)
# JSON POST request for column creation with a multiple strings
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'double',
'raw_categories': 'one, two, three',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNone(new_column)
# JSON POST request for column creation with a interval integer
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'double',
'raw_categories': '-3.0 - -5.0',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' not in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols + 1)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNotNone(new_column)
self.assertEqual(new_column.name, cname)
self.assertEqual(new_column.data_type, 'double')
data_frame = pandas.load_table(
self.workflow.get_data_frame_table_name())
self.assertTrue(
all(element in [-3, -4, -5] for element in data_frame[cname]))
# Delete the column
services.delete_column(self.workflow.user, self.workflow, new_column)
# JSON POST request for column creation with an integer list
resp = self.get_response('column:random_column_add',
method='POST',
req_params={
'name': cname,
'data_type': 'double',
'raw_categories': '17, 18, 19',
'position': 0
},
is_ajax=True)
resp_content = json.loads(resp.content)
self.assertTrue('html_form' not in resp_content)
self.assertTrue(status.is_success(resp.status_code))
self.workflow.refresh_from_db()
self.assertEqual(self.workflow.ncols, ncols + 1)
new_column = self.workflow.columns.filter(name=cname).first()
self.assertIsNotNone(new_column)
self.assertEqual(new_column.name, cname)
self.assertEqual(new_column.data_type, 'double')
data_frame = pandas.load_table(
self.workflow.get_data_frame_table_name())
self.assertTrue(
all(element in [17, 18, 19] for element in data_frame[cname]))
def test_back_to_home_page(self):
"""Loop over all URLs and check they redirect appropriately."""
redirect = [
# Workflow
reverse('workflow:detail'),
reverse('workflow:operations'),
reverse('workflow:column_move_top', kwargs={'pk': 1}),
reverse('workflow:column_move_bottom', kwargs={'pk': 1}),
# Action
reverse('action:index'),
reverse('action:timeline'),
reverse('action:timeline', kwargs={'pk': 1}),
reverse('action:edit', kwargs={'pk': 1}),
reverse('action:export', kwargs={'pklist': '1'}),
reverse('action:import'),
reverse('action:item_filter'),
reverse('action:run', kwargs={'pk': 1}),
reverse('action:run_done'),
reverse('action:zip_action', kwargs={'pk': 1}),
reverse('action:unselect_column_action',
kwargs={
'pk': 1,
'cpk': 1
}),
reverse('action:run_survey_row', kwargs={'pk': 1}),
# Dataops
reverse('dataops:uploadmerge'),
reverse('dataops:transform'),
reverse('dataops:model'),
reverse('dataops:plugin_invoke', kwargs={'pk': 1}),
reverse('dataops:rowupdate'),
reverse('dataops:rowcreate'),
reverse('dataops:csvupload_start'),
reverse('dataops:excelupload_start'),
reverse('dataops:googlesheetupload_start'),
reverse('dataops:s3upload_start'),
reverse('dataops:upload_s2'),
reverse('dataops:upload_s3'),
reverse('dataops:upload_s4'),
reverse('dataops:sqlconns_index'),
# reverse('dataops:athenaconns_instructor_index'),
reverse('dataops:sqlupload_start', kwargs={'pk': 1}),
# reverse('dataops:athenaupload_start', kwargs={'pk': 1}),
# Logs
reverse('logs:view', kwargs={'pk': 1}),
# Table
reverse('table:display_view', kwargs={'pk': 1}),
reverse('table:view_index'),
reverse('table:stat_column', kwargs={'pk': 1}),
reverse('table:stat_table'),
reverse('table:stat_table_view', kwargs={'pk': 1}),
reverse('table:csvdownload'),
reverse('table:csvdownload_view', kwargs={'pk': 1}),
]
bad_request = [
# Workflow
reverse('workflow:column_ss'),
reverse('workflow:attribute_create'),
reverse('workflow:attribute_edit', kwargs={'pk': 0}),
reverse('workflow:attribute_delete', kwargs={'pk': 0}),
reverse('workflow:share_create'),
# 'workflow:share_delete',
reverse('workflow:column_add'),
# 'workflow:question_add',
reverse('workflow:question_add', kwargs={'pk': 1}),
reverse('workflow:formula_column_add'),
reverse('workflow:random_column_add'),
reverse('workflow:column_delete', kwargs={'pk': 1}),
reverse('workflow:column_edit', kwargs={'pk': 1}),
# 'workflow:question_edit',
reverse('workflow:column_clone', kwargs={'pk': 1}),
reverse('workflow:column_move'),
reverse('workflow:column_restrict', kwargs={'pk': 1}),
# Action
reverse('action:create'),
reverse('action:save_text', kwargs={'pk': 1}),
reverse('action:update', kwargs={'pk': 1}),
reverse('action:clone_action', kwargs={'pk': 1}),
reverse('action:delete', kwargs={'pk': 1}),
reverse('action:select_key_column_action',
kwargs={
'pk': 1,
'cpk': 1,
'key': 1
}),
reverse('action:select_column_action', kwargs={
'pk': 1,
'cpk': 1
}),
reverse('action:shuffle_questions', kwargs={'pk': 1}),
reverse('action:edit_in_select_condition',
kwargs={
'pk': 1,
'condpk': 1
}),
reverse('action:edit_in_select_condition', kwargs={'tpk': 1}),
reverse('action:show_survey_table_ss', kwargs={'pk': 1}),
reverse('action:preview', kwargs={
'pk': 1,
'idx': 0
}),
reverse('action:preview_all_false', kwargs={
'pk': 1,
'idx': 0
}),
reverse('action:showurl', kwargs={'pk': 1}),
reverse('action:edit_description', kwargs={'pk': 1}),
reverse('action:create_filter', kwargs={'pk': 1}),
reverse('action:edit_filter', kwargs={'pk': 1}),
reverse('action:delete_filter', kwargs={'pk': 1}),
reverse('action:create_condition', kwargs={'pk': 1}),
reverse('action:edit_condition', kwargs={'pk': 1}),
reverse('action:delete_condition', kwargs={'pk': 1}),
reverse('action:clone_condition', kwargs={'pk': 1}),
reverse('action:clone_condition', kwargs={
'pk': 1,
'action_pk': 1
}),
# Dataops
reverse('dataops:plugin_diagnose', kwargs={'pk': 1}),
reverse('dataops:plugin_moreinfo', kwargs={'pk': 1}),
reverse('dataops:sqlconn_view', kwargs={'pk': 1}),
# reverse('dataops:athenaconn_view', kwargs={'pk': 1}),
# Logs
reverse('logs:display_ss'),
# Table
reverse('table:display_ss'),
reverse('table:display_view_ss', kwargs={'pk': 1}),
reverse('table:row_delete'),
reverse('table:view_add'),
reverse('table:stat_column_JSON', kwargs={'pk': 1}),
reverse('table:view_edit', kwargs={'pk': 1}),
reverse('table:view_clone', kwargs={'pk': 1}),
reverse('table:view_delete', kwargs={'pk': 1}),
]
self.client.login(email='*****@*****.**', password='******')
resp = self.client.get(reverse('home'))
self.assertTrue(status.is_success(resp.status_code))
for url_name in redirect:
resp = self.client.get(url_name)
self.assertEqual(resp.status_code, status.HTTP_302_FOUND)
self.assertEqual(resp.url, reverse('home'))
for url_name in bad_request:
resp = self.client.get(url_name)
self.assertEqual(resp.status_code, 400)
