def test_pause_resume_wrong_id(server, https):
version = 11
service = server.get_service('collection-management-A')
poll_service = server.get_service('poll-A')
headers = prepare_headers(version, https)
# Subscribing
request = prepare_request(collection=COLLECTION_OPEN, action=ACT_SUBSCRIBE,
version=version)
response = service.process(headers, request)
assert isinstance(response, as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
assert subs.status == SS_ACTIVE
# Pausing with wrong subscription ID
with pytest.raises(exceptions.StatusMessageException):
request = prepare_request(collection=COLLECTION_OPEN, action=ACT_PAUSE,
subscription_id="RANDOM-WRONG-SUBSCRIPTION", version=version)
response = service.process(headers, request)
# Resuming with wrong subscription ID
with pytest.raises(exceptions.StatusMessageException):
request = prepare_request(collection=COLLECTION_OPEN, action=ACT_RESUME,
subscription_id="RANDOM-WRONG-SUBSCRIPTION", version=version)
response = service.process(headers, request)
def setUpClass(cls):
"""Standart SetUpClass method of unittest.TestCase."""
cls.api_rooms_url = 'http://makechat-web/api/rooms'
cls.api_login_url = 'http://makechat-web/api/login'
User.drop_collection() # erase the users collection
Room.drop_collection() # erase the rooms collection
cls.user = User.objects.create(
username='******', email='*****@*****.**',
password=encrypt_password('test'))
cls.admin = User.objects.create(
username='******', email='*****@*****.**',
password=encrypt_password('admin'), is_superuser=True)
res = make_request(prepare_request(
cls.api_login_url, {'username': '******', 'password': '******'}))
cls.user_session = res.headers['set-cookie'] \
.split(';')[0].split('=')[1]
res = make_request(prepare_request(
cls.api_login_url, {'username': '******', 'password': '******'}))
cls.admin_session = res.headers['set-cookie'] \
.split(';')[0].split('=')[1]
def test_1_create_token(self):
"""Attempt to create token."""
res = make_request(prepare_request(
self.api_tokens_url, {'name': 'token1'}, session=self.session))
self.assertEqual(res.content.get('name'), 'token1')
self.assertEqual(res.code, 201)
res = make_request(prepare_request(
self.api_tokens_url, {'name': 'token2'}, session=self.session))
self.assertEqual(res.content.get('name'), 'token2')
self.assertEqual(res.code, 201)
def test_unsubscribe(server, version, https):
service = server.get_service('collection-management-A')
headers = prepare_headers(version, https)
params = dict(response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING])
# Subscribing
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_SUBSCRIBE,
version=version,
params=params)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
subscription_id = subs.subscription_id
# Unsubscribing with invalid subscription ID should still
# return valid response
INVALID_ID = "RANDOM-WRONG-SUBSCRIPTION"
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_UNSUBSCRIBE,
subscription_id=INVALID_ID,
version=version)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id == INVALID_ID
# Unsubscribing with valid subscription ID
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_UNSUBSCRIBE,
subscription_id=subscription_id,
version=version)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id == subscription_id
if version == 11:
assert subs.status == SS_UNSUBSCRIBED
assert (server.persistence.get_subscription(subscription_id).status ==
SS_UNSUBSCRIBED)
def test_unsubscribe(server, version, https):
service = server.get_service('collection-management-A')
headers = prepare_headers(version, https)
params = dict(
response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING]
)
# Subscribing
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_SUBSCRIBE,
version=version, params=params)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
subscription_id = subs.subscription_id
# Unsubscribing with invalid subscription ID should still
# return valid response
INVALID_ID = "RANDOM-WRONG-SUBSCRIPTION"
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_UNSUBSCRIBE,
subscription_id=INVALID_ID, version=version)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id == INVALID_ID
# Unsubscribing with valid subscription ID
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_UNSUBSCRIBE,
subscription_id=subscription_id, version=version)
response = service.process(headers, request)
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id == subscription_id
if version == 11:
assert subs.status == SS_UNSUBSCRIBED
assert (
server.persistence.get_subscription(subscription_id).status ==
SS_UNSUBSCRIBED)
def test_2_invalid_creds(self):
"""Attempt to login with incorrect credentials."""
# invalid password
res = make_request(prepare_request(
self.api_url, {'username': '******', 'password': '******'}))
self.assertEqual(res.code, 401)
# invalid username
res = make_request(prepare_request(
self.api_url, {'username': '******', 'password': '******'}))
self.assertEqual(res.code, 401)
# invalid username and password
res = make_request(prepare_request(
self.api_url, {'username': '******', 'password': '******'}))
self.assertEqual(res.code, 401)
def test_3_get_all_rooms(self):
"""Attempt to get all rooms."""
res = make_request(prepare_request(
self.api_rooms_url, {}, method='GET', session=self.admin_session))
self.assertEqual(res.code, 200)
self.assertEqual([
x['name'] for x in res.content['items']], ['room1', 'room2'])
def test_3_valid_form_data_email_exist(self):
"""Attempt to register with valid form data and existing email."""
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': '*****@*****.**',
'password1': 'test3', 'password2': 'test3'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('description'),
'Email is already taken.')
def test_subscribe(server, version, https):
service = server.get_service('collection-management-A')
poll_service = server.get_service('poll-A')
headers = prepare_headers(version, https)
params = dict(
response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING]
)
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_SUBSCRIBE,
version=version, params=params)
response = service.process(headers, request)
if version == 11:
assert isinstance(
response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
else:
assert isinstance(
response,
as_tm(version).ManageFeedSubscriptionResponse)
assert response.feed_name == COLLECTION_OPEN
assert response.message == SUBSCRIPTION_MESSAGE
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
# 1 poll service * 2 protocol bindings
assert len(subs.poll_instances) == 2
assert (
subs.poll_instances[0].poll_address ==
poll_service.get_absolute_address(
subs.poll_instances[0].poll_protocol))
if version == 11:
assert subs.status == SS_ACTIVE
response_bindings = [
b.binding_id
for b in subs.subscription_parameters.content_bindings]
assert response_bindings == params['content_bindings']
assert (
subs.subscription_parameters.response_type ==
params['response_type'])
def test_2_get_user_tokens(self):
"""Attempt to get user tokens."""
res = make_request(prepare_request(
self.api_tokens_url, {}, method='GET', session=self.session))
self.assertEqual(res.code, 200)
items = res.content['items']
self.assertEqual(len(items), 2)
self.assertEqual(items[0]['name'], 'token1')
self.assertEqual(items[0]['user']['$oid'], str(self.user.pk))
self.assertEqual(items[1]['name'], 'token2')
self.assertEqual(items[1]['user']['$oid'], str(self.user.pk))
def test_2_create_room_wit_admin_permissions(self):
"""Attempt to create room with admin permissions."""
res = make_request(prepare_request(
self.api_rooms_url, {'name': 'room1'}, session=self.admin_session))
self.assertEqual(res.code, 201)
self.assertEqual(res.content.get('name'), 'room1')
self.assertEqual(res.content.get('members'), [
{
'$oid': str(
Member.objects.get(profile=self.admin, role='owner').id)
}
])
res = make_request(prepare_request(
self.api_rooms_url, {'name': 'room2'}, session=self.admin_session))
self.assertEqual(res.code, 201)
self.assertEqual(res.content.get('name'), 'room2')
self.assertEqual(res.content.get('members'), [
{
'$oid': str(
Member.objects.get(profile=self.admin, role='owner').id)
}
])
def test_subscribe(server, version, https):
service = server.get_service('collection-management-A')
poll_service = server.get_service('poll-A')
headers = prepare_headers(version, https)
params = dict(response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING])
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_SUBSCRIBE,
version=version,
params=params)
response = service.process(headers, request)
if version == 11:
assert isinstance(response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
else:
assert isinstance(response,
as_tm(version).ManageFeedSubscriptionResponse)
assert response.feed_name == COLLECTION_OPEN
assert response.message == SUBSCRIPTION_MESSAGE
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
# 1 poll service * 2 protocol bindings
assert len(subs.poll_instances) == 2
assert (subs.poll_instances[0].poll_address ==
poll_service.get_absolute_address(
subs.poll_instances[0].poll_protocol))
if version == 11:
assert subs.status == SS_ACTIVE
response_bindings = [
b.binding_id for b in subs.subscription_parameters.content_bindings
]
assert response_bindings == params['content_bindings']
assert (subs.subscription_parameters.response_type ==
params['response_type'])
def setUpClass(cls):
"""Standart SetUpClass method of unittest.TestCase."""
cls.api_tokens_url = 'http://makechat-web/api/tokens'
cls.api_login_url = 'http://makechat-web/api/login'
User.drop_collection() # erase the users collection
Token.drop_collection() # erase the tokens collection
cls.user = User.objects.create(
username='******', email='*****@*****.**',
password=encrypt_password('test'))
res = make_request(prepare_request(
cls.api_login_url, {'username': '******', 'password': '******'}))
cls.session = res.headers['set-cookie'].split(';')[0].split('=')[1]
def test_4_invalid_form_data(self):
"""Attempt to register with invalid form data."""
# username, email, password2 are misssing
res = make_request(prepare_request(
self.api_url, {'password1': 'test2'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('title'), 'Missing parameter')
# email, password2 are misssing
res = make_request(prepare_request(
self.api_url, {'username': '******', 'password1': 'test2'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('title'), 'Missing parameter')
# password2 is misssing
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': '*****@*****.**',
'password1': 'test2'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('title'), 'Missing parameter')
# Passwords do not match
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': '*****@*****.**',
'password1': 'test2', 'password2': '2222'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('description'),
'Passwords do not match.')
# Bad username string which contains non ASCII chars
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': '*****@*****.**',
'password1': 'test2', 'password2': 'test2'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('description'),
"{'username': '******'}")
# Bad username string which contains non ASCII chars
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': 'test@a',
'password1': 'test2', 'password2': 'test2'}))
self.assertEqual(res.code, 400)
self.assertEqual(res.content.get('description'),
"{'email': 'Invalid Mail-address: test@a'}")
def test_1_create_room_without_admin_permissions(self):
"""Attempt to create room without admin permissions."""
res = make_request(prepare_request(
self.api_rooms_url, {'name': 'room1'}, session=self.user_session))
self.assertEqual(res.code, 403)
def test_subscribe_pause_resume(server, https):
version = 11
service = server.get_service('collection-management-A')
headers = prepare_headers(version, https)
params = dict(
response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING]
)
# Subscribing
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_SUBSCRIBE,
version=version, params=params)
response = service.process(headers, request)
assert isinstance(
response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.status == SS_ACTIVE
assert (
server.persistence.get_subscription(subs.subscription_id).status ==
SS_ACTIVE)
# Pausing
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_PAUSE,
subscription_id=subs.subscription_id, version=version)
response = service.process(headers, request)
assert isinstance(
response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
assert subs.status == SS_PAUSED
assert (
server.persistence.get_subscription(subs.subscription_id).status ==
SS_PAUSED)
# Resume
request = prepare_request(
collection=COLLECTION_OPEN, action=ACT_RESUME,
subscription_id=subs.subscription_id, version=version)
response = service.process(headers, request)
assert isinstance(
response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
assert subs.status == SS_ACTIVE
assert (
server.persistence.get_subscription(subs.subscription_id).status ==
SS_ACTIVE)
def test_1_valid_form_data(self):
"""Attempt to register with valid form data."""
res = make_request(prepare_request(
self.api_url, {'username': '******', 'email': '*****@*****.**',
'password1': 'test2', 'password2': 'test2'}))
self.assertEqual(res.code, 201)
def test_1_ping_api_user_is_authenticated(self):
"""Attempt to ping api with successful authorization."""
res = make_request(prepare_request(
self.api_ping_url, {}, method='GET', session=self.user_session))
self.assertEqual(res.code, 200)
def test_subscribe_pause_resume(server, https):
version = 11
service = server.get_service('collection-management-A')
headers = prepare_headers(version, https)
params = dict(response_type=RT_FULL,
content_bindings=[CB_STIX_XML_111, CUSTOM_CONTENT_BINDING])
# Subscribing
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_SUBSCRIBE,
version=version,
params=params)
response = service.process(headers, request)
assert isinstance(response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.status == SS_ACTIVE
assert (server.persistence.get_subscription(
subs.subscription_id).status == SS_ACTIVE)
# Pausing
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_PAUSE,
subscription_id=subs.subscription_id,
version=version)
response = service.process(headers, request)
assert isinstance(response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
assert subs.status == SS_PAUSED
assert (server.persistence.get_subscription(
subs.subscription_id).status == SS_PAUSED)
# Resume
request = prepare_request(collection=COLLECTION_OPEN,
action=ACT_RESUME,
subscription_id=subs.subscription_id,
version=version)
response = service.process(headers, request)
assert isinstance(response,
as_tm(version).ManageCollectionSubscriptionResponse)
assert response.collection_name == COLLECTION_OPEN
assert len(response.subscription_instances) == 1
subs = response.subscription_instances[0]
assert subs.subscription_id
assert subs.status == SS_ACTIVE
assert (server.persistence.get_subscription(
subs.subscription_id).status == SS_ACTIVE)
def test_1_valid_creds(self):
"""Attempt to login with correct credentials."""
res = make_request(prepare_request(
self.api_url, {'username': '******', 'password': '******'}))
self.assertEqual(res.code, 200)
