def test_login_worker_with_bad_password(self):
post_data = {}
post_data['username'] = '******'
post_data['password'] = '******'
user1 = User.objects.create_user(
username='******',
email=None,
password='******')
user1.save()
worker = WorkerEntry.objects.create(name='worker-1',
uuid=post_data['username'],
description='One Worker :)',
user=user1)
resp = self.client.post('/main/bluesteelworker/login/',
data=json.dumps(post_data),
content_type='text/plain')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(401, resp_obj['status'])
self.assertEqual('Access denied!', resp_obj['message'])
self.assertEqual(False, self.client.session.has_key('_auth_user_id'))
def test_command_output(self):
StackedMailEntry.objects.create(receiver='*****@*****.**', sender='*****@*****.**', title='Title1', content='Body1', is_sent=True)
StackedMailEntry.objects.create(receiver='*****@*****.**', sender='*****@*****.**', title='Title2', content='Body2', is_sent=False)
StackedMailEntry.objects.create(receiver='*****@*****.**', sender='*****@*****.**', title='Title3', content='Body3', is_sent=False)
StackedMailEntry.objects.create(receiver='*****@*****.**', sender='*****@*****.**', title='Title4', content='Body4', is_sent=False)
resp = self.client.post(
'/main/notification/send/all/',
data = json.dumps({}),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
mail.outbox.sort(key=lambda x: x.to[0])
self.assertEqual('*****@*****.**', mail.outbox[0].to[0])
self.assertEqual('*****@*****.**', mail.outbox[0].from_email)
self.assertEqual('*****@*****.**', mail.outbox[1].to[0])
self.assertEqual('*****@*****.**', mail.outbox[1].from_email)
self.assertEqual('*****@*****.**', mail.outbox[2].to[0])
self.assertEqual('*****@*****.**', mail.outbox[2].from_email)
emails = StackedMailEntry.objects.all()
for email in emails:
self.assertEqual(True, email.is_sent)
def test_fluctuation_waiver_modified_successfully_to_false(self):
waiver = BenchmarkFluctuationWaiverEntry.objects.create(
git_user=self.git_user1, notification_allowed=True)
self.assertEqual(1,
BenchmarkFluctuationWaiverEntry.objects.all().count())
self.assertEqual(
1,
BenchmarkFluctuationWaiverEntry.objects.filter(
git_user__id=self.git_user1.id,
notification_allowed=True).count())
resp = self.client.post('/main/notification/waiver/{0}/deny/'.format(
waiver.id),
data=json.dumps({}),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(1,
BenchmarkFluctuationWaiverEntry.objects.all().count())
self.assertEqual(
1,
BenchmarkFluctuationWaiverEntry.objects.filter(
git_user__id=self.git_user1.id,
notification_allowed=False).count())
def test_add_bluesteel_project_to_layout(self):
self.assertEqual(1, BluesteelLayoutEntry.objects.all().count())
self.assertEqual(0, BluesteelProjectEntry.objects.all().count())
resp = self.client.post('/main/layout/{0}/add/project/'.format(
self.layout_1.id),
data='',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(1, BluesteelLayoutEntry.objects.all().count())
self.assertEqual(1,
BluesteelProjectEntry.objects.filter(order=0).count())
resp = self.client.post('/main/layout/{0}/add/project/'.format(
self.layout_1.id),
data='',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(1, BluesteelLayoutEntry.objects.all().count())
self.assertEqual(1,
BluesteelProjectEntry.objects.filter(order=0).count())
self.assertEqual(1,
BluesteelProjectEntry.objects.filter(order=1).count())
def test_delete_bluesteel_project_to_layout(self):
layout_entry = BluesteelLayoutController.create_new_default_layout()
self.assertEqual(
1,
BluesteelLayoutEntry.objects.filter(id=layout_entry.id).count())
self.assertEqual(1, BluesteelProjectEntry.objects.all().count())
self.assertEqual(15, CommandEntry.objects.all().count())
self.assertTrue(self.check_default_fetch_commands())
resp = self.client.post('/main/layout/{0}/delete/'.format(
layout_entry.id),
data='',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(
0,
BluesteelLayoutEntry.objects.filter(id=layout_entry.id).count())
self.assertEqual(0, BluesteelProjectEntry.objects.all().count())
self.assertEqual(0, CommandEntry.objects.all().count())
def test_get_all_branches_and_merge_target_info(self):
diff_entry = GitDiffEntry.objects.create(
project=self.git_project1,
commit_son=self.git_commit3,
commit_parent=self.git_commit1,
content='diff-3-1')
GitBranchMergeTargetEntry.objects.create(
project=self.git_project1,
current_branch=self.git_branch3,
target_branch=self.git_branch1,
fork_point=self.git_commit1,
diff=diff_entry)
resp = self.client.get('/main/branch/all/project/{0}/'.format(
self.git_project1.id))
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(2, len(resp_obj['data']))
self.assertEqual('branch-1', resp_obj['data'][0]['name'])
self.assertEqual('0000100001000010000100001000010000100001',
resp_obj['data'][0]['commit_hash'])
self.assertFalse('target_branch_name' in resp_obj['data'][0])
self.assertEqual('branch-3', resp_obj['data'][1]['name'])
self.assertEqual('0000300003000030000300003000030000300003',
resp_obj['data'][1]['commit_hash'])
self.assertEqual('branch-1', resp_obj['data'][1]['target_branch_name'])
def test_merge_target_not_changed_because_its_the_same(self):
self.git_merge_target1.target_branch = self.git_branch3
self.git_merge_target1.save()
self.assertEqual('branch-3', self.git_merge_target1.target_branch.name)
self.assertEqual(False, self.git_merge_target1.invalidated)
obj = {}
obj['current_branch_name'] = 'branch-1'
obj['target_branch_name'] = 'branch-3'
resp = self.client.post(
'/main/branch/merge/target/project/{0}/'.format(
self.git_project1.id),
data=json.dumps(obj),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual('Target branch not changed', resp_obj['message'])
self.assertEqual(
False,
GitBranchMergeTargetEntry.objects.get(
project=self.git_project1,
target_branch=self.git_branch3).invalidated)
self.assertEqual(
'branch-3',
GitBranchMergeTargetEntry.objects.get(
project=self.git_project1,
target_branch=self.git_branch3).target_branch.name)
def test_get_layout_1(self):
git_project = GitProjectEntry.objects.create(
url='http://www.test.com',
name='git-project-28',
)
command_group = CommandGroupEntry.objects.create()
command_set = CommandSetEntry.objects.create(group=command_group)
command = CommandEntry.objects.create(command_set=command_set,
command='command-1 arg-2, arg-3',
order=0)
project_1 = BluesteelProjectEntry.objects.create(
name='project-1',
layout=self.layout_1,
command_group=command_group,
git_project=git_project,
)
resp = self.client.get('/main/layout/1/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(1, resp_obj['data']['id'])
self.assertEqual('layout-1', resp_obj['data']['name'])
self.assertEqual('archive-1', resp_obj['data']['uuid'])
self.assertEqual('http://testserver/main/feed/commit/project/1/',
resp_obj['data']['projects'][0]['feed_commits_url'])
self.assertEqual('http://testserver/main/feed/report/project/1/',
resp_obj['data']['projects'][0]['feed_reports_url'])
def test_incorrect_branch(self):
commit_time = str(timezone.now().isoformat())
commit1 = FeederTestHelper.create_commit(1, [], 'user1',
'*****@*****.**', commit_time,
commit_time)
branch1 = FeederTestHelper.create_branch('master', 2, 'master', 2, 1,
[2, 1],
'merge-target-content')
feed_data = {}
feed_data['commits'] = []
feed_data['commits'].append(commit1)
feed_data['branches'] = []
feed_data['branches'].append(branch1)
post_data = FeederTestHelper.create_feed_data(feed_data)
resp = self.client.post('/main/feed/commit/project/{0}/'.format(
self.git_project1.id),
data=json.dumps(post_data),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(400, resp_obj['status'])
self.assertEqual('Branches not correct', resp_obj['message'])
self.assertEqual(0, GitCommitEntry.objects.all().count())
self.assertEqual(0, GitBranchEntry.objects.all().count())
def test_save_worker(self):
worker_new = WorkerEntry.objects.create(
name='worker-new',
uuid='8a88432d-33db-4d24-a0a7-2f863e111111',
description='description-1',
git_feeder=False,
user=self.user1)
self.assertEqual('description-1', worker_new.description)
self.assertFalse(worker_new.git_feeder)
post_data = {}
post_data['description'] = 'description-2'
post_data['git_feeder'] = True
post_data['max_feed_reports'] = 30
resp = self.client.post('/main/bluesteelworker/{0}/save/'.format(
worker_new.id),
data=json.dumps(post_data),
content_type='text/plain')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
worker = WorkerEntry.objects.filter(id=worker_new.id).first()
self.assertEqual(200, resp_obj['status'])
self.assertEqual('description-2', worker.description)
self.assertEqual(True, worker.git_feeder)
self.assertEqual(30, worker.max_feed_reports)
def test_udpate_branch_5_order_value_to_be_the_first(self):
resp = self.client.post(
'/main/branch/{0}/project/{1}/update/order/0/'.format(
self.git_branch5.id, self.git_project1.id),
data='{}',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(
1,
GitBranchEntry.objects.filter(
id=self.git_branch1.id).first().order)
self.assertEqual(
2,
GitBranchEntry.objects.filter(
id=self.git_branch2.id).first().order)
self.assertEqual(
3,
GitBranchEntry.objects.filter(
id=self.git_branch3.id).first().order)
self.assertEqual(
4,
GitBranchEntry.objects.filter(
id=self.git_branch4.id).first().order)
self.assertEqual(
0,
GitBranchEntry.objects.filter(
id=self.git_branch5.id).first().order)
def test_get_worker_files_hash_does_not_exists(self):
resp = self.client.get('/main/bluesteelworker/hash/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(400, resp_obj['status'])
self.assertEqual('Worker files hash not found', resp_obj['message'])
def test_get_worker_info_not_found(self):
resp = self.client.get(
'/main/bluesteelworker/8a88432d-33db-4d24-a0a7-20000000000a/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(400, resp_obj['status'])
self.assertEqual('Worker not found', resp_obj['message'])
def test_fluctuation_waiver_modified_not_successful(self):
resp = self.client.post('/main/notification/waiver/28/deny/',
data=json.dumps({}),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(404, resp_obj['status'])
def test_get_worker_files_hash_exists(self):
WorkerFilesHashEntry.objects.create(files_hash='aaaa')
resp = self.client.get('/main/bluesteelworker/hash/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual('aaaa', resp_obj['data']['worker_files_hash'])
def test_project_not_found(self):
resp = self.client.post('/main/branch/merge/target/project/128/',
data='{}',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(404, resp_obj['status'])
self.assertEqual('project not found', resp_obj['message'])
def test_get_layout_project_ids_and_names_and_selected(self):
git_project = GitProjectEntry.objects.create(
url='http://www.test.com',
name='git-project-28',
)
command_group = CommandGroupEntry.objects.create()
command_set = CommandSetEntry.objects.create(group=command_group)
command = CommandEntry.objects.create(command_set=command_set,
command='command-1 arg-2, arg-3',
order=0)
project_1 = BluesteelProjectEntry.objects.create(
name='project-1',
layout=self.layout_1,
command_group=command_group,
git_project=git_project,
)
project_2 = BluesteelProjectEntry.objects.create(
name='project-2',
layout=self.layout_1,
command_group=command_group,
git_project=git_project,
)
project_3 = BluesteelProjectEntry.objects.create(
name='project-3',
layout=self.layout_1,
command_group=command_group,
git_project=git_project,
)
self.layout_1.project_index_path = 2
self.layout_1.save()
resp = self.client.get('/main/layout/1/projects/info/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(3, len(resp_obj['data']['projects']))
self.assertEqual('project-1', resp_obj['data']['projects'][0]['name'])
self.assertEqual(project_1.id, resp_obj['data']['projects'][0]['id'])
self.assertEqual(False, resp_obj['data']['projects'][0]['selected'])
self.assertEqual('project-2', resp_obj['data']['projects'][1]['name'])
self.assertEqual(project_2.id, resp_obj['data']['projects'][1]['id'])
self.assertEqual(False, resp_obj['data']['projects'][1]['selected'])
self.assertEqual('project-3', resp_obj['data']['projects'][2]['name'])
self.assertEqual(project_3.id, resp_obj['data']['projects'][2]['id'])
self.assertEqual(True, resp_obj['data']['projects'][2]['selected'])
def test_get_definitions_list_associated_with_a_bluesteel_project(self):
command_group = CommandGroupEntry.objects.create()
git_project = GitProjectEntry.objects.create(url='',
name='git-project')
bluesteel_proj = BluesteelProjectEntry.objects.create(
name='project-1',
layout=self.layout_1,
command_group=command_group,
git_project=git_project)
benchmark_def1 = BenchmarkDefinitionEntry.objects.create(
name='def-1',
layout=self.layout_1,
project=bluesteel_proj,
command_set=CommandSetEntry.objects.create(),
active=True)
benchmark_def2 = BenchmarkDefinitionEntry.objects.create(
name='def-2',
layout=self.layout_1,
project=bluesteel_proj,
command_set=CommandSetEntry.objects.create(),
active=True)
benchmark_def3 = BenchmarkDefinitionEntry.objects.create(
name='def-3',
layout=self.layout_1,
project=bluesteel_proj,
command_set=CommandSetEntry.objects.create(),
active=True)
benchmark_def4 = BenchmarkDefinitionEntry.objects.create(
name='def-4',
layout=self.layout_1,
project=bluesteel_proj,
command_set=CommandSetEntry.objects.create(),
active=False)
resp = self.client.get('/main/project/{0}/definition/list/'.format(
bluesteel_proj.id))
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(3, len(resp_obj['data']['definitions']))
self.assertEqual(benchmark_def1.id,
resp_obj['data']['definitions'][0]['id'])
self.assertEqual(benchmark_def2.id,
resp_obj['data']['definitions'][1]['id'])
self.assertEqual(benchmark_def3.id,
resp_obj['data']['definitions'][2]['id'])
self.assertEqual('def-1', resp_obj['data']['definitions'][0]['name'])
self.assertEqual('def-2', resp_obj['data']['definitions'][1]['name'])
self.assertEqual('def-3', resp_obj['data']['definitions'][2]['name'])
def test_acqiere_execution_is_none_because_no_definition(self):
resp = self.client.post('/main/execution/acquire/')
resp = self.client.post('/main/execution/acquire/',
data=json.dumps({}),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(404, resp_obj['status'])
self.assertEqual('Next Execution not found', resp_obj['message'])
def test_json_data_is_incorrect(self):
resp = self.client.post(
'/main/branch/merge/target/project/{0}/'.format(
self.git_project1.id),
data='/',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(406, resp_obj['status'])
self.assertEqual('Json parser failed.', resp_obj['message'])
def test_create_benchmark_definition(self):
layout = BluesteelLayoutController.create_new_default_layout()
blueProject = BluesteelProjectEntry.objects.all().first().git_project
commit1 = GitCommitEntry.objects.create(
project=blueProject,
commit_hash='0000500005000050000500005000050000500005',
author=self.git_user1,
author_date=timezone.now(),
committer=self.git_user1,
committer_date=timezone.now())
commit2 = GitCommitEntry.objects.create(
project=blueProject,
commit_hash='0000600006000060000600006000060000600006',
author=self.git_user1,
author_date=timezone.now(),
committer=self.git_user1,
committer_date=timezone.now())
commit3 = GitCommitEntry.objects.create(
project=blueProject,
commit_hash='0000700007000070000700007000070000700007',
author=self.git_user1,
author_date=timezone.now(),
committer=self.git_user1,
committer_date=timezone.now())
self.assertEqual(0, BenchmarkDefinitionEntry.objects.all().count())
self.assertEqual(0, BenchmarkExecutionEntry.objects.all().count())
resp = self.client.post('/main/definitions/create/',
data='',
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
definition = BenchmarkDefinitionEntry.objects.all().first()
self.assertEqual(1, BenchmarkDefinitionEntry.objects.all().count())
self.assertEqual(0, BenchmarkExecutionEntry.objects.all().count())
self.assertEqual(
2,
BenchmarkDefinitionWorkerPassEntry.objects.all().count())
self.assertEqual(
1,
BenchmarkDefinitionWorkerPassEntry.objects.filter(
definition=definition, worker=self.worker1).count())
self.assertEqual(
1,
BenchmarkDefinitionWorkerPassEntry.objects.filter(
definition=definition, worker=self.worker2).count())
def test_get_project_list_from_layout(self):
command_group = CommandGroupEntry.objects.create()
git_project1 = GitProjectEntry.objects.create(url='',
name='git-project-1')
git_project2 = GitProjectEntry.objects.create(url='',
name='git-project-2')
git_project3 = GitProjectEntry.objects.create(url='',
name='git-project-3')
bluesteel_proj1 = BluesteelProjectEntry.objects.create(
name='project-1',
layout=self.layout_1,
command_group=command_group,
git_project=git_project1)
bluesteel_proj2 = BluesteelProjectEntry.objects.create(
name='project-2',
layout=self.layout_1,
command_group=command_group,
git_project=git_project2)
bluesteel_proj3 = BluesteelProjectEntry.objects.create(
name='project-3',
layout=self.layout_1,
command_group=command_group,
git_project=git_project3)
resp = self.client.get('/main/layout/{0}/projects/list/'.format(
self.layout_1.id))
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(3, len(resp_obj['data']['projects']))
self.assertEqual(bluesteel_proj1.id,
resp_obj['data']['projects'][0]['id'])
self.assertEqual(bluesteel_proj2.id,
resp_obj['data']['projects'][1]['id'])
self.assertEqual(bluesteel_proj3.id,
resp_obj['data']['projects'][2]['id'])
self.assertEqual('project-1', resp_obj['data']['projects'][0]['name'])
self.assertEqual('project-2', resp_obj['data']['projects'][1]['name'])
self.assertEqual('project-3', resp_obj['data']['projects'][2]['name'])
self.assertEqual(
'/main/project/1/branch/list/',
resp_obj['data']['projects'][0]['url']['project_branch_list'])
self.assertEqual(
'/main/project/2/branch/list/',
resp_obj['data']['projects'][1]['url']['project_branch_list'])
self.assertEqual(
'/main/project/3/branch/list/',
resp_obj['data']['projects'][2]['url']['project_branch_list'])
def test_report_ok(self):
reports = []
report = {}
report['commands'] = []
command = {}
command['command'] = 'command1 arg1 arg2'
command['result'] = {}
command['result']['error'] = 'error-text-1'
command['result']['out'] = 'out-text-1'
command['result']['status'] = 0
command['result']['start_time'] = datetime.datetime.utcnow().isoformat(
)
command['result']['finish_time'] = datetime.datetime.utcnow(
).isoformat()
report['commands'].append(command)
reports.append(report)
obj = {}
obj['reports'] = reports
resp = self.client.post('/main/feed/report/project/{0}/'.format(
self.git_project1.id),
data=json.dumps(obj),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual('Reports added correctly', resp_obj['message'])
reports_entry = CommandGroupEntry.objects.all()
self.assertEqual(1, len(reports_entry))
sets_entry = CommandSetEntry.objects.all()
self.assertEqual(1, len(sets_entry))
self.assertEqual(reports_entry[0], sets_entry[0].group)
comm_entry = CommandEntry.objects.all().first()
self.assertEqual(u'command1 arg1 arg2', comm_entry.command)
comm_result_entry = CommandResultEntry.objects.all().first()
self.assertEqual('error-text-1', comm_result_entry.error)
self.assertEqual('out-text-1', comm_result_entry.out)
self.assertEqual(0, comm_result_entry.status)
self.assertEqual(sets_entry[0], comm_entry.command_set)
def test_layout_remains_active_because_project_index_is_correct(self):
git_project_1 = GitProjectEntry.objects.create(
url='http://www.test-1.com',
name='git-project-1',
)
git_project_2 = GitProjectEntry.objects.create(
url='http://www.test-2.com',
name='git-project-2',
)
command_group_1 = BluesteelProjectController.create_default_command_group(
)
command_group_2 = BluesteelProjectController.create_default_command_group(
)
project_entry_1 = BluesteelProjectEntry.objects.create(
layout=self.layout_1,
name='project-1',
command_group=command_group_1,
git_project=git_project_1,
)
project_entry_2 = BluesteelProjectEntry.objects.create(
layout=self.layout_1,
name='project-2',
command_group=command_group_2,
git_project=git_project_2,
)
self.assertEqual(0, self.layout_1.project_index_path)
obj = {}
obj['name'] = 'layout-1'
obj['active'] = True
obj['project_index_path'] = 1
resp = self.client.post('/main/layout/{0}/save/'.format(
self.layout_1.id),
data=json.dumps(obj),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(True,
BluesteelLayoutEntry.objects.all().first().active)
self.assertEqual(
1,
BluesteelLayoutEntry.objects.all().first().project_index_path)
def test_save_benchmark_stores_the_correct_json(self):
execution = BenchmarkExecutionController.create_benchmark_execution(
self.benchmark_definition1, self.commit1, self.worker1)
obj = {
'command_set': [{
'command': 'command-vertical-bars',
'result': {
'status':
0,
'out': [{
'visual_type': 'vertical_bars',
'id': 'id1',
'data': [1, 2, 3, 4, 5]
}, {
'visual_type': 'text',
'id': 'id2',
'data': 'this is a text, very long'
}],
'error':
'',
'start_time':
str(timezone.now()),
'finish_time':
str(timezone.now())
},
}]
}
resp = self.client.post('/main/execution/{0}/save/'.format(
execution.id),
data=json.dumps(obj),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
execution = BenchmarkExecutionEntry.objects.filter(
definition=self.benchmark_definition1).first()
obj = json.loads(CommandResultEntry.objects.all().first().out)
self.assertEqual(2, len(obj))
self.assertEqual('id1', obj[0]['id'])
self.assertEqual('vertical_bars', obj[0]['visual_type'])
self.assertEqual([1, 2, 3, 4, 5], obj[0]['data'])
self.assertEqual('id2', obj[1]['id'])
self.assertEqual('text', obj[1]['visual_type'])
self.assertEqual('this is a text, very long', obj[1]['data'])
def test_get_all_layouts_urls(self):
resp = self.client.get('/main/layout/all/urls/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(3, len(resp_obj['data']['layouts']))
self.assertTrue(
'http://testserver/main/layout/1/' in resp_obj['data']['layouts'])
self.assertTrue(
'http://testserver/main/layout/2/' in resp_obj['data']['layouts'])
self.assertTrue(
'http://testserver/main/layout/3/' in resp_obj['data']['layouts'])
def test_get_known_commit_hashes(self):
resp = self.client.get('/main/commit/all/project/{0}/hashes/'.format(
self.git_project1.id))
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(2, len(resp_obj['data']['hashes']))
self.assertTrue('0000100001000010000100001000010000100001' in
resp_obj['data']['hashes'])
self.assertFalse('0000200002000020000200002000020000200002' in
resp_obj['data']['hashes'])
self.assertTrue('0000300003000030000300003000030000300003' in
resp_obj['data']['hashes'])
def test_save_bluesteel_project_removing_everything_in_path(self):
commands = []
commands.append('command-1')
commands.append('command-2')
commands.append('command-3')
commands2 = []
commands2.append('command-4')
commands2.append('command-5')
commands2.append('command-6')
command_group = CommandGroupEntry.objects.create()
CommandController.add_full_command_set(command_group, "CLONE", 0,
commands)
CommandController.add_full_command_set(command_group, "FETCH", 1,
commands2)
git_project = GitProjectEntry.objects.create(url='',
name='git-project')
bluesteel_proj = BluesteelProjectEntry.objects.create(
name='project-1',
layout=self.layout_1,
command_group=command_group,
git_project=git_project)
obj = {}
obj['name'] = 'NAME-updated'
obj['git_project_folder_search_path'] = '\\..\\'
obj['clone'] = []
obj['clone'].append('command-28')
obj['clone'].append('command-29')
obj['fetch'] = []
obj['fetch'].append('command-30')
obj['fetch'].append('command-31')
resp = self.client.post('/main/project/{0}/save/'.format(
bluesteel_proj.id),
data=json.dumps(obj),
content_type='application/json')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual(
'.',
BluesteelProjectEntry.objects.all().first().
git_project_folder_search_path)
def test_get_bootstrap_urls(self):
resp = self.client.get('/main/bluesteelworker/bootstrap/')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
self.assertEqual(200, resp_obj['status'])
self.assertEqual('http://testserver/main/layout/all/urls/',
resp_obj['data']['layouts_url'])
self.assertEqual('http://testserver/main/bluesteelworker/',
resp_obj['data']['worker_info_url'])
self.assertEqual('http://testserver/main/bluesteelworker/create/',
resp_obj['data']['create_worker_url'])
self.assertEqual('http://testserver/main/bluesteelworker/login/',
resp_obj['data']['login_worker_url'])
def test_creation_of_worker_also_create_worker_passes(self):
self.worker_1.delete()
self.assertEqual(0, WorkerEntry.objects.all().count())
command_group = CommandGroupEntry.objects.create()
command_set = CommandSetEntry.objects.create(group=command_group)
bluesteel_layout = BluesteelLayoutEntry.objects.create(
name='Layout', active=True, project_index_path=0)
bluesteel_project = BluesteelProjectEntry.objects.create(
name='Project',
order=0,
layout=bluesteel_layout,
command_group=command_group,
git_project=self.git_project1)
benchmark_definition1 = BenchmarkDefinitionEntry.objects.create(
name='BenchmarkDefinition1',
layout=bluesteel_layout,
project=bluesteel_project,
command_set=command_set,
revision=28)
post_data = {}
post_data['uuid'] = '8a88432d-33db-4d24-a0a7-0000007e8e4a'
post_data['operative_system'] = 'osx'
post_data['host_name'] = 'host-name'
post_str = json.dumps(post_data)
resp = self.client.post('/main/bluesteelworker/create/',
data=post_str,
content_type='text/plain')
res.check_cross_origin_headers(self, resp)
resp_obj = json.loads(resp.content)
worker = WorkerEntry.objects.all().first()
self.assertEqual(1, BenchmarkDefinitionEntry.objects.all().count())
self.assertEqual(1, WorkerEntry.objects.all().count())
self.assertEqual(
1,
BenchmarkDefinitionWorkerPassEntry.objects.all().count())
self.assertEqual(
1,
BenchmarkDefinitionWorkerPassEntry.objects.filter(
definition=benchmark_definition1, worker=worker).count())
