def test_search(self, mock_search, mock_base):
request = MagicMock()
request.query_string = 'test_query'
request.username = '******'
mock_res = MagicMock()
mock_res.hits.total.value = 1
mock_res.__iter__.return_value = [IndexedFile(name='file01')]
mock_search().query().extra().execute.return_value = mock_res
sm = PrivateDataSearchManager(request)
expected_result = {
'trail': [{
'name': '$SEARCH',
'path': '/$SEARCH'
}],
'name': '$SEARCH',
'path': '/',
'system': 'test.system',
'type': 'dir',
'children': [{
'name': 'file01'
}],
'permissions': 'READ'
}
listing = sm.listing('test.system', '/')
self.assertEqual(listing, expected_result)
def test_init(self, mock_base):
request = MagicMock()
request.query_string = 'test_query'
request.username = '******'
sm = CommunityDataSearchManager(request)
mock_base.assert_called_with(IndexedFile, IndexedFile.search())
def test_init(self, mock_base):
request = MagicMock()
request.query_string = 'test_query'
request.username = '******'
sm = PublicationsSearchManager(request)
mock_base.assert_called_with(IndexedPublication, Search())
def test_listing(self, mock_search, mock_pub, mock_leg_pub):
request = MagicMock()
request.query_string = 'test_query'
request.username = '******'
fm = PublicationsSearchManager(request)
mock_search().filter().sort().extra().execute.return_value = [
IndexedPublication(projectId='PRJ-XXX'),
IndexedPublicationLegacy()
]
mock_pub().to_file.return_value = {'type': 'pub'}
mock_leg_pub().to_file.return_value = {'type': 'leg_pub'}
res = fm.listing(**{'type_filters': []})
expected_result = {
'trail': [{
'name': '$SEARCH',
'path': '/$SEARCH'
}],
'name': '$SEARCH',
'path': '/',
'system': None,
'type': 'dir',
'children': [{
'type': 'pub'
}, {
'type': 'leg_pub'
}],
'permissions': 'READ'
}
self.assertEqual(res, expected_result)
def test_args(self):
mocked_os = MagicMock()
mocked_log = MagicMock()
mocked_grp = MagicMock()
mocked_pass = MagicMock()
mocked_file = MagicMock()
mocked_args = MagicMock()
mocked_parser = MagicMock()
mocked_urlparse = MagicMock()
mocked_parse_res1 = MagicMock()
mocked_parse_res2 = MagicMock()
mocked_log_handler = MagicMock()
url = '[email protected]:owner/test.git'
mocked_file.mkdtemp.return_value = "/tmp"
mocked_pass.getuser.return_value = "test_user"
mocked_os.getgid.return_value = 1
mocked_os.environ = {}
mocked_os.path.abspath.return_value = "abs/tmp"
mocked_grp.getgrgid().gr_name = "test_group"
mocked_parser.parse_args.return_value = mocked_args
mocked_args.remote_url = url
mocked_parse_res1.scheme = None
mocked_parse_res2.username = "******"
mocked_urlparse.side_effect = [mocked_parse_res1, mocked_parse_res2]
mocked_args.o = "magic=True,not_magic=False"
mocked_args.group = None
mocked_args.repo_path = None
mocked_args.user = None
mocked_args.branch = None
mocked_args.ssh_user = None
mocked_args.sentry_dsn = ''
with patch.multiple('gitfs.utils.args',
os=mocked_os,
grp=mocked_grp,
getpass=mocked_pass,
tempfile=mocked_file,
TimedRotatingFileHandler=mocked_log_handler,
urlparse=mocked_urlparse,
log=mocked_log):
args = Args(mocked_parser)
asserted_results = {
"repo_path": "abs/tmp",
"user": "******",
"group": "test_group",
"branch": "master",
"not_magic": "False",
"ssh_user": "******",
}
for name, value in iteritems(asserted_results):
assert value == getattr(args, name)
assert args.config == mocked_args
assert mocked_pass.getuser.call_count == 1
assert mocked_file.mkdtemp.call_count == 1
mocked_log.setLevel.assert_called_once_with('DEBUG')
mocked_urlparse.assert_has_calls([call(url), call('ssh://' + url)])
mocked_grp.getgrgid.has_calls([call(1)])
def setUp(self):
views.RSS = MagicMock()
self.rss_object = MagicMock()
views.RSS.objects.all.return_value = [self.rss_object]
# Create request user mock
user_object = MagicMock()
user_object.username = '******'
user_object.pk = '1111'
user_object.is_staff = False
self.request = MagicMock()
self.request.user = user_object
# Create organization mock
self.org_object = MagicMock()
self.org_object.name = 'test_org'
self.org_object.managers = ['1111']
self.org_object.payment_info = {
'number': '4567456745674567'
}
views.Organization = MagicMock()
views.Organization.objects.get.return_value = self.org_object
views.RSSManagerFactory = MagicMock()
self._limits_factory = MagicMock()
views.RSSManagerFactory.return_value = self._limits_factory
self._exp_mock = MagicMock(name="ExpenditureManager")
self._limits_factory.get_expenditure_manager.return_value = self._exp_mock
def test_register_5to6(self, mock_subprocess):
self.engine.options = self.create_options(
five_to_six=True,
destination_url="http://example.com",
service_level="x")
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self.engine.consumer_id = "id"
self.engine.consumer_exists = MagicMock(return_value=True)
self.engine.select_service_level = MagicMock(return_value="y")
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = [
'subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--serverurl=http://example.com',
'--org=org',
'--environment=env',
'--consumerid=id',
'--auto-attach',
'--service-level=y',
]
self.engine.consumer_exists.assert_called_once_with(
self.engine.consumer_id)
self.engine.select_service_level.assert_called_once_with("org", "x")
mock_subprocess.assert_called_once_with(arg_list)
def change_role(self, user, role):
from cthulhu.calamari_ctl import assign_role
args = MagicMock()
args.username = user
args.role_name = role
assign_role(args)
log.debug('changing role of %s to %s' % (user, role))
def test_register_5to6(self, mock_subprocess):
self.engine.options = self.create_options(
five_to_six=True,
destination_url="http://example.com",
service_level="x")
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self.engine.consumer_id = "id"
self.engine.consumer_exists = MagicMock(return_value=True)
self.engine.select_service_level = MagicMock(return_value="y")
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--environment=env',
'--auto-attach',
'--serverurl=http://example.com',
'--org=org',
'--consumerid=id',
'--servicelevel=y',
]
self.engine.consumer_exists.assert_called_once_with(self.engine.consumer_id)
self.engine.select_service_level.assert_called_once_with("org", "x")
mock_subprocess.assert_called_once_with(arg_list)
def get_user(token):
if token in tokens:
user = MagicMock()
user.username = '******'
return user
else:
return None
def setUp(self):
views.RSS = MagicMock()
self.rss_object = MagicMock()
views.RSS.objects.all.return_value = [self.rss_object]
# Create request user mock
user_object = MagicMock()
user_object.username = '******'
user_object.pk = '1111'
user_object.is_staff = False
self.request = MagicMock()
self.request.user = user_object
# Create organization mock
self.org_object = MagicMock()
self.org_object.name = 'test_org'
self.org_object.managers = ['1111']
self.org_object.payment_info = {'number': '4567456745674567'}
views.Organization = MagicMock()
views.Organization.objects.get.return_value = self.org_object
views.RSSManagerFactory = MagicMock()
self._limits_factory = MagicMock()
views.RSSManagerFactory.return_value = self._limits_factory
self._exp_mock = MagicMock(name="ExpenditureManager")
self._limits_factory.get_expenditure_manager.return_value = self._exp_mock
def change_role(self, user, role):
from cthulhu.calamari_ctl import assign_role
args = MagicMock()
args.username = user
args.role_name = role
assign_role(args)
log.debug('changing role of %s to %s' % (user, role))
def test_get_username(self, xblock):
user = MagicMock()
user.username = "******"
xblock.xmodule_runtime = MagicMock()
xblock.xmodule_runtime.get_real_user.return_value = user
self.assertEqual('Bob', xblock.get_username('anon_id'))
def test_get_username(self, xblock):
user = MagicMock()
user.username = "******"
xblock.xmodule_runtime = MagicMock()
xblock.xmodule_runtime.get_real_user.return_value = user
self.assertEqual('Bob', xblock.get_username('anon_id'))
def _get_user(self, netid=None):
user = MagicMock()
if netid is None:
user.is_authenticated.return_value = False
else:
user.is_authenticated.return_value = True
user.netid = netid
user.username = netid + '@washington.edu'
return user
def _get_user(self, netid=None):
user = MagicMock()
if netid is None:
user.is_authenticated.return_value = False
else:
user.is_authenticated.return_value = True
user.netid = netid
user.username = netid + '@washington.edu'
return user
def test_args(self):
mocked_os = MagicMock()
mocked_log = MagicMock()
mocked_grp = MagicMock()
mocked_pass = MagicMock()
mocked_file = MagicMock()
mocked_args = MagicMock()
mocked_parser = MagicMock()
mocked_urlparse = MagicMock()
mocked_parse_res1 = MagicMock()
mocked_parse_res2 = MagicMock()
mocked_log_handler = MagicMock()
url = '[email protected]:owner/test.git'
mocked_file.mkdtemp.return_value = "/tmp"
mocked_pass.getuser.return_value = "test_user"
mocked_os.getgid.return_value = 1
mocked_os.environ = {}
mocked_os.path.abspath.return_value = "abs/tmp"
mocked_grp.getgrgid().gr_name = "test_group"
mocked_parser.parse_args.return_value = mocked_args
mocked_args.remote_url = url
mocked_parse_res1.scheme = None
mocked_parse_res2.username = "******"
mocked_urlparse.side_effect = [mocked_parse_res1, mocked_parse_res2]
mocked_args.o = "magic=True,not_magic=False"
mocked_args.group = None
mocked_args.repo_path = None
mocked_args.user = None
mocked_args.branch = None
mocked_args.ssh_user = None
mocked_args.sentry_dsn = ''
with patch.multiple('gitfs.utils.args', os=mocked_os, grp=mocked_grp,
getpass=mocked_pass, tempfile=mocked_file,
TimedRotatingFileHandler=mocked_log_handler,
urlparse=mocked_urlparse, log=mocked_log):
args = Args(mocked_parser)
asserted_results = {
"repo_path": "abs/tmp",
"user": "******",
"group": "test_group",
"branch": "master",
"not_magic": "False",
"ssh_user": "******",
}
for name, value in asserted_results.iteritems():
assert value == getattr(args, name)
assert args.config == mocked_args
assert mocked_pass.getuser.call_count == 1
assert mocked_file.mkdtemp.call_count == 1
mocked_log.setLevel.assert_called_once_with('DEBUG')
mocked_urlparse.assert_has_calls([call(url), call('ssh://' + url)])
mocked_grp.getgrgid.has_calls([call(1)])
def _create_review_mock(self, rev_data):
review = MagicMock()
review.pk = rev_data['id']
usr = MagicMock()
usr.username = rev_data['user']
org = MagicMock()
org.name = rev_data['organization']
if usr.name == rev_data['organization']:
usr.userprofile.current_organization = org
review.user = usr
review.organization = org
review.title = rev_data['title']
review.comment = rev_data['comment']
review.rating = rev_data['rating']
review.offering = self.offering
review.timestamp = datetime.strptime(rev_data['timestamp'],
'%Y-%m-%d %H:%M:%S.%f')
if 'response' in rev_data:
response = MagicMock()
resp_user = MagicMock()
resp_user.username = rev_data['response']['user']
resp_org = MagicMock()
resp_org.name = rev_data['response']['organization']
if resp_user.name == rev_data['response']['organization']:
resp_user.userprofile.current_organization = resp_org
response.user = resp_user
response.organization = resp_org
response.title = rev_data['response']['title']
response.response = rev_data['response']['response']
response.timestamp = datetime.strptime(
rev_data['response']['timestamp'], '%Y-%m-%d %H:%M:%S.%f')
review.response = response
else:
review.response = None
return review
def test_register_failure(self, mock_subprocess):
self.engine.options = self.create_options({'serverurl': 'foobar'})
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 1
try:
self.engine.register(credentials, "", "")
except SystemExit, e:
self.assertEquals(e.code, 2)
def test_inventory_list_backwards_compat_configs(self):
# FIXME(shardy) backwards compatibility until we switch
# tripleo-validations to pass the individual values
configs = MagicMock()
configs.plan = self.plan_name
configs.auth_url = 'xyz://keystone.local'
configs.cacert = 'acacert'
configs.project_name = 'admin'
configs.username = '******'
configs.ansible_ssh_user = '******'
inventory = TripleoInventory(configs, self.session, self.hclient)
self._inventory_list(inventory)
def test_register_failure(self, mock_subprocess):
self.engine.options = self.create_options({'serverurl': 'foobar'})
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 1
try:
self.engine.register(credentials, "", "")
except SystemExit, e:
self.assertEquals(e.code, 2)
def test_register_failure(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar')
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self._inject_mock_invalid_consumer()
try:
self.engine.register(credentials, "", "")
except SystemExit, e:
self.assertEquals(e.code, 2)
def test_register_failure(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar')
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self._inject_mock_invalid_consumer()
try:
self.engine.register(credentials, "", "")
except SystemExit, e:
self.assertEquals(e.code, 2)
def _create_review_mock(self, rev_data):
review = MagicMock()
review.pk = rev_data['id']
usr = MagicMock()
usr.username = rev_data['user']
org = MagicMock()
org.name = rev_data['organization']
if usr.name == rev_data['organization']:
usr.userprofile.current_organization = org
review.user = usr
review.organization = org
review.title = rev_data['title']
review.comment = rev_data['comment']
review.rating = rev_data['rating']
review.offering = self.offering
review.timestamp = datetime.strptime(rev_data['timestamp'], '%Y-%m-%d %H:%M:%S.%f')
if 'response' in rev_data:
response = MagicMock()
resp_user = MagicMock()
resp_user.username = rev_data['response']['user']
resp_org = MagicMock()
resp_org.name = rev_data['response']['organization']
if resp_user.name == rev_data['response']['organization']:
resp_user.userprofile.current_organization = resp_org
response.user = resp_user
response.organization = resp_org
response.title = rev_data['response']['title']
response.response = rev_data['response']['response']
response.timestamp = datetime.strptime(rev_data['response']['timestamp'], '%Y-%m-%d %H:%M:%S.%f')
review.response = response
else:
review.response = None
return review
def test_args(self):
"""
Does the correct set of arguments get passed to the ap
"""
args = MagicMock()
del args.channel
args.hostname = 'mike'
args.username = '******'
args.password = '******'
ap = MagicMock()
with patch('apcommand.accesspoints.atheros', ap):
# 000
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with(hostname=args.hostname,
username=args.username,
password=args.password)
args.password = None
# 001
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with(hostname=args.hostname,
username=args.username)
args.username = None
# 011
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with(hostname=args.hostname)
args.password = '******'
# 010
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with(hostname=args.hostname,
password=args.password)
args.hostname=None
# 110
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with(password=args.password)
args.password = None
# 111
access_point = self.sub_command.access_point(args)
ap.AtherosAR5KAP.assert_called_with()
return
def test_notify_should_send_email_to_user(self, mock_send_email):
user = MagicMock()
email = '*****@*****.**'
name = 'manchester united'
user.email = email
user.username = name
subject = "some subject"
message = "some %s message"
CSVExportService.notify(user, subject, message)
expected_message = "some manchester united message"
mock_send_email.assert_called_once_with(subject, expected_message, DEFAULT_FROM_EMAIL, [email])
def setUp(self):
# Create request mock
self.request = MagicMock()
self.request.user = MagicMock()
self.request.user.is_staff = True
# Create user mocks
user_mock1 = MagicMock()
user_mock1.username = '******'
user_mock1.first_name = 'Test'
user_mock1.last_name = 'user1'
user_mock1.pk = '1122'
user_mock1.is_staff = True
user_mock2 = MagicMock()
user_mock2.username = '******'
user_mock2.first_name = 'Test'
user_mock2.last_name = 'user2'
user_mock2.is_staff = False
self.user_mocks = {
'user1': user_mock1,
'user2': user_mock2,
}
def test_notify_should_send_email_to_user(self, mock_send_email):
user = MagicMock()
email = '*****@*****.**'
name = 'manchester united'
user.email = email
user.username = name
subject = "some subject"
message = "some %s message"
CSVExportService.notify(user, subject, message)
expected_message = "some manchester united message"
mock_send_email.assert_called_once_with(subject, expected_message,
DEFAULT_FROM_EMAIL, [email])
def _base_dependency_setup(self, manager_def_mock, user_mock,
ngouserprofile_def_mock, project_mock):
manager_mock = MagicMock(spec=DatabaseManager)
manager_def_mock.return_value = manager_mock
user_saved_mock = MagicMock(spec=User)
user_saved_mock.username = '******'
user_mock.objects.create_user.return_value = user_saved_mock
user_mock.objects.get.return_value = user_saved_mock
ngo_user_profile_mock = MagicMock(spec=NGOUserProfile)
ngouserprofile_def_mock.return_value = ngo_user_profile_mock
ngouserprofile_def_mock.objects.get.return_value = ngo_user_profile_mock
questionnaire_mock = MagicMock(spec=Project)
project_mock.get.return_value = questionnaire_mock
return manager_mock, user_saved_mock, ngo_user_profile_mock, questionnaire_mock
def connect_to_account(username):
account = MagicMock(spec=Account)
if username != "*****@*****.**":
account.access_type = "delegate"
account.domain = "exch.com"
account.Identity = ("*****@*****.**", None, None, None)
account.username = "******"
account.get_user = "******"
account.protocol = MagicMock()
account.protocol.resolve_names = MagicMock()
account.protocol.resolve_names.return_value = resolve_names()
else:
account.protocol = MagicMock()
account.protocol.resolve_names = MagicMock()
account.protocol.resolve_names.return_value = []
return account
def a_registered_project_member(username=None):
if username is None:
username = a_string()
registered_member_info = MagicMock()
registered_member_info.avatarSource = 'default'
registered_member_info.avatarUrl = ''
registered_member_info.firstName = a_string()
registered_member_info.lastName = a_string()
registered_member_info.username = username
project_member = MagicMock()
project_member.invitationInfo = None
project_member.registeredMemberInfo = registered_member_info
project_member.role = 'manager'
return project_member
def setUp(self):
# Create request user mock
user_object = MagicMock()
user_object.username = '******'
user_object.pk = '1111'
user_object.is_staff = False
self.request = MagicMock()
self.request.user = user_object
# Create organization mock
self.org_object = MagicMock()
self.org_object.name = 'test_org'
self.org_object.managers = ['1111']
self.org_object.payment_info = {
'number': '4567456745674567'
}
views.Organization = MagicMock()
views.Organization.objects.get.return_value = self.org_object
def test_register_no_auto(self, mock_subprocess):
self.engine.options = self.create_options(auto=False)
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self.engine.consumer_id = "id"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--environment=env',
'--org=org',
]
mock_subprocess.assert_called_once_with(arg_list)
def test_register_with_activation_keys(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar', activation_keys=['hello', 'world'])
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--activationkey=hello',
'--activationkey=world',
'--serverurl=foobar',
'--org=org',
]
mock_subprocess.assert_called_with(arg_list)
def test_register_no_auto(self, mock_subprocess):
self.engine.options = self.create_options(auto=False)
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
self.engine.consumer_id = "id"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--environment=env',
'--org=org',
]
mock_subprocess.assert_called_once_with(arg_list)
def test_register_with_activation_keys(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar', activation_keys=['hello', 'world'])
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--activationkey=hello',
'--activationkey=world',
'--serverurl=foobar',
'--org=org',
]
mock_subprocess.assert_called_with(arg_list)
def test_connect_to_rhn(self, mock_server):
rhn_config = {
"serverURL": "https://some.host.example.com/XMLRPC",
"enableProxy": True,
"enableProxyAuth": True,
"sslCACert": "/some/path/here",
}
self.engine.rhncfg = rhn_config
self.engine.proxy_user = "******"
self.engine.proxy_pass = "******"
self.engine.proxy_host = "proxy.example.com"
self.engine.proxy_port = "3128"
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
ms = mock_server.return_value
self.engine.connect_to_rhn(credentials)
mock_server.assert_called_with("https://some.host.example.com/rpc/api", proxy="proxy_user:[email protected]:3128")
ms.auth.login.assert_called_with("username", "password")
def test_chat_settings(self):
mock_user = MagicMock()
mock_user.username = "******"
mock_course = MagicMock()
mock_course.id = "a/b/c"
# Stub this out in the case that it's not in the settings
domain = "jabber.edx.org"
settings.JABBER_DOMAIN = domain
chat_settings = views.chat_settings(mock_course, mock_user)
# Test the proper format of all chat settings
self.assertEqual(chat_settings['domain'], domain)
self.assertEqual(chat_settings['room'], "a-b-c_class")
self.assertEqual(chat_settings['username'], "johndoe@%s" % domain)
# TODO: this needs to be changed once we figure out how to
# generate/store a real password.
self.assertEqual(chat_settings['password'], "johndoe@%s" % domain)
def test_chat_settings(self):
mock_user = MagicMock()
mock_user.username = "******"
mock_course = MagicMock()
mock_course.id = "a/b/c"
# Stub this out in the case that it's not in the settings
domain = "jabber.edx.org"
settings.JABBER_DOMAIN = domain
chat_settings = views.chat_settings(mock_course, mock_user)
# Test the proper format of all chat settings
self.assertEqual(chat_settings['domain'], domain)
self.assertEqual(chat_settings['room'], "a-b-c_class")
self.assertEqual(chat_settings['username'], "johndoe@%s" % domain)
# TODO: this needs to be changed once we figure out how to
# generate/store a real password.
self.assertEqual(chat_settings['password'], "johndoe@%s" % domain)
def test_connect_to_rhn(self, mock_server):
rhn_config = {
"serverURL": "https://some.host.example.com/XMLRPC",
"enableProxy": True,
"enableProxyAuth": True,
"sslCACert": "/some/path/here",
}
self.engine.rhncfg = rhn_config
self.engine.proxy_user = "******"
self.engine.proxy_pass = "******"
self.engine.proxy_host = "proxy.example.com"
self.engine.proxy_port = "3128"
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
ms = mock_server.return_value
self.engine.connect_to_rhn(credentials)
mock_server.assert_called_with("https://some.host.example.com/rpc/api", proxy="proxy_user:[email protected]:3128")
ms.auth.login.assert_called_with("username", "password")
def test_register(self, mock_read, mock_subprocess):
self.engine.options = self.create_options({'serverurl': 'foobar'})
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
mock_read.return_value = MagicMock()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--serverurl=foobar',
'--username=foo',
'--password=bar',
'--org=org',
'--environment=env',
]
mock_subprocess.assert_called_with(arg_list)
def test_register(self, mock_read, mock_subprocess):
self.engine.options = self.create_options({'serverurl': 'foobar'})
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
mock_read.return_value = MagicMock()
self.engine.register(credentials, "org", "env")
arg_list = [
'subscription-manager',
'register',
'--serverurl=foobar',
'--username=foo',
'--password=bar',
'--org=org',
'--environment=env',
]
mock_subprocess.assert_called_with(arg_list)
def test_register(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar')
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--environment=env',
'--auto-attach',
'--serverurl=foobar',
'--org=org',
]
mock_subprocess.assert_called_with(arg_list)
def test_register(self, mock_subprocess):
self.engine.options = self.create_options(destination_url='foobar')
credentials = MagicMock()
credentials.username = "******"
credentials.password = "******"
mock_subprocess.return_value = 0
self._inject_mock_valid_consumer()
self.engine.register(credentials, "org", "env")
arg_list = ['subscription-manager',
'register',
'--username=foo',
'--password=bar',
'--environment=env',
'--auto-attach',
'--serverurl=foobar',
'--org=org',
]
mock_subprocess.assert_called_with(arg_list)
def setUp(self):
# Create mock request
user_object = MagicMock()
user_object.is_staff = False
user_object.pk = '2222'
user_object.userprofile.actor_id = 2
user_object.username = '******'
self.request = MagicMock()
self.request.META.get.return_value = 'application/json'
self.request.user = user_object
# Mock user
views.User = MagicMock()
views.User.objects.get = MagicMock()
views.User.objects.get.return_value = user_object
views.Organization = MagicMock()
self.org = MagicMock()
self.org.name = 'test_org'
self.org.managers = []
views.Organization.objects.get.return_value = self.org
def setUp(self):
# Create mock request
user_object = MagicMock()
user_object.is_staff = False
user_object.pk = '2222'
user_object.userprofile.actor_id = 2
user_object.username = '******'
self.request = MagicMock()
self.request.META.get.return_value = 'application/json'
self.request.user = user_object
# Mock user
views.User = MagicMock()
views.User.objects.get = MagicMock()
views.User.objects.get.return_value = user_object
views.Organization = MagicMock()
self.org = MagicMock()
self.org.name = 'test_org'
self.org.managers = []
views.Organization.objects.get.return_value = self.org
def test_commands(self, bottle_request, check_auth_data,
get_infrastructure, SSH):
"""Test REST StopInfrastructure."""
bottle_request.return_value = MagicMock()
bottle_request.headers = {
"AUTHORIZATION":
("type = InfrastructureManager; username = user; password = pass\n"
"id = one; type = OpenNebula; host = onedock.i3m.upv.es:2633; "
"username = user; password = pass")
}
bottle_request.environ = {'HTTP_HOST': 'imserver.com'}
inf = InfrastructureInfo()
inf.id = "1"
inf.auth = Authentication([{
'type': 'InfrastructureManager',
'username': '******',
'password': '******'
}])
get_infrastructure.return_value = inf
bottle_request.params = {'step': '1'}
res = RESTGetVMProperty("1", "1", "command")
auth_str = "Authorization: type = InfrastructureManager; username = user; password = pass"
url = "http://imserver.com/infrastructures/1/vms/1/command?step=2"
expected_res = """
res="wait"
while [ "$res" == "wait" ]
do
res=`curl -s -H "%s" -H "Accept: text/plain" %s`
if [ "$res" != "wait" ]
then
eval "$res"
else
sleep 20
fi
done""" % (auth_str, url)
self.assertEqual(res, expected_res)
radl_master = parse_radl("""
network publica (outbound = 'yes')
network privada ()
system front (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
net_interface.0.ip = '8.8.8.8' and
net_interface.0.connection = 'publica' and
net_interface.1.connection = 'privada' and
disk.0.image.url = 'mock0://linux.for.ev.er' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.0.os.name = 'linux'
)
""")
radl_vm1 = parse_radl("""
network privada ()
system wn (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
net_interface.0.connection = 'privada' and
disk.0.image.url = 'mock0://linux.for.ev.er' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.0.os.name = 'linux'
)
""")
radl_vm2 = parse_radl("""
network privada2 ()
system wn2 (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
net_interface.0.connection = 'privada2' and
disk.0.image.url = 'mock0://linux.for.ev.er' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.0.os.name = 'linux'
)
""")
# in the Master VM
bottle_request.params = {'step': '2'}
inf.vm_master = VirtualMachine(inf, None, None, radl_master,
radl_master)
inf.vm_master.creation_im_id = 0
ssh = MagicMock()
ssh.test_connectivity.return_value = True
ssh.port = 22
ssh.private_key = None
ssh.password = "******"
ssh.username = "******"
ssh.host = "8.8.8.8"
SSH.return_value = ssh
vm1 = VirtualMachine(inf, None, None, radl_vm1, radl_vm1)
vm1.creation_im_id = 1
vm1.destroy = False
vm2 = VirtualMachine(inf, None, None, radl_vm2, radl_vm2)
vm2.creation_im_id = 2
vm2.destroy = False
inf.vm_list = [inf.vm_master, vm1, vm2]
res = RESTGetVMProperty("1", "0", "command")
expected_res = "true"
self.assertEqual(res, expected_res)
bottle_request.params = {'step': '2'}
res = RESTGetVMProperty("1", "1", "command")
expected_res = "true"
self.assertEqual(res, expected_res)
# in VM not connected to the Master VM
res = RESTGetVMProperty("1", "2", "command")
expected_res = (
'sshpass -pyoyoyo ssh -N -R 20002:localhost:22 -p 22 -o "UserKnownHostsFile=/dev/null"'
' -o "StrictHostKeyChecking=no" [email protected] &')
self.assertEqual(res, expected_res)
