def create_test_slice(test):
add_test_aggregate_to_project(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# create the slice
Slice.objects.all().delete()
expiration = datetime.now() + timedelta(days=settings.MAX_SLICE_LIFE - 5)
test_get_and_post_form(
client=test.client,
url=Slice.get_create_url(proj_id=test.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "%s" % expiration.date(),
"expiration_date_1": expiration.time().strftime("%H:%m:%S"),
},
)
test.slice = Slice.objects.all()[0]
test.client.logout()
threadlocals.pop_frame()
def start_test_slice(test):
"""Create a test setup with aggregates, users, project, and started slice.
Creates two users, test.u1 and test.u2. Gives test.u1 permission to
create aggregates. Creates two dummy aggregates with resources using u1.
Gives u2 permission to create project, creates project with u2, add u1 as
researcher member, creates a slice, add all dummy resources to slice,
and starts it.
C{test} must be a child of L{expedient.common.tests.manager.SettingsTestCase}.
"""
add_resources_to_test_slice(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# start the slice
test_get_and_post_form(
client=test.client,
url=test.slice.get_start_url(),
params={},
)
test.slice = Slice.objects.get(pk=test.slice.pk)
test.assertTrue(test.slice.started)
test.client.logout()
threadlocals.pop_frame()
def start_test_slice(test):
"""Create a test setup with aggregates, users, project, and started slice.
Creates two users, test.u1 and test.u2. Gives test.u1 permission to
create aggregates. Creates two dummy aggregates with resources using u1.
Gives u2 permission to create project, creates project with u2, add u1 as
researcher member, creates a slice, add all dummy resources to slice,
and starts it.
C{test} must be a child of L{expedient.common.tests.manager.SettingsTestCase}.
"""
add_resources_to_test_slice(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# start the slice
test_get_and_post_form(
client=test.client,
url=test.slice.get_start_url(),
params={},
)
test.slice = Slice.objects.get(pk=test.slice.pk)
test.assertTrue(test.slice.started)
test.client.logout()
threadlocals.pop_frame()
def create_test_slice(test):
add_test_aggregate_to_project(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# create the slice
Slice.objects.all().delete()
expiration = datetime.now() + timedelta(days=settings.MAX_SLICE_LIFE - 5)
test_get_and_post_form(
client=test.client,
url=Slice.get_create_url(proj_id=test.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "%s" % expiration.date(),
"expiration_date_1": expiration.time().strftime("%H:%m:%S"),
},
)
test.slice = Slice.objects.all()[0]
test.client.logout()
threadlocals.pop_frame()
def test_req_process(self):
"""
Test that when a request is made for a user, it shows up in the
dashboard.
"""
self.client.login(username="******", password="******")
resp = self.client.get(reverse("permissionmgmt_dashboard"))
# "permission1" should not be mentioned anywhere on the page
self.assertContains(resp, "permission1", 0)
obj_perm1=ObjectPermission.objects.get_or_create_for_object_or_class(
"permission1", self.u1,
)[0]
obj_perm2=ObjectPermission.objects.get_or_create_for_object_or_class(
"permission1", self.u2,
)[0]
req1 = PermissionRequest.objects.create(
requesting_user=self.u2,
permittee=Permittee.objects.get_or_create_from_instance(self.u2)[0],
permission_owner=self.u1,
requested_permission=obj_perm1,
)
req2 = PermissionRequest.objects.create(
requesting_user=self.u2,
permittee=Permittee.objects.get_or_create_from_instance(self.u2)[0],
permission_owner=self.u1,
requested_permission=obj_perm2,
)
resp = self.client.get(reverse("permissionmgmt_dashboard"))
# "permission1" should be mentioned twice: once in each request
self.assertContains(resp, "permission1", 2)
resp = test_get_and_post_form(
self.client, reverse("permissionmgmt_dashboard"),
dict(
approved=[str(req2.id)],
denied=[str(req1.id)],
)
)
self.assertRedirects(resp, reverse("permissionmgmt_confirm_req"))
resp = test_get_and_post_form(
self.client, reverse("permissionmgmt_confirm_req"),
dict(
post="yes",
)
)
self.assertRedirects(resp, reverse("home"))
self.assertEqual(PermissionRequest.objects.count(), 0)
self.assertTrue(has_permission(self.u2, self.u2, "permission1"))
self.assertFalse(has_permission(self.u2, self.u1, "permission1"))
def test_add_aggregate(self):
# end
# check nothing is there
self.assertEqual(SSHAggregate.objects.count(), 0)
# end
# get private key as string
pkey_f = StringIO()
self.test_key.write_private_key(pkey_f)
pkey = pkey_f.getvalue()
pkey_f.close()
# end
# Add the aggregate
response = test_get_and_post_form(
self.client,
url=reverse(aggregate_crud),
params=dict(
name="Test Aggregate",
description="Aggregate on localhost",
location="right here",
admin_username=getpass.getuser(),
private_key=pkey,
add_user_command="sh -c 'echo %(username)s >> " +
Tests.CREATED_USER_FNAME + "'",
del_user_command="sh -c 'echo %(username)s >> " +
Tests.DELETED_USER_FNAME + "'",
add_pubkey_user_command="sh -c 'echo %(pubkey)s >> " +
Tests.PUBKEY_USER_FNAME + "'",
),
)
self.assertEqual(SSHAggregate.objects.count(), 1)
# end
# where do we go next?
next_url = reverse(aggregate_add_servers, args=[1])
self.assertRedirects(
response, next_url)
# end
# Add the localhost as a server
response = test_get_and_post_form(
self.client,
url=next_url,
params={
"form-0-name": "localhost",
"form-0-ip_address": "127.0.0.1",
"form-0-ssh_port": "22",
},
)
# end
# check that localhost added
self.assertRedirects(
response, reverse(aggregate_add_servers, args=[1]),
msg_prefix="Response was %s" % response)
self.assertEqual(SSHServer.objects.count(), 1)
def test_req_process(self):
"""
Test that when a request is made for a user, it shows up in the
dashboard.
"""
self.client.login(username="******", password="******")
resp = self.client.get(reverse("permissionmgmt_dashboard"))
# "permission1" should not be mentioned anywhere on the page
self.assertContains(resp, "permission1", 0)
obj_perm1 = ObjectPermission.objects.get_or_create_for_object_or_class(
"permission1",
self.u1,
)[0]
obj_perm2 = ObjectPermission.objects.get_or_create_for_object_or_class(
"permission1",
self.u2,
)[0]
req1 = PermissionRequest.objects.create(
requesting_user=self.u2,
permittee=Permittee.objects.get_or_create_from_instance(
self.u2)[0],
permission_owner=self.u1,
requested_permission=obj_perm1,
)
req2 = PermissionRequest.objects.create(
requesting_user=self.u2,
permittee=Permittee.objects.get_or_create_from_instance(
self.u2)[0],
permission_owner=self.u1,
requested_permission=obj_perm2,
)
resp = self.client.get(reverse("permissionmgmt_dashboard"))
# "permission1" should be mentioned twice: once in each request
self.assertContains(resp, "permission1", 2)
resp = test_get_and_post_form(
self.client, reverse("permissionmgmt_dashboard"),
dict(
approved=[str(req2.id)],
denied=[str(req1.id)],
))
self.assertRedirects(resp, reverse("permissionmgmt_confirm_req"))
resp = test_get_and_post_form(self.client,
reverse("permissionmgmt_confirm_req"),
dict(post="yes", ))
self.assertRedirects(resp, reverse("home"))
self.assertEqual(PermissionRequest.objects.count(), 0)
self.assertTrue(has_permission(self.u2, self.u2, "permission1"))
self.assertFalse(has_permission(self.u2, self.u1, "permission1"))
def test_request_flowspace(self):
'''
A single user and a single admin.
User send a request. test that admin auto approve and manual approve works.
'''
u = User.objects.create_user("user", "*****@*****.**", "password")
profile = UserProfile.get_or_create_profile(u)
# log in as user
logged = self.client.login(username="******", password="******")
self.assertEqual(logged, True)
response = test_get_and_post_form(
self.client,
reverse("user_reg_fs"),
{
"ip_addr": "176.25.10.1",
"mac_addr": "*"
},
)
rufs = RequestedUserFlowSpace.objects.filter(user=u)
self.assertEqual(rufs.count(), 2)
self.assertContains(response, "submitted successfully")
self.assertContains(response, "awaiting approval by")
# now try it with auto approve script
self.client.logout()
logged = self.client.login(username="******", password="******")
self.assertEqual(logged, True)
response = test_get_and_post_form(
self.client,
reverse("set_auto_approve"),
{"script": "Approve All Requests"},
)
script = AdminAutoApproveScript.objects.filter(admin=self.test_admin)
self.assertEqual(script.count(), 1)
self.assertEqual(script[0].script_name, "Approve All Requests")
self.client.logout()
# log in as user
logged = self.client.login(username="******", password="******")
self.assertEqual(logged, True)
response = test_get_and_post_form(
self.client,
reverse("user_reg_fs"),
{
"ip_addr": "176.26.10.1",
"mac_addr": "*"
},
)
ufs = UserFlowSpace.objects.filter(user=u)
self.assertEqual(ufs.count(), 2)
self.assertContains(response, "submitted successfully")
self.assertContains(response, "approved by")
def test_request_flowspace(self):
'''
A single user and a single admin.
User send a request. test that admin auto approve and manual approve works.
'''
u = User.objects.create_user("user", "*****@*****.**", "password")
profile = UserProfile.get_or_create_profile(u)
# log in as user
logged = self.client.login(username="******",password="******")
self.assertEqual(logged,True)
response = test_get_and_post_form(
self.client,
reverse("user_reg_fs"),
{"ip_addr":"176.25.10.1","mac_addr":"*"},
)
rufs = RequestedUserFlowSpace.objects.filter(user=u)
self.assertEqual(rufs.count(),2)
self.assertContains(response, "submitted successfully")
self.assertContains(response, "awaiting approval by")
# now try it with auto approve script
self.client.logout()
logged = self.client.login(username="******",password="******")
self.assertEqual(logged,True)
response = test_get_and_post_form(
self.client,
reverse("set_auto_approve"),
{"script":"Approve All Requests"},
)
script = AdminAutoApproveScript.objects.filter(admin=self.test_admin)
self.assertEqual(script.count(),1)
self.assertEqual(script[0].script_name,"Approve All Requests")
self.client.logout()
# log in as user
logged = self.client.login(username="******",password="******")
self.assertEqual(logged,True)
response = test_get_and_post_form(
self.client,
reverse("user_reg_fs"),
{"ip_addr":"176.26.10.1","mac_addr":"*"},
)
ufs = UserFlowSpace.objects.filter(user=u)
self.assertEqual(ufs.count(),2)
self.assertContains(response, "submitted successfully")
self.assertContains(response, "approved by")
def test_create_aggregates(self):
"""
Test that we can create an OpenFlow Aggregate using the create view.
"""
self.client.login(username=self.test_user.username,
password=self.test_user_password)
for i in range(NUM_DUMMY_OMS):
response = test_get_and_post_form(
self.client, reverse("openflow_aggregate_create"),
dict(
name="DummyOM %s" % i,
description="DummyOM Description",
location="Stanford, CA",
usage_agreement="Do you agree?",
username="******" % i,
password="******",
url="test://testserver:80/dummyom/%s/xmlrpc/" % (i + 1),
))
logger.debug("Created aggregate %s" % (i + 1))
self.assertRedirects(
response,
expected_url=reverse("openflow_aggregate_add_links",
args=[i + 1]),
)
self.assertEqual(OpenFlowAggregate.objects.count(), NUM_DUMMY_OMS)
def test_user_re_optin(self):
'''
Test if opting into the same experiment just updates the previous opt and
doesn't double opt
'''
self.test_user_optin()
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(), 1)
uopt = UserOpts.objects.filter(user__username__exact="user")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs), 1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment": all_exps[0].id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 1)
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs), 1)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(self.num_fv_rules, actual_fv_rules_count)
def test_user_optin(self):
'''
Test if a single opt-in is happening correctly
'''
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(),1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":all_exps[0].id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),1)
self.assertEqual(uopt[0].experiment.slice_name,"slice name_1")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs),1)
self.num_fv_rules = MatchStruct.objects.filter(optfs=optfs[0]).count()
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count,self.num_fv_rules)
self.assertEqual(optfs[0].ip_src_s,max(self.user_ip_src_s,self.exp_ip_src_s))
self.assertEqual(optfs[0].ip_src_e,min(self.user_ip_src_e,self.exp_ip_src_e))
self.assertEqual(getattr(optfs[0],"%s_s"%self.user_field_name), self.user_field_s)
self.assertEqual(getattr(optfs[0],"%s_e"%self.user_field_name), self.user_field_e)
self.assertEqual(getattr(optfs[0],"%s_s"%self.exp_field_name), self.exp_field_s)
self.assertEqual(getattr(optfs[0],"%s_e"%self.exp_field_name), self.exp_field_e)
def test_add_aggregate(self):
resp = test_get_and_post_form(
self.client, reverse("gopenflow_aggregate_create"),
dict(
name="DummyOF",
description="DummyOF Description",
location="Stanford, CA",
url="test://testserver:80"+reverse("dummy_gopenflow"),
)
)
self.assertEqual(GCFOpenFlowAggregate.objects.count(), 1)
self.assertRedirects(
resp,
expected_url=reverse(
"gopenflow_aggregate_add_links",
args=[GCFOpenFlowAggregate.objects.all()[0].id]),
)
exp_switches, exp_links = parse_external_rspec(self.of.adv_rspec)
new_rspec = gapi.ListResources({}, None)
new_switches, new_links = parse_external_rspec(new_rspec)
self.assertEqual(
self.sort_switches(new_switches),
self.sort_switches(exp_switches))
self.assertEqual(
self.links_to_set(new_links),
self.links_to_set(exp_links))
def test_create_aggregates(self):
"""
Test that we can create an OpenFlow Aggregate using the create view.
"""
self.client.login(
username=self.test_user.username, password=self.test_user_password)
for i in range(NUM_DUMMY_OMS):
response = test_get_and_post_form(
self.client, reverse("openflow_aggregate_create"),
dict(
name="DummyOM %s" % i,
description="DummyOM Description",
location="Stanford, CA",
usage_agreement="Do you agree?",
username="******" % i,
password="******",
url="test://testserver:80/dummyom/%s/xmlrpc/" % (i+1),
))
logger.debug("Created aggregate %s" % (i+1))
self.assertRedirects(
response,
expected_url=reverse("openflow_aggregate_add_links", args=[i+1]),
)
self.assertEqual(OpenFlowAggregate.objects.count(), NUM_DUMMY_OMS)
def test_full(self):
"""
Test that a project with a started slice can be deleted.
"""
start_test_slice(self)
slice_name = "%s" % self.slice
self.client.login(
username=self.u2.username, password="******")
threadlocals.push_frame(user=self.u2)
# delete the project. This should delete all the slivers
# and resources, and delete the slice. It should also stop
# the slice (which creates a DummySliceEvent)
response = test_get_and_post_form(
client=self.client,
url=self.project.get_delete_url(),
params={},
)
self.assertRedirects(response, "/")
self.assertEqual(
DummySliceEvent.objects.filter(
slice=slice_name, status="stopped").count(), 2)
self.assertEqual(Sliver.objects.count(), 0)
self.assertEqual(Project.objects.count(), 0)
self.client.logout()
threadlocals.pop_frame()
def test_user_optin(self):
'''
Test if a single opt-in is happening correctly
'''
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(), 1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment": all_exps[0].id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 1)
self.assertEqual(uopt[0].experiment.slice_name, "slice name_1")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs), 1)
self.num_fv_rules = MatchStruct.objects.filter(optfs=optfs[0]).count()
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count, self.num_fv_rules)
self.assertEqual(optfs[0].ip_src_s,
max(self.user_ip_src_s, self.exp_ip_src_s))
self.assertEqual(optfs[0].ip_src_e,
min(self.user_ip_src_e, self.exp_ip_src_e))
self.assertEqual(getattr(optfs[0], "%s_s" % self.user_field_name),
self.user_field_s)
self.assertEqual(getattr(optfs[0], "%s_e" % self.user_field_name),
self.user_field_e)
self.assertEqual(getattr(optfs[0], "%s_s" % self.exp_field_name),
self.exp_field_s)
self.assertEqual(getattr(optfs[0], "%s_e" % self.exp_field_name),
self.exp_field_e)
def test_user_re_optin(self):
'''
Test if opting into the same experiment just updates the previous opt and
doesn't double opt
'''
self.test_user_optin()
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(),1)
uopt = UserOpts.objects.filter(user__username__exact="user")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs),1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":all_exps[0].id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),1)
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs),1)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(self.num_fv_rules,actual_fv_rules_count)
def setUp(self):
# Create a test admin
self.test_admin = User.objects.create_superuser(
"admin", "*****@*****.**", "password")
# first set admin to use manual approve:
logged = self.client.login(username="******",password="******")
self.assertEqual(logged,True)
# Create the FV proxy connection
username = "******"
password = "******"
u = User.objects.create(username=username)
u.set_password(password)
u.save()
FVServerProxy.objects.create(
name="Flowvisor",
username=username,
password=password,
url = SCHEME+"://%s:8443/dummyfv/1/xmlrpc/" % (
HOST,
),
)
response = test_get_and_post_form(
self.client,
reverse("set_auto_approve"),
{"script":"Manual"},
)
script = AdminAutoApproveScript.objects.filter(admin=self.test_admin)
self.assertEqual(script.count(),1)
self.assertEqual(script[0].script_name,"Manual")
self.client.logout()
def setUp(self):
# Create a test admin
self.test_admin = User.objects.create_superuser(
"admin", "*****@*****.**", "password")
# first set admin to use manual approve:
logged = self.client.login(username="******", password="******")
self.assertEqual(logged, True)
# Create the FV proxy connection
username = "******"
password = "******"
u = User.objects.create(username=username)
u.set_password(password)
u.save()
FVServerProxy.objects.create(
name="Flowvisor",
username=username,
password=password,
url=SCHEME + "://%s:8443/dummyfv/1/xmlrpc/" % (HOST, ),
)
response = test_get_and_post_form(
self.client,
reverse("set_auto_approve"),
{"script": "Manual"},
)
script = AdminAutoApproveScript.objects.filter(admin=self.test_admin)
self.assertEqual(script.count(), 1)
self.assertEqual(script[0].script_name, "Manual")
self.client.logout()
def setUp(self):
"""
Update settings, create DummyOMs and test models and login.
"""
# add the test application
self.settings_manager.set(
INSTALLED_APPS=settings.INSTALLED_APPS + [MOD + ".tests"],
DEBUG_PROPAGATE_EXCEPTIONS=True,
)
logger.debug("Updating RPC dispatchers.")
rpc4django_views._register_rpcmethods(
[MOD + ".tests"],
restrict_introspection=False,
dispatchers=rpc4django_views.dispatchers)
self.su = User.objects.create_superuser(
"superuser", "*****@*****.**", "password")
self.client.login(username="******", password="******")
om = DummyOM.objects.create()
om.populate_links(5, 10)
# Add the aggregate to the CH
test_get_and_post_form(
self.client, reverse("openflow_aggregate_create"),
dict(
name="DummyOM",
description="DummyOM Description",
location="Stanford, CA",
usage_agreement="Do you agree?",
username="******",
password="******",
url="test://testserver:80/dummyom/1/xmlrpc/",
)
)
self.of = DummyOFAggregate.objects.create()
# now get the list of resources and store it, then delete the
# OpenFlowAggregate.
self.of.snapshot_switches()
OpenFlowAggregate.objects.all().delete()
# set defaults for SSL_CLIENT_CERT and REMOTE_USER
tl = threadlocals.get_thread_locals()
def setUp(self):
"""
Update settings, create DummyOMs and test models and login.
"""
# add the test application
self.settings_manager.set(
INSTALLED_APPS=settings.INSTALLED_APPS + [MOD + ".tests"],
DEBUG_PROPAGATE_EXCEPTIONS=True,
)
logger.debug("Updating RPC dispatchers.")
rpc4django_views._register_rpcmethods(
[MOD + ".tests"],
restrict_introspection=False,
dispatchers=rpc4django_views.dispatchers)
self.su = User.objects.create_superuser("superuser", "*****@*****.**",
"password")
self.client.login(username="******", password="******")
om = DummyOM.objects.create()
om.populate_links(5, 10)
# Add the aggregate to the CH
test_get_and_post_form(
self.client, reverse("openflow_aggregate_create"),
dict(
name="DummyOM",
description="DummyOM Description",
location="Stanford, CA",
usage_agreement="Do you agree?",
username="******",
password="******",
url="test://testserver:80/dummyom/1/xmlrpc/",
))
self.of = DummyOFAggregate.objects.create()
# now get the list of resources and store it, then delete the
# OpenFlowAggregate.
self.of.snapshot_switches()
OpenFlowAggregate.objects.all().delete()
# set defaults for SSL_CLIENT_CERT and REMOTE_USER
tl = threadlocals.get_thread_locals()
def create_test_project(test):
create_test_aggregates(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# create the project
Project.objects.all().delete()
test_get_and_post_form(
client=test.client,
url=Project.get_create_url(),
params={"name": "project name", "description": "project description"},
)
test.project = Project.objects.all()[0]
test.client.logout()
threadlocals.pop_frame()
def test_slice_expiration_form(self):
add_test_aggregate_to_project(self)
self.client.login(username=self.u2.username, password="******")
threadlocals.push_frame(user=self.u2)
expiration = datetime.now() \
+ timedelta(days=settings.MAX_SLICE_LIFE + 5)
response = test_get_and_post_form(
client=self.client,
url=Slice.get_create_url(proj_id=self.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "%s" % expiration.date(),
"expiration_date_1": expiration.time().strftime("%H:%m:%S"),
},
)
self.assertContains(
response,
"The entered date is too late. Maximum is",
)
response = test_get_and_post_form(
client=self.client,
url=Slice.get_create_url(proj_id=self.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "xyaz",
"expiration_date_1": "%s" % expiration.time(),
},
)
self.assertContains(
response,
"Enter a valid date",
)
self.client.logout()
threadlocals.pop_frame()
def test_slice_expiration_form(self):
add_test_aggregate_to_project(self)
self.client.login(
username=self.u2.username, password="******")
threadlocals.push_frame(user=self.u2)
expiration = datetime.now() \
+ timedelta(days=settings.MAX_SLICE_LIFE + 5)
response = test_get_and_post_form(
client=self.client,
url=Slice.get_create_url(proj_id=self.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "%s" % expiration.date(),
"expiration_date_1": expiration.time().strftime("%H:%m:%S"),
},
)
self.assertContains(
response, "The entered date is too late. Maximum is",
)
response = test_get_and_post_form(
client=self.client,
url=Slice.get_create_url(proj_id=self.project.id),
params={
"name": "slice name",
"description": "slice description",
"expiration_date_0": "xyaz",
"expiration_date_1": "%s" % expiration.time(),
},
)
self.assertContains(
response, "Enter a valid date",
)
self.client.logout()
threadlocals.pop_frame()
def add_test_project_member(test):
create_test_project(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# add a member
researcher = ProjectRole.objects.get(project=test.project, name="researcher")
test_get_and_post_form(
client=test.client,
url=test.project.get_member_add_url(),
params={"user": test.u3.id, "roles": researcher.id},
)
test.assertEqual(test.project.owners.count(), 1)
test.assertEqual(test.project.members.count(), 2)
test.client.logout()
threadlocals.pop_frame()
def create_test_project(test):
create_test_aggregates(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# create the project
Project.objects.all().delete()
test_get_and_post_form(
client=test.client,
url=Project.get_create_url(),
params={
"name": "project name",
"description": "project description"
},
)
test.project = Project.objects.all()[0]
test.client.logout()
threadlocals.pop_frame()
def add_test_aggregate_to_slice(test):
create_test_slice(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# add the aggregate to the slice
test_get_and_post_form(
client=test.client,
url=test.slice.get_agg_add_url(),
params={"id": "%s" % test.agg1.id},
)
test_get_and_post_form(
client=test.client,
url=test.slice.get_agg_add_url(),
params={"id": "%s" % test.agg2.id},
)
test.assertEqual(test.slice.aggregates.count(), 2)
test.client.logout()
threadlocals.pop_frame()
def add_test_aggregate_to_slice(test):
create_test_slice(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# add the aggregate to the slice
test_get_and_post_form(
client=test.client,
url=test.slice.get_agg_add_url(),
params={"id": "%s" % test.agg1.id},
)
test_get_and_post_form(
client=test.client,
url=test.slice.get_agg_add_url(),
params={"id": "%s" % test.agg2.id},
)
test.assertEqual(test.slice.aggregates.count(), 2)
test.client.logout()
threadlocals.pop_frame()
def test_user_optin_invalid(self):
'''
Test if a single opt-in is happening correctly
'''
#opt into an experiemnt that doesn't
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment": 234},
)
self.assertNotContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 0)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count, 0)
def test_optout(self):
self.test_user_optin()
uopt = UserOpts.objects.filter(user__username__exact="user")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs), 1)
response = test_get_and_post_form(
self.client,
reverse("opt_out_of_experiment"),
{"1": "checked"},
)
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 0)
optfs = OptsFlowSpace.objects.filter(opt__user__username="******")
self.assertEqual(optfs.count(), 0)
def add_test_project_member(test):
create_test_project(test)
test.client.login(username=test.u2.username, password="******")
threadlocals.push_frame(user=test.u2)
# add a member
researcher = ProjectRole.objects.get(project=test.project,
name="researcher")
test_get_and_post_form(
client=test.client,
url=test.project.get_member_add_url(),
params={
"user": test.u3.id,
"roles": researcher.id
},
)
test.assertEqual(test.project.owners.count(), 1)
test.assertEqual(test.project.members.count(), 2)
test.client.logout()
threadlocals.pop_frame()
def test_user_optin_invalid(self):
'''
Test if a single opt-in is happening correctly
'''
#opt into an experiemnt that doesn't
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":234},
)
self.assertNotContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),0)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count,0)
def test_optout(self):
self.test_user_optin()
uopt = UserOpts.objects.filter(user__username__exact="user")
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(len(optfs),1)
response = test_get_and_post_form(
self.client,
reverse("opt_out_of_experiment"),
{"1":"checked"},
)
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),0)
optfs = OptsFlowSpace.objects.filter(opt__user__username="******")
self.assertEqual(optfs.count(),0)
def test_user_optin_invalid_fv(self):
fv_server_proxy = FVServerProxy.objects.all()[0]
fv_server_proxy.username = "******"
fv_server_proxy.save()
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(), 1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment": all_exps[0].id},
)
print response
self.assertNotContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 0)
def test_allowed_delete(self):
"""
Tests that delete works when given permission.
"""
give_permission_to("can_add_aggregate", Aggregate, self.u)
agg = DummyAggregate.objects.create(
name="dummy agg",
description="aggregate description",
location="Stanford, CA",
)
response = test_get_and_post_form(
client=self.client,
url=agg.get_delete_url(next="/"),
params={},
)
self.assertRedirects(response, "/")
def test_allowed_delete(self):
"""
Tests that delete works when given permission.
"""
give_permission_to("can_add_aggregate", Aggregate, self.u)
agg = DummyAggregate.objects.create(
name="dummy agg",
description="aggregate description",
location="Stanford, CA",
)
response = test_get_and_post_form(
client=self.client,
url=agg.get_delete_url(next="/"),
params={},
)
self.assertRedirects(response, "/")
def test_user_optin_invalid_fv(self):
fv_server_proxy = FVServerProxy.objects.all()[0]
fv_server_proxy.username = "******"
fv_server_proxy.save()
all_exps = Experiment.objects.all()
self.assertEqual(all_exps.count(),1)
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":all_exps[0].id},
)
print response
self.assertNotContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),0)
def test_login(self):
"""Check that users can login and get a cert created for them."""
response = test_get_and_post_form(
self.client,
settings.LOGIN_URL,
{"username": "******", "password": "******"},
)
expected_url = reverse("home")
self.assertRedirects(
response,
expected_url,
)
self.assertTrue(
os.access(self.cert_fname, os.F_OK))
self.assertTrue(
os.access(self.key_fname, os.F_OK))
def test_login(self):
"""Check that users can login and get a cert created for them."""
response = test_get_and_post_form(
self.client,
settings.LOGIN_URL,
{
"username": "******",
"password": "******"
},
)
expected_url = reverse("home")
self.assertRedirects(
response,
expected_url,
)
self.assertTrue(os.access(self.cert_fname, os.F_OK))
self.assertTrue(os.access(self.key_fname, os.F_OK))
def test_add_to_project(self):
"""
Create a project, add first aggregate to project.
"""
self.test_create_aggregates()
# create project
response = test_get_and_post_form(
self.client,
url=reverse("project_create"),
params=dict(
name="project",
description="description",
)
)
project = Project.objects.all()[0]
self.assertRedirects(
response,
reverse("project_detail", args=[project.id]),
)
# add aggregates to project
for i in range(1, 4):
url = reverse("project_add_agg", args=[project.id])
response = self.client.post(
path=url,
data={"id": i},
)
self.assertTrue(project.aggregates.count() == i)
self.assertRedirects(
response,
url,
)
def test_disallowed_edit(self):
"""
Test that we cannot edit or delete without permission.
"""
threadlocals.push_frame(user=self.su)
agg = DummyAggregate.objects.create(
name="dummy agg",
description="aggregate description",
location="Stanford, CA",
)
threadlocals.pop_frame()
self.assertRaises(PermissionDenied, agg.save)
self.assertRaises(PermissionDenied, agg.delete)
# Try delete using a post
response = test_get_and_post_form(
client=self.client,
url=agg.get_delete_url(next="/"),
params={},
)
self.assertEqual(response.status_code, 302)
self.assertTrue("/permissions/can_edit_aggregate/" in response["location"])
def test_add_aggregate(self):
resp = test_get_and_post_form(
self.client, reverse("gopenflow_aggregate_create"),
dict(
name="DummyOF",
description="DummyOF Description",
location="Stanford, CA",
url="test://testserver:80" + reverse("dummy_gopenflow"),
))
self.assertEqual(GCFOpenFlowAggregate.objects.count(), 1)
self.assertRedirects(
resp,
expected_url=reverse(
"gopenflow_aggregate_add_links",
args=[GCFOpenFlowAggregate.objects.all()[0].id]),
)
exp_switches, exp_links = parse_external_rspec(self.of.adv_rspec)
new_rspec = gapi.ListResources({}, None)
new_switches, new_links = parse_external_rspec(new_rspec)
self.assertEqual(self.sort_switches(new_switches),
self.sort_switches(exp_switches))
self.assertEqual(self.links_to_set(new_links),
self.links_to_set(exp_links))
def test_allowed_delete_with_started_slice(self):
'''
Tests that we can delete an aggregate that is in a started slice.
'''
start_test_slice(self)
self.client.login(username=self.u1.username, password="******")
threadlocals.push_frame(user=self.u1)
# delete the aggregate. This should delete all the slivers
# and resources, and create a DummySliceEvent to that effect.
response = test_get_and_post_form(
client=self.client,
url=self.agg1.get_delete_url(next="/"),
params={},
)
self.assertRedirects(response, "/")
self.assertEqual(DummyAggregate.objects.count(), 1)
self.assertEqual(Sliver.objects.count(), 3)
self.assertEqual(
DummySliceEvent.objects.filter(
slice="%s" % self.slice, status="stopped").count(), 1)
def test_disallowed_edit(self):
"""
Test that we cannot edit or delete without permission.
"""
threadlocals.push_frame(user=self.su)
agg = DummyAggregate.objects.create(
name="dummy agg",
description="aggregate description",
location="Stanford, CA",
)
threadlocals.pop_frame()
self.assertRaises(PermissionDenied, agg.save)
self.assertRaises(PermissionDenied, agg.delete)
# Try delete using a post
response = test_get_and_post_form(
client=self.client,
url=agg.get_delete_url(next="/"),
params={},
)
self.assertEqual(response.status_code, 302)
self.assertTrue(
"/permissions/can_edit_aggregate/" in response["location"])
def test_allowed_delete_with_started_slice(self):
'''
Tests that we can delete an aggregate that is in a started slice.
'''
start_test_slice(self)
self.client.login(username=self.u1.username, password="******")
threadlocals.push_frame(user=self.u1)
# delete the aggregate. This should delete all the slivers
# and resources, and create a DummySliceEvent to that effect.
response = test_get_and_post_form(
client=self.client,
url=self.agg1.get_delete_url(next="/"),
params={},
)
self.assertRedirects(response, "/")
self.assertEqual(DummyAggregate.objects.count(), 1)
self.assertEqual(Sliver.objects.count(), 3)
self.assertEqual(
DummySliceEvent.objects.filter(slice="%s" % self.slice,
status="stopped").count(), 1)
def test_add_to_project(self):
"""
Create a project, add first aggregate to project.
"""
self.test_create_aggregates()
# create project
response = test_get_and_post_form(self.client,
url=reverse("project_create"),
params=dict(
name="project",
description="description",
))
project = Project.objects.all()[0]
self.assertRedirects(
response,
reverse("project_detail", args=[project.id]),
)
# add aggregates to project
for i in range(1, 4):
url = reverse("project_add_agg", args=[project.id])
response = self.client.post(
path=url,
data={"id": i},
)
self.assertTrue(project.aggregates.count() == i)
self.assertRedirects(
response,
url,
)
def test_reserve_sliver(self):
self.test_add_aggregate()
proj_name = "test project"
proj_desc = "test project description"
slice_name = "test slice"
slice_desc = "test slice description"
username = "******"
firstname = "gapi"
lastname = "user"
password = "******"
affiliation = "Stanford"
email = "*****@*****.**"
controller_url = "tcp:bla.com:6633"
fs1 = dict(
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(4455, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
)
fs2 = dict(
dl_src=("11:22:33:44:55:66", "11:22:33:44:55:77"),
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(None, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
nw_proto=(4, 4),
tp_src=(123, 123),
)
agg = GCFOpenFlowAggregate.objects.all()[0]
# setup threadlocals
tl = threadlocals.get_thread_locals()
tl["user"] = self.su
project = Project.objects.create(
name=proj_name,
description=proj_desc,
)
tl["project"] = project
url = reverse("project_add_agg", args=[project.id])
response = self.client.post(
path=url,
data={"id": agg.id},
)
self.assertTrue(project.aggregates.count() == 1)
self.assertRedirects(
response,
url,
)
slice = Slice.objects.create(
project=project,
name=slice_name,
description=slice_desc,
owner=self.su,
)
tl["slice"] = slice
# To avoid expensive key creation
info = GENISliceInfo.objects.get(slice=slice)
info.ssh_private_key = "abc"
info.ssh_public_key = "def"
info.save()
slice_add_agg_url = reverse("slice_add_agg", args=[slice.id])
# add aggregate to slice
gopenflow_aggregate_slice_add_url = reverse(
"gopenflow_aggregate_slice_add",
kwargs={
"agg_id": agg.id,
"slice_id": slice.id,
})
# post the form to add aggregate to slice
response = self.client.post(
path=slice_add_agg_url,
data={"id": agg.id},
)
# should go the openflow special add aggregates page
self.assertRedirects(
response,
gopenflow_aggregate_slice_add_url + "?next=" + slice_add_agg_url,
)
# Set the slice info
response = test_get_and_post_form(self.client,
gopenflow_aggregate_slice_add_url +
"?next=" + slice_add_agg_url,
params=dict(
controller_url="tcp:blabla:6633",
password="******",
))
self.assertRedirects(
response,
slice_add_agg_url,
)
self.assertEqual(slice.aggregates.count(), 1,
"Did not add aggregate to slice.")
# select ports and switches
random.seed(0)
fs1_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs1_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
fs2_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs2_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
def create_port_slivers(fs, ports):
slivers = []
for p in ports:
slivers.append(
OpenFlowInterfaceSliver.objects.create(slice=slice,
resource=p))
kw = {}
for k, r in fs.items():
if r[0]:
kw[k + "_start"] = r[0]
if r[1]:
kw[k + "_end"] = r[1]
rule = FlowSpaceRule.objects.create(**kw)
for s in slivers:
rule.slivers.add(s)
return rule
# create the slivers for the slice
r1 = create_port_slivers(fs1, fs1_ports)
r2 = create_port_slivers(fs2, fs2_ports)
create_or_update(
OpenFlowSliceInfo,
filter_attrs=dict(slice=slice),
new_attrs=dict(password=password, controller_url=controller_url),
)
def add_switch_slivers(rule, switches):
for s in switches:
ports = OpenFlowInterface.objects.filter(switch=s)
for p in ports:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice, resource=p)
rule.slivers.add(sliver)
add_switch_slivers(r1, fs1_switches)
add_switch_slivers(r2, fs2_switches)
# get the expected reservation rspec
exp_rspec = create_resv_rspec(self.su, slice)
slice.start(self.su)
actual_rspec = DummyOFAggregate.objects.all()[0].resv_rspec
self.assertEqual(exp_rspec, actual_rspec)
def test_user_multiple_opts(self):
'''
Opt into multiple experiments,change their priorities and then opt all out.
at each of the three steps, test internal database to make sure that it is done
correctly.
'''
max_opt = random.randint(5,9)
exp_ids = []
first_id = Experiment.objects.all()[0].id
exp_ids.append(first_id)
for index in range(2,max_opt):
#create a random number of experiments
exp = Experiment.objects.create(slice_id="slice_id_%d"%index, project_name="project name_%d"%index,
project_desc="project description", slice_name="slice name_%d"%index,
slice_desc="slice description", controller_url="controller url",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:0%d"%index,
ip_src_s=random.randint(0,0x80000000) & 0xFFFF0000,
ip_src_e=random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000,
)
expfs.save()
exp_ids.append(exp.id)
# opt into all of them
count = 0
for exp in Experiment.objects.all():
count = count + 1
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":exp.id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),count)
self.assertEqual(uopt[count-1].experiment.slice_name,exp.slice_name)
optfs = OptsFlowSpace.objects.filter(opt=uopt[count-1])
self.assertEqual(len(optfs),1)
# change priority
request_post = {}
for id in range(1,max_opt):
request_post["p_%d"%exp_ids[id-1]] = max_opt - id + 1
response = test_get_and_post_form(
self.client,
reverse("change_priority"),
request_post,
)
self.assertContains(response, "Successfully")
for id in range(1,max_opt):
uopt = UserOpts.objects.filter(user__username__exact="user",\
experiment__slice_name="slice name_%d"%id)
self.assertEqual(uopt.count(),1,"uopt.count()!=1 for id=%d"%id)
self.assertEqual(uopt[0].priority,max_opt - id + 1)
optfs = OptsFlowSpace.objects.filter(opt = uopt[0])
self.assertEqual(optfs.count(),1)
mstr = optfs[0].matchstruct_set.all()
self.assertNotEqual(mstr.count(),0)
fv_rule = DummyFVRule.objects.filter(match=mstr[0].match,\
dpid="00:00:00:00:00:00:0%d"%id)
self.assertEqual(fv_rule.count(),1)
self.assertEqual(fv_rule[0].priority,mstr[0].priority)
#opt out of all of them
request_post = {}
for id in range(1,max_opt):
request_post["%d"%exp_ids[id-1]] = "checked"
response = test_get_and_post_form(
self.client,
reverse("opt_out_of_experiment"),
request_post,
)
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt),0)
optfs = OptsFlowSpace.objects.filter(opt__user__username="******")
self.assertEqual(optfs.count(),0)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count,0)
def run():
client = Client()
client.login(username=SUPERUSER_USERNAME, password=SUPERUSER_PASSWORD)
# setup the Flowvisor
response = test_get_and_post_form(
client,
reverse("set_flowvisor"),
params=dict(
name="flowvisor",
username=FV_USERNAME,
password=FV_PASSWORD,
password2=FV_PASSWORD,
url=FV_URL,
),
)
assert response.status_code == 301
# setup the Clearinghouse user
response = test_get_and_post_form(
client,
reverse("set_clearinghouse"),
params=dict(
username=CH_USERNAME,
password1=CH_PASSWORD,
password2=CH_PASSWORD,
),
)
assert response.status_code == 301
client.logout()
for username, info in USER_INFO.items():
# create user
User.objects.create_user(username=username,
email=info["email"],
password=info["password"])
client.login(username=username, password=info["password"])
# request flowspace
for fs in info["flowspace"]:
response = test_get_and_post_form(
client,
reverse("user_reg_fs"),
params=dict(
mac_addr=fs["mac_addr"],
ip_addr=fs["ip_addr"],
),
)
assert response.status_code == 301
client.logout()
# Login to approve user requests
client.login(username=SUPERUSER_USERNAME, password=SUPERUSER_PASSWORD)
# Parse the approval form
resp = client.get(reverse("approve_user_reg_table"))
# Get all the forms
d = pq(resp.content, parser="html")
forms = d("form")
for f in forms:
# only post to approve urls
if "approve" in f.action:
client.post(f.action, {})
client.logout()
def test_static_of_links(self):
"""
Tests that we can add/delete openflow-to-openflow static links.
"""
self.test_create_aggregates()
url = reverse("openflow_aggregate_add_links", args=[1])
local_iface = OpenFlowInterface.objects.filter(aggregate__pk=1)[0]
remote_iface = OpenFlowInterface.objects.filter(aggregate__pk=2)[0]
disabled_iface = OpenFlowInterface.objects.filter(aggregate__pk=1)[1]
disabled_iface.available = False
disabled_iface.save()
# check that there are no links already
self.assertEqual(
OpenFlowConnection.objects.filter(
src_iface=local_iface, dst_iface=remote_iface).count(), 0)
self.assertEqual(
OpenFlowConnection.objects.filter(
dst_iface=local_iface, src_iface=remote_iface).count(), 0)
# check that disabled interfaces are not present and enabled ones are.
response = self.client.get(url)
opt_values = get_form_options(response.content)
self.assertFalse(disabled_iface.id in opt_values)
self.assertFalse(local_iface.id in opt_values)
self.assertFalse(remote_iface.id in opt_values)
response = test_get_and_post_form(
self.client, url,
dict(
remote_interface=remote_iface.pk,
local_interface=local_iface.pk,
),
del_params=["delete_links", "add_other_links"]
)
self.assertRedirects(
response,
expected_url=url,
)
# check that the new connection shows up
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 2)
to_link = OpenFlowConnection.objects.get(
src_iface=local_iface, dst_iface=remote_iface)
from_link = OpenFlowConnection.objects.get(
dst_iface=local_iface, src_iface=remote_iface)
# disable an interface to see if the connection still shows
local_iface.available = False
local_iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 0)
# reenable the interface to see if the connection shows back up
local_iface.available = True
local_iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 2)
# test delete
response = test_get_and_post_form(
self.client, url,
dict(
of_connections=[to_link.pk, from_link.pk],
),
del_params=["add_links", "add_other_links"],
)
print response
self.assertRedirects(
response,
expected_url=url,
)
self.assertEqual(
OpenFlowConnection.objects.filter(
src_iface=local_iface, dst_iface=remote_iface).count(), 0)
self.assertEqual(
OpenFlowConnection.objects.filter(
dst_iface=local_iface, src_iface=remote_iface).count(), 0)
def test_static_non_of_links(self):
"""
Tests that we can add/delete openflow-to-openflow static links.
"""
self.test_create_aggregates()
i = 0
url = reverse("openflow_aggregate_add_links", args=[i + 1])
iface = OpenFlowInterface.objects.filter(aggregate__pk=i + 1)[0]
threadlocals.push_frame(user=self.test_user)
self.generic_agg = Aggregate.objects.create(name="TestAggregate")
self.non_of_rsc = []
resource = Resource.objects.create(
name="TestResource%s" % i,
aggregate=self.generic_agg,
)
self.assertEqual(
NonOpenFlowConnection.objects.filter(of_iface=iface,
resource=resource).count(), 0)
response = test_get_and_post_form(
self.client,
url,
dict(
of_iface=iface.pk,
resource=resource.pk,
),
del_params=["delete_links", "add_links"])
self.assertRedirects(
response,
expected_url=url,
)
cnxn = NonOpenFlowConnection.objects.get(of_iface=iface,
resource=resource)
# check that the new connection shows up
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 1)
# disable an interface to see if the connection still shows
iface.available = False
iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 0)
# reenable the interface to see if the connection shows back up
iface.available = True
iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 1)
# test delete
response = test_get_and_post_form(
self.client,
url,
dict(non_of_connections=[cnxn.pk], ),
del_params=["add_links", "add_other_links"],
)
print response
self.assertRedirects(
response,
expected_url=url,
)
self.assertEqual(
NonOpenFlowConnection.objects.filter(of_iface=iface,
resource=resource).count(), 0)
def handle_noargs(self, **options):
username = options.get("username")
password = options.get("password")
filename = options.get("filename")
do_aggs = options.get("load_aggs")
do_slices = options.get("load_slices")
start_slices = options.get("start_slices")
append = options.get("append")
f = open(filename)
data = load(f)
f.close()
client = Client()
client.login(username=username, password=password)
user = User.objects.get(username=username)
threadlocals.get_thread_locals()["user"] = user
if do_aggs:
for agg_dict in data["aggregates"]:
resp = test_get_and_post_form(
client, reverse("openflow_aggregate_create"),
agg_dict,
)
assert(resp.status_code == 302)
assert(
re.search(
r"/openflow/aggregate/\d+/links/$",
resp["Location"]))
if do_slices:
for project_dict in data["projects"]:
project, _ = Project.objects.get_or_create(
name=project_dict["name"],
description=project_dict["description"],
)
create_project_roles(project, user)
threadlocals.get_thread_locals()["project"] = project
# add aggregates to project
for aggregate in OpenFlowAggregate.objects.all():
give_permission_to("can_use_aggregate", aggregate, user)
give_permission_to("can_use_aggregate", aggregate, project)
for aggregate in GCFOpenFlowAggregate.objects.all():
give_permission_to("can_use_aggregate", aggregate, user)
give_permission_to("can_use_aggregate", aggregate, project)
# add slices to project
for slice_dict in project_dict["slices"]:
slice = Slice.objects.create(
name=slice_dict["name"],
description=slice_dict["description"],
project=project,
owner=user,
)
OpenFlowSliceInfo.objects.create(
slice=slice,
controller_url=slice_dict["controller_url"],
password=slice_dict["password"],
)
info, _ = GENISliceInfo.objects.get_or_create(
slice=slice,
)
if not info.ssh_private_key or not info.ssh_public_key:
info.generate_ssh_keys()
info.save()
# add aggregates to slices
for aggregate in OpenFlowAggregate.objects.all():
give_permission_to("can_use_aggregate", aggregate, slice)
for aggregate in GCFOpenFlowAggregate.objects.all():
give_permission_to("can_use_aggregate", aggregate, slice)
# add slivers
slivers = []
for dpid, port in slice_dict["ifaces"]:
try:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice,
resource=OpenFlowInterface.objects.get(
port_num=port, switch__datapath_id=dpid),
)
slivers.append(sliver)
except OpenFlowInterface.DoesNotExist:
continue
# add flowspace
for sfs_dict in slice_dict["sfs"]:
fs_dict = {}
for attr in "dl_src", "dl_dst", "dl_type", "vlan_id", \
"nw_src", "nw_dst", "nw_proto", "tp_dst", "tp_src":
fs_dict[attr+"_start"] = sfs_dict[attr]
fs_dict[attr+"_end"] = sfs_dict[attr]
fs = FlowSpaceRule.objects.create(**fs_dict)
for sliver in slivers:
fs.slivers.add(sliver)
if start_slices:
tl = threadlocals.get_thread_locals()
tl["project"] = project
tl["slice"] = slice
slice.start(user)
def test_add_to_slice(self):
"""
Add the aggregate to a slice.
"""
self.test_add_to_project()
expiration = datetime.now() \
+ timedelta(days=settings.MAX_SLICE_LIFE - 2)
# create slice
response = test_get_and_post_form(
self.client,
url=reverse("slice_create", args=[1]),
params=dict(
name="slice",
description="description",
expiration_date_0="%s" % expiration.date(),
expiration_date_1=expiration.time().strftime("%H:%m:%S"),
),
)
slice = Slice.objects.all()[0]
self.assertRedirects(
response,
reverse("slice_detail", args=[slice.id]),
)
slice_add_agg_url = reverse("slice_add_agg", args=[slice.id])
# add aggregates to slice
for i in range(1, 4):
openflow_aggregate_slice_add_url = reverse(
"openflow_aggregate_slice_add",
kwargs={
"agg_id": i,
"slice_id": slice.id,
})
# post the form to add aggregate to slice
response = self.client.post(
path=slice_add_agg_url,
data={"id": i},
)
# should go the openflow special add aggregates page
self.assertRedirects(
response,
openflow_aggregate_slice_add_url + "?next=" +
slice_add_agg_url,
)
# Set the slice info
response = test_get_and_post_form(
self.client,
openflow_aggregate_slice_add_url + "?next=" +
slice_add_agg_url,
params=dict(
controller_url="tcp:blabla:6633",
password="******",
))
self.assertRedirects(
response,
slice_add_agg_url,
)
self.assertEqual(slice.aggregates.count(), i,
"Did not add aggregates to slice.")
def test_add_to_slice(self):
"""
Add the aggregate to a slice.
"""
self.test_add_to_project()
expiration = datetime.now() \
+ timedelta(days=settings.MAX_SLICE_LIFE - 2)
# create slice
response = test_get_and_post_form(
self.client,
url=reverse("slice_create", args=[1]),
params=dict(
name="slice",
description="description",
expiration_date_0="%s" % expiration.date(),
expiration_date_1=expiration.time().strftime("%H:%m:%S"),
),
)
slice = Slice.objects.all()[0]
self.assertRedirects(
response,
reverse("slice_detail", args=[slice.id]),
)
slice_add_agg_url = reverse("slice_add_agg", args=[slice.id])
# add aggregates to slice
for i in range(1, 4):
openflow_aggregate_slice_add_url = reverse(
"openflow_aggregate_slice_add",
kwargs={
"agg_id": i,
"slice_id": slice.id,
}
)
# post the form to add aggregate to slice
response = self.client.post(
path=slice_add_agg_url,
data={"id": i},
)
# should go the openflow special add aggregates page
self.assertRedirects(
response,
openflow_aggregate_slice_add_url+ "?next=" + slice_add_agg_url,
)
# Set the slice info
response = test_get_and_post_form(
self.client,
openflow_aggregate_slice_add_url+ "?next=" + slice_add_agg_url,
params=dict(
controller_url="tcp:blabla:6633",
password="******",
)
)
self.assertRedirects(
response,
slice_add_agg_url,
)
self.assertEqual(
slice.aggregates.count(), i,
"Did not add aggregates to slice.")
def test_update_slice_and_optin(self):
'''
Test if updating a slice when there are some opt-ins actually update the opt-ins
'''
user_ip_addr_s = "192.168.0.123"
user_ip_addr_e = "192.168.0.124"
ip_addr_s = "192.168.0.123"
ip_addr_e = "192.168.0.126"
new_ip_addr_s = "192.168.0.125"
new_ip_addr_e = "192.168.0.128"
# create a user and assign a FS to him:
u = User.objects.create_user("username", "*****@*****.**", "password")
UserProfile.get_or_create_profile(u)
UserFlowSpace.objects.create(user=u,approver=self.test_admin,
ip_src_s=dotted_ip_to_int(user_ip_addr_s)
,ip_src_e=dotted_ip_to_int(user_ip_addr_e))
args = {
"slice_id": 1,
"project_name": "project_name 1",
"project_description": "project_description 1",
"slice_name": "new slice name-1",
"slice_description": "new slice_description",
"controller_url": "bla:bla.bla.bla:6633",
"owner_email": "*****@*****.**",
"owner_password": "******",
"switch_slivers": [
{
"datapath_id": "00:00:00:00:00:00:01",
"flowspace": [
{"nw_src_start":"%s"%ip_addr_s,"nw_src_send":"%s"%ip_addr_e},
],
},
{
"datapath_id": "00:00:00:00:00:00:02",
"flowspace": [
{"nw_src_start":"%s"%new_ip_addr_s,"nw_src_send":"%s"%new_ip_addr_e},
],
},
]
}
# Create!
ret = self.om_client.create_slice(
args["slice_id"], args["project_name"], args["project_description"],
args["slice_name"], args["slice_description"],
args["controller_url"], args["owner_email"], args["owner_password"],
args["switch_slivers"]
)
# now test that just one experiment exist and that is the
# updated version:
# check the return value
self.assertEqual(ret, {'error_msg': "", 'switches': []})
# check the OM database to see if Experiment has been created correctly
returned = Experiment.objects.filter(slice_id=args["slice_id"])
self.assertEqual(
returned.count(), 1 ,
"more than one slice with same name %s" % args["slice_name"])
# now opt-in user:
self.client.login(username="******",password="******")
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment":1},
)
# now test if opt-in was correct
self.assertContains(response, "successfully")
optfs = OptsFlowSpace.objects.filter(opt__user=u)
self.assertEqual(optfs.count(),1)
self.assertEqual(optfs[0].dpid,"00:00:00:00:00:00:01")
self.assertEqual(optfs[0].ip_src_s,dotted_ip_to_int(user_ip_addr_s))
self.assertEqual(optfs[0].ip_src_e,dotted_ip_to_int(user_ip_addr_e))
# now change the experiments flowspace, verify that user opt
# updated accordingly:
args = {
"slice_id": 1,
"project_name": "project_name 1",
"project_description": "project_description 1",
"slice_name": "new slice name-1",
"slice_description": "new slice_description",
"controller_url": "bla:bla.bla.bla:6633",
"owner_email": "*****@*****.**",
"owner_password": "******",
"switch_slivers": [
{
"datapath_id": "00:00:00:00:00:00:01",
"flowspace": [
{"nw_src_start":"%s"%new_ip_addr_s,"nw_src_send":"%s"%new_ip_addr_e},
],
},
{
"datapath_id": "00:00:00:00:00:00:02",
"flowspace": [
{"nw_src_start":"%s"%new_ip_addr_s,"nw_src_send":"%s"%new_ip_addr_e},
],
},
]
}
# Create!
ret = self.om_client.create_slice(
args["slice_id"], args["project_name"], args["project_description"],
args["slice_name"], args["slice_description"],
args["controller_url"], args["owner_email"], args["owner_password"],
args["switch_slivers"]
)
# now test that just one experiment exist and that is the
# updated version:
# check the return value
self.assertEqual(ret, {'error_msg': "", 'switches': []})
optfs = OptsFlowSpace.objects.filter(opt__user=u)
self.assertEqual(optfs.count(),0)
def test_user_multiple_opts(self):
'''
Opt into multiple experiments,change their priorities and then opt all out.
at each of the three steps, test internal database to make sure that it is done
correctly.
'''
max_opt = random.randint(5, 9)
exp_ids = []
first_id = Experiment.objects.all()[0].id
exp_ids.append(first_id)
for index in range(2, max_opt):
#create a random number of experiments
exp = Experiment.objects.create(slice_id="slice_id_%d" % index,
project_name="project name_%d" %
index,
project_desc="project description",
slice_name="slice name_%d" % index,
slice_desc="slice description",
controller_url="controller url",
owner_email="owner email",
owner_password="******")
expfs = ExperimentFLowSpace.objects.create(
exp=exp,
dpid="00:00:00:00:00:00:0%d" % index,
ip_src_s=random.randint(0, 0x80000000) & 0xFFFF0000,
ip_src_e=random.randint(0x80000000, 0xFFFFFFFF) & 0xFFFF0000,
)
expfs.save()
exp_ids.append(exp.id)
# opt into all of them
count = 0
for exp in Experiment.objects.all():
count = count + 1
response = test_get_and_post_form(
self.client,
reverse("opt_in_experiment"),
{"experiment": exp.id},
)
self.assertContains(response, "successfully")
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), count)
self.assertEqual(uopt[count - 1].experiment.slice_name,
exp.slice_name)
optfs = OptsFlowSpace.objects.filter(opt=uopt[count - 1])
self.assertEqual(len(optfs), 1)
# change priority
request_post = {}
for id in range(1, max_opt):
request_post["p_%d" % exp_ids[id - 1]] = max_opt - id + 1
response = test_get_and_post_form(
self.client,
reverse("change_priority"),
request_post,
)
self.assertContains(response, "Successfully")
for id in range(1, max_opt):
uopt = UserOpts.objects.filter(user__username__exact="user",\
experiment__slice_name="slice name_%d"%id)
self.assertEqual(uopt.count(), 1, "uopt.count()!=1 for id=%d" % id)
self.assertEqual(uopt[0].priority, max_opt - id + 1)
optfs = OptsFlowSpace.objects.filter(opt=uopt[0])
self.assertEqual(optfs.count(), 1)
mstr = optfs[0].matchstruct_set.all()
self.assertNotEqual(mstr.count(), 0)
fv_rule = DummyFVRule.objects.filter(match=mstr[0].match,\
dpid="00:00:00:00:00:00:0%d"%id)
self.assertEqual(fv_rule.count(), 1)
self.assertEqual(fv_rule[0].priority, mstr[0].priority)
#opt out of all of them
request_post = {}
for id in range(1, max_opt):
request_post["%d" % exp_ids[id - 1]] = "checked"
response = test_get_and_post_form(
self.client,
reverse("opt_out_of_experiment"),
request_post,
)
uopt = UserOpts.objects.filter(user__username__exact="user")
self.assertEqual(len(uopt), 0)
optfs = OptsFlowSpace.objects.filter(opt__user__username="******")
self.assertEqual(optfs.count(), 0)
actual_fv_rules_count = DummyFVRule.objects.all().count()
self.assertEqual(actual_fv_rules_count, 0)
def test_static_of_links(self):
"""
Tests that we can add/delete openflow-to-openflow static links.
"""
self.test_create_aggregates()
url = reverse("openflow_aggregate_add_links", args=[1])
local_iface = OpenFlowInterface.objects.filter(aggregate__pk=1)[0]
remote_iface = OpenFlowInterface.objects.filter(aggregate__pk=2)[0]
disabled_iface = OpenFlowInterface.objects.filter(aggregate__pk=1)[1]
disabled_iface.available = False
disabled_iface.save()
# check that there are no links already
self.assertEqual(
OpenFlowConnection.objects.filter(src_iface=local_iface,
dst_iface=remote_iface).count(),
0)
self.assertEqual(
OpenFlowConnection.objects.filter(dst_iface=local_iface,
src_iface=remote_iface).count(),
0)
# check that disabled interfaces are not present and enabled ones are.
response = self.client.get(url)
opt_values = get_form_options(response.content)
self.assertFalse(disabled_iface.id in opt_values)
self.assertFalse(local_iface.id in opt_values)
self.assertFalse(remote_iface.id in opt_values)
response = test_get_and_post_form(
self.client,
url,
dict(
remote_interface=remote_iface.pk,
local_interface=local_iface.pk,
),
del_params=["delete_links", "add_other_links"])
self.assertRedirects(
response,
expected_url=url,
)
# check that the new connection shows up
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 2)
to_link = OpenFlowConnection.objects.get(src_iface=local_iface,
dst_iface=remote_iface)
from_link = OpenFlowConnection.objects.get(dst_iface=local_iface,
src_iface=remote_iface)
# disable an interface to see if the connection still shows
local_iface.available = False
local_iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 0)
# reenable the interface to see if the connection shows back up
local_iface.available = True
local_iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='of_connections']")
self.assertEqual(len(cnxns), 2)
# test delete
response = test_get_and_post_form(
self.client,
url,
dict(of_connections=[to_link.pk, from_link.pk], ),
del_params=["add_links", "add_other_links"],
)
print response
self.assertRedirects(
response,
expected_url=url,
)
self.assertEqual(
OpenFlowConnection.objects.filter(src_iface=local_iface,
dst_iface=remote_iface).count(),
0)
self.assertEqual(
OpenFlowConnection.objects.filter(dst_iface=local_iface,
src_iface=remote_iface).count(),
0)
def test_static_non_of_links(self):
"""
Tests that we can add/delete openflow-to-openflow static links.
"""
self.test_create_aggregates()
i = 0
url = reverse("openflow_aggregate_add_links", args=[i+1])
iface = OpenFlowInterface.objects.filter(aggregate__pk=i+1)[0]
threadlocals.push_frame(user=self.test_user)
self.generic_agg = Aggregate.objects.create(
name="TestAggregate")
self.non_of_rsc = []
resource = Resource.objects.create(
name="TestResource%s" % i,
aggregate=self.generic_agg,
)
self.assertEqual(
NonOpenFlowConnection.objects.filter(
of_iface=iface, resource=resource).count(), 0)
response = test_get_and_post_form(
self.client, url,
dict(
of_iface=iface.pk,
resource=resource.pk,
),
del_params=["delete_links", "add_links"]
)
self.assertRedirects(
response,
expected_url=url,
)
cnxn = NonOpenFlowConnection.objects.get(
of_iface=iface, resource=resource)
# check that the new connection shows up
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 1)
# disable an interface to see if the connection still shows
iface.available = False
iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 0)
# reenable the interface to see if the connection shows back up
iface.available = True
iface.save()
response = self.client.get(url)
d = pq(response.content, parser="html")
cnxns = d("input[name='non_of_connections']")
self.assertEqual(len(cnxns), 1)
# test delete
response = test_get_and_post_form(
self.client, url,
dict(
non_of_connections=[cnxn.pk],
),
del_params=["add_links", "add_other_links"],
)
print response
self.assertRedirects(
response,
expected_url=url,
)
self.assertEqual(
NonOpenFlowConnection.objects.filter(
of_iface=iface, resource=resource).count(), 0)
