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)