def generate_domain():
domain = create_token()
update_token = create_token()
domain = Domain(domain,
'00:00:00:00:00:00',
'some-device',
'Some Device',
update_token=update_token)
return domain
def test_domain_update_server_side_client_ip(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
response = self.app.post('/domain/update', data=json.dumps(update_data), environ_base={'REMOTE_ADDR': '127.0.0.1'})
self.assertEqual(200, response.status_code)
expected_data = {
'ip': '127.0.0.1',
'user_domain': user_domain,
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
self.check_domain(update_token, expected_data)
def test_new(self):
email, password = self.create_active_user()
user_domain = create_token()
acquire_data = dict(
user_domain=user_domain,
device_mac_address='00:00:00:00:00:00',
device_name='my-super-board',
device_title='My Super Board',
email=email,
password=password)
response = self.app.post('/domain/acquire', data=acquire_data)
self.assertEqual(200, response.status_code)
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
self.assertIsNotNone(update_token)
expected_data = {
'ip': None,
'user_domain': user_domain,
'device_mac_address': '00:00:00:00:00:00',
'device_name': 'my-super-board',
'device_title': 'My Super Board'
}
self.check_domain(update_token, expected_data)
def test(self):
update_token = create_token()
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain,
self.main_domain)
original_ip = self.query_dns(full_domain_name, 'A')
domain = Domain(self.user_domain, '00:00:00:00:00:00', 'some-device',
'Some Device', update_token)
domain.ip = '192.168.0.1'
self.dns.update_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain,
self.main_domain)
self.validate_dns('192.168.0.1', full_domain_name)
domain.ip = '192.168.0.2'
self.dns.update_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain,
self.main_domain)
self.validate_dns('192.168.0.2', full_domain_name)
self.dns.delete_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain,
self.main_domain)
self.validate_dns(original_ip.address, full_domain_name)
def test_simple(self):
email, password = self.create_active_user()
user_domain = create_token()
acquire_data = dict(
user_domain=user_domain,
device_mac_address='00:00:00:00:00:00',
device_name='my-super-board',
device_title='My Super Board',
email=email,
password=password)
response = self.app.post('/domain/acquire', data=acquire_data)
self.assertEqual(200, response.status_code)
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
drop_data = {
'email': email,
'password': password,
'user_domain': user_domain
}
response = self.app.post('/domain/drop_device', data=drop_data)
self.assertEqual(200, response.status_code)
response = self.app.get('/domain/get', query_string={'token': update_token})
self.assertEqual(400, response.status_code)
def test_domain_update_date(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80
}
self.app.post('/domain/update', data=json.dumps(update_data))
domain = self.get_domain(update_token)
last_updated1 = domain['last_update']
time.sleep(1)
self.app.post('/domain/update', data=json.dumps(update_data))
domain = self.get_domain(update_token)
last_updated2 = domain['last_update']
self.assertGreater(last_updated2, last_updated1)
def test_local_ip_changed(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'local_ip': '192.168.1.5',
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
update_data = {
'token': update_token,
'ip': '127.0.0.2',
'local_ip': '192.168.1.6',
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
self.check_domain(update_token, {'ip': '127.0.0.2', 'local_ip': '192.168.1.6', 'user_domain': user_domain})
def test_user_delete(self):
email, password = self.create_active_user()
user_domain_1 = create_token()
update_token_1 = self.acquire_domain(email, password, user_domain_1)
user_domain_2 = create_token()
update_token_2 = self.acquire_domain(email, password, user_domain_2)
response = self.app.post('/user/delete', data={'email': email, 'password': password})
self.assertEquals(200, response.status_code)
response = self.app.get('/domain/get', query_string={'token': update_token_1})
self.assertEqual(400, response.status_code)
response = self.app.get('/domain/get', query_string={'token': update_token_2})
self.assertEqual(400, response.status_code)
def create_active_user(self):
self.smtp.clear()
email = create_token()+'@mail.com'
password = '******'
self.app.post('/user/create', data={'email': email, 'password': password})
activate_token = self.get_token(self.smtp.emails()[0])
self.app.get('/user/activate', query_string={'token': activate_token})
self.smtp.clear()
return email, password
def test_user_activate_success(self):
user_domain = create_token()
email = user_domain+'@mail.com'
self.app.post('/user/create', data={'email': email, 'password': '******'})
self.assertFalse(self.smtp.empty())
token = self.get_token(self.smtp.emails()[0])
activate_response = self.app.get('/user/activate', query_string={'token': token})
self.assertEqual(200, activate_response.status_code)
def test_acquire_new(self):
email, password = self.create_active_user()
user_domain = create_token()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=email, password=password))
self.assertEqual(200, response.status_code)
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
self.assertIsNotNone(update_token)
self.check_domain(update_token, {'ip': None, 'user_domain': user_domain, 'services': []})
def test_simple(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
delete_data = {'user_domain': user_domain, 'email': email, 'password': password}
response = self.app.post('/domain/delete', data=json.dumps(delete_data))
self.assertEqual(200, response.status_code)
user_data = self.get_user(email, password)
self.assertEquals(0, len(user_data['domains']))
def test_domain_update_missing_port(self):
email, password = self.create_active_user()
user_domain = create_token()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=email, password=password))
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
service_data = {'name': 'ownCloud', 'type': '_http._tcp', 'url': None}
update_data = {'token': update_token, 'ip': '127.0.0.1', 'services': [service_data]}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(400, response.status_code)
def test_acquire_existing(self):
user_domain = create_token()
other_email, other_password = self.create_active_user()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=other_email, password=other_password))
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
email, password = self.create_active_user()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=email, password=password))
self.assertEqual(409, response.status_code)
self.check_domain(update_token, {'ip': None, 'user_domain': user_domain, 'services': []})
def test_wrong_mac_address_format(self):
email, password = self.create_active_user()
user_domain = create_token()
acquire_data = {
'user_domain': user_domain,
'device_mac_address': 'wrong_format',
'device_name': 'my-super-board',
'device_title': 'My Super Board',
'email': email,
'password': password
}
response = self.app.post('/domain/acquire', data=acquire_data)
self.assertEqual(400, response.status_code)
def test_domain_update_two_new_services(self):
email, password = self.create_active_user()
user_domain = create_token()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=email, password=password))
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
services_data = [{'name': 'ownCloud', 'protocol': 'http', 'type': '_http._tcp', 'port': 10001, 'url': None},
{'name': 'SSH', 'protocol': 'https', 'type': '_http._tcp', 'port': 10002, 'url': None}]
update_data = {'token': update_token, 'ip': '127.0.0.1', 'services': services_data}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
self.check_domain(update_token, {'ip': '127.0.0.1', 'user_domain': user_domain, 'services': services_data})
def test_get_user_data(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'web_protocol': 'http',
'web_local_port': 80,
'web_port': 10000
}
self.app.post('/domain/update', data=json.dumps(update_data))
response = self.app.get('/user/get', query_string={'email': email, 'password': password})
response_data = json.loads(response.data)
user_data = response_data['data']
# This is hack. We do not know last_update value - it is set by server.
last_update = user_data["domains"][0]["last_update"]
update_token = user_data["update_token"]
expected = {
'active': True,
'email': email,
'unsubscribed': False,
'update_token': update_token,
'domains': [{
'user_domain': user_domain,
'web_local_port': 80,
'web_port': 10000,
'web_protocol': 'http',
'ip': '127.0.0.1',
'local_ip': None,
'map_local_address': False,
'platform_version': None,
'device_mac_address': '00:00:00:00:00:00',
'device_name': 'some-device',
'device_title': 'Some Device',
'last_update': last_update
}]
}
self.assertEquals(expected, user_data)
def test_domain_update_platform_version(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'platform_version': '366',
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
self.check_domain(update_token, {'platform_version': '366'})
def test(self):
update_token = create_token()
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain, self.main_domain)
original_ip = self.query_dns(full_domain_name, 'A')
domain = Domain(self.user_domain, '00:00:00:00:00:00', 'some-device', 'Some Device', update_token)
domain.ip = '192.168.0.1'
self.dns.update_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain, self.main_domain)
self.validate_dns('192.168.0.1', full_domain_name)
domain.ip = '192.168.0.2'
self.dns.update_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain, self.main_domain)
self.validate_dns('192.168.0.2', full_domain_name)
self.dns.delete_domain(self.main_domain, domain)
full_domain_name = 'name1.{0}.{1}'.format(self.user_domain, self.main_domain)
self.validate_dns(original_ip.address, full_domain_name)
def test_domain_update_map_local_address(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '108.108.108.108',
'local_ip': '192.168.1.2',
'map_local_address': True,
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
self.check_domain(update_token, {'ip': '108.108.108.108', 'local_ip': '192.168.1.2', 'map_local_address': True, 'user_domain': user_domain})
def test_domain_update_date(self):
email, password = self.create_active_user()
user_domain = create_token()
response = self.app.post('/domain/acquire', data=dict(user_domain=user_domain, email=email, password=password))
domain_data = json.loads(response.data)
update_token = domain_data['update_token']
update_data = {'token': update_token, 'ip': '127.0.0.1', 'services': []}
self.app.post('/domain/update', data=json.dumps(update_data))
domain = self.get_domain(update_token)
last_updated1 = domain['last_update']
time.sleep(1)
self.app.post('/domain/update', data=json.dumps(update_data))
domain = self.get_domain(update_token)
last_updated2 = domain['last_update']
self.assertGreater(last_updated2, last_updated1)
def test_domain_update_web_updated(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'web_protocol': 'http',
'web_port': 10001,
'web_local_port': 80,
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
update_data = {
'token': update_token,
'ip': '127.0.0.1',
'web_protocol': 'https',
'web_port': 10002,
'web_local_port': 443,
}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(200, response.status_code)
expected_data = {
'ip': '127.0.0.1',
'user_domain': user_domain,
'web_protocol': 'https',
'web_port': 10002,
'web_local_port': 443,
}
self.check_domain(update_token, expected_data)
def test_get_user_data(self):
email, password = self.create_active_user()
user_domain = create_token()
update_token = self.acquire_domain(email, password, user_domain)
service_data = {'name': 'ownCloud', 'protocol': 'http', 'type': '_http._tcp', 'port': 10000, 'url': None}
update_data = {'token': update_token, 'ip': '127.0.0.1', 'services': [service_data]}
self.app.post('/domain/update', data=json.dumps(update_data))
response = self.app.get('/user/get', query_string={'email': email, 'password': password})
response_data = json.loads(response.data)
user_data = response_data['data']
# This is hack. We do not know last_update value - it is set by server.
last_update = user_data["domains"][0]["last_update"]
expected = {
"active": True,
"email": email,
"domains": [{
"user_domain": user_domain,
"ip": "127.0.0.1",
"last_update": last_update,
"services": [{
"name": "ownCloud",
"protocol": "http",
"port": 10000,
"type": "_http._tcp",
"url": None
}],
}]
}
self.assertEquals(expected, user_data)
def test_length(self):
token = create_token()
self.assertIsNotNone(token)
self.assertTrue(len(token) > 10)
def test_domain_update_wrong_token(self):
service_data = {'name': 'ownCloud', 'type': '_http._tcp', 'port': 10000, 'url': None}
update_data = {'token': create_token(), 'ip': '127.0.0.1', 'services': [service_data]}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(400, response.status_code)
def test_user_create_special_symbols_in_password(self):
user_domain = create_token()
email = user_domain+'@mail.com'
response = self.app.post('/user/create', data={'email': email, 'password': r'pass12& ^%"'})
self.assertEqual(200, response.status_code)
self.assertFalse(self.smtp.empty())
def test_user_create_success(self):
user_domain = create_token()
email = user_domain+'@mail.com'
response = self.app.post('/user/create', data={'email': email, 'password': '******'})
self.assertEqual(200, response.status_code)
self.assertFalse(self.smtp.empty())
def generate_user():
email = unicode(create_token() + '@mail.com')
user = User(email, hash('pass1234'), False)
user.enable_action(ActionType.ACTIVATE)
return user
def test_length(self):
token = create_token()
self.assertIsNotNone(token)
self.assertTrue(len(token) > 10)
def test_different_every_time(self):
token1 = create_token()
token2 = create_token()
self.assertNotEquals(token1, token2)
def test_domain_update_wrong_token(self):
update_data = {'token': create_token(), 'ip': '127.0.0.1'}
response = self.app.post('/domain/update', data=json.dumps(update_data))
self.assertEqual(400, response.status_code)
def generate_domain():
domain = create_token()
update_token = create_token()
domain = Domain(domain, '00:00:00:00:00:00', 'some-device', 'Some Device', update_token=update_token)
return domain
def generate_user():
email = unicode(create_token() + '@mail.com')
user = User(email, hash('pass1234'), False)
user.enable_action(ActionType.ACTIVATE)
return user
def generate_domain():
domain = create_token()
update_token = create_token()
domain = Domain(domain, None, update_token)
return domain
def test_different_every_time(self):
token1 = create_token()
token2 = create_token()
self.assertNotEquals(token1, token2)
