def setUp(self):
self.staff = UserFactory(is_staff=True)
self.owner = UserFactory()
self.user = UserFactory()
self.customer = CustomerFactory()
self.customer.add_user(self.owner, CustomerRole.OWNER)
self.url = reverse('customer_image',
kwargs={'uuid': self.customer.uuid.hex})
def setUp(self):
from waldur_core.structure.tests.factories import UserFactory
self.user = UserFactory(is_staff=True)
self.request = APIRequestFactory().get('/')
self.request.user = self.user
self.field = GenericRelatedField(related_models=get_loggable_models())
self.field.root._context = {'request': self.request}
def change_user(self, **kwargs):
user = UserFactory()
form_for_data = UserChangeForm(instance=user)
post_data = form_for_data.initial
post_data.update(kwargs)
form = UserChangeForm(instance=user, data=post_data)
form.save()
user.refresh_from_db()
return user
def change_user(self, **kwargs):
user = UserFactory()
ma = UserAdmin(User, AdminSite())
UserChangeForm = ma.get_form(request, user, change=True)
form_for_data = UserChangeForm(instance=user)
post_data = form_for_data.initial
post_data.update(kwargs)
form = UserChangeForm(instance=user, data=post_data)
form.save()
user.refresh_from_db()
return user
def setUp(self) -> None:
self.mp_fixture = marketplace_fixtures.MarketplaceFixture()
self.project = self.mp_fixture.project
self.new_user = UserFactory()
resource = self.mp_fixture.resource
resource.set_state_ok()
resource.save()
self.resource = resource
offering = self.mp_fixture.offering
offering.backend_id = 'ABC'
offering.secret_options = {
'api_url': 'http://offerings.example.com/api',
'token': 'AAABBBCCC',
'customer_uuid': '12345',
}
offering.type = PLUGIN_NAME
offering.activate()
offering.save()
self.offering = offering
self.customer = self.mp_fixture.customer
self.patcher = mock.patch(
"waldur_mastermind.marketplace_remote.utils.WaldurClient")
client_mock = self.patcher.start()
client_mock().get_remote_eduteams_user.return_value = {
'uuid': REMOTE_USER_UUID
}
client_mock().list_projects.return_value = [{
'uuid': REMOTE_PROJECT_UUID
}]
client_mock().get_project_permissions.return_value = []
self.client_mock = client_mock
def test_service_provider_can_get_resource_data(self):
owner = UserFactory()
self.offering.customer.add_user(owner,
structure_models.CustomerRole.OWNER)
response = self.get_resource()
self.assertEqual(response.status_code, status.HTTP_200_OK)
def make_request(self, fields):
from waldur_core.structure.tests.factories import UserFactory
request = APIRequestFactory().get('/', {'field': fields})
force_authenticate(request, UserFactory())
response = RestrictedSerializerView.as_view()(request)
return response
def create_offering_user(self, user):
self.client.force_authenticate(user=getattr(self.fixture, user))
offering_url = factories.OfferingFactory.get_url(self.offering)
user_url = UserFactory.get_url(self.fixture.user)
payload = {'offering': offering_url, 'user': user_url}
return self.client.post(reverse('marketplace-offering-user-list'),
payload)
def test_user_details_are_rendered(self):
self.client.force_login(UserFactory())
responses.add(
responses.GET,
'http://example.com/',
json={
'nameen': 'User',
'namebn': 'User',
'desig': 'সহকারী সচিব',
'office': 'Secretariat',
},
)
response = self.client.get(self.URL, {
'civil_number': '123',
'tax_number': '456-789'
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data,
{
'full_name': 'User',
'native_name': 'User',
'job_title': 'সহকারী সচিব',
'organization': 'Secretariat',
},
)
def test_offering_lookup_succeeds_if_more_than_one_manager_exists(self):
self.client.force_authenticate(self.fixture.user)
user = UserFactory()
OfferingPermission.objects.create(
offering=self.offering, user=user, is_active=True
)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
def test_native_name_is_rendered_in_user_admin_if_feature_is_enabled(self):
user = UserFactory()
ma = UserAdmin(User, AdminSite())
self.assertTrue('native_name' in ma.get_list_display(request))
self.assertTrue('native_name' in ma.get_search_fields(request))
self.assertTrue(
any('native_name' in fieldset[1]['fields']
for fieldset in ma.get_fieldsets(request, user)))
def test_feature_is_not_updated_if_it_is_not_defined(self):
user = UserFactory(is_staff=True)
self.client.force_login(user)
response = self.client.post('/api/feature-values/',
{'marketplace': {
'foo': True
}})
self.assertEqual(response.data, '0 features are updated.')
def test_user_can_update_threshold(self):
self.client.force_authenticate(UserFactory(is_staff=True))
response = self.client.put(QuotaFactory.get_url(self.quota), {
'threshold': 1000,
})
self.assertEqual(status.HTTP_200_OK, response.status_code,
response.data)
self.assertEqual(1000, response.data['threshold'], response.data)
def test_non_staff_can_not_update_features(self):
user = UserFactory()
self.client.force_login(user)
response = self.client.post('/api/feature-values/',
{'marketplace': {
'flows': True
}})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def grant_permission(self, user):
self.client.force_authenticate(user=getattr(self.fixture, user))
return self.client.post(
reverse('marketplace-offering-permission-list'),
{
'offering': factories.OfferingFactory.get_url(self.offering),
'user': UserFactory.get_url(self.fixture.user),
},
)
def setUp(self):
self.list_url = reverse('marketplace-offering-activate-request-list')
self.fixture = SupportFixture()
self.offering = self.fixture.offering
self.offering.state = Offering.States.DRAFT
self.offering.save()
self.plan = self.fixture.plan
self.user = UserFactory()
self.offering_url = OfferingFactory.get_url(self.offering)
class GenericRelatedFieldTest(APITransactionTestCase):
def setUp(self):
from waldur_core.structure.tests.factories import UserFactory
self.user = UserFactory(is_staff=True)
self.request = APIRequestFactory().get('/')
self.request.user = self.user
self.field = GenericRelatedField(related_models=get_loggable_models())
self.field.root._context = {'request': self.request}
def test_if_related_object_exists_it_is_deserialized(self):
from waldur_core.structure.tests.factories import CustomerFactory
customer = CustomerFactory()
valid_url = CustomerFactory.get_url(customer)
self.assertEqual(self.field.to_internal_value(valid_url), customer)
def test_if_related_object_does_not_exist_validation_error_is_raised(self):
from waldur_core.structure.tests.factories import CustomerFactory
customer = CustomerFactory()
valid_url = CustomerFactory.get_url(customer)
customer.delete()
self.assertRaises(serializers.ValidationError,
self.field.to_internal_value, valid_url)
def test_if_user_does_not_have_permissions_for_related_object_validation_error_is_raised(
self, ):
from waldur_core.structure.tests.factories import CustomerFactory
customer = CustomerFactory()
valid_url = CustomerFactory.get_url(customer)
self.user.is_staff = False
self.user.save()
self.assertRaises(serializers.ValidationError,
self.field.to_internal_value, valid_url)
def test_if_uuid_is_invalid_validation_error_is_raised(self):
invalid_url = 'https://example.com/api/customers/invalid/'
self.assertRaises(serializers.ValidationError,
self.field.to_internal_value, invalid_url)
def setUp(self):
self.fixture = fixtures.ProjectFixture()
self.project = self.fixture.project
self.resource = factories.ResourceFactory(project=self.project)
self.url = factories.ResourceFactory.get_url(
self.resource, action='submit_report'
)
self.valid_report = [{'header': 'Section header', 'body': 'Section body'}]
service_manager = UserFactory()
self.resource.offering.customer.add_user(
service_manager, role=structure_models.CustomerRole.SERVICE_MANAGER
)
setattr(self.fixture, 'service_manager', service_manager)
service_owner = UserFactory()
self.resource.offering.customer.add_user(
service_owner, role=structure_models.CustomerRole.OWNER
)
setattr(self.fixture, 'service_owner', service_manager)
def test_error_is_handled(self):
self.client.force_login(UserFactory())
responses.add(responses.GET,
'http://example.com/',
json={'error': 'Invalid request'})
response = self.client.get(self.URL, {
'civil_number': '123',
'tax_number': '456-789'
})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['details'], 'Invalid request')
def test_service_provider_can_terminate_resource(self, mocked_approve):
# Arrange
owner = UserFactory()
self.offering.customer.add_user(owner, structure_models.CustomerRole.OWNER)
# Act
response = self.terminate(owner)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
mocked_approve.assert_not_called()
def test_new_revisions_are_not_created_on_each_authentication(self):
staff = UserFactory(is_staff=True, is_superuser=True)
staff_password = User.objects.make_random_password()
staff.set_password(staff_password)
staff.save()
self.assertTrue(
self.client.login(username=staff.username,
password=staff_password))
url = '/admin/core/user/add/'
user_password = User.objects.make_random_password()
self.client.post(
url,
{
'username': '******',
'password1': user_password,
'password2': user_password,
},
)
user = User.objects.get(username='******')
ct = ContentType.objects.get_for_model(user)
self.assertEqual(
Version.objects.filter(object_id=user.id, content_type=ct).count(),
1)
user.is_staff = True
user.save()
self.assertTrue(
self.client.login(username=user.username, password=user_password))
self.assertEqual(
Version.objects.filter(object_id=user.id, content_type=ct).count(),
1)
def setUp(self):
self.fixture = fixtures.ProjectFixture()
self.project = self.fixture.project
self.resource = factories.ResourceFactory(project=self.project)
self.url = factories.ResourceFactory.get_url(
self.resource, action='set_backend_id'
)
service_manager = UserFactory()
self.resource.offering.customer.add_user(
service_manager, role=structure_models.CustomerRole.SERVICE_MANAGER
)
setattr(self.fixture, 'service_manager', service_manager)
def test_empty_response_is_rendered_as_error(self):
self.client.force_login(UserFactory())
responses.add(responses.GET,
'http://example.com/',
json={
'nameen': '',
'namebn': '',
'desig': '',
'office': '',
})
response = self.client.get(self.URL, {
'civil_number': '123',
'tax_number': '456-789'
})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_rancher_cluster_is_filtered_out_for_unrelated_user(self):
project = ProjectFactory(customer=self.fixture.customer)
admin = UserFactory()
project.add_user(admin, ProjectRole.ADMINISTRATOR)
vm = openstack_tenant_factories.InstanceFactory(
service_settings=self.fixture.tenant_settings,
project=project,
state=StateMixin.States.OK,
)
self.client.force_authenticate(admin)
response = self.client.get(
openstack_tenant_factories.InstanceFactory.get_url(vm)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['rancher_cluster'], None)
def test_staff_can_update_feature(self):
user = UserFactory(is_staff=True)
self.client.force_login(user)
response = self.client.get('/api/configuration/')
self.assertFalse(response.data['FEATURES']['marketplace']['flows'])
response = self.client.post('/api/feature-values/',
{'marketplace': {
'flows': True
}})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.client.get('/api/configuration/')
self.assertTrue(
models.Feature.objects.get(key="marketplace.flows").value)
def test_remote_customers_are_listed_for_given_token_and_api_url(self):
responses.add(responses.GET,
'https://remote-waldur.com/customers/',
json=[])
self.client.force_login(UserFactory())
response = self.client.post(
'/api/remote-waldur-api/remote_customers/',
{
'api_url': 'https://remote-waldur.com/',
'token': 'valid_token',
},
)
self.assertEqual(responses.calls[0].request.headers['Authorization'],
'token valid_token')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_accounting_is_running_filter_behaves_properly(self):
staff = UserFactory(is_staff=True)
self.client.force_authenticate(user=staff)
response = self.client.get(ProjectFactory.get_list_url())
self.assertEqual(len(response.data), 2)
response = self.client.get(ProjectFactory.get_list_url(), {
"accounting_is_running": "true",
})
self.assertEqual(len(response.data), 1)
response = self.client.get(ProjectFactory.get_list_url(), {
"accounting_is_running": "false",
})
self.assertEqual(len(response.data), 1)
def setUp(self):
super(CreateResourceFlowTest, self).setUp()
self.list_url = reverse('marketplace-resource-creation-flow-list')
self.fixture = SupportFixture()
self.offering = self.fixture.offering
self.offering.state = Offering.States.ACTIVE
self.offering.save()
self.plan = self.fixture.plan
self.user = UserFactory()
self.payload = {
'customer_create_request': {
'name': 'XYZ corp'
},
'project_create_request': {
'name': 'First project'
},
'resource_create_request': {
'name': 'Test VM',
'offering': OfferingFactory.get_url(self.offering),
'plan': PlanFactory.get_url(self.plan),
'attributes': {},
},
}
def setUp(self):
self.user = UserFactory()
self.customer = CustomerFactory()
def test_authenticated_user_can_access_version(self):
user = UserFactory()
self.client.force_authenticate(user=user)
response = self.client.get(self.version_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
